Merge branch 'master' into staging-next

.github/workflows/manual-rendering.yml

···
       - name: Compare DocBook and MD manuals
         id: check
         run: |
+          export NIX_PATH=nixpkgs=$(pwd)
           .github/workflows/compare-manuals.sh \
             docbook/share/doc/nixos/options.html \
             md/share/doc/nixos/options.html

nixos/modules/services/databases/influxdb.nix

···
     };
   } cfg.extraConfig;
 
-  configFile = pkgs.runCommandLocal "config.toml" {
-    nativeBuildInputs = [ pkgs.remarshal ];
-  } ''
-    remarshal -if json -of toml \
+  configFile = pkgs.runCommandLocal "config.toml" { } ''
+    ${pkgs.buildPackages.remarshal}/bin/remarshal -if json -of toml \
       < ${pkgs.writeText "config.json" (builtins.toJSON configOptions)} \
       > $out
   '';

nixos/modules/system/boot/luksroot.nix

···
            + optionalString dev.bypassWorkqueues " --perf-no_read_workqueue --perf-no_write_workqueue"
            + optionalString (dev.header != null) " --header=${dev.header}";
     cschange = "cryptsetup luksChangeKey ${dev.device} ${optionalString (dev.header != null) "--header=${dev.header}"}";
+    fido2luksCredentials = dev.fido2.credentials ++ optional (dev.fido2.credential != null) dev.fido2.credential;
   in ''
     # Wait for luksRoot (and optionally keyFile and/or header) to appear, e.g.
     # if on a USB drive.
···
     }
     ''}
 
-    ${optionalString (luks.fido2Support && (dev.fido2.credential != null)) ''
+    ${optionalString (luks.fido2Support && fido2luksCredentials != []) ''
 
     open_with_hardware() {
       local passsphrase
···
           echo "Please move your mouse to create needed randomness."
         ''}
           echo "Waiting for your FIDO2 device..."
-          fido2luks open${optionalString dev.allowDiscards " --allow-discards"} ${dev.device} ${dev.name} ${dev.fido2.credential} --await-dev ${toString dev.fido2.gracePeriod} --salt string:$passphrase
+          fido2luks open${optionalString dev.allowDiscards " --allow-discards"} ${dev.device} ${dev.name} "${builtins.concatStringsSep "," fido2luksCredentials}" --await-dev ${toString dev.fido2.gracePeriod} --salt string:$passphrase
         if [ $? -ne 0 ]; then
           echo "No FIDO2 key found, falling back to normal open procedure"
           open_normally
···
     # commands to run right before we mount our device
     ${dev.preOpenCommands}
 
-    ${if (luks.yubikeySupport && (dev.yubikey != null)) || (luks.gpgSupport && (dev.gpgCard != null)) || (luks.fido2Support && (dev.fido2.credential != null)) then ''
+    ${if (luks.yubikeySupport && (dev.yubikey != null)) || (luks.gpgSupport && (dev.gpgCard != null)) || (luks.fido2Support && fido2luksCredentials != []) then ''
     open_with_hardware
     '' else ''
     open_normally
···
               example = "f1d00200d8dc783f7fb1e10ace8da27f8312d72692abfca2f7e4960a73f48e82e1f7571f6ebfcee9fb434f9886ccc8fcc52a6614d8d2";
               type = types.nullOr types.str;
               description = lib.mdDoc "The FIDO2 credential ID.";
+            };
+
+            credentials = mkOption {
+              default = [];
+              example = [ "f1d00200d8dc783f7fb1e10ace8da27f8312d72692abfca2f7e4960a73f48e82e1f7571f6ebfcee9fb434f9886ccc8fcc52a6614d8d2" ];
+              type = types.listOf types.str;
+              description = lib.mdDoc ''
+                List of FIDO2 credential IDs.
+
+                Use this if you have multiple FIDO2 keys you want to use for the same luks device.
+              '';
             };
 
             gracePeriod = mkOption {

pkgs/applications/emulators/pcsx2/default.nix

···
 stdenv.mkDerivation rec {
   pname = "pcsx2";
   version = "1.7.3165";
+  # nixpkgs-update: no auto update
 
   src = fetchFromGitHub {
     owner = "PCSX2";

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "3c1ad4d78a1d5fc29c5e169f5ba9f82bc580d2f0",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/3c1ad4d78a1d5fc29c5e169f5ba9f82bc580d2f0.tar.gz",
-  "sha256": "0cd24ibv0i2zq0vvawafm0hqjgv70flmna84g320h5jy3lc0qrv4",
-  "msg": "Update from Hackage at 2022-08-20T06:29:36Z"
+  "commit": "0fd2081c5296d9891054f8c742545d3871d76485",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/0fd2081c5296d9891054f8c742545d3871d76485.tar.gz",
+  "sha256": "1bxxlks9bjf9lmshlg8777j6h7gb5mpd9lxj97nkqh32gnlj8m38",
+  "msg": "Update from Hackage at 2022-08-28T23:15:42Z"
 }

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

···
       name = "git-annex-${super.git-annex.version}-src";
       url = "git://git-annex.branchable.com/";
       rev = "refs/tags/" + super.git-annex.version;
-      sha256 = "0p9qd7yasdji5kwxn4d0hrv9hnxbzfsczknldh8jav3ynhg8k6c9";
+      sha256 = "19n60rx4mpr52551mvm0i5kgy32099rvgnihvmh5np09n2f81c2r";
       # 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
···
     testHaskellDepends = drv.testHaskellDepends or [] ++ [ self.hspec-meta_2_9_3 ];
     testToolDepends = drv.testToolDepends or [] ++ [ pkgs.git ];
   }) (super.sensei.override {
-    hspec = self.hspec_2_10_0_1;
+    hspec = self.hspec_2_10_1;
     hspec-wai = super.hspec-wai.override {
-      hspec = self.hspec_2_10_0_1;
+      hspec = self.hspec_2_10_1;
     };
   });
 
···
 
   # The test suite depends on an impure cabal-install installation in
   # $HOME, which we don't have in our build sandbox.
-  cabal-install-parsers = dontCheck (super.cabal-install-parsers.override {
-    Cabal = self.Cabal_3_6_3_0;
-  });
+  # 2022-08-31: Jailbreak is done to allow aeson 2.0.*:
+  # https://github.com/haskell-CI/haskell-ci/commit/6ad0d5d701cbe101013335d597acaf5feadd3ab9#r82681900
+  cabal-install-parsers = doJailbreak (dontCheck (super.cabal-install-parsers.override {
+    Cabal-syntax = self.Cabal-syntax_3_8_1_0;
+  }));
+  cabal-install-parsers_0_4_5 = doDistribute (
+    dontCheck (
+      super.cabal-install-parsers_0_4_5.override {
+        Cabal = self.Cabal_3_6_3_0;
+      }
+    )
+  );
 
   # 2022-03-12: Pick patches from master for compat with Stackage Nightly
   gitit = appendPatches [
···
   servant-openapi3 = dontCheck super.servant-openapi3;
 
   # Give hspec 2.10.* correct dependency versions without overrideScope
-  hspec_2_10_0_1 = doDistribute (super.hspec_2_10_0_1.override {
-    hspec-discover = self.hspec-discover_2_10_0_1;
-    hspec-core = self.hspec-core_2_10_0_1;
+  hspec_2_10_1 = doDistribute (super.hspec_2_10_1.override {
+    hspec-discover = self.hspec-discover_2_10_1;
+    hspec-core = self.hspec-core_2_10_1;
   });
-  hspec-discover_2_10_0_1 = super.hspec-discover_2_10_0_1.override {
+  hspec-discover_2_10_1 = super.hspec-discover_2_10_1.override {
     hspec-meta = self.hspec-meta_2_9_3;
   };
-  hspec-core_2_10_0_1 = super.hspec-core_2_10_0_1.override {
+  hspec-core_2_10_1 = super.hspec-core_2_10_1.override {
     hspec-meta = self.hspec-meta_2_9_3;
   };
 
···
   haskell-ci = super.haskell-ci.overrideScope (self: super: {
     Cabal = self.Cabal_3_6_3_0;
     ShellCheck = self.ShellCheck_0_7_2;
+    cabal-install-parsers = self.cabal-install-parsers_0_4_5;
   });
-
-  # Build haskell-ci from git repository
-  haskell-ci-unstable = overrideSrc rec {
-    version = "0.14.1-${builtins.substring 0 7 src.rev}";
-    src = pkgs.fetchFromGitHub {
-      owner = "haskell-CI";
-      repo = "haskell-ci";
-      rev = "8311a999b8e8be3aa31f65f314def256aa2d5535";
-      sha256 = "169jaqm4xs2almmvqsk567wayxs0g6kn0l5877c03hzr3d9ykrav";
-    };
-  } self.haskell-ci;
 
   large-hashable = lib.pipe (super.large-hashable.override {
     # https://github.com/factisresearch/large-hashable/commit/5ec9d2c7233fc4445303564047c992b693e1155c
···
 
   # Fixes https://github.com/NixOS/nixpkgs/issues/140613
   # https://github.com/recursion-schemes/recursion-schemes/issues/128
-  recursion-schemes = appendPatch ./patches/recursion-schemes-128.patch super.recursion-schemes;
+  recursion-schemes = overrideCabal (drv: {
+    patches = drv.patches or [] ++ [
+      ./patches/recursion-schemes-128.patch
+    ];
+    # make sure line endings don't break the patch
+    prePatch = drv.prePatch or "" + ''
+      "${pkgs.buildPackages.dos2unix}/bin/dos2unix" *.cabal
+    '';
+  }) super.recursion-schemes;
+
+  # 2022-08-30 Too strict bounds on finite-typelits
+  # https://github.com/jumper149/blucontrol/issues/1
+  blucontrol = doJailbreak super.blucontrol;
 
   # Fix from https://github.com/brendanhay/gogol/pull/144 which has seen no release
   # Can't use fetchpatch as it required tweaking the line endings as the .cabal
···
     testTarget = "regex-tdfa-unittest";
   } super.regex-tdfa;
 
+  # 2022-09-01:
+  # Restrictive upper bound on base.
+  # Remove once version 1.* is released
+  monad-bayes = doJailbreak super.monad-bayes;
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super // (let
   # We need to build purescript with these dependencies and thus also its reverse
   # dependencies to avoid version mismatches in their dependency closure.

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

···
   time-compat = doJailbreak super.time-compat;
   http-media = unmarkBroken (doJailbreak super.http-media);
   servant-server = unmarkBroken (doJailbreak super.servant-server);
-  foundation = dontCheck super.foundation;
+  basement = doDistribute self.basement_0_0_14;
+  foundation = doDistribute (dontCheck self.foundation_0_0_28);
   vault = dontHaddock super.vault;
 
   # https://github.com/snapframework/snap-core/issues/288

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

···
   constraints = doJailbreak super.constraints;
   cpphs = overrideCabal (drv: { postPatch = "sed -i -e 's,time >=1.5 && <1.11,time >=1.5 \\&\\& <1.12,' cpphs.cabal";}) super.cpphs;
   data-fix = doJailbreak super.data-fix;
-  dbus = self.dbus_1_2_25;
+  dbus = self.dbus_1_2_26;
   dec = doJailbreak super.dec;
   ed25519 = doJailbreak super.ed25519;
   ghc-byteorder = doJailbreak super.ghc-byteorder;
···
   retrie = doDistribute (dontCheck self.retrie_1_2_0_1);
   singleton-bool = doJailbreak super.singleton-bool;
   servant = doJailbreak super.servant;
+  servant-swagger = doJailbreak super.servant-swagger;
+
+  # 2022-09-02: Too strict bounds on lens
+  # https://github.com/haskell-servant/servant/pull/1607/files
+  servant-docs = doJailbreak super.servant-docs;
+  servant-foreign = doJailbreak super.servant-foreign;
   servant-auth = doJailbreak super.servant-auth;
-  servant-swagger = doJailbreak super.servant-swagger;
+  servant-auth-docs = doJailbreak super.servant-auth-docs;
+  servant-auth-server = doJailbreak super.servant-auth-server;
   servant-auth-swagger = doJailbreak super.servant-auth-swagger;
+  # 2022-09-02: Too strict bounds on lens
+  # https://github.com/haskell-servant/servant-multipart/pull/64
+  servant-multipart = doJailbreak super.servant-multipart;
+  # 2022-09-02: Too strict bounds on lens
+  # https://github.com/GetShopTV/swagger2/pull/242
+  swagger2 = doJailbreak super.swagger2;
+
   shelly = doJailbreak super.shelly;
   splitmix = doJailbreak super.splitmix;
   tasty-hspec = doJailbreak super.tasty-hspec;
-  th-desugar = self.th-desugar_1_13_1;
+  th-desugar = self.th-desugar_1_14;
   time-compat = doJailbreak super.time-compat;
   tomland = doJailbreak super.tomland;
   type-equality = doJailbreak super.type-equality;

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

···
   - aeson-bson
   - aeson-decode
   - aeson-default
+  - aeson-dependent-sum
   - aeson-deriving
   - aeson-diff-generic
   - aeson-filthy
···
   - djinn-th
   - dmcc
   - dmenu
+  - dns-patterns
   - dnsrbl
   - dnssd
   - dobutok
···
   - etcd
   - ethereum-rlp
   - eurofxref
-  - evdev
   - eve
   - eved
   - event
···
   - heterogeneous-list-literals
   - hetris
   - heukarya
-  - hevm
   - HExcel
   - hexchat
   - hexif
···
   - hsns
   - hsntp
   - hs-openmoji-data
+  - hs-opentelemetry-instrumentation-hspec
   - hsoptions
   - hsoz
   - hsparql
···
   - kd-tree
   - keccak
   - keera-hails-reactivevalues
-  - keid-render-basic
   - keid-ui-dearimgui
   - keiretsu
   - kempe
···
   - monadacme
   - monad-atom
   - monad-atom-simple
-  - monad-bayes
   - monad-branch
   - MonadCatchIO-transformers
   - monad-choice
···
   - proxy-mapping
   - psc-ide
   - pseudo-trie
+  - psx
   - PTQ
   - publicsuffix
   - publicsuffixlistcreate
···
   - text-ascii
   - text-builder-linear
   - text-containers
+  - text-display
   - text-format-heavy
   - text-generic-pretty
   - text-icu-normalized
···
   - tracetree
   - tracked-files
   - tracker
+  - trackit
   - traction
   - tracy
   - traildb

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

···
   - weeder == 2.2.*                     # 2022-02-21: preserve for GHC 8.10.7
   - weeder == 2.3.*                     # 2022-05-31: preserve for GHC 9.0.2
   - brick == 0.70.*                     # 2022-08-13: needed by matterhorn-50200.17.0
+  - basement < 0.0.15                   # 2022-08-30: last version to support GHC < 8.10
+  - foundation < 0.0.29                 # 2022-08-30: last version to support GHC < 8.10
+  - cabal-install-parsers < 0.5         # 2022-08-31: required by haskell-ci 0.14.3
 
 package-maintainers:
   abbradar:
···
   dx9base:                                      [ platforms.windows ]
   dx9d3d:                                       [ platforms.windows ]
   dx9d3dx:                                      [ platforms.windows ]
+  evdev:                                        [ platforms.linux ]
+  evdev-streamly:                               [ platforms.linux ]
   geomancy:                                     [ platforms.x86 ] # x86 intrinsics
   gi-gtkosxapplication:                         [ platforms.darwin ]
   gtk-mac-integration:                          [ platforms.darwin ]

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

···
-# Stackage LTS 19.19
+# Stackage LTS 19.20
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - active ==0.2.0.15
   - ad ==4.5.2
   - ad-delcont ==0.3.0.0
-  - adjunctions ==4.4.1
+  - adjunctions ==4.4.2
   - adler32 ==0.1.2.0
   - advent-of-code-api ==0.2.8.1
-  - aern2-mp ==0.2.9.1
-  - aern2-real ==0.2.9.1
+  - aern2-mp ==0.2.10.0
+  - aern2-real ==0.2.10.0
   - aeson ==2.0.3.0
   - aeson-attoparsec ==0.0.0
   - aeson-better-errors ==0.9.1.1
···
   - base64-string ==0.2
   - base-compat ==0.11.2
   - base-compat-batteries ==0.11.2
-  - basement ==0.0.14
+  - basement ==0.0.15
   - base-orphans ==0.8.7
   - base-prelude ==1.6.1
   - base-unicode-symbols ==0.2.4.2
···
   - charset ==0.3.9
   - charsetdetect-ae ==1.1.0.4
   - Chart ==1.9.4
-  - ChasingBottoms ==1.3.1.11
+  - ChasingBottoms ==1.3.1.12
   - cheapskate ==0.1.1.2
   - cheapskate-highlight ==0.1.0.0
   - cheapskate-lucid ==0.1.0.0
···
   - convertible ==1.1.1.1
   - cookie ==0.4.5
   - copr-api ==0.1.0
-  - core-data ==0.3.4.0
+  - core-data ==0.3.6.0
   - core-program ==0.4.6.4
   - core-text ==0.3.8.0
   - countable ==1.0
···
   - doctest-exitcode-stdio ==0.0
   - doctest-extract ==0.1
   - doctest-lib ==0.1
-  - doctest-parallel ==0.2.4
+  - doctest-parallel ==0.2.5
   - doldol ==0.4.1.2
   - do-list ==1.0.1
   - domain ==0.1.1.3
···
   - drifter-sqlite ==0.1.0.0
   - dsp ==0.2.5.1
   - dual ==0.1.1.1
-  - dual-tree ==0.2.3.0
+  - dual-tree ==0.2.3.1
   - dublincore-xml-conduit ==0.1.0.2
   - dunai ==0.8.3
   - duration ==0.2.0.0
···
   - errors ==2.3.0
   - errors-ext ==0.4.2
   - ersatz ==0.4.12
-  - esqueleto ==3.5.6.1
+  - esqueleto ==3.5.7.0
   - essence-of-live-coding ==0.2.6
   - essence-of-live-coding-gloss ==0.2.6
   - essence-of-live-coding-pulse ==0.2.6
···
   - fakedata-quickcheck ==0.2.0
   - fakefs ==0.3.0.2
   - fakepull ==0.3.0.2
-  - faktory ==1.1.2.2
+  - faktory ==1.1.2.3
   - fast-builder ==0.1.3.0
   - fast-logger ==3.1.1
   - fast-math ==1.0.2
···
   - fin ==0.2.1
   - FindBin ==0.0.5
   - fingertree ==0.1.5.0
-  - finite-typelits ==0.1.4.2
+  - finite-typelits ==0.1.6.0
   - first-class-families ==0.8.0.1
   - first-class-patterns ==0.3.2.5
   - fitspec ==0.4.10
···
   - format-numbers ==0.1.0.1
   - formatting ==7.1.3
   - fortran-src ==0.9.0
-  - foundation ==0.0.28
+  - foundation ==0.0.29
   - fourmolu ==0.4.0.0
   - Frames ==0.7.3
   - free ==5.1.9
···
   - graph-core ==0.3.0.0
   - graphite ==0.10.0.1
   - graphs ==0.7.2
-  - graphula ==2.0.1.1
+  - graphula ==2.0.2.1
   - graphviz ==2999.20.1.0
   - graph-wrapper ==0.2.6.0
   - gravatar ==0.8.1
···
   - hslua-core ==2.1.0
   - hslua-marshalling ==2.1.0
   - hslua-module-doclayout ==1.0.4
-  - hslua-module-path ==1.0.2
+  - hslua-module-path ==1.0.3
   - hslua-module-system ==1.0.2
   - hslua-module-text ==1.0.2
   - hslua-module-version ==1.0.2
···
   - io-memoize ==1.1.1.0
   - io-region ==0.1.1
   - io-storage ==0.3
-  - io-streams ==1.5.2.1
+  - io-streams ==1.5.2.2
   - ip6addr ==1.0.3
   - iproute ==1.7.12
   - IPv6Addr ==2.0.5
···
   - markdown ==0.1.17.5
   - markdown-unlit ==0.5.1
   - markov-chain ==0.0.3.4
-  - massiv ==1.0.1.1
+  - massiv ==1.0.2.0
   - massiv-io ==1.0.0.1
   - massiv-persist ==1.0.0.3
   - massiv-serialise ==1.0.0.2
···
   - nano-erl ==0.1.0.1
   - NanoID ==3.2.1
   - nanospec ==0.2.2
-  - nanovg ==0.8.0.0
+  - nanovg ==0.8.1.0
   - nats ==1.1.2
   - natural-arithmetic ==0.1.3.0
   - natural-induction ==0.2.0.0
···
   - pulse-simple ==0.1.14
   - pureMD5 ==2.1.4
   - purescript-bridge ==0.14.0.0
-  - pusher-http-haskell ==2.1.0.10
+  - pusher-http-haskell ==2.1.0.11
   - pvar ==1.0.0.0
   - PyF ==0.10.2.0
   - qchas ==1.1.0.1
···
   - Stream ==0.4.7.2
   - streaming ==0.2.3.1
   - streaming-attoparsec ==1.0.0.1
-  - streaming-bytestring ==0.2.2
+  - streaming-bytestring ==0.2.3
   - streaming-cassava ==0.2.0.0
   - streaming-commons ==0.2.2.4
   - streamly ==0.8.1.1
···
   - type-spec ==0.4.0.0
   - typography-geometry ==1.0.1.0
   - tz ==0.1.3.6
-  - tzdata ==0.2.20220810.0
+  - tzdata ==0.2.20220815.0
   - ua-parser ==0.7.7.0
   - uglymemo ==0.1.0.1
   - unagi-chan ==0.4.1.4
···
   - yesod-auth ==1.6.11
   - yesod-auth-basic ==0.1.0.3
   - yesod-auth-hashdb ==1.7.1.7
-  - yesod-auth-oauth2 ==0.7.0.1
+  - yesod-auth-oauth2 ==0.7.0.2
   - yesod-bin ==1.6.2.1
   - yesod-core ==1.6.24.0
   - yesod-eventsource ==1.6.0.1

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

···
  - ethereum-client-haskell
  - ethereum-merkle-patricia-db
  - euphoria
- - evdev-streamly
  - eve-cli
  - event-monad
  - eventful-dynamodb
···
  - hsx-jmacro
  - hsx-xhtml
  - html-kure
+ - html-parse-util
  - htoml-parse
  - hts
  - htsn-import

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

···
     '';
   }) super.haskell-language-server;
 
+  # NOTE: this patch updates the hevm code to work with the latest packages that broke the build
+  # it's temporary until hevm version 0.50.0 is released - https://github.com/ethereum/hevm/milestone/1
   # tests depend on a specific version of solc
-  hevm = dontCheck (doJailbreak super.hevm);
+  hevm = dontCheck (appendPatch ./patches/hevm-update-deps.patch super.hevm);
 
   # hadolint enables static linking by default in the cabal file, so we have to explicitly disable it.
   # https://github.com/hadolint/hadolint/commit/e1305042c62d52c2af4d77cdce5d62f6a0a3ce7b
···
     '';
   }) super.jacinda;
 
+  # Smoke test can't be executed in sandbox
+  # https://github.com/georgefst/evdev/issues/25
+  evdev = overrideCabal (drv: {
+    testFlags = drv.testFlags or [] ++ [
+      "-p" "!/Smoke/"
+    ];
+  }) super.evdev;
+
   # Tests assume dist-newstyle build directory is present
   cabal-hoogle = dontCheck super.cabal-hoogle;
 
···
     hydraPlatforms = pkgs.lib.platforms.all;
     broken = false;
   }) super.cabal-install;
+
+  keid-render-basic = addBuildTool pkgs.glslang super.keid-render-basic;
 
 # haskell-language-server plugins all use the same test harness so we give them what we want in this loop.
 } // pkgs.lib.mapAttrs

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

···
      }:
      mkDerivation {
        pname = "BlogLiterately";
-       version = "0.8.8";
-       sha256 = "1g374dxdvs2mg9y5aq07qkff4srd53rhanav2fdz1g73ssbdjyhl";
+       version = "0.8.8.1";
+       sha256 = "1jj3daw8vr11v4dlvdkd7gddkpiy484mpk8dl9zgns2wnq5ibrkj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ChasingBottoms";
-       version = "1.3.1.11";
-       sha256 = "162lykrhhnj7i3l0kfzk2jwgjkdrqwamvxwf8g3hr042rqr1qywp";
-       libraryHaskellDepends = [
-         base containers mtl QuickCheck random syb
-       ];
-       testHaskellDepends = [
-         array base containers mtl QuickCheck random syb
-       ];
-       description = "For testing partial and infinite values";
-       license = lib.licenses.mit;
-     }) {};
-
-  "ChasingBottoms_1_3_1_12" = callPackage
-    ({ mkDerivation, array, base, containers, mtl, QuickCheck, random
-     , syb
-     }:
-     mkDerivation {
-       pname = "ChasingBottoms";
        version = "1.3.1.12";
        sha256 = "1vy9yq07p95qiap1pcp2bbbn1mqvp3spyrswpdz0qfcn06656650";
        libraryHaskellDepends = [
···
        ];
        description = "For testing partial and infinite values";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "CheatSheet" = callPackage
···
        pname = "JuicyPixels-scale-dct";
        version = "0.1.2";
        sha256 = "04rhrmjnh12hh2nz04k245avgdcwqfyjnsbpcrz8j9328j41nf7p";
-       revision = "8";
-       editedCabalFile = "08ym2s8ypmqs2viz4jr9zm54cia8b54li2zqi8dq93vjnzz0kkbf";
+       revision = "9";
+       editedCabalFile = "130s6r1p7v0dhfk9q0kb5qlapccap3mbkjzn2y59r00n011rs6bi";
        libraryHaskellDepends = [
          base base-compat carray fft JuicyPixels
        ];
···
        pname = "PSQueue";
        version = "1.1.1";
        sha256 = "02pgqzwxndi8cwa5fw668gfsh7z3lzbygkgcsf56bwrxwqjyz4bi";
+       revision = "1";
+       editedCabalFile = "02a5g59sc9jh3v4pibhjpijv8lsbiydznrpqyin7qhwsyc0p813a";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck ];
        description = "Priority Search Queue";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "active_0_2_0_16" = callPackage
+    ({ mkDerivation, base, lens, linear, QuickCheck, semigroupoids
+     , semigroups, vector
+     }:
+     mkDerivation {
+       pname = "active";
+       version = "0.2.0.16";
+       sha256 = "1fz2rsyk41p9f9avlmn9lrdmii5alv88lkw677mw8q6mzyxpw67i";
+       libraryHaskellDepends = [
+         base lens linear semigroupoids semigroups vector
+       ];
+       testHaskellDepends = [
+         base lens linear QuickCheck semigroupoids semigroups vector
+       ];
+       description = "Abstractions for animation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "activehs" = callPackage
     ({ mkDerivation, activehs-base, array, base, blaze-html
      , blaze-markup, bytestring, cmdargs, containers, data-pprint
···
      }:
      mkDerivation {
        pname = "adjunctions";
-       version = "4.4.1";
-       sha256 = "0hqm86v5in7xp31wv3wvr1h7gsim96fpl0si0xrpv8060qalzwww";
-       libraryHaskellDepends = [
-         array base comonad containers contravariant distributive free mtl
-         profunctors semigroupoids semigroups tagged transformers
-         transformers-compat void
-       ];
-       testHaskellDepends = [ base distributive generic-deriving hspec ];
-       testToolDepends = [ hspec-discover ];
-       description = "Adjunctions and representable functors";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "adjunctions_4_4_2" = callPackage
-    ({ mkDerivation, array, base, comonad, containers, contravariant
-     , distributive, free, generic-deriving, hspec, hspec-discover, mtl
-     , profunctors, semigroupoids, semigroups, tagged, transformers
-     , transformers-compat, void
-     }:
-     mkDerivation {
-       pname = "adjunctions";
        version = "4.4.2";
        sha256 = "06354xzgf78jl4g1xw11rp74gi7zh94rgvsji7ma1g0hp26myyql";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Adjunctions and representable functors";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "adler32" = callPackage
···
      }:
      mkDerivation {
        pname = "aern2-mp";
-       version = "0.2.9.1";
-       sha256 = "0fygbfrww0qjjjfj21crkv5najrnk57qizfh8q43s4z1szad9lk1";
+       version = "0.2.10.0";
+       sha256 = "1rrgij6wa0479pa2qr2fqylqlymg1xxsblrdp0ahmabdaazbdqd7";
        libraryHaskellDepends = [
          base cdar-mBound collect-errors deepseq hspec integer-logarithms
          mixed-types-num QuickCheck reflection regex-tdfa template-haskell
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "aern2-mp_0_2_10_0" = callPackage
+  "aern2-mp_0_2_11_0" = callPackage
     ({ mkDerivation, base, cdar-mBound, collect-errors, deepseq, hspec
      , integer-logarithms, mixed-types-num, QuickCheck, reflection
      , regex-tdfa, template-haskell
      }:
      mkDerivation {
        pname = "aern2-mp";
-       version = "0.2.10.0";
-       sha256 = "1rrgij6wa0479pa2qr2fqylqlymg1xxsblrdp0ahmabdaazbdqd7";
+       version = "0.2.11.0";
+       sha256 = "17syak48rqqlssk4gsxdfl21sidfypfwsyfmxsakahflcvl9jgpy";
        libraryHaskellDepends = [
          base cdar-mBound collect-errors deepseq hspec integer-logarithms
          mixed-types-num QuickCheck reflection regex-tdfa template-haskell
···
      }:
      mkDerivation {
        pname = "aern2-real";
-       version = "0.2.9.1";
-       sha256 = "09h1x62jz30spfbshriznb9nczxiigd6nhs8n2xgnsjbdrspy45q";
+       version = "0.2.10.0";
+       sha256 = "08hfk0q6jmrjmkr9bj488lxjr7prkhc48ghfrk33flwk59zfgh3i";
        libraryHaskellDepends = [
          aern2-mp base collect-errors hspec integer-logarithms
          mixed-types-num QuickCheck
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "aern2-real_0_2_10_0" = callPackage
+  "aern2-real_0_2_11_0" = callPackage
     ({ mkDerivation, aern2-mp, base, collect-errors, hspec
      , integer-logarithms, mixed-types-num, QuickCheck
      }:
      mkDerivation {
        pname = "aern2-real";
-       version = "0.2.10.0";
-       sha256 = "08hfk0q6jmrjmkr9bj488lxjr7prkhc48ghfrk33flwk59zfgh3i";
+       version = "0.2.11.0";
+       sha256 = "094hs147jzlg3zqary2zbpi7n18vykj0f7cw89k125zrs2h0f0v2";
        libraryHaskellDepends = [
          aern2-mp base collect-errors hspec integer-logarithms
          mixed-types-num QuickCheck
···
        pname = "aeson-compat";
        version = "0.3.10";
        sha256 = "0ia3qfdpbrzhwwg4ywpdwca0z1m85k081pcz6jh1sx8qjsvcr71w";
-       revision = "3";
-       editedCabalFile = "0a4mvv7j18a4wiv6sssb6v4z2xn3kbrfw34842nq0hbygxqn05ri";
+       revision = "4";
+       editedCabalFile = "001w7pck3q5k4cnx53npllil5cblkg1ssqza4s9v347dfih3zmss";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-iso8601 base base-compat bytestring
          containers exceptions hashable scientific tagged text time
···
        broken = true;
      }) {};
 
+  "aeson-dependent-sum" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, constraints-extras
+     , dependent-sum, dependent-sum-template, hedgehog, some, tasty
+     , tasty-discover, tasty-hedgehog, tasty-hunit, vector
+     }:
+     mkDerivation {
+       pname = "aeson-dependent-sum";
+       version = "0.1.0.1";
+       sha256 = "1ahgvs93i4lkyli7x0xiqm0fg5gyd1zbk9xzwrdishaxs1w0aw3k";
+       libraryHaskellDepends = [
+         aeson base constraints-extras dependent-sum some vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring constraints-extras dependent-sum
+         dependent-sum-template hedgehog tasty tasty-hedgehog tasty-hunit
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "JSON encoding/decoding for dependent-sum";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "aeson-deriving" = callPackage
     ({ mkDerivation, aeson, base, hedgehog, regex-tdfa, text
      , unordered-containers
···
        pname = "aeson-extra";
        version = "0.5.1.1";
        sha256 = "1fzri1h2wica3grnp8ag8izakqmsb2lh0nld7xnpxk0p766wg9r7";
+       revision = "1";
+       editedCabalFile = "1bw3qsk0ndw0d72qz3jgb2r7z5mvaxdjl1n9s2qhrx0jz2vapn0q";
        libraryHaskellDepends = [
          aeson attoparsec base base-compat-batteries bytestring deepseq
          recursion-schemes scientific semialign template-haskell text these
···
        license = lib.licenses.mit;
      }) {};
 
-  "aeson-optics_1_2" = callPackage
+  "aeson-optics_1_2_0_1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, optics-core
-     , optics-extra, scientific, text, text-short, unordered-containers
-     , vector
+     , optics-extra, scientific, text, text-short, vector
      }:
      mkDerivation {
        pname = "aeson-optics";
-       version = "1.2";
-       sha256 = "0p852w0ns9mkmydbhj1p3szvkw7pl83c0xaqhvn5jwdrpqj6ma74";
-       revision = "1";
-       editedCabalFile = "0d8f0sx4qqiqws70b1gm6ks4gw5hwl0qjh7mdjzr1yf3r4zyk5hq";
+       version = "1.2.0.1";
+       sha256 = "0b7frw4fm5hn611i8ldbnkq1h47vjw4fn6f85sj38fw2cn4n826j";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring optics-core optics-extra
-         scientific text text-short unordered-containers vector
+         scientific text text-short vector
        ];
        description = "Law-abiding optics for aeson";
        license = lib.licenses.mit;
···
      }) {};
 
   "algebraic-graphs-io" = callPackage
-    ({ mkDerivation, algebraic-graphs, attoparsec, base, binary
+    ({ mkDerivation, aeson, algebraic-graphs, attoparsec, base, binary
      , binary-conduit, bytestring, conduit, conduit-extra, containers
-     , csv-conduit, directory, dot, exceptions, filepath, hspec
-     , http-conduit, matrix-market-attoparsec, megaparsec, mtl
-     , parser-combinators, primitive, QuickCheck, tar-conduit, text
-     , transformers, vector
+     , csv-conduit, directory, exceptions, filepath, hspec, http-conduit
+     , megaparsec, mtl, parser-combinators, primitive, serialise
+     , tar-conduit, text, transformers, vector
      }:
      mkDerivation {
        pname = "algebraic-graphs-io";
-       version = "0.4";
-       sha256 = "03a31y4kxswn9h32vs7nh83cvwjmx714rckj8pvqxl4l7i01y6wf";
-       revision = "1";
-       editedCabalFile = "060m82d4qirv7anyp3n6wh5rsycipr5cimhl1y8p9mcm5573r2pl";
+       version = "0.5.0.1";
+       sha256 = "07vi8b928kjbrmd2p6mv808bh8vwb08wcsnz125v7wm4mc8lv24c";
        libraryHaskellDepends = [
-         algebraic-graphs attoparsec base binary binary-conduit bytestring
-         conduit conduit-extra containers csv-conduit directory dot
-         exceptions filepath http-conduit matrix-market-attoparsec
-         megaparsec mtl parser-combinators primitive tar-conduit text
-         transformers vector
+         aeson algebraic-graphs attoparsec base binary binary-conduit
+         bytestring conduit conduit-extra containers csv-conduit directory
+         exceptions filepath http-conduit megaparsec mtl parser-combinators
+         primitive serialise tar-conduit text transformers vector
        ];
-       testHaskellDepends = [ base hspec QuickCheck ];
+       testHaskellDepends = [
+         aeson algebraic-graphs base hspec serialise
+       ];
        description = "I/O utilities and datasets for algebraic-graphs";
        license = lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "argo";
-       version = "0.2022.2.27";
-       sha256 = "0jbxkkgia4jj49kyc7zg97w397cfdfk194bx8s6cikyaigw0yg0a";
+       version = "0.2022.8.28";
+       sha256 = "0hiqj4by1pqx13rqnmkwncnv37lkgx4s5dlnyn1f4mqmw5x54s4k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
+  "atrophy" = callPackage
+    ({ mkDerivation, base, contiguous, deepseq, HUnit, QuickCheck
+     , quickcheck-classes, random, tasty, tasty-bench, tasty-hunit
+     , tasty-quickcheck, wide-word
+     }:
+     mkDerivation {
+       pname = "atrophy";
+       version = "0.1.0.0";
+       sha256 = "13jdrbnmg2nvgl5c35kdikgdacw7c8kxdwq111mdi9x8bsd3j23q";
+       libraryHaskellDepends = [ base contiguous wide-word ];
+       testHaskellDepends = [
+         base contiguous HUnit QuickCheck quickcheck-classes tasty
+         tasty-hunit tasty-quickcheck wide-word
+       ];
+       benchmarkHaskellDepends = [
+         base deepseq random tasty tasty-bench
+       ];
+       description = "Faster integer division and modulus operations";
+       license = lib.licenses.mit;
+     }) {};
+
   "ats-format" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, Cabal, cli-setup, directory
      , filepath, language-ats, optparse-applicative, process, text
···
        executableHaskellDepends = [ base Cabal directory filepath ];
        description = "Automatically re-export modules";
        license = lib.licenses.mit;
+       mainProgram = "autoexporter";
+     }) {};
+
+  "autoexporter_2_0_0_2" = callPackage
+    ({ mkDerivation, base, Cabal, directory, filepath }:
+     mkDerivation {
+       pname = "autoexporter";
+       version = "2.0.0.2";
+       sha256 = "1058lfjxlcbnd2p7lfjvhbzsgl0wss24c6frw7qzl2sg2kd5bppi";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base Cabal directory filepath ];
+       executableHaskellDepends = [ base Cabal directory filepath ];
+       description = "Automatically re-export modules";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "autoexporter";
      }) {};
 
···
        license = lib.licenses.mit;
      }) {};
 
-  "basement" = callPackage
+  "basement_0_0_14" = callPackage
     ({ mkDerivation, base, ghc-prim }:
      mkDerivation {
        pname = "basement";
···
        libraryHaskellDepends = [ base ghc-prim ];
        description = "Foundation scrap box of array & string";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "basement_0_0_15" = callPackage
+  "basement" = callPackage
     ({ mkDerivation, base, ghc-prim }:
      mkDerivation {
        pname = "basement";
···
        libraryHaskellDepends = [ base ghc-prim ];
        description = "Foundation scrap box of array & string";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "basement-cd" = callPackage
···
      }:
      mkDerivation {
        pname = "bearriver";
-       version = "0.13.5";
-       sha256 = "08r6i7xs7n9054m80svqbyjgy6c5diypxswwjkc3gxrcn1s0fqkv";
+       version = "0.13.6";
+       sha256 = "07ga08r2wwwd2n7jq2bc93jaiqymn4kih2mjb43273zz29kxds99";
        libraryHaskellDepends = [
          base dunai MonadRandom mtl simple-affine-space transformers
        ];
···
        pname = "bin";
        version = "0.1.2";
        sha256 = "0idm2ix4wv1ppr3fjvd8xdlbkhk6lq4rvfs9dv615lmds4gbzm72";
+       revision = "1";
+       editedCabalFile = "052i9qfb037p71fhzl38ly51jkk9q6klb1cb07a0cv2ja5nzrjgn";
        libraryHaskellDepends = [
          base boring dec deepseq fin hashable QuickCheck some
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "binary-instances_1_0_3" = callPackage
+    ({ mkDerivation, aeson, base, binary, binary-orphans, bytestring
+     , case-insensitive, hashable, primitive, QuickCheck
+     , quickcheck-instances, scientific, tagged, tasty, tasty-quickcheck
+     , text, text-binary, time-compat, unordered-containers, vector
+     , vector-binary-instances
+     }:
+     mkDerivation {
+       pname = "binary-instances";
+       version = "1.0.3";
+       sha256 = "00wwdk744x762p39jkg0azswxj0qy1lxjw8h9z2c0cvfam934987";
+       libraryHaskellDepends = [
+         aeson base binary binary-orphans case-insensitive hashable
+         primitive scientific tagged text text-binary time-compat
+         unordered-containers vector vector-binary-instances
+       ];
+       testHaskellDepends = [
+         aeson base binary bytestring case-insensitive hashable primitive
+         QuickCheck quickcheck-instances scientific tagged tasty
+         tasty-quickcheck text time-compat unordered-containers vector
+       ];
+       description = "Orphan instances for binary";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "binary-io" = callPackage
     ({ mkDerivation, async, base, binary, bytestring, concurrency
      , deque, exceptions, hspec, process, stm, transformers
···
        pname = "binary-tagged";
        version = "0.3.1";
        sha256 = "01d1wb8h5mz76l09r2azphvhm1y3nar8pqrh2waxn797bd2dh6fp";
-       revision = "1";
-       editedCabalFile = "08s4ryp28j0vg94rfp9gnlb8mfyfcnrqnvq59k88l7hh1s4af0r5";
+       revision = "2";
+       editedCabalFile = "0w0n299j37w4xyf69wlfs1s06m01y6yyh9r5clacrr5m893rxy9a";
        libraryHaskellDepends = [
          array base base16-bytestring binary bytestring containers
          structured tagged
···
      }:
      mkDerivation {
        pname = "binrep";
-       version = "0.2.0";
-       sha256 = "151vvxs4h6x24j437qma62z3n82yhvl754321zlyjj815icrax5a";
+       version = "0.3.0";
+       sha256 = "1mx4bjgn3jjflnr4cxyqljvh0k7yd7pla422xpawpkr5q1z8rq5m";
        libraryHaskellDepends = [
          aeson base bytestring either flatparse mason megaparsec refined
          strongweak text text-icu vector vector-sized
···
      }:
      mkDerivation {
        pname = "bloodhound";
-       version = "0.20.0.2";
-       sha256 = "1dvs0gbh7wn9bp99b64vdf2as7zr4bcvxrjzpmlkak4vb4g4bqfz";
+       version = "0.21.0.0";
+       sha256 = "01znn7g5vnhdharl8cl2symffqinbz9syanpnim3ijx7015nasf1";
        libraryHaskellDepends = [
          aeson base blaze-builder bytestring containers exceptions hashable
          http-client http-types mtl network-uri scientific semigroups semver
···
        pname = "boring";
        version = "0.2";
        sha256 = "0d2cm9ra69cvaxs5x3lr2rfv7xx6xrbpb3dbcpyd8m77cqxm7b0b";
-       revision = "1";
-       editedCabalFile = "116sbp55pp6b4z9c1iyxaafxwd3mzra5ha2g65sfdla28rabwxj0";
+       revision = "2";
+       editedCabalFile = "04pn94i3mysi7px93k86sf29vw99sf38sl4n0gy2nma0iqsik828";
        libraryHaskellDepends = [ base tagged transformers ];
        description = "Boring and Absurd types";
        license = lib.licenses.bsd3;
···
        pname = "bound-extras";
        version = "0.0.2";
        sha256 = "1mrsr75yd55p3rgqqjlhs0f498qgbmj12ldadj4frmkhjqf3vf9y";
+       revision = "1";
+       editedCabalFile = "07mqf5ycbjj31q1d8b2szzb96nigfhn9iv1h153ks8cgjh5ir8qj";
        libraryHaskellDepends = [
          base bound deepseq hashable transformers
        ];
···
        pname = "boundingboxes";
        version = "0.2.3";
        sha256 = "0r3mffqxqadn8qklq3kr0ggirkficfj8ic1fxgki2zrc5jm4f2g8";
+       revision = "1";
+       editedCabalFile = "0qz1bnci5bhb8zqc2dw19sa0k9i57fyhhdh78s3yllp3aijdc3n6";
        libraryHaskellDepends = [ base lens ];
        description = "A generic boundingbox for an arbitrary vector";
        license = lib.licenses.bsd3;
···
        mainProgram = "breakout";
      }) {};
 
+  "breakpoint" = callPackage
+    ({ mkDerivation, base, containers, ghc, haskeline, mtl, tasty
+     , tasty-hunit, transformers
+     }:
+     mkDerivation {
+       pname = "breakpoint";
+       version = "0.1.0.0";
+       sha256 = "11b2wbm8fm1zwz81hx1l3c559ad7y50d0838n94lkm1vsa39hpk7";
+       libraryHaskellDepends = [
+         base containers ghc haskeline mtl transformers
+       ];
+       testHaskellDepends = [ base containers tasty tasty-hunit ];
+       description = "Set breakpoints using a GHC plugin";
+       license = lib.licenses.mit;
+     }) {};
+
   "breve" = callPackage
     ({ mkDerivation, aeson, base, binary, blaze-html, bytestring
      , configurator, cryptohash, directory, hashtables, http-api-data
···
        pname = "broadcast-chan";
        version = "0.2.1.2";
        sha256 = "1zsrafz3q9l8np8wafmrbi8ilwwsgnzkc8jfjkjfgs4kq65yglqw";
+       revision = "1";
+       editedCabalFile = "1989dc49db8cf3ca24x4hs3nirm74xl9p0dqf8kpj1dr64y6dvzj";
        libraryHaskellDepends = [ base transformers unliftio-core ];
        benchmarkHaskellDepends = [ async base criterion deepseq stm ];
        description = "Closable, fair, single-wakeup channel type that avoids 0 reader space leaks";
···
        pname = "broadcast-chan-conduit";
        version = "0.2.1.2";
        sha256 = "0mwd82arm50zwz559qzxi70ia9d4h5kjwdvhk09jf966hd0knnmm";
+       revision = "1";
+       editedCabalFile = "0p0xp5jd5mjgapym482178z2b0vs61w93dxza37n3gqgd28n79is";
        libraryHaskellDepends = [
          base broadcast-chan conduit resourcet transformers unliftio-core
        ];
···
        pname = "broadcast-chan-pipes";
        version = "0.2.1.1";
        sha256 = "06nghcddlcnc97p3464fsgcfvjlsnxv7i7khzws3g3myl8hrd89c";
+       revision = "1";
+       editedCabalFile = "1cigswvq3jvsvk155mszyvjvrhlng7yjf8gnvdw2hw089dzsva95";
        libraryHaskellDepends = [ base broadcast-chan pipes pipes-safe ];
        testHaskellDepends = [
          base broadcast-chan-tests containers foldl pipes pipes-safe
···
        pname = "broadcast-chan-tests";
        version = "0.2.1.2";
        sha256 = "08qjvhdx2pwgj5kcl5fmg5qdlzbdchxjihmqch4sgv48kcga06nv";
-       revision = "2";
-       editedCabalFile = "0cd1sfjkf158z5g0xk2r5mcawmzay04q8hyhcbara4lfx6gwx3h9";
+       revision = "3";
+       editedCabalFile = "0z8ldbdgwzacl6pimn8784yvqnl6na8ffzbh76icdic59frwc2sz";
        libraryHaskellDepends = [
          async base broadcast-chan clock containers optparse-applicative
          paramtree stm tagged tasty tasty-golden tasty-hunit tasty-travis
···
        license = lib.licenses.mit;
      }) {};
 
+  "burrito_2_0_1_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hspec, parsec
+     , QuickCheck, template-haskell, text, transformers
+     }:
+     mkDerivation {
+       pname = "burrito";
+       version = "2.0.1.2";
+       sha256 = "1awfxllw4n1zg58q08ml25k0f3mvbrlsws17m40hwp3ddvv8nyfd";
+       libraryHaskellDepends = [
+         base bytestring containers parsec template-haskell text
+         transformers
+       ];
+       testHaskellDepends = [
+         base bytestring containers hspec parsec QuickCheck template-haskell
+         text transformers
+       ];
+       description = "Parse and render URI templates";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "burst-detection" = callPackage
     ({ mkDerivation, base, criterion, deepseq }:
      mkDerivation {
···
        pname = "bytes";
        version = "0.17.2";
        sha256 = "06kqqk19qjhrwdqi6pyd1lwqfnj2sw3b3s49lc5vr2fmv8gg8mdw";
+       revision = "1";
+       editedCabalFile = "0frs6ag93kmg2fw3vd686czx8g7h9qmdn1ip6wdk96d94ap0fz9i";
        libraryHaskellDepends = [
          base binary binary-orphans bytestring cereal containers hashable
          mtl scientific text time transformers transformers-compat
···
        ];
        description = "Efficiently parse and produce common integral and fractional numbers";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "bytestring-lexing_0_5_0_9" = callPackage
+    ({ mkDerivation, base, bytestring, tasty, tasty-quickcheck
+     , tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "bytestring-lexing";
+       version = "0.5.0.9";
+       sha256 = "14nx7sfs75g57mlfiwgzm5sc3wm4va58zryjp27m5lmfdp30873c";
+       libraryHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [
+         base bytestring tasty tasty-quickcheck tasty-smallcheck
+       ];
+       description = "Efficiently parse and produce common integral and fractional numbers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bytestring-mmap" = callPackage
···
        broken = true;
      }) {};
 
-  "cabal-install-parsers" = callPackage
+  "cabal-install-parsers_0_4_5" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, base16-bytestring
      , binary, binary-instances, bytestring, Cabal, containers
      , criterion, cryptohash-sha256, deepseq, directory, filepath, lukko
···
        ];
        description = "Utilities to work with cabal-install files";
        license = "GPL-2.0-or-later AND BSD-3-Clause";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "cabal-install-parsers" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, base16-bytestring
+     , binary, binary-instances, bytestring, Cabal-syntax, containers
+     , criterion, cryptohash-sha256, deepseq, directory, filepath, lukko
+     , network-uri, parsec, pretty, tar, tasty, tasty-golden
+     , tasty-hunit, text, time, transformers, tree-diff
+     }:
+     mkDerivation {
+       pname = "cabal-install-parsers";
+       version = "0.5";
+       sha256 = "017q4cagx3w0ww9bpilji9hiscilmg78m10ggi9ih0997hjp4l50";
+       libraryHaskellDepends = [
+         aeson base base16-bytestring binary binary-instances bytestring
+         Cabal-syntax containers cryptohash-sha256 deepseq directory
+         filepath lukko network-uri parsec pretty tar text time transformers
+       ];
+       testHaskellDepends = [
+         ansi-terminal base base16-bytestring bytestring Cabal-syntax
+         containers directory filepath pretty tar tasty tasty-golden
+         tasty-hunit tree-diff
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring Cabal-syntax containers criterion directory
+         filepath
+       ];
+       description = "Utilities to work with cabal-install files";
+       license = "GPL-2.0-or-later AND BSD-3-Clause";
      }) {};
 
   "cabal-install-solver" = callPackage
···
        mainProgram = "cabal-plan";
      }) {};
 
+  "cabal-plan_0_7_2_2" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, async, base, base-compat
+     , base16-bytestring, bytestring, containers, directory, filepath
+     , mtl, optics-core, optparse-applicative, parsec, process
+     , semialign, singleton-bool, text, these, topograph, transformers
+     , vector
+     }:
+     mkDerivation {
+       pname = "cabal-plan";
+       version = "0.7.2.2";
+       sha256 = "0ld2hgyyx64ns9cfxp1blb3azkv951qrcpx878hdvx2cdllgyy31";
+       configureFlags = [ "-fexe" ];
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base base16-bytestring bytestring containers directory
+         filepath text
+       ];
+       executableHaskellDepends = [
+         ansi-terminal async base base-compat bytestring containers
+         directory mtl optics-core optparse-applicative parsec process
+         semialign singleton-bool text these topograph transformers vector
+       ];
+       description = "Library and utility for processing cabal's plan.json file";
+       license = lib.licenses.gpl2Plus;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "cabal-plan";
+     }) {};
+
   "cabal-progdeps" = callPackage
     ({ mkDerivation, base, Cabal, directory, filepath }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "caerbannog";
-       version = "1.0.0.0";
-       sha256 = "1sfk4kh7jk762dqfp4c0hq9jqmp1r0x0727vp0cp48wsp9yn4d8f";
+       version = "1.0.0.2";
+       sha256 = "09rkj17p8c2j0zwkzhvjpajhga5h5q9y1vay2bmnplchx3r3sm8i";
        libraryHaskellDepends = [ base binary bytestring ];
        testHaskellDepends = [
          base binary bytestring hspec QuickCheck random
···
        broken = true;
      }) {};
 
-  "cayley-client_0_4_19_1" = callPackage
+  "cayley-client_0_4_19_2" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
      , exceptions, hspec, http-client, http-conduit, lens, lens-aeson
      , mtl, text, transformers, unordered-containers, vector
      }:
      mkDerivation {
        pname = "cayley-client";
-       version = "0.4.19.1";
-       sha256 = "195qkxxmzbfaynzni7bv99iv7ia2k0ijhkd260nfdaa3z98j4rkz";
+       version = "0.4.19.2";
+       sha256 = "0p8s4r4wgscqll2jd1k3plfq8v89jf344vq5bz5fg9r66kbryjxs";
        libraryHaskellDepends = [
          aeson attoparsec base binary bytestring exceptions http-client
          http-conduit lens lens-aeson mtl text transformers
···
        pname = "colors";
        version = "0.3.0.2";
        sha256 = "0gbdqn5wrh9711j5hs5ypbd3w7a3mh37g6aadqiq4m5n7jna6phm";
-       revision = "1";
-       editedCabalFile = "0q152j8ybnga46azvfg3xmsjk01lz4wkhlli07cd92803vc4d6dl";
+       revision = "2";
+       editedCabalFile = "1zhm6608y16haxvkf0rs3iihq1j8jg5kgfj9r6n65raymymd7rfj";
        libraryHaskellDepends = [ base lens linear profunctors ];
        description = "A type for colors";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "core-data";
-       version = "0.3.4.0";
-       sha256 = "07f90lhjv9vpnymidq6kyrnz6s2w3slvy2nwzjxvbia2p22nqmak";
-       revision = "1";
-       editedCabalFile = "1zc0y1f2mzycdnyd5f8dmkhnwc15bczhf2i82y45bjy4pg3890vg";
-       libraryHaskellDepends = [
-         aeson base bytestring containers core-text hashable hourglass
-         prettyprinter scientific text time unordered-containers uuid vector
-       ];
-       description = "Convenience wrappers around common data structures and encodings";
-       license = lib.licenses.mit;
-     }) {};
-
-  "core-data_0_3_6_0" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, containers, core-text
-     , hashable, hourglass, prettyprinter, scientific, text, time
-     , unordered-containers, uuid, vector
-     }:
-     mkDerivation {
-       pname = "core-data";
        version = "0.3.6.0";
        sha256 = "17x6dkrrps7cwh232fhmwn1r06xn28ghxysw26rba44lwshc9wga";
        libraryHaskellDepends = [
···
        ];
        description = "Convenience wrappers around common data structures and encodings";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "core-haskell" = callPackage
···
        pname = "crypt-sha512";
        version = "0";
        sha256 = "1wsma9frdrn39i506zydlzlk1ir6jh1pidqfjms8rwqjpx965gn2";
-       revision = "7";
-       editedCabalFile = "18i2irw9ghwic6yanl6iqqbqqvlwvm6hvvniqgb75hinxgyim0d4";
+       revision = "8";
+       editedCabalFile = "09fj4nghk80l8pqxjiddw0v8frwg46v5izkjsx2jvk1ksh6cif2b";
        libraryHaskellDepends = [
          attoparsec base bytestring cryptohash-sha512
        ];
···
        pname = "cue-sheet";
        version = "2.0.2";
        sha256 = "0n8a5m5qlz8dz03sphj9pybfjfkc0gngpmh56h6idj88frn1z947";
+       revision = "1";
+       editedCabalFile = "14w4r8y871fkvvak9lklncchlnq3cb6gy4qy1124g9hsnf75mgg4";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base bytestring containers exceptions megaparsec mtl QuickCheck
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "data-bword_0_1_0_2" = callPackage
+    ({ mkDerivation, base, ghc-prim, tasty, tasty-quickcheck }:
+     mkDerivation {
+       pname = "data-bword";
+       version = "0.1.0.2";
+       sha256 = "0dcngqc0igqs68lplqzfg5rl2nj1iy4555g7swsxd8n7svkq0j6n";
+       libraryHaskellDepends = [ base ghc-prim ];
+       testHaskellDepends = [ base tasty tasty-quickcheck ];
+       description = "Extra operations on binary words of fixed length";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "data-carousel" = callPackage
     ({ mkDerivation, base, containers, lens }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "dec_0_0_5" = callPackage
+    ({ mkDerivation, base, boring }:
+     mkDerivation {
+       pname = "dec";
+       version = "0.0.5";
+       sha256 = "126z70ij9hhy8pajw0d5fl0hrppy5sh22j8nkx46i0g6qz3l7071";
+       libraryHaskellDepends = [ base boring ];
+       description = "Decidable propositions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "decepticons" = callPackage
     ({ mkDerivation, base, comonad-transformers }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
+  "dejafu_2_4_0_4" = callPackage
+    ({ mkDerivation, base, concurrency, containers, contravariant
+     , deepseq, exceptions, leancheck, profunctors, random, transformers
+     }:
+     mkDerivation {
+       pname = "dejafu";
+       version = "2.4.0.4";
+       sha256 = "0nf89l7ps8wrm97skkn8nmi7wmmnr3dxmvjmhs69abnlahj7zjqh";
+       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 {
···
        testHaskellDepends = [ base HUnit ];
        description = "Parse and render JSON simply";
        license = lib.licenses.mit;
+       mainProgram = "derulo";
+     }) {};
+
+  "derulo_2_0_0_3" = callPackage
+    ({ mkDerivation, base, HUnit }:
+     mkDerivation {
+       pname = "derulo";
+       pname = "htaut";
+       sha256 = "0bs0bl66256i7ib82i70slf8s2pm091vbqk50pna2vrxs0a3mlkb";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base HUnit ];
+       description = "Parse and render JSON simply";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "derulo";
      }) {};
 
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "diagrams-core_1_5_0_1" = callPackage
+    ({ mkDerivation, adjunctions, base, containers, distributive
+     , dual-tree, lens, linear, monoid-extras, mtl, profunctors
+     , semigroups, unordered-containers
+     }:
+     mkDerivation {
+       pname = "diagrams-core";
+       version = "1.5.0.1";
+       sha256 = "1gv1p5hrxi3hks0nb4l38gdgfq9bh9d86b6dxcyzqxrwxbxk1khn";
+       libraryHaskellDepends = [
+         adjunctions base containers distributive dual-tree lens linear
+         monoid-extras mtl profunctors semigroups unordered-containers
+       ];
+       description = "Core libraries for diagrams EDSL";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "diagrams-graphviz" = callPackage
     ({ mkDerivation, base, containers, diagrams-lib, fgl, graphviz
      , split
···
        pname = "diagrams-lib";
        version = "1.4.5.1";
        sha256 = "1hkxp549i99s45qk8zmhjvz1xyyv3i0ffl8155bifkic6fd8y2gz";
-       revision = "2";
-       editedCabalFile = "12zif237fhf8r016225wsfkshwsxpqq0bm0h3k1ys5yjyk6m3x90";
+       revision = "3";
+       editedCabalFile = "1s8iyx86hd7p1h08nlmx8dj03fdzbwi417yw1qxc5ivd77ciqj61";
        libraryHaskellDepends = [
          active adjunctions array base bytestring cereal colour containers
          data-default-class diagrams-core diagrams-solve directory
···
   "discord-haskell" = callPackage
     ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring
      , containers, data-default, emoji, http-api-data, http-client
-     , iso8601-time, MonadRandom, mtl, req, safe-exceptions, scientific
-     , text, time, unliftio, websockets, wuss
+     , iso8601-time, MonadRandom, mtl, network, req, safe-exceptions
+     , scientific, text, time, unliftio, unordered-containers
+     , websockets, wuss
      }:
      mkDerivation {
        pname = "discord-haskell";
-       version = "1.14.0";
-       sha256 = "0dxzv2kl4njnq5m48d017ph1r8fir418ndzjahcing3b2hp2g1lp";
+       version = "1.15.1";
+       sha256 = "18md6zdvanmd29d6pn6v979c8iy4rsbzbrppjmz732fn5q9063f2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson async base base64-bytestring bytestring containers
          data-default emoji http-api-data http-client iso8601-time
-         MonadRandom mtl req safe-exceptions scientific text time unliftio
-         websockets wuss
+         MonadRandom mtl network req safe-exceptions scientific text time
+         unliftio unordered-containers websockets wuss
        ];
        executableHaskellDepends = [ base text unliftio ];
        description = "Write bots for Discord in Haskell";
···
      }) {};
 
   "ditto" = callPackage
-    ({ mkDerivation, base, containers, mtl, semigroups, text, torsor }:
+    ({ mkDerivation, base, containers, mtl, text }:
      mkDerivation {
        pname = "ditto";
-       version = "0.4";
-       sha256 = "0qnkv0r5dm73qlrsgwxwzm7f9gbknwcy1dzbjs6vlcmx8hyqh2gp";
-       libraryHaskellDepends = [
-         base containers mtl semigroups text torsor
-       ];
+       version = "0.4.1";
+       sha256 = "0wimz4zpiyll6wcbdhlwjbbjb0y6xy6lk0q1p0hpq5jmf1j2h4pb";
+       libraryHaskellDepends = [ base containers mtl text ];
        description = "ditto is a type-safe HTML form generation and validation library";
        license = lib.licenses.bsd3;
      }) {};
···
        pname = "dlist-nonempty";
        version = "0.1.1";
        sha256 = "0csbspdy43pzvasb5mhs5pz2f49ws78pi253cx7pp84wjx6ads20";
-       revision = "12";
-       editedCabalFile = "0b8lkcpzxjdwm13v7y35j2x3sy97rwzyjwdwzag1va4lvfwa1287";
+       revision = "13";
+       editedCabalFile = "1hbd0j8yw81y4rnxqxxnvhy33ccgl5c7qcr9shzqy97fwi2vkikm";
        libraryHaskellDepends = [
          base base-compat deepseq dlist semigroupoids
        ];
···
      }:
      mkDerivation {
        pname = "dns-patterns";
-       version = "0.1.3";
-       sha256 = "01373vx919s6xznifc0nv9dlwnqh8j0h57v0pdzmpfa5z7jyq7vf";
+       version = "0.2.1";
+       sha256 = "0vaxh178kndjryhchx6wryla5q8a9498vx7w39bb4va96f7gyby6";
        libraryHaskellDepends = [
          attoparsec base bytestring parser-combinators text
        ];
        testHaskellDepends = [ attoparsec base bytestring HUnit text ];
        description = "DNS name parsing and pattern matching utilities";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "dnscache" = callPackage
···
      }:
      mkDerivation {
        pname = "doctest-parallel";
-       version = "0.2.4";
-       sha256 = "0fzfhvam3j15vmh356svg6zlafbayaqmds8hki6jxrandj2d14kp";
-       libraryHaskellDepends = [
-         base base-compat Cabal code-page containers deepseq directory
-         exceptions extra filepath ghc ghc-paths Glob pretty process random
-         syb template-haskell transformers unordered-containers
-       ];
-       testHaskellDepends = [
-         base base-compat code-page containers deepseq directory exceptions
-         filepath ghc ghc-paths hspec hspec-core hspec-discover HUnit
-         mockery process QuickCheck setenv silently stringbuilder syb
-         transformers
-       ];
-       testToolDepends = [ hspec-discover ];
-       doHaddock = false;
-       description = "Test interactive Haskell examples";
-       license = lib.licenses.mit;
-     }) {};
-
-  "doctest-parallel_0_2_5" = callPackage
-    ({ mkDerivation, base, base-compat, Cabal, code-page, containers
-     , deepseq, directory, exceptions, extra, filepath, ghc, ghc-paths
-     , Glob, hspec, hspec-core, hspec-discover, HUnit, mockery, pretty
-     , process, QuickCheck, random, setenv, silently, stringbuilder, syb
-     , template-haskell, transformers, unordered-containers
-     }:
-     mkDerivation {
-       pname = "doctest-parallel";
        version = "0.2.5";
        sha256 = "075y4yllpgfq0dlfd6y9nqhsdkxzb9s3jgb0v194l216kg5zsqzc";
        libraryHaskellDepends = [
···
        doHaddock = false;
        description = "Test interactive Haskell examples";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "doctest-prop" = callPackage
···
      }) {};
 
   "dual-tree" = callPackage
-    ({ mkDerivation, base, monoid-extras, newtype-generics, QuickCheck
-     , semigroups, testing-feat
-     }:
-     mkDerivation {
-       pname = "dual-tree";
-       version = "0.2.3.0";
-       sha256 = "0qyn7kb42wvlcvb1wbf1qx3isc2y6k3hzp5iq6ab0r0llw9g6qlg";
-       revision = "2";
-       editedCabalFile = "0cv2pkq85d7wgk6jjcq8vpv3577iyd1x0sg5ivw9ixyf5v5qwjxy";
-       libraryHaskellDepends = [
-         base monoid-extras newtype-generics semigroups
-       ];
-       testHaskellDepends = [
-         base monoid-extras QuickCheck semigroups testing-feat
-       ];
-       description = "Rose trees with cached and accumulating monoidal annotations";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "dual-tree_0_2_3_1" = callPackage
     ({ mkDerivation, base, monoid-extras, QuickCheck, semigroups
      , testing-feat
      }:
···
        ];
        description = "Rose trees with cached and accumulating monoidal annotations";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "dualizer" = callPackage
···
        maintainers = [ lib.maintainers.turion ];
      }) {};
 
+  "dunai_0_9_0" = callPackage
+    ({ mkDerivation, base, MonadRandom, simple-affine-space, tasty
+     , tasty-hunit, transformers, transformers-base
+     }:
+     mkDerivation {
+       pname = "dunai";
+       version = "0.9.0";
+       sha256 = "0p93c1h5bggvabx4vvd95khmjrq4qh46rvxkm4cqcdfd0601lyy5";
+       libraryHaskellDepends = [
+         base MonadRandom simple-affine-space transformers transformers-base
+       ];
+       testHaskellDepends = [ base tasty tasty-hunit transformers ];
+       description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.turion ];
+     }) {};
+
   "dunai-core" = callPackage
     ({ mkDerivation, base, MonadRandom, transformers, transformers-base
      }:
···
     ({ mkDerivation, base, dunai, normaldistribution, QuickCheck }:
      mkDerivation {
        pname = "dunai-test";
-       version = "0.8.3";
-       sha256 = "07kirfcyzanscp0kdhgsg0pf809nwf6im0m104xrsrxkak1iqkh4";
+       version = "0.9.0";
+       sha256 = "0j007pd475fmxhnvvwh6z8awrxfcfgwmph1z412k332lrj46nhv7";
        libraryHaskellDepends = [
          base dunai normaldistribution QuickCheck
        ];
···
      }:
      mkDerivation {
        pname = "effectful";
-       version = "2.0.0.0";
-       sha256 = "1fhi7nfaxbazq01pgypf5mk6gd6k983jm3qbvwf6wi75xqx68rxy";
+       version = "2.1.0.0";
+       sha256 = "16vkxjmlwmyrvp3gdjma73jqlbmvbj9cawazg9h6fchxfr6ps53n";
        libraryHaskellDepends = [
          async base bytestring directory effectful-core process stm time
          unliftio
···
      }:
      mkDerivation {
        pname = "effectful-core";
-       version = "2.0.0.0";
-       sha256 = "15jg59843h0llv6v6s66nhz8q48ch1y5jibpxq4ki3w91nqaz13i";
+       version = "2.1.0.0";
+       sha256 = "1lgg8f66jrs206b4zvkplq7w8d8sd91mxj9333sr4v4dnnshp4lk";
        libraryHaskellDepends = [
          base containers exceptions monad-control primitive
          transformers-base unliftio-core
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "eliminators_0_9" = callPackage
+  "eliminators_0_9_1" = callPackage
     ({ mkDerivation, base, extra, hspec, hspec-discover, singleton-nats
-     , singletons-base, template-haskell, th-abstraction, th-desugar
+     , singletons-base, template-haskell, text, th-abstraction
+     , th-desugar
      }:
      mkDerivation {
        pname = "eliminators";
-       version = "0.9";
-       sha256 = "118bd51hfbh29yhs9ai3srk431avwsmccm1500mp21fbwxq8phsj";
+       version = "0.9.1";
+       sha256 = "0qw6fd6mskwyj1mzz6a6vdxh80jqxn0dzmwp1vq8py1cgnzrpfda";
        libraryHaskellDepends = [
-         base extra singleton-nats singletons-base template-haskell
+         base extra singleton-nats singletons-base template-haskell text
          th-abstraction th-desugar
        ];
        testHaskellDepends = [ base hspec singleton-nats singletons-base ];
···
      }:
      mkDerivation {
        pname = "ema";
-       version = "0.8.0.0";
-       sha256 = "03phqldw1dldmp4gp1wmlm8cyb5qkg1v62brvhwbc9cl1iasllk2";
+       version = "0.8.2.0";
+       sha256 = "158n1qizqncl4q4szk9jwjdnj1y0jsbpzyi4hjslk4zkvkkscwqa";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson async base blaze-html blaze-markup constraints-extras
···
      }:
      mkDerivation {
        pname = "email-validator";
-       version = "1.0.0";
-       sha256 = "0l8c87kv80y1cpifcg80zhmdi884n7409w22akvc7kb9vvyp3b4v";
-       revision = "1";
-       editedCabalFile = "08ncdqjmgxlzsxfj8z0xaj1p5nnx4ndj4490gvfhj50kv2wx47iw";
+       version = "1.0.1";
+       sha256 = "0nn1lrl1dv9zg9kvw46253jdb6cfzh5wn70n71pv85adc544001s";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
          pcre-light tasty tasty-hunit
        ];
        testHaskellDepends = [
-         base bytestring cmdargs dns doctest email-validate HUnit
-         parallel-io pcre-light tasty tasty-hunit
+         base bytestring doctest email-validate HUnit pcre-light tasty
+         tasty-hunit
        ];
        description = "Perform basic syntax and deliverability checks on email addresses";
        license = lib.licenses.agpl3Only;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "entropy_0_4_1_10" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, directory, filepath
+     , process, unix
+     }:
+     mkDerivation {
+       pname = "entropy";
+       version = "0.4.1.10";
+       sha256 = "1rbx4ydabrjs8kkdg9laznkh9nisiq6b5z93vnp9bh6iy59ivb45";
+       setupHaskellDepends = [ base Cabal directory filepath process ];
+       libraryHaskellDepends = [ base bytestring unix ];
+       description = "A platform independent entropy source";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "entwine" = callPackage
     ({ mkDerivation, async, base, clock, containers, criterion
      , directory, exceptions, monad-loops, process, QuickCheck
···
        maintainers = [ lib.maintainers.sternenseemann ];
      }) {};
 
+  "envy_2_1_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hspec, mtl
+     , QuickCheck, quickcheck-instances, text, time, transformers
+     }:
+     mkDerivation {
+       pname = "envy";
+       version = "2.1.1.0";
+       sha256 = "0cc4lxh4zyg388s794i4ydixi83mgzarjldssmccmss9gp90qcj6";
+       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
···
        pname = "equational-reasoning";
        version = "0.7.0.1";
        sha256 = "1xp5vmz19idc29xidr7q65hsnhfnl3ca80hxxfllsqpyyh32qlhn";
+       revision = "1";
+       editedCabalFile = "0bi5xmaq5cbs1jqz6naw4706wv5yjgx1g4vibp872iqzcjc86yka";
        libraryHaskellDepends = [
          base containers template-haskell th-desugar void
        ];
···
        pname = "ersatz-toysat";
        version = "0.2.2.0";
        sha256 = "056yyls1mhl20sbngk43lip9gi092c1da0snx6fcs0vbv8gm0j4v";
+       revision = "2";
+       editedCabalFile = "0ijzzn2bis2kgxf3cnnqkxrfh3n5pw5jp29548dac9ayfk8iwvvh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "esqueleto";
-       version = "3.5.6.1";
-       sha256 = "1cb8hnv3i75db46dgi2a960zq715py2jq9w3x31q8d3avfkgds2i";
+       version = "3.5.7.0";
+       sha256 = "1dqd1ni4rv70yrb71cbldrak22dgxgns3qnfhsnwbwp5mia9h1v1";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-html bytestring conduit containers
          monad-logger persistent resourcet tagged template-haskell text time
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "esqueleto_3_5_7_0" = callPackage
+  "esqueleto_3_5_8_0" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring
      , conduit, containers, exceptions, hspec, hspec-core, monad-logger
      , mtl, mysql, mysql-simple, persistent, persistent-mysql
···
      }:
      mkDerivation {
        pname = "esqueleto";
-       version = "3.5.7.0";
-       sha256 = "1dqd1ni4rv70yrb71cbldrak22dgxgns3qnfhsnwbwp5mia9h1v1";
+       version = "3.5.8.0";
+       sha256 = "06fdrmp57kqvyj4bl8a7f1xz4iyd1w5qldrkf3raq6in0l628m9y";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-html bytestring conduit containers
          monad-logger persistent resourcet tagged template-haskell text time
···
        ];
        description = "Bindings to libevdev";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       platforms = lib.platforms.linux;
      }) {inherit (pkgs) libevdev;};
 
   "evdev-streamly" = callPackage
···
        ];
        description = "Bridge for working with evdev and streamly";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
+       platforms = lib.platforms.linux;
      }) {};
 
   "eve" = callPackage
···
      }:
      mkDerivation {
        pname = "evoke";
-       version = "0.2022.5.19";
-       sha256 = "1kw4jklbr5pjd1rhwm6c89492w7rjc0mv335j5bis6nn53g7psna";
+       version = "0.2022.8.26";
+       sha256 = "05jyak1dmb4cw4gp5p71pv8imkfachylq8bak81jmg6ni2shp28j";
        libraryHaskellDepends = [ base ghc text ];
        testHaskellDepends = [
          aeson base HUnit insert-ordered-containers lens QuickCheck swagger2
···
      }:
      mkDerivation {
        pname = "exon";
-       version = "0.4.0.0";
-       sha256 = "17hzyfh4wcv5x1446qk448mdlcr63z50nkicf67k8618szf2sqdl";
+       version = "0.5.0.0";
+       sha256 = "0q55lxd85nkpml2x1c1i0dgh6z3c61cr07866zzlqn0mnm2wx8rv";
        libraryHaskellDepends = [
          base flatparse haskell-src-exts haskell-src-meta incipit-base
          template-haskell text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "extra_1_7_11" = callPackage
+    ({ mkDerivation, base, clock, directory, filepath, process
+     , QuickCheck, quickcheck-instances, time, unix
+     }:
+     mkDerivation {
+       pname = "extra";
+       version = "1.7.11";
+       sha256 = "0zskgc0y16y3fkfd5z0r0rh4z8jahfpywbs6xviqg09hx5y0bxjy";
+       libraryHaskellDepends = [
+         base clock directory filepath process time unix
+       ];
+       testHaskellDepends = [
+         base directory filepath QuickCheck quickcheck-instances unix
+       ];
+       description = "Extra functions I use";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "extract-dependencies" = callPackage
     ({ mkDerivation, async, base, Cabal, containers
      , package-description-remote
···
      }:
      mkDerivation {
        pname = "faktory";
-       version = "1.1.2.2";
-       sha256 = "0vkjd20wpzb170lisk1sb4508h56mgjbk4f5qbi6k8vvbdipiaqy";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson aeson-casing base bytestring connection cryptonite errors
-         megaparsec memory mtl network random safe-exceptions scanner
-         semigroups text time unix unordered-containers
-       ];
-       executableHaskellDepends = [ aeson base safe-exceptions ];
-       testHaskellDepends = [
-         aeson aeson-qq async base hspec markdown-unlit mtl time
-       ];
-       testToolDepends = [ markdown-unlit ];
-       description = "Faktory Worker for Haskell";
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "faktory_1_1_2_3" = callPackage
-    ({ mkDerivation, aeson, aeson-casing, aeson-qq, async, base
-     , bytestring, connection, cryptonite, errors, hspec, markdown-unlit
-     , megaparsec, memory, mtl, network, random, safe-exceptions
-     , scanner, semigroups, text, time, unix, unordered-containers
-     }:
-     mkDerivation {
-       pname = "faktory";
        version = "1.1.2.3";
        sha256 = "1mihcmz3wzw2f6vfwv7xkvzhiql1fbb5v2llpkx5y455z939xl37";
        isLibrary = true;
···
        pname = "fgl";
        version = "5.7.0.3";
        sha256 = "04k5grp5d381wkc7sxgcl0sd3z3nlm6l6mmh103vhzh6p49vhs99";
+       revision = "1";
+       editedCabalFile = "0d5b88j42a3f50b7kbksszvwvcgr59f8pcg3p6cvzq9f4n7y51s7";
        libraryHaskellDepends = [
          array base containers deepseq transformers
        ];
···
        testHaskellDepends = [ base bytestring ];
        description = "Use Template Haskell to embed (LZMA compressed) data";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "file-embed-lzma_0_0_1" = callPackage
+    ({ mkDerivation, base, bytestring, directory, filepath, lzma
+     , template-haskell, text, transformers
+     }:
+     mkDerivation {
+       pname = "file-embed-lzma";
+       version = "0.0.1";
+       sha256 = "19l1gdjhsn4zh96mzbjsa5rn0acwrx1w3jy25cm23xv6jl8z28i9";
+       libraryHaskellDepends = [
+         base bytestring directory filepath lzma template-haskell text
+         transformers
+       ];
+       testHaskellDepends = [ base bytestring ];
+       description = "Use Template Haskell to embed (LZMA compressed) data";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "file-embed-poly" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "filepattern_0_1_3" = callPackage
+    ({ mkDerivation, base, directory, extra, filepath, QuickCheck }:
+     mkDerivation {
+       pname = "filepattern";
+       version = "0.1.3";
+       sha256 = "0dlnwnwhsfdkwm69z66wj5d2x9n3la55glq4fsn5rxm2kr1msi6c";
+       libraryHaskellDepends = [ base directory extra filepath ];
+       testHaskellDepends = [ base directory extra filepath QuickCheck ];
+       description = "File path glob-like matching";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "fileplow" = callPackage
     ({ mkDerivation, base, binary-search, bytestring, hspec, mtl
      , QuickCheck, temporary, vector
···
        pname = "fin";
        version = "0.2.1";
        sha256 = "14zknp1f65i57nsx8v0np08d7y0szzblybmq7fa5ydazhqwnxlrv";
+       revision = "1";
+       editedCabalFile = "0qk48l13k8xr0qcs4nr5mpr5y84s8apdm5wlqldjdl9l3qbp58aw";
        libraryHaskellDepends = [
          base boring dec deepseq hashable QuickCheck some universe-base
        ];
···
      }) {};
 
   "finite-typelits" = callPackage
-    ({ mkDerivation, base, deepseq }:
-     mkDerivation {
-       pname = "finite-typelits";
-       version = "0.1.4.2";
-       sha256 = "0iyp9fyd2ki9qcmk9infz9p6rjhsx9jrs3f5yz0yqs8vj5na81yj";
-       libraryHaskellDepends = [ base deepseq ];
-       description = "A type inhabited by finitely many values, indexed by type-level naturals";
-       license = lib.licenses.bsd3;
-       maintainers = [ lib.maintainers.turion ];
-     }) {};
-
-  "finite-typelits_0_1_6_0" = callPackage
     ({ mkDerivation, base, deepseq, QuickCheck }:
      mkDerivation {
        pname = "finite-typelits";
···
        testHaskellDepends = [ base deepseq QuickCheck ];
        description = "A type inhabited by finitely many values, indexed by type-level naturals";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.turion ];
      }) {};
 
···
        ];
        description = "Fixes whitespace issues";
        license = "unknown";
+       mainProgram = "fix-whitespace";
+     }) {};
+
+  "fix-whitespace_0_0_10" = callPackage
+    ({ mkDerivation, base, directory, extra, filepath, filepattern
+     , text, yaml
+     }:
+     mkDerivation {
+       pname = "fix-whitespace";
+       version = "0.0.10";
+       sha256 = "1jlkx0ygl315yik0f2fh4ml77c4080y0czs2mlnc84pkhximj58l";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base directory extra filepath filepattern text yaml
+       ];
+       description = "Fixes whitespace issues";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "fix-whitespace";
      }) {};
 
···
        license = lib.licenses.mit;
      }) {};
 
+  "flow_2_0_0_1" = callPackage
+    ({ mkDerivation, base, HUnit }:
+     mkDerivation {
+       pname = "flow";
+       version = "2.0.0.1";
+       sha256 = "1drbw1lbglx30i48mq9a77f34jff6wxvgq1d4rk8axlfis6pnj4h";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base HUnit ];
+       description = "Write more understandable Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "flow-er" = callPackage
     ({ mkDerivation, base, doctest, flow, QuickCheck }:
      mkDerivation {
···
        pname = "force-layout";
        version = "0.4.0.6";
        sha256 = "17956k3mab2xhrmfy7fj5gh08h43yjlsryi5acjhnkmin5arhwpp";
-       revision = "8";
-       editedCabalFile = "0ifp1bcvgkyma6sp889f1fr866vw884d0wgrnzqx9isfjk52csi4";
+       revision = "9";
+       editedCabalFile = "0271sh8py8lm6amwxyr4dic20cji5hq1iixmikq0kmijg1095wkp";
        libraryHaskellDepends = [
          base containers data-default-class lens linear
        ];
···
      }:
      mkDerivation {
        pname = "fortran-src-extras";
-       version = "0.3.1";
-       sha256 = "1n4w5qs93pahdnmfc30r5nmfn7zq6sxmb80f2bnl1zws3xcr30v7";
+       version = "0.3.2";
+       sha256 = "1b8vcg86pq92r1012s6fpnnkr489zs9x202rdjkjnyrmzm9v8rrx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "fortran-vars";
-       version = "0.3.0";
-       sha256 = "0095ifc9psi2mv348qw7538rl1ld2drfq5pcsbdyxrhklm12h5ji";
+       version = "0.3.1";
+       sha256 = "16b1f2h3q2bskz139p8v7w5aa9nsz73w05jby3s3h1rv4g7lj3f1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        mainProgram = "foscam-sort";
      }) {};
 
-  "foundation" = callPackage
+  "foundation_0_0_28" = callPackage
     ({ mkDerivation, base, basement, gauge, ghc-prim }:
      mkDerivation {
        pname = "foundation";
···
        benchmarkHaskellDepends = [ base basement gauge ];
        description = "Alternative prelude with batteries and no dependencies";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "foundation_0_0_29" = callPackage
+  "foundation" = callPackage
     ({ mkDerivation, base, basement, gauge, ghc-prim }:
      mkDerivation {
        pname = "foundation";
···
        benchmarkHaskellDepends = [ base basement gauge ];
        description = "Alternative prelude with batteries and no dependencies";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "foundation-edge" = callPackage
···
        mainProgram = "fourmolu";
      }) {};
 
-  "fourmolu_0_8_1_0" = callPackage
+  "fourmolu_0_8_2_0" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, array, base, bytestring
      , Cabal, containers, Diff, directory, dlist, exceptions, filepath
      , ghc-lib-parser, gitrev, hspec, hspec-discover, hspec-megaparsec
···
      }:
      mkDerivation {
        pname = "fourmolu";
-       version = "0.8.1.0";
-       sha256 = "0acpl5p259pfs42k4iaqhpfpbpbzjk8fxzc65i9wr2wka9cdvzdv";
+       version = "0.8.2.0";
+       sha256 = "1wyfj3yfhp00pr0sjbkba8djjgp1pk8jabj48cps2nkgy5lqbyix";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "functor-classes-compat";
        version = "2.0.0.2";
        sha256 = "02jamibwyr8hvf432m761v94xmwhbflrp6hd01jyv7fm95f5ki6h";
+       revision = "1";
+       editedCabalFile = "1yiw8wsxyvadbdbhv8r9h1m130lvgdgvz1v7lmga8pcg7brfagz8";
        libraryHaskellDepends = [ base containers ];
        description = "Data.Functor.Classes instances for core packages";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.asl20;
      }) {};
 
+  "fusion-plugin_0_2_5" = callPackage
+    ({ mkDerivation, base, containers, directory, filepath
+     , fusion-plugin-types, ghc, syb, time, transformers
+     }:
+     mkDerivation {
+       pname = "fusion-plugin";
+       version = "0.2.5";
+       sha256 = "0xzy7ml8wh63mza4am9rdd12qqn9r6ba6c0i9bv7bxp0nlzy7d6l";
+       libraryHaskellDepends = [
+         base containers directory filepath fusion-plugin-types ghc syb time
+         transformers
+       ];
+       description = "GHC plugin to make stream fusion more predictable";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "fusion-plugin-types" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
-  "generic-arbitrary_1_0_0" = callPackage
+  "generic-arbitrary_1_0_1" = callPackage
     ({ mkDerivation, base, deepseq, QuickCheck, tasty, tasty-discover
      , tasty-hunit, tasty-quickcheck
      }:
      mkDerivation {
        pname = "generic-arbitrary";
-       version = "1.0.0";
-       sha256 = "1l1d61336r92rrpcgsdfxfc2c9slvf9g1m7vbl54bcvw0qlgzgc9";
+       version = "1.0.1";
+       sha256 = "1ir95k98w3i7aisw3gjflzaxzgq3qamxw1bssvdbww43sgckw0cj";
        libraryHaskellDepends = [ base QuickCheck ];
        testHaskellDepends = [
          base deepseq QuickCheck tasty tasty-discover tasty-hunit
···
        pname = "generic-lens-lite";
        version = "0.1";
        sha256 = "07z00phy6h50bb4axlr57kin9l5fygi4q4j33rj5180ai2cbcpc6";
-       revision = "3";
-       editedCabalFile = "0srsqwncr5fkjcqk7ldfmd8q4y80ksbv9mvnzrw9lk2hywdagl8c";
+       revision = "4";
+       editedCabalFile = "1aw808ifylrwjpsf754gzq4npmh7c872cy2fsm7r2gpjgk7mkpp6";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        description = "Monomorphic field lens like with generic-lens";
        license = lib.licenses.bsd3;
      }) {};
 
+  "generic-lexicographic-order" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "generic-lexicographic-order";
+       version = "0.1.0.0";
+       sha256 = "096c1fan7isxynyk968llm3p204kgcmh8xp4krnmspz0xvcn7sh0";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       description = "Derive Bounded and Enum for sum types and Enum for product types";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "generic-lucid-scaffold" = callPackage
     ({ mkDerivation, base, lucid, text }:
      mkDerivation {
···
        pname = "generic-optics-lite";
        version = "0.1";
        sha256 = "0vf5sk1narj69pdhjqxjj0w3w3i5lxjxn8p98xp8dj0jws4mx9xi";
-       revision = "3";
-       editedCabalFile = "0f2dnsdl25s6cfdp7f97r2d9md82vn53dm5gry2pds791k1w4q53";
+       revision = "4";
+       editedCabalFile = "1k5lkdzzdqq743bcw0shhwxj2i7ywh7rihdgasy543i5mvcp0cr4";
        libraryHaskellDepends = [ base generic-lens-lite optics-core ];
        testHaskellDepends = [ base optics-core ];
        description = "Monomorphic field opics like with generic-lens";
···
        pname = "generics-sop";
        version = "0.5.1.2";
        sha256 = "098blydb7c7wg77dn658r0zb1z20vfkar1him1rqlq0da90437b3";
+       revision = "1";
+       editedCabalFile = "1s8bx25yrjqy1cj9y1s1m8a8qlby9dxjzin16yymz7g39fqcqxz8";
        libraryHaskellDepends = [
          base ghc-prim sop-core template-haskell th-abstraction
        ];
···
        pname = "generics-sop-lens";
        version = "0.2.0.1";
        sha256 = "1yl74pz6r2zf9sspzbqg6xvr6k9b5irq3c3pjrf5ih6hfrz4k1ks";
-       revision = "2";
-       editedCabalFile = "14rw0xyfhgyywyb7yghjaqnkpkx9dh0yz8y7l8phxzqgim5r8d1v";
+       revision = "3";
+       editedCabalFile = "0p9h7xbd0jcf85r480gbnyyh822r3wziv1rg2qwgq0ll5apqvzmn";
        libraryHaskellDepends = [ base generics-sop lens ];
        description = "Lenses for types in generics-sop";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "gettext-th" = callPackage
-    ({ mkDerivation, base, bytestring, directory, filepath
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
      , haskell-gettext, template-haskell, text, th-lift-instances
      }:
      mkDerivation {
        pname = "gettext-th";
-       version = "0.1.0.3";
-       sha256 = "0z0mz8bm4a1ns2k7mm5k1amm0l9vk7f64g3w6la7v7q80zaql0b1";
+       version = "0.2.0.0";
+       sha256 = "0jmzg9yj6barpwdvq3mzdd2m9x3hn10hlvd18b1s8qfa2qq2lf21";
        libraryHaskellDepends = [
-         base bytestring directory filepath haskell-gettext template-haskell
-         text th-lift-instances
+         base bytestring containers directory filepath haskell-gettext
+         template-haskell text th-lift-instances
        ];
        description = "gettext-th can internationalise a haskell program without runtime dependencies";
        license = lib.licenses.bsd3;
···
        mainProgram = "gh-pocket-knife";
      }) {};
 
-  "ghc_9_2_4" = callPackage
-    ({ mkDerivation, array, base, binary, bytestring, containers
-     , deepseq, directory, exceptions, filepath, ghc-boot, ghc-heap
-     , ghci, hpc, process, template-haskell, terminfo, time
-     , transformers, unix
+  "ghc_9_4_2" = callPackage
+    ({ mkDerivation, alex, array, base, binary, bytestring, Cabal
+     , containers, deepseq, deriveConstants, directory, exceptions
+     , filepath, genprimopcode, ghc-boot, ghc-heap, ghci, happy, hpc
+     , process, stm, template-haskell, terminfo, time, transformers
+     , unix
      }:
      mkDerivation {
        pname = "ghc";
-       version = "9.2.4";
-       sha256 = "0w63p24p4k16jbr4pnh8nrnxqpiyg8fa0l75ry28y72kp4ngif9q";
+       version = "9.4.2";
+       sha256 = "1xqcc807pdlm2108iz138dh90ppa3v9swb0nfd790va1xvqdvn4c";
+       setupHaskellDepends = [ base Cabal directory filepath process ];
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
-         exceptions filepath ghc-boot ghc-heap ghci hpc process
+         exceptions filepath ghc-boot ghc-heap ghci hpc process stm
          template-haskell terminfo time transformers unix
        ];
+       libraryToolDepends = [ alex deriveConstants genprimopcode happy ];
        description = "The GHC API";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
-     }) {};
+     }) {deriveConstants = null; genprimopcode = null;};
 
   "ghc-api-compat_8_6" = callPackage
     ({ mkDerivation, ghc }:
···
      }:
      mkDerivation {
        pname = "ghc-hs-meta";
-       version = "0.1.0.0";
-       sha256 = "0csbhd6agq3siwrlkjc063jynzxplpwi3x288kw3hhaz5nz1v3ck";
+       version = "0.1.1.0";
+       sha256 = "0yrrf0lx626rl4b14jaqmkab1vf4vymi81jkjm91y5vas8zc276i";
        libraryHaskellDepends = [
          base bytestring ghc ghc-boot template-haskell
        ];
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-lib_9_4_1_20220807" = callPackage
+  "ghc-lib_9_4_2_20220822" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, exceptions, filepath, ghc-lib-parser
      , ghc-prim, happy, hpc, parsec, pretty, process, rts, stm, time
···
      }:
      mkDerivation {
        pname = "ghc-lib";
-       version = "9.4.1.20220807";
-       sha256 = "0anaf36bgziqy8ajc5442qf06xv06p3x46dca29qdnplckjypc51";
-       revision = "1";
-       editedCabalFile = "00mik89sdk4hr5pk3f82kdyik0aamlc1c6apiwvqv03pwrl2v6ih";
+       version = "9.4.2.20220822";
+       sha256 = "0ri29jyrs31ai4a1w3a9jwxc6xb1hqp64gxbwb5y7mbfyi5ray30";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-lib-parser_9_4_1_20220807" = callPackage
+  "ghc-lib-parser_9_4_2_20220822" = 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.4.1.20220807";
-       sha256 = "0m297q39afy2dd2gya451lgwl8wjrzcz2f72102x69qbbp3r63q2";
+       version = "9.4.2.20220822";
+       sha256 = "0irqp5v5vsmv4jmwizl0ag9v43bxfi14m2n977xzya27fdwzvc9y";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "10.20220724";
-       sha256 = "0890xsfhk5k7xddqgq4qppbr169vjja76cd5cz1cslj20lmz5f28";
+       version = "10.20220822";
+       sha256 = "1qv3cb7p2zyc5mpcr4nfgzdmswfny5jbimd2ip7ygh71jlahrbfc";
        configureFlags = [
          "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime"
          "-fnetworkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser"
···
        mainProgram = "github-release";
      }) {};
 
+  "github-release_2_0_0_2" = callPackage
+    ({ mkDerivation, aeson, base, burrito, bytestring, http-client
+     , http-client-tls, http-types, mime-types, optparse-generic, text
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "github-release";
+       version = "2.0.0.2";
+       sha256 = "0xyh4nkrclpvy5i9v0yqlbzm6aq5gl4p3sairdi1abnyzn3ij04h";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base burrito bytestring http-client http-client-tls
+         http-types mime-types optparse-generic text unordered-containers
+       ];
+       executableHaskellDepends = [
+         aeson base burrito bytestring http-client http-client-tls
+         http-types mime-types optparse-generic text unordered-containers
+       ];
+       description = "Upload files to GitHub releases";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "github-release";
+     }) {};
+
   "github-rest" = callPackage
     ({ mkDerivation, aeson, aeson-qq, base, bytestring, http-client
      , http-client-tls, http-types, jwt, mtl, scientific, tasty
···
      }) {};
 
   "gitlab-haskell" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, connection, http-client
-     , http-conduit, http-types, tasty, tasty-hunit, temporary, text
-     , time, transformers, unix
+    ({ mkDerivation, aeson, ansi-wl-pprint, base, bytestring
+     , connection, http-client, http-conduit, http-types, tasty
+     , tasty-hunit, temporary, text, time, transformers, tree-diff, unix
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "gitlab-haskell";
-       version = "0.3.2.0";
-       sha256 = "1ibsb4wyavyb6s64czy1pdbcskfwn96wcky4vlpr0r1f8gjpym5s";
+       version = "1.0.0.1";
+       sha256 = "1spd989dpqjx7m39fdzdkirp3pgh5cf57dqv756x51r4qkcs4hh1";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring connection http-client http-conduit
          http-types temporary text time transformers unix
        ];
-       testHaskellDepends = [ aeson base bytestring tasty tasty-hunit ];
+       testHaskellDepends = [
+         aeson ansi-wl-pprint base bytestring tasty tasty-hunit tree-diff
+         unordered-containers vector
+       ];
        description = "A Haskell library for the GitLab web API";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
      }:
      mkDerivation {
        pname = "graphula";
-       version = "2.0.1.1";
-       sha256 = "0gn33jz9nb2pf1mkjzwnf04l0shnvj520qb0jmz6d87w79jiqdlj";
-       libraryHaskellDepends = [
-         base containers directory generics-eot HUnit mtl persistent
-         QuickCheck random semigroups temporary text unliftio unliftio-core
-       ];
-       testHaskellDepends = [
-         base generic-arbitrary hspec markdown-unlit monad-logger persistent
-         persistent-sqlite QuickCheck resourcet transformers unliftio-core
-       ];
-       testToolDepends = [ markdown-unlit ];
-       description = "A simple interface for generating persistent data and linking its dependencies";
-       license = lib.licenses.mit;
-     }) {};
-
-  "graphula_2_0_2_1" = callPackage
-    ({ mkDerivation, base, containers, directory, generic-arbitrary
-     , generics-eot, hspec, HUnit, markdown-unlit, monad-logger, mtl
-     , persistent, persistent-sqlite, QuickCheck, random, resourcet
-     , semigroups, temporary, text, transformers, unliftio
-     , unliftio-core
-     }:
-     mkDerivation {
-       pname = "graphula";
        version = "2.0.2.1";
        sha256 = "0kkjhfb9x3s0j6m0a68cblfkh70wg2vxrd1f998g20dlpx5rl27m";
        libraryHaskellDepends = [
···
        testToolDepends = [ markdown-unlit ];
        description = "A simple interface for generating persistent data and linking its dependencies";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "graphula-core" = callPackage
···
        pname = "graphviz";
        version = "2999.20.1.0";
        sha256 = "0l0zxgb938hh09qirggbaskq79mgj3s081cnr42y5vm1rp1jir2s";
+       revision = "1";
+       editedCabalFile = "1i0ayvs8iaq5vg38ximc23w1f1qvgmwmn5znqkjsrb96x0ssmdiw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hackage-repo-tool";
        version = "0.1.1.3";
        sha256 = "13q81gi3xmkzwfrbyk5dwxws3c92vnrlslksi021iasmjwhw2h6l";
+       revision = "1";
+       editedCabalFile = "0c1hg72yxpkmcpl22rm40gf0xx3djdakscqll5g7hsgda4bkg2lr";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "hackage-security";
        version = "0.6.2.2";
        sha256 = "0xmjw3frssdv3glhdg3yivdy38h5icz6xywngrahc19220ba6cx8";
+       revision = "1";
+       editedCabalFile = "01fhp3kzc1wfvixzgnz4y52bzm4sickk1cj7pksrwmbi90dghv0s";
        libraryHaskellDepends = [
          base base16-bytestring base64-bytestring bytestring Cabal
          Cabal-syntax containers cryptohash-sha256 directory ed25519
···
 
   "hackport" = callPackage
     ({ mkDerivation, array, async, base, base16-bytestring
-     , base64-bytestring, binary, bytestring, cabal-install, containers
+     , base64-bytestring, binary, bytestring, containers
      , cryptohash-sha256, deepseq, directory, doctest, echo, ed25519
      , edit-distance, extensible-exceptions, filepath, ghc-prim
-     , hashable, hspec, hspec-discover, HTTP, mtl, network, network-uri
-     , parallel, parsec, pretty, process, QuickCheck, random, regex-base
-     , regex-posix, resolv, split, stm, tar, template-haskell, text
-     , time, transformers, unix, xml, zlib
+     , hashable, hspec, hspec-discover, HTTP, lifted-base, monad-control
+     , mtl, network, network-uri, optparse-applicative, parallel, parsec
+     , parser-combinators, pretty, process, QuickCheck, random
+     , regex-base, regex-posix, resolv, split, stm, tar
+     , template-haskell, text, time, transformers, unix, xml, zlib
      }:
      mkDerivation {
        pname = "hackport";
-       version = "0.7.2.2";
-       sha256 = "0yknhk34pwmij8virmlf619sw1k8rl5a8sy7h18q05rsnsdsbipf";
+       version = "0.7.3.0";
+       sha256 = "0166ybpnb0ajp2afgi70lwwmkwbbgavj8mfpcksyaysbpa6zpl4m";
        isLibrary = false;
        isExecutable = true;
        libraryHaskellDepends = [
          array async base base16-bytestring base64-bytestring binary
          bytestring containers cryptohash-sha256 deepseq directory echo
          ed25519 edit-distance extensible-exceptions filepath ghc-prim
-         hashable HTTP mtl network network-uri parallel parsec pretty
-         process QuickCheck random regex-base regex-posix resolv split stm
-         tar template-haskell text time transformers unix xml zlib
+         hashable HTTP lifted-base monad-control mtl network network-uri
+         parallel parsec pretty process QuickCheck random regex-base
+         regex-posix resolv split stm tar template-haskell text time
+         transformers unix xml zlib
        ];
-       executableHaskellDepends = [ base directory filepath ];
+       executableHaskellDepends = [
+         base directory filepath optparse-applicative parsec
+         parser-combinators
+       ];
        testHaskellDepends = [
          async base bytestring containers deepseq directory
-         extensible-exceptions filepath hspec network-uri parallel pretty
-         process QuickCheck split text time xml
+         extensible-exceptions filepath hspec network-uri parallel parsec
+         pretty process QuickCheck split text time xml
        ];
-       testToolDepends = [ cabal-install doctest hspec-discover ];
+       testToolDepends = [ doctest hspec-discover ];
        doHaddock = false;
        description = "Hackage and Portage integration tool";
        license = lib.licenses.gpl3Plus;
···
      }:
      mkDerivation {
        pname = "haeredes";
-       version = "0.5.2";
-       sha256 = "0qqz22aghl00hy240hvws3sgaw2jvhqicms0c1y76b68af1dlkyh";
+       version = "0.5.3";
+       sha256 = "10pjkgwqyij2vd6q2n6g53n11h6fqv9g2zr57bym8dp2j22p2jzh";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
 
   "hashes" = callPackage
     ({ mkDerivation, base, bytestring, criterion, openssl, QuickCheck
-     , sydtest
+     , sha-validation, sydtest, vector
      }:
      mkDerivation {
        pname = "hashes";
-       version = "0.2.1.1";
-       sha256 = "0ni2viazdsg7632lf5viclmwicas36y4ky3mm1bmy3rpvw48g8np";
+       version = "0.2.2.0";
+       sha256 = "194r4zi3sz3dwd5qmrrf92y655v1vxl0xkzsmj4yjk9xpl85wpcl";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ openssl ];
-       testHaskellDepends = [ base bytestring QuickCheck sydtest ];
+       testHaskellDepends = [
+         base bytestring QuickCheck sha-validation sydtest vector
+       ];
        testSystemDepends = [ openssl ];
        benchmarkHaskellDepends = [ base bytestring criterion ];
        benchmarkSystemDepends = [ openssl ];
···
      }:
      mkDerivation {
        pname = "hath";
-       version = "0.5.0";
-       sha256 = "16597w35xbv0hq14bdz4g8w52iy7z54wrqfmd929xrzbxbnc41r6";
+       version = "0.5.7";
+       sha256 = "0ma4myb0cnia0j31a8863a2c80ynw9aa85ls9r688cd9gl1dbhfy";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          base cmdargs split tasty tasty-hunit tasty-quickcheck
        ];
        testHaskellDepends = [
-         base cmdargs process split tasty tasty-hunit tasty-quickcheck
+         base process split tasty tasty-hunit tasty-quickcheck
        ];
        description = "Hath manipulates network blocks in CIDR notation";
        license = lib.licenses.agpl3Only;
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "hedgehog_1_1_1" = callPackage
+  "hedgehog_1_2" = callPackage
     ({ mkDerivation, ansi-terminal, async, barbies, base, bytestring
      , concurrent-output, containers, deepseq, directory, erf
      , exceptions, lifted-async, mmorph, monad-control, mtl, pretty-show
···
      }:
      mkDerivation {
        pname = "hedgehog";
-       version = "1.1.1";
-       sha256 = "1qx7bjcdgczvz5xhrqz25lray9rk3wrhzqfc5vpjnvgkzvnj3mny";
-       revision = "2";
-       editedCabalFile = "06i998jic83qpihcv7xhc2ny1z3b4k0p22ds79l5l9hfbf0la6rh";
+       version = "1.2";
+       sha256 = "0zlfmzzancsglzqmdr40kdfk3ih7anssfkb196r0n9b5lvdcfn98";
        libraryHaskellDepends = [
          ansi-terminal async barbies base bytestring concurrent-output
          containers deepseq directory erf exceptions lifted-async mmorph
···
        pname = "hedgehog-quickcheck";
        version = "0.1.1";
        sha256 = "1z2ja63wqz83qhwzh0zs98k502v8fjdpnsnhqk3srypx2nw5vdlp";
-       revision = "3";
-       editedCabalFile = "0mfpgn46126y1y2k3i2r5nqxcrsa16il3vyf7ir0w471nmks7n54";
+       revision = "4";
+       editedCabalFile = "1838hm2p22n8qrps17zjzf9k0jwvrw9g99r0crii3igfbi22m8nf";
        libraryHaskellDepends = [ base hedgehog QuickCheck transformers ];
        description = "Use QuickCheck generators in Hedgehog and vice versa";
        license = lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
+  "hegg" = callPackage
+    ({ mkDerivation, base, containers, deriving-compat, tasty
+     , tasty-hunit, tasty-quickcheck, transformers
+     }:
+     mkDerivation {
+       pname = "hegg";
+       version = "0.1.0.0";
+       sha256 = "00i18as11njqc10g360aca0l9diz474lsm73rwkg53bwwnfssg1n";
+       libraryHaskellDepends = [ base containers transformers ];
+       testHaskellDepends = [
+         base containers deriving-compat tasty tasty-hunit tasty-quickcheck
+       ];
+       description = "Fast equality saturation in Haskell";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "heidi" = callPackage
     ({ mkDerivation, base, boxes, containers, criterion, exceptions
      , generics-sop, hashable, microlens, microlens-th, scientific
···
        testSystemDepends = [ secp256k1 ];
        description = "Ethereum virtual machine evaluator";
        license = lib.licenses.agpl3Only;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "hevm";
-       broken = true;
      }) {inherit (pkgs) libff; inherit (pkgs) secp256k1;};
 
   "hevolisa" = callPackage
···
        pname = "hkd";
        version = "0.1";
        sha256 = "1xz0i8lkh0rp55b0s7npkzqgyz9pf1bwq9b66cwbg073r9sz41wa";
-       revision = "3";
-       editedCabalFile = "0801yrh576b5yvglv0ywzhqfqda376bc10frgdkc0phi5c7qmnj4";
+       revision = "4";
+       editedCabalFile = "08qjy1616ypa6r0jwh5m66dlvnj87k4cdcggi28caadzg8cf1fz5";
        libraryHaskellDepends = [ base some ];
        testHaskellDepends = [ base some ];
        description = "\"higher-kinded data\"";
···
        pname = "hpqtypes";
        version = "1.9.4.0";
        sha256 = "0m0jpv0d2zynhn53gbjb50sb91lxss71qnzhcy30agxvf29qpi0w";
+       revision = "2";
+       editedCabalFile = "1xpbb5js710rd7kbdgx6hl10dl7n95yp6pidqrh8f9ifwx076k3g";
        setupHaskellDepends = [ base Cabal directory filepath ];
        libraryHaskellDepends = [
          aeson async base bytestring containers exceptions lifted-base
···
      }:
      mkDerivation {
        pname = "hs-opentelemetry-api";
-       version = "0.0.3.5";
-       sha256 = "0jk623sg997d92iid7v04bh83mp09bb1fyf0j005r9f0zgmdmwvv";
+       version = "0.0.3.6";
+       sha256 = "1g634i1md07vrq10c6sj01nnanhn377xv14vcmygi85np66mqkc8";
        libraryHaskellDepends = [
          async attoparsec base binary bytestring charset clock containers
          ghc-prim hashable http-types memory mtl template-haskell text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hs-opentelemetry-instrumentation-hspec" = callPackage
+    ({ mkDerivation, base, hs-opentelemetry-api, hspec, hspec-core, mtl
+     , resourcet, text, unliftio, vault
+     }:
+     mkDerivation {
+       pname = "hs-opentelemetry-instrumentation-hspec";
+       version = "0.0.1.0";
+       sha256 = "0ya2s4x37fz8zzdik1mbxv5j69rz8m4gv9viizcgp5wcknjs818z";
+       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
+       ];
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "hs-opentelemetry-instrumentation-http-client" = callPackage
     ({ mkDerivation, aeson, base, bytestring, case-insensitive, conduit
      , hs-opentelemetry-api, hs-opentelemetry-instrumentation-conduit
···
     ({ mkDerivation, async, base, bytestring, clock
      , hs-opentelemetry-api, hs-opentelemetry-exporter-otlp
      , hs-opentelemetry-propagator-w3c, hspec, http-types, mwc-random
-     , network-bsd, random, random-bytestring, stm, text, unagi-chan
-     , unix, unordered-containers, vector, vector-builder
+     , network-bsd, random, random-bytestring, stm, text, transformers
+     , unagi-chan, unix, unordered-containers, vector, vector-builder
      }:
      mkDerivation {
        pname = "hs-opentelemetry-sdk";
-       version = "0.0.3.1";
-       sha256 = "0z4j2jih8076xic39kil0w0p6vcjbpcmpbfiskx2i7ycm2cg4gs2";
+       pname = "htaut";
+       sha256 = "1721786554sb0jwa8mmkcrlwci1i49mgwpaxa8xaiilw6nddmc8a";
        libraryHaskellDepends = [
          async base bytestring hs-opentelemetry-api
          hs-opentelemetry-exporter-otlp hs-opentelemetry-propagator-w3c
          http-types mwc-random network-bsd random random-bytestring stm text
-         unagi-chan unix unordered-containers vector vector-builder
+         transformers unagi-chan unix unordered-containers vector
+         vector-builder
        ];
        testHaskellDepends = [
          async base bytestring clock hs-opentelemetry-api
          hs-opentelemetry-exporter-otlp hs-opentelemetry-propagator-w3c
          hspec http-types mwc-random network-bsd random random-bytestring
-         stm text unagi-chan unix unordered-containers vector vector-builder
+         stm text transformers unagi-chan unix unordered-containers vector
+         vector-builder
        ];
        description = "OpenTelemetry SDK for use in applications";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "hs-opentelemetry-utils-exceptions" = callPackage
+    ({ mkDerivation, base, exceptions, hs-opentelemetry-api
+     , hs-opentelemetry-sdk, text
+     }:
+     mkDerivation {
+       pname = "hs-opentelemetry-utils-exceptions";
+       version = "0.1.0.0";
+       sha256 = "0syz50by1n5818pwfap58rj6d76frwvhk14aqxk1x3mx2ddsz0yc";
+       libraryHaskellDepends = [
+         base exceptions hs-opentelemetry-api hs-opentelemetry-sdk text
+       ];
+       testHaskellDepends = [
+         base exceptions hs-opentelemetry-api hs-opentelemetry-sdk text
+       ];
        license = lib.licenses.bsd3;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "hslua-module-path";
-       version = "1.0.2";
-       sha256 = "0y2syngdhqdpbz9y5ya0cwp07s2q7g16djw508w5003va811yw60";
-       libraryHaskellDepends = [
-         base filepath hslua-core hslua-marshalling hslua-packaging text
-       ];
-       testHaskellDepends = [
-         base filepath hslua-core hslua-marshalling hslua-packaging tasty
-         tasty-hunit tasty-lua text
-       ];
-       description = "Lua module to work with file paths";
-       license = lib.licenses.mit;
-     }) {};
-
-  "hslua-module-path_1_0_3" = callPackage
-    ({ mkDerivation, base, filepath, hslua-core, hslua-marshalling
-     , hslua-packaging, tasty, tasty-hunit, tasty-lua, text
-     }:
-     mkDerivation {
-       pname = "hslua-module-path";
        version = "1.0.3";
        sha256 = "1sy2k4mb263kg85vkf39ja84xz5kvm6z61xn62jy1swhrvvd96sr";
        libraryHaskellDepends = [
···
        ];
        description = "Lua module to work with file paths";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hslua-module-system" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
-  "hspec_2_10_0_1" = callPackage
+  "hspec_2_10_1" = callPackage
     ({ mkDerivation, base, hspec-core, hspec-discover
      , hspec-expectations, QuickCheck
      }:
      mkDerivation {
        pname = "hspec";
-       version = "2.10.0.1";
-       sha256 = "0in22h0k4f0c6d55zbdsypf0a546f4mafifxmk019cxnj4i5rx8q";
+       version = "2.10.1";
+       sha256 = "1nhsamvdpbz89dxww1bz1428nn7zb5w83r4jgjwb30y5aa29w2jm";
        libraryHaskellDepends = [
          base hspec-core hspec-discover hspec-expectations QuickCheck
        ];
···
        license = lib.licenses.mit;
      }) {};
 
-  "hspec-core_2_10_0_1" = callPackage
+  "hspec-core_2_10_1" = callPackage
     ({ mkDerivation, ansi-terminal, array, base, base-orphans
      , call-stack, clock, deepseq, directory, filepath, ghc, ghc-boot-th
      , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
···
      }:
      mkDerivation {
        pname = "hspec-core";
-       version = "2.10.0.1";
-       sha256 = "0g59jlkds28q9vb4fw7wc7cdwa7rl4anhk6gaz411j8ra3j1cjql";
+       version = "2.10.1";
+       sha256 = "0f1af3j1szh801ahxrxasb78icq8swhdv99hjlgb52k3drf77pwn";
        libraryHaskellDepends = [
          ansi-terminal array base call-stack clock deepseq directory
          filepath ghc ghc-boot-th hspec-expectations HUnit QuickCheck
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "hspec-discover_2_10_0_1" = callPackage
+  "hspec-discover_2_10_1" = callPackage
     ({ mkDerivation, base, directory, filepath, hspec-meta, mockery
      , QuickCheck
      }:
      mkDerivation {
        pname = "hspec-discover";
-       version = "2.10.0.1";
-       sha256 = "1z27h094qyiqnlqsp5ppfd6v9yshhnz4ry7x7zvkyjfmx3xxwm9z";
+       version = "2.10.1";
+       sha256 = "034xm9zgclvpbbs54d93s0h9qvbb9p86dd1w1p9sl8kjp108a542";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base directory filepath ];
···
        pname = "htaglib";
        version = "1.2.0";
        sha256 = "0ph04j1ysjzzrcyllgibzrzfv5g5mgpa6s0ksxww15aryipw65sa";
-       revision = "1";
-       editedCabalFile = "09vsz2z5sb5ai3qpksqdckb43vndqs66x4abx3lln2xr40dlkljv";
+       revision = "2";
+       editedCabalFile = "1vb9izb058z8lsq5yp4c0w4lralb0mzr5g6hw4mvd82yjf07il0z";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base bytestring text transformers ];
        librarySystemDepends = [ taglib ];
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "html-parse-util" = callPackage
+    ({ mkDerivation, attoparsec, base, html-parse, text }:
+     mkDerivation {
+       pname = "html-parse-util";
+       version = "0.2.1";
+       sha256 = "1n5pxx7m1b2dnlck3vqibjcny2r3ywi6r4f9vl3j516dx8r22pp2";
+       libraryHaskellDepends = [ attoparsec base html-parse text ];
+       description = "Utility functions for working with html-parse";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "html-presentation-text" = callPackage
···
        pname = "http-api-data";
        version = "0.5";
        sha256 = "0gxpfrkr83gq5kndfbyg03ps0g421bn4vafdqng7wmnn5hhb9vgp";
+       revision = "1";
+       editedCabalFile = "1gcqa0lm804cqv1xdaxz87mg0fv7d98i57px8al7qgdzpldma17k";
        libraryHaskellDepends = [
          attoparsec attoparsec-iso8601 base base-compat bytestring
          containers cookie hashable http-types tagged text time-compat
···
        pname = "insert-ordered-containers";
        version = "0.2.5.1";
        sha256 = "1mnc0gby7xz8065rvkqsaqk1vqs0gv1y9qgvwsvxx3gsg9yj3a7r";
-       revision = "2";
-       editedCabalFile = "1mb1iknk0hyz0az85k9w45ymdan37gx3m72mn6zw9i3dib3ly1il";
+       revision = "3";
+       editedCabalFile = "11awwf3lm3qzjqxy8gw9cizr30228cjwhqzff7wvjvdx131s0raa";
        libraryHaskellDepends = [
          aeson base deepseq hashable indexed-traversable lens optics-core
          optics-extra semigroupoids text transformers unordered-containers
···
      }:
      mkDerivation {
        pname = "io-streams";
-       version = "1.5.2.1";
-       sha256 = "1y3sqmxrwiksz7pl4hf3vzvg8p8n00qnv98nj5xbpcadlh468rny";
-       revision = "3";
-       editedCabalFile = "14zy4y6xnrfal02w0m8smjpb202axmq88cm40722rzxfpy5s1cjq";
-       configureFlags = [ "-fnointeractivetests" ];
-       libraryHaskellDepends = [
-         attoparsec base bytestring network primitive process text time
-         transformers vector zlib-bindings
-       ];
-       testHaskellDepends = [
-         attoparsec base bytestring deepseq directory filepath HUnit mtl
-         network primitive process QuickCheck test-framework
-         test-framework-hunit test-framework-quickcheck2 text time
-         transformers vector zlib zlib-bindings
-       ];
-       description = "Simple, composable, and easy-to-use stream I/O";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "io-streams_1_5_2_2" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, deepseq, directory
-     , filepath, HUnit, mtl, network, primitive, process, QuickCheck
-     , test-framework, test-framework-hunit, test-framework-quickcheck2
-     , text, time, transformers, vector, zlib, zlib-bindings
-     }:
-     mkDerivation {
-       pname = "io-streams";
        version = "1.5.2.2";
        sha256 = "1zn4iyd18g9jc1qdgixp6hi56nj7czy4jdz2xca59hcn2q2xarfk";
        configureFlags = [ "-fnointeractivetests" ];
···
        ];
        description = "Simple, composable, and easy-to-use stream I/O";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "io-streams-haproxy" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "json-feed_2_0_0_4" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, filepath, hspec
+     , mime-types, network-uri, tagsoup, text, time
+     }:
+     mkDerivation {
+       pname = "json-feed";
+       version = "2.0.0.4";
+       sha256 = "022zdas84skhh9s17k6mx45axrzfv2c7jf7f2rhk324706b7wxfl";
+       libraryHaskellDepends = [
+         aeson base bytestring mime-types network-uri tagsoup text time
+       ];
+       testHaskellDepends = [
+         aeson base bytestring filepath hspec mime-types network-uri tagsoup
+         text time
+       ];
+       description = "JSON Feed";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "json-fu" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
      , hashable, hspec, mtl, syb, text, time, unordered-containers
···
      }) {inherit (pkgs) SDL_mixer;};
 
   "keid-core" = callPackage
-    ({ mkDerivation, base, binary, bytestring, cryptohash-md5
-     , derive-storable, derive-storable-plugin, file-embed, foldl
-     , geomancy, GLFW-b, ktx-codec, neat-interpolation
-     , optparse-applicative, optparse-simple, resourcet, rio, rio-app
-     , serialise, StateVar, tagged, template-haskell, text, transformers
-     , unagi-chan, unliftio, vector, vulkan, vulkan-utils
+    ({ mkDerivation, base, binary, bytestring, containers
+     , cryptohash-md5, derive-storable, derive-storable-plugin
+     , file-embed, foldl, geomancy, GLFW-b, ktx-codec
+     , neat-interpolation, optparse-applicative, optparse-simple
+     , resourcet, rio, rio-app, serialise, spirv-reflect-types
+     , spirv-reflect-yaml, StateVar, tagged, template-haskell, text
+     , transformers, unagi-chan, unliftio, vector, vulkan, vulkan-utils
      , VulkanMemoryAllocator, zstd
      }:
      mkDerivation {
        pname = "keid-core";
-       version = "0.1.6.1";
-       sha256 = "0r0gkq8hn3gkfpc9c982fhncdfbbk2y06lll515ycs55456bqdnh";
+       version = "0.1.7.0";
+       sha256 = "0y9ks8bgaimg8qzwx5lxkihlx0akkbwhghma9sfm37d7qq2nbn07";
        libraryHaskellDepends = [
-         base binary bytestring cryptohash-md5 derive-storable
+         base binary bytestring containers cryptohash-md5 derive-storable
          derive-storable-plugin file-embed foldl geomancy GLFW-b ktx-codec
          neat-interpolation optparse-applicative optparse-simple resourcet
-         rio rio-app serialise StateVar tagged template-haskell text
-         transformers unagi-chan unliftio vector vulkan vulkan-utils
-         VulkanMemoryAllocator zstd
+         rio rio-app serialise spirv-reflect-types spirv-reflect-yaml
+         StateVar tagged template-haskell text transformers unagi-chan
+         unliftio vector vulkan vulkan-utils VulkanMemoryAllocator zstd
        ];
        description = "Core parts of Keid engine";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "keid-render-basic";
-       version = "0.1.6.1";
-       sha256 = "0rp06ap82ky70qhp8prhyi3vkynrn3c2wilr2lmlh2gv64q2ri0g";
+       version = "0.1.7.0";
+       sha256 = "0amv73z9154r10501wm5zxcc2drqf47xsvygqzhyvs655yfcg0x6";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring derive-storable derive-storable-plugin
···
        description = "Basic rendering programs for Keid engine";
        license = lib.licenses.bsd3;
        platforms = [ "x86_64-linux" ];
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "keid-resource-gltf" = callPackage
···
      }:
      mkDerivation {
        pname = "keid-ui-dearimgui";
-       version = "0.1.1.1";
-       sha256 = "0qxkgrayb365mj7sknzq7w9cxs5ppfzg272cah632bvs70qkl7xl";
+       version = "0.1.2.0";
+       sha256 = "1n8a33fr8y8wz4nbgn1pijk73ik0jmr6mxp8dnvcad2gp4cr86j5";
        libraryHaskellDepends = [
          base binary bytestring dear-imgui GLFW-b keid-core resourcet rio
          rio-app unliftio vector vulkan vulkan-utils VulkanMemoryAllocator
···
        license = lib.licenses.mit;
      }) {};
 
+  "lackey_2_0_0_3" = callPackage
+    ({ mkDerivation, base, hspec, servant, servant-foreign, text }:
+     mkDerivation {
+       pname = "lackey";
+       pname = "htaut";
+       sha256 = "0drcq03vsya11002wg7i3phbgyylcyx4zry3ixflffm8sz00smci";
+       libraryHaskellDepends = [ base servant-foreign text ];
+       testHaskellDepends = [ base hspec servant servant-foreign text ];
+       description = "Generate Ruby clients from Servant APIs";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lacroix" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "lame";
        version = "0.2.0";
        sha256 = "1bqq3aanfffdsl3v0am7jdfslcr6y372cq7jx36z7g09zy5mp2sp";
-       revision = "1";
-       editedCabalFile = "1czjga37b56xs6jrylsf5gip5srmlfg2982k96l5w4300sj8ricz";
+       revision = "2";
+       editedCabalFile = "15yjwhwxiqds425y7a4s1z9vdrgmqwq2y5kvl1d1xhw7h05ryxkr";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base bytestring directory exceptions filepath text transformers
···
        broken = true;
      }) {mp3lame = null;};
 
+  "lame_0_2_1" = callPackage
+    ({ mkDerivation, base, bytestring, directory, exceptions, filepath
+     , hspec, hspec-discover, htaglib, mp3lame, temporary, text
+     , transformers, wave
+     }:
+     mkDerivation {
+       pname = "lame";
+       version = "0.2.1";
+       sha256 = "1xz98v2kqs69jijza0vyz57lpbs3h2f7fcablihlzprh1sylc3vq";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bytestring directory exceptions filepath text transformers
+         wave
+       ];
+       librarySystemDepends = [ mp3lame ];
+       testHaskellDepends = [
+         base directory filepath hspec htaglib temporary text
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A high-level binding to the LAME encoder";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {mp3lame = null;};
+
   "lame-tester" = callPackage
     ({ mkDerivation, base-noprelude, bizzlelude, containers, semigroups
      , tasty, tasty-hunit, validation
···
      }) {};
 
   "landlock" = callPackage
-    ({ mkDerivation, base, exceptions, filepath, process, QuickCheck
-     , tasty, tasty-expected-failure, tasty-hunit, tasty-quickcheck
-     , unix
+    ({ mkDerivation, async, base, exceptions, filepath, process, psx
+     , QuickCheck, tasty, tasty-expected-failure, tasty-hunit
+     , tasty-quickcheck, unix
      }:
      mkDerivation {
        pname = "landlock";
-       version = "0.1.0.0";
-       sha256 = "19l95a4wajdzml38l9251yklxsgk70ky29x7bmldyn6nagdqgdap";
-       libraryHaskellDepends = [ base exceptions unix ];
+       version = "0.2.0.1";
+       sha256 = "1xn517if819v7qrazq0dx7mmgn9i996j1lmxrkb68rmflbg2wic1";
+       libraryHaskellDepends = [ base exceptions psx unix ];
        testHaskellDepends = [
-         base filepath process QuickCheck tasty tasty-expected-failure
+         async base filepath process QuickCheck tasty tasty-expected-failure
          tasty-hunit tasty-quickcheck
        ];
        doHaddock = false;
···
     ({ mkDerivation, base, language-c99, language-c99-util, mtl }:
      mkDerivation {
        pname = "language-c99-simple";
-       version = "0.2.1";
-       sha256 = "0ii5mlxzy47gs91amriv1zsbb0myayanwsw3qwz4p29m09fqjpic";
+       version = "0.2.2";
+       sha256 = "16va8nd3xa4a8nfdpazcnrl0192cpdc7z06ixcx0ya04sycc9cx9";
        libraryHaskellDepends = [
          base language-c99 language-c99-util mtl
        ];
···
        testHaskellDepends = [ base ];
        description = "Enumerative property-based testing";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "leancheck_1_0_0" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "leancheck";
+       version = "1.0.0";
+       sha256 = "0896792d34aqag2hhmi6596kx46ca3897d0v9lr69qbcms9jj5gh";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base ];
+       description = "Enumerative property-based testing";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "leancheck-enum-instances" = callPackage
···
      , containers, data-default-class, free-vector-spaces, hashable
      , ieee754, lens, linear, manifolds-core, MemoTrie, QuickCheck
      , semigroups, tagged, tasty, tasty-quickcheck, template-haskell
-     , transformers, vector, vector-space
+     , th-abstraction, transformers, vector, vector-space
      }:
      mkDerivation {
        pname = "linearmap-category";
-       version = "0.4.2.0";
-       sha256 = "0iblymralldn1xljdl6qyvxcsxg6rmgj42qx254vaajijp51ycmp";
+       version = "0.4.3.0";
+       sha256 = "0319x0fz863d44p1lzgbnp8nwxdpvn50ms29z7lwh0g3s0mcs628";
        libraryHaskellDepends = [
          base call-stack constrained-categories containers
          data-default-class free-vector-spaces hashable ieee754 lens linear
          manifolds-core MemoTrie QuickCheck semigroups tagged
-         template-haskell transformers vector vector-space
+         template-haskell th-abstraction transformers vector vector-space
        ];
        testHaskellDepends = [
          base constrained-categories linear manifolds-core QuickCheck tasty
···
     ({ mkDerivation, base, bytestring, cmdargs, configurator
      , containers, directory, dns, doctest, filemanip, filepath, HDBC
      , HDBC-postgresql, HDBC-sqlite3, MissingH, tasty, tasty-hunit
-     , tasty-quickcheck
      }:
      mkDerivation {
        pname = "list-remote-forwards";
-       version = "0.0.1";
-       sha256 = "1bq5244ys4xy3pfj72dq399x0g57q41lrllbd5hgvk9z0j92lxys";
+       version = "0.0.3";
+       sha256 = "0c7fm8mbhhh9nhcib5d0k2gipfkcsvpkg5x4xb7x75x0i099q6jf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          base bytestring cmdargs configurator containers directory dns
          filepath HDBC HDBC-postgresql HDBC-sqlite3 MissingH tasty
-         tasty-hunit tasty-quickcheck
+         tasty-hunit
        ];
        testHaskellDepends = [
          base bytestring cmdargs configurator containers directory dns
-         doctest filemanip filepath HDBC HDBC-postgresql HDBC-sqlite3
-         MissingH tasty tasty-hunit tasty-quickcheck
+         doctest filemanip filepath HDBC HDBC-sqlite3 MissingH tasty
+         tasty-hunit
        ];
        description = "List all remote forwards for mail accounts stored in a SQL database";
-       license = lib.licenses.gpl3Only;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "list-remote-forwards";
        broken = true;
···
        libraryHaskellDepends = [ base ];
        description = "Easily and clearly create lists with only one element in them";
        license = lib.licenses.mit;
+     }) {};
+
+  "list-singleton_2_0_0_2" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "list-singleton";
+       version = "2.0.0.2";
+       sha256 = "1n1b1fk8zn9hz162lmy9d123icd2i6cnlvpkk2ypbphmnam0xr43";
+       libraryHaskellDepends = [ base ];
+       description = "Easily and clearly create lists with only one element in them";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "list-t" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "lockfree-queue_0_2_4" = callPackage
+    ({ mkDerivation, abstract-deque, abstract-deque-tests
+     , atomic-primops, base, bytestring, ghc-prim, HUnit, test-framework
+     , test-framework-hunit
+     }:
+     mkDerivation {
+       pname = "lockfree-queue";
+       version = "0.2.4";
+       sha256 = "1vlrydp3ywqgfnhmfm7zhdfn3nrkd7q8lj9apa34y35yvh67gxm0";
+       libraryHaskellDepends = [
+         abstract-deque atomic-primops base ghc-prim
+       ];
+       testHaskellDepends = [
+         abstract-deque abstract-deque-tests atomic-primops base bytestring
+         ghc-prim HUnit test-framework test-framework-hunit
+       ];
+       description = "Michael and Scott lock-free queues";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lockpool" = callPackage
     ({ mkDerivation, base, clock, stm }:
      mkDerivation {
···
        pname = "lukko";
        version = "0.1.1.3";
        sha256 = "07xb926kixqv5scqdl8w34z42zjzdpbq06f0ha3f3nm3rxhgn3m8";
-       revision = "2";
-       editedCabalFile = "1h4pdybiqpwljjm4p9bhn3nr2kgqxxggnl5czk5d6ch6li1w1160";
+       revision = "3";
+       editedCabalFile = "1a6spmbiv3ias40sjrnsxfgr1d5mwg039a2q7113zb7i9n6c1m7g";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          async base bytestring filepath singleton-bool tasty
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) xz;};
 
+  "lzma_0_0_0_4" = callPackage
+    ({ mkDerivation, base, bytestring, HUnit, QuickCheck, tasty
+     , tasty-hunit, tasty-quickcheck, xz
+     }:
+     mkDerivation {
+       pname = "lzma";
+       version = "0.0.0.4";
+       sha256 = "0fy11i7fanrsbh8w7cclwx0i6csn5df6vl38dh2112aqw6n7h382";
+       libraryHaskellDepends = [ base bytestring ];
+       librarySystemDepends = [ xz ];
+       testHaskellDepends = [
+         base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
+       ];
+       description = "LZMA/XZ compression and decompression";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) xz;};
+
   "lzma-clib" = callPackage
     ({ mkDerivation }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "mailbox-count";
-       version = "0.0.5";
-       sha256 = "0g1kbb4pmh1vs8ddswpcmqb9fhfkhlffwp9y7r4dq5wcsdihwm8c";
+       version = "0.0.6";
+       sha256 = "0pjy1l63wzic55snhkxq7hv4iscda3np5f5dl5lb9vmh0hlx4x1k";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        testHaskellDepends = [
          base cmdargs configurator containers directory doctest filemanip
-         filepath HDBC HDBC-postgresql HDBC-sqlite3 MissingH tasty
-         tasty-hunit
+         filepath HDBC HDBC-sqlite3 MissingH tasty tasty-hunit
        ];
        description = "Count mailboxes in a SQL database";
        license = lib.licenses.agpl3Only;
···
      }:
      mkDerivation {
        pname = "massiv";
-       version = "1.0.1.1";
-       sha256 = "1yg594y0v8bpymd5g6hy8a7cy2hbvlpyxm9hnq3pprbhbcrrx22w";
-       revision = "1";
-       editedCabalFile = "1rcjcd3sf4qlrwk026sw5nz9i5jagpga83jyp5ij3igkg2ffps21";
-       libraryHaskellDepends = [
-         base bytestring deepseq exceptions primitive random scheduler
-         unliftio-core vector
-       ];
-       testHaskellDepends = [ base doctest ];
-       description = "Massiv (Массив) is an Array Library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "massiv_1_0_2_0" = callPackage
-    ({ mkDerivation, base, bytestring, deepseq, doctest, exceptions
-     , primitive, random, scheduler, unliftio-core, vector
-     }:
-     mkDerivation {
-       pname = "massiv";
        version = "1.0.2.0";
        sha256 = "15ckrsavsrkgm4c9al2jlk1r4nm2mdjshw1ksbkh8m65l3l5kcrr";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base doctest ];
        description = "Massiv (Массив) is an Array Library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "massiv-io" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "mixed-types-num_0_5_11" = callPackage
+    ({ mkDerivation, base, collect-errors, hspec, hspec-smallcheck, mtl
+     , QuickCheck, smallcheck, template-haskell
+     }:
+     mkDerivation {
+       pname = "mixed-types-num";
+       version = "0.5.11";
+       sha256 = "15r1lj39fkddlqfda41cp76xr8ck4fkannszxi32j7a8lkjr2f21";
+       libraryHaskellDepends = [
+         base collect-errors hspec hspec-smallcheck mtl QuickCheck
+         smallcheck template-haskell
+       ];
+       testHaskellDepends = [
+         base collect-errors hspec hspec-smallcheck QuickCheck smallcheck
+       ];
+       description = "Alternative Prelude with numeric and logic expressions typed bottom-up";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "mixpanel-client" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring, hspec
      , hspec-discover, http-client, http-client-tls, markdown-unlit
···
        ];
        description = "A library for probabilistic programming";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "example";
-       broken = true;
      }) {};
 
   "monad-bool" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "monad-logger_0_3_37" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, conduit-extra
+     , exceptions, fast-logger, lifted-base, monad-control, monad-loops
+     , mtl, resourcet, stm, stm-chans, template-haskell, text
+     , transformers, transformers-base, transformers-compat
+     , unliftio-core
+     }:
+     mkDerivation {
+       pname = "monad-logger";
+       version = "0.3.37";
+       sha256 = "1z275a428zcj73zz0cpfha2adwiwqqqp7klx3kbd3i9rl20xa106";
+       libraryHaskellDepends = [
+         base bytestring conduit conduit-extra exceptions fast-logger
+         lifted-base monad-control monad-loops mtl resourcet stm stm-chans
+         template-haskell text transformers transformers-base
+         transformers-compat unliftio-core
+       ];
+       description = "A class of monads which can log messages";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "monad-logger-aeson" = callPackage
     ({ mkDerivation, aeson, aeson-diff, base, bytestring, context
      , directory, exceptions, fast-logger, hspec, hspec-discover
···
        pname = "months";
        version = "0.2";
        sha256 = "054dag7806850hdii7s5rxg8gx2spdp33pnx4s4ckni9ayvspija";
-       revision = "5";
-       editedCabalFile = "1fqxdjclv2jsj802sr4v35cn12qchcxdmhpfm003v2j1s6gp689s";
+       revision = "6";
+       editedCabalFile = "05h58b9cg1iy9l4lh1xf35ngjh9cpwiibprbbsmjl0gw9d0a32p9";
        libraryHaskellDepends = [
          aeson attoparsec base base-compat deepseq hashable intervals
          QuickCheck text time-compat
···
      }:
      mkDerivation {
        pname = "morpheus-graphql";
-       version = "0.20.0";
-       sha256 = "0ikbfapl9jb9yd9i5v9plw3s3drsbx660h8x0mibn8qsci0jsbh5";
+       version = "0.20.1";
+       sha256 = "0y1c43010spp70z2srfmln1nd7r286b8nprq851f2zgp0g3lbkfi";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers morpheus-graphql-app
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-app";
-       version = "0.20.0";
-       sha256 = "1qvgfsykml7mx36azgbdvjc814hdd14554qpld716v339bj3jgmp";
+       version = "0.20.1";
+       sha256 = "0dc84pswgjl401nqx3127zn2r43a1n9kmhwx4xqy5l1favm1lfv0";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers hashable megaparsec
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-client";
-       version = "0.20.0";
-       sha256 = "1gq7sn2dfsmbls2l9kw1x59xq2xqb7ahbdgi4705riwm06kvrj1y";
+       version = "0.20.1";
+       sha256 = "0r2qp9nin5hlk1adflgn6s2x831d3g6y5d1pvdiahgjbn0mm580w";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers file-embed
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-code-gen";
-       version = "0.20.0";
-       sha256 = "0d7p2151zrvbbdxwsp6kjrmd4x5za3n7p47apn9b4lhwylqzgx1k";
+       version = "0.20.1";
+       sha256 = "08hzxxvnbrqnkhaahh5npjy637pjkhcf8dnh2zswq1c2pmyaw10s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-core";
-       version = "0.20.0";
-       sha256 = "19203qc0zfixb60fyf8ddlpbdwynq0g1w31ssmcdldqjdqf7fpdc";
+       version = "0.20.1";
+       sha256 = "0rinp9zkdls07lr0606jxxijybq89xwxl6vgkx9wgfkrcd014wng";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers hashable megaparsec mtl relude
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-subscriptions";
-       version = "0.20.0";
-       sha256 = "1yrba6d33x24rmzpmbnd3pbnn00za0bs4xl9sqfbyizc485164v0";
+       version = "0.20.1";
+       sha256 = "1wad97zjw8766920q26069qb1fi4w25i9pxibkadvc42j4vzkv0p";
        libraryHaskellDepends = [
          aeson base bytestring morpheus-graphql-app morpheus-graphql-core
          mtl relude text transformers unliftio-core unordered-containers
···
        license = lib.licenses.mit;
      }) {};
 
-  "morpheus-graphql-tests_0_20_0" = callPackage
+  "morpheus-graphql-tests_0_20_1" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory, relude, tasty
      , tasty-hunit, text, unordered-containers
      }:
      mkDerivation {
        pname = "morpheus-graphql-tests";
-       version = "0.20.0";
-       sha256 = "0ss2fmz97ppmxsd2dfaxbiy2rw1xba7kyn6fg7a0y25y68whwryl";
+       version = "0.20.1";
+       sha256 = "1z977hyf1hsaal45m4jh938q3srw3kh75xhgb9m0zrph085wzr7f";
        libraryHaskellDepends = [
          aeson base bytestring directory relude tasty tasty-hunit text
          unordered-containers
···
      }:
      mkDerivation {
        pname = "nanovg";
-       version = "0.8.0.0";
-       sha256 = "1il4305wv7f53225jv5s04nf7gf5rw6cfxm8j3v1di2xvhdingz5";
-       revision = "2";
-       editedCabalFile = "1vvlmbvpafvqawfph2aicysy9nklm8rqdz2bdpkq0kg4dgi72jr2";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base bytestring containers text vector ];
-       librarySystemDepends = [ glew libGL libGLU libX11 ];
-       libraryPkgconfigDepends = [ freetype glew ];
-       libraryToolDepends = [ c2hs ];
-       testHaskellDepends = [ base containers hspec inline-c QuickCheck ];
-       description = "Haskell bindings for nanovg";
-       license = lib.licenses.isc;
-     }) {inherit (pkgs) freetype; inherit (pkgs) glew; 
-         inherit (pkgs) libGL; inherit (pkgs) libGLU; 
-         inherit (pkgs.xorg) libX11;};
-
-  "nanovg_0_8_1_0" = callPackage
-    ({ mkDerivation, base, bytestring, c2hs, containers, freetype, glew
-     , hspec, inline-c, libGL, libGLU, libX11, QuickCheck, text, vector
-     }:
-     mkDerivation {
-       pname = "nanovg";
        version = "0.8.1.0";
        sha256 = "1yzabd2l8z77dsgby97dzv0h38a6w554kmhp6hsfx3j24n0h0rnv";
        isLibrary = true;
···
        testHaskellDepends = [ base containers hspec inline-c QuickCheck ];
        description = "Haskell bindings for nanovg";
        license = lib.licenses.isc;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) freetype; inherit (pkgs) glew; 
          inherit (pkgs) libGL; inherit (pkgs) libGLU; 
          inherit (pkgs.xorg) libX11;};
···
        pname = "nonlinear-optimization-ad";
        version = "0.2.4";
        sha256 = "0wqi1y4f2sqn7wg1bj3i73kwdawg9ni6lq1s87m6sshy34n0vbx5";
-       revision = "2";
-       editedCabalFile = "09q4c4vaxs1dxi6m8ph8r1jw95hwsqvcybsfpzxdrk2j5mp43gw8";
+       revision = "3";
+       editedCabalFile = "0n32cs870mkw8imgm7fx4d6jg53q2idxnl0x85ky973p4igdpy4h";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "nonlinear-optimization-backprop";
        version = "0.2.4";
        sha256 = "0j7i67m25r4hs81w0j090c8wifvxxs0hzj0l0rj7aa1yrx5iwbhq";
+       revision = "1";
+       editedCabalFile = "1n034q0qc7xz3ggj105ghsn89k5v91178p1vfji9ig9f8kfs055c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.asl20;
      }) {};
 
+  "nvim-hs_2_2_0_3" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, cereal-conduit, conduit
+     , containers, data-default, deepseq, foreign-store, hslogger, hspec
+     , hspec-discover, HUnit, megaparsec, messagepack, mtl, network
+     , optparse-applicative, path, path-io, prettyprinter
+     , prettyprinter-ansi-terminal, QuickCheck, resourcet, stm
+     , streaming-commons, template-haskell
+     , template-haskell-compat-v0208, text, time, time-locale-compat
+     , transformers, transformers-base, typed-process, unliftio
+     , unliftio-core, utf8-string, vector, void
+     }:
+     mkDerivation {
+       pname = "nvim-hs";
+       version = "2.2.0.3";
+       sha256 = "0sbppnphnbygxjns373hyb3hvbwzlv4sq104682bcajd07x6vhmw";
+       libraryHaskellDepends = [
+         base bytestring cereal cereal-conduit conduit containers
+         data-default deepseq foreign-store hslogger megaparsec messagepack
+         mtl network optparse-applicative path path-io prettyprinter
+         prettyprinter-ansi-terminal resourcet stm streaming-commons
+         template-haskell template-haskell-compat-v0208 text time
+         time-locale-compat transformers transformers-base typed-process
+         unliftio unliftio-core utf8-string vector void
+       ];
+       testHaskellDepends = [
+         base bytestring cereal cereal-conduit conduit containers
+         data-default foreign-store hslogger hspec hspec-discover HUnit
+         megaparsec messagepack mtl network optparse-applicative path
+         path-io prettyprinter prettyprinter-ansi-terminal QuickCheck
+         resourcet stm streaming-commons template-haskell
+         template-haskell-compat-v0208 text time time-locale-compat
+         transformers transformers-base typed-process unliftio unliftio-core
+         utf8-string vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Haskell plugin backend for neovim";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "nvim-hs-contrib" = callPackage
     ({ mkDerivation, base, bytestring, data-default, directory
      , filepath, hspec, hspec-discover, messagepack, mtl, nvim-hs
···
        pname = "optics-extra";
        version = "0.4.2.1";
        sha256 = "0hfa5yb7l3l310lfxkii13fjzb69g619agadc5a86i734nisf8vy";
+       revision = "1";
+       editedCabalFile = "0bpr1bkb7mmww028n8ikwa0qhdl7ybxpb9s887dlp3dvxr5iq8nq";
        libraryHaskellDepends = [
          array base bytestring containers hashable indexed-profunctors
          indexed-traversable-instances mtl optics-core text transformers
···
        pname = "optics-th";
        version = "0.4.1";
        sha256 = "05zxljfqmhr5if7l8gld5s864nql6kqjfizsf1z7r3ydknvmff6p";
-       revision = "1";
-       editedCabalFile = "0q58020ql4ggv50y64chg57czczg27f8ysbp4a265zxi5i0kfvvq";
+       revision = "2";
+       editedCabalFile = "1fl217q7s0g8a46p2smanhhdj0jqvc9n3lagcnpphkv3fzfgrcbz";
        libraryHaskellDepends = [
          base containers mtl optics-core template-haskell th-abstraction
          transformers
···
        pname = "palette";
        version = "0.3.0.2";
        sha256 = "0820n3cj4zy9s46diln2rrs4lrxbipkhdw74p2w42gc7k1nlj54i";
-       revision = "3";
-       editedCabalFile = "1m9nd65pmnwmy74yqq283w53p483mnfvzkv1iyd6y97f0scgxs84";
+       revision = "4";
+       editedCabalFile = "07yjz9hsmfm5jh05i4nqc6iax61ssr97475l7pf3bbdp8bam39wl";
        libraryHaskellDepends = [
          array base colour containers MonadRandom
        ];
···
        maintainers = [ lib.maintainers.peti ];
      }) {};
 
-  "pandoc_2_19_1" = callPackage
+  "pandoc_2_19_2" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
      , base64, binary, blaze-html, blaze-markup, bytestring
      , case-insensitive, citeproc, commonmark, commonmark-extensions
···
      }:
      mkDerivation {
        pname = "pandoc";
-       version = "2.19.1";
-       sha256 = "107r2hqljjic503w198qz16gv7gmkl7w8ir1w5riba0kvz9nqs3c";
+       version = "2.19.2";
+       sha256 = "0ia2gpl345lwymk38y89sgcqjci7sjmxbi228idg6nkaqfa3ds1n";
        configureFlags = [ "-f-trypandoc" ];
        isLibrary = true;
        isExecutable = true;
···
        ];
        description = "Content addressable Haskell package management";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "pantry_0_5_7" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal
+     , casa-client, casa-types, conduit, conduit-extra, containers
+     , cryptonite, cryptonite-conduit, digest, exceptions, filelock
+     , generic-deriving, hackage-security, hedgehog, hpack, hspec
+     , http-client, http-client-tls, http-conduit, http-download
+     , http-types, memory, mtl, network-uri, path, path-io, persistent
+     , persistent-sqlite, persistent-template, primitive, QuickCheck
+     , raw-strings-qq, resourcet, rio, rio-orphans, rio-prettyprint
+     , tar-conduit, text, text-metrics, time, transformers, unix-compat
+     , unliftio, unordered-containers, vector, yaml, zip-archive
+     }:
+     mkDerivation {
+       pname = "pantry";
+       version = "0.5.7";
+       sha256 = "1cck09972pv2kz6kpg631rxfqwy92g4ibngfjy0bkp2xfadcg6ci";
+       libraryHaskellDepends = [
+         aeson ansi-terminal base bytestring Cabal casa-client casa-types
+         conduit conduit-extra containers cryptonite cryptonite-conduit
+         digest filelock generic-deriving hackage-security hpack http-client
+         http-client-tls http-conduit http-download http-types memory mtl
+         network-uri path path-io persistent persistent-sqlite
+         persistent-template primitive resourcet rio rio-orphans
+         rio-prettyprint tar-conduit text text-metrics time transformers
+         unix-compat unliftio unordered-containers vector yaml zip-archive
+       ];
+       testHaskellDepends = [
+         aeson ansi-terminal base bytestring Cabal casa-client casa-types
+         conduit conduit-extra containers cryptonite cryptonite-conduit
+         digest exceptions filelock generic-deriving hackage-security
+         hedgehog hpack hspec http-client http-client-tls http-conduit
+         http-download http-types memory mtl network-uri path path-io
+         persistent persistent-sqlite persistent-template primitive
+         QuickCheck raw-strings-qq resourcet rio rio-orphans rio-prettyprint
+         tar-conduit text text-metrics time transformers unix-compat
+         unliftio unordered-containers vector yaml zip-archive
+       ];
+       description = "Content addressable Haskell package management";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pantry-tmp" = callPackage
···
        maintainers = [ lib.maintainers.psibi ];
      }) {};
 
-  "persistent_2_14_1_0" = callPackage
+  "persistent_2_14_2_0" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
      , blaze-html, bytestring, conduit, containers, criterion, deepseq
      , fast-logger, file-embed, hspec, http-api-data, lift-type
···
      }:
      mkDerivation {
        pname = "persistent";
-       version = "2.14.1.0";
-       sha256 = "1jzmqxlvyzgp25rczlp1pi8msd776gw6jlf141zlqrs3523qc0wq";
+       version = "2.14.2.0";
+       sha256 = "0iwkn9llas29jmih1zqj52973352pz4yp3dpajdxbypyn16v8p5v";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring blaze-html bytestring
          conduit containers fast-logger http-api-data lift-type monad-logger
···
        pname = "persistent-discover";
        version = "0.1.0.5";
        sha256 = "1y90046yva6zxm0im8p51yivqyp8nhgplwgnmw78sw1fa2gvjvs9";
+       revision = "1";
+       editedCabalFile = "1irdncx38kk4s22fbygh4q3ai08sj98qw2mp2dhaflyjxmv3px5x";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "pg-entity" = callPackage
-    ({ mkDerivation, base, bytestring, colourista, exceptions, hspec
-     , hspec-expectations-lifted, hspec-pg-transact, monad-control
-     , parsec, pg-transact, postgresql-simple
-     , postgresql-simple-migration, resource-pool, safe-exceptions
-     , template-haskell, text, text-manipulate, time, uuid, vector
+    ({ mkDerivation, aeson, base, bytestring, colourista, containers
+     , exceptions, hedgehog, monad-control, mtl, optics-core, parsec
+     , pg-transact, postgresql-simple, postgresql-simple-migration
+     , resource-pool, safe-exceptions, tasty, tasty-hunit
+     , template-haskell, text, text-display, text-manipulate, time
+     , tmp-postgres, uuid, vector
      }:
      mkDerivation {
        pname = "pg-entity";
-       version = "0.0.1.0";
-       sha256 = "0njmlxxisigza4k6v5ci36xm6mpf5jdls2mrlarlw91agxiz8zd9";
+       version = "0.0.2.0";
+       sha256 = "0g8ici9l5lm4a900nyi90xvbjgy4z3zds46nn8sdw8ipnj0hkk1v";
        libraryHaskellDepends = [
          base bytestring colourista exceptions monad-control parsec
          pg-transact postgresql-simple resource-pool safe-exceptions
-         template-haskell text text-manipulate time uuid vector
+         template-haskell text text-display text-manipulate time uuid vector
        ];
        testHaskellDepends = [
-         base hspec hspec-expectations-lifted hspec-pg-transact pg-transact
-         postgresql-simple postgresql-simple-migration text time uuid vector
+         aeson base containers hedgehog mtl optics-core pg-transact
+         postgresql-simple postgresql-simple-migration resource-pool
+         safe-exceptions tasty tasty-hunit text time tmp-postgres uuid
+         vector
        ];
        description = "A pleasant PostgreSQL layer";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, filters-basic, mmsyn2-array }:
      mkDerivation {
        pname = "phonetic-languages-filters-array";
-       version = "0.4.0.0";
-       sha256 = "0rkgwf9v98vdflhkcfn7s0in8dw69rh2dcv8n9lvpjd0ccmlvil8";
+       version = "0.5.0.0";
+       sha256 = "087ngarvpihrjvfnm6kbm7qfiy947r35rig44hyn5dxzq7pxqzp6";
        libraryHaskellDepends = [ base filters-basic mmsyn2-array ];
        description = "Allows to change the structure of the function output";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-examples-array";
-       version = "0.20.0.0";
-       sha256 = "0w22h8s272rnasqyzlxx0badw5dkv99sxrgbflb86hj6lsm06g1d";
+       version = "0.20.1.0";
+       sha256 = "0c664k9vvk2j522dwn27caf4d35dshj3z07c9qgzy47rjs65r6xw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-examples-array";
-       version = "0.18.1.0";
-       sha256 = "1frn5zijjv1054lwd7mvp4klv96ywpbxv5msnyl7a2bbikwrdhqs";
+       version = "0.18.2.0";
+       sha256 = "0jyg507a4gh437vzxj658nhs8l32p2xg4vifrgs5q5jyck61p7z5";
        libraryHaskellDepends = [
          base cli-arguments foldable-ix heaps mmsyn2-array mmsyn3 parallel
          phonetic-languages-basis phonetic-languages-constraints-array
···
      }:
      mkDerivation {
        pname = "polysemy-chronos";
-       version = "0.5.0.0";
-       sha256 = "04cj96iwn7fgyk4r8hy730lm1j01q7iv1yd7rdq20kp9mris5c6c";
+       version = "0.5.1.0";
+       sha256 = "00kbc6591mpa41fl0vzmxickphn4ryh3fx2f55qbqpshvg417m6x";
        libraryHaskellDepends = [
          base chronos incipit-core polysemy-time
        ];
···
      }:
      mkDerivation {
        pname = "polysemy-time";
-       version = "0.5.0.0";
-       sha256 = "026rqwm9bjlxvcxjnnma06z30xkmysjnj8r5krbq5rinqdpjdfbs";
+       version = "0.5.1.0";
+       sha256 = "16p5256v9cvns348xva8qz0dsaqgcf5cijm93831lskfkvlvnzc5";
        libraryHaskellDepends = [
          aeson base incipit-core stm template-haskell time torsor
        ];
···
        broken = true;
      }) {};
 
+  "postgresql-query_3_10_0" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
+     , containers, data-default, doctest, exceptions, file-embed
+     , generic-arbitrary, haskell-src-meta, hreader, hset, inflections
+     , monad-control, monad-logger, mtl, postgresql-simple, QuickCheck
+     , quickcheck-assertions, quickcheck-instances, resource-pool
+     , semigroups, tasty, tasty-hunit, tasty-quickcheck, tasty-th
+     , template-haskell, text, th-lift, th-lift-instances, time
+     , transformers, transformers-base, transformers-compat
+     }:
+     mkDerivation {
+       pname = "postgresql-query";
+       version = "3.10.0";
+       sha256 = "16dkfcv9wcbzqdyka609nav538044bwzvzw79mghrrax0xmzl1xj";
+       libraryHaskellDepends = [
+         aeson attoparsec base blaze-builder bytestring containers
+         data-default exceptions file-embed haskell-src-meta hreader hset
+         inflections monad-control monad-logger mtl postgresql-simple
+         resource-pool semigroups template-haskell text th-lift
+         th-lift-instances time transformers transformers-base
+         transformers-compat
+       ];
+       testHaskellDepends = [
+         attoparsec base doctest generic-arbitrary postgresql-simple
+         QuickCheck quickcheck-assertions quickcheck-instances tasty
+         tasty-hunit tasty-quickcheck tasty-th text time
+       ];
+       description = "Sql interpolating quasiquote plus some kind of primitive ORM using it";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "postgresql-replicant" = callPackage
     ({ mkDerivation, aeson, async, attoparsec, base, binary, bits
      , bytestring, cereal, containers, hspec, keep-alive
···
      , bytestring, Cabal, cassava, conduit, containers, convertible
      , criterion, cryptohash-sha256, curryer-rpc, data-interval, deepseq
      , deepseq-generics, deferred-folds, directory, either, exceptions
-     , extended-reals, filepath, foldl, ghc, ghc-boot, ghc-paths, ghci
-     , Glob, gnuplot, hashable, hashable-time, haskeline, http-api-data
-     , http-conduit, http-types, HUnit, list-t, megaparsec, modern-uri
-     , monad-parallel, MonadRandom, mtl, network, old-locale
-     , optparse-applicative, parallel, parser-combinators, path-pieces
-     , prettyprinter, QuickCheck, quickcheck-instances, random
-     , random-shuffle, recursion-schemes, resourcet, rset, scotty
-     , semigroups, stm, stm-containers, streamly, template-haskell
-     , temporary, text, text-manipulate, time, transformers, unix
-     , unordered-containers, uuid, vector, vector-instances, wai
-     , wai-websockets, warp, warp-tls, websockets, winery, zlib
+     , extended-reals, fast-builder, filepath, foldl, ghc, ghc-boot
+     , ghc-paths, ghci, Glob, gnuplot, hashable, haskeline
+     , http-api-data, http-conduit, http-types, HUnit, list-t
+     , megaparsec, modern-uri, monad-parallel, MonadRandom, mtl, network
+     , old-locale, optparse-applicative, parallel, parser-combinators
+     , path-pieces, prettyprinter, QuickCheck, quickcheck-instances
+     , random, random-shuffle, recursion-schemes, resourcet, rset
+     , scientific, scotty, semigroups, stm, stm-containers, streamly
+     , template-haskell, temporary, text, text-manipulate, time
+     , time-compat, transformers, unix, unordered-containers, uuid
+     , vector, vector-instances, wai, wai-websockets, warp, warp-tls
+     , websockets, winery, zlib
      }:
      mkDerivation {
        pname = "project-m36";
-       version = "0.9.4";
-       sha256 = "0byxxgakhkmqgzc0p394fi3k3qffn65zkk51zgvlzin0m074baxp";
+       version = "0.9.5";
+       sha256 = "01gd1hi7x515q1y2nz3zsx3481rb13f30i6xccyzm4fjn7p08mv7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson async attoparsec base base64-bytestring bytestring cassava
          conduit containers convertible cryptohash-sha256 curryer-rpc
          data-interval deepseq deepseq-generics deferred-folds directory
-         either exceptions extended-reals filepath foldl ghc ghc-boot
-         ghc-paths ghci Glob gnuplot hashable hashable-time haskeline
+         either exceptions extended-reals fast-builder filepath foldl ghc
+         ghc-boot ghc-paths ghci Glob gnuplot hashable haskeline
          http-api-data list-t monad-parallel MonadRandom mtl network
          old-locale optparse-applicative parallel path-pieces QuickCheck
          quickcheck-instances random-shuffle recursion-schemes resourcet
-         rset semigroups stm stm-containers streamly temporary text
-         text-manipulate time transformers unix unordered-containers uuid
-         vector vector-instances winery zlib
+         rset scientific semigroups stm stm-containers streamly temporary
+         text text-manipulate time time-compat transformers unix
+         unordered-containers uuid vector vector-instances winery zlib
        ];
        executableHaskellDepends = [
          aeson attoparsec barbies base base16-bytestring base64-bytestring
          binary blaze-html bytestring Cabal cassava conduit containers
          cryptohash-sha256 curryer-rpc data-interval deepseq
          deepseq-generics directory either filepath ghc ghc-paths gnuplot
-         hashable hashable-time haskeline http-api-data http-conduit
-         http-types HUnit list-t megaparsec modern-uri MonadRandom mtl
-         network optparse-applicative parallel parser-combinators
-         path-pieces prettyprinter random scotty semigroups stm
+         hashable haskeline http-api-data http-conduit http-types HUnit
+         list-t megaparsec modern-uri MonadRandom mtl network
+         optparse-applicative parallel parser-combinators path-pieces
+         prettyprinter random scientific scotty semigroups stm
          stm-containers template-haskell temporary text time transformers
          unordered-containers uuid vector wai wai-websockets warp warp-tls
          websockets winery
···
          aeson attoparsec base base16-bytestring base64-bytestring
          bytestring Cabal cassava containers cryptohash-sha256 curryer-rpc
          data-interval deepseq deepseq-generics directory filepath gnuplot
-         hashable hashable-time haskeline http-conduit http-types HUnit
-         list-t megaparsec modern-uri MonadRandom mtl network
-         optparse-applicative parallel parser-combinators prettyprinter
-         random semigroups stm stm-containers temporary text time
-         transformers unordered-containers uuid vector websockets winery
+         hashable haskeline http-conduit http-types HUnit list-t megaparsec
+         modern-uri MonadRandom mtl network optparse-applicative parallel
+         parser-combinators prettyprinter random scientific semigroups stm
+         stm-containers temporary text time transformers
+         unordered-containers uuid vector websockets winery
        ];
        benchmarkHaskellDepends = [
          aeson attoparsec base base16-bytestring base64-bytestring
          bytestring Cabal cassava containers criterion cryptohash-sha256
          curryer-rpc data-interval deepseq deepseq-generics directory
-         filepath gnuplot hashable hashable-time haskeline http-conduit
-         http-types HUnit list-t megaparsec modern-uri MonadRandom mtl
-         network optparse-applicative parallel parser-combinators
-         prettyprinter random semigroups stm stm-containers temporary text
-         time transformers unordered-containers uuid vector websockets
-         winery
+         filepath gnuplot hashable haskeline http-conduit http-types HUnit
+         list-t megaparsec modern-uri MonadRandom mtl network
+         optparse-applicative parallel parser-combinators prettyprinter
+         random scientific semigroups stm stm-containers temporary text time
+         transformers unordered-containers uuid vector websockets winery
        ];
        description = "Relational Algebra Engine";
        license = lib.licenses.mit;
···
        mainProgram = "pstemmer-test-exe";
      }) {};
 
+  "psx" = callPackage
+    ({ mkDerivation, async, base, tasty, tasty-hunit }:
+     mkDerivation {
+       pname = "psx";
+       version = "0.1.0.0";
+       sha256 = "1clxvv9qazq02307ay7acy17614407zhjm9p1139dfiqri1218ar";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ async base tasty tasty-hunit ];
+       description = "Integrate @libpsx@ with the GHC RTS";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "ptera" = callPackage
     ({ mkDerivation, base, Cabal, cabal-doctest, containers, doctest
      , enummapset-th, hspec, hspec-discover, membership, ptera-core
···
      }:
      mkDerivation {
        pname = "pusher-http-haskell";
-       version = "2.1.0.10";
-       sha256 = "1xmqs11v8bj099izdqfq6mza4rqm1njznrdcfq4zvwg9381n86hz";
-       libraryHaskellDepends = [
-         aeson base base16-bytestring bytestring cryptonite hashable
-         http-client http-client-tls http-types memory text time
-         unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson base bytestring hspec QuickCheck text unordered-containers
-       ];
-       description = "Haskell client library for the Pusher Channels HTTP API";
-       license = lib.licenses.mit;
-     }) {};
-
-  "pusher-http-haskell_2_1_0_11" = callPackage
-    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
-     , cryptonite, hashable, hspec, http-client, http-client-tls
-     , http-types, memory, QuickCheck, text, time, unordered-containers
-     }:
-     mkDerivation {
-       pname = "pusher-http-haskell";
        version = "2.1.0.11";
        sha256 = "1vrpdj0z41zhpfy4lk87w4fyfvrp27rvqds9j5s2wyxj95k2scm5";
        libraryHaskellDepends = [
···
        ];
        description = "Haskell client library for the Pusher Channels HTTP API";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pusher-ws" = callPackage
···
     ({ mkDerivation, base, QuickCheck, random }:
      mkDerivation {
        pname = "quickcheck-dynamic";
-       version = "1.0.0";
-       sha256 = "0c4kagvlwihqz14kwdawkv9gg1ncq36icqdxyz3lyk5hyijxr56n";
+       version = "1.1.0";
+       sha256 = "0agb3hi9g9fcwbas1wh3sxb77gakisgh5wmfbysr91pxilqkrx3y";
        libraryHaskellDepends = [ base QuickCheck random ];
        description = "A library for stateful property-based testing";
        license = lib.licenses.asl20;
···
        pname = "ral";
        version = "0.2.1";
        sha256 = "1f6sks81g8zxkgnp7lc5n0aimnvbbvkazassc17z0prs56hs63si";
+       revision = "1";
+       editedCabalFile = "12hvk5cz97ljnwa4y8c47hhfg8v1j7n3zqhb99cmrvgm58ar5j4q";
        libraryHaskellDepends = [
          adjunctions base bin boring deepseq distributive fin hashable
          indexed-traversable QuickCheck semigroupoids
···
        pname = "ral-lens";
        version = "0.2";
        sha256 = "0nlw0q0b8bza98h74k0wa2vc9m5bk6g9slri1mzd6cr1pmpvna67";
-       revision = "1";
-       editedCabalFile = "0fmwfl0ci25g4lzprj9xm4jv1is4m7j8v8j0n09j4qxvlzz6y4p1";
+       revision = "2";
+       editedCabalFile = "156nfgr5229r2r3aq92jrjagjvp95vy303b680h89rfyl8bjx7qi";
        libraryHaskellDepends = [ base bin fin lens ral ];
        description = "Length-indexed random access lists: lens utilities";
        license = lib.licenses.gpl2Plus;
···
        pname = "ral-optics";
        version = "0.2";
        sha256 = "1s7pxkf0vw1a5k1gwyfn6wsmiaa4csbghqshdbva8c73510q0fp1";
-       revision = "1";
-       editedCabalFile = "1dbd9v0s0g06sr0cx5dma4bn6ga47ha501nm06rfs2y6dbv1jn23";
+       revision = "2";
+       editedCabalFile = "111b5ghsy1flf5czqz42hfqzp5n8fphw4a1jdgphm2f9b3h1bj43";
        libraryHaskellDepends = [ base bin fin optics-core ral ];
        description = "Length-indexed random access lists: optics utilities";
        license = lib.licenses.gpl2Plus;
···
        license = lib.licenses.mit;
      }) {};
 
+  "rampart_2_0_0_3" = callPackage
+    ({ mkDerivation, base, criterion, hspec }:
+     mkDerivation {
+       pname = "rampart";
+       pname = "htaut";
+       sha256 = "1g6297vfsa61ygywsc906p5449nzljldl3bbf2jags79b6qwa15n";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec ];
+       benchmarkHaskellDepends = [ base criterion ];
+       description = "Determine how intervals relate to each other";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ramus" = callPackage
     ({ mkDerivation, base, criterion, hspec, QuickCheck, quickcheck-io
      }:
···
        pname = "range-set-list";
        version = "0.1.3.1";
        sha256 = "0m8c8qhpk9vaykqfy6gsv1csmvdclm27zv9l56ipv152k75xks0j";
-       revision = "3";
-       editedCabalFile = "0r6ilczzhzhkndg56bih8na4jf62nrwwpkc5n16sbm61yr49hsha";
+       revision = "4";
+       editedCabalFile = "17wbbhjlcbyz9qil2z2s6nwk7mdfck1lkx5jqrdsavwbrzza6xzr";
        libraryHaskellDepends = [ base containers deepseq hashable ];
        testHaskellDepends = [
          base containers deepseq hashable tasty tasty-quickcheck
···
        license = lib.licenses.mit;
      }) {};
 
+  "ratel_2_0_0_4" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, case-insensitive
+     , containers, filepath, hspec, http-client, http-client-tls
+     , http-types, uuid
+     }:
+     mkDerivation {
+       pname = "ratel";
+       version = "2.0.0.4";
+       sha256 = "0iwdj9bmv3k7ppq51z66z1h8rrsi6jcc6xpdf5b8c869fazy6nd4";
+       libraryHaskellDepends = [
+         aeson base bytestring case-insensitive containers http-client
+         http-client-tls http-types uuid
+       ];
+       testHaskellDepends = [
+         aeson base bytestring case-insensitive containers filepath hspec
+         http-client http-client-tls http-types uuid
+       ];
+       description = "Notify Honeybadger about exceptions";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ratel-wai" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, containers
      , http-client, ratel, wai
···
        ];
        description = "Notify Honeybadger about exceptions via a WAI middleware";
        license = lib.licenses.mit;
+     }) {};
+
+  "ratel-wai_2_0_0_1" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, containers
+     , http-client, ratel, wai
+     }:
+     mkDerivation {
+       pname = "ratel-wai";
+       version = "2.0.0.1";
+       sha256 = "0hh99f7dwl5gihgqjn627s6sn4p68h1lifl2m8qqlhhdnnbwy4lr";
+       libraryHaskellDepends = [
+         base bytestring case-insensitive containers http-client ratel wai
+       ];
+       description = "Notify Honeybadger about exceptions via a WAI middleware";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ratelimiter" = callPackage
···
        broken = true;
      }) {};
 
-  "rattletrap_11_2_11" = callPackage
+  "rattletrap_11_2_12" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
      , containers, filepath, http-client, http-client-tls, text
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "11.2.11";
-       sha256 = "004lhyi5v34124990j1m8mhcb1inn6313lp4db9yd3p82c7k928n";
+       version = "11.2.12";
+       sha256 = "1c3mpcjx2yl1w5myrqsdcsgr5x2hiv4pw5qd3ghlxkhl15rxbkzv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "recursion-schemes";
        version = "5.2.2.2";
        sha256 = "018l7j9pk8izi817vqyrakrkjsxr332jh24d6j0yl35i5wm4khv6";
+       revision = "1";
+       editedCabalFile = "1l6wbzx8804pb6p8gvk45hal6sz8r1gvyxb8aa9ih6j8pqv4q04c";
        libraryHaskellDepends = [
          base base-orphans comonad containers data-fix free template-haskell
          th-abstraction transformers
···
        broken = true;
      }) {};
 
+  "recv" = callPackage
+    ({ mkDerivation, base, bytestring, hspec, hspec-discover, network
+     }:
+     mkDerivation {
+       pname = "recv";
+       version = "0.0.0";
+       sha256 = "1yz9b95m9yxcwbbwdvp288y47ycn4yq9g7ixlw0sf98h5rjp4s2w";
+       libraryHaskellDepends = [ base bytestring network ];
+       testHaskellDepends = [ base bytestring hspec network ];
+       testToolDepends = [ hspec-discover ];
+       description = "Efficient netowrk recv";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "red-black-record" = callPackage
     ({ mkDerivation, aeson, base, bytestring, doctest, profunctors
      , sop-core, tasty, tasty-hunit, text
···
        pname = "regex-rure";
        version = "0.1.2.0";
        sha256 = "1my3rmj2766bd00qg25wijgvw7ffk8fq965y2b97s5v00fjds33r";
+       revision = "1";
+       editedCabalFile = "0pyj0ar204q8vhcwn0i5rqjjplsw0b6yhvy57am5b3sgcki41si5";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ rure ];
        libraryToolDepends = [ c2hs ];
···
        pname = "rere";
        version = "0.2";
        sha256 = "0s89flhcmwppypxz909ifmzq7vlwy35yjrbw0gkgm4ikbw6l1ylr";
-       revision = "1";
-       editedCabalFile = "1mpabhclfkn4a1b7r4vwf6n98xwrzivw8nd0g5jbplbsw5lwxv1j";
+       revision = "2";
+       editedCabalFile = "1gbf04s2rjs8kn1g28kd5qm8rvq6fdna88l1plw67q19v9rkxidp";
        libraryHaskellDepends = [
          base containers fin parsec QuickCheck transformers vec
        ];
···
      }:
      mkDerivation {
        pname = "ret";
-       version = "0.1.4.2";
-       sha256 = "1p0d854hw5qs94fiqsbgbs4picyjj2g51x0j4nasw4acbfwhmzgz";
+       version = "0.1.5.0";
+       sha256 = "0d7r0q39xkgh23bgl0za9jrwxlp8jvc5zkz51561sd40hjwbllqx";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "rpmbuild-order";
        version = "0.4.8";
        sha256 = "16mzvgx4az9wjy4va85hprj2mqiw1mmc6pw8xjdfv8vxsw17kb16";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base case-insensitive directory extra fgl filepath graphviz
+         simple-cmd
+       ];
+       executableHaskellDepends = [
+         base directory extra fgl optparse-applicative simple-cmd-args
+       ];
+       testHaskellDepends = [ base extra hspec simple-cmd unix ];
+       description = "Sort RPM packages in dependency order";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "rpmbuild-order";
+       broken = true;
+     }) {};
+
+  "rpmbuild-order_0_4_9" = callPackage
+    ({ mkDerivation, base, case-insensitive, directory, extra, fgl
+     , filepath, graphviz, hspec, optparse-applicative, simple-cmd
+     , simple-cmd-args, unix
+     }:
+     mkDerivation {
+       pname = "rpmbuild-order";
+       version = "0.4.9";
+       sha256 = "1fclj2g340030y26mvlzkg9x1br1dmz1y8g5gjh3ngwjwlpy8k1q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "safe-json";
        version = "1.1.3.1";
        sha256 = "1rwjlyw0ps29ks2lzji0pi0mz86ma5x0zyhpc1xg740s5592rjf9";
+       revision = "1";
+       editedCabalFile = "0mf2z0rfyyhscrx8cg0yjz87f7xm8bv68c6z1p0pj5kbfnz0pzqs";
        libraryHaskellDepends = [
          aeson base bytestring containers dlist hashable scientific tasty
          tasty-hunit tasty-quickcheck text time unordered-containers
···
        license = lib.licenses.mit;
      }) {};
 
+  "salve_2_0_0_1" = callPackage
+    ({ mkDerivation, base, HUnit }:
+     mkDerivation {
+       pname = "salve";
+       version = "2.0.0.1";
+       sha256 = "0g2y0ng0s3hp9scp080m933yixhl3zd8bsjvyf2k0pn9b9cg0p79";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base HUnit ];
+       description = "Semantic version numbers and constraints";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "salvia" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory, fclabels
      , MaybeT-transformers, monads-fd, network, old-locale, process
···
        pname = "satchmo-toysat";
        version = "0.2.1.0";
        sha256 = "1g6hzgdiiczwk87928xi42lv2swm218i9hs39f3zqpcp8r7fxh61";
-       revision = "1";
-       editedCabalFile = "1cyaibpgmzyc2yd6djjll0f2ywc2fkny9f4pbgwl8f1pyl223m67";
+       revision = "2";
+       editedCabalFile = "1q9kdi7l4nzig91b7gl9vqr8285kdfcbgzbkd22204iih6j6cmmf";
        libraryHaskellDepends = [
          array base containers satchmo toysolver
        ];
···
     ({ mkDerivation, base, ditto, ditto-lucid, lucid, scotty, text }:
      mkDerivation {
        pname = "scotty-form";
-       version = "0.3.0.0";
-       sha256 = "0v04j8ffbbm319xh5cfk1zjh3z12n18g38ppmzww0b7n4ixr2f8c";
+       version = "0.4.1.0";
+       sha256 = "1xfii1ms9z4h52jxv3p784l1ymn9khgxiazaqq6kxyzfkmn5l9zv";
        libraryHaskellDepends = [
          base ditto ditto-lucid lucid scotty text
        ];
        description = "Html form validation using `ditto`";
-       license = lib.licenses.gpl2Only;
+       license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        hydraPlatforms = lib.platforms.none;
        mainProgram = "sha-streams";
        broken = true;
+     }) {};
+
+  "sha-validation" = callPackage
+    ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring
+     , directory, filepath, template-haskell, text, vector
+     }:
+     mkDerivation {
+       pname = "sha-validation";
+       version = "0.1.0.0";
+       sha256 = "190z2sgbbnq4p91j1xlc8bnnspz68r1m17vvzxpcifh2ji42al0v";
+       libraryHaskellDepends = [
+         attoparsec base base16-bytestring bytestring directory filepath
+         template-haskell text vector
+       ];
+       description = "Validation SHA Implementations";
+       license = lib.licenses.mit;
      }) {};
 
   "sha1" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "silently_1_2_5_3" = callPackage
+    ({ mkDerivation, base, deepseq, directory, nanospec, temporary }:
+     mkDerivation {
+       pname = "silently";
+       version = "1.2.5.3";
+       sha256 = "0wk3yci4r9v0vwyzylj3k07damz17jwc6n6imwqahf4lsapsz7ds";
+       libraryHaskellDepends = [ base deepseq directory ];
+       testHaskellDepends = [ base deepseq directory nanospec temporary ];
+       description = "Prevent or capture writing to stdout and other handles";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "silkscreen" = callPackage
     ({ mkDerivation, base, prettyprinter }:
      mkDerivation {
···
        libraryHaskellDepends = [ base ];
        description = "A very simple timestamp";
        license = lib.licenses.mit;
+     }) {};
+
+  "simple-media-timestamp_0_2_1_0" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "simple-media-timestamp";
+       version = "0.2.1.0";
+       sha256 = "1d4zx68cz4i3gdah3j7kn2zr3h34mh89a4wkqb0aasxbyiwll4p0";
+       libraryHaskellDepends = [ base ];
+       description = "A very simple timestamp type";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "simple-media-timestamp-attoparsec" = callPackage
···
        pname = "singleton-bool";
        version = "0.1.6";
        sha256 = "1pc34dbzx5g3vw5w03zifvqva3whyvxzfy3yh78qkpd05f0g98sw";
-       revision = "1";
-       editedCabalFile = "0wg0js2fn7xpvaxz5jmghhc1al3lpwmhjb43mn731ffrbmfryihx";
+       revision = "2";
+       editedCabalFile = "1l4nx664awgwzk3ih5idsgnj220jqdr1c55241xjv7fz7lwyhh5r";
        libraryHaskellDepends = [ base boring dec deepseq some ];
        description = "Type level booleans";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "singletons_3_0_2" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "singletons";
+       version = "3.0.2";
+       sha256 = "10jy9phwx3gnl5dx6by7chsln1x3lizz2igi4m1qlhznkq9fws7m";
+       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
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "singletons-base_3_1" = callPackage
+  "singletons-base_3_1_1" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, deepseq, directory
      , filepath, pretty, process, singletons, singletons-th, tasty
      , tasty-golden, template-haskell, text, th-desugar, turtle
      }:
      mkDerivation {
        pname = "singletons-base";
-       version = "3.1";
-       sha256 = "1bsfbdbfwiq2nis3r95x06r0q9iypyz4hkvmgvk56bwj6421k7kd";
-       revision = "1";
-       editedCabalFile = "12p0xzmrkn2bjz6wf9i291bh47s9c0ziz6cvvja65vnzwd8l60ry";
+       version = "3.1.1";
+       sha256 = "0d32c1dmi8mlrli0927g3hy6gip4c9w0myza3x594nlb6cnwdj6f";
        setupHaskellDepends = [ base Cabal directory filepath ];
        libraryHaskellDepends = [
          base pretty singletons singletons-th template-haskell text
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "singletons-th_3_1" = callPackage
+  "singletons-th_3_1_1" = callPackage
     ({ mkDerivation, base, containers, ghc-boot-th, mtl, singletons
      , syb, template-haskell, th-desugar, th-orphans, transformers
      }:
      mkDerivation {
        pname = "singletons-th";
-       version = "3.1";
-       sha256 = "1mhx7sadw7zxaf7qhryrhi4fiyf9v3jcaplkh1syaa7b4725dm7a";
-       revision = "2";
-       editedCabalFile = "19ac6s4k6yv0lfrhkmgpf000k32rpm91lngs4955158792pa6fi6";
+       version = "3.1.1";
+       sha256 = "1bp9abhbk6ad27p0ksqx2nhrkp6r9dgx20dzyl3bq1zf6nz92ss6";
        libraryHaskellDepends = [
          base containers ghc-boot-th mtl singletons syb template-haskell
          th-desugar th-orphans transformers
···
        broken = true;
      }) {};
 
+  "sized-wrapper" = callPackage
+    ({ mkDerivation, base, hspec, hspec-core, hspec-discover }:
+     mkDerivation {
+       pname = "sized-wrapper";
+       version = "0.1.0.0";
+       sha256 = "0y3fbnpps039g0k2r01h0im2ihbnpdb9h6ik912ri73r15mggldm";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec hspec-core hspec-discover ];
+       testToolDepends = [ hspec-discover ];
+       description = "Create a Sized version of any container";
+       license = lib.licenses.isc;
+     }) {};
+
+  "sized-wrapper-aeson" = callPackage
+    ({ mkDerivation, aeson, base, containers, hspec, hspec-core
+     , hspec-discover, sized-wrapper
+     }:
+     mkDerivation {
+       pname = "sized-wrapper-aeson";
+       version = "0.1.0.0";
+       sha256 = "1gymzm9cx3989gpcvphzkam4ndxs54j3pavj46ypm3p8853h1zcn";
+       libraryHaskellDepends = [ aeson base sized-wrapper ];
+       testHaskellDepends = [
+         aeson base containers hspec hspec-core hspec-discover sized-wrapper
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "aeson instances for 'Sized'";
+       license = lib.licenses.isc;
+     }) {};
+
+  "sized-wrapper-quickcheck" = callPackage
+    ({ mkDerivation, base, QuickCheck, sized-wrapper }:
+     mkDerivation {
+       pname = "sized-wrapper-quickcheck";
+       version = "0.1.0.0";
+       sha256 = "1z14v55h1bn2imzwk50xv6cjpa9qm5m0cdp7zkfhh2pw9qw51ibc";
+       libraryHaskellDepends = [ base QuickCheck sized-wrapper ];
+       description = "QuickCheck instance for 'Sized'";
+       license = lib.licenses.isc;
+     }) {};
+
+  "sized-wrapper-text" = callPackage
+    ({ mkDerivation, base, bytestring, sized-wrapper, text }:
+     mkDerivation {
+       pname = "sized-wrapper-text";
+       version = "0.1.0.0";
+       sha256 = "03p68x5nxzpqz5zfkjr8qfhmqr49gy11nyrnh5glrifih66f7ljs";
+       libraryHaskellDepends = [ base bytestring sized-wrapper text ];
+       description = "'Sized' wrappers for text";
+       license = lib.licenses.isc;
+     }) {};
+
   "sizes" = callPackage
     ({ mkDerivation, base, bytestring, cmdargs, deepseq, dlist, lens
      , parallel-io, regex-posix, system-fileio, system-filepath, text
···
     ({ mkDerivation, base, byteorder, bytestring, network }:
      mkDerivation {
        pname = "sockaddr";
-       version = "0.0.0";
-       sha256 = "1h74k5pipv9314y1d2wgpwgvyxfp6pcnq5051fdqr1shqlkpwbs2";
+       version = "0.0.1";
+       sha256 = "0szmfcn2bn76c4c14pb59ll83bwrxg68ybfd142cyqdyv5qy18g4";
        libraryHaskellDepends = [ base byteorder bytestring network ];
        description = "Printing SockAddr";
        license = lib.licenses.bsd3;
···
        pname = "sop-core";
        version = "0.5.0.2";
        sha256 = "0rbj56icbaqlcxx5xwvbx4n4vmyv6cfcv7s45n1fv3drahigvgw7";
+       revision = "1";
+       editedCabalFile = "1p6zyqja021gyndskn1qnj29glqr0hldyhxplnpxz06hz4xqwngz";
        libraryHaskellDepends = [ base deepseq ];
        description = "True Sums of Products";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "spline3" = callPackage
-    ({ mkDerivation, base, cmdargs, doctest, filepath, MissingH, repa
+    ({ mkDerivation, base, cmdargs, doctest, MissingH, repa
      , repa-algorithms, repa-io, tasty, tasty-hunit, tasty-quickcheck
      , vector
      }:
      mkDerivation {
        pname = "spline3";
-       version = "1.0.0";
-       sha256 = "02sj4mqgjakmk24fv8swwr06rpl4idgmwwnjwqf257hzlns6lriw";
+       version = "1.0.1";
+       sha256 = "12jpbzmwixhrd6a67ay7rgqbh61d70ffmcn83k0yl6qqkyn2hqkv";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base cmdargs filepath MissingH repa repa-algorithms repa-io tasty
+         base cmdargs MissingH repa repa-algorithms repa-io tasty
          tasty-hunit tasty-quickcheck vector
        ];
        testHaskellDepends = [
-         base cmdargs doctest filepath MissingH repa repa-algorithms repa-io
-         tasty tasty-hunit tasty-quickcheck vector
+         base doctest repa tasty tasty-hunit tasty-quickcheck vector
        ];
        description = "A parallel implementation of the Sorokina/Zeilfelder spline scheme";
        license = lib.licenses.agpl3Only;
···
        libraryHaskellDepends = [ base containers ghc hlint stm ];
        description = "HLint as a GHC source plugin";
        license = lib.licenses.isc;
+     }) {};
+
+  "splint_1_0_2_1" = callPackage
+    ({ mkDerivation, base, containers, ghc, hlint, stm }:
+     mkDerivation {
+       pname = "splint";
+       version = "1.0.2.1";
+       sha256 = "04887k7ys72gkjkw0l1w3sqxwydk20gvfpl0qfwkrx8xp705710l";
+       libraryHaskellDepends = [ base containers ghc hlint stm ];
+       description = "HLint as a GHC source plugin";
+       license = lib.licenses.isc;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "split" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "srt_0_1_2_0" = callPackage
+    ({ mkDerivation, base, simple-media-timestamp, text }:
+     mkDerivation {
+       pname = "srt";
+       version = "0.1.2.0";
+       sha256 = "0y8aagnc1n2pr4yrq2rj2id031yshi241nfbsrl916i81hw4bcny";
+       libraryHaskellDepends = [ base simple-media-timestamp text ];
+       description = "The data type for SRT files";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "srt-attoparsec" = callPackage
     ({ mkDerivation, attoparsec, base, mtl, simple-media-timestamp
      , simple-media-timestamp-attoparsec, srt, text
···
        pname = "statestack";
        version = "0.3.1";
        sha256 = "0h8kwzf117zb2ffc5phbvlxpgza8h59bjg93ndp7r1ks0jvs5lpr";
+       revision = "1";
+       editedCabalFile = "1bvx9s7zssczqpwwgqw4cgmfdw1wjy0mwqlndjgnkjjn4nm31ml8";
        libraryHaskellDepends = [ base mtl transformers ];
        description = "Simple State-like monad transformer with saveable and restorable state";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, array, base, containers, hashable, primes }:
      mkDerivation {
        pname = "static-hash";
-       version = "0.0.1";
-       sha256 = "0nkgx4s389027zi23wmbc6wqnmplvjvbrsbyzy7zn41mbwmzqz8l";
+       version = "0.0.2";
+       sha256 = "1kp832cxhclairdpha9mhxma52102b7x1clw6cnlxjzmjygbqbk3";
        libraryHaskellDepends = [ array base containers hashable primes ];
        description = "Immutable hash";
        license = lib.licenses.bsd3;
···
        pname = "step-function";
        version = "0.2";
        sha256 = "1mg7zqqs32zdh1x1738kk0yydyksbhx3y3x8n31f7byk5fvzqq6j";
-       revision = "7";
-       editedCabalFile = "0fnzln04c8wvhag730hl3h4wwykizwwg5xzsbw5qd3zzx2fmbywz";
+       revision = "8";
+       editedCabalFile = "0gailvq05bd7ycmhrqr99p653s5nhfhp4ppj0zg7qsvygwcqg2jf";
        libraryHaskellDepends = [
          base base-compat-batteries containers deepseq QuickCheck
        ];
···
      }:
      mkDerivation {
        pname = "streaming-bytestring";
-       version = "0.2.2";
-       sha256 = "01iw8d3lxb72cv6gp6k8w966g9q485zmd5akri2x1n5xdd26lv9h";
+       version = "0.2.3";
+       sha256 = "026fr6415iaxw3fmjjmczs7fiqw8ckzd4vfpp2rh88ismz8j6s7l";
        libraryHaskellDepends = [
          base bytestring deepseq exceptions ghc-prim mmorph mtl resourcet
          streaming transformers transformers-base
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "streaming-bytestring_0_2_3" = callPackage
+  "streaming-bytestring_0_2_4" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, exceptions, ghc-prim
      , mmorph, mtl, resourcet, smallcheck, streaming, tasty, tasty-hunit
      , tasty-smallcheck, transformers, transformers-base
      }:
      mkDerivation {
        pname = "streaming-bytestring";
-       version = "0.2.3";
-       sha256 = "026fr6415iaxw3fmjjmczs7fiqw8ckzd4vfpp2rh88ismz8j6s7l";
+       version = "0.2.4";
+       sha256 = "0iz4h5a1fd9bj2rkpwh5vk37j71frwqlbl2igfyxn4g7irpxipxh";
        libraryHaskellDepends = [
          base bytestring deepseq exceptions ghc-prim mmorph mtl resourcet
          streaming transformers transformers-base
···
        license = lib.licenses.mit;
      }) {};
 
+  "strive_6_0_0_4" = 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.4";
+       sha256 = "1vvv1cc88niciqly68wddpkkly796jyl6hypahyd0rkif53q789l";
+       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 = "structured";
        version = "0.1.1";
        sha256 = "1mz02ys85z79nj24ylsmgh8v2m7zv2rixf7w0iqnwc49lax52w4q";
-       revision = "4";
-       editedCabalFile = "1ayq9nf0bxx960qmdckxjsyhrz4xd6ymp0cf6v3qih13k8ld74hd";
+       revision = "5";
+       editedCabalFile = "1saljgwlag0ajhwqblvb459hw2m0n2dc9w3j50b069grbm6v8dr6";
        libraryHaskellDepends = [
          aeson array base base16-bytestring binary bytestring containers
          hashable scientific tagged text time-compat transformers
···
      }) {};
 
   "sydtest-yesod" = callPackage
-    ({ mkDerivation, base, binary, blaze-builder, bytestring
-     , case-insensitive, conduit, containers, cookie, exceptions
-     , http-client, http-client-tls, http-types, monad-logger, mtl
-     , network, network-uri, persistent, persistent-sqlite
-     , persistent-template, pretty-show, QuickCheck, resourcet, sydtest
-     , sydtest-discover, sydtest-persistent-sqlite, sydtest-wai, text
-     , time, wai, xml-conduit, yesod, yesod-core, yesod-form, yesod-test
+    ({ mkDerivation, base, binary, bytestring, case-insensitive
+     , conduit, containers, cookie, exceptions, http-client
+     , http-client-tls, http-types, monad-logger, mtl, network
+     , network-uri, path, path-io, persistent, persistent-sqlite
+     , QuickCheck, sydtest, sydtest-discover, sydtest-persistent-sqlite
+     , sydtest-wai, text, time, xml-conduit, yesod, yesod-core
+     , yesod-test
      }:
      mkDerivation {
        pname = "sydtest-yesod";
-       version = "0.3.0.0";
-       sha256 = "19pc9yxfw355xvp27i0g1xdlwg8hck8p4y7mnvxrwvwnp911akkf";
+       version = "0.3.0.1";
+       sha256 = "1sfq18n25qczhp24hz95spg4ppigajysg0if5ah0k96k1q3p3f51";
        libraryHaskellDepends = [
-         base binary blaze-builder bytestring case-insensitive containers
-         cookie exceptions http-client http-client-tls http-types mtl
-         network network-uri pretty-show sydtest sydtest-wai text time wai
-         xml-conduit yesod-core yesod-test
+         base binary bytestring case-insensitive containers cookie
+         exceptions http-client http-client-tls http-types mtl network
+         network-uri sydtest sydtest-wai text time xml-conduit yesod-core
+         yesod-test
        ];
        testHaskellDepends = [
          base bytestring conduit cookie http-client http-types monad-logger
-         mtl persistent persistent-sqlite persistent-template QuickCheck
-         resourcet sydtest sydtest-persistent-sqlite text yesod yesod-core
-         yesod-form
+         mtl path path-io persistent persistent-sqlite QuickCheck sydtest
+         sydtest-persistent-sqlite sydtest-wai text yesod yesod-core
        ];
        testToolDepends = [ sydtest-discover ];
        description = "A yesod companion library for sydtest";
···
      }:
      mkDerivation {
        pname = "tasty-autocollect";
-       version = "0.3.0.0";
-       sha256 = "0yk5qfhfnd0lx42bajlr042pj97gljg6ggi8wd2yr0fh4a7gq0gw";
+       version = "0.3.1.0";
+       sha256 = "0cvg7010hxrixpz013fb8ky5jgvvqf3l8x8kiwj0b3a31v8lk82d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base containers directory filepath ghc tasty tasty-expected-failure
-         template-haskell text transformers
+         base bytestring containers directory filepath ghc tasty
+         tasty-expected-failure template-haskell text transformers
        ];
        executableHaskellDepends = [ base text ];
        testHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "tasty-hedgehog_1_2_0_0" = callPackage
+  "tasty-hedgehog_1_3_0_0" = callPackage
     ({ mkDerivation, base, hedgehog, tagged, tasty
      , tasty-expected-failure
      }:
      mkDerivation {
        pname = "tasty-hedgehog";
-       version = "1.2.0.0";
-       sha256 = "0bqaxchadvrgphv46g9fczg8b1gg832n7np3czqribxma6rhsrfd";
+       version = "1.3.0.0";
+       sha256 = "1dk4bcm0a8vl1y5d3c89ypc688rp59fn11hyr2jx5kd8yvpzh0bj";
        libraryHaskellDepends = [ base hedgehog tagged tasty ];
        testHaskellDepends = [
          base hedgehog tasty tasty-expected-failure
···
      }:
      mkDerivation {
        pname = "text-display";
-       version = "0.0.2.0";
-       sha256 = "093sgyn7jpwk6vkvyxb5f3qbf8zrq6xd0pyqs3a6qd9ci4r1k6dl";
+       version = "0.0.3.0";
+       sha256 = "1bkgilcszj4jmixlg9vvmxsd3lcz0gl8d9phpd6lz1vnfyx98ysc";
        libraryHaskellDepends = [ base bytestring text ];
        testHaskellDepends = [
          base bytestring hspec quickcheck-text should-not-typecheck text
        ];
        description = "A typeclass for user-facing output";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "text-format" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "th-desugar_1_13_1" = callPackage
+  "th-desugar_1_14" = callPackage
     ({ mkDerivation, base, containers, ghc-prim, hspec, HUnit, mtl
      , ordered-containers, syb, template-haskell, th-abstraction
      , th-lift, th-orphans, transformers-compat
      }:
      mkDerivation {
        pname = "th-desugar";
-       version = "1.13.1";
-       sha256 = "03k2kfbzfc87kibzbpp3s1l5xb0ww2vvwj9ngh0qapxm28a01rz3";
+       version = "1.14";
+       sha256 = "1b57v15xx0z0xjlijv61dh07p6rvfkdpxnxiaaa1iv7zyg2x7cnz";
        libraryHaskellDepends = [
          base containers ghc-prim mtl ordered-containers syb
          template-haskell th-abstraction th-lift th-orphans
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "th-lift-instances_0_1_20" = callPackage
+    ({ mkDerivation, base, bytestring, containers, QuickCheck
+     , template-haskell, text, th-lift, transformers, vector
+     }:
+     mkDerivation {
+       pname = "th-lift-instances";
+       version = "0.1.20";
+       sha256 = "0w6qc7xzyjymhh8hv72rlszh3n2xyzzamlfcl1hs9k6xbbww6czm";
+       libraryHaskellDepends = [
+         base bytestring containers template-haskell text th-lift
+         transformers vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers QuickCheck template-haskell text vector
+       ];
+       description = "Lift instances for template-haskell for common data types";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "th-nowq" = callPackage
     ({ mkDerivation, base, markdown-unlit, template-haskell, time }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "th-orphans_0_13_14" = 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.14";
+       sha256 = "0z07qcbbsj2b3j9p1qr4jvlpa7qgjfjvymkjd6vbizka1wd2mnwx";
+       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 = "Fork threads and wait for their result";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "threads_0_5_1_7" = callPackage
+    ({ mkDerivation, base, Cabal, concurrent-extra, HUnit, stm
+     , test-framework, test-framework-hunit
+     }:
+     mkDerivation {
+       pname = "threads";
+       version = "0.5.1.7";
+       sha256 = "1l226792dqlp772aaxqr3qzz8yq72702g708k16gi8lrkfhgxxp0";
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [ base stm ];
+       testHaskellDepends = [
+         base concurrent-extra HUnit stm test-framework test-framework-hunit
+       ];
+       description = "Fork threads and wait for their result";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "threads-extras" = callPackage
···
        pname = "time-parsers";
        version = "0.1.2.1";
        sha256 = "102k6l9888kbgng045jk170qjbmdnwv2lbzlc12ncybfk2yk7wdv";
-       revision = "4";
-       editedCabalFile = "04hc42rkk0n9xapiy5zwac4x55m5cc5a8bgnkf6lkd7sy79k1j9k";
+       revision = "5";
+       editedCabalFile = "0dbqqlh98m06qj8jh1fs55lcxj4x4555x4p48xi3bjh5fdg4dkw0";
        libraryHaskellDepends = [ base parsers template-haskell time ];
        testHaskellDepends = [
          attoparsec base bifunctors parsec parsers tasty tasty-hunit
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "topograph_1_0_0_2" = callPackage
+    ({ mkDerivation, base, base-compat, base-orphans, containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "topograph";
+       version = "1.0.0.2";
+       sha256 = "08fpwaf6341gaf7niwss08zlfyf8nvfrc4343zlkhscb19l4b7ni";
+       libraryHaskellDepends = [
+         base base-compat base-orphans containers vector
+       ];
+       description = "Directed acyclic graphs";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "torch" = callPackage
     ({ mkDerivation, base, mtl, parallel, QuickCheck }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "trackit";
-       version = "0.7.2";
-       sha256 = "1ha28wdc4dabr9qxkbpg9fasfnplicb2pyrn9zmija204nigbcdj";
-       revision = "3";
-       editedCabalFile = "07ak29br452qssj5kik8izmny24qw1icz84dq82b5g6xhy31vdrf";
+       version = "0.7.3";
+       sha256 = "0hlndixyvscmf2161yv2f4xl7qy2vgrikik3dj2nbq4vvi6v940v";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        description = "A command-line tool for live monitoring";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "trackit";
+       broken = true;
      }) {};
 
   "traction" = callPackage
···
      }:
      mkDerivation {
        pname = "trasa-form";
-       version = "0.4";
-       sha256 = "0d3fkwvjjwvjzaw5n9n4j4mrrrf8zwrg1882gyqjg0bglsd27xzx";
+       version = "0.4.1";
+       sha256 = "1wz920q7lkibc14hai2ngp81ssp273siynkyxq4d5lan2cvc4dny";
        libraryHaskellDepends = [
          base bytestring cookie ditto ditto-lucid http-api-data http-types
          lucid mtl quantification text trasa trasa-server
···
        benchmarkHaskellDepends = [ base criterion deepseq Diff ];
        description = "Diffing of (expression) trees";
        license = lib.licenses.gpl2Plus;
+     }) {};
+
+  "tree-diff_0_2_2" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, ansi-wl-pprint, base
+     , base-compat, bytestring, bytestring-builder, containers
+     , criterion, deepseq, Diff, hashable, parsec, parsers, pretty
+     , primitive, QuickCheck, scientific, semialign, strict, tagged
+     , tasty, tasty-golden, tasty-quickcheck, text, these, time
+     , trifecta, unordered-containers, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "tree-diff";
+       version = "0.2.2";
+       sha256 = "0g3lsp067dq1ydvj2im4nlfxa65g9zjmjjkv91dhjhnrklir10q0";
+       libraryHaskellDepends = [
+         aeson ansi-terminal ansi-wl-pprint base base-compat bytestring
+         bytestring-builder containers deepseq hashable parsec parsers
+         pretty primitive QuickCheck scientific semialign strict tagged text
+         these time unordered-containers uuid-types vector
+       ];
+       testHaskellDepends = [
+         ansi-terminal ansi-wl-pprint base base-compat parsec primitive
+         QuickCheck tagged tasty tasty-golden tasty-quickcheck trifecta
+       ];
+       benchmarkHaskellDepends = [ base criterion deepseq Diff ];
+       description = "Diffing of (expression) trees";
+       license = lib.licenses.gpl2Plus;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tree-fun" = callPackage
···
      }:
      mkDerivation {
        pname = "tzdata";
-       version = "0.2.20220810.0";
-       sha256 = "0jayyhljnwz7ax4qc7ywlkpsqfm4qkfkbkyl9yc89s6pqnhdg4jd";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base bytestring containers deepseq vector
-       ];
-       testHaskellDepends = [
-         base bytestring HUnit tasty tasty-hunit tasty-th unix
-       ];
-       description = "Time zone database (as files and as a module)";
-       license = lib.licenses.asl20;
-     }) {};
-
-  "tzdata_0_2_20220815_0" = callPackage
-    ({ mkDerivation, base, bytestring, containers, deepseq, HUnit
-     , tasty, tasty-hunit, tasty-th, unix, vector
-     }:
-     mkDerivation {
-       pname = "tzdata";
        version = "0.2.20220815.0";
        sha256 = "0ya7hmq93mmfbiwwsf628b27mahkv525fyjh8r1mg9zwf6pkrhrd";
        enableSeparateDataOutput = true;
···
        ];
        description = "Time zone database (as files and as a module)";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "u2f" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "unix-bytestring_0_3_7_8" = callPackage
+    ({ mkDerivation, base, bytestring }:
+     mkDerivation {
+       pname = "unix-bytestring";
+       version = "0.3.7.8";
+       sha256 = "0x20dzcpmy5qq35fsxiigk4lzad101qkrkckphry2ak0b1ijk4zl";
+       libraryHaskellDepends = [ base bytestring ];
+       description = "Unix/Posix-specific functions for ByteStrings";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "unix-compat" = callPackage
     ({ mkDerivation, base, unix }:
      mkDerivation {
···
 
   "url-bytes" = callPackage
     ({ mkDerivation, base, byteslice, bytesmith, bytestring, deepseq
-     , gauge, HUnit, primitive, tasty, tasty-hunit, template-haskell
-     , uri-bytestring, weigh
+     , dormouse-uri, HUnit, primitive, tasty, tasty-bench, tasty-hunit
+     , template-haskell, uri-bytestring, weigh
      }:
      mkDerivation {
        pname = "url-bytes";
-       version = "0.1.0.0";
-       sha256 = "0nbxnmz1m2icg3vvdndr4zydwr8nbgxhb70ak2jzc6d92c3vhvqi";
+       version = "0.1.1.1";
+       sha256 = "13z9bgl0i49pj5q4cmf1ydr32mn7vijrksgal8f8jvlsax9zwcdj";
        libraryHaskellDepends = [
          base byteslice bytesmith primitive template-haskell
        ];
···
          base byteslice HUnit primitive tasty tasty-hunit
        ];
        benchmarkHaskellDepends = [
-         base byteslice bytestring deepseq gauge primitive uri-bytestring
-         weigh
+         base byteslice bytestring deepseq dormouse-uri primitive
+         tasty-bench uri-bytestring weigh
        ];
        description = "Memory efficient url type and parser";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "uuid-bytes";
-       version = "0.1.2.0";
-       sha256 = "08sfxj0900pgpbvasi2n2x93qwglir2ijc43fpn5xf0gq7z2b25r";
+       version = "0.1.3.0";
+       sha256 = "1771fjcgvds299ls3myqlgricx9nha0dyaiban39g0sga075w00l";
        libraryHaskellDepends = [
          base bytebuild byteslice bytesmith natural-arithmetic primitive
          wide-word
···
        pname = "validated-literals";
        version = "0.3.1";
        sha256 = "0s6ag8wm19qzfhxpz686nsmvrf3lhbq1g5fcck6d97lij559xlvg";
+       revision = "1";
+       editedCabalFile = "1irh3qd5p1pblklsq9v3468m4rjn0waj5x4mdnfksk4c6mrnj0ri";
        libraryHaskellDepends = [ base template-haskell th-compat ];
        testHaskellDepends = [
          base bytestring deepseq tasty tasty-hunit tasty-travis
···
        pname = "vec";
        version = "0.4.1";
        sha256 = "01v5zd4lak76ymlhi3zjpsy3g01vcchwx1b7cavc4rdzpdjqw58b";
+       revision = "1";
+       editedCabalFile = "156w28mz6d1gdp907j14v5xvj5y786h5pi4bfgvri592zwd2p46b";
        libraryHaskellDepends = [
          adjunctions base boring deepseq distributive fin hashable
          indexed-traversable QuickCheck semigroupoids transformers
···
        pname = "vec-lens";
        version = "0.4";
        sha256 = "1qjv8wg6b8wbldvripn84vyw5cgpcpgh2v6v1nk7pzwrn99lfb7h";
-       revision = "1";
-       editedCabalFile = "1708aj1b38cd17fmv6giidq8hdpq96imka8hfr7z1y5nq9bf8am3";
+       revision = "2";
+       editedCabalFile = "0hkwpsfp9v5crmgm2gvrvfi27manyx930v1pd9mp7n64y3brrxqm";
        libraryHaskellDepends = [ base fin lens vec ];
        description = "Vec: length-indexed (sized) list: lens support";
        license = lib.licenses.bsd3;
···
        pname = "vec-optics";
        version = "0.4";
        sha256 = "0vdpxkmhiqbql68rkrfaci6c6n7sbr49p08q0jj6cvbmjy3aa1lg";
-       revision = "1";
-       editedCabalFile = "0bwian3k668nbp7vnawdzzr9sv8vxhfsd3qjyfk9k112w3y2kjfs";
+       revision = "2";
+       editedCabalFile = "0gm2xaxbrr4ha8d7lvgddq3iy5fxzx9g6w62rn7dxswbhdaqnp46";
        libraryHaskellDepends = [ base fin optics-core vec ];
        description = "Vec: length-indexed (sized) list: optics support";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.mit;
      }) {};
 
+  "wai-saml2_0_3_0_1" = callPackage
+    ({ mkDerivation, base, base64-bytestring, bytestring, c14n
+     , cryptonite, data-default-class, filepath, http-types, mtl
+     , pretty-show, tasty, tasty-golden, text, time, vault, wai
+     , wai-extra, x509, x509-store, xml-conduit
+     }:
+     mkDerivation {
+       pname = "wai-saml2";
+       version = "0.3.0.1";
+       sha256 = "1j8qldy111q36dwr53pc6jiljfwzwi77n21mglvkpq4cfkcsch92";
+       libraryHaskellDepends = [
+         base base64-bytestring bytestring c14n cryptonite
+         data-default-class http-types mtl text time vault wai wai-extra
+         x509 x509-store xml-conduit
+       ];
+       testHaskellDepends = [
+         base base64-bytestring bytestring c14n cryptonite
+         data-default-class filepath http-types mtl pretty-show tasty
+         tasty-golden text time vault wai wai-extra x509 x509-store
+         xml-conduit
+       ];
+       description = "SAML2 assertion validation as WAI middleware";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "wai-secure-cookies" = callPackage
     ({ mkDerivation, base, bytestring, cryptonite, hspec
      , hspec-expectations, hspec-wai, http-types, memory, random, split
···
        license = lib.licenses.mpl20;
      }) {};
 
+  "webgear-core_1_0_4" = callPackage
+    ({ mkDerivation, arrows, base, bytestring, case-insensitive
+     , filepath, http-api-data, http-media, http-types, jose, mime-types
+     , network, safe-exceptions, tagged, template-haskell, text
+     , unordered-containers, wai
+     }:
+     mkDerivation {
+       pname = "webgear-core";
+       version = "1.0.4";
+       sha256 = "0ah01znv18ll9lhlwn81yxvdy9q1f0xl2pcy4k24d0blrrva0nl7";
+       libraryHaskellDepends = [
+         arrows base bytestring case-insensitive filepath http-api-data
+         http-media http-types jose mime-types network safe-exceptions
+         tagged template-haskell text unordered-containers wai
+       ];
+       description = "Composable, type-safe library to build HTTP APIs";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "webgear-openapi" = callPackage
     ({ mkDerivation, arrows, base, http-media, http-types
      , insert-ordered-containers, lens, openapi3, text, webgear-core
···
        license = lib.licenses.mpl20;
      }) {};
 
+  "webgear-openapi_1_0_4" = callPackage
+    ({ mkDerivation, arrows, base, http-media, http-types
+     , insert-ordered-containers, lens, openapi3, text, webgear-core
+     }:
+     mkDerivation {
+       pname = "webgear-openapi";
+       version = "1.0.4";
+       sha256 = "0wqgpq77ak4n0phaaq6mlr06krf9xxv4q26h7v8zni0422y01f4i";
+       libraryHaskellDepends = [
+         arrows base http-media http-types insert-ordered-containers lens
+         openapi3 text webgear-core
+       ];
+       description = "Composable, type-safe library to build HTTP API servers";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "webgear-server" = callPackage
     ({ mkDerivation, aeson, arrows, base, base64-bytestring, bytestring
      , bytestring-conversion, http-api-data, http-media, http-types
···
        license = lib.licenses.mpl20;
      }) {};
 
+  "webgear-server_1_0_4" = callPackage
+    ({ mkDerivation, aeson, arrows, base, base64-bytestring, bytestring
+     , bytestring-conversion, http-api-data, http-media, http-types
+     , jose, monad-time, mtl, QuickCheck, quickcheck-instances, tasty
+     , tasty-hunit, tasty-quickcheck, text, unordered-containers, wai
+     , webgear-core
+     }:
+     mkDerivation {
+       pname = "webgear-server";
+       version = "1.0.4";
+       sha256 = "106nfvr9saqpl3ngb3216wfig6fx90yl90vsxk9qjnkzi0dk041y";
+       libraryHaskellDepends = [
+         aeson arrows base base64-bytestring bytestring
+         bytestring-conversion http-api-data http-media http-types jose
+         monad-time mtl text unordered-containers wai webgear-core
+       ];
+       testHaskellDepends = [
+         base base64-bytestring bytestring http-types QuickCheck
+         quickcheck-instances tasty tasty-hunit tasty-quickcheck text wai
+         webgear-core
+       ];
+       description = "Composable, type-safe library to build HTTP API servers";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "webidl" = callPackage
     ({ mkDerivation, base, bytestring, HSFFIG, LEXER, parsec, pretty
      , utf8-env, utf8-string
···
        pname = "windns";
        version = "0.1.0.1";
        sha256 = "016d1cf51jqvhbzlf5kbizv4l4dymradac1420rl47q2k5faczq8";
-       revision = "4";
-       editedCabalFile = "17wzjaj16q4bm8kz2mcs02naj6v89lnbwjfgmrf81c9dw873l9px";
+       revision = "5";
+       editedCabalFile = "0lc90z7z74hqhjxflnyz0znf1iwvybcqvkglry30k9nxg35qpj71";
        libraryHaskellDepends = [ base bytestring deepseq ];
        librarySystemDepends = [ dnsapi ];
        description = "Domain Name Service (DNS) lookup via the <windns.h>/dnsapi.dll standard library";
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
+  "witch_1_0_0_3" = callPackage
+    ({ mkDerivation, base, bytestring, containers, HUnit
+     , template-haskell, text, time
+     }:
+     mkDerivation {
+       pname = "witch";
+       version = "1.0.0.3";
+       sha256 = "1d6wn4ykafq3hi439pf9ap55vjrcv668qq5wmxm5fiq6r78ndn0b";
+       libraryHaskellDepends = [
+         base bytestring containers template-haskell text time
+       ];
+       testHaskellDepends = [
+         base bytestring containers HUnit template-haskell text time
+       ];
+       description = "Convert values from one type into another";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.maralorn ];
+     }) {};
+
   "with-index" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "word-array" = callPackage
+    ({ mkDerivation, base, deepseq, HUnit, mono-traversable, primitive
+     , QuickCheck, quickcheck-classes, tasty, tasty-bench, tasty-hunit
+     , tasty-quickcheck, transformers, vector, weigh
+     }:
+     mkDerivation {
+       pname = "word-array";
+       version = "0.1.0.0";
+       sha256 = "1358a9sihpnrrddzffp3vw8wjrgbs6ff2lmww5yffh0blk7ajlff";
+       libraryHaskellDepends = [ base deepseq mono-traversable ];
+       testHaskellDepends = [
+         base HUnit mono-traversable primitive QuickCheck quickcheck-classes
+         tasty tasty-hunit tasty-quickcheck vector
+       ];
+       benchmarkHaskellDepends = [
+         base deepseq primitive tasty tasty-bench transformers weigh
+       ];
+       description = "treat integral types as arrays of smaller integral types";
+       license = lib.licenses.mit;
+     }) {};
+
   "word-compat" = callPackage
     ({ mkDerivation, base, ghc-prim }:
      mkDerivation {
        pname = "word-compat";
-       version = "0.0.4";
-       sha256 = "1pb1l8qxl7ys6db3wmp9rflqznjl6x11n477x159d920m7h5gz6k";
+       version = "0.0.5";
+       sha256 = "0wllk017f02r1prsvzq1qbcr6w6br2pwii4b8xzr7bqkkri0z6rs";
        libraryHaskellDepends = [ base ghc-prim ];
        testHaskellDepends = [ base ];
        description = "Compatibility shim for the Int/Word internal change in GHC 9.2";
···
      }:
      mkDerivation {
        pname = "wuss";
-       version = "2.0.0.1";
-       sha256 = "17s6wilzyzsdc174a3an12pkq20cy7x2pfrn4jmdp30f468r47fb";
+       version = "2.0.0.2";
+       sha256 = "04jqq3blzyxqyymhcjsm5z89whk5y7cvnd9dw6nlc40vq4w4v802";
        libraryHaskellDepends = [
          base bytestring connection network websockets
        ];
···
        pname = "yasi";
        version = "0.2.0.1";
        sha256 = "0j5g5h40qvz2rinka7mrb8nc7dzhnprdfpjmzc4pdlx1w8fzw8xy";
+       revision = "2";
+       editedCabalFile = "00jc6fgv0r2l91949d9ry094fn45v19kn301hfap5i4n4wks1kmz";
        libraryHaskellDepends = [
          base ghc-hs-meta template-haskell text text-display
        ];
···
        pname = "zinza";
        version = "0.2";
        sha256 = "1sy4chm8zan0ixgvvq4vm3fzvhqykn315l333al84768nly9rjv8";
-       revision = "4";
-       editedCabalFile = "0w4hy234rbgyc0lsaj3sm11vi13hy1aiqqdbq3dgaq6xkmcb4yal";
+       revision = "5";
+       editedCabalFile = "1gkfbm06qpcwy17mlk522wlf7jkxsmqdl33c6ckvwkq2z9diy63a";
        libraryHaskellDepends = [
          base containers parsec text transformers
        ];

pkgs/development/haskell-modules/patches/hevm-update-deps.patch

···
+diff --git a/hevm.cabal b/hevm.cabal
+index cf36961e..3b31f595 100644
+--- a/hevm.cabal
++++ b/hevm.cabal
+@@ -71,6 +71,10 @@ library
+     -Wall -Wno-deprecations
+   extra-libraries:
+     secp256k1, ff
++  if os(darwin)
++     extra-libraries: c++
++  else
++     extra-libraries: stdc++
+   c-sources:
+     ethjet/tinykeccak.c, ethjet/ethjet.c
+   cxx-sources:
+@@ -88,7 +92,7 @@ library
+     transformers                      >= 0.5.6 && < 0.6,
+     tree-view                         >= 0.5 && < 0.6,
+     abstract-par                      >= 0.3.3 && < 0.4,
+-    aeson                             >= 1.5.6 && < 1.6,
++    aeson                             >= 2.0 && < 2.1,
+     bytestring                        >= 0.10.8 && < 0.11,
+     scientific                        >= 0.3.6 && < 0.4,
+     binary                            >= 0.8.6 && < 0.9,
+@@ -97,7 +101,7 @@ library
+     vector                            >= 0.12.1 && < 0.13,
+     ansi-wl-pprint                    >= 0.6.9 && < 0.7,
+     base16-bytestring                 >= 1.0.0 && < 2.0,
+-    brick                             >= 0.58 && < 0.63,
++    brick                             >= 0.58 && < 0.69,
+     megaparsec                        >= 9.0.0 && < 10.0,
+     mtl                               >= 2.2.2 && < 2.3,
+     directory                         >= 1.3.3 && < 1.4,
+@@ -105,13 +109,13 @@ library
+     vty                               >= 5.25.1 && < 5.34,
+     cereal                            >= 0.5.8 && < 0.6,
+     cryptonite                        >= 0.27 && <= 0.29,
+-    memory                            >= 0.14.18 && < 0.16,
++    memory                            >= 0.14.18 && < 0.20,
+     data-dword                        >= 0.3.1 && < 0.4,
+     fgl                               >= 5.7.0 && < 5.8,
+     free                              >= 5.1.3 && < 5.2,
+     haskeline                         >= 0.8.0 && < 0.9,
+     process                           >= 1.6.5 && < 1.7,
+-    lens                              >= 4.17.1 && < 4.20,
++    lens                              >= 4.17.1 && < 5.1,
+     lens-aeson                        >= 1.0.2 && < 1.2,
+     monad-par                         >= 0.3.5 && < 0.4,
+     multiset                          >= 0.3.4 && < 0.4,
+@@ -124,7 +128,6 @@ library
+     sbv                               >= 8.9,
+     semver-range                      >= 0.2.7 && < 0.3,
+     temporary                         >= 1.3 && < 1.4,
+-    text-format                       >= 0.3.2 && < 0.4,
+     witherable                        >= 0.3.5 && < 0.5,
+     wreq                              >= 0.5.3 && < 0.6,
+     regex-tdfa                        >= 1.2.3 && < 1.4,
+@@ -190,7 +193,6 @@ executable hevm
+     sbv,
+     temporary,
+     text,
+-    text-format,
+     unordered-containers,
+     vector,
+     vty
+diff --git a/src/EVM/Solidity.hs b/src/EVM/Solidity.hs
+index b7d0f36b..4e9d6892 100644
+--- a/src/EVM/Solidity.hs
++++ b/src/EVM/Solidity.hs
+@@ -70,6 +70,7 @@ import Control.Monad
+ import Control.Lens         hiding (Indexed, (.=))
+ import qualified Data.String.Here as Here
+ import Data.Aeson hiding (json)
++import qualified Data.Aeson.KeyMap as KeyMap
+ import Data.Aeson.Types
+ import Data.Aeson.Lens
+ import Data.Scientific
+@@ -714,8 +715,8 @@ astIdMap = foldMap f
+     f :: Value -> Map Int Value
+     f (Array x) = foldMap f x
+     f v@(Object x) =
+-      let t = foldMap f (HMap.elems x)
+-      in case HMap.lookup "id" x of
++      let t = foldMap f (KeyMap.elems x)
++      in case KeyMap.lookup "id" x of
+         Nothing         -> t
+         Just (Number i) -> t <> Map.singleton (round i) v
+         Just _          -> t
+diff --git a/src/EVM/SymExec.hs b/src/EVM/SymExec.hs
+index 5bbf1c03..b828098e 100644
+--- a/src/EVM/SymExec.hs
++++ b/src/EVM/SymExec.hs
+@@ -40,8 +40,8 @@ type EquivalenceResult = ProofResult ([VM], [VM]) VM ()
+
+ -- | Convenience functions for generating large symbolic byte strings
+ sbytes32, sbytes128, sbytes256, sbytes512, sbytes1024 :: Query ([SWord 8])
+-sbytes32 = toBytes <$> freshVar_ @ (WordN 256)
+-sbytes128 = toBytes <$> freshVar_ @ (WordN 1024)
++sbytes32 = toBytes <$> freshVar_ @(WordN 256)
++sbytes128 = toBytes <$> freshVar_ @(WordN 1024)
+ sbytes256 = liftA2 (++) sbytes128 sbytes128
+ sbytes512 = liftA2 (++) sbytes256 sbytes256
+ sbytes1024 = liftA2 (++) sbytes512 sbytes512
+diff --git a/src/EVM/Types.hs b/src/EVM/Types.hs
+index fdd2368d..1dc29e83 100644
+--- a/src/EVM/Types.hs
++++ b/src/EVM/Types.hs
+@@ -434,17 +434,17 @@ readN s = fromIntegral (read s :: Integer)
+ readNull :: Read a => a -> String -> a
+ readNull x = fromMaybe x . Text.Read.readMaybe
+
+-wordField :: JSON.Object -> Text -> JSON.Parser W256
++wordField :: JSON.Object -> Key -> JSON.Parser W256
+ wordField x f = ((readNull 0) . Text.unpack)
+                   <$> (x .: f)
+
+-addrField :: JSON.Object -> Text -> JSON.Parser Addr
++addrField :: JSON.Object -> Key -> JSON.Parser Addr
+ addrField x f = (read . Text.unpack) <$> (x .: f)
+
+-addrFieldMaybe :: JSON.Object -> Text -> JSON.Parser (Maybe Addr)
++addrFieldMaybe :: JSON.Object -> Key -> JSON.Parser (Maybe Addr)
+ addrFieldMaybe x f = (Text.Read.readMaybe . Text.unpack) <$> (x .: f)
+
+-dataField :: JSON.Object -> Text -> JSON.Parser ByteString
++dataField :: JSON.Object -> Key -> JSON.Parser ByteString
+ dataField x f = hexText <$> (x .: f)
+
+ toWord512 :: W256 -> Word512

pkgs/development/libraries/libixp/default.nix

···
     hash = "sha256-S25DmXJ7fN0gXLV0IzUdz8hXPTYEHmaSG7Mnli6GQVc=";
   };
 
+  postPatch = lib.optionalString stdenv.cc.isClang ''
+    substituteInPlace mk/ixp.mk \
+      --replace "©" "C "
+  '';
+
   postConfigure = ''
    sed -i -e "s|^PREFIX.*=.*$|PREFIX = $out|" config.mk
   '';
···
   buildInputs = [ txt2tags ];
 
   meta = {
-    broken = stdenv.isDarwin;
     homepage = "https://github.com/0intro/libixp";
     description = "Portable, simple C-language 9P client and server libary";
     maintainers = with lib.maintainers; [ kovirobi ];

pkgs/development/libraries/v8/default.nix

···
 , gn, ninja, python3, glib, pkg-config, icu
 , xcbuild, darwin
 , fetchpatch
+, llvmPackages
+, symlinkJoin
 }:
 
 # Use update.sh to update all checksums.
···
     touch build/config/gclient_args.gni
   '';
 
+  llvmCcAndBintools = symlinkJoin { name = "llvmCcAndBintools"; paths = [ stdenv.cc llvmPackages.llvm ]; };
+
   gnFlags = [
     "use_custom_libcxx=false"
     "is_clang=${lib.boolToString stdenv.cc.isClang}"
···
     # ''custom_toolchain="//build/toolchain/linux/unbundle:default"''
     ''host_toolchain="//build/toolchain/linux/unbundle:default"''
     ''v8_snapshot_toolchain="//build/toolchain/linux/unbundle:default"''
-  ] ++ lib.optional stdenv.cc.isClang ''clang_base_path="${stdenv.cc}"'';
+  ] ++ lib.optional stdenv.cc.isClang ''clang_base_path="${llvmCcAndBintools}"''
+  ++ lib.optional stdenv.isDarwin ''use_lld=false'';
 
   NIX_CFLAGS_COMPILE = "-O2";
   FORCE_MAC_SDK_MIN = stdenv.targetPlatform.sdkVer or "10.12";
···
     python3
   ] ++ lib.optionals stdenv.isDarwin [
     xcbuild
-    darwin.DarwinTools
+    llvmPackages.llvm
     python3.pkgs.setuptools
   ];
   buildInputs = [ glib icu ];
···
     maintainers = with maintainers; [ cstrahan proglodyte matthewbauer ];
     platforms = platforms.unix;
     license = licenses.bsd3;
-    # Fails to build on Darwin, see https://github.com/NixOS/nixpkgs/issues/158076
-    broken = stdenv.isDarwin;
   };
 }

pkgs/development/python-modules/discogs-client/default.nix

···
 
 buildPythonPackage rec {
   pname = "discogs-client";
-  version = "2.3.15";
+  version = "2.4";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "joalla";
     repo = "discogs_client";
     rev = "refs/tags/v${version}";
-    sha256 = "sha256-teI0sbvluwVFmEOL/V1zLNGFVbeM7QzZ9rCOl3+A+aY=";
+    sha256 = "sha256-gGAtRhAg/W0dREhCOmif1XlQ4gldIGQ2hIC8gzifRu8=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/django-extensions/default.nix

···
 
 buildPythonPackage rec {
   pname = "django-extensions";
-  version = "3.2.0";
+  version = "3.2.1";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = "refs/tags/${version}";
-    sha256 = "sha256-jibske9cnOn4FPAGNs2EU1w1huF4dNxHAnOzuKSj3/E=";
+    sha256 = "sha256-i8A/FMba1Lc3IEBzefP3Uu23iGcDGYqo5bNv+u6hKQI=";
   };
 
   postPatch = ''

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

···
 
 buildPythonPackage rec {
   pname = "goodwe";
-  version = "0.2.19";
+  version = "0.2.20";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
     owner = "marcelblijleven";
     repo = pname;
     rev = "refs/tags/v${version}";
-    sha256 = "sha256-H3N0hAJsjBX3pQ2i03r4MRBQQLCXjLhftokZQx0bF80=";
+    sha256 = "sha256-RDd0KR7NjBTlgeQ/E4mnLnB2n4NCPoAt2a62NGdzCZE=";
   };
 
   checkInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "mailchecker";
-  version = "5.0.0";
+  version = "5.0.1";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-d8RG/PSWPHvQy7o9tPLPGrEp0r/Y3JWwWoT3cS4iR38=";
+    hash = "sha256-fJoV/mNImdcTpJC6c2zmYWZCXlBWLOP+5W5Hsmw2yOQ=";
   };
 
   # Module has no tests

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

···
 
 buildPythonPackage rec {
   pname = "nextcord";
-  version = "2.1.0";
+  version = "2.2.0";
 
   format = "setuptools";
 
···
     owner = "nextcord";
     repo = "nextcord";
     rev = "refs/tags/v${version}";
-    hash = "sha256-/M7Wyb1GW6LPWm41jVnhWA6+dyTrdLyJ6pfsMozw5xI=";
+    hash = "sha256-2VlmcldbW+BfQRzOjCsh6r29qzwD+SG8H8arbTDg94k=";
   };
 
   patches = [

pkgs/development/ruby-modules/gem-config/default.nix

···
     buildInputs = [ which v8 python2 ];
     buildFlags = [ "--with-system-v8=true" ];
     dontBuild = false;
+    # The gem includes broken symlinks which are ignored during unpacking, but
+    # then fail during build. Since the content is missing anyway, touching the
+    # files is enough to unblock the build.
+    preBuild = ''
+      touch vendor/depot_tools/cbuildbot vendor/depot_tools/chrome_set_ver vendor/depot_tools/cros_sdk
+    '';
     postPatch = ''
       substituteInPlace ext/libv8/extconf.rb \
         --replace "location = Libv8::Location::Vendor.new" \

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

···
-{ lib, stdenv, fetchurl, bison, buildPackages }:
+{ lib, stdenv, fetchurl, bison, buildPackages, pkgsBuildTarget }:
 
 let
-  mkJam = { meta ? { }, ... } @ args: stdenv.mkDerivation (args // {
+  mkJam = { pname, version, src, meta ? { } }: stdenv.mkDerivation {
+    inherit pname version src;
+
     depsBuildBuild = [ buildPackages.stdenv.cc ];
     nativeBuildInputs = [ bison ];
 
     # Jambase expects ar to have flags.
     preConfigure = ''
       export AR="$AR rc"
+    '';
+
+    # When cross-compiling, we need to set the preprocessor macros
+    # OSMAJOR/OSMINOR/OSPLAT to the values from the target platform, not the
+    # host platform. This looks a little ridiculous because the vast majority of
+    # build tools don't embed target-specific information into their binary, but
+    # in this case we behave more like a compiler than a make(1)-alike.
+    postPatch = lib.optionalString (stdenv.hostPlatform != stdenv.targetPlatform) ''
+      cat >>jam.h <<EOF
+      #undef OSMAJOR
+      #undef OSMINOR
+      #undef OSPLAT
+      $(
+        ${pkgsBuildTarget.targetPackages.stdenv.cc}/bin/${pkgsBuildTarget.targetPackages.stdenv.cc.targetPrefix}cc -E -dM jam.h \
+          | grep -E '^#define (OSMAJOR|OSMINOR|OSPLAT) '
+      )
+      EOF
     '';
 
     LOCATE_TARGET = "bin.unix";
···
 
     enableParallelBuilding = true;
 
-    meta = with lib; meta // {
+    meta = with lib; {
       license = licenses.free;
       mainProgram = "jam";
       platforms = platforms.unix;
-    };
-  });
+    } // meta;
+  };
 in
 {
   jam = let
     pname = "jam";
     version = "2.6.1";
-  in mkJam {
-    inherit pname version;
 
-    src = fetchurl {
-      url = "https://swarm.workshop.perforce.com/projects/perforce_software-jam/download/main/${pname}-${version}.tar";
-      sha256 = "19xkvkpycxfsncxvin6yqrql3x3z9ypc1j8kzls5k659q4kv5rmc";
-    };
+    base = mkJam {
+      inherit pname version;
+
+      src = fetchurl {
+        url = "https://swarm.workshop.perforce.com/projects/perforce_software-jam/download/main/${pname}-${version}.tar";
+        sha256 = "19xkvkpycxfsncxvin6yqrql3x3z9ypc1j8kzls5k659q4kv5rmc";
+      };
 
-    meta = with lib; {
-      description = "Just Another Make";
-      homepage = "https://www.perforce.com/resources/documentation/jam";
-      maintainers = with maintainers; [ impl orivej ];
+      meta = with lib; {
+        description = "Just Another Make";
+        homepage = "https://www.perforce.com/resources/documentation/jam";
+        maintainers = with maintainers; [ impl orivej ];
+      };
     };
-  };
+  in base.overrideAttrs (oldAttrs: {
+    makeFlags = (oldAttrs.makeFlags or []) ++ [
+      "CC=${buildPackages.stdenv.cc.targetPrefix}cc"
+    ];
+  });
 
   ftjam = let
     pname = "ftjam";
     version = "2.5.2";
-  in mkJam {
-    inherit pname version;
 
-    src = fetchurl {
-      url = "https://downloads.sourceforge.net/project/freetype/${pname}/${version}/${pname}-${version}.tar.bz2";
-      hash = "sha256-6JdzUAqSkS3pGOn+v/q+S2vOedaa8ZRDX04DK4ptZqM=";
-    };
+    base = mkJam {
+      inherit pname version;
 
-    postPatch = ''
+      src = fetchurl {
+        url = "https://downloads.sourceforge.net/project/freetype/${pname}/${version}/${pname}-${version}.tar.bz2";
+        hash = "sha256-6JdzUAqSkS3pGOn+v/q+S2vOedaa8ZRDX04DK4ptZqM=";
+      };
+
+      meta = with lib; {
+        description = "FreeType's enhanced, backwards-compatible Jam clone";
+        homepage = "https://freetype.org/jam/";
+        maintainers = with maintainers; [ AndersonTorres impl ];
+      };
+    };
+  in base.overrideAttrs (oldAttrs: {
+    postPatch = (oldAttrs.postPatch or "") + ''
       substituteInPlace Jamfile --replace strip ${stdenv.cc.targetPrefix}strip
     '';
 
     # Doesn't understand how to cross compile once bootstrapped, so we'll just
     # use the Makefile for the bootstrapping portion.
     configurePlatforms = [ "build" "target" ];
-    configureFlags = [
+    configureFlags = (oldAttrs.configureFlags or []) ++ [
       "CC=${buildPackages.stdenv.cc.targetPrefix}cc"
       "--host=${stdenv.buildPlatform.config}"
     ];
-
-    meta = with lib; {
-      description = "FreeType's enhanced, backwards-compatible Jam clone";
-      homepage = "https://freetype.org/jam/";
-      maintainers = with maintainers; [ AndersonTorres impl ];
-    };
-  };
+  });
 }

pkgs/development/tools/json2tsv/default.nix

···
+{ lib, stdenv, fetchurl }:
+
+stdenv.mkDerivation rec {
+  pname = "json2tsv";
+  version = "1.0";
+
+  src = fetchurl {
+    url = "https://codemadness.org/releases/json2tsv/json2tsv-${version}.tar.gz";
+    hash = "sha256-BOamDWszYDqKGdKOlAOLY7F9ScZaBJXNdhz38iYW3ps=";
+  };
+
+  postPatch = ''
+    substituteInPlace jaq --replace "json2tsv" "$out/bin/json2tsv"
+  '';
+
+  makeFlags = [ "RANLIB:=$(RANLIB)" ];
+
+  installFlags = [ "PREFIX=$(out)" ];
+
+  meta = with lib; {
+    description = "JSON to TSV converter";
+    homepage = "https://codemadness.org/json2tsv.html";
+    license = licenses.isc;
+    maintainers = with maintainers; [ sikmir ];
+    platforms = platforms.unix;
+  };
+}

pkgs/os-specific/linux/kernel/genksyms-fix-segfault.patch

···
-diff --git a/scripts/genksyms/genksyms.c b/scripts/genksyms/genksyms.c
-index 88632df..ba6cfa9 100644
---- a/scripts/genksyms/genksyms.c
-+++ b/scripts/genksyms/genksyms.c
-@@ -233,11 +233,11 @@ static struct symbol *__add_symbol(const char *name, enum symbol_type type,
- 		free_list(last_enum_expr, NULL);
- 		last_enum_expr = NULL;
- 		enum_counter = 0;
--		if (!name)
--			/* Anonymous enum definition, nothing more to do */
--			return NULL;
- 	}
- 
-+	if (!name)
-+		return NULL;
-+
- 	h = crc32(name) % HASH_BUCKETS;
- 	for (sym = symtab[h]; sym; sym = sym->hash_next) {
- 		if (map_to_ns(sym->type) == map_to_ns(type) &&

pkgs/os-specific/linux/kernel/mac-nvme-t2.patch

···
-diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c
-index dd10cf78f2d3..8f006638452b 100644
---- a/drivers/nvme/host/pci.c
-+++ b/drivers/nvme/host/pci.c
-@@ -28,8 +28,8 @@
- #include "trace.h"
- #include "nvme.h"
- 
--#define SQ_SIZE(depth)		(depth * sizeof(struct nvme_command))
--#define CQ_SIZE(depth)		(depth * sizeof(struct nvme_completion))
-+#define SQ_SIZE(q)	((q)->q_depth * sizeof(struct nvme_command))
-+#define CQ_SIZE(q)	((q)->q_depth * sizeof(struct nvme_completion))
- 
- #define SGES_PER_PAGE	(PAGE_SIZE / sizeof(struct nvme_sgl_desc))
- 
-@@ -1344,16 +1344,16 @@ static enum blk_eh_timer_return nvme_timeout(struct request *req, bool reserved)
- 
- static void nvme_free_queue(struct nvme_queue *nvmeq)
- {
--	dma_free_coherent(nvmeq->dev->dev, CQ_SIZE(nvmeq->q_depth),
-+	dma_free_coherent(nvmeq->dev->dev, CQ_SIZE(nvmeq),
- 				(void *)nvmeq->cqes, nvmeq->cq_dma_addr);
- 	if (!nvmeq->sq_cmds)
- 		return;
- 
- 	if (test_and_clear_bit(NVMEQ_SQ_CMB, &nvmeq->flags)) {
- 		pci_free_p2pmem(to_pci_dev(nvmeq->dev->dev),
--				nvmeq->sq_cmds, SQ_SIZE(nvmeq->q_depth));
-+				nvmeq->sq_cmds, SQ_SIZE(nvmeq));
- 	} else {
--		dma_free_coherent(nvmeq->dev->dev, SQ_SIZE(nvmeq->q_depth),
-+		dma_free_coherent(nvmeq->dev->dev, SQ_SIZE(nvmeq),
- 				nvmeq->sq_cmds, nvmeq->sq_dma_addr);
- 	}
- }
-@@ -1433,12 +1433,12 @@ static int nvme_cmb_qdepth(struct nvme_dev *dev, int nr_io_queues,
- }
- 
- static int nvme_alloc_sq_cmds(struct nvme_dev *dev, struct nvme_queue *nvmeq,
--				int qid, int depth)
-+				int qid)
- {
- 	struct pci_dev *pdev = to_pci_dev(dev->dev);
- 
- 	if (qid && dev->cmb_use_sqes && (dev->cmbsz & NVME_CMBSZ_SQS)) {
--		nvmeq->sq_cmds = pci_alloc_p2pmem(pdev, SQ_SIZE(depth));
-+		nvmeq->sq_cmds = pci_alloc_p2pmem(pdev, SQ_SIZE(nvmeq));
- 		if (nvmeq->sq_cmds) {
- 			nvmeq->sq_dma_addr = pci_p2pmem_virt_to_bus(pdev,
- 							nvmeq->sq_cmds);
-@@ -1447,11 +1447,11 @@ static int nvme_alloc_sq_cmds(struct nvme_dev *dev, struct nvme_queue *nvmeq,
- 				return 0;
- 			}
- 
--			pci_free_p2pmem(pdev, nvmeq->sq_cmds, SQ_SIZE(depth));
-+			pci_free_p2pmem(pdev, nvmeq->sq_cmds, SQ_SIZE(nvmeq));
- 		}
- 	}
- 
--	nvmeq->sq_cmds = dma_alloc_coherent(dev->dev, SQ_SIZE(depth),
-+	nvmeq->sq_cmds = dma_alloc_coherent(dev->dev, SQ_SIZE(nvmeq),
- 				&nvmeq->sq_dma_addr, GFP_KERNEL);
- 	if (!nvmeq->sq_cmds)
- 		return -ENOMEM;
-@@ -1465,12 +1465,13 @@ static int nvme_alloc_queue(struct nvme_dev *dev, int qid, int depth)
- 	if (dev->ctrl.queue_count > qid)
- 		return 0;
- 
--	nvmeq->cqes = dma_alloc_coherent(dev->dev, CQ_SIZE(depth),
-+	nvmeq->q_depth = depth;
-+	nvmeq->cqes = dma_alloc_coherent(dev->dev, CQ_SIZE(nvmeq),
- 					 &nvmeq->cq_dma_addr, GFP_KERNEL);
- 	if (!nvmeq->cqes)
- 		goto free_nvmeq;
- 
--	if (nvme_alloc_sq_cmds(dev, nvmeq, qid, depth))
-+	if (nvme_alloc_sq_cmds(dev, nvmeq, qid))
- 		goto free_cqdma;
- 
- 	nvmeq->dev = dev;
-@@ -1479,15 +1480,14 @@ static int nvme_alloc_queue(struct nvme_dev *dev, int qid, int depth)
- 	nvmeq->cq_head = 0;
- 	nvmeq->cq_phase = 1;
- 	nvmeq->q_db = &dev->dbs[qid * 2 * dev->db_stride];
--	nvmeq->q_depth = depth;
- 	nvmeq->qid = qid;
- 	dev->ctrl.queue_count++;
- 
- 	return 0;
- 
-  free_cqdma:
--	dma_free_coherent(dev->dev, CQ_SIZE(depth), (void *)nvmeq->cqes,
--							nvmeq->cq_dma_addr);
-+	dma_free_coherent(dev->dev, CQ_SIZE(nvmeq), (void *)nvmeq->cqes,
-+			  nvmeq->cq_dma_addr);
-  free_nvmeq:
- 	return -ENOMEM;
- }
-@@ -1515,7 +1515,7 @@ static void nvme_init_queue(struct nvme_queue *nvmeq, u16 qid)
- 	nvmeq->cq_head = 0;
- 	nvmeq->cq_phase = 1;
- 	nvmeq->q_db = &dev->dbs[qid * 2 * dev->db_stride];
--	memset((void *)nvmeq->cqes, 0, CQ_SIZE(nvmeq->q_depth));
-+	memset((void *)nvmeq->cqes, 0, CQ_SIZE(nvmeq));
- 	nvme_dbbuf_init(dev, nvmeq, qid);
- 	dev->online_queues++;
- 	wmb(); /* ensure the first interrupt sees the initialization */
-diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
-index cc09b81fc7f4..716ebe87a2b8 100644
---- a/drivers/nvme/host/core.c
-+++ b/drivers/nvme/host/core.c
-@@ -1986,6 +1986,7 @@ int nvme_enable_ctrl(struct nvme_ctrl *ctrl, u64 cap)
- 	ctrl->ctrl_config = NVME_CC_CSS_NVM;
- 	ctrl->ctrl_config |= (page_shift - 12) << NVME_CC_MPS_SHIFT;
- 	ctrl->ctrl_config |= NVME_CC_AMS_RR | NVME_CC_SHN_NONE;
-+	/* Use default IOSQES. We'll update it later if needed */
- 	ctrl->ctrl_config |= NVME_CC_IOSQES | NVME_CC_IOCQES;
- 	ctrl->ctrl_config |= NVME_CC_ENABLE;
- 
-@@ -2698,6 +2699,30 @@ int nvme_init_identify(struct nvme_ctrl *ctrl)
- 		ctrl->hmmin = le32_to_cpu(id->hmmin);
- 		ctrl->hmminds = le32_to_cpu(id->hmminds);
- 		ctrl->hmmaxd = le16_to_cpu(id->hmmaxd);
-+
-+		/* Grab required IO queue size */
-+		ctrl->iosqes = id->sqes & 0xf;
-+		if (ctrl->iosqes < NVME_NVM_IOSQES) {
-+			dev_err(ctrl->device,
-+				"unsupported required IO queue size %d\n", ctrl->iosqes);
-+			ret = -EINVAL;
-+			goto out_free;
-+		}
-+		/*
-+		 * If our IO queue size isn't the default, update the setting
-+		 * in CC:IOSQES.
-+		 */
-+		if (ctrl->iosqes != NVME_NVM_IOSQES) {
-+			ctrl->ctrl_config &= ~(0xfu << NVME_CC_IOSQES_SHIFT);
-+			ctrl->ctrl_config |= ctrl->iosqes << NVME_CC_IOSQES_SHIFT;
-+			ret = ctrl->ops->reg_write32(ctrl, NVME_REG_CC,
-+						     ctrl->ctrl_config);
-+			if (ret) {
-+				dev_err(ctrl->device,
-+					"error updating CC register\n");
-+				goto out_free;
-+			}
-+		}
- 	}
- 
- 	ret = nvme_mpath_init(ctrl, id);
-diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h
-index 716a876119c8..34ef35fcd8a5 100644
---- a/drivers/nvme/host/nvme.h
-+++ b/drivers/nvme/host/nvme.h
-@@ -244,6 +244,7 @@ struct nvme_ctrl {
- 	u32 hmmin;
- 	u32 hmminds;
- 	u16 hmmaxd;
-+	u8 iosqes;
- 
- 	/* Fabrics only */
- 	u16 sqsize;
-diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c
-index 8f006638452b..54b35ea4af88 100644
---- a/drivers/nvme/host/pci.c
-+++ b/drivers/nvme/host/pci.c
-@@ -28,7 +28,7 @@
- #include "trace.h"
- #include "nvme.h"
- 
--#define SQ_SIZE(q)	((q)->q_depth * sizeof(struct nvme_command))
-+#define SQ_SIZE(q)	((q)->q_depth << (q)->sqes)
- #define CQ_SIZE(q)	((q)->q_depth * sizeof(struct nvme_completion))
- 
- #define SGES_PER_PAGE	(PAGE_SIZE / sizeof(struct nvme_sgl_desc))
-@@ -162,7 +162,7 @@ static inline struct nvme_dev *to_nvme_dev(struct nvme_ctrl *ctrl)
- struct nvme_queue {
- 	struct nvme_dev *dev;
- 	spinlock_t sq_lock;
--	struct nvme_command *sq_cmds;
-+	void *sq_cmds;
- 	 /* only used for poll queues: */
- 	spinlock_t cq_poll_lock ____cacheline_aligned_in_smp;
- 	volatile struct nvme_completion *cqes;
-@@ -178,6 +178,7 @@ struct nvme_queue {
- 	u16 last_cq_head;
- 	u16 qid;
- 	u8 cq_phase;
-+	u8 sqes;
- 	unsigned long flags;
- #define NVMEQ_ENABLED		0
- #define NVMEQ_SQ_CMB		1
-@@ -488,7 +489,8 @@ static void nvme_submit_cmd(struct nvme_queue *nvmeq, struct nvme_command *cmd,
- 			    bool write_sq)
- {
- 	spin_lock(&nvmeq->sq_lock);
--	memcpy(&nvmeq->sq_cmds[nvmeq->sq_tail], cmd, sizeof(*cmd));
-+	memcpy(nvmeq->sq_cmds + (nvmeq->sq_tail << nvmeq->sqes),
-+	       cmd, sizeof(*cmd));
- 	if (++nvmeq->sq_tail == nvmeq->q_depth)
- 		nvmeq->sq_tail = 0;
- 	nvme_write_sq_db(nvmeq, write_sq);
-@@ -1465,6 +1467,7 @@ static int nvme_alloc_queue(struct nvme_dev *dev, int qid, int depth)
- 	if (dev->ctrl.queue_count > qid)
- 		return 0;
- 
-+	nvmeq->sqes = qid ? dev->ctrl.iosqes : NVME_NVM_ADMSQES;
- 	nvmeq->q_depth = depth;
- 	nvmeq->cqes = dma_alloc_coherent(dev->dev, CQ_SIZE(nvmeq),
- 					 &nvmeq->cq_dma_addr, GFP_KERNEL);
-diff --git a/include/linux/nvme.h b/include/linux/nvme.h
-index 01aa6a6c241d..7af18965fb57 100644
---- a/include/linux/nvme.h
-+++ b/include/linux/nvme.h
-@@ -141,6 +141,7 @@ enum {
-  * (In bytes and specified as a power of two (2^n)).
-  */
- #define NVME_NVM_IOSQES		6
-+#define NVME_NVM_ADMSQES	6
- #define NVME_NVM_IOCQES		4
- 
- enum {
-diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
-index 716ebe87a2b8..480ea24d8cf4 100644
---- a/drivers/nvme/host/core.c
-+++ b/drivers/nvme/host/core.c
-@@ -2701,7 +2701,10 @@ int nvme_init_identify(struct nvme_ctrl *ctrl)
- 		ctrl->hmmaxd = le16_to_cpu(id->hmmaxd);
- 
- 		/* Grab required IO queue size */
--		ctrl->iosqes = id->sqes & 0xf;
-+		if (ctrl->quirks & NVME_QUIRK_128_BYTES_SQES)
-+			ctrl->iosqes = 7;
-+		else
-+			ctrl->iosqes = id->sqes & 0xf;
- 		if (ctrl->iosqes < NVME_NVM_IOSQES) {
- 			dev_err(ctrl->device,
- 				"unsupported required IO queue size %d\n", ctrl->iosqes);
-diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h
-index 34ef35fcd8a5..b2a78d08b984 100644
---- a/drivers/nvme/host/nvme.h
-+++ b/drivers/nvme/host/nvme.h
-@@ -92,6 +92,16 @@ enum nvme_quirks {
- 	 * Broken Write Zeroes.
- 	 */
- 	NVME_QUIRK_DISABLE_WRITE_ZEROES		= (1 << 9),
-+
-+	/*
-+	 * Use only one interrupt vector for all queues
-+	 */
-+	NVME_QUIRK_SINGLE_VECTOR		= (1 << 10),
-+
-+	/*
-+	 * Use non-standard 128 bytes SQEs.
-+	 */
-+	NVME_QUIRK_128_BYTES_SQES		= (1 << 11),
- };
- 
- /*
-diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c
-index 54b35ea4af88..ab2358137419 100644
---- a/drivers/nvme/host/pci.c
-+++ b/drivers/nvme/host/pci.c
-@@ -2080,6 +2080,9 @@ static int nvme_setup_irqs(struct nvme_dev *dev, unsigned int nr_io_queues)
- 	dev->io_queues[HCTX_TYPE_DEFAULT] = 1;
- 	dev->io_queues[HCTX_TYPE_READ] = 0;
- 
-+	if (dev->ctrl.quirks & NVME_QUIRK_SINGLE_VECTOR)
-+		irq_queues = 1;
-+
- 	return pci_alloc_irq_vectors_affinity(pdev, 1, irq_queues,
- 			      PCI_IRQ_ALL_TYPES | PCI_IRQ_AFFINITY, &affd);
- }
-@@ -3037,6 +3040,9 @@ static const struct pci_device_id nvme_id_table[] = {
- 	{ PCI_DEVICE_CLASS(PCI_CLASS_STORAGE_EXPRESS, 0xffffff) },
- 	{ PCI_DEVICE(PCI_VENDOR_ID_APPLE, 0x2001) },
- 	{ PCI_DEVICE(PCI_VENDOR_ID_APPLE, 0x2003) },
-+	{ PCI_DEVICE(PCI_VENDOR_ID_APPLE, 0x2005),
-+		.driver_data = NVME_QUIRK_SINGLE_VECTOR |
-+				NVME_QUIRK_128_BYTES_SQES },
- 	{ 0, }
- };
- MODULE_DEVICE_TABLE(pci, nvme_id_table);

pkgs/os-specific/linux/kernel/p9-fixes.patch

···
-diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
---- a/fs/9p/vfs_inode.c
-+++ b/fs/9p/vfs_inode.c
-@@ -483,6 +483,9 @@ static int v9fs_test_inode(struct inode *inode, void *data)
- 
- 	if (v9inode->qid.type != st->qid.type)
- 		return 0;
-+
-+	if (v9inode->qid.path != st->qid.path)
-+		return 0;
- 	return 1;
- }
- 
-diff --git a/fs/9p/vfs_inode_dotl.c b/fs/9p/vfs_inode_dotl.c
---- a/fs/9p/vfs_inode_dotl.c
-+++ b/fs/9p/vfs_inode_dotl.c
-@@ -87,6 +87,9 @@ static int v9fs_test_inode_dotl(struct inode *inode, void *data)
- 
- 	if (v9inode->qid.type != st->qid.type)
- 		return 0;
-+
-+	if (v9inode->qid.path != st->qid.path)
-+		return 0;
- 	return 1;
- }
- 
-diff --git a/net/9p/client.c b/net/9p/client.c
-index 3ce672af1596..f1c8ad373f90 100644
---- a/net/9p/client.c
-+++ b/net/9p/client.c
-@@ -749,8 +749,7 @@ p9_client_rpc(struct p9_client *c, int8_t type, const char *fmt, ...)
- 	}
- again:
- 	/* Wait for the response */
--	err = wait_event_interruptible(*req->wq,
--				       req->status >= REQ_STATUS_RCVD);
-+	err = wait_event_killable(*req->wq, req->status >= REQ_STATUS_RCVD);
- 
- 	/*
- 	 * Make sure our req is coherent with regard to updates in other
-diff --git a/net/9p/trans_virtio.c b/net/9p/trans_virtio.c
-index f24b25c25106..f3a4efcf1456 100644
---- a/net/9p/trans_virtio.c
-+++ b/net/9p/trans_virtio.c
-@@ -286,8 +286,8 @@ p9_virtio_request(struct p9_client *client, struct p9_req_t *req)
- 		if (err == -ENOSPC) {
- 			chan->ring_bufs_avail = 0;
- 			spin_unlock_irqrestore(&chan->lock, flags);
--			err = wait_event_interruptible(*chan->vc_wq,
--							chan->ring_bufs_avail);
-+			err = wait_event_killable(*chan->vc_wq,
-+						  chan->ring_bufs_avail);
- 			if (err  == -ERESTARTSYS)
- 				return err;
- 
-@@ -327,7 +327,7 @@ static int p9_get_mapped_pages(struct virtio_chan *chan,
- 		 * Other zc request to finish here
- 		 */
- 		if (atomic_read(&vp_pinned) >= chan->p9_max_pages) {
--			err = wait_event_interruptible(vp_wq,
-+			err = wait_event_killable(vp_wq,
- 			      (atomic_read(&vp_pinned) < chan->p9_max_pages));
- 			if (err == -ERESTARTSYS)
- 				return err;
-@@ -471,8 +471,8 @@ p9_virtio_zc_request(struct p9_client *client, struct p9_req_t *req,
- 		if (err == -ENOSPC) {
- 			chan->ring_bufs_avail = 0;
- 			spin_unlock_irqrestore(&chan->lock, flags);
--			err = wait_event_interruptible(*chan->vc_wq,
--						       chan->ring_bufs_avail);
-+			err = wait_event_killable(*chan->vc_wq,
-+						  chan->ring_bufs_avail);
- 			if (err  == -ERESTARTSYS)
- 				goto err_out;
- 
-@@ -489,8 +489,7 @@ p9_virtio_zc_request(struct p9_client *client, struct p9_req_t *req,
- 	virtqueue_kick(chan->vq);
- 	spin_unlock_irqrestore(&chan->lock, flags);
- 	p9_debug(P9_DEBUG_TRANS, "virtio request kicked\n");
--	err = wait_event_interruptible(*req->wq,
--				       req->status >= REQ_STATUS_RCVD);
-+	err = wait_event_killable(*req->wq, req->status >= REQ_STATUS_RCVD);
- 	/*
- 	 * Non kernel buffers are pinned, unpin them
- 	 */

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

···
       patch = ./request-key-helper-updated.patch;
     };
 
-  p9_fixes =
-    { name = "p9-fixes";
-      patch = ./p9-fixes.patch;
-    };
-
   modinst_arg_list_too_long =
     { name = "modinst-arglist-too-long";
       patch = ./modinst-arg-list-too-long.patch;
     };
 
-  genksyms_fix_segfault =
-    { name = "genksyms-fix-segfault";
-      patch = ./genksyms-fix-segfault.patch;
-    };
-
   cpu-cgroup-v2 = import ./cpu-cgroup-v2-patches;
 
   hardened = let
···
     patches = lib.importJSON ./hardened/patches.json;
   in lib.mapAttrs mkPatch patches;
 
-  # https://bugzilla.kernel.org/show_bug.cgi?id=197591#c6
-  iwlwifi_mvm_support_version_7_scan_req_umac_fw_command = rec {
-    name = "iwlwifi_mvm_support_version_7_scan_req_umac_fw_command";
-    patch = fetchpatch {
-      name = name + ".patch";
-      url = "https://bugzilla.kernel.org/attachment.cgi?id=260597";
-      sha256 = "09096npxpgvlwdz3pb3m9brvxh7vy0xc9z9p8hh85xyczyzcsjhr";
-    };
-  };
-
-  # https://github.com/NixOS/nixpkgs/issues/42755
-  xen-netfront_fix_mismatched_rtnl_unlock = rec {
-    name = "xen-netfront_fix_mismatched_rtnl_unlock";
-    patch = fetchpatch {
-      name = name + ".patch";
-      url = "https://github.com/torvalds/linux/commit/cb257783c2927b73614b20f915a91ff78aa6f3e8.patch";
-      sha256 = "0xhblx2j8wi3kpnfpgjjwlcwdry97ji2aaq54r3zirk5g5p72zs8";
-    };
-  };
-
-  # https://github.com/NixOS/nixpkgs/issues/42755
-  xen-netfront_update_features_after_registering_netdev = rec {
-    name = "xen-netfront_update_features_after_registering_netdev";
-    patch = fetchpatch {
-      name = name + ".patch";
-      url = "https://github.com/torvalds/linux/commit/45c8184c1bed1ca8a7f02918552063a00b909bf5.patch";
-      sha256 = "1l8xq02rd7vakxg52xm9g4zng0ald866rpgm8kjlh88mwwyjkrwv";
-    };
-  };
-
   # Adapted for Linux 5.4 from:
   # https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=04896832c94aae4842100cafb8d3a73e1bed3a45
   rtl8761b_support =
···
   export-rt-sched-migrate = {
     name = "export-rt-sched-migrate";
     patch = ./export-rt-sched-migrate.patch;
-  };
-
-  # patches from https://lkml.org/lkml/2019/7/15/1748
-  mac_nvme_t2 = rec {
-    name = "mac_nvme_t2";
-    patch = ./mac-nvme-t2.patch;
   };
 }

pkgs/tools/package-management/nix-prefetch/default.nix

···
-{ lib, stdenv, fetchFromGitHub, installShellFiles, makeWrapper, asciidoc
+{ lib, stdenv, fetchFromGitHub, fetchpatch, installShellFiles, makeWrapper, asciidoc
 , docbook_xml_dtd_45, git, docbook_xsl, libxml2, libxslt, coreutils, gawk
 , gnugrep, gnused, jq, nix }:
 
···
       echo $(stat -c %Y $out) > $out/.timestamp
     '';
   };
+
+  patches = [
+    (fetchpatch {
+      name = "fix-prefetching-hash-key.patch";
+      url = "https://github.com/msteen/nix-prefetch/commit/877f80ac7e91d684857e2c940cdb3c423efa1833.patch";
+      hash = "sha256-nkVQ2c+zezPQBOCDeMg+GHW3uz9EBnHIT+ZafdC8nQQ=";
+    })
+  ];
 
   postPatch = ''
     lib=$out/lib/${pname}

pkgs/tools/security/echidna/default.nix

···
 { lib
-, fetchpatch
 , fetchFromGitHub
 # Haskell deps
 , mkDerivation, aeson, ansi-terminal, base, base16-bytestring, binary, brick
···
 , MonadRandom, mtl, optparse-applicative, process, random, stm, tasty
 , tasty-hunit, tasty-quickcheck, temporary, text, transformers , unix, unliftio
 , unliftio-core, unordered-containers, vector, vector-instances, vty
-, wl-pprint-annotated, word8, yaml , extra, ListLike, semver
+, wl-pprint-annotated, word8, yaml, extra, ListLike, semver
 }:
 mkDerivation rec {
   pname = "echidna";
-  version = "1.7.3";
+  version = "2.0.2";
 
   src = fetchFromGitHub {
     owner = "crytic";
     repo = "echidna";
     rev = "v${version}";
-    sha256 = "sha256-NkAAXYa1bbCNUO0eDM7LQbyC3//RRFAKmEHGH2Dhl/M=";
+    sha256 = "sha256-WmlQWgn4qfRmx3PdzY7wzT9AyU7Re2T1CWJ7yGjcVac=";
   };
+
+  # NOTE: echidna is behind with aeson because of hevm, this patch updates
+  # the code to work with the major aeson update that broke the build
+  # it's temporary until hevm version 0.50.0 is released - https://github.com/ethereum/hevm/milestone/1
+  patches = [ ./echidna-update-aeson.patch ];
 
   isLibrary = true;
   isExecutable = true;
···
   license = lib.licenses.agpl3Plus;
   maintainers = with lib.maintainers; [ arturcygan ];
   platforms = lib.platforms.unix;
+  mainProgram = "echidna-test";
 }

pkgs/tools/security/echidna/echidna-update-aeson.patch

···
+diff --git a/lib/Echidna/Config.hs b/lib/Echidna/Config.hs
+index f8d5777..3d761fe 100644
+--- a/lib/Echidna/Config.hs
++++ b/lib/Echidna/Config.hs
+@@ -13,8 +13,8 @@ import Control.Monad.State (StateT(..), runStateT)
+ import Control.Monad.Trans (lift)
+ import Data.Bool (bool)
+ import Data.Aeson
++import Data.Aeson.KeyMap (keys)
+ import Data.Has (Has(..))
+-import Data.HashMap.Strict (keys)
+ import Data.HashSet (fromList, insert, difference)
+ import Data.Maybe (fromMaybe)
+ import Data.Text (isPrefixOf)
+@@ -23,11 +23,13 @@ import EVM.Types (w256)
+ 
+ import qualified Control.Monad.Fail as M (MonadFail(..))
+ import qualified Data.ByteString as BS
++import qualified Data.Aeson.Key as Key
++import qualified Data.HashSet as HS
+ import qualified Data.List.NonEmpty as NE
+ import qualified Data.Yaml as Y
+ 
+ import Echidna.Test
+-import Echidna.Types.Campaign 
++import Echidna.Types.Campaign
+ import Echidna.Mutator.Corpus (defaultMutationConsts)
+ import Echidna.Types.Config (EConfigWithUsage(..), EConfig(..))
+ import Echidna.Types.Solidity
+@@ -52,7 +54,7 @@ instance FromJSON EConfigWithUsage where
+                   _        -> mempty
+     (c, ks) <- runStateT (parser v') $ fromList []
+     let found = fromList (keys v')
+-    return $ EConfigWithUsage c (found `difference` ks) (ks `difference` found)
++    return $ EConfigWithUsage c (HS.map Key.toText $ found `difference` ks) (HS.map Key.toText $ ks `difference` found)
+     -- this parser runs in StateT and comes equipped with the following
+     -- equivalent unary operators:
+     -- x .:? k (Parser) <==> x ..:? k (StateT)

pkgs/top-level/all-packages.nix

···
     inherit (darwin) libobjc;
   };
   defaultGemConfig = callPackage ../development/ruby-modules/gem-config {
-    # recent v8 doesn't build on nixpkgs Darwin yet. https://github.com/NixOS/nixpkgs/issues/158076
-    v8 = if stdenv.isDarwin then v8_8_x else v8;
     inherit (darwin) DarwinTools cctools;
     inherit (darwin.apple_sdk.frameworks) CoreServices;
   };
···
   msitools = callPackage ../development/tools/misc/msitools { };
 
   haskell-ci = haskell.lib.compose.justStaticExecutables haskellPackages.haskell-ci;
-  haskell-ci-unstable = lowPrio (haskell.lib.compose.justStaticExecutables haskellPackages.haskell-ci-unstable);
 
   neoload = callPackage ../development/tools/neoload {
     licenseAccepted = (config.neoload.accept_license or false);
···
 
   json2hcl = callPackage ../development/tools/json2hcl { };
 
+  json2tsv = callPackage ../development/tools/json2tsv { };
+
   json2yaml = haskell.lib.compose.justStaticExecutables haskellPackages.json2yaml;
 
   json-glib = callPackage ../development/libraries/json-glib { };
···
 
   ucommon = callPackage ../development/libraries/ucommon { };
 
-  v8 = callPackage ../development/libraries/v8 { };
+  v8 = darwin.apple_sdk_11_0.callPackage ../development/libraries/v8 { };
 
   v8_8_x = callPackage ../development/libraries/v8/8_x.nix { };
 

pkgs/top-level/beam-packages.nix

···
-{ beam, callPackage, wxGTK30, buildPackages, stdenv
+{ beam
+, callPackage
 , openssl_1_1
+, wxGTK30
+, buildPackages
+, stdenv
 , wxSupport ? true
 , systemdSupport ? stdenv.isLinux
 }:
 
-with beam; {
-  lib = callPackage ../development/beam-modules/lib.nix { };
+let
+  self = beam;
+in
+
+{
+  beamLib = callPackage ../development/beam-modules/lib.nix { };
 
   # R24 is the default version.
   # The main switch to change default Erlang version.
   defaultVersion = "erlangR24";
 
   # Each
-  interpreters = with beam.interpreters; {
+  interpreters = {
 
-    erlang = beam.interpreters.${defaultVersion};
-    erlang_odbc = beam.interpreters."${defaultVersion}_odbc";
-    erlang_javac = beam.interpreters."${defaultVersion}_javac";
-    erlang_odbc_javac = beam.interpreters."${defaultVersion}_odbc_javac";
+    erlang = self.interpreters.${self.defaultVersion};
+    erlang_odbc = self.interpreters."${self.defaultVersion}_odbc";
+    erlang_javac = self.interpreters."${self.defaultVersion}_javac";
+    erlang_odbc_javac = self.interpreters."${self.defaultVersion}_odbc_javac";
 
     # Standard Erlang versions, using the generic builder.
 
     # R25
-    erlangR25 = lib.callErlang ../development/interpreters/erlang/R25.nix {
+    erlangR25 = self.beamLib.callErlang ../development/interpreters/erlang/R25.nix {
       wxGTK = wxGTK30;
       parallelBuild = true;
       autoconf = buildPackages.autoconf269;
       inherit wxSupport systemdSupport;
     };
-    erlangR25_odbc = erlangR25.override { odbcSupport = true; };
-    erlangR25_javac = erlangR25.override { javacSupport = true; };
-    erlangR25_odbc_javac = erlangR25.override {
+    erlangR25_odbc = self.interpreters.erlangR25.override { odbcSupport = true; };
+    erlangR25_javac = self.interpreters.erlangR25.override { javacSupport = true; };
+    erlangR25_odbc_javac = self.interpreters.erlangR25.override {
       javacSupport = true;
       odbcSupport = true;
     };
 
     # R24
-    erlangR24 = lib.callErlang ../development/interpreters/erlang/R24.nix {
+    erlangR24 = self.beamLib.callErlang ../development/interpreters/erlang/R24.nix {
       wxGTK = wxGTK30;
       # Can be enabled since the bug has been fixed in https://github.com/erlang/otp/pull/2508
       parallelBuild = true;
       autoconf = buildPackages.autoconf269;
       inherit wxSupport systemdSupport;
     };
-    erlangR24_odbc = erlangR24.override { odbcSupport = true; };
-    erlangR24_javac = erlangR24.override { javacSupport = true; };
-    erlangR24_odbc_javac = erlangR24.override {
+    erlangR24_odbc = self.interpreters.erlangR24.override { odbcSupport = true; };
+    erlangR24_javac = self.interpreters.erlangR24.override { javacSupport = true; };
+    erlangR24_odbc_javac = self.interpreters.erlangR24.override {
       javacSupport = true;
       odbcSupport = true;
     };
 
     # R23
-    erlangR23 = lib.callErlang ../development/interpreters/erlang/R23.nix {
+    erlangR23 = self.beamLib.callErlang ../development/interpreters/erlang/R23.nix {
       openssl = openssl_1_1;
       wxGTK = wxGTK30;
       # Can be enabled since the bug has been fixed in https://github.com/erlang/otp/pull/2508
···
       autoconf = buildPackages.autoconf269;
       inherit wxSupport systemdSupport;
     };
-    erlangR23_odbc = erlangR23.override { odbcSupport = true; };
-    erlangR23_javac = erlangR23.override { javacSupport = true; };
-    erlangR23_odbc_javac = erlangR23.override {
+    erlangR23_odbc = self.interpreters.erlangR23.override { odbcSupport = true; };
+    erlangR23_javac = self.interpreters.erlangR23.override { javacSupport = true; };
+    erlangR23_odbc_javac = self.interpreters.erlangR23.override {
       javacSupport = true;
       odbcSupport = true;
     };
 
     # R22
-    erlangR22 = lib.callErlang ../development/interpreters/erlang/R22.nix {
+    erlangR22 = self.beamLib.callErlang ../development/interpreters/erlang/R22.nix {
       openssl = openssl_1_1;
       wxGTK = wxGTK30;
       # Can be enabled since the bug has been fixed in https://github.com/erlang/otp/pull/2508
···
       autoconf = buildPackages.autoconf269;
       inherit wxSupport systemdSupport;
     };
-    erlangR22_odbc = erlangR22.override { odbcSupport = true; };
-    erlangR22_javac = erlangR22.override { javacSupport = true; };
-    erlangR22_odbc_javac = erlangR22.override {
+    erlangR22_odbc = self.interpreters.erlangR22.override { odbcSupport = true; };
+    erlangR22_javac = self.interpreters.erlangR22.override { javacSupport = true; };
+    erlangR22_odbc_javac = self.interpreters.erlangR22.override {
       javacSupport = true;
       odbcSupport = true;
     };
 
     # R21
-    erlangR21 = lib.callErlang ../development/interpreters/erlang/R21.nix {
+    erlangR21 = self.beamLib.callErlang ../development/interpreters/erlang/R21.nix {
       openssl = openssl_1_1;
       wxGTK = wxGTK30;
       autoconf = buildPackages.autoconf269;
       inherit wxSupport systemdSupport;
     };
-    erlangR21_odbc = erlangR21.override { odbcSupport = true; };
-    erlangR21_javac = erlangR21.override { javacSupport = true; };
-    erlangR21_odbc_javac = erlangR21.override {
+    erlangR21_odbc = self.interpreters.erlangR21.override { odbcSupport = true; };
+    erlangR21_javac = self.interpreters.erlangR21.override { javacSupport = true; };
+    erlangR21_odbc_javac = self.interpreters.erlangR21.override {
       javacSupport = true;
       odbcSupport = true;
     };
···
     # Other Beam languages. These are built with `beam.interpreters.erlang`. To
     # access for example elixir built with different version of Erlang, use
     # `beam.packages.erlangR24.elixir`.
-    inherit (packages.erlang)
+    inherit (self.packages.erlang)
       elixir elixir_1_14 elixir_1_13 elixir_1_12 elixir_1_11 elixir_1_10 elixir_ls;
 
-    inherit (packages.erlang) lfe lfe_1_3;
+    inherit (self.packages.erlang) lfe lfe_1_3;
   };
 
   # Helper function to generate package set with a specific Erlang version.
···
   # appropriate Erlang/OTP version.
   packages = {
     # Packages built with default Erlang version.
-    erlang = packages.${defaultVersion};
+    erlang = self.packages.${self.defaultVersion};
 
-    erlangR25 = packagesWith interpreters.erlangR25;
-    erlangR24 = packagesWith interpreters.erlangR24;
-    erlangR23 = packagesWith interpreters.erlangR23;
-    erlangR22 = packagesWith interpreters.erlangR22;
-    erlangR21 = packagesWith interpreters.erlangR21;
+    erlangR25 = self.packagesWith self.interpreters.erlangR25;
+    erlangR24 = self.packagesWith self.interpreters.erlangR24;
+    erlangR23 = self.packagesWith self.interpreters.erlangR23;
+    erlangR22 = self.packagesWith self.interpreters.erlangR22;
+    erlangR21 = self.packagesWith self.interpreters.erlangR21;
   };
 }