Merge pull request #200740 from NixOS/haskell-updates

haskellPackages: update stackage and hackage

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "7e2dca1338ee7f19dbb8cdbc81e9eb1716bbf64e",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/7e2dca1338ee7f19dbb8cdbc81e9eb1716bbf64e.tar.gz",
-  "sha256": "1vrhv9w042sn2sm3niiy5640qvhiqn79zllp4vsbdpds758rj9vm",
-  "msg": "Update from Hackage at 2022-11-03T21:09:38Z"
+  "commit": "e2ccf8a8796c9192280f796ce0f5d98ec783f856",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/e2ccf8a8796c9192280f796ce0f5d98ec783f856.tar.gz",
+  "sha256": "092g4pbxyhkw1isbib967v5aw16iqs3w5iqcicv1irr4rphsr06z",
+  "msg": "Update from Hackage at 2022-11-11T17:48:48Z"
 }

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

···
     (disableCabalFlag "stan") # Sorry stan is totally unmaintained and terrible to get to run. It only works on ghc 8.8 or 8.10 anyways …
   ]).overrideScope (lself: lsuper: {
     ormolu = doJailbreak lself.ormolu_0_5_0_1;
-    fourmolu = doJailbreak lself.fourmolu_0_8_2_0;
+    fourmolu = doJailbreak lself.fourmolu_0_9_0_0;
     hlint = enableCabalFlag "ghc-lib" lself.hlint_3_4_1;
     ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_4;
-    ghc-lib-parser = lself.ghc-lib-parser_9_2_4_20220729;
+    ghc-lib-parser = lself.ghc-lib-parser_9_2_5_20221107;
     # For most ghc versions, we overrideScope Cabal in the configuration-ghc-???.nix,
     # because some packages, like ormolu, need a newer Cabal version.
     # ghc-paths is special because it depends on Cabal for building
···
     # For "ghc-lib" flag see https://github.com/haskell/haskell-language-server/issues/3185#issuecomment-1250264515
     hlint = enableCabalFlag "ghc-lib" lself.hlint_3_4_1;
     ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_4;
-    ghc-lib-parser = lself.ghc-lib-parser_9_2_4_20220729;
+    ghc-lib-parser = lself.ghc-lib-parser_9_2_5_20221107;
   });
 
   # For -f-auto see cabal.project in haskell-language-server.
   ghc-lib-parser-ex_9_2_0_4 = disableCabalFlag "auto" (super.ghc-lib-parser-ex_9_2_0_4.override {
-    ghc-lib-parser = self.ghc-lib-parser_9_2_4_20220729;
+    ghc-lib-parser = self.ghc-lib-parser_9_2_5_20221107;
   });
 
   # 2021-05-08: Tests fail: https://github.com/haskell/haskell-language-server/issues/1809
···
 
   # 2022-09-19: https://github.com/haskell/haskell-language-server/issues/3200
   hls-refactor-plugin = dontCheck super.hls-refactor-plugin;
+
+  # 2022-11-18: https://github.com/haskell/haskell-language-server/commit/c1a7527c4fb348bee6093d9794b7d3e0c8d563f2
+  hls-fourmolu-plugin = assert super.hls-fourmolu-plugin.version == "1.1.0.0"; doJailbreak super.hls-fourmolu-plugin;
 
   # 2022-10-27: implicit-hie 0.1.3.0 needs a newer version of Cabal-syntax.
   implicit-hie = super.implicit-hie.override {
···
 
   # 2022-03-21: Newest stylish-haskell needs ghc-lib-parser-9_2
   stylish-haskell = (super.stylish-haskell.override {
-    ghc-lib-parser = self.ghc-lib-parser_9_2_4_20220729;
+    ghc-lib-parser = self.ghc-lib-parser_9_2_5_20221107;
     ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_2_0_4;
   });
 
···
   # Missing test files https://github.com/kephas/xdg-basedir-compliant/issues/1
   xdg-basedir-compliant = dontCheck super.xdg-basedir-compliant;
 
-  # 2022-09-01:
-  # Restrictive upper bound on base.
-  # Remove once version 1.* is released
-  monad-bayes = doJailbreak super.monad-bayes;
-
   # Test failure after libxcrypt migration, reported upstrem at
   # https://github.com/phadej/crypt-sha512/issues/13
   crypt-sha512 = dontCheck super.crypt-sha512;
···
   # Upstream jailbreak is unreleased: https://github.com/srid/heist/commit/988692ea850b3cbe966c7dc4dd26ba1d49647706
   heist-emanote = doJailbreak (dontCheck super.heist-emanote);
 
+  # 2022-11-15: Needs newer witch package and brick 1.3 which in turn works with text-zipper 0.12
+  # Other dependencies are resolved with doJailbreak for both swarm and brick_1_3
+  swarm = doJailbreak (super.swarm.override {
+    witch = super.witch_1_1_2_0;
+    brick = doJailbreak (dontCheck (super.brick_1_3.override {
+      text-zipper = super.text-zipper_0_12;
+    }));
+  });
 })

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

···
   ormolu_0_5_0_1 = overrideCabal (drv: {
     libraryHaskellDepends = drv.libraryHaskellDepends ++ [ self.file-embed ];
   }) (disableCabalFlag "fixity-th" super.ormolu_0_5_0_1);
-  fourmolu_0_8_2_0 = overrideCabal (drv: {
+  fourmolu_0_9_0_0 = overrideCabal (drv: {
     libraryHaskellDepends = drv.libraryHaskellDepends ++ [ self.file-embed ];
-  }) (disableCabalFlag "fixity-th" super.fourmolu_0_8_2_0);
+  }) (disableCabalFlag "fixity-th" super.fourmolu_0_9_0_0);
 
 } // lib.optionalAttrs pkgs.stdenv.isx86_64 {  # x86_64-darwin
 

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

···
       self.data-default
     ] ++ drv.libraryHaskellDepends or [];
   }) super.ghc-exactprint;
-  ghc-lib = doDistribute self.ghc-lib_9_2_4_20220729;
-  ghc-lib-parser = doDistribute self.ghc-lib-parser_9_2_4_20220729;
+  ghc-lib = doDistribute self.ghc-lib_9_2_5_20221107;
+  ghc-lib-parser = doDistribute self.ghc-lib-parser_9_2_5_20221107;
   ghc-lib-parser-ex = doDistribute self.ghc-lib-parser-ex_9_2_1_1;
   hackage-security = doJailbreak super.hackage-security;
   hashable = super.hashable_1_4_1_0;
···
   jacinda = doDistribute super.jacinda;
   some = doJailbreak super.some;
 
-  fourmolu = super.fourmolu_0_8_2_0;
+  fourmolu = super.fourmolu_0_9_0_0;
 
   implicit-hie-cradle = doJailbreak super.implicit-hie-cradle;
   # 1.3 introduced support for GHC 9.2.x, so when this assert fails, the jailbreak can be removed

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

···
   dec = doJailbreak super.dec;
   ed25519 = doJailbreak super.ed25519;
   ghc-byteorder = doJailbreak super.ghc-byteorder;
-  ghc-lib = doDistribute self.ghc-lib_9_4_2_20220822;
-  ghc-lib-parser = doDistribute self.ghc-lib-parser_9_4_2_20220822;
+  ghc-lib = doDistribute self.ghc-lib_9_4_3_20221104;
+  ghc-lib-parser = doDistribute self.ghc-lib-parser_9_4_3_20221104;
   ghc-lib-parser-ex = doDistribute self.ghc-lib-parser-ex_9_4_0_0;
   hackage-security = doJailbreak super.hackage-security;
   hashable = super.hashable_1_4_1_0;
···
     hls-retrie-plugin = null;
     hls-splice-plugin = null;
   };
+
+  # https://github.com/tweag/ormolu/issues/941
+  ormolu = overrideCabal (drv: {
+    libraryHaskellDepends = drv.libraryHaskellDepends ++ [ self.file-embed ];
+  }) (disableCabalFlag "fixity-th" super.ormolu);
+  fourmolu = overrideCabal (drv: {
+    libraryHaskellDepends = drv.libraryHaskellDepends ++ [ self.file-embed ];
+  }) (disableCabalFlag "fixity-th" super.fourmolu);
 }

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

···
   - boombox
   - boots-app
   - boring-window-switcher
+  - borsh
   - bot
   - botpp
   - bottom
···
   - etcd
   - ethereum-rlp
   - eurofxref
+  - evdev-streamly
   - eve
   - eved
   - event
···
   - HaPy
   - haquery
   - harchive
+  - harfbuzz-pure
   - HARM
   - HarmTrace-Base
   - haroonga
···
   - hquantlib
   - hquery
   - hR
-  - h-raylib
   - hreq-core
   - h-reversi
   - hricket
···
   - monadacme
   - monad-atom
   - monad-atom-simple
+  - monad-bayes
   - monad-branch
   - MonadCatchIO-transformers
   - monad-choice
···
   - supervisor
   - supervisors
   - supplemented
+  - supply-chain-core
   - surjective
   - sv-core
   - SVD2HS
···
   - swagger
   - swagger-petstore
   - swagger-test
-  - swarm
   - swearjure
   - swf
   - swift-lda
···
   - text-and-plots
   - text-ascii
   - text-builder-linear
+  - text-compression
   - text-containers
   - text-display
   - text-format-heavy

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

···
   - basement < 0.0.15                   # 2022-08-30: last version to support GHC < 8.10
   - bower-json == 1.0.0.1               # 2022-05-21: Needed for spago 0.20.9
   - brick == 0.70.*                     # 2022-08-13: needed by matterhorn-50200.17.0
+  - brick == 1.3                        # 2022-11-03: needed by swarm 0.2.0.0
   - brittany == 0.13.1.2                # 2022-09-20: needed for hls on ghc 8.8
   - cabal-install-parsers < 0.5         # 2022-08-31: required by haskell-ci 0.14.3
   - clay < 0.14                         # 2022-03-20: Needed for neuron 1.0.0.0
···
   - hspec-discover < 2.8                # 2022-04-07: Needed for tasty-hspec 1.1.6
   - hspec-golden == 0.1.*               # 2022-04-07: Needed for elm-format
   - immortal == 0.2.2.1                 # required by Hasura 1.3.1, 2020-08-20
+  - language-docker == 11.0.0           # required by hadolint 2.12.0, 2022-11-16
   - language-javascript == 0.7.0.0      # required by purescript
   - lsp == 1.4.0.0                      # 2022-09-18: need for dhall-lsp-server 1.1.2
   - lsp-types == 1.4.0.1                # 2022-09-18: need for dhall-lsp-server 1.1.2
···
   - gi-webkit
   - hsqml
   - hsqml-datamodel
+  - hsqml-datamodel-vinyl
   - hsqml-demo-manic
+  - hsqml-demo-morris
   - hsqml-demo-notes
   - hsqml-demo-samples
+  - hsqml-morris
   - hstorchat
   - jsaddle-webkitgtk
   - jsc

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

···
-# Stackage LTS 19.31
+# Stackage LTS 19.32
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - crypto-pubkey-types ==0.4.3
   - crypto-random ==0.0.9
   - crypto-random-api ==0.2.0
-  - cryptostore ==0.2.2.0
+  - cryptostore ==0.2.3.0
   - crypt-sha512 ==0
   - csp ==1.4.0
   - css-text ==0.1.3.0
···
   - elerea ==2.9.0
   - elf ==0.31
   - eliminators ==0.8
-  - elm-bridge ==0.8.0
+  - elm-bridge ==0.8.1
   - elm-core-sources ==1.0.0
   - elm-export ==0.6.0.1
   - elynx ==0.6.1.1
···
   - error-or-utils ==0.2.0
   - errors ==2.3.0
   - errors-ext ==0.4.2
-  - ersatz ==0.4.12
+  - ersatz ==0.4.13
   - esqueleto ==3.5.8.1
   - essence-of-live-coding ==0.2.6
   - essence-of-live-coding-gloss ==0.2.6
···
   - mwc-random-monad ==0.7.3.1
   - mx-state-codes ==1.0.0.0
   - mysql ==0.2.1
-  - mysql-simple ==0.4.8.1
+  - mysql-simple ==0.4.9
   - n2o ==0.11.1
   - n2o-nitro ==0.11.2
   - nagios-check ==0.3.2
···
   - optparse-simple ==0.1.1.4
   - optparse-text ==0.1.1.0
   - OrderedBits ==0.0.2.0
-  - ordered-containers ==0.2.2
+  - ordered-containers ==0.2.3
   - ormolu ==0.3.1.0
   - overhang ==1.0.0
   - packcheck ==0.6.0
···
   - postgresql-binary ==0.12.5
   - postgresql-libpq ==0.9.4.3
   - postgresql-libpq-notify ==0.2.0.0
-  - postgresql-migration ==0.2.1.4
+  - postgresql-migration ==0.2.1.6
   - postgresql-orm ==0.5.1
   - postgresql-query ==3.9.0
   - postgresql-schema ==0.1.14
···
   - riak-protobuf ==0.25.0.0
   - rio ==0.1.22.0
   - rio-orphans ==0.1.2.0
-  - rio-prettyprint ==0.1.1.0
+  - rio-prettyprint ==0.1.2.0
   - rng-utils ==0.3.1
   - roc-id ==0.1.0.0
   - rocksdb-haskell ==1.0.1
···
   - skylighting-core ==0.12.3.1
   - slack-progressbar ==0.1.0.1
   - slave-thread ==1.1.0.1
-  - slist ==0.2.0.1
+  - slist ==0.2.1.0
   - slynx ==0.6.1.1
   - smallcheck ==1.2.1
   - smash ==0.1.3

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

···
  - apiary-websockets
  - apis
  - apotiki
+ - appendful-persistent
  - approx-rand-test
  - arbor-monad-metric-datadog
  - archive-tar-bytestring
···
  - geni-util
  - geniconvert
  - geniserver
+ - genvalidity-appendful
  - genvalidity-network-uri
  - genvalidity-sydtest
  - genvalidity-sydtest-aeson
···
  - hsql-odbc
  - hsql-postgresql
  - hsql-sqlite3
- - hsqml-datamodel-vinyl
- - hsqml-demo-morris
- - hsqml-morris
  - hsreadability
  - hssqlppp-th
  - hstar
···
  - sql-simple-pool
  - sql-simple-postgresql
  - sql-simple-sqlite
+ - sqlite-easy
  - sqlite-simple-typed
  - sqsd-local
  - sscgi
···
  - supercollider-midi
  - superconstraints
  - supernova
+ - supply-chain
  - sv
  - sv-cassava
  - sv-svfactor

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

···
   }) super.procex;
 
   # Test suite wants to run main executable
-  fourmolu_0_8_2_0 = overrideCabal (drv: {
+  fourmolu_0_9_0_0 = overrideCabal (drv: {
     preCheck = drv.preCheck or "" + ''
       export PATH="$PWD/dist/build/fourmolu:$PATH"
     '';
-  }) super.fourmolu_0_8_2_0;
+  }) super.fourmolu_0_9_0_0;
 
   # Test suite needs to execute 'disco' binary
   disco = overrideCabal (drv: {

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

···
      }:
      mkDerivation {
        pname = "Blammo";
-       version = "1.1.0.0";
-       sha256 = "02j49dzwlx0p39njspz10vbj5qybb1l2l2lk4gdrbicp953czaa8";
+       version = "1.1.1.0";
+       sha256 = "1hqrdzj30lwwb7zis2hkfz887jh107k33mbqkj2hxvd56sc4din5";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive clock containers dlist
          envparse exceptions fast-logger http-types lens monad-logger-aeson
          mtl text time unliftio unliftio-core unordered-containers vector
          wai
        ];
-       testHaskellDepends = [ aeson base hspec markdown-unlit mtl text ];
+       testHaskellDepends = [
+         aeson base bytestring hspec markdown-unlit mtl text time
+       ];
        testToolDepends = [ markdown-unlit ];
        description = "Batteries-included Structured Logging library";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "H";
-       version = "0.9.0.1";
-       sha256 = "0d3isp467pq5l1c95j0q6s2isywz8xamgrm9rs16i7xczkz4vh2z";
-       revision = "1";
-       editedCabalFile = "07pddiap3jzcnc09v442wq30j46nmkdibilzcv69hz5imcnmhz0h";
+       version = "1.0.0";
+       sha256 = "1xnv8a097pidh4q9ngrsha0vm9sgsbggblizcjz449iwwsb8yg9g";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        description = "Random-number generation monad";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "MonadRandom_0_6" = callPackage
+    ({ mkDerivation, base, mtl, primitive, random, transformers
+     , transformers-compat
+     }:
+     mkDerivation {
+       pname = "MonadRandom";
+       version = "0.6";
+       sha256 = "0i6h9s2iqj71q06i9al3s2akmdjjx16h015qb81nhgjwi4q8cf69";
+       libraryHaskellDepends = [
+         base mtl primitive random transformers transformers-compat
+       ];
+       description = "Random-number generation monad";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "MonadRandomLazy" = callPackage
···
      }) {};
 
   "ONC-RPC" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, cereal, containers
-     , filepath, haskell-src-exts, network, parsec, random, time, unix
-     , vector
+    ({ mkDerivation, base, base16-bytestring, bytestring, Cabal, cereal
+     , containers, filepath, haskell-src-exts, network, parsec, random
+     , time, unix, vector
      }:
      mkDerivation {
        pname = "ONC-RPC";
-       version = "0.1";
-       sha256 = "19smd0rp0jx9i59jgjk149g4czpwjx173szhp1z9dvm5j0pdwyy5";
+       version = "0.2";
+       sha256 = "0aqhvw6kqsd3b6wlyjhrz4ijc1b4ch57398icjfy7gr1a8g3z3c0";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [
-         base bytestring Cabal cereal containers filepath haskell-src-exts
-         parsec vector
+         base base16-bytestring bytestring Cabal cereal containers filepath
+         haskell-src-exts parsec vector
        ];
        libraryHaskellDepends = [
-         base bytestring Cabal cereal containers filepath haskell-src-exts
-         network parsec random time unix vector
+         base base16-bytestring bytestring Cabal cereal containers filepath
+         haskell-src-exts network parsec random time unix vector
        ];
        executableHaskellDepends = [ base filepath ];
        description = "ONC RPC (aka Sun RPC) and XDR library";
···
        broken = true;
      }) {};
 
+  "aeson-schemas_1_4_0_0" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, base, criterion, deepseq
+     , filepath, first-class-families, hashable, hint, interpolate
+     , megaparsec, process, QuickCheck, raw-strings-qq, tasty
+     , tasty-golden, tasty-hunit, tasty-quickcheck, template-haskell
+     , temporary, text, th-orphans, th-test-utils, unordered-containers
+     }:
+     mkDerivation {
+       pname = "aeson-schemas";
+       version = "1.4.0.0";
+       sha256 = "0nch4andx0w0l7dlw64ajz503f05zancx42178dsd5fskvd75ks2";
+       libraryHaskellDepends = [
+         aeson base first-class-families hashable megaparsec
+         template-haskell text unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson aeson-qq base deepseq filepath first-class-families hashable
+         hint interpolate megaparsec process QuickCheck raw-strings-qq tasty
+         tasty-golden tasty-hunit tasty-quickcheck template-haskell
+         temporary text th-orphans th-test-utils unordered-containers
+       ];
+       benchmarkHaskellDepends = [
+         aeson base criterion deepseq first-class-families hashable
+         megaparsec template-haskell text th-test-utils unordered-containers
+       ];
+       description = "Easily consume JSON data on-demand with type-safety";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "aeson-serialize" = callPackage
     ({ mkDerivation, aeson, base, cereal, hspec, HUnit }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "aeson-typescript_0_4_1_0" = callPackage
+  "aeson-typescript_0_4_2_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, directory
      , filepath, hspec, mtl, process, string-interpolate
      , template-haskell, temporary, text, th-abstraction, transformers
···
      }:
      mkDerivation {
        pname = "aeson-typescript";
-       version = "0.4.1.0";
-       sha256 = "0zr6p0yyzm1mdhnyycd37alw3xg2jmx303mbd5a7251wffxc42n8";
+       version = "0.4.2.0";
+       sha256 = "00lv7mfxxnhmbxh9s1qwfnffmpy6095fh3zms68bzdkjik2hk830";
        libraryHaskellDepends = [
          aeson base containers mtl string-interpolate template-haskell text
          th-abstraction transformers unordered-containers
···
 
   "appendful-persistent" = callPackage
     ({ mkDerivation, appendful, base, containers, genvalidity
-     , genvalidity-appendful, genvalidity-hspec, genvalidity-persistent
-     , hspec, microlens, monad-logger, mtl, path, path-io, persistent
-     , persistent-sqlite, persistent-template, QuickCheck, text
-     , validity
+     , genvalidity-appendful, genvalidity-persistent
+     , genvalidity-sydtest, microlens, monad-logger, mtl, path, path-io
+     , persistent, persistent-sqlite, persistent-template, QuickCheck
+     , sydtest, sydtest-discover, text, validity
      }:
      mkDerivation {
        pname = "appendful-persistent";
-       version = "0.0.0.0";
-       sha256 = "0h0hdjkkrz8ckhs8r8n0vm983513lahi9bd89i1hyqlycrckbphl";
+       version = "0.1.0.0";
+       sha256 = "0aw463j5qyjazzj7w325fn85nyz3i7rml1c5f02ps06n9rhw0w1k";
        libraryHaskellDepends = [
          appendful base containers microlens persistent
        ];
        testHaskellDepends = [
          appendful base containers genvalidity genvalidity-appendful
-         genvalidity-hspec genvalidity-persistent hspec monad-logger mtl
-         path path-io persistent persistent-sqlite persistent-template
-         QuickCheck text validity
+         genvalidity-persistent genvalidity-sydtest monad-logger mtl path
+         path-io persistent persistent-sqlite persistent-template QuickCheck
+         sydtest text validity
        ];
+       testToolDepends = [ sydtest-discover ];
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "appendmap" = callPackage
···
      }:
      mkDerivation {
        pname = "aws";
-       version = "0.22.1";
-       sha256 = "0zz8f144rsd7bpl4xfxw3wbp9s1a300c8i6vifh2yfhi798j76n4";
+       version = "0.23";
+       sha256 = "0kfdj9hxjvziq1y74xj9mm17zcgwywpvp9c0i6gfd5malf4qxgg0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "benri-hspec" = callPackage
+    ({ mkDerivation, base, hspec }:
+     mkDerivation {
+       pname = "benri-hspec";
+       version = "0.1.0.0";
+       sha256 = "0vvc7fw52c9flmdjmgrc9cca9yrl4r7yvh2l5ixc23gvvmlhdycy";
+       libraryHaskellDepends = [ base hspec ];
+       description = "Simplify tests where Either or Maybe types are returned from monadic code";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "bento" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "borsh" = callPackage
+    ({ mkDerivation, base, bytestring, containers, generics-sop, memory
+     , optics-core, profunctors, QuickCheck, quickcheck-instances
+     , sop-core, tasty, tasty-quickcheck, text, vector, wide-word
+     }:
+     mkDerivation {
+       pname = "borsh";
+       version = "0.1.0";
+       sha256 = "0nyv91sn2v8m1zlp789v85dm9n21k9gb532rkzhdds5fpvqa6w3z";
+       libraryHaskellDepends = [
+         base bytestring containers generics-sop memory sop-core text vector
+         wide-word
+       ];
+       testHaskellDepends = [
+         base bytestring containers generics-sop optics-core profunctors
+         QuickCheck quickcheck-instances sop-core tasty tasty-quickcheck
+         text
+       ];
+       description = "Implementation of BORSH serialisation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "bot" = callPackage
     ({ mkDerivation, arrows, base, Stream }:
      mkDerivation {
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "brick_1_3" = callPackage
+    ({ mkDerivation, base, bimap, bytestring, config-ini, containers
+     , contravariant, data-clist, deepseq, directory, exceptions
+     , filepath, microlens, microlens-mtl, microlens-th, mtl, QuickCheck
+     , stm, template-haskell, text, text-zipper, unix, vector, vty
+     , word-wrap
+     }:
+     mkDerivation {
+       pname = "brick";
+       version = "1.3";
+       sha256 = "0lpd6685ya0va0a6n7cw70f5b1s13y8ynzac0gkxyqb1ivzj0hsb";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bimap bytestring config-ini containers contravariant
+         data-clist deepseq directory exceptions filepath microlens
+         microlens-mtl microlens-th mtl stm template-haskell text
+         text-zipper unix vector vty word-wrap
+       ];
+       testHaskellDepends = [
+         base containers microlens QuickCheck vector vty
+       ];
+       description = "A declarative terminal user interface library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "brick_1_4" = callPackage
     ({ mkDerivation, base, bimap, bytestring, config-ini, containers
      , contravariant, data-clist, deepseq, directory, exceptions
···
      }:
      mkDerivation {
        pname = "brick-panes";
-       version = "1.0.0.1";
-       sha256 = "05f5c99b44c6aajx12hx4ayxjldbj4n0fi70i95q18qxy9aacljw";
+       version = "1.0.0.2";
+       sha256 = "1g6q9pnc0a0fnp2qaxqxp8qdriifi6w362ky36csxl633nl6gsw0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base brick containers microlens vty ];
···
        pname = "byteslice";
        version = "0.2.7.0";
        sha256 = "1mzqlyh0mswk64irz0sr8fk0v9y9ksb1k1j3g51l9vhhnz0cavhj";
+       revision = "1";
+       editedCabalFile = "1g5670xillqbfpnsxppfjkvaaff4rjlk6116pc5s1pds0zsnbyy8";
        libraryHaskellDepends = [
          base bytestring primitive primitive-addr primitive-unlifted run-st
          tuples vector
···
        license = lib.licenses.mit;
      }) {};
 
+  "commonmark-wikilink" = callPackage
+    ({ mkDerivation, aeson, base, commonmark, commonmark-pandoc
+     , megaparsec, network-uri, pandoc-types, parsec, relude, uri-encode
+     , url-slug
+     }:
+     mkDerivation {
+       pname = "commonmark-wikilink";
+       version = "0.1.0.0";
+       sha256 = "1varv4zihai08wvgpsf9pp3qaa1wniii21qhgy39cpcz9n9s2hv2";
+       libraryHaskellDepends = [
+         aeson base commonmark commonmark-pandoc megaparsec network-uri
+         pandoc-types parsec relude uri-encode url-slug
+       ];
+       description = "Obsidian-friendly commonmark wikilink parser";
+       license = lib.licenses.mit;
+     }) {};
+
   "commsec" = callPackage
     ({ mkDerivation, base, bytestring, cipher-aes128, crypto-api
      , network
···
      }:
      mkDerivation {
        pname = "copilot";
-       version = "3.11";
-       sha256 = "1g542m2bk0avnsnrzc0y1dqy5k91i0d9p5fd8ir39gpaa8024ih2";
+       version = "3.12";
+       sha256 = "0svbn9djzxqbmi62106i2692fx31vdxqjjd2y329nlq36iivvyxf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "copilot-c99";
-       version = "3.11";
-       sha256 = "0xz92m8rhcb1l7533lxd5sbnisld2ss0h2sm18bxdig22v4qlzh5";
+       version = "3.12";
+       sha256 = "0xxvdl1k09il545y263k5x37gi5z1y4plm8f4yjqh3hprv23ffhp";
        libraryHaskellDepends = [
          base copilot-core directory filepath language-c99
          language-c99-simple mtl pretty
···
      }:
      mkDerivation {
        pname = "copilot-core";
-       version = "3.11";
-       sha256 = "01h21a40v233qphm03fb9y18iwisnznpdvjvciy3kcc756rvranx";
+       version = "3.12";
+       sha256 = "1aw6pkxqpcwqib86yq2zvjz6jqxjc3ina0hbxsyvmgmcqs5hwybs";
        libraryHaskellDepends = [ base dlist pretty ];
        testHaskellDepends = [
          base HUnit pretty QuickCheck test-framework test-framework-hunit
···
      }) {};
 
   "copilot-interpreter" = callPackage
-    ({ mkDerivation, base, copilot-core, pretty, QuickCheck
-     , test-framework, test-framework-quickcheck2
+    ({ mkDerivation, base, copilot-core, copilot-prettyprinter, pretty
+     , QuickCheck, test-framework, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "copilot-interpreter";
-       version = "3.11";
-       sha256 = "1w6acc3hzjyai20l52qxhnx165i8ywra8jpc2nqvyji13fq433z6";
+       version = "3.12";
+       sha256 = "100nalpd7q9z26nyk06nbl4hr8p6akm8qny988zd8znp2c3z37rr";
        libraryHaskellDepends = [ base copilot-core pretty ];
        testHaskellDepends = [
-         base copilot-core pretty QuickCheck test-framework
-         test-framework-quickcheck2
+         base copilot-core copilot-prettyprinter pretty QuickCheck
+         test-framework test-framework-quickcheck2
        ];
        description = "Interpreter for Copilot";
        license = lib.licenses.bsd3;
···
 
   "copilot-language" = callPackage
     ({ mkDerivation, array, base, containers, copilot-core
-     , copilot-interpreter, copilot-theorem, data-reify, HUnit, mtl
-     , pretty, QuickCheck, test-framework, test-framework-hunit
-     , test-framework-quickcheck2
+     , copilot-interpreter, copilot-prettyprinter, copilot-theorem
+     , data-reify, HUnit, mtl, pretty, QuickCheck, test-framework
+     , test-framework-hunit, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "copilot-language";
-       version = "3.11";
-       sha256 = "1j0bvlplm5pz2yf09b7n716mvkkc7n6gq25fkghmqb1ndaffz5m3";
+       version = "3.12";
+       sha256 = "1n2n83617wi0piw94g843zk39xvralcn7l8vdcvbx6gwqm9dn320";
        libraryHaskellDepends = [
          array base containers copilot-core copilot-interpreter
-         copilot-theorem data-reify mtl
+         copilot-prettyprinter copilot-theorem data-reify mtl
        ];
        testHaskellDepends = [
          base copilot-core copilot-interpreter HUnit pretty QuickCheck
···
     ({ mkDerivation, base, containers, copilot-language, mtl, parsec }:
      mkDerivation {
        pname = "copilot-libraries";
-       version = "3.11";
-       sha256 = "0cvz3vq6k48yq5qjhdnzn3shgjfdyrbb480721nkmqml0v64p213";
+       version = "3.12";
+       sha256 = "0xxfz2r04x0cwyidlfd792v4jspv38v8w012w0dmr0ajsw15npxb";
        libraryHaskellDepends = [
          base containers copilot-language mtl parsec
        ];
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "copilot-prettyprinter" = callPackage
+    ({ mkDerivation, base, copilot-core, pretty }:
+     mkDerivation {
+       pname = "copilot-prettyprinter";
+       version = "3.12";
+       sha256 = "1sj4fjj6kwarjxn53qrfvl0ca200ra9hnh8mrisc4jr87xhdbnh0";
+       libraryHaskellDepends = [ base copilot-core pretty ];
+       description = "A prettyprinter of Copilot Specifications";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "copilot-sbv" = callPackage
     ({ mkDerivation, base, containers, copilot-core, directory
      , filepath, pretty, sbv
···
 
   "copilot-theorem" = callPackage
     ({ mkDerivation, base, bimap, bv-sized, containers, copilot-core
-     , data-default, directory, libBF, mtl, panic, parameterized-utils
-     , parsec, pretty, process, random, transformers, what4, xml
+     , copilot-prettyprinter, data-default, directory, libBF, mtl, panic
+     , parameterized-utils, parsec, pretty, process, random
+     , transformers, what4, xml
      }:
      mkDerivation {
        pname = "copilot-theorem";
-       version = "3.11";
-       sha256 = "1nrcm5vzjlqch2ff3vpjrlqjjm0j58p74md3wvpb0swr85j1calf";
+       version = "3.12";
+       sha256 = "1q0r8fa4jvqpkiy099f9fmrcm2qy0wrvxwkaycbqlhgx1zixxl3z";
        libraryHaskellDepends = [
-         base bimap bv-sized containers copilot-core data-default directory
-         libBF mtl panic parameterized-utils parsec pretty process random
-         transformers what4 xml
+         base bimap bv-sized containers copilot-core copilot-prettyprinter
+         data-default directory libBF mtl panic parameterized-utils parsec
+         pretty process random transformers what4 xml
        ];
        description = "k-induction for Copilot";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "cryptostore";
-       version = "0.2.2.0";
-       sha256 = "0n70amg7y2qwfjhj4xaqjia46fbabba9l2g19ry191m7c4zp1skx";
+       version = "0.2.3.0";
+       sha256 = "1w84klg3r10vapkc8s6q21ldnp3014x9nvi5ffsmzikn7g7pw1g5";
        libraryHaskellDepends = [
          asn1-encoding asn1-types base basement bytestring cryptonite
          hourglass memory pem x509 x509-validation
···
     ({ mkDerivation, base, hspec }:
      mkDerivation {
        pname = "data-elevator";
-       version = "0.1.0.0";
-       sha256 = "1pv9z25fmqrjyh0zfbiy8wmcmhsr2r6x3hip8zgavaa7f5qb8n4y";
+       version = "0.1.0.1";
+       sha256 = "0j2adsqn3r23jjwl5p0kyf2z1wd2kibfqivdcchngsmf3yfr34sz";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        description = "Coerce between unlifted boxed and lifted types";
···
      }:
      mkDerivation {
        pname = "dep-t";
-       version = "0.6.2.0";
-       sha256 = "1wpb5p07vvny0bhapi87iwh43nykgy6b25xmsxsp403mbnv9g9ws";
+       version = "0.6.4.0";
+       sha256 = "1xrazkn8pdzkjrcia9ndxiva483w9fyclcq562assnv9j3svi145";
        libraryHaskellDepends = [ base mtl transformers unliftio-core ];
        testHaskellDepends = [
          aeson barbies base bytestring containers doctest mtl rank2classes
···
      }:
      mkDerivation {
        pname = "dep-t-dynamic";
-       version = "0.1.0.2";
-       sha256 = "0dv7ydxqgmgphcjgphrdf6jghkykvg5nnppgpgglwi2rg7yfmp7i";
+       version = "0.1.1.0";
+       sha256 = "1vh4igb25di61by6dhfnv2ans2ryk6j2sh8bp8rp8yawnwsidyx9";
        libraryHaskellDepends = [
          algebraic-graphs base dep-t hashable sop-core transformers
          unordered-containers
···
        pname = "dhall";
        version = "1.41.2";
        sha256 = "14m5rrvkid76qnvg0l14xw1mnqclhip3gjrz20g1lp4fd5p056ka";
-       revision = "2";
-       editedCabalFile = "18jh1c2zinwglih5gc8av2szicyywq5q0kl2h5200sm67nxmask9";
+       revision = "3";
+       editedCabalFile = "1j8hhg6jxzvg1lh5lad9wp54fi0znq5syfxa7rpr6sw0v6257fi1";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "dhall-docs";
        version = "1.0.10";
        sha256 = "1rh6nxmjin8kvbscbhbcjsgxnlkw1r19plzpps6wkx86zfjd2ms2";
-       revision = "2";
-       editedCabalFile = "1zm07bnaf6j0h5x2rlyvi4fs5d42w2v5z11qxc7gysqp1k2p99m1";
+       revision = "3";
+       editedCabalFile = "06pjafliw9a3pzw9846yb9rmsjrwrn7jhax7s2bsdasx5agdrfg5";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "diagrams-contrib";
        version = "1.4.4";
        sha256 = "043jpr7lqg708lzmv6cqys7312lfdwnf8ijcnpl4jkbvcwl87c1m";
-       revision = "6";
-       editedCabalFile = "1jdya89yf8r11mr0b587w7k4f5g40709048wxpijczla169f4is8";
+       revision = "7";
+       editedCabalFile = "0jwj06c2bqawpr57y2x8hbnjlsl1nv9k7wjxhk56w240qyspmj3p";
        libraryHaskellDepends = [
          base circle-packing colour containers cubicbezier data-default
          data-default-class diagrams-core diagrams-lib diagrams-solve
···
      }) {};
 
   "dnf-repo" = callPackage
-    ({ mkDerivation, base, directory, extra, filepath, Glob, simple-cmd
-     , simple-cmd-args
+    ({ mkDerivation, base, directory, extra, filepath, Glob
+     , http-directory, simple-cmd, simple-cmd-args
      }:
      mkDerivation {
        pname = "dnf-repo";
-       version = "0.5";
-       sha256 = "1adpbm76kra59jgbrx2b1lzi06lq3znwqy8wapx0p5qsf630kilw";
+       version = "0.5.1";
+       sha256 = "158gfmdwf77yd623782pjv4702xjnqfr5dxwl4chrbanvsdfg7si";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
-         base directory extra filepath Glob simple-cmd simple-cmd-args
+         base directory extra filepath Glob http-directory simple-cmd
+         simple-cmd-args
        ];
        testHaskellDepends = [ base simple-cmd ];
        description = "DNF wrapper tool to control repos";
···
      }:
      mkDerivation {
        pname = "effectful";
-       version = "2.2.0.0";
-       sha256 = "0zymvpg7bbvgwpziqj3bfpxbb77d45kph0qcrdilfi9w1bbjg63r";
+       version = "2.2.1.0";
+       sha256 = "0p2kr9vcyhcpvyrqbvwmjjh4k2lsrrhhq6rdi087iyvd7vj33al2";
        libraryHaskellDepends = [
          async base bytestring directory effectful-core process stm time
          unliftio
···
      }:
      mkDerivation {
        pname = "effectful-core";
-       version = "2.2.0.0";
-       sha256 = "0i4ybsqkamsg91vp4pkr7pxpscfk5n44far9c53cbnh49nx14jqg";
+       version = "2.2.1.0";
+       sha256 = "0439fk1gr2jq663zl6p0ra9hkzmjm9ad24wnbrbz1nnl5v01ay2s";
        libraryHaskellDepends = [
          base containers exceptions monad-control primitive
          transformers-base unliftio-core
···
      }:
      mkDerivation {
        pname = "elm-bridge";
-       version = "0.8.0";
-       sha256 = "05xnbwxzxm80xccrd5g4f83gsvs7gmyg9a7a0xxyk10qx93j4rs3";
+       version = "0.8.1";
+       sha256 = "0qhxjgjmbs2gr43rzxhzr6hjygkjr7fiqka93vsfi13hpv6bw2p7";
        libraryHaskellDepends = [ aeson base template-haskell ];
        testHaskellDepends = [
          aeson base containers hspec QuickCheck text
···
      }:
      mkDerivation {
        pname = "ersatz";
-       version = "0.4.12";
-       sha256 = "0xdmp8yc22flb2p7bczb56k2z79kp4zs0y9x5430029whhz90bar";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         array attoparsec base bytestring containers data-default lens mtl
-         process semigroups streams temporary transformers
-         unordered-containers
-       ];
-       executableHaskellDepends = [
-         array base containers fail lens mtl parsec semigroups
-       ];
-       testHaskellDepends = [ array base ];
-       description = "A monad for expressing SAT or QSAT problems using observable sharing";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "ersatz_0_4_13" = callPackage
-    ({ mkDerivation, array, attoparsec, base, bytestring, containers
-     , data-default, fail, lens, mtl, parsec, process, semigroups
-     , streams, temporary, transformers, unordered-containers
-     }:
-     mkDerivation {
-       pname = "ersatz";
        version = "0.4.13";
        sha256 = "0ph2ayw4vb4rrgfmm8dhwr18172igx2sczjhv2vf3b6vd5r0z1hy";
        isLibrary = true;
···
      }:
      mkDerivation {
        pname = "evdev";
-       version = "2.1.0";
-       sha256 = "1gzf9hpsi2dmcgsifq5z91ing9b5k56mm2hx9wbsa180pmq30lj3";
-       revision = "1";
-       editedCabalFile = "0c930gd1a9pwlr4p9r9d9nizr90g06l836rai5b83z5sa0s3p01n";
+       version = "2.2.0";
+       sha256 = "128i0rlxdskd63jjz887c0mjrrcm0v4xac8k2m0csglp7jap1cb7";
        libraryHaskellDepends = [
          base bytestring containers extra filepath-bytestring monad-loops
          rawfilepath time unix
···
        description = "Bridge for working with evdev and streamly";
        license = lib.licenses.bsd3;
        platforms = lib.platforms.linux;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "eve" = callPackage
···
        broken = true;
      }) {};
 
+  "faster-megaparsec" = callPackage
+    ({ mkDerivation, base, bytestring, cassava, containers, deepseq
+     , directory, megaparsec, mtl, QuickCheck, tasty-bench, temporary
+     , text
+     }:
+     mkDerivation {
+       pname = "faster-megaparsec";
+       version = "0.1.2.0";
+       sha256 = "0xrwh9jnbjq5i7iry0w3yz60qqi5qy46qq4fq31880rjm87qc68b";
+       libraryHaskellDepends = [ base megaparsec mtl ];
+       testHaskellDepends = [
+         base containers megaparsec QuickCheck text
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring cassava containers deepseq directory megaparsec
+         QuickCheck tasty-bench temporary text
+       ];
+       description = "Speed up Megaparsec parsing when parsing succeeds";
+       license = lib.licenses.gpl3Only;
+     }) {};
+
   "fastirc" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, bytestring-show
      , containers, monadLib, network-fancy
···
        maintainers = [ lib.maintainers.sternenseemann ];
      }) {};
 
-  "flat_0_5_2" = callPackage
+  "flat_0_6" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, deepseq
      , dlist, filepath, ghc-prim, hashable, list-t, mono-traversable
      , pretty, primitive, QuickCheck, quickcheck-text, tasty
···
      }:
      mkDerivation {
        pname = "flat";
-       version = "0.5.2";
-       sha256 = "189jgx5zd1m3wgn2mal93ak1p6qp9mkaz38gkfzvgv6nwgywxxix";
+       version = "0.6";
+       sha256 = "11mg3m760vm3b33c39h5n79lpsh9s4rjlmsmn6xxlycv2ms42cm4";
        libraryHaskellDepends = [
          array base bytestring containers deepseq dlist ghc-prim hashable
          list-t mono-traversable pretty primitive text unordered-containers
···
        mainProgram = "fourmolu";
      }) {};
 
-  "fourmolu_0_8_2_0" = callPackage
+  "fourmolu_0_9_0_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.2.0";
-       sha256 = "1wyfj3yfhp00pr0sjbkba8djjgp1pk8jabj48cps2nkgy5lqbyix";
+       version = "0.9.0.0";
+       sha256 = "0zq9fv5yszm7icirgwj8g4lhg21lg87fhz56sssjnfikzmkwyh1l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "ftp-client";
        version = "0.5.1.4";
        sha256 = "0c2xn2q24imrfgsx4zxzi24ciwkrly6n47lc5k5406j5b4znn5lf";
-       revision = "2";
-       editedCabalFile = "128c6lalfyjqsrycgk0773fwww3a914qd4w62vv3hx4vpmy75gq4";
+       revision = "3";
+       editedCabalFile = "1a7xya5c89lj4s73bd0cgr53id53xz4fnqzrizdibb6a90ml7g9r";
        libraryHaskellDepends = [
          attoparsec base bytestring connection containers exceptions network
          transformers
···
      }) {};
 
   "genvalidity-appendful" = callPackage
-    ({ mkDerivation, appendful, base, containers, criterion
-     , genvalidity, genvalidity-containers, genvalidity-criterion
-     , genvalidity-hspec, genvalidity-hspec-aeson, genvalidity-time
-     , genvalidity-uuid, hspec, mtl, pretty-show, QuickCheck, random
-     , time, uuid
+    ({ mkDerivation, appendful, autodocodec, autodocodec-yaml, base
+     , containers, criterion, genvalidity, genvalidity-containers
+     , genvalidity-criterion, genvalidity-sydtest
+     , genvalidity-sydtest-aeson, genvalidity-time, genvalidity-uuid
+     , mtl, pretty-show, QuickCheck, random, safe-coloured-text, sydtest
+     , sydtest-discover, time, uuid
      }:
      mkDerivation {
        pname = "genvalidity-appendful";
-       version = "0.0.0.0";
-       sha256 = "0sri0xdaqxpaapjspq4gipmvh7az3dilbzd4v5ihgcsjfk7kxmaj";
+       version = "0.1.0.0";
+       sha256 = "081a9m99mr1mvq9bysn3g0fq05f6zayb4401v6709jcw7szxfbwn";
        libraryHaskellDepends = [
          appendful base containers genvalidity genvalidity-containers
          genvalidity-time QuickCheck
        ];
        testHaskellDepends = [
-         appendful base containers genvalidity-hspec genvalidity-hspec-aeson
-         genvalidity-uuid hspec mtl pretty-show QuickCheck random time uuid
+         appendful autodocodec autodocodec-yaml base containers
+         genvalidity-sydtest genvalidity-sydtest-aeson genvalidity-uuid mtl
+         pretty-show QuickCheck random safe-coloured-text sydtest time uuid
        ];
+       testToolDepends = [ sydtest-discover ];
        benchmarkHaskellDepends = [
          appendful base criterion genvalidity-criterion
        ];
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "genvalidity-bytestring" = callPackage
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-exactprint_1_6_0" = callPackage
+  "ghc-exactprint_1_6_1" = callPackage
     ({ mkDerivation }:
      mkDerivation {
        pname = "ghc-exactprint";
-       version = "1.6.0";
-       sha256 = "1yj0vn42sysilikylabnncq2g005mnmpf8n7sn0a6lphpcv9gdcf";
+       version = "1.6.1";
+       sha256 = "1ihr3mffcm0z4plkgysiki5l225ayrxgjfjqx37ysqgp7vvnsr08";
        isLibrary = true;
        isExecutable = true;
        description = "ExactPrint for GHC";
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib_9_2_4_20220729" = callPackage
+  "ghc-lib_9_2_5_20221107" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, exceptions, filepath, ghc-lib-parser
      , ghc-prim, happy, hpc, parsec, pretty, process, rts, time
···
      }:
      mkDerivation {
        pname = "ghc-lib";
-       version = "9.2.4.20220729";
-       sha256 = "16whiazjynzj6qw1rmadyrxkibvmyhfzxzw42cv0ya9ijzlplhpq";
+       version = "9.2.5.20221107";
+       sha256 = "0layv7zsjlah3dmr538g34pg7cwwiawg0xcihyjxdh2x5q5qi05s";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-lib_9_4_2_20220822" = callPackage
+  "ghc-lib_9_4_3_20221104" = 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.2.20220822";
-       sha256 = "0ri29jyrs31ai4a1w3a9jwxc6xb1hqp64gxbwb5y7mbfyi5ray30";
+       version = "9.4.3.20221104";
+       sha256 = "0qvlf7i5lk7d4q8kaq4b783kvrswl9q5idlw3ggqhph910bgvcwn";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ghc-lib-parser_9_2_4_20220729" = callPackage
+  "ghc-lib-parser_9_2_5_20221107" = 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.2.4.20220729";
-       sha256 = "0rlm6znxrhs3s9s6c7qblvl03lscydx3dridyp985i593jyan55s";
+       version = "9.2.5.20221107";
+       sha256 = "1xh8rm5lwbh96g4v34whkcbb1yjsyvx3rwwycj30lrglhqk7f4c4";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-lib-parser_9_4_2_20220822" = callPackage
+  "ghc-lib-parser_9_4_3_20221104" = 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.2.20220822";
-       sha256 = "0irqp5v5vsmv4jmwizl0ag9v43bxfi14m2n977xzya27fdwzvc9y";
+       version = "9.4.3.20221104";
+       sha256 = "10j4vfpajr716bnipfr1rfc6r99gdfc3pjmp80lqdsfzv7xfbgj4";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
      }:
      mkDerivation {
        pname = "gopro-plus";
-       version = "0.6.6.0";
-       sha256 = "1pc89l3kirw7d8bzzbsivnf2mcfd15bk3kl1x2f7i0fdgk06apzy";
+       version = "0.6.6.3";
+       sha256 = "0rxkpxm7606lpiw4csixqfmd025f7rp6ivv86c6ximjlqzz1krhz";
        libraryHaskellDepends = [
          aeson base bytestring containers exceptions filepath
          generic-deriving generic-random lens lens-aeson monad-logger mtl
···
      }:
      mkDerivation {
        pname = "graphql-client";
-       version = "1.1.1";
-       sha256 = "1d00ib9c8ps8vv1qgrkjfzrjbgbsdnp1jiz7779bwm76j88vggb4";
-       revision = "5";
-       editedCabalFile = "0kbpsca7iybc1ra1fm04c8axmbd18czgn1rq93j0ak9979yw79gd";
+       version = "1.2.0";
+       sha256 = "1570gsfz3f2dlqpmmb00kr2hcjsfz9p4knfnwvjcm2lij7avcvnp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "h-raylib" = callPackage
-    ({ mkDerivation, base, c, libGL, libX11, libXcursor, libXi
+    ({ mkDerivation, base, c, libGL, libX11, libXcursor, libXext, libXi
      , libXinerama, libXrandr
      }:
      mkDerivation {
        pname = "h-raylib";
-       version = "4.5.0.2";
-       sha256 = "0yxjr2y12fj2mhis8gy3wz0115nbiznx6llxapbylcw4zx9vnb8i";
+       version = "4.5.0.3";
+       sha256 = "05k7z23fkjdwlq379vcd9ahqch52hkwlpmy774xafrbh2wrfli3d";
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [
-         c libGL libX11 libXcursor libXi libXinerama libXrandr
+         c libGL libX11 libXcursor libXext libXi libXinerama libXrandr
        ];
        description = "Raylib bindings for Haskell";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {c = null; inherit (pkgs) libGL; inherit (pkgs.xorg) libX11; 
-         inherit (pkgs.xorg) libXcursor; inherit (pkgs.xorg) libXi; 
-         inherit (pkgs.xorg) libXinerama; inherit (pkgs.xorg) libXrandr;};
+         inherit (pkgs.xorg) libXcursor; inherit (pkgs.xorg) libXext; 
+         inherit (pkgs.xorg) libXi; inherit (pkgs.xorg) libXinerama; 
+         inherit (pkgs.xorg) libXrandr;};
 
   "h-reversi" = callPackage
     ({ mkDerivation, base, blank-canvas, containers, hspec, QuickCheck
···
   "hadolint" = callPackage
     ({ mkDerivation, aeson, base, bytestring, Cabal, colourista
      , containers, cryptonite, data-default, deepseq, directory
-     , email-validate, filepath, foldl, gitrev, hspec, HsYAML, HUnit
-     , ilist, language-docker, megaparsec, mtl, network-uri
-     , optparse-applicative, parallel, parsec, prettyprinter, semver
-     , ShellCheck, silently, spdx, split, text, time, timerep, void
+     , email-validate, filepath, foldl, gitrev, hspec, hspec-discover
+     , HsYAML, HUnit, ilist, language-docker, megaparsec, mtl
+     , network-uri, optparse-applicative, parallel, parsec
+     , prettyprinter, semver, ShellCheck, silently, spdx, split, text
+     , time, timerep, void
      }:
      mkDerivation {
        pname = "hadolint";
-       version = "2.11.0";
-       sha256 = "1k5xjy064q6v306kaqkglkwzk5qwnljs7x550rxjk6012d8allcm";
+       version = "2.12.0";
+       sha256 = "190ighmy5bg21b67n8msli8im6xp1z4bh3cjadfpr76mikxk25vl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          HUnit language-docker megaparsec optparse-applicative ShellCheck
          silently split text
        ];
+       testToolDepends = [ hspec-discover ];
        description = "Dockerfile Linter JavaScript API";
        license = lib.licenses.gpl3Only;
        mainProgram = "hadolint";
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "hal_1_0_0" = callPackage
+  "hal_1_0_0_1" = callPackage
     ({ mkDerivation, aeson, base, base64-bytestring, bytestring
      , case-insensitive, conduit, conduit-extra, containers, exceptions
      , hashable, hedgehog, hspec, hspec-hedgehog, http-client
···
      }:
      mkDerivation {
        pname = "hal";
-       version = "1.0.0";
-       sha256 = "0mfdxjlypb1sj2kcsqks6anh80xy1azcg9lvlpkgz7dgdpjfygaq";
-       revision = "2";
-       editedCabalFile = "0hc2b8bdsbd1q1j7d8l64d51q3apsmsfs1blzw0fg3cjzd4v2slc";
+       version = "1.0.0.1";
+       sha256 = "1gdd0nbwm6hma57nw1y1gd0cc6z9zhhmim6l5miql2j6dk909mdv";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring case-insensitive conduit
          conduit-extra containers exceptions hashable http-client http-types
···
      }) {};
 
   "hspec-jenkins" = callPackage
-  "hspec-jenkins" = callPackage
-  "hspec-jenkins" = callPackage
+    ({ mkDerivation, base, bytestring, derive-storable, freetype2
+     , harfbuzz, parallel, text, utf8-light
      }:
      mkDerivation {
   "hspec-jenkins" = callPackage
-       version = "0.1.0.0";
-  "hspec-jenkins" = callPackage
+       version = "1.0.0.0";
+       sha256 = "1bydw57ab1qlicrs6cav3vk0jzqkvhnwb8c0k7ba48fmjyihi5fp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-  "hspec-jenkins" = callPackage
+         base bytestring derive-storable freetype2 text utf8-light
        ];
   "hspec-jenkins" = callPackage
-  "hspec-jenkins" = callPackage
+       executableHaskellDepends = [ base bytestring parallel text ];
   "hspec-jenkins" = callPackage
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
   "hspec-jenkins" = callPackage
+       broken = true;
   "hspec-jenkins" = callPackage
 
   "hspec-jenkins" = callPackage
···
        pname = "hex-text";
        version = "0.1.0.6";
        sha256 = "1a5ccvbj7asbx92f4309qfwwih8ffnfi5kkahdn6dp444xa374r7";
+       revision = "2";
+       editedCabalFile = "00bwakiri9vbn05zi7alwhl5rdg13ls3pydcrgc0q4v8banrp868";
        libraryHaskellDepends = [ base base16-bytestring bytestring text ];
        testHaskellDepends = [ base base16-bytestring bytestring text ];
        description = "ByteString-Text hexidecimal conversions";
        license = lib.licenses.mit;
+     }) {};
+
+  "hex-text_0_1_0_7" = callPackage
+    ({ mkDerivation, base, base16-bytestring, bytestring, text }:
+     mkDerivation {
+       pname = "hex-text";
+       version = "0.1.0.7";
+       sha256 = "1xyyr6570dbp6mgarz8v56s9kg4pfzk1dc10nw0gg51j6xl1c2zn";
+       libraryHaskellDepends = [ base base16-bytestring bytestring text ];
+       testHaskellDepends = [ base base16-bytestring bytestring text ];
+       description = "ByteString-Text hexidecimal conversions";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hexchat" = callPackage
···
      }:
      mkDerivation {
        pname = "hpc-lcov";
-       version = "1.0.1";
-       sha256 = "01ws5y2vavgm7151dcabw3jwny1prrnzn5b04q76m5gc6a36wivl";
-       revision = "4";
-       editedCabalFile = "0mds8q19pqxgrmyzgzrc01zb6wf7gx5cjl8brvw7ljkyrb2n2lya";
+       version = "1.1.0";
+       sha256 = "009z1i0ddjx7sazybirrpw99675p1fyl84ykg4dyypa7rz81vv3z";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers hpc ];
···
   "inline-r" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, criterion
      , data-default-class, deepseq, directory, exceptions, filepath
-     , ieee754, inline-c, mtl, pretty, primitive, process
+     , heredoc, ieee754, inline-c, mtl, pretty, primitive, process
      , quickcheck-assertions, R, reflection, setenv, silently
-     , singletons, strict, tasty, tasty-expected-failure, tasty-golden
-     , tasty-hunit, tasty-quickcheck, template-haskell, temporary, text
-     , th-lift, th-orphans, transformers, unix, vector
+     , singletons, singletons-th, strict, tasty, tasty-expected-failure
+     , tasty-golden, tasty-hunit, tasty-quickcheck, template-haskell
+     , temporary, text, th-lift, th-orphans, transformers, unix, vector
      }:
      mkDerivation {
        pname = "inline-r";
-       version = "0.10.5";
-       sha256 = "1jaj3p4vj9g1pk4rfs1sywbq04w24g137yvl6g6mlsxyzd4mldwh";
+       version = "1.0.0";
+       sha256 = "0b7xsfglhb9mjac79ch07fd426bkdg22nwdg50j3jj906bi65jba";
        libraryHaskellDepends = [
          aeson base bytestring containers data-default-class deepseq
-         exceptions inline-c mtl pretty primitive process reflection setenv
-         singletons template-haskell text th-lift th-orphans transformers
-         unix vector
+         exceptions heredoc inline-c mtl pretty primitive process reflection
+         setenv singletons singletons-th template-haskell temporary text
+         th-lift th-orphans transformers unix vector
        ];
        libraryPkgconfigDepends = [ R ];
        testHaskellDepends = [
-         base bytestring directory filepath ieee754 mtl process
+         base bytestring directory filepath heredoc ieee754 mtl process
          quickcheck-assertions silently singletons strict tasty
          tasty-expected-failure tasty-golden tasty-hunit tasty-quickcheck
          template-haskell temporary text unix vector
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "language-docker_12_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, data-default
+     , data-default-class, hspec, hspec-megaparsec, HUnit, megaparsec
+     , prettyprinter, QuickCheck, split, text, time
+     }:
+     mkDerivation {
+       pname = "language-docker";
+       version = "12.0.0";
+       sha256 = "1slrq343rcg9shmqxxy8kzk911071x31q61q75dnldnm3x27j6by";
+       libraryHaskellDepends = [
+         base bytestring containers data-default data-default-class
+         megaparsec prettyprinter split text time
+       ];
+       testHaskellDepends = [
+         base bytestring containers data-default data-default-class hspec
+         hspec-megaparsec HUnit megaparsec prettyprinter QuickCheck split
+         text time
+       ];
+       description = "Dockerfile parser, pretty-printer and embedded DSL";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "language-dockerfile" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory, filepath, free
      , Glob, hspec, HUnit, mtl, parsec, pretty, process, QuickCheck
···
      }:
      mkDerivation {
        pname = "launchdarkly-server-sdk";
-       version = "3.0.2";
-       sha256 = "1wh0an9g3hzpmdp2jayag7dknajivl07h273ar1qplrfd1js5fd6";
+       version = "3.0.3";
+       sha256 = "0j5j4x94r7ha7amv0cggs7n7n9vyx1ga5kwdr8mcddc7karz18cg";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring bytestring clock containers
          cryptohash exceptions extra generic-lens hashtables hedis
···
     ({ mkDerivation, array, base, constraints }:
      mkDerivation {
        pname = "linear-smc";
-       version = "1.0.0";
-       sha256 = "13b1gvpnpxvkswigd9cdq289m6d68vqddnq95p0i65vr2hhard8i";
+       version = "1.0.1";
+       sha256 = "0xgrsjqfxzz1qbphv9r0kh4agg6cjz712isk5c16zywldw5hrx9q";
        libraryHaskellDepends = [ base constraints ];
        testHaskellDepends = [ array base constraints ];
        description = "Build SMC morphisms using linear types";
···
     ({ mkDerivation, base, tidal }:
      mkDerivation {
        pname = "maquinitas-tidal";
-       version = "0.2.10";
-       sha256 = "1p1n21hzmkk7czwnmyl4hm36jvn0m05wid3zdwiqhbxq3mw46sxa";
+       version = "0.2.11";
+       sha256 = "1bg0az68jzxkb54rx7zf7bbkdkp5h0aqxyy78d8caaimc5ch2mbv";
        libraryHaskellDepends = [ base tidal ];
        description = "library for MIDI control of hardware";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "migrant-core";
-       version = "0.1.0.2";
-       sha256 = "1na0vcrmw3vy6v9qxxpprhga9ja7izwbp856pdpqiq98p4h8xmiw";
+       version = "0.1.0.3";
+       sha256 = "15g7w2bpzhpp0gann0s8sj5ha315jf3bwlhkapfbrbjmswph0fgf";
        libraryHaskellDepends = [ base text ];
        testHaskellDepends = [
          base HUnit QuickCheck tasty tasty-hunit tasty-quickcheck text
···
      }:
      mkDerivation {
        pname = "migrant-hdbc";
-       version = "0.1.0.2";
-       sha256 = "084vqb1z0ipxn07nswlcw0bbh0bfywm7hyvakb75xg8rv5kfak15";
+       version = "0.1.0.3";
+       sha256 = "181n17jxwii3c64crzrpxry9fbpmclpanf6sqbb3rc9vdpm7df0g";
        libraryHaskellDepends = [ base HDBC migrant-core text ];
        testHaskellDepends = [
          base HDBC HDBC-sqlite3 HUnit migrant-core process QuickCheck random
···
      }:
      mkDerivation {
        pname = "migrant-postgresql-simple";
-       version = "0.1.0.2";
-       sha256 = "1x1gsf0vp82n6dmyiamj1cvs9fww7j1ffh6d9qr075z5sj8zbhzx";
+       version = "0.1.0.3";
+       sha256 = "096lj9ibminyfb09ciab20q014mqhwahqh3prc530lhv5arin1ml";
        libraryHaskellDepends = [
          base migrant-core postgresql-simple text
        ];
···
      }:
      mkDerivation {
        pname = "migrant-sqlite-simple";
-       version = "0.1.0.2";
-       sha256 = "140fchiid0kjp1cdw114w497h0fsrskn9195bkjv44sdmq2l8car";
+       version = "0.1.0.3";
+       sha256 = "0gcji3kmdndn77kg74bxki32fwrvzafjv4svpxj31advprn6jdgx";
        libraryHaskellDepends = [ base migrant-core sqlite-simple text ];
        testHaskellDepends = [
          base HUnit migrant-core QuickCheck sqlite-simple tasty tasty-hunit
···
     ({ mkDerivation, base, doctest, typelits-witnesses }:
      mkDerivation {
        pname = "modular-arithmetic";
-       version = "2.0.0.1";
-       sha256 = "132cxgrw6lsdkpqi69v1f9jgl5icslwi5qclv4rc03hn0mcnl2sz";
+       version = "2.0.0.2";
+       sha256 = "1bbn3pwvpl9v7a8gkxx83w2s8mk2q9gin7yvkkr97f64rdf8lnrq";
        libraryHaskellDepends = [ base typelits-witnesses ];
        testHaskellDepends = [ base doctest typelits-witnesses ];
        description = "A type for integers modulo some constant";
···
      }:
      mkDerivation {
        pname = "monad-bayes";
-       version = "1.0.0";
-       sha256 = "1s5niiss16a5lgw2jhda3c34r1ylcjb5k14bk0n7p7l117xpxsza";
+       version = "1.1.0";
+       sha256 = "0zpgmai2wh8iqdg8ds9y1928fsila80dhpidgz4hp0jkxkk988gh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "A library for probabilistic programming";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "example";
+       broken = true;
      }) {};
 
   "monad-bool" = callPackage
···
      }:
      mkDerivation {
        pname = "morpheus-graphql";
-       version = "0.25.0";
-       sha256 = "08vi8g73c55ky6qrgkq57h1zbpkavv0ajfd16i86s6zdaxpk3fhm";
+       version = "0.26.0";
+       sha256 = "1x1hg60l7zbdb7kg2gx93zxknd9f7bbdvr6r9hcy8w86h8aplilm";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers morpheus-graphql-app
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-app";
-       version = "0.25.0";
-       sha256 = "09skrg2pasx3hdm13sq9ajka5yh5wsc1wc8rphc9g6pa7hpnnsxh";
+       version = "0.26.0";
+       sha256 = "1dq0hnm1bsy43vbrs2rm5df5j9yy55azj420jf8fs71676xni7hn";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers hashable megaparsec
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-client";
-       version = "0.25.0";
-       sha256 = "01brdkc2vqipif5942hrzli45agb7rk8wlhx2m1j9zhcxhsbhlwf";
+       version = "0.26.0";
+       sha256 = "0n8x888qhamlb6pkk4sa864mb3y7h261s1f83waqg0d7qdwcp5nx";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers file-embed modern-uri
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-code-gen";
-       version = "0.25.0";
-       sha256 = "0hisqds2fn7m53hddvxw4glgwghqnx3qg0hhdc6c4zjafyfkbckf";
+       version = "0.26.0";
+       sha256 = "1mdhifqqj44dr9j2z4nh0m8n4836mv8cav9qn155b3nairfh3w3a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-code-gen-utils";
-       version = "0.25.0";
-       sha256 = "1xnszpmzw0jl9dshzqs5vr9kjnm9sbi0jbgpjb44s9bd4hdgyxq5";
+       version = "0.26.0";
+       sha256 = "0nhv20vn8v73zri9ws3rwyi9xyshp6pm7v610rrwfa43wyxlpq5g";
        libraryHaskellDepends = [
          base bytestring containers morpheus-graphql-core prettyprinter
          relude template-haskell text unordered-containers
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-core";
-       version = "0.25.0";
-       sha256 = "07ay9vzhlxgsv9lw3b22c59r00b6f0w2c90qn14a349lkjhl1wfa";
+       version = "0.26.0";
+       sha256 = "0cj78h29ryalxnx4hzpl5kywqdcvjxvxqlc6axibb1cmajn4kbqm";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers hashable megaparsec mtl relude
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-server";
-       version = "0.25.0";
-       sha256 = "02lhrvz00l2486n7nihs8ka92hxa3idzlzx10fn142kqli65bwwi";
+       version = "0.26.0";
+       sha256 = "1aca18d60ja6awgsvwjjbikqhvspn3wans1dvh57g37ma1p1v331";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers morpheus-graphql-app
···
      }:
      mkDerivation {
        pname = "morpheus-graphql-subscriptions";
-       version = "0.25.0";
-       sha256 = "063gszwrjlszqg973axyig9alrix0fj7j4n2c01wdaxyjmxmzdjx";
+       version = "0.26.0";
+       sha256 = "1kmd37w3kp2mdhz64fwlyl9v7p10x3p6fbzw535kipic89y9pcx2";
        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_25_0" = callPackage
+  "morpheus-graphql-tests_0_26_0" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory, relude, tasty
      , tasty-hunit, text, unordered-containers
      }:
      mkDerivation {
        pname = "morpheus-graphql-tests";
-       version = "0.25.0";
-       sha256 = "1gnysygk4rvcyv85f86yhcxl0rlq5hk5avanyv428fdirsjkkn5q";
+       version = "0.26.0";
+       sha256 = "0dyza53pp9s16y8mlpm63b9ds396lqf8wsj2qaymyy18iakcfb9m";
        libraryHaskellDepends = [
          aeson base bytestring directory relude tasty tasty-hunit text
          unordered-containers
···
     ({ mkDerivation, base, hspec }:
      mkDerivation {
        pname = "mr-env";
-       version = "0.1.0.4";
-       sha256 = "05f89d0lxmi8w7hgdlqrgxh2abnjghcgjhzmra41p28h26adqnfm";
+       version = "0.1.0.5";
+       sha256 = "0hy9hqy3ijrg4l85lj6g5y48cj812y7i6nkb4q8cq2yshdchj6pi";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        description = "A simple way to read environment variables in Haskell";
···
      }:
      mkDerivation {
        pname = "mysql-simple";
-       version = "0.4.8.1";
-       sha256 = "18w6mp7s1dmvwzqdgdzywhp5li3h4kisrhgxllwi578nddwg2yx3";
-       libraryHaskellDepends = [
-         attoparsec base base16-bytestring blaze-builder bytestring
-         containers mysql old-locale pcre-light text time vector
-       ];
-       testHaskellDepends = [
-         base blaze-builder bytestring hspec mysql text time
-       ];
-       description = "A mid-level MySQL client library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "mysql-simple_0_4_9" = callPackage
-    ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder
-     , bytestring, containers, hspec, mysql, old-locale, pcre-light
-     , text, time, vector
-     }:
-     mkDerivation {
-       pname = "mysql-simple";
        version = "0.4.9";
        sha256 = "0hwv1hlr65m5l2zrrj5zmvrjz9y2814jy05l17l5jb4j4j5xw3z2";
        libraryHaskellDepends = [
···
        ];
        description = "A mid-level MySQL client library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "mysql-simple-quasi" = callPackage
···
        license = lib.licenses.asl20;
      }) {};
 
+  "nvim-hs_2_3_0_0" = 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.3.0.0";
+       sha256 = "0jc0wzxfkah115j0y4pa4hvr4wziba4q319x5ddgb9jbc52rqh7r";
+       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
···
      }:
      mkDerivation {
        pname = "oidc-client";
-       version = "0.6.1.0";
-       sha256 = "0hhjndh4q2a9694rhylrqk2a8bzy8x9i5k4is2w7709sifydip1y";
+       version = "0.7.0.0";
+       sha256 = "0cc1psif3s6qmina5sx49clvpg54b6sapcvq4ax3r0afsp4hdl3m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, containers }:
      mkDerivation {
        pname = "ordered-containers";
-       version = "0.2.2";
-       sha256 = "1j92dm36s0cfhc7s4k3dk36ibkvr6w1nhaq6q1m5vkbh1qrwfnn7";
-       libraryHaskellDepends = [ base containers ];
-       description = "Set- and Map-like types that remember the order elements were inserted";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "ordered-containers_0_2_3" = callPackage
-    ({ mkDerivation, base, containers }:
-     mkDerivation {
-       pname = "ordered-containers";
        version = "0.2.3";
        sha256 = "18w1dasny6xffbjlvmz9861l2xbkqlg2w5qxz9kw6frgfl2rg11n";
        libraryHaskellDepends = [ base containers ];
        description = "Set- and Map-like types that remember the order elements were inserted";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ordering-util" = callPackage
···
        pname = "palette";
        version = "0.3.0.2";
        sha256 = "0820n3cj4zy9s46diln2rrs4lrxbipkhdw74p2w42gc7k1nlj54i";
-       revision = "4";
-       editedCabalFile = "07yjz9hsmfm5jh05i4nqc6iax61ssr97475l7pf3bbdp8bam39wl";
+       revision = "5";
+       editedCabalFile = "1h5vs204qkq0m9ks5sf7f300drpkinkhinvmnijq8x0mbjl8hsg4";
        libraryHaskellDepends = [
          array base colour containers MonadRandom
        ];
···
        pname = "phatsort";
        version = "0.5.0.1";
        sha256 = "14czx4s3ywfcxbw8lr60i3cdk62rcfr7m1v98mx3qm1gjinll5js";
-       revision = "1";
-       editedCabalFile = "06s8xg07za1d23wai8pb7gvbcri2vmbv0jks7as8d8mf82giqvz8";
+       revision = "2";
+       editedCabalFile = "087vq0cfrvqgqrph5kkpyrvyfc72n9jh7bip68s30w5y4v55a821";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "postgresql-migration";
-       version = "0.2.1.4";
-       sha256 = "0p8rggalgijw02p7m77x443md5dg1kjvvm06v980cchsj148c80s";
+       version = "0.2.1.6";
+       sha256 = "0zx6pa9s8k3gq1sgn8pj9xwdlj0wlx49d1mxgmd9s2zk9flfzybf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "project-m36";
-       version = "0.9.5";
-       sha256 = "01gd1hi7x515q1y2nz3zsx3481rb13f30i6xccyzm4fjn7p08mv7";
+       version = "0.9.6";
+       sha256 = "067z934phddvi7r4kp3b1ykfz62vak395j9wlwm36m9rn526ih8g";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          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
+         unordered-containers uuid vector wai warp websockets winery
        ];
        benchmarkHaskellDepends = [
          aeson attoparsec base base16-bytestring base64-bytestring
···
      }) {};
 
   "quickcheck-lockstep" = callPackage
-    ({ mkDerivation, base, containers, directory, filepath, mtl
-     , QuickCheck, quickcheck-dynamic, tasty, tasty-hunit
+    ({ mkDerivation, base, constraints, containers, directory, filepath
+     , mtl, QuickCheck, quickcheck-dynamic, tasty, tasty-hunit
      , tasty-quickcheck, temporary
      }:
      mkDerivation {
        pname = "quickcheck-lockstep";
-       version = "0.1.0";
-       sha256 = "0i0sqd5fky5d8imlrqazmr7cpdm71mdgv7sagyx9f1bb38p4yr9g";
+       version = "0.2.0";
+       sha256 = "1vc0ry2qp4c99pql6mgb4csffsjs9qgwciz58g68wbrjqp7rgm2w";
        libraryHaskellDepends = [
-         base containers mtl QuickCheck quickcheck-dynamic
+         base constraints containers mtl QuickCheck quickcheck-dynamic
        ];
        testHaskellDepends = [
-         base containers directory filepath mtl QuickCheck
+         base constraints containers directory filepath mtl QuickCheck
          quickcheck-dynamic tasty tasty-hunit tasty-quickcheck temporary
        ];
        description = "Library for lockstep-style testing with 'quickcheck-dynamic'";
···
      }:
      mkDerivation {
        pname = "ret";
-       version = "0.1.5.1";
-       sha256 = "0jac5hidynwqnfik8h2fkf45dm1cdf6ql6zxwyap14m7z3jbv48n";
+       version = "0.1.5.2";
+       sha256 = "1lsqjqib4nvxacsjlr4207vwwxdd86wxxjvxw4vqra6a5clj6g08";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "rio-prettyprint";
-       version = "0.1.1.0";
-       sha256 = "1h092l46pfm6k3n0vb6c67gb64kahzc97qv45rhvp0cq2y5bqykf";
+       version = "0.1.2.0";
+       sha256 = "0xql9rjd0b8vyfllb9h8j7nxbrnrvz9kkclzlb3wln10l9pi5v03";
        libraryHaskellDepends = [
          aeson annotated-wl-pprint ansi-terminal array base Cabal colour mtl
          path rio text
···
      }:
      mkDerivation {
        pname = "servant-polysemy";
-       version = "0.1.3";
-       sha256 = "132yf6fp0hl6k3859sywkfzsca8xsaqd3a4ca4vdqqjrllk0m88i";
+       version = "0.1.4";
+       sha256 = "07rma3yijvp9sd0lnnx77in0h4a8mm955v65hzh5mh0j91k406n2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "shake-cabal";
        version = "0.2.2.2";
        sha256 = "1z1l4mah7nmpa6ycx9f5ynr9rn24irs1w44nq1j3ck25b408g460";
+       revision = "1";
+       editedCabalFile = "0r2b00d0r2i73sw4h5sksdck70924k0485ayai22n3ybdj8h6xwx";
        libraryHaskellDepends = [
          base binary Cabal composition-prelude deepseq directory filepath
          hashable shake
···
      }:
      mkDerivation {
        pname = "slist";
-       version = "0.2.0.1";
-       sha256 = "1b7b869gg3bkhx8ija601gwx9521mqy5sxkizc7ss73pqj4bhv60";
-       libraryHaskellDepends = [ base containers ];
-       testHaskellDepends = [
-         base doctest Glob hedgehog hspec hspec-hedgehog
-       ];
-       description = "Sized list";
-       license = lib.licenses.mpl20;
-     }) {};
-
-  "slist_0_2_1_0" = callPackage
-    ({ mkDerivation, base, containers, doctest, Glob, hedgehog, hspec
-     , hspec-hedgehog
-     }:
-     mkDerivation {
-       pname = "slist";
        version = "0.2.1.0";
        sha256 = "1j52gvq42x03y7jq0pxzab98qnrsjg6qnw4ysq6cd89cx6gg04ab";
        libraryHaskellDepends = [ base containers ];
···
        ];
        description = "Sized list";
        license = lib.licenses.mpl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sloane" = callPackage
···
   "souffle-haskell" = callPackage
     ({ mkDerivation, array, base, bytestring, criterion, deepseq
      , directory, filepath, hedgehog, hspec, hspec-hedgehog, mtl
-     , process, profunctors, temporary, text, text-short
-     , type-errors-pretty, vector
+     , process, profunctors, temporary, text, text-short, vector
      }:
      mkDerivation {
        pname = "souffle-haskell";
-       version = "3.5.0";
-       sha256 = "1s6398wfm6wly72b7kb7l13lskc1v4iivzz9d0vbwr8jv83grjbr";
+       version = "3.5.1";
+       sha256 = "0vxwbs0nc7rvlcfb62nx8fa5kghwgxakg4djqmsrcq2qdvxvifbh";
        libraryHaskellDepends = [
          array base bytestring deepseq directory filepath mtl process
-         profunctors temporary text text-short type-errors-pretty vector
+         profunctors temporary text text-short vector
        ];
        testHaskellDepends = [
          array base directory hedgehog hspec hspec-hedgehog profunctors
···
        broken = true;
      }) {inherit (pkgs) sqlite;};
 
+  "sqlite-easy" = callPackage
+    ({ mkDerivation, base, bytestring, direct-sqlite, hspec
+     , hspec-discover, migrant-core, resource-pool, text
+     }:
+     mkDerivation {
+       pname = "sqlite-easy";
+       version = "0.1.0.0";
+       sha256 = "0i971dvfsdxpm6chxbc53flcw8gyk45nsp8pm0q2avl8p9sab05f";
+       revision = "1";
+       editedCabalFile = "0b3sa10mk3c2gjpsgdnylb3iqpwycfnhpscqhi68s0vfvq2ph9w8";
+       libraryHaskellDepends = [
+         base bytestring direct-sqlite migrant-core resource-pool text
+       ];
+       testHaskellDepends = [
+         base direct-sqlite hspec hspec-discover text
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A primitive yet easy to use sqlite library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "sqlite-simple" = callPackage
     ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder
      , blaze-textual, bytestring, containers, direct-sqlite, HUnit, Only
···
      }:
      mkDerivation {
        pname = "stackctl";
-       version = "1.1.0.1";
-       sha256 = "1rhwgc6qgip3p8qvyjahpk7xbv583p35rxba2x02ig7hbx3724y7";
+       version = "1.1.0.3";
+       sha256 = "0vvhvyvc6dz8l0df3f14qiy5851n2mv45gvjyz1cq94f44higfjw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "supply-chain" = callPackage
+    ({ mkDerivation, base, supply-chain-core }:
+     mkDerivation {
+       pname = "supply-chain";
+       version = "0.0.0.0";
+       sha256 = "12rdx593ivps3khxpvq0r1kc99jhzvc0qfkdxa7jdy0qn22fi3dx";
+       libraryHaskellDepends = [ base supply-chain-core ];
+       description = "Composable request-response pipelines";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "supply-chain-core" = callPackage
+    ({ mkDerivation, base, tasty, tasty-hedgehog, tasty-hunit }:
+     mkDerivation {
+       pname = "supply-chain-core";
+       version = "0.0.0.0";
+       sha256 = "17ih0pvfk0xzr30q9094gf8ry8pvnannr92hvk86z7j514nv6q9h";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base tasty tasty-hedgehog tasty-hunit ];
+       description = "Composable request-response pipelines";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "surjective" = callPackage
     ({ mkDerivation, base, lens, mtl, template-haskell }:
      mkDerivation {
···
     ({ mkDerivation, base, blaze-markup, blaze-svg, directory, text }:
      mkDerivation {
        pname = "svg-icons";
-       version = "2.3.0.0";
-       sha256 = "0ybnda16klwcajhhmzpiajdl39rkk52zb41k6b0qvd21dxmv2qji";
+       version = "2.5.0.1";
+       sha256 = "0iwrs53n6f4l2fqybamghbk5ha1w8vspiha6cnjx49hzljsjz738";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "2D resource gathering game with programmable robots";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "swarm";
-       broken = true;
      }) {};
 
   "swearjure" = callPackage
···
      }) {};
 
   "tasty-sugar" = callPackage
-    ({ mkDerivation, base, directory, filemanip, filepath, hedgehog
-     , kvitable, logict, microlens, mtl, optparse-applicative
-     , pretty-show, prettyprinter, raw-strings-qq, tasty, tasty-hedgehog
-     , tasty-hunit, text
+    ({ mkDerivation, base, containers, directory, filemanip, filepath
+     , hedgehog, kvitable, logict, microlens, mtl, optparse-applicative
+     , parallel, pretty-show, prettyprinter, raw-strings-qq, tasty
+     , tasty-hedgehog, tasty-hunit, text
      }:
      mkDerivation {
        pname = "tasty-sugar";
-       version = "1.3.0.2";
-       sha256 = "1hh2a3bzk0x0l4wqar7qb8kj9kwjlw1j5z7jxsia7a0p25wy8w8a";
+       version = "2.0.0.1";
+       sha256 = "0rgq5k9vv72c5826acpfscjfszvyi5bms5wjbw7bs0izimqw7b1j";
        libraryHaskellDepends = [
-         base directory filemanip filepath kvitable logict microlens mtl
-         optparse-applicative prettyprinter tasty text
+         base containers directory filemanip filepath kvitable logict
+         microlens mtl optparse-applicative parallel prettyprinter tasty
+         text
        ];
        testHaskellDepends = [
          base filepath hedgehog logict pretty-show prettyprinter
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "text-ansi_0_2_0" = callPackage
+  "text-ansi_0_2_1" = callPackage
     ({ mkDerivation, base, text, text-builder }:
      mkDerivation {
        pname = "text-ansi";
-       version = "0.2.0";
-       sha256 = "15sraxbiwwx49nz4kxhh2b45q222pcxzgm85rmaskpi7pswwj0b2";
+       version = "0.2.1";
+       sha256 = "1s0ad0nap9z0pzwl3nm2vglkz148qv120bngwy08bqb6vbs8w90p";
        libraryHaskellDepends = [ base text text-builder ];
        description = "Text styling for ANSI terminals";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "text-compression" = callPackage
-    ({ mkDerivation, base, containers, massiv, mtl }:
+    ({ mkDerivation, base, bytestring, containers, massiv, mtl, text }:
      mkDerivation {
        pname = "text-compression";
-       version = "0.1.0.4";
-       sha256 = "15bkgmlav4aybsgh7wg261fkhqg7phsc91sp1w26f9m2wb278xby";
-       libraryHaskellDepends = [ base containers massiv mtl ];
+       version = "0.1.0.7";
+       sha256 = "0sxzcdfx2v0870w130vkw6iyg5w0k8vvkz7fj3b50kr4wl9wypb4";
+       libraryHaskellDepends = [
+         base bytestring containers massiv mtl text
+       ];
        description = "A text compression library";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "text-containers" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "th-test-utils_1_2_0" = callPackage
+    ({ mkDerivation, base, bytestring, tasty, tasty-golden, tasty-hunit
+     , template-haskell, th-orphans, transformers
+     }:
+     mkDerivation {
+       pname = "th-test-utils";
+       version = "1.2.0";
+       sha256 = "0p5j5mgjqwvkw0rcxlfkcflyqdz972ls70lprn38yjb32v3l8ncf";
+       libraryHaskellDepends = [
+         base template-haskell th-orphans transformers
+       ];
+       testHaskellDepends = [
+         base bytestring tasty tasty-golden tasty-hunit template-haskell
+         th-orphans transformers
+       ];
+       description = "Utility functions for testing Template Haskell code";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "th-to-exp" = callPackage
     ({ mkDerivation, base, hspec, template-haskell }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "tibetan-utils";
-       version = "0.1.2.0";
-       sha256 = "1bw10jahy0s9ai6ryfdx58jzjib146x7kzqkg65z71brvm0cliza";
+       version = "0.1.2.1";
+       sha256 = "1crs90dy9ljprxb19x3zj92579njjw6ki5jnnjj8afrharim9ppj";
        libraryHaskellDepends = [
          base composition-prelude megaparsec text
        ];
···
        pname = "timer-wheel";
        version = "0.3.0";
        sha256 = "16v663mcsj0h17x4jriq50dps3m3f8wqcsm19kl48vrs7f4mp07s";
-       revision = "2";
-       editedCabalFile = "0kfckbmcf9c8538i38r40agrc31mgk771hfnm54sgslnam1idiym";
+       revision = "3";
+       editedCabalFile = "1lgavl752g968ki042dxha8d28dm8zfs8mzm5zl8xk4p0wi1iwdv";
        libraryHaskellDepends = [ atomic-primops base psqueues vector ];
        testHaskellDepends = [ base ];
        description = "A timer wheel";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "timer-wheel_0_4_0_1" = callPackage
+    ({ mkDerivation, array, atomic-primops, base, ki, psqueues }:
+     mkDerivation {
+       pname = "timer-wheel";
+       version = "0.4.0.1";
+       sha256 = "0h8g9mgp7hcmksvgwwx2n1p9mavdsykqlavpdms7xbh0kgsb445z";
+       libraryHaskellDepends = [ array atomic-primops base ki psqueues ];
+       testHaskellDepends = [ base ];
+       description = "A timer wheel";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "timerep" = callPackage
···
      }:
      mkDerivation {
        pname = "twitchapi";
-       version = "0.0.2";
-       sha256 = "0lw7lr41lnm0jz3ig3y7y23348sp7mvpnihz90nh8j5iv74j7z12";
+       version = "0.0.3";
+       sha256 = "1wbkix4cmkzgg5mz6d721107nra00dr00nhigq55wkzhnpf39lbz";
        libraryHaskellDepends = [
          aeson base bytestring hoauth2 http-client text time timerep
          uri-bytestring
···
      }:
      mkDerivation {
        pname = "welford-online-mean-variance";
-       version = "0.1.0.1";
-       sha256 = "1zzahm5d47rx1zx70i24mj6slkddwpa6hwyplda36x9xpkpjzr51";
+       version = "0.1.0.2";
+       sha256 = "041z3vgbnv2q6a9w80rjws3y0lwb56z1ws2ic8pyx79dvjb0y55q";
        libraryHaskellDepends = [ base cereal deepseq vector ];
        testHaskellDepends = [
          base cereal deepseq QuickCheck tasty tasty-discover
···
        pname = "xmonad";
        version = "0.17.1";
        sha256 = "1apqwyqmc51gamfgsvlanzqqig9qvjss89ibcamhnha1gs1k4jl8";
+       revision = "2";
+       editedCabalFile = "1rgwrnyb7kijzl2mqm8ks2nydh37q5vkbg4400rg9n6x13w2r9b3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "xmonad-contrib";
        version = "0.17.1";
        sha256 = "0lwj8xkyaw6h0rv3lz2jdqrwzz7yghfmnhpndygkb3wgyhvq6dxb";
+       revision = "1";
+       editedCabalFile = "0dc9nbn0kaw98rgpi1rq8np601zjhdr1y0ydg6yb82wwaqawql6z";
        libraryHaskellDepends = [
          base bytestring containers deepseq directory filepath mtl process
          random time unix utf8-string X11 X11-xft xmonad

pkgs/top-level/release-haskell.nix

···
         hlint
         hpack
         # hyper-haskell  # depends on electron-10.4.7 which is marked as insecure
-        hyper-haskell-server-with-packages
+        # hyper-haskell-server-with-packages # hyper-haskell-server is broken
         icepeak
         idris
         ihaskell