haskellPackages: pull from hackage (#394605)

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "264a7959091df9d0be29b5ef12a0a4155e8d55a7",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/264a7959091df9d0be29b5ef12a0a4155e8d55a7.tar.gz",
-  "sha256": "0m0imbi3pd7j2484qc45wr2iknm922rdn0pd8fyz4n2dz7bjr5hb",
-  "msg": "Update from Hackage at 2025-02-15T14:17:54Z"
+  "commit": "6fc5e0d20fed4a6e8ec26f6956786d0077f028b4",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/6fc5e0d20fed4a6e8ec26f6956786d0077f028b4.tar.gz",
+  "sha256": "08vkrfn4s1jb680rq1flxas8hv04f5l715z0kh8sv909k3psbfak",
+  "msg": "Update from Hackage at 2025-03-30T11:13:14Z"
 }

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

···
  - StockholmAlignment
  - Strafunski-Sdf2Haskell
  - SybWidget
+ - Synapse
  - SyntaxMacros
  - TV
  - TastyTLT
···
  - TreeCounter
  - Treiber
  - TrieMap
+ - TypeClass
  - TypeIlluminator
  - UMM
  - URLT
···
  - axel
  - axiom
  - azimuth-hs
- - aztecs-sdl
+ - aztecs-sdl-image
  - azure-functions-worker
  - azure-service-api
  - azure-servicebus
···
  - botan-low
  - both
  - bound-gen
+ - breakout
  - bricks
  - bricks-internal-test
  - bricks-parsec
  - bricks-rendering
  - bricks-syntax
- - broadcast-chan-conduit
- - broadcast-chan-pipes
  - bronyradiogermany-streaming
  - btc-lsp
  - btree
···
  - captcha-core
  - car-pool
  - carboncopy
+ - cardano-addresses
  - cartel
  - cas-hashable-s3
  - cas-store
···
  - chp-plus
  - chp-spec
  - chp-transformers
+ - chr-core
+ - chr-data
  - chr-lang
  - chromatin
  - chu2
···
  - constraint-reflection
  - constructible
  - consumers
+ - consumers-metrics-prometheus
  - container
  - containers-accelerate
  - content-store
···
  - distribution-plot
  - dixi
  - dl-fedora
+ - dl-fedora_2_0_1
  - dmenu-pkill
  - dmenu-pmount
  - dmenu-search
···
  - extract-dependencies
  - factual-api
  - fair
+ - fallingblocks
  - family-tree
  - fast-arithmetic
  - fast-bech32
···
  - gps
  - gps2htmlReport
  - gpu-vulkan
+ - gpu-vulkan-khr-surface
+ - gpu-vulkan-khr-surface-glfw
+ - gpu-vulkan-khr-swapchain
  - grab-form
  - graflog
  - grammar-combinators
···
  - grapefruit-ui
  - grapefruit-ui-gtk
  - grapesy
+ - grapesy-etcd
  - graph-rewriting-cl
  - graph-rewriting-gl
  - graph-rewriting-lambdascope
···
  - graphicstools
  - graphtype
  - graphula
+ - graphula_2_1_0_1
  - greencard-lib
  - grid-proto
  - gridbounds
···
  - hashable-accelerate
  - hashflare
  - hask-home
+ - haskanoid
  - haskdeep
  - haskeem
  - haskell-admin
···
  - haskell-docs
  - haskell-eigen-util
  - haskell-ftp
+ - haskell-language-server
  - haskell-lsp
  - haskell-lsp-client
  - haskell-pdf-presenter
···
  - haskelm
  - haskey
  - haskey-mtl
+ - haskgame
  - hasklepias
  - haskoin-bitcoind
  - haskoin-crypto
···
  - hasql-postgres
  - hasql-postgres-options
  - hasql-queue
+ - hasql-streams-example
  - hastache-aeson
  - haste-app
  - haste-gapi
···
  - hplayground
  - hpqtypes-effectful
  - hpqtypes-extras
+ - hpqtypes-extras_1_17_0_1
  - hprotoc
  - hprotoc-fork
  - hps
···
  - hsfacter
  - hsinspect-lsp
  - hslogstash
- - hsparql
  - hspec-dirstream
  - hspec-expectations-pretty
  - hspec-pg-transact
···
  - layouting
  - lazy-hash-cache
  - lda
- - ldap-client-og
  - ldap-scim-bridge
  - ldapply
  - leaky
···
  - luachunk
  - lucid-colonnade
  - lucienne
+ - lui
  - luminance-samples
  - lvish
  - lz4-conduit
···
  - potoki-zlib
  - powerqueue-sqs
  - ppad-base58
+ - ppad-bip32
+ - ppad-bip39
  - ppad-hkdf
  - ppad-hmac-drbg
+ - ppad-pbkdf
  - ppad-secp256k1
  - pqueue-mtl
  - practice-room
···
  - rds-data
  - react-flux-servant
  - reactive
+ - reactive-banana-sdl
  - reactive-banana-wx
  - reactive-fieldtrip
  - reactive-glut
···
  - regular-web
  - regular-xmlpickler
  - reheat
+ - rel8
  - relative-date
  - remote-json
  - remote-json-client
···
  - shady-gen
  - shady-graphics
  - shake-ats
+ - shake-language-c
  - shake-minify-css
  - shakebook
  - shaker
···
  - symantic-lib
  - symbiote
  - symmetry-operations-symbols
+ - synapse
  - syncthing-hs
  - syntaxnet-haskell
  - sys-process
···
  - vault-tool-server
  - vault-trans
  - vaultaire-common
- - vaultenv
  - vcache-trie
  - vcard
  - vcsgui
···
  - wavesurfer
  - wavy
  - weatherhs
+ - weave
  - web-mongrel2
  - web-routes-hsp
  - web-routes-regular
  - web-routing
+ - web-view-colonnade
  - web3
  - web3-bignum
  - web3-crypto

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

···
        license = lib.licenses.mit;
      }) {};
 
+  "Blammo_2_1_2_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, dlist
+     , envparse, exceptions, fast-logger, hspec, lens, markdown-unlit
+     , monad-logger-aeson, mtl, text, time, unliftio, unliftio-core
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "Blammo";
+       version = "2.1.2.0";
+       sha256 = "0aa1kn4aljj6nvsnilfq3xy4b4yzy4gs6k949jjcvjhpm2zgab1m";
+       libraryHaskellDepends = [
+         aeson base bytestring containers dlist envparse exceptions
+         fast-logger lens monad-logger-aeson mtl text time unliftio
+         unliftio-core unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring envparse hspec lens markdown-unlit mtl text
+         time
+       ];
+       testToolDepends = [ markdown-unlit ];
+       description = "Batteries-included Structured Logging library";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "Blammo-wai" = callPackage
     ({ mkDerivation, aeson, base, Blammo, bytestring, case-insensitive
      , clock, http-types, lens, markdown-unlit, monad-logger-aeson, text
···
        pname = "Chart-cairo";
        version = "1.9.4.1";
        sha256 = "0x10l9y38bscx88n849k9ybn7axp4j9hlivc1jv9wwvv4gqw5jr7";
-       revision = "2";
-       editedCabalFile = "0gyhv409q1a9rxw0j51rngws2bzy7xnjsbs4lj2wysjxp8c7xs74";
+       revision = "3";
+       editedCabalFile = "0rl4var9s1521n6ryxp59kglfip2bw1svm3mx72ya8zc4yj3z5rb";
        libraryHaskellDepends = [
          array base cairo Chart colour data-default-class lens mtl
          old-locale operational time
···
        pname = "Chart-diagrams";
        version = "1.9.5.1";
        sha256 = "1pk2fsmjl2dsabzpdwk3190nw0nwy581c4qsl93npx764qcxkp7q";
-       revision = "2";
-       editedCabalFile = "14z8s46qxcn33mzy66zhlg0pmwk1xks8c3mmrrbj4bp30wldgihz";
+       revision = "3";
+       editedCabalFile = "1d02cd4i4kvz53ymw1jrracbv0mkfzjizc64mkg8yxmrby0ywvlj";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base blaze-markup bytestring Chart colour containers
···
 
   "ClickHaskell" = callPackage
     ({ mkDerivation, base, binary, bytestring, deepseq, network, text
-     , time, vector, wide-word
+     , time, wide-word
      }:
      mkDerivation {
        pname = "ClickHaskell";
-       version = "0.1.0";
-       sha256 = "1yb3g1rh587clzhlav00c0m7v3fy4i09jf55i2mlwcv3w2xk1hd7";
-       revision = "1";
-       editedCabalFile = "1d8msl3vlazp7xsbd5glxjc1qppfi8q7x6ncqdd6mmi88q8rfgrz";
+       version = "0.2.0";
+       sha256 = "13xsg5ml172asp7sy6afgvqk57rknmjq2gpli41pgk6im1wzm6vl";
        libraryHaskellDepends = [
-         base binary bytestring deepseq network text time vector wide-word
+         base binary bytestring deepseq network text time wide-word
        ];
        description = "ClickHouse driver";
        license = lib.licenses.bsd3;
···
        libraryHaskellDepends = [ base directory unix utf8-string X11 ];
        description = "System clipboard interface";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "Clipboard_2_3_2_2" = callPackage
+    ({ mkDerivation, base, directory, unix, utf8-string, X11 }:
+     mkDerivation {
+       pname = "Clipboard";
+       version = "2.3.2.2";
+       sha256 = "12j3dcjcqj8mzk1720xnwi4zmmp2q0rjsxziiw8vd5kia13xdxdp";
+       libraryHaskellDepends = [ base directory unix utf8-string X11 ];
+       description = "System clipboard interface";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ClustalParser" = callPackage
···
      }:
      mkDerivation {
        pname = "HList";
-       version = "0.5.3.0";
-       sha256 = "0azwcaky2jlf4ldbj3aasv8i457g67ih9aap6qgjcmdz6q8ad2f4";
+       version = "0.5.4.0";
+       sha256 = "0m9703yzplkvgia1wxwjyfj21sflfa20ik3v54rzhshiyh7lcncq";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base base-orphans ghc-prim mtl profunctors semigroups tagged
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "HaTeX_3_23_0_0" = callPackage
+  "HaTeX_3_23_0_1" = callPackage
     ({ mkDerivation, base, bibtex, bytestring, containers, hashable
      , matrix, parsec, prettyprinter, QuickCheck, tasty
      , tasty-quickcheck, text, transformers
      }:
      mkDerivation {
        pname = "HaTeX";
-       version = "3.23.0.0";
-       sha256 = "05nz9nyzm127j57rdsph62fw4a086zvmxjpww6wynfhbb5afsd88";
+       version = "3.23.0.1";
+       sha256 = "1w98iprpanz7i78fzhf14rlzyhj0wmjs45xp5nrbxkzvwb1dvigk";
        libraryHaskellDepends = [
          base bibtex bytestring containers hashable matrix parsec
          prettyprinter QuickCheck text transformers
···
      }:
      mkDerivation {
        pname = "HaskellNet-SSL";
-       version = "0.4.0.1";
-       sha256 = "0dsi12cnb4w59k19x61galhpchgk63bakaswdds92kg2pv14ibcj";
+       version = "0.4.0.2";
+       sha256 = "17nisvcs2b325rhb7hwvm8dj26snjhkpiqnwmq5nhs2ir1vdsslm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.gpl2Only;
      }) {};
 
+  "HsYAML_0_2_1_5" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, mtl, parsec
+     , QuickCheck, tasty, tasty-quickcheck, text, transformers
+     }:
+     mkDerivation {
+       pname = "HsYAML";
+       version = "0.2.1.5";
+       sha256 = "13av46629msknp1spmcczgd2hpsyj0ca590vpiy7df8l6cfwjyk5";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers deepseq mtl parsec text transformers
+       ];
+       testHaskellDepends = [
+         base bytestring containers mtl QuickCheck tasty tasty-quickcheck
+         text
+       ];
+       description = "Pure Haskell YAML 1.2 processor";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "HsYAML-aeson" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, HsYAML, mtl
      , scientific, text, unordered-containers, vector
···
        ];
        description = "JSON to YAML Adapter";
        license = lib.licenses.gpl2Plus;
+     }) {};
+
+  "HsYAML-aeson_0_2_0_2" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, HsYAML, mtl
+     , scientific, text, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "HsYAML-aeson";
+       version = "0.2.0.2";
+       sha256 = "12f9fdkgbg9gk7gbf5v3w0b68s382rxjkpxmvsq0ga02v7nhlvna";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers HsYAML mtl scientific text
+         unordered-containers vector
+       ];
+       description = "JSON to YAML Adapter";
+       license = lib.licenses.gpl2Plus;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Hsed" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "IPv6Addr_2_0_6_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, HUnit, iproute, network
+     , network-info, random, test-framework, test-framework-hunit, text
+     }:
+     mkDerivation {
+       pname = "IPv6Addr";
+       version = "2.0.6.1";
+       sha256 = "1gdz3m6sc7aj4wy0j9sdd4qbb1jzilw8vjqig29szcqmp6cslc3c";
+       libraryHaskellDepends = [
+         aeson attoparsec base iproute network network-info random text
+       ];
+       testHaskellDepends = [
+         base HUnit test-framework test-framework-hunit text
+       ];
+       description = "Library to deal with IPv6 address text representations";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "IPv6DB" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, fast-logger
      , hedis, hspec, http-client, http-types, IPv6Addr, mtl
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "ListLike_4_7_8_3" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, deepseq
+     , dlist, fmlist, HUnit, QuickCheck, random, text, utf8-string
+     , vector
+     }:
+     mkDerivation {
+       pname = "ListLike";
+       version = "4.7.8.3";
+       sha256 = "0diq2dzg2bhl40n9xidlnlzxyqdi11rybqrkgmxg3msypzlvxzhl";
+       libraryHaskellDepends = [
+         array base bytestring containers deepseq dlist fmlist text
+         utf8-string vector
+       ];
+       testHaskellDepends = [
+         array base bytestring containers dlist fmlist HUnit QuickCheck
+         random text utf8-string vector
+       ];
+       description = "Generalized support for list-like structures";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ListT" = callPackage
     ({ mkDerivation, base, smallcheck, tasty, tasty-smallcheck
      , transformers, util
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "MissingH_1_6_0_2" = callPackage
+    ({ mkDerivation, array, base, containers, directory, filepath
+     , hslogger, HUnit, mtl, network, network-bsd, old-locale, old-time
+     , parsec, process, regex-compat, time, unix
+     }:
+     mkDerivation {
+       pname = "MissingH";
+       version = "1.6.0.2";
+       sha256 = "17ckc5hck9ng9rqx2afj1xac0d7m1p0vqfc5mdmmlkg5nza432is";
+       libraryHaskellDepends = [
+         array base containers directory filepath hslogger mtl network
+         network-bsd old-locale old-time parsec process regex-compat time
+         unix
+       ];
+       testHaskellDepends = [
+         base containers directory filepath HUnit old-time parsec
+         regex-compat time unix
+       ];
+       description = "Large utility library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "MissingK" = callPackage
     ({ mkDerivation, base, glib, template-haskell }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "MonadRandom_0_6_2" = callPackage
+    ({ mkDerivation, base, mtl, primitive, random, transformers
+     , transformers-compat
+     }:
+     mkDerivation {
+       pname = "MonadRandom";
+       version = "0.6.2";
+       sha256 = "0sk61xbpagiwfpmfskysc2f7y05rpmaz0q8hr0a7m6f2xyw1rw02";
+       libraryHaskellDepends = [
+         base mtl primitive random transformers transformers-compat
+       ];
+       description = "Random-number generation monad";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "MonadRandomLazy" = callPackage
     ({ mkDerivation, base, MonadRandom, mtl, random }:
      mkDerivation {
···
      }) {};
 
   "Monadoro" = callPackage
-    ({ mkDerivation, base, doctest, hspec, process, time }:
+    ({ mkDerivation, base, doctest, process, time }:
      mkDerivation {
        pname = "Monadoro";
-       version = "0.3.6.2";
-       sha256 = "0hlgxk6p863h5l8x1qivbk41g8i4pngiy63x6y153i9j7v3nhbrh";
+       version = "0.4.0.0";
+       sha256 = "0axilb24mw5f0jvmdyqbrnmh2k9klygxdfazqsyrj2cbxfsby3c3";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base process time ];
        executableHaskellDepends = [ base process time ];
-       testHaskellDepends = [ base doctest hspec process time ];
+       testHaskellDepends = [ base doctest process time ];
        description = "A minimalistic CLI Pomodoro timer";
        license = lib.licenses.mit;
        mainProgram = "monadoro";
···
        pname = "QuickCheck";
        version = "2.15.0.1";
        sha256 = "0zvfydg44ibs1br522rzvdlxj9mpz0h62js1hay1sj5gvdnj3cm3";
+       revision = "1";
+       editedCabalFile = "0cgfp4s51cjphsn9cls6rndisvqmi94vn95xan9g1yz6p5xk7z8c";
        libraryHaskellDepends = [
          base containers deepseq random splitmix template-haskell
          transformers
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "Synapse" = callPackage
+    ({ mkDerivation, base, easyplot, hashable, HUnit, random
+     , terminal-progress-bar, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "Synapse";
+       version = "0.1.0.2";
+       sha256 = "1npzgilpmq5sy594mrsnamh90p6hbphivjas925w0zr0rdjx8wdv";
+       libraryHaskellDepends = [
+         base hashable random terminal-progress-bar unordered-containers
+         vector
+       ];
+       testHaskellDepends = [ base easyplot HUnit random ];
+       description = "Synapse is a machine learning library written in pure Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "SyntaxMacros" = callPackage
     ({ mkDerivation, AspectAG, base, containers, HList, ListLike
      , template-haskell, TTTAS, uu-parsinglib, uulib
···
        ];
        description = "Typing speed game";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "TypeClass";
      }) {};
 
···
        pname = "Vis";
        version = "1.0.0";
        sha256 = "1ackm8k1ggkhyn6s6z6y0h5hvimp6q9wsc2vdyfw21824vppkpsk";
+       revision = "1";
+       editedCabalFile = "1ll4cfxkmnyfqjajsqyjx0wgija813m61adhfr3w3i8klf6d2x5m";
        libraryHaskellDepends = [
          base binary bmp bytestring GLUT linear OpenGL OpenGLRaw time vector
          vector-binary-instances
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "Yampa_0_15" = callPackage
+    ({ mkDerivation, base, criterion, deepseq, filepath, random
+     , simple-affine-space, time
+     }:
+     mkDerivation {
+       pname = "Yampa";
+       version = "0.15";
+       sha256 = "0dxcgd7i0n5g2h041vgaam47gn3ac7i2980lq6dihvyzw8zplpcq";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base deepseq random simple-affine-space
+       ];
+       benchmarkHaskellDepends = [ base criterion filepath time ];
+       description = "Elegant Functional Reactive Programming Language for Hybrid Systems";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "Yampa-core" = callPackage
     ({ mkDerivation, base, deepseq, random, vector-space }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "ac-library-hs";
-       version = "1.2.0.0";
-       sha256 = "12f5wyhpflbirp6dzakcin47kspfvv7sqkjgk8b061zlpb758v37";
+       version = "1.2.3.0";
+       sha256 = "0b41jpl97imwprn73qqff5p4l2qk0qnm58hi88lgn74az5harpqk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "acid-state";
        version = "0.16.1.3";
        sha256 = "0vmggxzp6alv92ycwc9bc53vn73s1cbn8rhmbcb2jvcglyakvws5";
-       revision = "1";
-       editedCabalFile = "17m2071y2vam37ixgqa4rgfmcrwvc4x0k6a89hz70fmpzx52hhad";
+       revision = "2";
+       editedCabalFile = "1a6l987cajb70h3i6gpd4im7s0y81cikkyr10hyc6lkq79inlr26";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "ad";
        version = "4.5.6";
        sha256 = "1v3ax1m0adsnc1bcjqkppxykv1di73bcv2jby90w8yiawyfay24x";
+       revision = "1";
+       editedCabalFile = "1mbz3wya76kndwyzj9vf6yfcb1s3ba51clfkxdf0nqkqj6zx7f5g";
        libraryHaskellDepends = [
          adjunctions array base comonad containers data-reify erf free nats
          reflection semigroups transformers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "adjunctions_4_4_3" = callPackage
+    ({ mkDerivation, array, base, comonad, containers, contravariant
+     , distributive, free, hspec, hspec-discover, mtl, profunctors
+     , semigroupoids, semigroups, tagged, transformers
+     , transformers-compat, void
+     }:
+     mkDerivation {
+       pname = "adjunctions";
+       version = "4.4.3";
+       sha256 = "16hqxd88998dgjib8k1dy78a1waww3hd33hqqgd17y9bxqf15swb";
+       libraryHaskellDepends = [
+         array base comonad containers contravariant distributive free mtl
+         profunctors semigroupoids semigroups tagged transformers
+         transformers-compat void
+       ];
+       testHaskellDepends = [ base distributive hspec ];
+       testToolDepends = [ hspec-discover ];
+       description = "Adjunctions and representable functors";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "adler32" = callPackage
     ({ mkDerivation, base, bytestring, hspec, zlib }:
      mkDerivation {
···
        license = lib.licenses.mit;
      }) {};
 
-  "aeson-jsonpath_0_3_0_1" = callPackage
+  "aeson-jsonpath_0_3_0_2" = callPackage
     ({ mkDerivation, aeson, base, hspec, parsec, scientific
      , template-haskell, text, vector
      }:
      mkDerivation {
        pname = "aeson-jsonpath";
-       version = "0.3.0.1";
-       sha256 = "00fjghn7fr614sb3shg2vq2l7i8xh96kn0yhk7m3qzmzbvkf6mfa";
+       version = "0.3.0.2";
+       sha256 = "0z869j8hdgbc86y9zb3ssrjzqyzryky08x2iyw2ys6pdh5mgcckl";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base parsec scientific template-haskell text vector
···
     ({ mkDerivation, async, base, cli-arguments, containers, deepseq
      , directory, intermediate-structures, lists-flines, minmax
      , mmsyn2-array, monoid-insertleft, quantizer, rev-scientific
-     , rhythmic-sequences
+     , rhythmic-sequences, uniqueness-periods-vector-stats
      }:
      mkDerivation {
        pname = "aftovolio";
-       version = "0.6.2.0";
-       sha256 = "0ijyhd38g7dfd64dksc5v834qd1k2wmz2r37fsz612xdgkldfqcc";
+       version = "0.7.1.0";
+       sha256 = "1yzjgiw9g7rh480s47f8q2lfxhwh76f0nsm2ch15av9vnpp4yad6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          async base cli-arguments containers deepseq directory
          intermediate-structures lists-flines minmax mmsyn2-array
          monoid-insertleft quantizer rev-scientific rhythmic-sequences
+         uniqueness-periods-vector-stats
        ];
        executableHaskellDepends = [
          async base cli-arguments containers deepseq directory
          intermediate-structures lists-flines minmax mmsyn2-array
          monoid-insertleft quantizer rev-scientific rhythmic-sequences
+         uniqueness-periods-vector-stats
        ];
        description = "An AFTOVolio implementation for creating texts with special phonetic / prosodic properties";
        license = lib.licenses.mit;
···
        maintainers = [ lib.maintainers.thielema ];
      }) {};
 
+  "align-equal" = callPackage
+    ({ mkDerivation, base, safe, text }:
+     mkDerivation {
+       pname = "align-equal";
+       version = "0.1.1.0";
+       sha256 = "138iplm5xgbbahbssdqsrwq0w3qwyr26gpnjf9rrkw82p2xph74n";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base safe text ];
+       executableHaskellDepends = [ base text ];
+       description = "Aligns text prefixes before '=' for consistent formatting";
+       license = lib.licenses.mit;
+       mainProgram = "align-equal";
+     }) {};
+
   "align-text" = callPackage
     ({ mkDerivation, base, optparse-applicative, text }:
      mkDerivation {
···
 
   "amazonka-mtl" = callPackage
     ({ mkDerivation, amazonka, amazonka-core, amazonka-s3, base, Blammo
-     , conduit, hspec, lens, markdown-unlit, mtl, resourcet, text, time
-     , unliftio-core
+     , conduit, hspec, lens, markdown-unlit, monad-logger, mtl
+     , resourcet, text, time, unliftio-core
      }:
      mkDerivation {
        pname = "amazonka-mtl";
-       version = "0.1.1.0";
-       sha256 = "0r7fmffqj3yl6vwidfny4s2ynhkfx9h0di6l7pm79j5m5fp5vdvr";
-       revision = "1";
-       editedCabalFile = "1hsrc72v7qqbpzi5pqbjb8ysrhiiydk7fi6i9078nf8f1jammd4h";
+       version = "0.1.1.1";
+       sha256 = "19rcmfq5ly92jm96w5770286kihd5gsdc45rmpbkhm71xl2aa0pq";
        libraryHaskellDepends = [
-         amazonka amazonka-core base conduit lens mtl resourcet
+         amazonka amazonka-core base conduit lens monad-logger mtl resourcet
          unliftio-core
        ];
        testHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "antikythera" = callPackage
+    ({ mkDerivation, base, hspec, hspec-core, time, unbounded-delays }:
+     mkDerivation {
+       pname = "antikythera";
+       version = "0.1.0.0";
+       sha256 = "1lqq5ccg3b2m23ilisbp60wjmk6rr1nd8havgghz6hrjwihmvn79";
+       libraryHaskellDepends = [ base time unbounded-delays ];
+       testHaskellDepends = [ base hspec hspec-core time ];
+       description = "Simple job/task/event scheduler/cronjob";
+       license = lib.licenses.isc;
+     }) {};
+
   "antimirov" = callPackage
     ({ mkDerivation, base, containers, QuickCheck }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "aoc" = callPackage
+    ({ mkDerivation, base, containers, hashable, heap
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "aoc";
+       version = "0.1.0.1";
+       sha256 = "1rw92ndc2mqlxg9jdpf9k62mmcgq383zx5y34x9qhgddnqav1wwq";
+       libraryHaskellDepends = [
+         base containers hashable heap unordered-containers
+       ];
+       description = "Utility functions commonly used while solving Advent of Code puzzles";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "aop-prelude" = callPackage
     ({ mkDerivation, base, ghc-prim, integer-gmp }:
      mkDerivation {
···
        pname = "apply-merge";
        version = "0.1.1.0";
        sha256 = "1snm9m35r3px9vgn64ygcqq37ay6jvwc5jsi3s62rxrh8biy8ir8";
-       revision = "4";
-       editedCabalFile = "06aslf9s35kimwshzvajxr63416979f0j598jk31zwl95wfgn5y9";
+       revision = "5";
+       editedCabalFile = "1bcpcp6cg50bm4p7snbl8z9vrmps2qzfhzf3v8rk3xlcwfmhvjw0";
        libraryHaskellDepends = [ base containers pqueue reflection ];
        testHaskellDepends = [
          base containers data-ordlist pqueue reflection tasty
···
      }:
      mkDerivation {
        pname = "arduino-copilot";
-       version = "1.7.8";
-       sha256 = "0gb7w8sp75z9b3avlpy2cli60rxfyxkdppaf1pmlhsgnlf2fjjz6";
+       version = "1.7.9";
+       sha256 = "042qzzvzrf7c8x9jdvx4znhwzdvgz2jgag51ky6zprh9k267xvs1";
        libraryHaskellDepends = [
          base containers copilot copilot-c99 copilot-language directory
          filepath mtl optparse-applicative sketch-frp-copilot temporary
···
        license = lib.licenses.mit;
      }) {};
 
+  "arithmoi_0_13_0_1" = callPackage
+    ({ mkDerivation, array, base, chimera, constraints, containers
+     , deepseq, exact-pi, ghc-bignum, infinite-list, integer-logarithms
+     , integer-roots, mod, QuickCheck, quickcheck-classes, random
+     , semirings, smallcheck, tasty, tasty-bench, tasty-hunit
+     , tasty-quickcheck, tasty-rerun, tasty-smallcheck, transformers
+     , vector
+     }:
+     mkDerivation {
+       pname = "arithmoi";
+       version = "0.13.0.1";
+       sha256 = "08ny7pwy2askq0h34lsna0p0fqrb4wgngw5pxbdc150y2wb7p0lq";
+       configureFlags = [ "-f-llvm" ];
+       libraryHaskellDepends = [
+         array base chimera constraints containers deepseq exact-pi
+         ghc-bignum infinite-list integer-logarithms integer-roots mod
+         random semirings transformers vector
+       ];
+       testHaskellDepends = [
+         base containers exact-pi infinite-list integer-roots mod QuickCheck
+         quickcheck-classes random semirings smallcheck tasty tasty-hunit
+         tasty-quickcheck tasty-rerun tasty-smallcheck transformers vector
+       ];
+       benchmarkHaskellDepends = [
+         array base constraints containers deepseq infinite-list
+         integer-logarithms mod random semirings tasty-bench vector
+       ];
+       description = "Efficient basic number-theoretic functions";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "arity-generic-liftA" = callPackage
     ({ mkDerivation, base, doctest }:
      mkDerivation {
···
        license = lib.licenses.cc0;
      }) {};
 
+  "atom-conduit_0_9_0_2" = callPackage
+    ({ mkDerivation, base, blaze-builder, conduit, data-default
+     , filepath, generic-random, microlens, microlens-th, parsers
+     , pretty-simple, prettyprinter, QuickCheck, quickcheck-instances
+     , refined, relude, resourcet, safe-exceptions, tasty, tasty-golden
+     , tasty-hunit, tasty-quickcheck, text, time, timerep
+     , uri-bytestring, xml-conduit, xml-types
+     }:
+     mkDerivation {
+       pname = "atom-conduit";
+       version = "0.9.0.2";
+       sha256 = "1qdiadr74zgqfkiv4b2z447mlcfahwx56l4251a5q25sh0igk564";
+       libraryHaskellDepends = [
+         base blaze-builder conduit microlens microlens-th parsers
+         prettyprinter refined relude safe-exceptions text time timerep
+         uri-bytestring xml-conduit xml-types
+       ];
+       testHaskellDepends = [
+         base conduit data-default filepath generic-random microlens
+         pretty-simple QuickCheck quickcheck-instances refined relude
+         resourcet tasty tasty-golden tasty-hunit tasty-quickcheck text time
+         uri-bytestring xml-conduit xml-types
+       ];
+       description = "Streaming parser/renderer for the Atom 1.0 standard (RFC 4287).";
+       license = lib.licenses.cc0;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "atom-msp430" = callPackage
     ({ mkDerivation, atom, base, mtl }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "auto-split";
-       version = "0.1.0.2";
-       sha256 = "1xvvdcns6jvx3qr4m1734i9chaz11rz8gf0z68185g07zbipv9b0";
+       version = "0.1.0.3";
+       sha256 = "1v0m3a1jh04brkxvi9111a49wj7pfvx5wjix6h5q4clc85l0hcmg";
        libraryHaskellDepends = [
          base ghc ghc-exactprint ghc-paths syb transformers
        ];
···
        pname = "aws-arn";
        version = "0.3.3.0";
        sha256 = "0zwnqmzibgvrlak2as9z5kjh54zq6lqpv5qy1k2jbdjmj4g6sn8q";
+       revision = "1";
+       editedCabalFile = "0yjvdncz48k5gym4lh90aag34qr3aj9bd3dalg7w0jjxrjyr45s7";
        libraryHaskellDepends = [
          base deriving-compat hashable microlens-pro tagged text
        ];
···
      }:
      mkDerivation {
        pname = "aws-spend-summary";
-       version = "0.2.0.1";
-       sha256 = "12wyff4n79w2amsxjkcs9wbpgg3szx88jpxypcbjb2bjswqnmhsz";
+       version = "0.2.0.2";
+       sha256 = "0zp9bdrhxl4z8fyjqcilndpj6qw5scs1byh1fzj8v9r4zzg59zsg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "aztecs" = callPackage
-    ({ mkDerivation, base, containers, criterion, hspec, mtl
-     , QuickCheck
+    ({ mkDerivation, base, containers, criterion, deepseq, hspec, mtl
+     , QuickCheck, stm
      }:
      mkDerivation {
        pname = "aztecs";
-       version = "0.4.0.1";
-       sha256 = "1javdfkpa59ma0b13vjh34cqric66ds62ifgp6cw668fp9qk7lmr";
+       version = "0.12.0";
+       sha256 = "0r904arfgisqg83ps9schak9pwhf9r17rpilj2qx8fy2iwvfs98k";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ base containers mtl ];
-       executableHaskellDepends = [ base ];
-       testHaskellDepends = [ base hspec QuickCheck ];
-       benchmarkHaskellDepends = [ base criterion ];
-       description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell";
+       libraryHaskellDepends = [ base containers deepseq mtl stm ];
+       executableHaskellDepends = [ base deepseq ];
+       testHaskellDepends = [ base containers deepseq hspec QuickCheck ];
+       benchmarkHaskellDepends = [ base criterion deepseq ];
+       description = "A modular game engine and Entity-Component-System (ECS) for Haskell";
        license = lib.licenses.bsd3;
        mainProgram = "ecs";
      }) {};
···
     ({ mkDerivation, aztecs, base, containers, linear, mtl }:
      mkDerivation {
        pname = "aztecs-asset";
-       version = "0.1.0.0";
-       sha256 = "08i1r8h3q7p4mj09bwdaim90bgh08i2mrrdzj2pp67zdw1cmqa5n";
+       version = "0.2.0.0";
+       sha256 = "1qhn96yznh6spdz5w7v4hqcbcysjjsgg9a97m6pz18j2nb8b93ii";
        libraryHaskellDepends = [ aztecs base containers linear mtl ];
        description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "aztecs-hierarchy";
-       version = "0.1.0.0";
-       sha256 = "1fkgk75khaza3am67idh3n32kn3vzx494c1rz84kl8iik3qy5ayz";
+       version = "0.2.0.0";
+       sha256 = "0db9dgh5bakc0qcwwcnc5afi19xabslnr623g4whdfwiykk1l4ym";
        libraryHaskellDepends = [ aztecs base containers linear mtl ];
        testHaskellDepends = [ aztecs base containers hspec QuickCheck ];
        description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell";
···
      }) {};
 
   "aztecs-sdl" = callPackage
-    ({ mkDerivation, aztecs, aztecs-asset, aztecs-transform, base
-     , containers, linear, mtl, sdl2, sdl2-image, text
+    ({ mkDerivation, aztecs, base, containers, deepseq, linear, mtl
+     , sdl2, text
      }:
      mkDerivation {
        pname = "aztecs-sdl";
-       version = "0.1.0.0";
-       sha256 = "02p36mc7j3rzrmdqb9jgmlhr14dab54ilwj1kw2lwgmhzc0rlxyh";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.7.0";
+       sha256 = "089dvs98y3glw4jzf8dhnia02jivl7zwhpkyz86mq8q56xlpbii4";
        libraryHaskellDepends = [
-         aztecs aztecs-asset aztecs-transform base containers linear mtl
-         sdl2 sdl2-image text
+         aztecs base containers deepseq linear mtl sdl2 text
        ];
-       executableHaskellDepends = [
-         aztecs aztecs-asset aztecs-transform base sdl2
+       description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "aztecs-sdl-image" = callPackage
+    ({ mkDerivation, aztecs, aztecs-sdl, base, containers, deepseq
+     , linear, mtl, sdl2, sdl2-image, text
+     }:
+     mkDerivation {
+       pname = "aztecs-sdl-image";
+       version = "0.6.0";
+       sha256 = "0y120l46jl2s6mhabplfns9dmz8bbjd39lyc2yi4nqzcgnzajhm4";
+       libraryHaskellDepends = [
+         aztecs aztecs-sdl base containers deepseq linear mtl sdl2
+         sdl2-image text
        ];
        description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
-       mainProgram = "window";
+     }) {};
+
+  "aztecs-sdl-text" = callPackage
+    ({ mkDerivation, aztecs, aztecs-sdl, base, containers, deepseq
+     , linear, mtl, sdl2, sdl2-ttf, text
+     }:
+     mkDerivation {
+       pname = "aztecs-sdl-text";
+       version = "0.6.0";
+       sha256 = "08ihqzjfchgdqs1gcrb2gpfjbysjh7hzh5lh8bs9163lckg5z3ah";
+       libraryHaskellDepends = [
+         aztecs aztecs-sdl base containers deepseq linear mtl sdl2 sdl2-ttf
+         text
+       ];
+       description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell";
+       license = lib.licenses.bsd3;
      }) {};
 
   "aztecs-transform" = callPackage
-    ({ mkDerivation, aztecs, base, linear, mtl }:
+    ({ mkDerivation, aztecs, aztecs-hierarchy, base, linear, mtl }:
      mkDerivation {
        pname = "aztecs-transform";
-       version = "0.1.0.0";
-       sha256 = "18aidpl85r48xbd8v6hvcfd9i2cd67vjqhwyz914sb2qg8ib5g6m";
-       libraryHaskellDepends = [ aztecs base linear mtl ];
+       version = "0.2.0.0";
+       sha256 = "0nbq24ksbk2xx4yx7lqkr23ky857bn75mv9bkmrndzpdg0fy9yk3";
+       libraryHaskellDepends = [
+         aztecs aztecs-hierarchy base linear mtl
+       ];
        description = "A type-safe and friendly Entity-Component-System (ECS) for Haskell";
        license = lib.licenses.bsd3;
      }) {};
···
        pname = "base64";
        version = "1.0";
        sha256 = "1dmjy4pkz66s3wa99lkc0wc4bdjkdkr57a8rsgb5z50432gj6hkr";
-       revision = "1";
-       editedCabalFile = "0b02k2r5dkzm8rapypkcjl08mz97z5qh4yfxyxn0vwq5hmh8905b";
+       revision = "2";
+       editedCabalFile = "1jp2pc5r4w0vmd2piidzh0h308gx7gdl1xxk9mndc381c8bvkj0m";
        libraryHaskellDepends = [
          base bytestring deepseq text text-short
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "beam-large-records" = callPackage
+    ({ mkDerivation, base, beam-core, beam-sqlite, ghc-prim
+     , large-generics, large-records, microlens, record-dot-preprocessor
+     , record-hasfield, sop-core, sqlite-simple, tasty, tasty-hunit
+     , text, time
+     }:
+     mkDerivation {
+       pname = "beam-large-records";
+       version = "0.1.1";
+       sha256 = "1vsc8aikpxwhzgjk4vlvs9wkg9hlq0942zqz0r8s98s1ad2pfmih";
+       libraryHaskellDepends = [
+         base beam-core large-generics microlens sop-core text
+       ];
+       testHaskellDepends = [
+         base beam-core beam-sqlite ghc-prim large-generics large-records
+         microlens record-dot-preprocessor record-hasfield sqlite-simple
+         tasty tasty-hunit text time
+       ];
+       description = "Integration of large-records with beam-core";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "beam-migrate" = callPackage
     ({ mkDerivation, aeson, base, beam-core, bytestring, containers
      , deepseq, dependent-map, dependent-sum, free, ghc-prim, hashable
···
        broken = true;
      }) {};
 
+  "bearlibterminal" = callPackage
+    ({ mkDerivation, base, BearLibTerminal, bytestring, containers
+     , formatting, mtl, random, text, time, vector, word8
+     }:
+     mkDerivation {
+       pname = "bearlibterminal";
+       version = "0.1.0.1";
+       sha256 = "0w6xjikkcg0nb58ra0n953nxg854534ygxbcm1kxvpipkpz7fjmj";
+       revision = "2";
+       editedCabalFile = "07wws4fk0aw1ir63v9zp3bwpg4fsf8qi4kbmzkji2gvi7a27fzvp";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base bytestring mtl text ];
+       librarySystemDepends = [ BearLibTerminal ];
+       executableHaskellDepends = [
+         base bytestring containers formatting mtl random text time vector
+         word8
+       ];
+       description = "Low-level Haskell bindings to the BearLibTerminal graphics library";
+       license = lib.licenses.mit;
+       mainProgram = "omni";
+     }) {BearLibTerminal = null;};
+
   "bearriver" = callPackage
     ({ mkDerivation, base, deepseq, dunai, mtl, random
      , simple-affine-space, transformers
      }:
      mkDerivation {
        pname = "bearriver";
-       version = "0.14.12";
-       sha256 = "1md63c0v8mn0ljcwfsx1bbsrq8a06hh5zz6n730x97db8gpf73vk";
+       version = "0.15";
+       sha256 = "1w71myhyxwn6cjd123h9n2aggh0lj8y8pyqrflnjhw836gkkn2dr";
        libraryHaskellDepends = [
          base deepseq dunai mtl random simple-affine-space transformers
        ];
···
        pname = "benc";
        version = "0.1.1.0";
        sha256 = "12hp6qpz9wg0myyf9sv0izhd096ilqg0xgw0i96pildlx2cfzgpi";
+       revision = "1";
+       editedCabalFile = "0sn593qnyxc8xncllsk28s3pkphcnrv56iqdqaf2dx0i0vx68n4v";
        libraryHaskellDepends = [
          base bytestring containers primitive text transformers vector
        ];
···
        pname = "bench-show";
        version = "0.3.2";
        sha256 = "1f0zx572d54dyyjifv4p550ci90gdr4mrifhwww4z6p87fbdi32j";
-       revision = "1";
-       editedCabalFile = "1qq1ppj0x1d1rl0dbhpx6h2xj359rh2l6g63wkxcjzyqf2lzlx3q";
+       revision = "2";
+       editedCabalFile = "0cr695fg7cppfv84ji5dgz591ha757882xxyyr72q59cjcy5cllf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "betacode";
-       version = "0.1.0.0";
-       sha256 = "0ry42sp40234c83iw7di37j3jfjfbszxcv4mzgqc54b1693mjq7b";
+       version = "0.1.0.1";
+       sha256 = "1l1yg2h7s1sr7cvw7zdl5w0m17sfsd1a7q3lv58ill4q95mhc5ja";
        libraryHaskellDepends = [
          attoparsec base errors hashable text text-icu
        ];
···
        pname = "bifunctors";
        version = "5.6.2";
        sha256 = "0yk9v71xpwnxd6xia1bdr8pxbvrx4am6bjykqp1d1vk1a0lak1hh";
-       revision = "1";
-       editedCabalFile = "1gibijw482qj7p9zys27df71kmv94bcq0afrsnvld86nf7njdngz";
+       revision = "2";
+       editedCabalFile = "1ll0i0pjrmswpps64l1h6k83j7z2f4rxvr7r6iwb1axa9qf64nhi";
        libraryHaskellDepends = [
          assoc base comonad containers tagged template-haskell
          th-abstraction transformers
···
        ];
        description = "Orphan instances for binary";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "binary-instances_1_0_6" = callPackage
+    ({ mkDerivation, aeson, base, binary, binary-orphans, bytestring
+     , case-insensitive, hashable, primitive, QuickCheck
+     , quickcheck-instances, scientific, tagged, tasty, tasty-quickcheck
+     , text, time-compat, unordered-containers, vector
+     , vector-binary-instances
+     }:
+     mkDerivation {
+       pname = "binary-instances";
+       version = "1.0.6";
+       sha256 = "08ljfwhylln9ynxhlzgaaj28nh16j9afzfk0q4gzbqv5zv1waxgb";
+       libraryHaskellDepends = [
+         aeson base binary binary-orphans case-insensitive hashable
+         primitive scientific tagged text 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
···
        pname = "binary-serialise-cbor";
        version = "0.2.2.0";
        sha256 = "16yhimka17dza5nda62927k5x66c0yrsxzz92kya3gicd6vaga2g";
-       revision = "2";
-       editedCabalFile = "1ff948jlri6dz86l45bzlv057mazl1jw1kvj0m8awmy5w4xhjhmp";
+       revision = "3";
+       editedCabalFile = "15j75qp9700k77g55jwi5jxidr7p1px5r764hnkw0ihwhrnlxnc8";
        libraryHaskellDepends = [ base bytestring cborg serialise ];
        description = "Yet Another Binary Serialisation Library (compatibility shim)";
        license = lib.licenses.bsd3;
···
      , flatparse, gauge, generic-data-functions, generic-random
      , generic-type-asserts, generic-type-functions, ghc-bignum, hspec
      , hspec-discover, parser-combinators, QuickCheck
-     , quickcheck-instances, rerefined, strongweak, text
-     , text-builder-linear, text-icu, type-level-bytestrings
-     , type-level-show
+     , quickcheck-instances, rerefined, text, text-builder-linear
+     , text-icu, type-level-bytestrings, type-level-show
      }:
      mkDerivation {
        pname = "binrep";
-       version = "1.0.0";
-       sha256 = "1m81r00b8wh1sz6y5jk0vgpj7ljp1fafb5zggc77zy77fak7fc7b";
+       version = "1.1.0";
+       sha256 = "1g5sk85p6hiywjgl4hifvdf861a8zh0fqwy3r3n5cqilhy6sks68";
        libraryHaskellDepends = [
          base bytestring bytezap deepseq defun-core flatparse
          generic-data-functions generic-type-asserts generic-type-functions
-         ghc-bignum parser-combinators rerefined strongweak text
-         text-builder-linear text-icu type-level-bytestrings type-level-show
+         ghc-bignum parser-combinators rerefined text text-builder-linear
+         text-icu type-level-bytestrings type-level-show
        ];
        testHaskellDepends = [
          base bytestring bytezap deepseq defun-core flatparse
          generic-data-functions generic-random generic-type-asserts
          generic-type-functions ghc-bignum hspec parser-combinators
-         QuickCheck quickcheck-instances rerefined strongweak text
-         text-builder-linear text-icu type-level-bytestrings type-level-show
+         QuickCheck quickcheck-instances rerefined text text-builder-linear
+         text-icu type-level-bytestrings type-level-show
        ];
        testToolDepends = [ hspec-discover ];
        benchmarkHaskellDepends = [
          base bytestring bytezap deepseq defun-core flatparse gauge
          generic-data-functions generic-type-asserts generic-type-functions
-         ghc-bignum parser-combinators rerefined strongweak text
-         text-builder-linear text-icu type-level-bytestrings type-level-show
+         ghc-bignum parser-combinators rerefined text text-builder-linear
+         text-icu type-level-bytestrings type-level-show
        ];
        description = "Encode precise binary representations directly in types";
        license = lib.licenses.mit;
        maintainers = [ lib.maintainers.raehik ];
      }) {};
 
+  "binrep-instances" = callPackage
+    ({ mkDerivation, base, binrep, strongweak }:
+     mkDerivation {
+       pname = "binrep-instances";
+       version = "0.2.0";
+       sha256 = "11jzjj0lw1swkr94y3qjb1yhxqmzz826a39584r7j1za16ly4l5q";
+       libraryHaskellDepends = [ base binrep strongweak ];
+       description = "Orphan instances for binrep";
+       license = lib.licenses.mit;
+     }) {};
+
   "bins" = callPackage
     ({ mkDerivation, base, containers, finite-typelits
      , ghc-typelits-knownnat, ghc-typelits-natnormalise, math-functions
···
        pname = "bits-extra";
        version = "0.0.2.3";
        sha256 = "1lyrr5jg8yg9cb97pn1pd4qgc7qn3irv8k5ra5j48fyn1rb6z4r7";
-       revision = "3";
-       editedCabalFile = "0cmss27g52vcw8vx8y5smvmiqrr1r6s1b9vihw4qrjj91x7w8sf9";
+       revision = "4";
+       editedCabalFile = "0bbsc76rz96npfcvp408vwfwkalynn5c1qhsy88zm4hxm337krpk";
        libraryHaskellDepends = [ base ghc-prim vector ];
        testHaskellDepends = [
          base doctest doctest-discover ghc-prim hedgehog hspec hw-hedgehog
···
        pname = "blank-canvas";
        version = "0.7.4";
        sha256 = "1qm0ms3jk8m5zv81lh3pn5n04afyq7bpn9lc137ddmm9blnkzndi";
-       revision = "6";
-       editedCabalFile = "1lyx0j47dlr4pn3fwvx1lqd71i5pnikf3d15s755knwifc8z3mgg";
+       revision = "7";
+       editedCabalFile = "06knam8p11j08cgxjrnfysrbzgp8fabh651xna0ygpfffylbj9qc";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base base-compat-batteries base64-bytestring bytestring
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "bloodhound_0_23_0_1" = callPackage
+    ({ mkDerivation, aeson, aeson-optics, base, blaze-builder
+     , bytestring, containers, doctest, errors, exceptions
+     , generic-random, hashable, hspec, hspec-discover, http-client
+     , http-types, microlens, mtl, network-uri, optics, optics-core
+     , pretty-simple, QuickCheck, quickcheck-properties, scientific
+     , template-haskell, temporary, text, time, unix-compat
+     , unordered-containers, vector, versions
+     }:
+     mkDerivation {
+       pname = "bloodhound";
+       version = "0.23.0.1";
+       sha256 = "1pgfvfbqvpfcljpybqwhz5y4l4lw7z8c9icmy4mjvciyjjbscc84";
+       libraryHaskellDepends = [
+         aeson base blaze-builder bytestring containers exceptions hashable
+         http-client http-types mtl network-uri optics-core scientific
+         template-haskell text time unordered-containers vector versions
+       ];
+       testHaskellDepends = [
+         aeson aeson-optics base bytestring containers doctest errors
+         exceptions generic-random hspec hspec-discover http-client
+         http-types microlens mtl optics pretty-simple QuickCheck
+         quickcheck-properties temporary text time unix-compat vector
+         versions
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Elasticsearch client library for Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bloodhound-amazonka-auth" = callPackage
     ({ mkDerivation, aeson, amazonka, amazonka-core
      , amazonka-elasticsearch, base, bloodhound, exceptions, http-client
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
+  "bluefin_0_0_15_0" = callPackage
+    ({ mkDerivation, bluefin-internal }:
+     mkDerivation {
+       pname = "bluefin";
+       version = "0.0.15.0";
+       sha256 = "0spy2zmq1gdw49iqnvn2xqg2ka5vz46afgdbr34wwrwxmj66q4r9";
+       libraryHaskellDepends = [ bluefin-internal ];
+       description = "The Bluefin effect system";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.maralorn ];
+     }) {};
+
   "bluefin-algae" = callPackage
     ({ mkDerivation, base, bluefin, bluefin-internal, tasty
      , tasty-bench, tasty-hunit
···
        license = lib.licenses.mit;
      }) {};
 
+  "bluefin-internal_0_0_15_0" = callPackage
+    ({ mkDerivation, async, base, monad-control, transformers
+     , transformers-base, unliftio-core
+     }:
+     mkDerivation {
+       pname = "bluefin-internal";
+       version = "0.0.15.0";
+       sha256 = "1cq1v2cva1vkda1dfwv1c6z8xxxq4qlwwjx3096snsawl8jhnlnj";
+       libraryHaskellDepends = [
+         async base monad-control transformers transformers-base
+         unliftio-core
+       ];
+       testHaskellDepends = [ base ];
+       description = "The Bluefin effect system, internals";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bluemix-sdk" = callPackage
     ({ mkDerivation, aeson, base, bytestring, http-client, http-types
      , text, vector
···
        pname = "boomwhacker";
        version = "0.0.2";
        sha256 = "0q5cq5j7dy1qm5jqpcl1imwiqqm0h21yvqwnvabsjnfrvfvryqg2";
+       revision = "1";
+       editedCabalFile = "0hwqdahpbinw9m7h05q0fhakj4w8mlvqz0ah6609x6wgb0dggmyb";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        executableHaskellDepends = [ base haskgame mtl SDL ];
        description = "A simple Breakout game implementation";
        license = "GPL";
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "breakout";
      }) {};
 
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "brick_2_8_2" = callPackage
+  "brick_2_8_3" = callPackage
     ({ mkDerivation, base, bimap, bytestring, config-ini, containers
      , data-clist, deepseq, directory, exceptions, filepath, hashable
      , microlens, microlens-mtl, microlens-th, mtl, QuickCheck, stm
···
      }:
      mkDerivation {
        pname = "brick";
-       version = "2.8.2";
-       sha256 = "03zvrbh9jp124gw4s7wndvh4kwimwq5v40jv7aw8dhvcqpwwv02q";
+       version = "2.8.3";
+       sha256 = "0nd62a95dj9lhsyda8lf3wafp21q9v3f43bv3qdfayg159qgq5jl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "broadcast-chan" = callPackage
-    ({ mkDerivation, async, base, criterion, deepseq, stm, transformers
-     , unliftio-core
+    ({ mkDerivation, async, base, clock, containers, criterion, deepseq
+     , foldl, monad-loops, optparse-applicative, paramtree, pipes-safe
+     , random, resourcet, stm, tagged, tasty, tasty-golden, tasty-hunit
+     , temporary, text, transformers, unliftio-core
      }:
      mkDerivation {
        pname = "broadcast-chan";
-       version = "0.2.1.2";
-       sha256 = "1zsrafz3q9l8np8wafmrbi8ilwwsgnzkc8jfjkjfgs4kq65yglqw";
-       revision = "2";
-       editedCabalFile = "06hyysplac9n76kpvqayc281ma8is578aqcspss0v8qkm0abylpj";
-       libraryHaskellDepends = [ base transformers unliftio-core ];
+       version = "0.3.0";
+       sha256 = "0namf7bw306706hs3r1j91xl6lplp6raj8yyw1xwavzx11dx583p";
+       libraryHaskellDepends = [
+         async base clock containers optparse-applicative paramtree
+         pipes-safe resourcet stm tagged tasty tasty-golden tasty-hunit
+         temporary text transformers unliftio-core
+       ];
+       testHaskellDepends = [
+         base containers foldl monad-loops pipes-safe random
+       ];
        benchmarkHaskellDepends = [ async base criterion deepseq stm ];
+       doHaddock = false;
        description = "Closable, fair, single-wakeup channel type that avoids 0 reader space leaks";
        license = lib.licenses.bsd3;
      }) {};
 
   "broadcast-chan-conduit" = callPackage
-    ({ mkDerivation, base, broadcast-chan, broadcast-chan-tests
-     , conduit, containers, resourcet, transformers, unliftio-core
-     }:
+    ({ mkDerivation, broadcast-chan }:
      mkDerivation {
        pname = "broadcast-chan-conduit";
-       version = "0.2.1.2";
-       sha256 = "0mwd82arm50zwz559qzxi70ia9d4h5kjwdvhk09jf966hd0knnmm";
-       revision = "2";
-       editedCabalFile = "1k7lgfpxh7vyyv68m8bznl1b3nnr10xx7ky01r2x5b75f96asll4";
-       libraryHaskellDepends = [
-         base broadcast-chan conduit resourcet transformers unliftio-core
-       ];
-       testHaskellDepends = [
-         base broadcast-chan-tests conduit containers
-       ];
+       version = "0.3.0";
+       sha256 = "1xpznndpf56c403bifg4pb902m98z0lcvi0j2fk3xw37b4fqaclk";
+       libraryHaskellDepends = [ broadcast-chan ];
+       doHaddock = false;
        description = "Conduit-based parallel streaming code for broadcast-chan";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "broadcast-chan-pipes" = callPackage
-    ({ mkDerivation, base, broadcast-chan, broadcast-chan-tests
-     , containers, foldl, pipes, pipes-safe
-     }:
+    ({ mkDerivation, broadcast-chan }:
      mkDerivation {
        pname = "broadcast-chan-pipes";
-       version = "0.2.1.1";
-       sha256 = "06nghcddlcnc97p3464fsgcfvjlsnxv7i7khzws3g3myl8hrd89c";
-       revision = "2";
-       editedCabalFile = "0vzfjjhy4k07aizg1q3a1r99cacnihkjsxakllygrkl9hsya2cp0";
-       libraryHaskellDepends = [ base broadcast-chan pipes pipes-safe ];
-       testHaskellDepends = [
-         base broadcast-chan-tests containers foldl pipes pipes-safe
-       ];
+       version = "0.3.0";
+       sha256 = "031iqay33l68sh4hfj1icwiys1pwav9lp5ckfpcf7pmplngal890";
+       libraryHaskellDepends = [ broadcast-chan ];
+       doHaddock = false;
        description = "Pipes-based parallel streaming code for broadcast-chan";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "broadcast-chan-tests" = callPackage
···
        pname = "broadcast-chan-tests";
        version = "0.2.1.2";
        sha256 = "08qjvhdx2pwgj5kcl5fmg5qdlzbdchxjihmqch4sgv48kcga06nv";
-       revision = "4";
-       editedCabalFile = "1y1qxb9ibplx1hpwxwa83szxjwa6ridji25w0gmx92yrz11rprlj";
+       revision = "5";
+       editedCabalFile = "02ikd1lm606jdzm38cjrhl57g6lf0gsjw127s9mzfkibxnk0paay";
        libraryHaskellDepends = [
          async base broadcast-chan clock containers optparse-applicative
          paramtree stm tagged tasty tasty-golden tasty-hunit tasty-travis
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "bv-sized_1_0_6" = callPackage
+    ({ mkDerivation, base, bitwise, bytestring, deepseq, hedgehog
+     , MonadRandom, panic, parameterized-utils, random, tasty
+     , tasty-hedgehog, th-lift
+     }:
+     mkDerivation {
+       pname = "bv-sized";
+       version = "1.0.6";
+       sha256 = "1whz889kykmsps7z8xai4347gf186c3ygq6v9bgp148hfqqaiqmd";
+       libraryHaskellDepends = [
+         base bitwise bytestring deepseq panic parameterized-utils random
+         th-lift
+       ];
+       testHaskellDepends = [
+         base bytestring hedgehog MonadRandom parameterized-utils tasty
+         tasty-hedgehog
+       ];
+       description = "a bitvector datatype that is parameterized by the vector width";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bv-sized-lens" = callPackage
     ({ mkDerivation, base, bv-sized, lens, parameterized-utils }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "byline";
-       version = "1.1.2";
-       sha256 = "11z9dga8jq3f0h4v0c3s2brrcqb029h6wsn0x97393vkx7pjhai2";
+       version = "1.1.3";
+       sha256 = "14nczmwjz44cdz2hhgfll9widdw3a13zj2l8rg1iw59l8y9wq3hi";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "byteset_0_1_1_2" = callPackage
+    ({ mkDerivation, base, binary }:
+     mkDerivation {
+       pname = "byteset";
+       version = "0.1.1.2";
+       sha256 = "1ibq073s22yvgs6insnigcnk39qnsdhk73awnsq0kav8x37mnrzr";
+       libraryHaskellDepends = [ base binary ];
+       description = "Set of bytes";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "byteslice" = callPackage
     ({ mkDerivation, base, bytestring, gauge, natural-arithmetic
      , primitive, primitive-addr, primitive-unlifted, quickcheck-classes
···
      }) {};
 
   "bz3" = callPackage
-    ({ mkDerivation, base, binary, bytestring, c2hs, directory, tasty
-     , tasty-hunit
+    ({ mkDerivation, base, binary, bytestring, c2hs, directory, random
+     , tasty, tasty-hunit
      }:
      mkDerivation {
        pname = "bz3";
-       version = "0.1.0.0";
-       sha256 = "0mij0x122rldgskyy85gq4jmd29b420hmvphy8bdkipa2wfhqf6r";
+       version = "1.0.0.0";
+       sha256 = "1iik8r9hwhyqfi71f8nc0lb2ia18lgkrfsfcl98y7cfq243svc1a";
        libraryHaskellDepends = [ base binary bytestring ];
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [
-         base bytestring directory tasty tasty-hunit
+         base bytestring directory random tasty tasty-hunit
        ];
        description = "High-level bindings to bz3";
        license = lib.licenses.agpl3Plus;
···
        pname = "cabal-add";
        version = "0.1";
        sha256 = "1szbi0z8yf98641rwnj856gcfsvvflxwrfxraxy6rl60m7i0mab1";
-       revision = "1";
-       editedCabalFile = "0zwinjbnw4a191c951wwavbh6x6f300l0kgv53fiffxfn66x9w6f";
+       revision = "2";
+       editedCabalFile = "1qb5xq7r68psc2dpp8wdfcfd1w4nls7xfla1fkc9vppd8zxmi87m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = [ lib.maintainers.turion ];
      }) {};
 
+  "cabal-gild_1_6_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal-syntax, containers
+     , directory, exceptions, filepath, filepattern, hspec, parsec
+     , pretty, temporary, text, transformers
+     }:
+     mkDerivation {
+       pname = "cabal-gild";
+       version = "1.6.0.0";
+       sha256 = "09i4s1r5362w4q2ad2scw0d2p2p7l52b7nycxvrc71sb5a1x6zlw";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring Cabal-syntax containers exceptions filepath
+         filepattern parsec pretty text transformers
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base bytestring containers directory exceptions filepath
+         filepattern hspec temporary transformers
+       ];
+       description = "Formats package descriptions";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "cabal-gild";
+       maintainers = [ lib.maintainers.turion ];
+     }) {};
+
   "cabal-graphdeps" = callPackage
     ({ mkDerivation, base, containers, directory, options, parsec
      , process, split, temporary
···
        mainProgram = "cabal-rpm";
      }) {};
 
+  "cabal-rpm_2_3_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, Cabal, cached-json-file
+     , directory, extra, filepath, html-entities, http-client
+     , http-client-tls, http-query, safe, simple-cabal, simple-cmd
+     , simple-cmd-args, text, time, unix
+     }:
+     mkDerivation {
+       pname = "cabal-rpm";
+       version = "2.3.0";
+       sha256 = "1scgf9npfjynj5b730zjk0yzyq74v2dghs0pwp2zg4kl0hxp6sw0";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson base bytestring Cabal cached-json-file directory extra
+         filepath html-entities http-client http-client-tls http-query safe
+         simple-cabal simple-cmd simple-cmd-args text time unix
+       ];
+       description = "RPM packaging tool for Haskell Cabal-based packages";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "cabal-rpm";
+     }) {};
+
   "cabal-scaffold" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
      , bytestring, case-insensitive, conduit, containers, dlist
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "cabal-sort_0_1_2_2" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, comfort-graph, containers
+     , directory, explicit-exception, filepath, non-empty
+     , optparse-applicative, process, shell-utility, transformers
+     , utility-ht
+     }:
+     mkDerivation {
+       pname = "cabal-sort";
+       version = "0.1.2.2";
+       sha256 = "1gyx5d485mzya147d7gwh0i9bkvdqxixrb80bfv5sn710p07bfdz";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base bytestring Cabal comfort-graph containers directory
+         explicit-exception filepath non-empty optparse-applicative process
+         shell-utility transformers utility-ht
+       ];
+       description = "Topologically sort cabal packages";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "cabal-src" = callPackage
     ({ mkDerivation, base, bytestring, conduit, conduit-extra
      , containers, directory, filepath, http-conduit, http-types
···
      }) {};
 
   "cabal2nix" = callPackage
-    ({ mkDerivation, aeson, ansi-wl-pprint, base, bytestring, Cabal
-     , containers, deepseq, directory, distribution-nixpkgs, filepath
-     , hackage-db, hopenssl, hpack, language-nix, lens, monad-par
-     , monad-par-extras, mtl, optparse-applicative, pretty, process
-     , split, tasty, tasty-golden, text, time, transformers, yaml
+    ({ mkDerivation, aeson, ansi-terminal, ansi-wl-pprint, base
+     , bytestring, Cabal, containers, deepseq, directory
+     , distribution-nixpkgs, filepath, hackage-db, hopenssl, hpack
+     , language-nix, lens, monad-par, monad-par-extras, mtl
+     , optparse-applicative, pretty, process, split, tasty, tasty-golden
+     , text, time, transformers, yaml
      }:
      mkDerivation {
        pname = "cabal2nix";
-       version = "2.19.1";
-       sha256 = "1ck7yqvvxkylwh3pw8hj24jg5jqx6hqy3bm37dkg85q9p9fs7nz0";
+       version = "2.20.0";
+       sha256 = "1mf9af4x1jndjlxis05r32fg03naaljc3zvha69n69r9m79vpd9i";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson ansi-wl-pprint base bytestring Cabal containers deepseq
-         directory distribution-nixpkgs filepath hackage-db hopenssl hpack
-         language-nix lens optparse-applicative pretty process split text
-         time transformers yaml
+         aeson ansi-terminal ansi-wl-pprint base bytestring Cabal containers
+         deepseq directory distribution-nixpkgs filepath hackage-db hopenssl
+         hpack language-nix lens optparse-applicative pretty process split
+         text time transformers yaml
        ];
        executableHaskellDepends = [
          aeson base bytestring Cabal containers directory
···
        pname = "cached-io";
        version = "1.3.0.0";
        sha256 = "0bxb59brgfv1rgarsc1cix1g1043zl263j5a0rhpzvd80wj6msi2";
-       revision = "1";
-       editedCabalFile = "184j3550mp5d79ia2a0fzvywgkxzilsnj0f33wh1whaxdw1zwj1i";
+       revision = "2";
+       editedCabalFile = "0k3clbankknvbfwws70lpi6kazbvh7zj36h5rphf6wi94q9k9b4n";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base exceptions stm time transformers ];
···
      }:
      mkDerivation {
        pname = "cachix";
-       version = "1.7.6";
-       sha256 = "0534lkrfwgvmdsplg83z8z5yzif0l96nmkaw8s6sacmckvh5virn";
+       version = "1.7.7";
+       sha256 = "1hlihm8lwng0g2w1a1cw56y32h85hdb1nxx9h8p60fql46z2f18w";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "cachix-api";
-       version = "1.7.6";
-       sha256 = "1x5hhnjppik38n4q105331isl0bag6b32iw07zlm4kbjhl164bwr";
+       version = "1.7.7";
+       sha256 = "13gr7l65xpn8y32cds129bwwsjmc4ykz3vzvfm5hvmi5przlwb88";
        libraryHaskellDepends = [
          aeson async base bytestring conduit crypton deriving-aeson
          exceptions http-media jose memory nix-narinfo protolude resourcet
···
        libraryPkgconfigDepends = [ cairo ];
        description = "Binding to the Cairo library";
        license = lib.licenses.bsd3;
+     }) {inherit (pkgs) cairo;};
+
+  "cairo_0_13_12_0" = callPackage
+    ({ mkDerivation, array, base, bytestring, Cabal, cairo
+     , gtk2hs-buildtools, mtl, text, utf8-string
+     }:
+     mkDerivation {
+       pname = "cairo";
+       version = "0.13.12.0";
+       sha256 = "1d3ba8gz72f8dz3m5c2i6y85b3vf7405m16al7ms7k9qjy1wcpby";
+       enableSeparateDataOutput = true;
+       setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
+       libraryHaskellDepends = [
+         array base bytestring mtl text utf8-string
+       ];
+       libraryPkgconfigDepends = [ cairo ];
+       description = "Binding to the Cairo library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) cairo;};
 
   "cairo-appbase" = callPackage
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) cairo;};
 
+  "cairo-image_0_1_0_5" = callPackage
+    ({ mkDerivation, base, c-enum, cairo, primitive, template-haskell
+     }:
+     mkDerivation {
+       pname = "cairo-image";
+       version = "0.1.0.5";
+       sha256 = "13k7s3lpcb6mcc7ndyp139zr4xglfvhvx6d5ji2dxgk0s0nkj899";
+       libraryHaskellDepends = [ base c-enum primitive template-haskell ];
+       libraryPkgconfigDepends = [ cairo ];
+       testHaskellDepends = [ base c-enum primitive template-haskell ];
+       description = "Image for Cairo";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) cairo;};
+
   "cake" = callPackage
     ({ mkDerivation, array, base, binary, bytestring, cmdargs
      , containers, derive, directory, filepath, mtl, parsek, process
···
      }) {};
 
   "canadian-income-tax" = callPackage
-    ({ mkDerivation, base, bifunctors, bitwise-enum, bytestring
+    ({ mkDerivation, aeson, base, bifunctors, bitwise-enum, bytestring
      , ca-province-codes, containers, deep-transformations, directory
      , filepath, forms-data-format, hedgehog, http-types
      , monoid-subclasses, optparse-applicative, rank2classes, scotty
···
      }:
      mkDerivation {
        pname = "canadian-income-tax";
-       version = "2023.0";
-       sha256 = "0gys5qy3dihqqqpdvdpxjip7rh5p9h8xkf8fs4y7lbmjrfr5kbsq";
+       version = "2024.0";
+       sha256 = "0lciy9q87wjv8gpc0qhgf2p7bpcxk7bg0ka7ac86c201qbva1xw7";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          rank2classes template-haskell text time typed-process
        ];
        executableHaskellDepends = [
-         base bytestring ca-province-codes containers directory filepath
-         forms-data-format http-types monoid-subclasses optparse-applicative
-         rank2classes scotty tar text time unix wai-extra
-         wai-middleware-static zip-archive
+         aeson base bytestring ca-province-codes containers directory
+         filepath forms-data-format http-types monoid-subclasses
+         optparse-applicative rank2classes scotty tar text time unix
+         wai-extra wai-middleware-static zip-archive
        ];
        testHaskellDepends = [
          base bytestring ca-province-codes containers deep-transformations
···
        description = "Candid integration";
        license = lib.licenses.asl20;
        mainProgram = "hcandid";
-       maintainers = [ lib.maintainers.nomeata ];
      }) {};
 
   "canon" = callPackage
···
        mainProgram = "carboncopy";
      }) {};
 
+  "cardano-addresses" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, ansi-wl-pprint
+     , base, base58-bytestring, basement, bech32, bech32-th, binary
+     , bytestring, cardano-address, cardano-crypto, cborg, containers
+     , crypton, deepseq, digest, either, exceptions, extra, fmt
+     , hashable, hspec, hspec-discover, hspec-golden, memory, mtl
+     , optparse-applicative, pretty-simple, process, QuickCheck, safe
+     , string-interpolate, template-haskell, temporary, text
+     , transformers, unordered-containers, with-utf8
+     }:
+     mkDerivation {
+       pname = "cardano-addresses";
+       version = "4.0.0";
+       sha256 = "13cvazmshy3j9c53g7i8pd4fmh6mgiajhaf42cf2d353pjjxr1w4";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty ansi-terminal ansi-wl-pprint base
+         base58-bytestring basement bech32 bech32-th binary bytestring
+         cardano-crypto cborg containers crypton deepseq digest either
+         exceptions extra fmt hashable memory mtl optparse-applicative
+         process safe template-haskell text transformers
+         unordered-containers
+       ];
+       executableHaskellDepends = [ base with-utf8 ];
+       testHaskellDepends = [
+         aeson aeson-pretty base bech32 bech32-th binary bytestring
+         cardano-crypto containers crypton hspec hspec-golden memory
+         pretty-simple process QuickCheck string-interpolate temporary text
+         with-utf8
+       ];
+       testToolDepends = [ cardano-address hspec-discover ];
+       description = "Utils for constructing a command-line on top of cardano-addresses";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "cardano-address";
+     }) {cardano-address = null;};
+
   "cardano-coin-selection" = callPackage
     ({ mkDerivation, base, bytestring, containers, cryptonite, deepseq
      , fmt, hspec, memory, QuickCheck, quiet, random, text, transformers
···
        ];
        description = "Algorithms for coin selection and fee balancing";
        license = lib.licenses.asl20;
+     }) {};
+
+  "cardano-crypto" = callPackage
+    ({ mkDerivation, base, basement, bytestring, crypton, deepseq
+     , foundation, gauge, hashable, integer-gmp, memory
+     }:
+     mkDerivation {
+       pname = "cardano-crypto";
+       version = "1.3.0";
+       sha256 = "0yd83mvpspxbdr6k4gf00l1hbgiwm5qhaa3dfh2scn34g401ngjx";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base basement bytestring crypton deepseq foundation hashable
+         integer-gmp memory
+       ];
+       testHaskellDepends = [
+         base basement bytestring crypton foundation memory
+       ];
+       benchmarkHaskellDepends = [ base bytestring crypton gauge memory ];
+       description = "Cryptography primitives for cardano";
+       license = lib.licenses.mit;
      }) {};
 
   "cardano-transactions" = callPackage
···
        hydraPlatforms = lib.platforms.none;
        mainProgram = "cardano-tx";
        broken = true;
-     }) {cardano-binary = null; cardano-crypto = null; 
-         cardano-crypto-wrapper = null; cardano-ledger = null; 
-         cardano-ledger-test = null; cardano-tx = null;};
+     }) {cardano-binary = null; cardano-crypto-wrapper = null; 
+         cardano-ledger = null; cardano-ledger-test = null; 
+         cardano-tx = null;};
 
   "carettah" = callPackage
     ({ mkDerivation, base, cairo, directory, filepath, gtk
···
        pname = "cassava";
        version = "0.5.3.2";
        sha256 = "1jd9s10z2y3hizrpy3iaw2vvqmk342zxhwkky57ba39cbli5vlis";
+       revision = "1";
+       editedCabalFile = "0xkqzvj5xd6d37gpf2rm9cp2p2lhkc3jgd0gvlmv99vcmy125rdj";
        configureFlags = [ "-f-bytestring--lt-0_10_4" ];
        libraryHaskellDepends = [
          array attoparsec base bytestring containers deepseq hashable Only
···
      }:
      mkDerivation {
        pname = "cbor-tool";
-       version = "0.2.2.0";
-       sha256 = "0rsnnz1zh9jyjif94lrdppzaa41hypqs1r5dlyzbwlw1m75g286p";
-       revision = "5";
-       editedCabalFile = "0lwxyz8c9mrhq4lqdwwv0y82islakbhwv1jlmjw20ha47g1mg69n";
+       version = "0.2.3.0";
+       sha256 = "0g501fmlz99zj0rglzzcbsp8nqj2ac06f281b82jar3ysv2qhnac";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "cborg";
        version = "0.2.10.0";
        sha256 = "15y7p5rsv76fpklh4rgrxlxxaivpbchxdfdw96mqqjgw7060gzhp";
-       revision = "1";
-       editedCabalFile = "0x48942znc78nh63lxibaascaj1wxsqjg7r4vifisl9zlzccpcpp";
+       revision = "2";
+       editedCabalFile = "0m1ndq1a4yya5p7093lw3ynpcw2q74s73im0bhm9jp6a19cj88m5";
        libraryHaskellDepends = [
          array base bytestring containers deepseq ghc-bignum ghc-prim half
          primitive text
···
        pname = "cborg-json";
        version = "0.2.6.0";
        sha256 = "1p6xdimwypmlsc0zdyw1vyyapnhwn2g8b9n0a83ca6h4r90722yv";
-       revision = "2";
-       editedCabalFile = "1vj7p8k3ksb6fizsl39rb99zsjfh1wm7i9q9m18s4c8llnylhw0a";
+       revision = "3";
+       editedCabalFile = "1dlmm5jyl8a8rxpkvr2dk5dlsvxrap3x4pbwnx4mg3q7sz25rs8r";
        libraryHaskellDepends = [
          aeson aeson-pretty base base64-bytestring cborg scientific text
          unordered-containers vector
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "cgi_3001_5_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, exceptions, mtl
+     , multipart, network-uri, parsec, text, time, xhtml
+     }:
+     mkDerivation {
+       pname = "cgi";
+       version = "3001.5.1.0";
+       sha256 = "0n7a1vfja26340xfg4ni5zrcwqcc1wmpsxmyksyhri99kb6g9rm0";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers exceptions mtl multipart network-uri
+         parsec text time xhtml
+       ];
+       description = "A library for writing CGI programs";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "cgi-undecidable" = callPackage
     ({ mkDerivation, base, cgi, mtl }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "charset_0_3_12" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "charset";
+       version = "0.3.12";
+       sha256 = "0bbjrbgqdxiz47c0g5am6xh4lk3llbyiiqcz162md7df8kacds0w";
+       libraryHaskellDepends = [
+         array base bytestring containers unordered-containers
+       ];
+       description = "Fast unicode character sets based on complemented PATRICIA tries";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "charsetdetect" = callPackage
     ({ mkDerivation, base, bytestring }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "checked-exceptions" = callPackage
+    ({ mkDerivation, base, constraints, exceptions, ghc
+     , ghc-tcplugins-extra, HUnit, mtl, QuickCheck, tasty, tasty-hunit
+     , tasty-quickcheck, text, transformers
+     }:
+     mkDerivation {
+       pname = "checked-exceptions";
+       version = "0.2.0.0";
+       sha256 = "07gy2yyf47223qwqnrgq53pvdwd43q3ava5f2yv828bkzwv4yj44";
+       revision = "1";
+       editedCabalFile = "1dglb1zsgl0h2z9mlrawabqqdjrh28p2pznldcn1a92k225fnnr2";
+       libraryHaskellDepends = [
+         base constraints exceptions ghc ghc-tcplugins-extra mtl
+       ];
+       testHaskellDepends = [
+         base HUnit mtl QuickCheck tasty tasty-hunit tasty-quickcheck text
+         transformers
+       ];
+       description = "mtl-style checked exceptions";
+       license = lib.licenses.mit;
+     }) {};
+
   "checkers" = callPackage
     ({ mkDerivation, array, base, QuickCheck, random, semigroupoids }:
      mkDerivation {
···
        ];
        description = "Constraint Handling Rules";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "chr-data" = callPackage
···
        ];
        description = "Datatypes required for chr library";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "chr-lang" = callPackage
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "clash-finite" = callPackage
+    ({ mkDerivation, base, clash-prelude, constraints, deepseq
+     , ghc-typelits-extra, ghc-typelits-knownnat
+     , ghc-typelits-natnormalise, singletons, tasty, tasty-hunit
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "clash-finite";
+       version = "1.0.0.0";
+       sha256 = "12527rfb4s43n1plk6gn7km4zh4k2izfyx57h32hj0w0sb8y9kvr";
+       libraryHaskellDepends = [
+         base clash-prelude constraints ghc-typelits-extra
+         ghc-typelits-knownnat ghc-typelits-natnormalise singletons
+         template-haskell
+       ];
+       testHaskellDepends = [
+         base clash-prelude constraints deepseq tasty tasty-hunit
+       ];
+       description = "A class for types with only finitely many inhabitants";
+       license = lib.licenses.mit;
+     }) {};
+
   "clash-ghc" = callPackage
     ({ mkDerivation, array, base, bytestring, Cabal, clash-lib
      , clash-prelude, containers, data-binary-ieee754, deepseq
···
        pname = "clash-ghc";
        version = "1.8.2";
        sha256 = "1pwbpk0f502jx37raq4n64c39jgcrzbya7nzzi6mq7wjm1xmxnsw";
+       revision = "1";
+       editedCabalFile = "02arsg7mjlz8kjy04nsl4s91202ws40f1xccsm5kjs2zisgqcp15";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "clash-lib";
        version = "1.8.2";
        sha256 = "02yzqkzaligkvd3830nsgnmnpswydf1a67hrhyhn6gg5crmb2jmg";
+       revision = "1";
+       editedCabalFile = "0ygb5h1y42q1l34zfb218h4vr3sv4bm5lshh04171a0v0ikjkxnx";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "clash-prelude";
        version = "1.8.2";
        sha256 = "0pxzb0cj3wp2fjjj6wa2hnbqpvg7rrfza3fqr7m5c7l73yjmi2m3";
+       revision = "2";
+       editedCabalFile = "05xq9523nfip6qzjrjsyy1jj84s86zad3jml5vd720v8aplkjrmc";
        libraryHaskellDepends = [
          array arrows base binary bytestring constraints containers
          data-binary-ieee754 data-default-class deepseq extra ghc-bignum
···
        pname = "clash-prelude-hedgehog";
        version = "1.8.2";
        sha256 = "0fn92r1zhdabqdanh3wqgcrmvqg886jap82r3h25gsldz6f8635m";
+       revision = "1";
+       editedCabalFile = "1hvclgpy4vl129qvm8px9w7hq2cv15m4zacdn2ay300sp0mbiwg3";
        libraryHaskellDepends = [
          base clash-prelude ghc-typelits-knownnat ghc-typelits-natnormalise
          hedgehog text
···
        license = lib.licenses.mpl20;
      }) {};
 
+  "co-log_0_6_1_2" = callPackage
+    ({ mkDerivation, ansi-terminal, base, bytestring, chronos
+     , co-log-core, containers, contravariant, dependent-map
+     , dependent-sum, directory, doctest, exceptions, filepath, Glob
+     , hedgehog, mtl, text, transformers, unliftio-core, vector
+     }:
+     mkDerivation {
+       pname = "co-log";
+       version = "0.6.1.2";
+       sha256 = "0qq3zad2pq6y37ll0hdz3481grng6ms0rb9vkf66663p2qbkngqh";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-terminal base bytestring chronos co-log-core containers
+         contravariant dependent-map dependent-sum directory exceptions
+         filepath mtl text transformers unliftio-core vector
+       ];
+       executableHaskellDepends = [ base bytestring dependent-map mtl ];
+       testHaskellDepends = [ base co-log-core doctest Glob hedgehog ];
+       description = "Composable Contravariant Comonadic Logging Library";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "co-log-concurrent" = callPackage
     ({ mkDerivation, base, co-log-core, stm }:
      mkDerivation {
···
        testHaskellDepends = [ base doctest Glob ];
        description = "Composable Contravariant Comonadic Logging Library";
        license = lib.licenses.mpl20;
+     }) {};
+
+  "co-log-core_0_3_2_5" = callPackage
+    ({ mkDerivation, base, doctest, Glob }:
+     mkDerivation {
+       pname = "co-log-core";
+       version = "0.3.2.5";
+       sha256 = "0nizwa5z13ydhqc0vvpzpb8cwdqqdsgpv45v0k6929m0yxhrwp7r";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base doctest Glob ];
+       description = "Composable Contravariant Comonadic Logging Library";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "co-log-effectful" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "code-conjure_0_6_2" = callPackage
+  "code-conjure_0_6_10" = callPackage
     ({ mkDerivation, base, express, leancheck, speculate
      , template-haskell
      }:
      mkDerivation {
        pname = "code-conjure";
-       version = "0.6.2";
-       sha256 = "0wsy7zn74xxzsgra43mpg2xx5wwv5aw6hg3f85kgwxpcmhrzhn6n";
+       version = "0.6.10";
+       sha256 = "195xik1h55bl5rjipl2g979jnwh99h223v23di82cwaafmv747bn";
        libraryHaskellDepends = [
          base express leancheck speculate template-haskell
        ];
···
        pname = "comfort-graph";
        version = "0.0.4";
        sha256 = "1v3acgdr8srvpddl2kvap556ag93b9yphjf3y1qy14sq6f7v46hc";
-       revision = "1";
-       editedCabalFile = "0lkk5p558x0dv8vfy329g2amaai76gkxdnb8nzy3miw76vvi5xrw";
+       revision = "2";
+       editedCabalFile = "05fhxw5lb81iah3siqv7liljj07qls6l3zl9kgrx3a9n865vygvw";
        libraryHaskellDepends = [
          base containers QuickCheck semigroups transformers utility-ht
        ];
···
        maintainers = [ lib.maintainers.alexfmpe ];
      }) {};
 
+  "commutative-semigroups_0_2_0_2" = callPackage
+    ({ mkDerivation, base, containers }:
+     mkDerivation {
+       pname = "commutative-semigroups";
+       version = "0.2.0.2";
+       sha256 = "06s7mw3j2g6yinabw3w1ncpph6q4n36almbn4xv7lqi5k7bb297q";
+       libraryHaskellDepends = [ base containers ];
+       description = "Commutative semigroups";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.alexfmpe ];
+     }) {};
+
   "comonad" = callPackage
     ({ mkDerivation, base, containers, distributive
      , indexed-traversable, tagged, transformers, transformers-compat
···
        pname = "comonad";
        version = "5.0.9";
        sha256 = "12d7g3c2x1jb6jlmdgwdmi840z3p91b0l7fkfsdml1c0kas0xyv9";
+       revision = "1";
+       editedCabalFile = "0ly3cy3p99zvizspassk0wjnw9bz0spc11s69s790g2qpxwyvbbm";
        libraryHaskellDepends = [
          base containers distributive indexed-traversable tagged
          transformers transformers-compat
···
        pname = "compact";
        version = "0.2.0.0";
        sha256 = "0xv24vd2h76928355rr8gzdbkyn2j17yf6wjyghnzw7qyhsbb9h3";
-       revision = "3";
-       editedCabalFile = "198fvj8a5f0wh0wk2k7gzhxczbqlyxafyy6mi5qf5wh9hpj7vb6q";
+       revision = "4";
+       editedCabalFile = "1psnvlnacwmnnf204ynav9bq5x7zaj5qma092lv3g6jiz1jn74v3";
        libraryHaskellDepends = [ base binary bytestring ghc-compact ];
        testHaskellDepends = [ base directory ];
        description = "Non-GC'd, contiguous storage for immutable data structures";
···
        license = lib.licenses.mit;
      }) {};
 
+  "conduit_1_3_6_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, directory
+     , exceptions, filepath, gauge, hspec, mono-traversable, mtl
+     , mwc-random, primitive, QuickCheck, resourcet, safe, silently
+     , split, text, transformers, unix, unliftio, unliftio-core, vector
+     }:
+     mkDerivation {
+       pname = "conduit";
+       version = "1.3.6.1";
+       sha256 = "0gxsahlfaqjkmr0a2bm5s1i3p5rnzqma8gd85yccpr577vq2m439";
+       libraryHaskellDepends = [
+         base bytestring directory exceptions filepath mono-traversable mtl
+         primitive resourcet text transformers unix unliftio-core vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory exceptions filepath hspec
+         mono-traversable mtl QuickCheck resourcet safe silently split text
+         transformers unliftio vector
+       ];
+       benchmarkHaskellDepends = [
+         base containers deepseq gauge hspec mwc-random transformers vector
+       ];
+       description = "Streaming data processing library";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "conduit-aeson" = callPackage
     ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base
      , bytestring, conduit, conduit-extra, containers, doctest, hspec
···
        mainProgram = "example";
      }) {};
 
+  "configuration-tools_0_7_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base-unicode-symbols
+     , bytestring, Cabal, case-insensitive, deepseq, directory, dlist
+     , filepath, mtl, network-uri, optparse-applicative, prettyprinter
+     , process, profunctors, semigroupoids, semigroups, text
+     , transformers, unordered-containers, vector, yaml
+     }:
+     mkDerivation {
+       pname = "configuration-tools";
+       version = "0.7.1";
+       sha256 = "0ihhanxc544qyw56h3858y1jbh0lqbwlaxjaqhdbkpqj7liqy5hz";
+       isLibrary = true;
+       isExecutable = true;
+       setupHaskellDepends = [
+         base bytestring Cabal directory filepath process
+       ];
+       libraryHaskellDepends = [
+         aeson attoparsec base base-unicode-symbols bytestring Cabal
+         case-insensitive deepseq directory dlist filepath mtl network-uri
+         optparse-applicative prettyprinter process profunctors
+         semigroupoids semigroups text transformers unordered-containers
+         vector yaml
+       ];
+       executableHaskellDepends = [ base base-unicode-symbols Cabal mtl ];
+       testHaskellDepends = [
+         base base-unicode-symbols bytestring Cabal mtl text transformers
+         unordered-containers yaml
+       ];
+       description = "Tools for specifying and parsing configurations";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "example";
+     }) {};
+
   "configurator" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, directory, filepath
      , hashable, HUnit, test-framework, test-framework-hunit, text
···
      }) {};
 
   "consumers" = callPackage
-    ({ mkDerivation, base, containers, exceptions, hpqtypes
+    ({ mkDerivation, aeson, base, containers, exceptions, hpqtypes
      , hpqtypes-extras, HUnit, lifted-base, lifted-threads, log-base
-     , monad-control, monad-time, mtl, safe-exceptions, stm, text
-     , text-show, time, transformers, transformers-base
+     , monad-control, monad-time, mtl, safe-exceptions, stm, text, time
+     , transformers, transformers-base
      }:
      mkDerivation {
        pname = "consumers";
-       version = "2.3.2.0";
-       sha256 = "1kj7ng8cpwvbc8x3bzcnkk19g3hrcy3v2c5kpxqn52x607c9flmf";
+       version = "2.3.3.0";
+       sha256 = "19j16m20qrlqqgcp1nfzn9q9bv3b27vn48chpj2ifh0l9mxjqnmv";
        libraryHaskellDepends = [
-         base containers exceptions hpqtypes lifted-base lifted-threads
-         log-base monad-control monad-time mtl safe-exceptions stm text time
-         transformers-base
+         aeson base containers exceptions hpqtypes lifted-base
+         lifted-threads log-base monad-control monad-time mtl
+         safe-exceptions stm text time transformers-base
        ];
        testHaskellDepends = [
          base exceptions hpqtypes hpqtypes-extras HUnit log-base
-         monad-control monad-time mtl stm text text-show time transformers
+         monad-control monad-time mtl stm text time transformers
          transformers-base
        ];
        description = "Concurrent PostgreSQL data consumers";
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "consumers-metrics-prometheus" = callPackage
+    ({ mkDerivation, base, consumers, exceptions, hpqtypes, lifted-base
+     , log-base, monad-control, monad-time, prometheus-client
+     , safe-exceptions, transformers-base
+     }:
+     mkDerivation {
+       pname = "consumers-metrics-prometheus";
+       version = "1.0.0.0";
+       sha256 = "1iing53h6ph5bqp00hzqwv16rrp8xjvprwbk9zfbk64j9kwy8qph";
+       libraryHaskellDepends = [
+         base consumers exceptions hpqtypes lifted-base log-base
+         monad-control monad-time prometheus-client safe-exceptions
+         transformers-base
+       ];
+       description = "Prometheus metrics for the consumers library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "container" = callPackage
     ({ mkDerivation, base, containers, convert, lens, text, vector }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "containers_0_7" = callPackage
+  "containers_0_8" = callPackage
     ({ mkDerivation, array, base, deepseq, template-haskell }:
      mkDerivation {
        pname = "containers";
-       version = "0.7";
-       sha256 = "09732p786v3886vgk5c272fid62wlwqa4wrncjwg0n3isba04sfg";
+       version = "0.8";
+       sha256 = "1n2bm64z66myhls9bm4yli3a2760c95abkih1d6q8vvvymzi5hdi";
        libraryHaskellDepends = [ array base deepseq template-haskell ];
        description = "Assorted concrete container types";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "copilot_4_2" = callPackage
+  "copilot_4_3" = callPackage
     ({ mkDerivation, base, copilot-c99, copilot-core, copilot-language
      , copilot-libraries, copilot-prettyprinter, copilot-theorem
      , directory, filepath, optparse-applicative
      }:
      mkDerivation {
        pname = "copilot";
-       version = "4.2";
-       sha256 = "1gm4088qxlia57dc79rhzmshhzhm16rfrmv0xs94zcqz0qlxikpp";
+       version = "4.3";
+       sha256 = "09015r4fryyc60dzk5pvjpl8vjp9sm6bmykgixshkfrd6788xlad";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "copilot-bluespec";
-       version = "4.2";
-       sha256 = "0qr5b3cnxxs5wqiwzs08bz9yjhxnlsik4y7dnqpkx3k5i4rfy769";
+       version = "4.3";
+       sha256 = "1ybs2r8jllnb873l9aq2bq79y1spf2lj73i2ckkbiynqj33fzmih";
        libraryHaskellDepends = [
          base copilot-core directory filepath language-bluespec pretty
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "copilot-c99_4_2" = callPackage
+  "copilot-c99_4_3" = callPackage
     ({ mkDerivation, base, copilot-core, directory, filepath, HUnit
      , language-c99, language-c99-simple, mtl, pretty, process
      , QuickCheck, random, test-framework, test-framework-hunit
···
      }:
      mkDerivation {
        pname = "copilot-c99";
-       version = "4.2";
-       sha256 = "08bp830ggvnfxclpgmjwz2xmwpvbf47v9cm2mi9jjmwckm9k6n65";
+       version = "4.3";
+       sha256 = "1g7lnspbb0fkd6yhbv69an3q31ibr3a3pgvnsncsdasfbvz06hiy";
        libraryHaskellDepends = [
          base copilot-core directory filepath language-c99
          language-c99-simple mtl pretty
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "copilot-core_4_2" = callPackage
+  "copilot-core_4_3" = callPackage
     ({ mkDerivation, base, HUnit, QuickCheck, test-framework
      , test-framework-hunit, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "copilot-core";
-       version = "4.2";
-       sha256 = "0z980vpq27394q3iq5ijmsbi8dssihb5jamznsc86wnv51mh2d3g";
+       version = "4.3";
+       sha256 = "0m8ynx430wkh7vgpag6c2ayzcll73zmhj7r9gdss0vgr7w73wki3";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base HUnit QuickCheck test-framework test-framework-hunit
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "copilot-interpreter_4_2" = callPackage
+  "copilot-interpreter_4_3" = callPackage
     ({ mkDerivation, base, copilot-core, copilot-prettyprinter, pretty
      , QuickCheck, test-framework, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "copilot-interpreter";
-       version = "4.2";
-       sha256 = "06xi9lg5wnpwn1jl80k1122kglf6in5lc53sdi03m2pax87qa6qv";
+       version = "4.3";
+       sha256 = "15x06k5l06yfc173934nw5hqs0zhypr805kbkf9i1rvrzwz233k7";
        libraryHaskellDepends = [ base copilot-core pretty ];
        testHaskellDepends = [
          base copilot-core copilot-prettyprinter pretty QuickCheck
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "copilot-language_4_2" = callPackage
+  "copilot-language_4_3" = callPackage
     ({ mkDerivation, array, base, containers, copilot-core
      , copilot-interpreter, copilot-theorem, data-reify, HUnit, mtl
      , pretty, QuickCheck, test-framework, test-framework-hunit
···
      }:
      mkDerivation {
        pname = "copilot-language";
-       version = "4.2";
-       sha256 = "1gr7l3f8dvj9q0ssbsabmmk20zqvr8fsf8gka4rs5gsr2g73s12q";
+       version = "4.3";
+       sha256 = "1yzqm5kcy8by1smhaac3qw6y5kkbdkiimh41jj0q49n0k64hgs9y";
        libraryHaskellDepends = [
          array base containers copilot-core copilot-interpreter
          copilot-theorem data-reify mtl
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "copilot-libraries_4_2" = callPackage
+  "copilot-libraries_4_3" = callPackage
     ({ mkDerivation, base, containers, copilot-interpreter
      , copilot-language, copilot-theorem, mtl, parsec, QuickCheck
      , test-framework, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "copilot-libraries";
-       version = "4.2";
-       sha256 = "1cc8x14v72p9nmkvdfviz8brap6a87zajr8kxjs1in9xbfxm0a4w";
+       version = "4.3";
+       sha256 = "1yka76zqrxzbdv6ks35n0lhwi4ahcx7wj51cx0cwy9gar4608plm";
        libraryHaskellDepends = [
          base containers copilot-language mtl parsec
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "copilot-prettyprinter_4_2" = callPackage
+  "copilot-prettyprinter_4_3" = callPackage
     ({ mkDerivation, base, copilot-core, pretty }:
      mkDerivation {
        pname = "copilot-prettyprinter";
-       version = "4.2";
-       sha256 = "053g6p8afn35b803ysiyqr66ivjsyi7wn19yy6q0xf56753fwz9l";
+       version = "4.3";
+       sha256 = "0iynrm13cylmlmpzg9bdpx4nhsgl5ckz4ngzila9agfiijzs74f7";
        libraryHaskellDepends = [ base copilot-core pretty ];
        description = "A prettyprinter of Copilot Specifications";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "copilot-theorem_4_2" = callPackage
+  "copilot-theorem_4_3" = callPackage
     ({ mkDerivation, base, bimap, bv-sized, containers, copilot-core
-     , copilot-prettyprinter, data-default, directory, libBF, mtl, panic
-     , parameterized-utils, parsec, pretty, process, QuickCheck, random
-     , test-framework, test-framework-quickcheck2, transformers, what4
-     , xml
+     , copilot-prettyprinter, data-default, directory, HUnit, libBF, mtl
+     , panic, parameterized-utils, parsec, pretty, process, QuickCheck
+     , random, test-framework, test-framework-quickcheck2, transformers
+     , what4, xml
      }:
      mkDerivation {
        pname = "copilot-theorem";
-       version = "4.2";
-       sha256 = "0vf4xm0kj1bag5yksfrx0xj85zas06ajv552v0zk0y67spjfdwrl";
+       version = "4.3";
+       sha256 = "19kz53v5kj7z6jy8hxnm8mdy4xybimfrfq3xdbq0ynk8p47v18ry";
        libraryHaskellDepends = [
          base bimap bv-sized containers copilot-core copilot-prettyprinter
          data-default directory libBF mtl panic parameterized-utils parsec
          pretty process random transformers what4 xml
        ];
        testHaskellDepends = [
-         base copilot-core QuickCheck test-framework
+         base copilot-core HUnit QuickCheck test-framework
          test-framework-quickcheck2
        ];
        description = "k-induction for Copilot";
···
   "copilot-verifier" = callPackage
     ({ mkDerivation, aeson, base, bv-sized, bytestring
      , case-insensitive, containers, copilot, copilot-c99, copilot-core
-     , copilot-language, copilot-prettyprinter, copilot-theorem
-     , crucible, crucible-llvm, crux, crux-llvm, filepath, lens
-     , llvm-pretty, mtl, optparse-applicative, panic
+     , copilot-language, copilot-libraries, copilot-prettyprinter
+     , copilot-theorem, crucible, crucible-llvm, crux, crux-llvm
+     , filepath, lens, llvm-pretty, mtl, optparse-applicative, panic
      , parameterized-utils, prettyprinter, silently, tasty
      , tasty-expected-failure, tasty-hunit, text, transformers, vector
      , what4
      }:
      mkDerivation {
        pname = "copilot-verifier";
-       version = "4.2";
-       sha256 = "13zmv43wrj2aicjdmniq3jdfd2hnxzylf5iaz6mravz4jfjkb3l1";
+       version = "4.3";
+       sha256 = "0wxycssvs4qnih1jblypmk8hn1yj9pkhi4l2lamyda70sm7dv624";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson base bv-sized bytestring case-insensitive containers copilot
-         copilot-c99 copilot-core copilot-language copilot-prettyprinter
-         copilot-theorem crucible crucible-llvm crux crux-llvm filepath lens
-         llvm-pretty mtl panic parameterized-utils prettyprinter text
-         transformers vector what4
+         copilot-c99 copilot-core copilot-language copilot-libraries
+         copilot-prettyprinter copilot-theorem crucible crucible-llvm crux
+         crux-llvm filepath lens llvm-pretty mtl panic parameterized-utils
+         prettyprinter text transformers vector what4
        ];
        executableHaskellDepends = [
          aeson base bv-sized bytestring case-insensitive containers
···
        license = lib.licenses.mit;
      }) {};
 
+  "countdown-numbers-game" = callPackage
+    ({ mkDerivation, base, doctest-exitcode-stdio, doctest-lib
+     , non-empty, optparse-applicative, QuickCheck, utility-ht
+     }:
+     mkDerivation {
+       pname = "countdown-numbers-game";
+       version = "0.0.0.1";
+       sha256 = "1warpkqimxjvqrm1jq4nbj3g3bz009alklqs46dh23p3lrgcif61";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base non-empty optparse-applicative utility-ht
+       ];
+       testHaskellDepends = [
+         base doctest-exitcode-stdio doctest-lib non-empty QuickCheck
+         utility-ht
+       ];
+       description = "Solve problems from the number round of the Countdown game show";
+       license = lib.licenses.bsd3;
+       mainProgram = "countdown-numbers-solve";
+     }) {};
+
   "counter" = callPackage
     ({ mkDerivation, base, containers }:
      mkDerivation {
···
     ({ mkDerivation, attoparsec, base, bytestring, deepseq }:
      mkDerivation {
        pname = "cpuinfo";
-       version = "0.1.0.2";
-       sha256 = "0973bkgcfha0xyimizgq55w4a32gjgklcikfhcwkak4m9czwyynr";
+       version = "0.1.0.3";
+       sha256 = "0713nn1rz9mb9w6lykkdyrs09mi5kvd3mrxknsxz3rj6zv97vjfl";
        libraryHaskellDepends = [ attoparsec base bytestring deepseq ];
        description = "Haskell Library for Checking CPU Information";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "crucible";
-       version = "0.7.1";
-       sha256 = "1c9a8km88ngxghn35f6wnaddm534ixmz1iciyn0whl0xmp27f4zv";
-       revision = "1";
-       editedCabalFile = "1zixmd0qg2x4pg996safdpq3njrd9qafm9w1bh27j1pqbarl9m0i";
+       version = "0.7.2";
+       sha256 = "0wz9gsbqdgjsdg68rzi1gsc21bzfb34dx6hd9bdlbzkq4i1km0b3";
        libraryHaskellDepends = [
          async base bimap bv-sized containers exceptions fgl hashable json
          lens mtl panic parameterized-utils prettyprinter template-haskell
···
          what4
        ];
        testHaskellDepends = [
-         base containers hspec mtl panic parameterized-utils QuickCheck
+         base containers hspec lens mtl panic parameterized-utils QuickCheck
          tasty tasty-hspec tasty-hunit tasty-quickcheck what4
        ];
        description = "Crucible is a library for language-agnostic symbolic simulation";
        license = lib.licenses.bsd3;
      }) {};
 
+  "crucible-debug" = callPackage
+    ({ mkDerivation, base, bytestring, containers, crucible
+     , crucible-syntax, directory, filepath, isocline, lens, megaparsec
+     , mtl, parameterized-utils, prettyprinter, ring-buffer, tasty
+     , tasty-golden, text, vector, what4
+     }:
+     mkDerivation {
+       pname = "crucible-debug";
+       version = "0.1.0";
+       sha256 = "12xrvsj9asaq07diifi3adjy9524ma4zxsd8a9393fd1zi07693a";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers crucible crucible-syntax directory filepath
+         isocline lens megaparsec mtl parameterized-utils prettyprinter
+         ring-buffer text vector what4
+       ];
+       executableHaskellDepends = [ base text ];
+       testHaskellDepends = [
+         base bytestring directory prettyprinter tasty tasty-golden text
+       ];
+       description = "An interactive debugger for Crucible programs";
+       license = lib.licenses.bsd3;
+       mainProgram = "crucible-debug";
+     }) {};
+
   "crucible-llvm" = callPackage
     ({ mkDerivation, attoparsec, base, bv-sized, bytestring, containers
      , crucible, crucible-symio, directory, extra, filepath, itanium-abi
···
      }:
      mkDerivation {
        pname = "crucible-llvm";
-       version = "0.7";
-       sha256 = "0v4d3c971w6acka4s1lg9iai55ghk054hkkka5jbinyhhymmaf0k";
-       revision = "1";
-       editedCabalFile = "11h69y7s8smlrir6gvxijpg3k4laafznypw5786vsrkhvxr91mxk";
+       version = "0.7.1";
+       sha256 = "0q2ifjvdgbdvpj5092v9s4nhbkwmw8hghnslcx5ljrwfm8vmzxbs";
+       revision = "2";
+       editedCabalFile = "12k4r85w7864b4nbg03v2w0vhk8sgld55aqqckc5qz7d78q6lzkx";
        libraryHaskellDepends = [
          attoparsec base bv-sized bytestring containers crucible
          crucible-symio extra itanium-abi lens llvm-pretty mtl
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "crucible-syntax" = callPackage
+    ({ mkDerivation, base, bv-sized, containers, crucible, directory
+     , filepath, lens, megaparsec, mtl, parameterized-utils
+     , prettyprinter, tasty, tasty-golden, tasty-hunit, text
+     , transformers, vector, what4
+     }:
+     mkDerivation {
+       pname = "crucible-syntax";
+       version = "0.4.1";
+       sha256 = "0b60qh1hnz9q8diqnc4f9pvmkbgp1amg8gfk9zjk7mlkq4x9g9bh";
+       libraryHaskellDepends = [
+         base bv-sized containers crucible lens megaparsec mtl
+         parameterized-utils prettyprinter text transformers vector what4
+       ];
+       testHaskellDepends = [
+         base containers crucible directory filepath megaparsec
+         parameterized-utils tasty tasty-golden tasty-hunit text what4
+       ];
+       description = "A syntax for reading and writing Crucible control-flow graphs";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "cruncher-types" = callPackage
     ({ mkDerivation, aeson, base, containers, hlint, lens, text }:
      mkDerivation {
···
   "crux" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, async, attoparsec, base
      , bv-sized, bytestring, config-schema, config-value, containers
-     , contravariant, crucible, directory, filepath, generic-lens, Glob
-     , lens, libBF, lumberjack, parameterized-utils, prettyprinter
-     , raw-strings-qq, semigroupoids, simple-get-opt, split
-     , terminal-size, text, time, vector, what4, xml, yaml
+     , contravariant, crucible, crucible-debug, crucible-syntax
+     , directory, filepath, generic-lens, Glob, lens, libBF, lumberjack
+     , parameterized-utils, prettyprinter, raw-strings-qq, semigroupoids
+     , simple-get-opt, split, terminal-size, text, time, vector, what4
+     , xml, yaml
      }:
      mkDerivation {
        pname = "crux";
-       version = "0.7.1";
-       sha256 = "0l5nl9rv3kl07pwvj7dpw6njr6bh127ckallnlgkvp7c8l4cxgdy";
+       version = "0.7.2";
+       sha256 = "025nrsa3a1wl2ymw1q4pj77hgjn3nq33qhwnx05xykkqq7fyandh";
        libraryHaskellDepends = [
          aeson ansi-terminal async attoparsec base bv-sized bytestring
          config-schema config-value containers contravariant crucible
-         directory filepath generic-lens Glob lens libBF lumberjack
-         parameterized-utils prettyprinter raw-strings-qq semigroupoids
-         simple-get-opt split terminal-size text time vector what4 xml yaml
+         crucible-debug crucible-syntax directory filepath generic-lens Glob
+         lens libBF lumberjack parameterized-utils prettyprinter
+         raw-strings-qq semigroupoids simple-get-opt split terminal-size
+         text time vector what4 xml yaml
        ];
        description = "Simple top-level library for Crucible Simulation";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "crux-llvm";
-       version = "0.9";
-       sha256 = "0nrqaqs9l3kyj954swlln12b75xszcwrgwscc5n0r0pmi6sszrqj";
+       version = "0.10";
+       sha256 = "0648w3i2hpgkfqhcx3r7qsdgqak8295ik0g98jqs9s79dn7i8s4g";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
   "cryptol" = callPackage
     ({ mkDerivation, alex, ansi-terminal, arithmoi, array, async, base
      , base-compat, blaze-html, bv-sized, bytestring, containers
-     , criterion, criterion-measurement, cryptohash-sha1, deepseq
+     , criterion, criterion-measurement, cryptohash-sha256, deepseq
      , directory, exceptions, extra, file-embed, filepath, ghc-bignum
-     , ghc-prim, gitrev, GraphSCC, happy, haskeline, hgmp, language-c99
-     , language-c99-simple, libBF, libffi, MemoTrie, monad-control
-     , monadLib, mtl, optparse-applicative, panic, parameterized-utils
-     , pretty, pretty-show, prettyprinter, process, sbv, simple-smt, stm
-     , strict, temporary, text, tf-random, time, transformers
-     , transformers-base, unix, vector, what4
+     , ghc-prim, gitrev, GraphSCC, happy, haskeline, heredoc, hgmp
+     , language-c99, language-c99-simple, libBF, libffi, MemoTrie
+     , monad-control, monadLib, mtl, optparse-applicative, panic
+     , parameterized-utils, pretty, pretty-show, prettyprinter, process
+     , sbv, simple-smt, stm, strict, tasty, tasty-hunit, temporary, text
+     , tf-random, time, toml-parser, transformers, transformers-base
+     , unix, vector, what4
      }:
      mkDerivation {
        pname = "cryptol";
-       version = "3.2.0";
-       sha256 = "0nx25dfsnz1sd33kzicz9wqw4nsjv5s86s9w83mnh93xpmjqj1zd";
+       version = "3.3.0";
+       sha256 = "1c1pny7nj34wbph6yg2dmwbrflfrp7flzgjvmp2xdb1s7h4d38rv";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         arithmoi array async base base-compat bv-sized bytestring
-         containers criterion-measurement cryptohash-sha1 deepseq directory
-         exceptions file-embed filepath ghc-bignum ghc-prim gitrev GraphSCC
-         hgmp language-c99 language-c99-simple libBF libffi MemoTrie
-         monad-control monadLib mtl panic parameterized-utils pretty
-         pretty-show prettyprinter process sbv simple-smt stm strict text
-         tf-random time transformers-base unix vector what4
+         ansi-terminal arithmoi array async base base-compat bv-sized
+         bytestring containers criterion-measurement cryptohash-sha256
+         deepseq directory exceptions file-embed filepath ghc-bignum
+         ghc-prim gitrev GraphSCC haskeline heredoc hgmp language-c99
+         language-c99-simple libBF libffi MemoTrie monad-control monadLib
+         mtl panic parameterized-utils pretty pretty-show prettyprinter
+         process sbv simple-smt stm strict text tf-random time toml-parser
+         transformers transformers-base unix vector what4
        ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [
          ansi-terminal base base-compat blaze-html containers directory
-         exceptions extra filepath haskeline monad-control mtl
-         optparse-applicative process temporary text transformers
+         extra filepath mtl optparse-applicative process temporary text
        ];
+       testHaskellDepends = [ base haskeline tasty tasty-hunit ];
        benchmarkHaskellDepends = [
          base criterion deepseq directory filepath sbv text
        ];
+       doHaddock = false;
        description = "Cryptol: The Language of Cryptography";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "crypton_1_0_4" = callPackage
+    ({ mkDerivation, base, basement, bytestring, deepseq, gauge
+     , ghc-prim, integer-gmp, memory, random, tasty, tasty-hunit
+     , tasty-kat, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "crypton";
+       version = "1.0.4";
+       sha256 = "06h1qjvqd8gmiyzvh31sc061vcgns101l0774c44a8k44015925l";
+       libraryHaskellDepends = [
+         base basement bytestring deepseq ghc-prim integer-gmp memory
+       ];
+       testHaskellDepends = [
+         base bytestring memory tasty tasty-hunit tasty-kat tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring deepseq gauge memory random
+       ];
+       description = "Cryptography Primitives sink";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "crypton-box" = callPackage
     ({ mkDerivation, base, bytestring, crypton, hspec, hspec-discover
      , memory
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "crypton-connection_0_4_4" = callPackage
+    ({ mkDerivation, base, bytestring, containers, crypton-x509-store
+     , crypton-x509-system, data-default, network, socks, tls
+     }:
+     mkDerivation {
+       pname = "crypton-connection";
+       version = "0.4.4";
+       sha256 = "14d47klwmmf7zdm66161rbrbwy58qjzrkmd8mmkfrzm54b16hw14";
+       libraryHaskellDepends = [
+         base bytestring containers crypton-x509-store crypton-x509-system
+         data-default network socks tls
+       ];
+       description = "Simple and easy network connection API";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "crypton-x509" = callPackage
     ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base
      , bytestring, containers, crypton, hourglass, memory, mtl, pem
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "crypton-x509-store_1_6_10" = callPackage
+    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
+     , containers, crypton, crypton-x509, directory, filepath, mtl, pem
+     , tasty, tasty-hunit
+     }:
+     mkDerivation {
+       pname = "crypton-x509-store";
+       version = "1.6.10";
+       sha256 = "1c1q8bz42vcwxlij42zx9cgrmpp763q404g5hhws975d1lf67w6f";
+       libraryHaskellDepends = [
+         asn1-encoding asn1-types base bytestring containers crypton
+         crypton-x509 directory filepath mtl pem
+       ];
+       testHaskellDepends = [
+         base bytestring crypton-x509 tasty tasty-hunit
+       ];
+       description = "X.509 collection accessing and storing methods";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "crypton-x509-system" = callPackage
     ({ mkDerivation, base, bytestring, containers, crypton-x509
      , crypton-x509-store, directory, filepath, mtl, pem, process
···
        ];
        description = "X.509 Certificate and CRL validation";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "crypton-x509-validation_1_6_14" = callPackage
+    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
+     , containers, crypton, crypton-x509, crypton-x509-store
+     , data-default, hourglass, iproute, memory, mtl, pem, tasty
+     , tasty-hunit
+     }:
+     mkDerivation {
+       pname = "crypton-x509-validation";
+       version = "1.6.14";
+       sha256 = "07b09kgrd3m5ahxpj458r5ycd30bz8ldwjwf19mdcnfv4x0kj3pd";
+       libraryHaskellDepends = [
+         asn1-encoding asn1-types base bytestring containers crypton
+         crypton-x509 crypton-x509-store data-default hourglass iproute
+         memory mtl pem
+       ];
+       testHaskellDepends = [
+         asn1-encoding asn1-types base bytestring crypton crypton-x509
+         crypton-x509-store data-default hourglass memory tasty tasty-hunit
+       ];
+       description = "X.509 Certificate and CRL validation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "cryptonite" = callPackage
···
        mainProgram = "currycarbon";
      }) {};
 
+  "currycarbon_0_4_0_1" = callPackage
+    ({ mkDerivation, base, file-embed, filepath, hspec, hspec-core
+     , math-functions, MonadRandom, optparse-applicative, parsec
+     , process, random, vector
+     }:
+     mkDerivation {
+       pname = "currycarbon";
+       version = "0.4.0.1";
+       sha256 = "1qjgm413qxvr99zikd6jvc9znm163x2jr1spp32ig892hqbzcpdw";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base file-embed filepath math-functions MonadRandom parsec random
+         vector
+       ];
+       executableHaskellDepends = [ base filepath optparse-applicative ];
+       testHaskellDepends = [ base hspec hspec-core process ];
+       description = "A package for simple, fast radiocarbon calibration";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "currycarbon";
+     }) {};
+
   "curryer" = callPackage
     ({ mkDerivation, aeson, base, blaze-html, bytestring
      , case-insensitive, containers, cookie, http-types, mtl, regex-pcre
···
      }:
      mkDerivation {
        pname = "curryer-rpc";
-       version = "0.3.8";
-       sha256 = "1nr3x4qym270i1ddk69964b8c11k303ayhqspykrxkpsqf83hi0z";
+       version = "0.4.0";
+       sha256 = "0a0jlnwc58zj2lyk0flpqw3ccgiwd75mlwlkcad56ilfi7mgrwd0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "data-default_0_8_0_0" = callPackage
+  "data-default_0_8_0_1" = callPackage
     ({ mkDerivation, base, containers, mtl }:
      mkDerivation {
        pname = "data-default";
-       version = "0.8.0.0";
-       sha256 = "0cfxfbgsxxla1hr59rnm1cljb6i18rbp8yq7f0bfwvwpi4q0xwi3";
+       version = "0.8.0.1";
+       sha256 = "1jmn83y7ss7896xvykpxxp4kfmvxa65avw0asg0z15i1xkl5s26f";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers mtl ];
        description = "A class for types with a default value";
···
        pname = "data-elevator";
        version = "0.2";
        sha256 = "0fvj6bd86vdxmfwq36pcj810mbl3wc0lipw50ddzdcypsixr21gq";
+       revision = "1";
+       editedCabalFile = "1227s0fy6xg2z8awllig60csj824fw4wy3gky3vadpf1srwwq3lj";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec inspection-testing primitive ];
        description = "Coerce between unlifted boxed and lifted types";
···
        pname = "data-embed";
        version = "0.1.0.0";
        sha256 = "1pppd4w0sfb71i7ppqcp71rqx36b30g1dj468d2hb6fvnnhm830q";
-       revision = "2";
-       editedCabalFile = "0c51kfsyl7nzizx6awx8m0m4z2rjz8zn8ivl4869fgqdjkrmw8my";
+       revision = "3";
+       editedCabalFile = "1k3xib78x739y8dbazyspifnycfwwj94a252kd46vknw1xijsl8s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "data-findcycle" = callPackage
+    ({ mkDerivation, base, containers, deepseq, hashable, primes
+     , QuickCheck, tasty, tasty-bench, tasty-quickcheck
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "data-findcycle";
+       version = "0.1.0.0";
+       sha256 = "0l0ggmrb6czfy81qbdfm5iyi7mkipqgnrz26c6b38fahbrqflpa3";
+       libraryHaskellDepends = [
+         base containers hashable unordered-containers
+       ];
+       testHaskellDepends = [
+         base primes QuickCheck tasty tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [
+         base deepseq primes tasty tasty-bench
+       ];
+       description = "Find cycles in periodic functions (and lists)";
+       license = lib.licenses.mit;
+     }) {};
+
   "data-fix" = callPackage
     ({ mkDerivation, base, deepseq, hashable }:
      mkDerivation {
···
        pname = "data-interval";
        version = "2.1.2";
        sha256 = "01nr9g5phijlchbfc8h8rc1y54igzshnx5ld4fyls3kw8dsr03jf";
-       revision = "1";
-       editedCabalFile = "1b7l6nc2i4y34fmqr7qx8g154c0fh3cn1h47vy30736b25rfgfx3";
+       revision = "2";
+       editedCabalFile = "1797q6h0ihwhjz4hjxc6r8gmhr7z3dcwp0ypmzqhljisbykdxk4s";
        libraryHaskellDepends = [
          base containers deepseq extended-reals hashable lattices
        ];
···
        broken = true;
      }) {};
 
+  "data-prometheus" = callPackage
+    ({ mkDerivation, attoparsec, base, containers, hspec, mtl
+     , raw-strings-qq, text, transformers
+     }:
+     mkDerivation {
+       pname = "data-prometheus";
+       version = "0.1.0.0";
+       sha256 = "1zric3dwnxn5szi5lviih0w59djm2izaf2345ycmam7m87938gz1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         attoparsec base containers mtl text transformers
+       ];
+       testHaskellDepends = [
+         attoparsec base containers hspec raw-strings-qq
+       ];
+       description = "Prometheus metrics text format";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "data-quotientref" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "data-reify-gadt" = callPackage
+    ({ mkDerivation, base, containers, hashable, hspec
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "data-reify-gadt";
+       version = "0.1.0.0";
+       sha256 = "1fi9fsx1xvrd6lbh0zr21727clvv1j6ca62yq70z5fwsy4yx1gf2";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers hashable unordered-containers
+       ];
+       executableHaskellDepends = [
+         base containers hashable unordered-containers
+       ];
+       testHaskellDepends = [
+         base containers hashable hspec unordered-containers
+       ];
+       description = "Data.Reify for GADTs";
+       license = lib.licenses.bsd3;
+       mainProgram = "example-ast";
      }) {};
 
   "data-repr" = callPackage
···
        license = lib.licenses.asl20;
      }) {};
 
+  "dbus_1_4_0" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, conduit, containers
+     , deepseq, directory, exceptions, extra, filepath, lens, network
+     , parsec, process, QuickCheck, random, resourcet, split, tasty
+     , tasty-hunit, tasty-quickcheck, template-haskell, temporary, text
+     , th-lift, transformers, unix, vector, xml-conduit, xml-types
+     }:
+     mkDerivation {
+       pname = "dbus";
+       version = "1.4.0";
+       sha256 = "1rb5q8g0n3fj9b57wlds7ldji029fqym4dvpvq10hmn7qw313dz6";
+       libraryHaskellDepends = [
+         base bytestring cereal conduit containers deepseq exceptions
+         filepath lens network parsec random split template-haskell text
+         th-lift transformers unix vector xml-conduit xml-types
+       ];
+       testHaskellDepends = [
+         base bytestring cereal containers directory extra filepath network
+         parsec process QuickCheck random resourcet tasty tasty-hunit
+         tasty-quickcheck temporary text transformers unix vector
+       ];
+       doCheck = false;
+       description = "A client library for the D-Bus IPC system";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "dbus-app-launcher" = callPackage
     ({ mkDerivation, base, containers, dbus, extra, regex-tdfa
      , shellwords, unix
···
        broken = true;
      }) {debug-hoed = null;};
 
+  "debug-print" = callPackage
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+     , text, vector
+     }:
+     mkDerivation {
+       pname = "debug-print";
+       version = "0.1.0.0";
+       sha256 = "0920fwzv5lal5214g973yv73dyyg02aa9fdkddcv7bdq445as6m5";
+       libraryHaskellDepends = [ aeson base containers text vector ];
+       testHaskellDepends = [ aeson base hspec markdown-unlit text ];
+       testToolDepends = [ markdown-unlit ];
+       doHaddock = false;
+       description = "A structured alternative to Show";
+       license = lib.licenses.mit;
+     }) {};
+
   "debug-time" = callPackage
     ({ mkDerivation, base, clock, containers }:
      mkDerivation {
···
        mainProgram = "delta-h";
      }) {};
 
+  "delta-store" = callPackage
+    ({ mkDerivation, base, delta-types, hspec, hspec-discover
+     , io-classes, io-sim, QuickCheck, transformers
+     }:
+     mkDerivation {
+       pname = "delta-store";
+       version = "1.0.0.0";
+       sha256 = "1a04qp46zl3ja9g97qww8krhfygiwxf96kgxcyv6wvhf8caqw16q";
+       libraryHaskellDepends = [
+         base delta-types io-classes QuickCheck transformers
+       ];
+       testHaskellDepends = [
+         base delta-types hspec io-classes io-sim QuickCheck
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Facilities for storing a Haskell value, using delta types";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "delta-types" = callPackage
+    ({ mkDerivation, base, containers, hspec, hspec-discover
+     , QuickCheck, semigroupoids
+     }:
+     mkDerivation {
+       pname = "delta-types";
+       version = "1.0.0.0";
+       sha256 = "1v8bpg5r021xy93chs4ijyw470v8nh4prjq7qi76lz28f9jkpnqg";
+       libraryHaskellDepends = [ base containers semigroupoids ];
+       testHaskellDepends = [ base containers hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
+       description = "Delta types, also known as change actions";
+       license = lib.licenses.asl20;
+     }) {};
+
   "deltaq" = callPackage
     ({ mkDerivation, base, bytestring, cassava, Chart, criterion
      , deepseq, hspec, hspec-discover, hvega, lattices
···
        broken = true;
      }) {};
 
+  "derive-is-data-con" = callPackage
+    ({ mkDerivation, base, HUnit, template-haskell }:
+     mkDerivation {
+       pname = "derive-is-data-con";
+       version = "0.1.0.0";
+       sha256 = "0w8c86lwkdcmc9a7959042bs70hiacdf21kjjv2bcpmzfn4y3rwv";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base HUnit ];
+       description = "This package generates data constructor predicate functions";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "derive-lifted-instances" = callPackage
     ({ mkDerivation, base, bifunctors, reflection, template-haskell }:
      mkDerivation {
···
        pname = "deriving-compat";
        version = "0.6.7";
        sha256 = "1pzmqwjfd4j5bbcxl8xcgaxilmsfvcwak47rqkakn87n2c85zi6x";
+       revision = "1";
+       editedCabalFile = "0wmpl2falxhrksd8wf4p7amq5mlyawjpypysip4f1izcwq4vkvdl";
        libraryHaskellDepends = [
          base containers ghc-boot-th ghc-prim template-haskell
          th-abstraction transformers transformers-compat
···
     ({ mkDerivation, aeson, base, containers, QuickCheck, random }:
      mkDerivation {
        pname = "dhscanner-ast";
-       version = "0.1.0.5";
-       sha256 = "0fwglyb9179hvhnjbvds0gmhzd2ksvj13rp920n3x34y6m7c03wi";
+       version = "1.0.8";
+       sha256 = "0sgjlqrvdfqmma9cf1cs01mmj7gk66i3zwfjb1ywhs7l4kj4avn7";
        libraryHaskellDepends = [ aeson base containers ];
        testHaskellDepends = [ base QuickCheck random ];
        description = "abstract syntax tree for multiple programming languages";
···
      }:
      mkDerivation {
        pname = "dhscanner-bitcode";
-       version = "0.1.0.2";
-       sha256 = "1ixm87h6ycbzf7b6jzwivcnvw96xlm8gmcw032hk54z8c9szrx3d";
+       version = "1.0.4";
+       sha256 = "08jk89rn2g5aa57wwz7nsc38phdmg9wnkzxfsrk7l68rdbmxfl64";
        libraryHaskellDepends = [ aeson base containers dhscanner-ast ];
        testHaskellDepends = [
          base containers dhscanner-ast QuickCheck random
···
        pname = "diagrams-contrib";
        version = "1.4.6";
        sha256 = "1x5z361xmqfa503brmf0zwyq3lldm9kgixx90v14s4dsz52my46k";
+       revision = "1";
+       editedCabalFile = "00zgzy7b3vkjd0f22hbp2lknwl1x5nd6d1ng30wq4qlncwdxqkpz";
        libraryHaskellDepends = [
          base circle-packing colour containers cubicbezier data-default
          diagrams-core diagrams-lib diagrams-solve force-layout hashable
···
      }:
      mkDerivation {
        pname = "diagrams-pgf";
-       version = "1.4.2.1";
-       sha256 = "1778sjjvggq5ks73489y76f4z0cvzkn9ixn176fm8kf8swaf82ja";
-       revision = "2";
-       editedCabalFile = "1ri4jyw2cxcypcayp9w1wrv4ms2p28zjz80129x9f72mkf3ds6gk";
+       version = "1.5";
+       sha256 = "13zm00ayyk6gvlh4l2wdmrdqic386v69i3krylgvrajhdsd050al";
        libraryHaskellDepends = [
          base bytestring bytestring-builder colour containers diagrams-core
          diagrams-lib directory filepath hashable JuicyPixels mtl
···
        pname = "diagrams-postscript";
        version = "1.5.2";
        sha256 = "08kqhnd5r60kisjraypwjfcri1v4f32rf14js413871pgic4rhy5";
+       revision = "1";
+       editedCabalFile = "0ndvf9nhvgwvwnc0k9in3n83l3jif1nzsyyrmpk5plif590hj1zp";
        libraryHaskellDepends = [
          base bytestring containers data-default diagrams-core diagrams-lib
          hashable lens monoid-extras mtl semigroups split statestack
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "diagrams-rasterific_1_4_3" = callPackage
+  "diagrams-rasterific_1_5" = callPackage
     ({ mkDerivation, base, bytestring, containers, data-default
      , diagrams-core, diagrams-lib, file-embed, filepath, FontyFruity
      , hashable, JuicyPixels, lens, mtl, optparse-applicative
···
      }:
      mkDerivation {
        pname = "diagrams-rasterific";
-       version = "1.4.3";
-       sha256 = "1m7d9mjyydzb74vq1w3irazx334ygqvjhcql3akw62c9f6kckdq8";
+       version = "1.5";
+       sha256 = "02bq6819a8xxa20kggmg9j5wa72zh4gbcvbpv1b1pzbg57bp2s8k";
        libraryHaskellDepends = [
          base bytestring containers data-default diagrams-core diagrams-lib
          file-embed filepath FontyFruity hashable JuicyPixels lens mtl
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "diagrams-solve_0_1_3_1" = callPackage
+    ({ mkDerivation, base, deepseq, tasty, tasty-hunit
+     , tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "diagrams-solve";
+       version = "0.1.3.1";
+       sha256 = "19rymk08gh8bq7afa5p2hjj4747j0ardacbdvh205czfhirmdmga";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base deepseq tasty tasty-hunit tasty-quickcheck
+       ];
+       description = "Pure Haskell solver routines used by diagrams";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "diagrams-svg" = callPackage
     ({ mkDerivation, base, base64-bytestring, bytestring, colour
      , containers, diagrams-core, diagrams-lib, filepath, hashable
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "diagrams-svg_1_5" = callPackage
+    ({ mkDerivation, base, base64-bytestring, bytestring, colour
+     , containers, diagrams-core, diagrams-lib, filepath, hashable
+     , JuicyPixels, lens, monoid-extras, mtl, optparse-applicative
+     , semigroups, split, svg-builder, text
+     }:
+     mkDerivation {
+       pname = "diagrams-svg";
+       version = "1.5";
+       sha256 = "1g11fvcgx99xg71c9sd6m7pfclnzcfx72alcx3avlb4qzz56wn52";
+       libraryHaskellDepends = [
+         base base64-bytestring bytestring colour containers diagrams-core
+         diagrams-lib filepath hashable JuicyPixels lens monoid-extras mtl
+         optparse-applicative semigroups split svg-builder text
+       ];
+       description = "SVG backend for diagrams drawing EDSL";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "diagrams-tikz" = callPackage
     ({ mkDerivation, base, diagrams-core, diagrams-lib, dlist, mtl }:
      mkDerivation {
···
        license = lib.licenses.asl20;
      }) {};
 
-  "directory-ospath-streaming_0_2_1" = callPackage
+  "directory-ospath-streaming_0_2_2" = callPackage
     ({ mkDerivation, atomic-counter, base, deepseq, directory, filepath
      , os-string, random, tasty, tasty-hunit, unix
      }:
      mkDerivation {
        pname = "directory-ospath-streaming";
-       version = "0.2.1";
-       sha256 = "01jp33m4fq54v3yr95nigad99kznnh23hx3p1yxz6mj2b4q63ia5";
+       version = "0.2.2";
+       sha256 = "1xsfaps14pm68qfva4crqsmpqqcl8yjxrv514a6mxc9xw6z8zphs";
        libraryHaskellDepends = [
          atomic-counter base deepseq filepath os-string unix
        ];
···
 
   "discord-haskell-voice" = callPackage
     ({ mkDerivation, aeson, async, base, binary, BoundedChan
-     , bytestring, conduit, discord-haskell, microlens, microlens-th
-     , mtl, network, optparse-applicative, opus, process
+     , bytestring, conduit, conduit-extra, discord-haskell, microlens
+     , microlens-th, mtl, network, optparse-applicative, opus
      , safe-exceptions, saltine, stm, stm-containers, text, time
      , unliftio, websockets, wuss
      }:
      mkDerivation {
        pname = "discord-haskell-voice";
-       version = "2.3.1";
-       sha256 = "0j6gb0f63i70xqwq2yn8mfkn5nph3vmbbgnzid976cllcnwdxz5v";
+       version = "3.0.0";
+       sha256 = "0nac7m0szs0lajgg27h8hpx4q1m6v1nl6y3mzmz9aqhb1zwi0162";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson async base binary BoundedChan bytestring conduit
-         discord-haskell microlens microlens-th mtl network opus process
-         safe-exceptions saltine text time unliftio websockets wuss
+         conduit-extra discord-haskell microlens microlens-th mtl network
+         opus safe-exceptions saltine stm text time unliftio websockets wuss
        ];
        executableHaskellDepends = [
-         aeson async base binary BoundedChan bytestring conduit
-         discord-haskell microlens microlens-th mtl network
-         optparse-applicative opus process safe-exceptions saltine stm
-         stm-containers text time unliftio websockets wuss
+         base conduit discord-haskell optparse-applicative safe-exceptions
+         stm stm-containers text unliftio
        ];
        description = "Voice support for discord-haskell";
        license = lib.licenses.mit;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "distributors" = callPackage
+    ({ mkDerivation, adjunctions, base, bifunctors, bytestring
+     , containers, contravariant, distributive, hspec, lens, mtl
+     , profunctors, tagged, text, vector, witherable
+     }:
+     mkDerivation {
+       pname = "distributors";
+       version = "0.1.0.3";
+       sha256 = "1xisl64gmzmbgqqv3dnk1jdymq67zcxd4v7lx1fzxvxwr2z8ky5w";
+       libraryHaskellDepends = [
+         adjunctions base bifunctors bytestring containers contravariant
+         distributive lens mtl profunctors tagged text vector witherable
+       ];
+       testHaskellDepends = [
+         adjunctions base bifunctors bytestring containers contravariant
+         distributive hspec lens mtl profunctors tagged text vector
+         witherable
+       ];
+       description = "Unifying Parsers, Printers & Grammars";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "ditto" = callPackage
     ({ mkDerivation, base, containers, mtl, text }:
      mkDerivation {
···
     ({ mkDerivation, array, base, containers, haskeline, mtl, pretty }:
      mkDerivation {
        pname = "djinn";
-       version = "2014.9.7";
-       sha256 = "1p9dvzb83nlrq8h4brdq5l9dm2zf28rjhsmi7nwmac79p5pk9y2g";
+       version = "2025.2.21";
+       sha256 = "1r62y81ic1xphbbis25a8h8110n3wclgabdz8588wn8jb4322pi1";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        mainProgram = "dl-fedora";
      }) {};
 
+  "dl-fedora_2_0_1" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, base, bytestring, directory, extra
+     , fedora-releases, filepath, http-client, http-client-tls
+     , http-directory, http-types, optparse-applicative, pretty-terminal
+     , regex-posix, simple-cmd, simple-cmd-args, simple-prompt, text
+     , time, unix, xdg-userdirs
+     }:
+     mkDerivation {
+       pname = "dl-fedora";
+       version = "2.0.1";
+       sha256 = "18ga0lq0rhdr7g5v6svfhln3g0a2lrwp2fbzaa2mgl8h9rc2n57f";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         ansi-wl-pprint base bytestring directory extra fedora-releases
+         filepath http-client http-client-tls http-directory http-types
+         optparse-applicative pretty-terminal regex-posix simple-cmd
+         simple-cmd-args simple-prompt text time unix xdg-userdirs
+       ];
+       testHaskellDepends = [ base fedora-releases simple-cmd ];
+       description = "Fedora image download tool";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "dl-fedora";
+     }) {};
+
   "dlist" = callPackage
     ({ mkDerivation, base, deepseq, QuickCheck }:
      mkDerivation {
···
   "dobutokO2" = callPackage
     ({ mkDerivation, aftovolio, base, bytestring, directory, end-of-exe
      , mmsyn2-array, mmsyn7l, mmsyn7ukr-array, mmsyn7ukr-common, process
-     , vector
+     , quantizer, vector
      }:
      mkDerivation {
        pname = "dobutokO2";
-       version = "0.44.1.0";
-       sha256 = "1ggk53mzi1dmgr5yijsz9hbnaqjxbajzksbpvrpfb5d8s5mnw77p";
+       version = "0.45.2.0";
+       sha256 = "19b9nyl2xhl0ha5imz0h7n5szydbvvv9gn4ji7ycb9xazq2h6jjk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aftovolio base bytestring directory end-of-exe mmsyn2-array mmsyn7l
-         mmsyn7ukr-array mmsyn7ukr-common process vector
+         mmsyn7ukr-array mmsyn7ukr-common process quantizer vector
        ];
        executableHaskellDepends = [
          aftovolio base bytestring directory end-of-exe mmsyn2-array mmsyn7l
-         mmsyn7ukr-array mmsyn7ukr-common process vector
+         mmsyn7ukr-array mmsyn7ukr-common process quantizer vector
        ];
        description = "Helps to create experimental music from a file (or its part) and a Ukrainian text";
        license = lib.licenses.mit;
···
        pname = "docopt";
        version = "0.7.0.8";
        sha256 = "0pcixlpa5cwf531aa5nmwvp50gagm2khwl1xsy8hi4jn7ksnk1y8";
-       revision = "1";
-       editedCabalFile = "13p8gyib0w3hhbqaijbm0jajnc7cp0bnd23wih2apg9a6aalwsnr";
+       revision = "2";
+       editedCabalFile = "07vr5q9nn81ilklzg22n3s4fswgd596d459r8jbd4ca2w2a1s76v";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base containers parsec template-haskell
···
        mainProgram = "doctest";
      }) {};
 
-  "doctest_0_23_0" = callPackage
+  "doctest_0_24_0" = callPackage
     ({ mkDerivation, base, code-page, containers, deepseq, directory
      , exceptions, filepath, ghc, ghc-paths, hspec, hspec-core
      , hspec-discover, HUnit, mockery, process, QuickCheck, silently
···
      }:
      mkDerivation {
        pname = "doctest";
-       version = "0.23.0";
-       sha256 = "1jh38pj6rbsli4ba6jvnrg9dm2di18i7g9706nnfm0xc9ckhfs90";
-       revision = "1";
-       editedCabalFile = "1n9y3j4z15jf8xfi8v8pjd33b1z2csswzslqqpaa1cwazgv6f342";
+       version = "0.24.0";
+       sha256 = "1cylb84kmlw7a38xnfyx0sxcpgahmfm7bsbv0vf2x3slsgz597kx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "dunai";
-       version = "0.14.0";
-       sha256 = "1iss2iq5wbys06vnwzd37frhcqlhva1b6krac4wbc7l5b0dirvr3";
+       version = "0.14.1";
+       sha256 = "0smrrb5jqd1b0365wbjx0hjbsf76hqvx31vgpak94n5kc5fj6p3a";
        libraryHaskellDepends = [
          base list-transformer MonadRandom simple-affine-space transformers
          transformers-base
···
     ({ mkDerivation, base, dunai, normaldistribution, QuickCheck }:
      mkDerivation {
        pname = "dunai-test";
-       version = "0.14.0";
-       sha256 = "1z4gyjhvlcky9gg7az01i955c585qh15w4bm74l9r8zjd67b8xyc";
+       version = "0.14.1";
+       sha256 = "1802lrmxd11fjw0gwllrzchfqxdxkfgqy30vfdpx45krgvkf58qy";
        libraryHaskellDepends = [
          base dunai normaldistribution QuickCheck
        ];
···
     ({ mkDerivation, base, pretty }:
      mkDerivation {
        pname = "dwergaz";
-       version = "0.3.0.1";
-       sha256 = "1l2a52gg8z5appajr9p2pci66vrj6zlm90s079xklbhig2fgckmb";
+       version = "0.3.0.2";
+       sha256 = "0849adznjgfg4z1llq5kfwi3ypjj9bj1jw7anax6g86izzvs75jj";
        libraryHaskellDepends = [ base pretty ];
        testHaskellDepends = [ base ];
        description = "A minimal testing library";
···
        license = lib.licenses.gpl2Only;
      }) {};
 
+  "dynamic-state_0_3_2" = callPackage
+    ({ mkDerivation, base, binary, bytestring, hashable
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "dynamic-state";
+       version = "0.3.2";
+       sha256 = "1nwdiwi5v96p8jbifj9qz6cm65sz977pq3bznm4kd7mlqp2sglfr";
+       libraryHaskellDepends = [
+         base binary bytestring hashable unordered-containers
+       ];
+       description = "Optionally serializable dynamic state keyed by type";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "dynamodb-simple" = callPackage
     ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-dynamodb
      , base, bytestring, conduit, containers, double-conversion
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "ech-config" = callPackage
+    ({ mkDerivation, base, base16-bytestring, bytestring, filepath
+     , network-byte-order
+     }:
+     mkDerivation {
+       pname = "ech-config";
+       version = "0.0.1";
+       sha256 = "1fpynisvv87m0rfdydbvrg4k3nznv33yslb0ny0c518kxbbvcdmj";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base base16-bytestring bytestring filepath network-byte-order
+       ];
+       description = "Config for TLS Encrypted Client Hello";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "echo" = callPackage
     ({ mkDerivation, base, process }:
      mkDerivation {
···
        pname = "ed25519";
        version = "0.0.5.0";
        sha256 = "0v8msqvgzimhs7p5ri25hrb1ni2wvisl5rmdxy89fc59py79b9fq";
-       revision = "8";
-       editedCabalFile = "0x8wx1mp6lf9cgz0p326m76p181r14fyxwwq8iicrx8sha4kff28";
+       revision = "9";
+       editedCabalFile = "0y5vfdcys18waa5k5zxiq9n8jq0l05j76riml23i0gxmwgdhsmgi";
        libraryHaskellDepends = [ base bytestring ghc-prim ];
        testHaskellDepends = [
          base bytestring directory doctest filepath hlint QuickCheck
···
      }:
      mkDerivation {
        pname = "effectful-zoo";
-       version = "0.0.4.1";
-       sha256 = "1psp867hyy2yr1wyq48fzpw4zhkp874zzpbv99msr21db4v9dram";
-       revision = "1";
-       editedCabalFile = "112kgb5zddvhdar0n8xdg252zr19fpql3vbmqsgg9nlr6l9rpnxs";
+       version = "0.0.5.0";
+       sha256 = "09qscfnbv1vfgj0f7nfscahqc36q5pr2x6fxar9mivh4zfpwi6cs";
        isLibrary = false;
        isExecutable = false;
        libraryHaskellDepends = [
···
        pname = "ekg-core";
        version = "0.1.1.8";
        sha256 = "028c3g1fz0rfxpfn98wxxmklnxx3szwvjxl9n9ls2w011vqslvia";
+       revision = "1";
+       editedCabalFile = "1lwss6aha8bjmjb3xji58jznca7k7nss76qva5pihgb20j7xs7vi";
        libraryHaskellDepends = [
          base containers text unordered-containers
        ];
···
        pname = "ekg-json";
        version = "0.1.1.1";
        sha256 = "1mngxy3zhrgfpzi060l4v6x65la7vplbd5z04cvna2m759cn5q2i";
+       revision = "1";
+       editedCabalFile = "1ibdws48pirdl8asvizylz9vnz3yrfkqsximxsmb7ivbbindd75x";
        libraryHaskellDepends = [
          aeson base ekg-core text unordered-containers
        ];
···
      }:
      mkDerivation {
        pname = "erebos";
-       version = "0.1.7";
-       sha256 = "0kcvnh3car18qj9hgg3j85b4fir2zy7i4dp3qbfck32qddf5i1z7";
+       version = "0.1.8.1";
+       sha256 = "04lw5xr1nxra0i6m6882rhv06lm892rvhaczacbhynrhnblq96dm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {libpjproject = null;};
 
   "erebos-tester" = callPackage
-    ({ mkDerivation, base, bytestring, containers, directory, filepath
-     , Glob, haskeline, HsYAML, linux-namespaces, megaparsec, mtl
+    ({ mkDerivation, base, bytestring, clock, containers, directory
+     , filepath, Glob, haskeline, HsYAML, megaparsec, mtl
      , parser-combinators, process, regex-tdfa, scientific, stm
      , template-haskell, text, th-compat, unix
      }:
      mkDerivation {
        pname = "erebos-tester";
-       version = "0.2.4";
-       sha256 = "1nfhkwva75qwrhmrhccvy52ga0fxig7ddqhgnl0cpcsll3hfkmdn";
+       version = "0.3.1";
+       sha256 = "1qwhxhd8ihk20gwddfj3cj9ag8s9kaj3i5aynjbccx7s24chwmfv";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base bytestring containers directory filepath Glob haskeline HsYAML
-         linux-namespaces megaparsec mtl parser-combinators process
-         regex-tdfa scientific stm template-haskell text th-compat unix
+         base bytestring clock containers directory filepath Glob haskeline
+         HsYAML megaparsec mtl parser-combinators process regex-tdfa
+         scientific stm template-haskell text th-compat unix
        ];
        description = "Test framework with virtual network using Linux namespaces";
        license = lib.licenses.gpl3Only;
        platforms = lib.platforms.linux;
+       mainProgram = "erebos-tester";
      }) {};
 
   "erf" = callPackage
···
        mainProgram = "eros-http";
      }) {};
 
+  "erpnext-api-client" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, http-client, http-types
+     , network-uri, text, time
+     }:
+     mkDerivation {
+       pname = "erpnext-api-client";
+       version = "0.1.0.1";
+       sha256 = "01p08sgjpxmg9zq4953m09csg2qy28kp6ffpv042cn5djcdmb1ls";
+       libraryHaskellDepends = [
+         aeson base bytestring http-client http-types network-uri text time
+       ];
+       description = "Generic API client library for ERPNext";
+       license = lib.licenses.mit;
+     }) {};
+
   "errata" = callPackage
     ({ mkDerivation, base, containers, hspec, hspec-discover
      , hspec-golden, text
···
        pname = "ersatz";
        version = "0.5";
        sha256 = "1fzaany3mzzmizfzdglwqni3q842ip5z86apgdla2ynhq0hlmh3m";
-       revision = "2";
-       editedCabalFile = "0z56cmxs98iw15nmq2ajw57w4p8zrwz7kcgqsr27716rkpnspy4f";
+       revision = "3";
+       editedCabalFile = "11sbymicw1npij9fzrzkn1h47si9bv9nknjvqwny074vnryxy4bq";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "ersatz-toysat";
        version = "0.2.2.0";
        sha256 = "056yyls1mhl20sbngk43lip9gi092c1da0snx6fcs0vbv8gm0j4v";
-       revision = "2";
-       editedCabalFile = "0ijzzn2bis2kgxf3cnnqkxrfh3n5pw5jp29548dac9ayfk8iwvvh";
+       revision = "3";
+       editedCabalFile = "0spla3iw8ffias5vnh368ivmq1aalk11ynpngppsccsfi21rbrwv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Espial is an open-source, web-based bookmarking server";
        license = lib.licenses.agpl3Only;
-       maintainers = [ lib.maintainers.dalpd ];
      }) {};
 
   "esqueleto" = callPackage
···
        pname = "esqueleto";
        version = "3.6.0.0";
        sha256 = "1x7bd4l7ax6d47mhkbfdqsfjay0qn362is393cnbbm0395v2ijlh";
+       revision = "1";
+       editedCabalFile = "1xfigma6ha5rhll6cg05iz6lzh88w3pgniarib7fzvi6rxyg3a17";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-html bytestring conduit containers
          monad-logger persistent resourcet tagged template-haskell text time
···
      }:
      mkDerivation {
        pname = "evdev";
-       version = "2.3.1.1";
-       sha256 = "1jq7ayi4rv8v02wyxva9776iqymv0ac1h7jbfxf96gmk5ifwyinf";
-       revision = "1";
-       editedCabalFile = "05v90azm7rfmzbcbm2rmbl20977nk1m41m0l8sryf64zk6sxpw3n";
+       version = "2.3.1.2";
+       sha256 = "1v8gs1sfyrll4yc1qrv2gnv36plhaflxy8h8qhlmqj5kwbipi83x";
        libraryHaskellDepends = [
          base bytestring containers extra filepath-bytestring monad-loops
          mtl rawfilepath time unix
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "exception-hierarchy_0_1_0_13" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "exception-hierarchy";
+       version = "0.1.0.13";
+       sha256 = "18pbkp82d6mlndx06b7sxwcacp41c342cqljmp2iksa05kwrdzny";
+       libraryHaskellDepends = [ base template-haskell ];
+       description = "Exception type hierarchy with TemplateHaskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "exception-mailer" = callPackage
     ({ mkDerivation, base, hslogger, mime-mail, text }:
      mkDerivation {
···
        license = "BSD-2-Clause-Patent";
      }) {};
 
+  "exon_1_7_2_0" = callPackage
+    ({ mkDerivation, base, criterion, ghc, hedgehog, incipit-base
+     , parsec, tasty, tasty-hedgehog, template-haskell
+     }:
+     mkDerivation {
+       pname = "exon";
+       version = "1.7.2.0";
+       sha256 = "120cd6n7sqpakyk91izjblk92vc9bzr1a3bcskzkpky512mw47wm";
+       libraryHaskellDepends = [
+         base ghc incipit-base parsec template-haskell
+       ];
+       testHaskellDepends = [
+         base hedgehog incipit-base tasty tasty-hedgehog template-haskell
+       ];
+       benchmarkHaskellDepends = [ base criterion incipit-base ];
+       description = "Customizable quasiquote interpolation";
+       license = "BSD-2-Clause-Patent";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "exotic-list-monads" = callPackage
     ({ mkDerivation, base, hspec, hspec-core, hspec-discover
      , QuickCheck
···
        pname = "exp-pairs";
        version = "0.2.1.1";
        sha256 = "01n730xafan7yf11bzsp40vi30an7risyxvnp16hzjxwlg6xlkpi";
+       revision = "1";
+       editedCabalFile = "0zxnd6v1wmr7i09kwllrd2y822diclkhwma8rqfjlkhkldalkwcr";
        libraryHaskellDepends = [
          base containers deepseq ghc-prim prettyprinter
        ];
···
      }:
      mkDerivation {
        pname = "exploring-interpreters";
-       version = "1.5.0.1";
-       sha256 = "11n58j4i432z9y2glyii178safnbr2ij1dpp8x6c0nh3sigclnzg";
+       version = "1.6.0.0";
+       sha256 = "1mnfqmzbnaii24xdqvhpbnfn3fv380jx75iqm7dw8qxjc46xf4iz";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers exceptions fgl
          haskeline http-types mtl network scientific text transformers
···
        ];
        description = "Extension of real numbers with positive/negative infinities";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "extended-reals_0_2_6_0" = callPackage
+    ({ mkDerivation, base, deepseq, hashable, HUnit, QuickCheck, tasty
+     , tasty-hunit, tasty-quickcheck, tasty-th, template-haskell
+     }:
+     mkDerivation {
+       pname = "extended-reals";
+       version = "0.2.6.0";
+       sha256 = "0cy5fb6b9kidxqadpymy0pqvswlsqxwxqqhfx9di1l66ynks2b6z";
+       libraryHaskellDepends = [ base deepseq hashable template-haskell ];
+       testHaskellDepends = [
+         base deepseq HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
+         tasty-th
+       ];
+       description = "Extension of real numbers with positive/negative infinities";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "extensible" = callPackage
···
        ];
        description = "A fun falling blocks game";
        license = "GPL";
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "fallingblocks";
      }) {};
 
···
        pname = "falsify";
        version = "0.2.0";
        sha256 = "1fhj70q6kfd98892gxfy3mc8wxxyr80g4rzapaici4zd3zczz2fd";
-       revision = "4";
-       editedCabalFile = "125c2jsl085kd0i4pdxkawpx43jlgn18xqf86r97f1ax15142p5g";
+       revision = "5";
+       editedCabalFile = "08559x5pnw0g756jx30myxl974rhjxwv7v0yywnwkcqlbq0ir64r";
        libraryHaskellDepends = [
          base base16-bytestring binary bytestring containers data-default
          mtl optics-core optparse-applicative selective sop-core splitmix
···
        ];
        description = "Fast ByteString Builder";
        license = lib.licenses.publicDomain;
+     }) {};
+
+  "fast-builder_0_1_5_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, criterion
+     , deepseq, ghc-prim, process, QuickCheck, scientific, stm, text
+     , vector
+     }:
+     mkDerivation {
+       pname = "fast-builder";
+       version = "0.1.5.0";
+       sha256 = "0whb8g2dg27zcy757zbrlbq1bi3gn0235ana12s6wnx0clixvg56";
+       libraryHaskellDepends = [ base bytestring ghc-prim ];
+       testHaskellDepends = [ base bytestring process QuickCheck stm ];
+       benchmarkHaskellDepends = [
+         aeson base bytestring containers criterion deepseq ghc-prim
+         scientific text vector
+       ];
+       description = "Fast ByteString Builder";
+       license = lib.licenses.publicDomain;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fast-combinatorics" = callPackage
···
   "fbrnch" = callPackage
     ({ mkDerivation, aeson, async, base, bodhi, bugzilla-redhat
      , bytestring, config-ini, copr-api, directory, either
-     , email-validate, extra, fedora-releases, filepath, http-conduit
-     , http-directory, http-query, koji, network-uri, pagure
-     , pretty-terminal, process, rpm-nvr, rpmbuild-order, safe, say
-     , select-rpms, simple-cmd, simple-cmd-args, simple-prompt, text
-     , time, typed-process, unix, utf8-string, xdg-basedir
+     , email-validate, extra, fedora-krb, fedora-releases, filepath
+     , http-conduit, http-directory, http-query, koji, network-uri
+     , pagure, pretty-terminal, process, rpm-nvr, rpmbuild-order, safe
+     , say, select-rpms, simple-cmd, simple-cmd-args, simple-prompt
+     , text, time, typed-process, unix, utf8-string, xdg-basedir
      }:
      mkDerivation {
        pname = "fbrnch";
-       version = "1.6.1";
-       sha256 = "1hixxzx1f9x5mj84220mc9hf94lpyq42qp00s3yry79kaiwwh7cz";
+       version = "1.6.2";
+       sha256 = "0yqpxma3qgdkacbabaffz0498phl79yvn2pbhn10gb6f18lzxcsf";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          aeson async base bodhi bugzilla-redhat bytestring config-ini
-         copr-api directory either email-validate extra fedora-releases
-         filepath http-conduit http-directory http-query koji network-uri
-         pagure pretty-terminal process rpm-nvr rpmbuild-order safe say
-         select-rpms simple-cmd simple-cmd-args simple-prompt text time
-         typed-process unix utf8-string xdg-basedir
+         copr-api directory either email-validate extra fedora-krb
+         fedora-releases filepath http-conduit http-directory http-query
+         koji network-uri pagure pretty-terminal process rpm-nvr
+         rpmbuild-order safe say select-rpms simple-cmd simple-cmd-args
+         simple-prompt text time typed-process unix utf8-string xdg-basedir
        ];
        description = "Fedora packager tool to build package branches";
        license = lib.licenses.gpl2Only;
···
        license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "fedora-img-dl";
+     }) {};
+
+  "fedora-krb" = callPackage
+    ({ mkDerivation, base, simple-cmd }:
+     mkDerivation {
+       pname = "fedora-krb";
+       version = "0.1.0";
+       sha256 = "1jwj1hik5fpj0f5ni4zz2ic3kq0hha4yjq9rb4yw7gspmyfkh40i";
+       libraryHaskellDepends = [ base simple-cmd ];
+       description = "Kerberos for Fedora packagers";
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "fedora-packages" = callPackage
···
      }:
      mkDerivation {
        pname = "fix-imports";
-       version = "2.4.0";
-       sha256 = "0c1qa217wkw0xhgzn57l2brr87fg971vfzk49ls4m6kgyfin8dgx";
+       version = "2.5.0";
+       sha256 = "00iqi20qs1zyd68r10gk0pki3rvs2zbjqi073hnr4baahdajh5kb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "flatbuffers-builder" = callPackage
+    ({ mkDerivation, array-builder, base, base16-bytestring, byte-order
+     , bytebuild, byteslice, bytesmith, bytestring, containers
+     , contiguous, primitive, run-st, tasty, tasty-golden, text
+     }:
+     mkDerivation {
+       pname = "flatbuffers-builder";
+       version = "1.0.0.0";
+       sha256 = "0casldhrsqs8fgsf4b78g934z1g8f4n1dzwiv6ls2nhccj5azgi5";
+       revision = "1";
+       editedCabalFile = "1pz1k12k1cw7v2yx1vmi72wa37b589ihv00h7ylpj4n0ss77ck12";
+       libraryHaskellDepends = [
+         array-builder base byte-order byteslice containers contiguous
+         primitive run-st text
+       ];
+       testHaskellDepends = [
+         array-builder base base16-bytestring bytebuild byteslice bytesmith
+         bytestring primitive tasty tasty-golden text
+       ];
+       description = "Flatbuffers encoding based on a syntax tree";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "flatbuffers-parser" = callPackage
+    ({ mkDerivation, array-builder, base, base16-bytestring, byte-order
+     , bytebuild, byteslice, bytesmith, bytestring, contiguous
+     , primitive, text, transformers
+     }:
+     mkDerivation {
+       pname = "flatbuffers-parser";
+       version = "0.1.1.0";
+       sha256 = "08f775sr7hghh5plgh4fvwq408w9d9m7hd5bck7nzfxy0n7l2sij";
+       libraryHaskellDepends = [
+         base byte-order byteslice contiguous primitive text transformers
+       ];
+       testHaskellDepends = [
+         array-builder base base16-bytestring bytebuild byteslice bytesmith
+         bytestring primitive text
+       ];
+       description = "Parse flatbuffers";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "flatparse" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, containers, gauge
      , hspec, HUnit, integer-gmp, megaparsec, parsec, primitive
···
        testHaskellDepends = [ base HUnit ];
        description = "Write more understandable Haskell";
        license = lib.licenses.mit;
+     }) {};
+
+  "flow_2_0_0_7" = callPackage
+    ({ mkDerivation, base, HUnit }:
+     mkDerivation {
+       pname = "flow";
+       version = "2.0.0.7";
+       sha256 = "18v7vlcc3na743i6755zk7qjqqvaxnd1lb68fci1z3wzyjxjcxml";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base HUnit ];
+       description = "Write more understandable Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "flow-er" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "fold-debounce_0_2_0_16" = callPackage
+    ({ mkDerivation, base, data-default, hspec, hspec-discover, stm
+     , stm-delay, time
+     }:
+     mkDerivation {
+       pname = "fold-debounce";
+       version = "0.2.0.16";
+       sha256 = "0clc38mv6ss1js1b4lpyzx0z50f1hk2zl7ccx52yznid2a3ndw7p";
+       libraryHaskellDepends = [ base data-default stm stm-delay time ];
+       testHaskellDepends = [ base hspec stm time ];
+       testToolDepends = [ hspec-discover ];
+       description = "Fold multiple events that happen in a given period of time";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "fold-debounce-conduit" = callPackage
     ({ mkDerivation, base, conduit, fold-debounce, hspec
      , hspec-discover, resourcet, stm, transformers, transformers-base
      }:
      mkDerivation {
        pname = "fold-debounce-conduit";
-       version = "0.2.0.7";
-       sha256 = "02a3kxk4b3725h4dbnfvc1va4h7l4mxg3aaf3jacq9vmn1zwl4n5";
+       version = "0.2.0.8";
+       sha256 = "17zyg28rhjlns7hs2yllhgc0c7srx2bajmwpx4d9anmkl0qi26dk";
        libraryHaskellDepends = [
          base conduit fold-debounce resourcet stm transformers
          transformers-base
···
        pname = "foldable1-classes-compat";
        version = "0.1.1";
        sha256 = "17xmc3525crnd86rrl2c50rfnhibwh5xbqrnmvzvyns4d3l4vvdg";
-       revision = "1";
-       editedCabalFile = "1yd6ksym0jxhagyps93w1dlw9rrfsnps96m44md5n90z0qzalnm7";
+       revision = "2";
+       editedCabalFile = "0m1cd2g2f2983nb9h4d3amq058k2yri6hbh5v026y5lxhg9fq0i8";
        libraryHaskellDepends = [ base ghc-prim tagged ];
        testHaskellDepends = [
          base containers QuickCheck quickcheck-instances test-framework
···
        pname = "force-layout";
        version = "0.4.1";
        sha256 = "0mas3v19mhzcb4rdn6033rmnbw36y3yw240q2cbpr6z4rfk1wxqq";
-       revision = "1";
-       editedCabalFile = "1m4s2my32pjy8mykw46iz1w0nj3b5hhl3gnd4v0j2ch82hcll5rj";
+       revision = "2";
+       editedCabalFile = "0xf34wk0w5i7y7hzsdvyijf3cr1clbr82a2hi024dk7sp8i5gwnp";
        libraryHaskellDepends = [
          base containers data-default lens linear
        ];
···
        pname = "formattable";
        version = "0.1.1";
        sha256 = "0brp1j21ll6g266zyzknqc20k5nf3na97fjbh66hjbsw6yxah5x7";
+       revision = "1";
+       editedCabalFile = "060j0pmz5p3if22675wxp2d30d1cqy3gbs38klnrsq6mfz50yb04";
        libraryHaskellDepends = [
          base bytestring data-default-class old-locale text time
        ];
···
        broken = true;
      }) {};
 
+  "fractaltext" = callPackage
+    ({ mkDerivation, base, containers, directory, filepath, free
+     , generic-data, hedgehog, json, microlens-platform, streaming
+     , tasty, tasty-discover, tasty-hedgehog, tasty-hunit, text
+     , text-short, transformers, vector
+     }:
+     mkDerivation {
+       pname = "fractaltext";
+       version = "0.1.0";
+       sha256 = "11wcldm5m54yxxiranghd7rw03mvqwg3zk5jn6n5cipc1r0rvlb0";
+       libraryHaskellDepends = [
+         base containers free generic-data microlens-platform streaming text
+         text-short transformers vector
+       ];
+       testHaskellDepends = [
+         base containers directory filepath hedgehog json microlens-platform
+         streaming tasty tasty-hedgehog tasty-hunit text text-short vector
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Reference implementation of FractalText";
+       license = lib.licenses.asl20;
+     }) {};
+
   "fraction" = callPackage
     ({ mkDerivation, base, semigroups }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "freckle-app";
-       version = "1.23.0.0";
-       sha256 = "1a4kk6fix4634npx9lcjw5b47nqg5y4s7l4rz76bzmq819f7a2k2";
+       version = "1.23.0.1";
+       sha256 = "0vpi7kps9xndc1h6wnklpf1k2qaqxx4301pwa9l03ln97l0zkpvr";
        libraryHaskellDepends = [
          aeson annotated-exception autodocodec autodocodec-openapi3 base
          bcp47 Blammo Blammo-wai bugsnag bytestring case-insensitive cassava
···
        pname = "free";
        version = "5.2";
        sha256 = "12agp68cwwixcwfwnvk2xamg34a2x6ax7s1naxv66chpi5y7z1kj";
-       revision = "6";
-       editedCabalFile = "1n8yx64gffqiqkkmn67bfhnfafgf1c10m9mm7yb8b5fiv21kx5hj";
+       revision = "7";
+       editedCabalFile = "0h43xp4f38bpxhs5s06x1jw6d6zv55hhyhj6cmdbmfw7d6k94fbz";
        libraryHaskellDepends = [
          base comonad containers distributive exceptions indexed-traversable
          mtl profunctors semigroupoids template-haskell th-abstraction
···
        pname = "fs-api";
        version = "0.3.0.1";
        sha256 = "0yjfldwmxqg4fgcymyb9bb9axwsfsnldnxxfmk54spkmiab8kr49";
+       revision = "1";
+       editedCabalFile = "17z9clqfs0hm8jl2hdgk0jqvjdxm8i4lk0av489nhsj2qp6ikvmy";
        libraryHaskellDepends = [
          base bytestring containers deepseq digest directory filepath
          io-classes primitive safe-wild-cards text unix unix-bytestring
···
        pname = "fs-sim";
        version = "0.3.1.0";
        sha256 = "0qq7fc9b37haz2dcywyxhkszy58i3fr7z8nyrrp16x46v5cs6jwq";
+       revision = "1";
+       editedCabalFile = "1pbpi5hngw723z2nr9zwp9rzfxh1p1q8jk8ln01brm7xf3kkq2pb";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers fs-api io-classes mtl
          primitive QuickCheck safe-wild-cards text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "fsnotify_0_4_2_0" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, directory
+     , exceptions, filepath, hinotify, monad-control, monad-logger
+     , random, retry, safe-exceptions, sandwich, string-interpolate
+     , temporary, text, time, unix, unix-compat, unliftio
+     }:
+     mkDerivation {
+       pname = "fsnotify";
+       version = "0.4.2.0";
+       sha256 = "0nm2wm01r3595pf2k3jmdll1i7q7vzayvxq1k2xxnmvxh0rnak8i";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         async base bytestring containers directory filepath hinotify
+         monad-control safe-exceptions text time unix unix-compat
+       ];
+       executableHaskellDepends = [
+         base directory exceptions filepath monad-logger random retry
+         safe-exceptions string-interpolate temporary unix-compat unliftio
+       ];
+       testHaskellDepends = [
+         async base directory exceptions filepath monad-logger random retry
+         safe-exceptions sandwich string-interpolate temporary unix-compat
+         unliftio
+       ];
+       description = "Cross platform library for file change notification";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "example";
+     }) {};
+
   "fsnotify-conduit" = callPackage
     ({ mkDerivation, base, conduit, directory, filepath, fsnotify
      , hspec, resourcet, temporary, transformers
···
      }:
      mkDerivation {
        pname = "ftdi";
-       version = "0.3.0.3";
-       sha256 = "11xgscqdg1nbfr49b7dxjlzh2w8iw0dzyp4f16jlrajyxvw8fjq5";
+       version = "0.3.0.4";
+       sha256 = "022axrrps1niz8r4r7mk69lxd6gra1410hfyvdn4v0b63498yclk";
        libraryHaskellDepends = [
          async base bytestring transformers usb vector
        ];
···
        pname = "fusion-plugin";
        version = "0.2.7";
        sha256 = "0ly2pyhh5s1ahmgkbmm1rqnz035dmniv23w6m2d0vbgxy5mkbb0i";
-       revision = "3";
-       editedCabalFile = "0vb24m1hc28xjhmpmx6sq2iayz85gg0j1q57iw4jyc45k23a3laz";
+       revision = "4";
+       editedCabalFile = "1qdy773bglbkl0gwmnm8jrk5w4zn7vfvs9k70p8vaim1d5ccbfrd";
        libraryHaskellDepends = [
          base containers directory filepath fusion-plugin-types ghc syb time
          transformers
···
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.25.27";
-       sha256 = "06gfmzi5sivn19y5ng2i3p3pw9a1ai29xqvp4dk28cmgv802v8sq";
+       version = "0.25.29";
+       sha256 = "1b7140xkkk89nhxnf8hlss8f6z1nffvp20252019jqv9300xj1zi";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "gargoyle-postgresql-nix" = callPackage
     ({ mkDerivation, base, bytestring, gargoyle, gargoyle-postgresql
-     , which
+     , libpq, which
      }:
      mkDerivation {
        pname = "gargoyle-postgresql-nix";
-       version = "0.3.0.2";
-       sha256 = "1nsw6waqyi9ajm1r97nn3i82m96nrpj5lfjfraf0h7w9byy3sixf";
+       version = "0.3.0.3";
+       sha256 = "1y40csa4k0d3mwmb4qnhp8vpi07p8vv3kcx0j9nl3sybimdc7h0a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          base bytestring gargoyle gargoyle-postgresql which
        ];
+       libraryPkgconfigDepends = [ libpq ];
        executableHaskellDepends = [
          base gargoyle gargoyle-postgresql which
        ];
        description = "Manage PostgreSQL servers with gargoyle and nix";
        license = lib.licenses.bsd3;
        maintainers = [ lib.maintainers.alexfmpe ];
-     }) {};
+     }) {inherit (pkgs) libpq;};
 
   "garlic-bread" = callPackage
     ({ mkDerivation, base, hspec, mtl, transformers }:
···
        broken = true;
      }) {};
 
+  "genai-lib" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, formatting, heredoc
+     , hslogger, http-client, optparse-applicative, prettyprinter
+     , servant, servant-client, servant-client-core, string-conv, text
+     }:
+     mkDerivation {
+       pname = "genai-lib";
+       version = "1.3";
+       sha256 = "002158i1g807jp3sn4wlshnnvpf3s1b8al6gaiy12ni0fvvncn1p";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring formatting hslogger http-client servant
+         servant-client servant-client-core string-conv text
+       ];
+       executableHaskellDepends = [
+         aeson base formatting heredoc optparse-applicative prettyprinter
+         text
+       ];
+       description = "Library and command line tool for interacting with various generative AI LLMs";
+       license = lib.licenses.isc;
+       mainProgram = "genai";
+     }) {};
+
   "gencheck" = callPackage
     ({ mkDerivation, base, combinat, containers, ieee754, memoize
      , random, template-haskell, transformers
···
        broken = true;
      }) {};
 
+  "generic-case" = callPackage
+    ({ mkDerivation, base, generics-sop, hspec, hspec-discover
+     , QuickCheck, sop-core
+     }:
+     mkDerivation {
+       pname = "generic-case";
+       version = "0.1.0.0";
+       sha256 = "0fbdic8f3cj7vvj539g4fvsga1cj99awc3qinv491by0gfpvvq2l";
+       libraryHaskellDepends = [ base generics-sop sop-core ];
+       testHaskellDepends = [
+         base generics-sop hspec QuickCheck sop-core
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Generic case analysis";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "generic-church" = callPackage
     ({ mkDerivation, base, HUnit, test-framework, test-framework-hunit
      }:
···
        pname = "generic-deriving";
        version = "1.14.6";
        sha256 = "1bxjar1kc29nma3whxb0kqgjgxmmm7wvhql7pyick8rj39zw35gi";
+       revision = "1";
+       editedCabalFile = "0mdcj86qy4qnjlx4nh3bi4nrplmycjci7mns4zp0w3ipj0fhfz7l";
        libraryHaskellDepends = [
          base containers ghc-prim template-haskell th-abstraction
        ];
···
        pname = "generic-monoid";
        version = "0.1.0.1";
        sha256 = "1pradfv1i2z73f3vxx78ahmfsdszcgi44kn29aww2hdgf2np5l6g";
-       revision = "4";
-       editedCabalFile = "0vdqgq19xr8b8v7i189qcj21m79ncgdscnm8qdp3ynnva74l19j7";
+       revision = "5";
+       editedCabalFile = "0p4f9rvqfvvhbc1rkfrq14k9wp7s06qlp5dvj3kdmjhynr9rpyk9";
        libraryHaskellDepends = [ base ];
        description = "Derive monoid instances for product types";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "geodetics_1_0_0" = callPackage
-    ({ mkDerivation, array, base, checkers, HUnit, QuickCheck, Stream
-     , test-framework, test-framework-hunit, test-framework-quickcheck2
+  "geodetics_1_1_0" = callPackage
+    ({ mkDerivation, array, base, checkers, hspec, HUnit, parsec
+     , QuickCheck, Stream
      }:
      mkDerivation {
        pname = "geodetics";
-       version = "1.0.0";
-       sha256 = "0nlrvnk99qvd3x3c79rryvy599nkdijj288q8hn0knskmxf0ry54";
-       libraryHaskellDepends = [ array base Stream ];
-       testHaskellDepends = [
-         array base checkers HUnit QuickCheck test-framework
-         test-framework-hunit test-framework-quickcheck2
-       ];
+       version = "1.1.0";
+       sha256 = "1qxh83nhmds1d0w8abnyf54g8by6gga9kv6krlkphavd95mxic6q";
+       libraryHaskellDepends = [ array base parsec Stream ];
+       testHaskellDepends = [ base checkers hspec HUnit QuickCheck ];
        description = "Terrestrial coordinate systems and geodetic calculations";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        pname = "ghc-events";
        version = "0.20.0.0";
        sha256 = "11p3i8jjsxffvh77dlmygh78hyavhkgmk4rhq9khp45br5xshwkk";
-       revision = "1";
-       editedCabalFile = "1kwhh5cqgvgadabban5kzhfjs6xsmbcd0yhqp6dpr4hpggv5cw4n";
+       revision = "2";
+       editedCabalFile = "0h7zy05mh07wa3crnd9zvy1yknka9qlx2fj84qaqyvghidzqb6vh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "ghc-exactprint_1_7_1_0" = callPackage
     ({ mkDerivation, base, bytestring, Cabal-syntax, containers
-     , data-default, Diff, directory, fail, filemanip, filepath, free
-     , ghc, ghc-boot, ghc-paths, HUnit, mtl, ordered-containers
-     , silently, syb
+     , data-default, Diff, directory, extra, fail, filepath, free, ghc
+     , ghc-boot, ghc-paths, HUnit, mtl, ordered-containers, silently
+     , syb
      }:
      mkDerivation {
        pname = "ghc-exactprint";
        version = "1.7.1.0";
-       sha256 = "sha256-fu+n3Z5TWIsxL+XkOxtfSWxDlH1426jYhrRQUvFOqs0=";
+       sha256 = "1kda9vqm4l5lhvcainvqgna46v29bwdkpr755wqqnn2kkvfsgvvy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        testHaskellDepends = [
          base bytestring Cabal-syntax containers data-default Diff directory
-         fail filemanip filepath ghc ghc-boot ghc-paths HUnit mtl
+         extra fail filepath ghc ghc-boot ghc-paths HUnit mtl
          ordered-containers silently syb
        ];
        description = "ExactPrint for GHC";
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-lib_9_12_1_20250105" = callPackage
+  "ghc-lib_9_12_2_20250320" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, exceptions, filepath, ghc-lib-parser
      , ghc-prim, happy, hpc, os-string, parsec, pretty, process, rts
···
      }:
      mkDerivation {
        pname = "ghc-lib";
-       version = "9.12.1.20250105";
-       sha256 = "08ijsdl816d95s6s8k7gragsd12rkvawmribjahxzqf8ivgscd8q";
+       version = "9.12.2.20250320";
+       sha256 = "1pmwky5aka2q07jzari6n3qlhiv6id65l4yg60kgjb6gf1jyknrk";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "ghc-lib-parser_9_12_1_20250105" = callPackage
+  "ghc-lib-parser_9_12_2_20250320" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , deepseq, directory, exceptions, filepath, ghc-prim, happy
      , os-string, parsec, pretty, process, time, transformers, unix
      }:
      mkDerivation {
        pname = "ghc-lib-parser";
-       version = "9.12.1.20250105";
-       sha256 = "0n0k0gwxibzab7nn4m7l5nyky8krp46d6xykvvqflhd6pal1mmyi";
+       version = "9.12.2.20250320";
+       sha256 = "1f9d3h8g7ic78k6jnvzm1klw980ad4y3vwkw4lqwrqssbg0800cp";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
        pname = "ghc-tags-core";
        version = "0.6.1.1";
        sha256 = "1p1ykmbq16lg30s2cnwds16aiq4wxiv9s59sa933fk9mv2841gb1";
+       revision = "1";
+       editedCabalFile = "1j3i4cdwr1wpzxgv8vhzzly6mfgkfggxhb8shrfkrrczr6vr2z96";
        libraryHaskellDepends = [
          attoparsec base bytestring containers deepseq filepath ghc text
        ];
···
        pname = "ghc-tags-pipes";
        version = "0.1.1.0";
        sha256 = "1ajgqhnch20zfrslmng3hbmn3p9hcsd3d6b02yq6qv8rlxrl9nxn";
-       revision = "1";
-       editedCabalFile = "0r40shzvq4ps4nhp4yhw76wnkm07k711gqzdbrilig4vv0r82x89";
+       revision = "3";
+       editedCabalFile = "0xa6c7hy0p16dbaqfpxiaxhkzrv5cximl7pj2398d08m9wi6izb8";
        libraryHaskellDepends = [
          attoparsec base bytestring ghc-tags-core mtl pipes pipes-attoparsec
          pipes-bytestring text
···
        pname = "ghc-tags-plugin";
        version = "0.6.1.1";
        sha256 = "1w1m942hzw63igdjvhb15n5w0yzkm2hp5lyv1dl815dvzj0bn8kq";
+       revision = "1";
+       editedCabalFile = "0hs57qfx8sv3mrpc4scqnynhzxpkklbzyk5af3nr4ambiayk4bjw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "ghc-tcplugins-extra_0_5" = callPackage
+    ({ mkDerivation, base, ghc }:
+     mkDerivation {
+       pname = "ghc-tcplugins-extra";
+       version = "0.5";
+       sha256 = "1spcy34ak90w75wgg79gdkxfz8sxhw4r0aslr5gsb900niszxyy7";
+       libraryHaskellDepends = [ base ghc ];
+       description = "Utilities for writing GHC type-checker plugins";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ghc-time-alloc-prof" = callPackage
     ({ mkDerivation, attoparsec, base, containers, directory, filepath
      , process, tasty, tasty-hunit, temporary, text, time
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "ghc-typelits-extra_0_4_8" = callPackage
+    ({ mkDerivation, base, containers, ghc, ghc-bignum, ghc-prim
+     , ghc-tcplugins-extra, ghc-typelits-knownnat
+     , ghc-typelits-natnormalise, tasty, tasty-hunit, template-haskell
+     , transformers
+     }:
+     mkDerivation {
+       pname = "ghc-typelits-extra";
+       version = "0.4.8";
+       sha256 = "06bcqh8n945rhqsin36kqhlx5jzsss57c0j06n8vhv9xjlq3xy7b";
+       libraryHaskellDepends = [
+         base containers ghc ghc-bignum ghc-prim ghc-tcplugins-extra
+         ghc-typelits-knownnat ghc-typelits-natnormalise template-haskell
+         transformers
+       ];
+       testHaskellDepends = [
+         base ghc-typelits-knownnat ghc-typelits-natnormalise tasty
+         tasty-hunit
+       ];
+       description = "Additional type-level operations on GHC.TypeLits.Nat";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ghc-typelits-knownnat" = callPackage
     ({ mkDerivation, base, ghc, ghc-prim, ghc-tcplugins-extra
      , ghc-typelits-natnormalise, tasty, tasty-hunit, tasty-quickcheck
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "ghc-typelits-knownnat_0_7_13" = callPackage
+    ({ mkDerivation, base, ghc, ghc-prim, ghc-tcplugins-extra
+     , ghc-typelits-natnormalise, tasty, tasty-hunit, tasty-quickcheck
+     , template-haskell, transformers
+     }:
+     mkDerivation {
+       pname = "ghc-typelits-knownnat";
+       version = "0.7.13";
+       sha256 = "0zb4m9zja1x5kjx7chszb9b1qczjknghqkhh99i9fygirs3d03zd";
+       libraryHaskellDepends = [
+         base ghc ghc-prim ghc-tcplugins-extra ghc-typelits-natnormalise
+         template-haskell transformers
+       ];
+       testHaskellDepends = [
+         base ghc-typelits-natnormalise tasty tasty-hunit tasty-quickcheck
+       ];
+       description = "Derive KnownNat constraints from other KnownNat constraints";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ghc-typelits-natnormalise" = callPackage
     ({ mkDerivation, base, containers, ghc, ghc-bignum, ghc-prim
      , ghc-tcplugins-extra, tasty, tasty-hunit, template-haskell
···
        ];
        description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
        license = lib.licenses.bsd2;
+     }) {};
+
+  "ghc-typelits-natnormalise_0_7_11" = callPackage
+    ({ mkDerivation, base, containers, ghc, ghc-bignum, ghc-prim
+     , ghc-tcplugins-extra, tasty, tasty-hunit, template-haskell
+     , transformers
+     }:
+     mkDerivation {
+       pname = "ghc-typelits-natnormalise";
+       version = "0.7.11";
+       sha256 = "1r661cnhn4gc2vlmdgxx3w42h8m3fbh7s7sf98kdp3ac9a59s8hb";
+       libraryHaskellDepends = [
+         base containers ghc ghc-bignum ghc-tcplugins-extra template-haskell
+         transformers
+       ];
+       testHaskellDepends = [
+         base ghc-prim tasty tasty-hunit template-haskell
+       ];
+       description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-typelits-presburger" = callPackage
···
      }:
      mkDerivation {
        pname = "ghci-dap";
-       version = "0.0.24.0";
-       sha256 = "0l3wvmdj4xwjili41x32fakx798jni9mssv6lyz56by4kjbmvjn9";
+       version = "0.0.25.0";
+       sha256 = "0za0m1s6hayzgv1j8brqlxylqsqx6cifml96a4rcjgi3g7i51ga8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      , extra, filepath, fingertree, focus, ghc, ghc-boot, ghc-boot-th
      , ghc-trace-events, gitrev, Glob, haddock-library, hashable
      , hie-bios, hie-compat, hiedb, hls-graph, hls-plugin-api
-     , implicit-hie, lens, list-t, lsp, lsp-types, mtl, opentelemetry
-     , optparse-applicative, parallel, prettyprinter
-     , prettyprinter-ansi-terminal, random, regex-tdfa, safe-exceptions
-     , sorted-list, sqlite-simple, stm, stm-containers, syb, text
-     , text-rope, time, transformers, unix, unliftio, unliftio-core
-     , unordered-containers, vector
+     , implicit-hie, lens, lens-aeson, list-t, lsp, lsp-types, mtl
+     , opentelemetry, optparse-applicative, os-string, parallel
+     , prettyprinter, prettyprinter-ansi-terminal, random, regex-tdfa
+     , safe-exceptions, sorted-list, sqlite-simple, stm, stm-containers
+     , syb, text, text-rope, time, transformers, unix, unliftio
+     , unliftio-core, unordered-containers, vector
      }:
      mkDerivation {
        pname = "ghcide";
-       version = "2.9.0.0";
-       sha256 = "18g70rjpkrvc433y2fd2wd6fgcwvxj1gy12h1ajr1dn28ys4847k";
+       version = "2.10.0.0";
+       sha256 = "1l8c0gpzbp6lk11zvwby2n7798lnpsc23gb3xvn5yl1kd1x0dk44";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          dlist enummapset exceptions extra filepath fingertree focus ghc
          ghc-boot ghc-boot-th ghc-trace-events Glob haddock-library hashable
          hie-bios hie-compat hiedb hls-graph hls-plugin-api implicit-hie
-         lens list-t lsp lsp-types mtl opentelemetry optparse-applicative
-         parallel prettyprinter prettyprinter-ansi-terminal random
-         regex-tdfa safe-exceptions sorted-list sqlite-simple stm
-         stm-containers syb text text-rope time transformers unix unliftio
-         unliftio-core unordered-containers vector
+         lens lens-aeson list-t lsp lsp-types mtl opentelemetry
+         optparse-applicative os-string parallel prettyprinter
+         prettyprinter-ansi-terminal random regex-tdfa safe-exceptions
+         sorted-list sqlite-simple stm stm-containers syb text text-rope
+         time transformers unix unliftio unliftio-core unordered-containers
+         vector
        ];
        executableHaskellDepends = [
          base data-default extra gitrev hls-plugin-api lsp lsp-types
···
        ];
        description = "The core of an IDE";
        license = lib.licenses.asl20;
+       mainProgram = "ghcide";
      }) {};
 
   "ghcide-bench" = callPackage
···
      }:
      mkDerivation {
        pname = "ghcup";
-       version = "0.1.40.0";
-       sha256 = "1pjipxl0lwag89s7dsllr2iq5kqki3sqdijg1g1fvhmsg84is55z";
-       revision = "3";
-       editedCabalFile = "0x8dz95qz95skb5xfvr31g30rg8n9pr1zmhs5281bva246h2h8gi";
+       version = "0.1.50.1";
+       sha256 = "0y0zpzxkxhm6kgwrbzhy167qllkzgyk5wcc3iy3qmbyg7wplb8xy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        testHaskellDepends = [
          base bytestring conduit containers directory filepath
-         generic-arbitrary hspec hspec-golden-aeson optparse-applicative
-         QuickCheck quickcheck-arbitrary-adt tasty tasty-hunit
-         template-haskell text time unix uri-bytestring versions
+         generic-arbitrary hspec hspec-golden-aeson megaparsec
+         optparse-applicative QuickCheck quickcheck-arbitrary-adt tasty
+         tasty-hunit template-haskell text time unix uri-bytestring versions
        ];
        testToolDepends = [ hspec-discover ];
        doHaddock = false;
···
        license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) glib;};
 
+  "gi-gio_2_0_36" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers, gi-glib
+     , gi-gobject, glib, haskell-gi, haskell-gi-base
+     , haskell-gi-overloading, text, transformers
+     }:
+     mkDerivation {
+       pname = "gi-gio";
+       version = "2.0.36";
+       sha256 = "03wbzg9xyjn6axkyvah4v5knf06inzfr1n5qd36bnbzffnbqihg9";
+       setupHaskellDepends = [ base Cabal gi-glib gi-gobject haskell-gi ];
+       libraryHaskellDepends = [
+         base bytestring containers gi-glib gi-gobject haskell-gi
+         haskell-gi-base haskell-gi-overloading text transformers
+       ];
+       libraryPkgconfigDepends = [ glib ];
+       description = "Gio bindings";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) glib;};
+
   "gi-gio-hs-list-model" = callPackage
     ({ mkDerivation, base, containers, gi-gio, gi-gobject
      , haskell-gi-base
···
      }:
      mkDerivation {
        pname = "gi-secret";
-       version = "0.0.19";
-       sha256 = "0070li67sl96cbqvywig532a00aqlc7spbf94v8bkj5qy7fph9nz";
+       version = "0.0.20";
+       sha256 = "0r5j7p2pw9qnsa6z2lrbgz2c3r82jnmzpxxdq3l8y0bsnada11ap";
        setupHaskellDepends = [
          base Cabal gi-gio gi-glib gi-gobject haskell-gi
        ];
···
        license = lib.licenses.lgpl21Only;
      }) {system-glib = pkgs.glib;};
 
+  "gio_0_13_12_0" = callPackage
+    ({ mkDerivation, array, base, bytestring, Cabal, containers, glib
+     , gtk2hs-buildtools, mtl, system-glib
+     }:
+     mkDerivation {
+       pname = "gio";
+       version = "0.13.12.0";
+       sha256 = "0g0hicy7ndzl4ax50a2ww1y3l06752dhaaqg30g9wxkj46nwaikk";
+       enableSeparateDataOutput = true;
+       setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
+       libraryHaskellDepends = [
+         array base bytestring containers glib mtl
+       ];
+       libraryPkgconfigDepends = [ system-glib ];
+       description = "Binding to GIO";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {system-glib = pkgs.glib;};
+
   "gipeda" = callPackage
     ({ mkDerivation, aeson, base, bytestring, cassava
      , concurrent-output, containers, directory, extra, file-embed
···
      , case-insensitive, clientsession, clock, concurrent-output
      , conduit, containers, crypto-api, crypton, data-default, DAV, dbus
      , deepseq, directory, disk-free-space, dlist, edit-distance
-     , exceptions, fdo-notify, feed, filepath, filepath-bytestring, free
-     , git-lfs, hinotify, http-client, http-client-restricted
-     , http-client-tls, http-conduit, http-types, IfElse, magic, memory
-     , microlens, monad-control, monad-logger, mountpoints, mtl, network
-     , network-bsd, network-info, network-multicast, network-uri
-     , old-locale, optparse-applicative, path-pieces, persistent
-     , persistent-sqlite, persistent-template, process, QuickCheck
-     , random, regex-tdfa, resourcet, SafeSemaphore, sandi, securemem
-     , servant, servant-client, servant-client-core, servant-server
-     , shakespeare, socks, split, stm, stm-chans, tagsoup, tasty
-     , tasty-hunit, tasty-quickcheck, tasty-rerun, template-haskell
-     , text, time, torrent, transformers, unbounded-delays, unix
-     , unix-compat, unliftio-core, unordered-containers, utf8-string
-     , uuid, vector, wai, wai-extra, warp, warp-tls, yesod, yesod-core
-     , yesod-form, yesod-static
+     , exceptions, fdo-notify, feed, file-io, filepath
+     , filepath-bytestring, free, git-lfs, hinotify, http-client
+     , http-client-restricted, http-client-tls, http-conduit, http-types
+     , IfElse, magic, memory, microlens, monad-control, monad-logger
+     , mountpoints, mtl, network, network-bsd, network-info
+     , network-multicast, network-uri, old-locale, optparse-applicative
+     , os-string, path-pieces, persistent, persistent-sqlite
+     , persistent-template, process, QuickCheck, random, regex-tdfa
+     , resourcet, SafeSemaphore, sandi, securemem, servant
+     , servant-client, servant-client-core, servant-server, shakespeare
+     , socks, split, stm, stm-chans, tagsoup, tasty, tasty-hunit
+     , tasty-quickcheck, tasty-rerun, template-haskell, text, time
+     , torrent, transformers, unbounded-delays, unix, unix-compat
+     , unliftio-core, unordered-containers, utf8-string, uuid, vector
+     , wai, wai-extra, warp, warp-tls, yesod, yesod-core, yesod-form
+     , yesod-static
      }:
      mkDerivation {
        pname = "git-annex";
-       version = "10.20250115";
-       sha256 = "1m2rsa31i85y72llpi3fppbv337xa9kd23182pbair2blixv5h6i";
+       version = "10.20250320";
+       sha256 = "03js1bafx3646h6h6zj0915c2pyjxj22f1nm6bjd34bjffx2di5i";
        configureFlags = [
          "-fassistant" "-f-benchmark" "-fcrypton" "-fdbus" "-f-debuglocks"
          "-fmagicmime" "-fpairing" "-fproduction" "-ftorrentparser"
···
          bloomfilter byteable bytestring case-insensitive clientsession
          clock concurrent-output conduit containers crypto-api crypton
          data-default DAV dbus deepseq directory disk-free-space dlist
-         edit-distance exceptions fdo-notify feed filepath
-         filepath-bytestring free git-lfs hinotify http-client
-         http-client-restricted http-client-tls http-conduit http-types
-         IfElse magic memory microlens monad-control monad-logger
-         mountpoints mtl network network-bsd network-info network-multicast
-         network-uri old-locale optparse-applicative path-pieces persistent
-         persistent-sqlite persistent-template process QuickCheck random
-         regex-tdfa resourcet SafeSemaphore sandi securemem servant
-         servant-client servant-client-core servant-server shakespeare socks
-         split stm stm-chans tagsoup tasty tasty-hunit tasty-quickcheck
-         tasty-rerun template-haskell text time torrent transformers
-         unbounded-delays unix unix-compat unliftio-core
-         unordered-containers utf8-string uuid vector wai wai-extra warp
-         warp-tls yesod yesod-core yesod-form yesod-static
+         edit-distance exceptions fdo-notify feed file-io filepath free
+         git-lfs hinotify http-client http-client-restricted http-client-tls
+         http-conduit http-types IfElse magic memory microlens monad-control
+         monad-logger mountpoints mtl network network-bsd network-info
+         network-multicast network-uri old-locale optparse-applicative
+         os-string path-pieces persistent persistent-sqlite
+         persistent-template process QuickCheck random regex-tdfa resourcet
+         SafeSemaphore sandi securemem servant servant-client
+         servant-client-core servant-server shakespeare socks split stm
+         stm-chans tagsoup tasty tasty-hunit tasty-quickcheck tasty-rerun
+         template-haskell text time torrent transformers unbounded-delays
+         unix unix-compat unliftio-core unordered-containers utf8-string
+         uuid vector wai wai-extra warp warp-tls yesod yesod-core yesod-form
+         yesod-static
        ];
        description = "manage files with git, without checking their contents into git";
        license = lib.licenses.agpl3Only;
···
        license = lib.licenses.agpl3Only;
      }) {};
 
+  "git-lfs_1_2_5" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, case-insensitive
+     , containers, http-client, http-types, network-uri, text
+     }:
+     mkDerivation {
+       pname = "git-lfs";
+       version = "1.2.5";
+       sha256 = "1lzlz9v05iabpkw09bgxxv4nj5yk7a0vzg6rx0kr0qrsir8c3jh2";
+       libraryHaskellDepends = [
+         aeson base bytestring case-insensitive containers http-client
+         http-types network-uri text
+       ];
+       description = "git-lfs protocol";
+       license = lib.licenses.agpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "git-mediate" = callPackage
     ({ mkDerivation, ansi-terminal, base, base-compat, containers, Diff
      , directory, filepath, generic-data, mtl, optparse-applicative
···
        license = lib.licenses.mit;
      }) {};
 
+  "github-webhooks_0_18_0" = callPackage
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+     , cryptonite, deepseq, deepseq-generics, hspec, memory, text, time
+     , vector
+     }:
+     mkDerivation {
+       pname = "github-webhooks";
+       version = "0.18.0";
+       sha256 = "0j1ykqmcz5bwr0ksvcan0p5rhsmgbvynp540vn6flmnscq45hhmb";
+       libraryHaskellDepends = [
+         aeson base base16-bytestring bytestring cryptonite deepseq
+         deepseq-generics memory text time vector
+       ];
+       testHaskellDepends = [ aeson base bytestring hspec text vector ];
+       description = "Aeson instances for GitHub webhook payloads";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "github-workflow-commands" = callPackage
     ({ mkDerivation, base, bytestring, containers, hspec
      , hspec-junit-formatter, lens, markdown-unlit, MonadRandom, text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "gitlab-haskell_1_1_0_0" = callPackage
+    ({ mkDerivation, aeson, ansi-wl-pprint, base, bytestring
+     , crypton-connection, data-default, http-client, http-conduit
+     , http-types, mtl, tasty, tasty-hunit, temporary, text, time
+     , transformers, tree-diff, unix-compat, unordered-containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "gitlab-haskell";
+       version = "1.1.0.0";
+       sha256 = "05x916wlmqys7f22whxysi3cbz9sjfm91xck810x2hpn8bgg79gy";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base bytestring crypton-connection data-default http-client
+         http-conduit http-types mtl temporary text time transformers
+         unix-compat
+       ];
+       testHaskellDepends = [
+         aeson ansi-wl-pprint base bytestring tasty tasty-hunit text
+         tree-diff unordered-containers vector
+       ];
+       description = "A Haskell library for the GitLab web API";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "gitlib" = callPackage
     ({ mkDerivation, base, base16-bytestring, bytestring, conduit
      , conduit-combinators, containers, directory, exceptions, filepath
···
        badPlatforms = lib.platforms.darwin;
      }) {inherit (pkgs) libGL;};
 
+  "gl_0_9_1" = callPackage
+    ({ mkDerivation, base, containers, fixed, half, libGL, transformers
+     }:
+     mkDerivation {
+       pname = "gl";
+       version = "0.9.1";
+       sha256 = "0wlrsn0bj0mcidhcb6mz7iykjxsgich6372iwr5akjhvxxlbr6j8";
+       libraryHaskellDepends = [
+         base containers fixed half transformers
+       ];
+       librarySystemDepends = [ libGL ];
+       description = "Complete OpenGL raw bindings";
+       license = lib.licenses.bsd3;
+       badPlatforms = lib.platforms.darwin;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) libGL;};
+
   "gl-block" = callPackage
     ({ mkDerivation, base, ptrdiff, tasty, tasty-bench, tasty-discover
      , tasty-hunit, vector
···
     ({ mkDerivation, base, containers, GLFW-b, stm, text }:
      mkDerivation {
        pname = "glfw-group";
-       version = "0.1.0.2";
-       sha256 = "10s8zi0km6jdyv8y0ckkf4wk8a1x1mq8rafhp89yjgsyqkpq2z5j";
+       version = "0.1.0.6";
+       sha256 = "1ga59i4g1rmywq4jqgrj39r68lv26j1y27rzpybsg5win4278g2z";
        libraryHaskellDepends = [ base containers GLFW-b stm text ];
        testHaskellDepends = [ base containers GLFW-b stm text ];
        description = "GLFW package with window groups destroyed together";
···
        libraryPkgconfigDepends = [ glib ];
        description = "Binding to the GLIB library for Gtk2Hs";
        license = lib.licenses.lgpl21Only;
+     }) {inherit (pkgs) glib;};
+
+  "glib_0_13_12_0" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers, glib
+     , gtk2hs-buildtools, text, utf8-string
+     }:
+     mkDerivation {
+       pname = "glib";
+       version = "0.13.12.0";
+       sha256 = "03b9s9fzg17mh4dcxmgnb43a0r5237gh91x6blpwawynrvi9bmmg";
+       setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
+       libraryHaskellDepends = [
+         base bytestring containers text utf8-string
+       ];
+       libraryPkgconfigDepends = [ glib ];
+       description = "Binding to the GLIB library for Gtk2Hs";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) glib;};
 
   "glib-stopgap" = callPackage
···
        pname = "gnuplot";
        version = "0.5.7";
        sha256 = "1glahh3si5bpazsklnpwxx4h4ivgb4wyngc032797zq1496fhhm3";
-       revision = "2";
-       editedCabalFile = "0mjyvpz71p80b87blhkqbvwihzkdc1dvbn9laxw5a9l9lh7761qd";
+       revision = "3";
+       editedCabalFile = "1rwlkr94h6lzp6aa3p4i5dgdl1i9nl7mahxny2qz9ggjbj4yiw65";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        broken = true;
      }) {};
 
+  "google-cloud-common" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, hspec
+     , http-conduit, jwt, mtl, process, text, time
+     }:
+     mkDerivation {
+       pname = "google-cloud-common";
+       version = "0.1.0.0";
+       sha256 = "094gfjd0mlnp44a2a1zjqz88rgq9xp12spff00yiyf6vkrqpxnkb";
+       libraryHaskellDepends = [
+         aeson base bytestring containers http-conduit jwt mtl process text
+         time
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers hspec http-conduit jwt mtl process
+         text time
+       ];
+       description = "GCP Client for Haskell";
+       license = lib.licenses.mit;
+     }) {};
+
+  "google-cloud-compute" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers
+     , google-cloud-common, hspec, http-conduit, text
+     }:
+     mkDerivation {
+       pname = "google-cloud-compute";
+       version = "0.1.0.0";
+       sha256 = "1s8dy9ns65m5vcf6ybfjg2jvck4awmzrg8szfdzfi89pqcnwx40w";
+       libraryHaskellDepends = [
+         aeson base bytestring containers google-cloud-common http-conduit
+         text
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers google-cloud-common hspec
+         http-conduit text
+       ];
+       description = "GCP Client for Haskell";
+       license = lib.licenses.mit;
+     }) {};
+
+  "google-cloud-logging" = callPackage
+    ({ mkDerivation, aeson, base, google-cloud-common }:
+     mkDerivation {
+       pname = "google-cloud-logging";
+       version = "0.1.0.0";
+       sha256 = "0yjwihsklbhqq1k3gdcn1df3bvln4brby8ymr6jizwgsy64cvsz3";
+       libraryHaskellDepends = [ aeson base google-cloud-common ];
+       testHaskellDepends = [ aeson base google-cloud-common ];
+       description = "GCP Client for Haskell";
+       license = lib.licenses.mit;
+     }) {};
+
+  "google-cloud-storage" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, google-cloud-common, text
+     }:
+     mkDerivation {
+       pname = "google-cloud-storage";
+       version = "0.1.0.0";
+       sha256 = "14c3m2r6br623ij7amig05mirhnpdcazszzys6dqd2izpf8dn85r";
+       libraryHaskellDepends = [
+         aeson base bytestring google-cloud-common text
+       ];
+       testHaskellDepends = [
+         aeson base bytestring google-cloud-common text
+       ];
+       license = lib.licenses.mit;
+     }) {};
+
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
      mkDerivation {
···
      }:
      mkDerivation {
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       version = "0.6.6.7";
+       sha256 = "005kdy8jvny75q4srphz5wvl3b2alkvj5kxlz5yp7qqiwvdgp0y4";
        libraryHaskellDepends = [
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
      }:
      mkDerivation {
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       version = "0.1.0.170";
+       sha256 = "1yasjnay36ac5qixnyzp1nl1srhvybs8z7z2al062cgrzklr4fb9";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
        ];
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
        ];
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
      }:
      mkDerivation {
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       version = "0.1.0.0";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       version = "0.1.0.1";
+       sha256 = "1yf1z9in4ddw4irgr9hsabrlpg52z5bb2jn19zmlkrimlnxyry2h";
        libraryHaskellDepends = [
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
        ];
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
      }:
      mkDerivation {
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       version = "0.1.0.75";
+       sha256 = "1m22f7p78pwpipkvlsg95izivhz4z2cxiww4l4qy329s1cyyy0w6";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        version = "1.0.0";
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       revision = "1";
+       editedCabalFile = "146jyzlqdppdshkjqc2k7wjfs0awil5n3b1m17dcsiis8fslnj6n";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
        ];
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "grapesy-etcd" = callPackage
+    ({ mkDerivation, base, exceptions, grapesy, proto-lens-etcd }:
+     mkDerivation {
+       pname = "grapesy-etcd";
+       version = "0.3.0";
+       sha256 = "0kv50shw2iwnmj896zzbqc1imsdwwls4dnak6k6hls5fp1jryy8k";
+       libraryHaskellDepends = [
+         base exceptions grapesy proto-lens-etcd
+       ];
+       description = "grapesy-etcd - GRPC interface to etcd";
+       license = lib.licenses.asl20;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "graphs_0_7_3" = callPackage
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+     , transformers-compat, void
+     }:
+     mkDerivation {
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       version = "0.7.3";
+       sha256 = "1lcavfli46azfacjh9vgsgs0yb6r0s4ch15pxypq63imiw169fvy";
+       libraryHaskellDepends = [
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       ];
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
     ({ mkDerivation, base, indexed }:
      mkDerivation {
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "graphula_2_1_0_1" = callPackage
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+     , unliftio-core
+     }:
+     mkDerivation {
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       version = "2.1.0.1";
+       sha256 = "1bc8nr6m9lahbfg5h1i9y25kv5ikr7dcqs4ga4hzii07zvq6ks84";
+       libraryHaskellDepends = [
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       ];
+       testHaskellDepends = [
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       ];
+       testToolDepends = [ markdown-unlit ];
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
     ({ mkDerivation, aeson, base, bytestring, containers, directory
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
        license = lib.licenses.bsd3;
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
 
+  "graphviz_2999_20_2_1" = callPackage
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+     }:
+     mkDerivation {
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       version = "2999.20.2.1";
+       sha256 = "10mksxlg0pn82z6sfz8xnnmhn03ddi4cml9fh3wlgph1ksjhzz4g";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       ];
+       testHaskellDepends = [
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       ];
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       testToolDepends = [ hspec-discover ];
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+
+  "graphwiz" = callPackage
+    ({ mkDerivation, base, containers, directory, filepath, hashable
+     , lens, mtl, stm, tagged, tasty, tasty-autocollect, tasty-golden
+     , text, text-builder, transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "graphwiz";
+       version = "1.0.0";
+       sha256 = "0ssddsg7wv007ll6jazhncdvs6pd42pc8nfvg4md1a2xhrzacv03";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers hashable lens mtl text text-builder transformers
+         unordered-containers
+       ];
+       executableHaskellDepends = [ base lens text-builder ];
+       testHaskellDepends = [
+         base containers directory filepath hashable lens mtl stm tagged
+         tasty tasty-autocollect tasty-golden text text-builder transformers
+         unordered-containers
+       ];
+       testToolDepends = [ tasty-autocollect ];
+       description = "Monadic DOT graph builder DSL";
+       license = lib.licenses.bsd3;
+       mainProgram = "example";
+     }) {};
+
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
      }) {};
 
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+    ({ mkDerivation, base, base16-bytestring, binary, bytestring
+     , cryptohash-md5, directory, exceptions, hashable, libX11, libXau
+     , libXScrnSaver, microlens, microlens-mtl, protolude, text, tomland
+     , unix, vector, wordexp, X11, xcb, xdmcp
      }:
      mkDerivation {
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       version = "4.2.0";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       version = "4.3.1";
+       sha256 = "16465cz2hcsi9qpn16xgy25zlb0kqvbfl6py8kq8s3qn9ad9qf8v";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+         base base16-bytestring binary bytestring cryptohash-md5 directory
+         exceptions hashable microlens microlens-mtl protolude text tomland
+         unix vector wordexp X11
        ];
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
        pname = "group-by-date";
        version = "0.1.0.5";
        sha256 = "1c19x8qqrq8fiaxdz917nim8z8dcsi4bcyf88ci39d3xq1iq9iis";
-       revision = "1";
-       editedCabalFile = "1kg5nfk68s2222nnxw76hxrzp04s2ax5vnn72i6w91agw294f7mh";
+       revision = "2";
+       editedCabalFile = "1hgil34is14j10dhxwbmmwkwgbqv0as1cmm2lm1j5p6aknz1swvh";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtk2;};
 
+  "gtk_0_15_10" = callPackage
+    ({ mkDerivation, array, base, bytestring, Cabal, cairo, containers
+     , gio, glib, gtk2, gtk2hs-buildtools, mtl, pango, text
+     }:
+     mkDerivation {
+       pname = "gtk";
+       version = "0.15.10";
+       sha256 = "1bxaf9c2ascrjk4xv03xqj6nfh3m1hzfq47cnvb32g6hxal9ap3k";
+       enableSeparateDataOutput = true;
+       setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
+       libraryHaskellDepends = [
+         array base bytestring cairo containers gio glib mtl pango text
+       ];
+       libraryPkgconfigDepends = [ gtk2 ];
+       description = "Binding to the Gtk+ graphical user interface library";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) gtk2;};
+
   "gtk-helpers" = callPackage
     ({ mkDerivation, array, base, gio, glib, gtk, mtl, process
      , template-haskell
···
        license = lib.licenses.gpl2Only;
      }) {};
 
+  "gtk2hs-buildtools_0_13_12_0" = callPackage
+    ({ mkDerivation, alex, array, base, Cabal, containers, directory
+     , filepath, happy, hashtables, pretty, process, random
+     }:
+     mkDerivation {
+       pname = "gtk2hs-buildtools";
+       version = "0.13.12.0";
+       sha256 = "15g4y6i0w0grnl1vi2c51k10qzhdbnqqk2vp2p3pclx5n41g6213";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         array base Cabal containers directory filepath hashtables pretty
+         process random
+       ];
+       libraryToolDepends = [ alex happy ];
+       executableHaskellDepends = [ base ];
+       description = "Tools to build the Gtk2Hs suite of User Interface libraries";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "gtk2hs-cast-glade" = callPackage
     ({ mkDerivation, base, glade, gtk, gtk2hs-cast-glib, hint
      , template-haskell
···
        libraryPkgconfigDepends = [ gtk3 ];
        description = "Binding to the Gtk+ 3 graphical user interface library";
        license = lib.licenses.lgpl21Only;
+     }) {inherit (pkgs) gtk3;};
+
+  "gtk3_0_15_10" = callPackage
+    ({ mkDerivation, array, base, bytestring, Cabal, cairo, containers
+     , gio, glib, gtk2hs-buildtools, gtk3, mtl, pango, text
+     }:
+     mkDerivation {
+       pname = "gtk3";
+       version = "0.15.10";
+       sha256 = "1bsl4ik7jw5d0lk7fmmdp3ymb30wircwdvdqd892hrmjaq3qmfh9";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       setupHaskellDepends = [ base Cabal gtk2hs-buildtools ];
+       libraryHaskellDepends = [
+         array base bytestring cairo containers gio glib mtl pango text
+       ];
+       libraryPkgconfigDepends = [ gtk3 ];
+       description = "Binding to the Gtk+ 3 graphical user interface library";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) gtk3;};
 
   "gtk3-helpers" = callPackage
···
      }:
      mkDerivation {
        pname = "hOpenPGP";
-       version = "2.10.0";
-       sha256 = "1k8c4qwkn4nb9kz3zmlpkjdrmzygk9dc2fms8k8rgqlnz7l61ch5";
+       version = "2.10.1";
+       sha256 = "1wj8p62hqzl409l91l0xiz5fb7lmzrnh0f453wgxkvyxk0vzf36z";
        libraryHaskellDepends = [
          aeson asn1-encoding attoparsec base base16-bytestring bifunctors
          binary binary-conduit bytestring bz2 conduit conduit-extra
···
        pname = "hackage-revdeps";
        version = "0.1";
        sha256 = "1rc6k7cjcc581cx7nx7q0p5qdfzpc010bacx4w524j6bw1qb2kp1";
+       revision = "1";
+       editedCabalFile = "1x0rslnwk818wv37qxjfk8nmv1ld5an6ca402zhgmq0i94gd39h3";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "haddock-use-refs" = callPackage
+    ({ mkDerivation, base, cpphs, haddock-library, tasty
+     , tasty-discover, tasty-hunit, tasty-quickcheck, template-haskell
+     }:
+     mkDerivation {
+       pname = "haddock-use-refs";
+       version = "1.0.1";
+       sha256 = "0yra139dxybs803c0fa5ssdcp9414mrr281y84z8xmyga7ifmrgw";
+       libraryHaskellDepends = [
+         base cpphs haddock-library template-haskell
+       ];
+       testHaskellDepends = [
+         base tasty tasty-discover tasty-hunit tasty-quickcheck
+         template-haskell
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Eliminate warnings for names referred in Haddock only";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "haddocset" = callPackage
     ({ mkDerivation, base, Cabal, conduit, conduit-extra, directory
      , exceptions, filepath, ghc, haddock-api, http-types, mtl
···
        maintainers = [ lib.maintainers.erictapen ];
      }) {inherit (pkgs) util-linux;};
 
+  "hakyll_4_16_6_0" = callPackage
+    ({ mkDerivation, aeson, base, binary, blaze-html, bytestring
+     , containers, data-default, deepseq, directory, file-embed
+     , filepath, fsnotify, hashable, http-conduit, http-types, lrucache
+     , mtl, network-uri, optparse-applicative, pandoc, pandoc-types
+     , parsec, process, QuickCheck, random, regex-tdfa, resourcet
+     , scientific, tagsoup, tasty, tasty-golden, tasty-hunit
+     , tasty-quickcheck, template-haskell, text, time
+     , time-locale-compat, util-linux, vector, wai, wai-app-static, warp
+     , yaml
+     }:
+     mkDerivation {
+       pname = "hakyll";
+       version = "4.16.6.0";
+       sha256 = "1933k6aiawa0kdws7ajm9picjchnfrkkd0qd8xb9l2yv1fvcywg2";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base binary blaze-html bytestring containers data-default
+         deepseq directory file-embed filepath fsnotify hashable
+         http-conduit http-types lrucache mtl network-uri
+         optparse-applicative pandoc pandoc-types parsec process random
+         regex-tdfa resourcet scientific tagsoup template-haskell text time
+         time-locale-compat vector wai wai-app-static warp yaml
+       ];
+       executableHaskellDepends = [ base directory filepath ];
+       testHaskellDepends = [
+         aeson base bytestring containers filepath pandoc pandoc-types
+         QuickCheck tagsoup tasty tasty-golden tasty-hunit tasty-quickcheck
+         yaml
+       ];
+       testToolDepends = [ util-linux ];
+       description = "A static website compiler library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hakyll-init";
+       maintainers = [ lib.maintainers.erictapen ];
+     }) {inherit (pkgs) util-linux;};
+
   "hakyll-R" = callPackage
     ({ mkDerivation, base, directory, filepath, hakyll, pandoc, process
      }:
···
        ];
        description = "A breakout game written in Yampa using SDL";
        license = "unknown";
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "haskanoid";
      }) {};
 
···
   "haskell-debug-adapter" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, Cabal, clock
      , conduit, conduit-extra, containers, data-default, directory
-     , filepath, ghci-dap, haskell-dap, hslogger, hspec, lens, mtl
-     , optparse-applicative, parsec, process, resourcet, safe-exceptions
-     , text
+     , filepath, fsnotify, ghci-dap, haskell-dap, hie-bios, hslogger
+     , hspec, lens, mtl, optparse-applicative, parsec, process
+     , resourcet, safe-exceptions, text
      }:
      mkDerivation {
        pname = "haskell-debug-adapter";
-       version = "0.0.41.0";
-       sha256 = "0w8hfaq9xndkjvxqyn6cbd7v4sh6wqw4b25xm24iy4r820zbyr1i";
+       version = "0.0.42.0";
+       sha256 = "0clchd6mfc71a5k8gzdb0kmdwimidlr9amf9ic65h68f1darzd0d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson async base bytestring Cabal clock conduit conduit-extra
-         containers data-default directory filepath ghci-dap haskell-dap
-         hslogger lens mtl optparse-applicative parsec process resourcet
-         safe-exceptions text
+         containers data-default directory filepath fsnotify ghci-dap
+         haskell-dap hie-bios hslogger lens mtl optparse-applicative parsec
+         process resourcet safe-exceptions text
        ];
        executableHaskellDepends = [
          aeson async base bytestring Cabal clock conduit conduit-extra
-         containers data-default directory filepath ghci-dap haskell-dap
-         hslogger lens mtl optparse-applicative parsec process resourcet
-         safe-exceptions text
+         containers data-default directory filepath fsnotify ghci-dap
+         haskell-dap hie-bios hslogger lens mtl optparse-applicative parsec
+         process resourcet safe-exceptions text
        ];
        testHaskellDepends = [
          aeson async base bytestring Cabal clock conduit conduit-extra
-         containers data-default directory filepath ghci-dap haskell-dap
-         hslogger hspec lens mtl optparse-applicative parsec process
-         resourcet safe-exceptions text
+         containers data-default directory filepath fsnotify ghci-dap
+         haskell-dap hie-bios hslogger hspec lens mtl optparse-applicative
+         parsec process resourcet safe-exceptions text
        ];
        description = "Haskell Debug Adapter";
        license = lib.licenses.bsd3;
···
 
   "haskell-language-server" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, apply-refact, array, async
-     , base, binary, bytestring, Cabal-syntax, containers, data-default
-     , deepseq, Diff, directory, dlist, enummapset, extra, filepath
-     , floskell, foldl, fourmolu, fuzzy, ghc, ghc-boot, ghc-boot-th
-     , ghc-exactprint, ghc-lib-parser, ghc-lib-parser-ex, ghcide
-     , githash, hashable, hie-bios, hie-compat, hiedb, hlint, hls-graph
-     , hls-plugin-api, hls-test-utils, hp2pretty, implicit-hie, lens
-     , lens-aeson, list-t, lsp, lsp-test, lsp-types, megaparsec, mod
-     , monoid-subclasses, mtl, network-uri, optparse-applicative
-     , optparse-simple, ormolu, parser-combinators, prettyprinter
-     , process, process-extras, QuickCheck, random, refact
-     , regex-applicative, regex-tdfa, retrie, row-types, safe-exceptions
-     , semigroupoids, shake, shake-bench, sqlite-simple, stan, stm
-     , stm-containers, stylish-haskell, syb, tasty
-     , tasty-expected-failure, tasty-hunit, tasty-quickcheck
-     , tasty-rerun, template-haskell, temporary, text, text-rope, time
-     , transformers, trial, unix, unliftio, unliftio-core
-     , unordered-containers, vector, yaml
+     , base, binary, bytestring, Cabal, cabal-add, Cabal-syntax
+     , containers, data-default, deepseq, Diff, directory, dlist
+     , enummapset, eventlog2html, extra, filepath, floskell, foldl
+     , fourmolu, fuzzy, ghc, ghc-boot, ghc-boot-th, ghc-exactprint
+     , ghc-lib-parser, ghc-lib-parser-ex, ghcide, githash, hashable
+     , hie-bios, hie-compat, hiedb, hlint, hls-graph, hls-plugin-api
+     , hls-test-utils, implicit-hie, lens, lens-aeson, list-t, lsp
+     , lsp-test, lsp-types, megaparsec, mod, monoid-subclasses, mtl
+     , network-uri, optparse-applicative, optparse-simple, ormolu
+     , parser-combinators, pretty, prettyprinter, process
+     , process-extras, QuickCheck, random, refact, regex-applicative
+     , regex-tdfa, retrie, row-types, safe-exceptions, semigroupoids
+     , shake, shake-bench, sqlite-simple, stan, stm, stm-containers
+     , stylish-haskell, syb, tasty, tasty-expected-failure, tasty-hunit
+     , tasty-quickcheck, tasty-rerun, template-haskell, temporary, text
+     , text-rope, time, transformers, trial, unix, unliftio
+     , unliftio-core, unordered-containers, vector, yaml
      }:
      mkDerivation {
        pname = "haskell-language-server";
-       version = "2.9.0.0";
-       sha256 = "171wn5nv42h00f2l6mcmdhf4vybmifkdk2ycz0v02vksd99h42fj";
+       version = "2.10.0.0";
+       sha256 = "1h1w40y03lwkwzhl4bz0xvk2fdvzxq3gzx0xjkqv0bghmnkmz3fn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-pretty apply-refact array async base binary bytestring
-         Cabal-syntax containers data-default deepseq Diff directory dlist
-         extra filepath floskell foldl fourmolu fuzzy ghc ghc-boot
-         ghc-boot-th ghc-exactprint ghc-lib-parser ghc-lib-parser-ex ghcide
-         githash hashable hie-bios hie-compat hiedb hlint hls-graph
-         hls-plugin-api hls-test-utils lens lsp lsp-test lsp-types
-         megaparsec mod mtl optparse-applicative optparse-simple ormolu
-         parser-combinators prettyprinter process process-extras refact
-         regex-applicative regex-tdfa retrie row-types safe-exceptions
-         semigroupoids shake sqlite-simple stan stm stm-containers
-         stylish-haskell syb template-haskell temporary text text-rope time
-         transformers trial unliftio unliftio-core unordered-containers
-         vector yaml
+         Cabal cabal-add Cabal-syntax containers data-default deepseq Diff
+         directory dlist extra filepath floskell foldl fourmolu fuzzy ghc
+         ghc-boot ghc-boot-th ghc-exactprint ghc-lib-parser
+         ghc-lib-parser-ex ghcide githash hashable hie-bios hie-compat hiedb
+         hlint hls-graph hls-plugin-api hls-test-utils lens lens-aeson lsp
+         lsp-test lsp-types megaparsec mod mtl optparse-applicative
+         optparse-simple ormolu parser-combinators pretty prettyprinter
+         process process-extras refact regex-applicative regex-tdfa retrie
+         row-types safe-exceptions semigroupoids shake sqlite-simple stan
+         stm stm-containers stylish-haskell syb template-haskell temporary
+         text text-rope time transformers trial unliftio unliftio-core
+         unordered-containers vector yaml
        ];
        executableHaskellDepends = [
          aeson base bytestring containers data-default directory extra
···
          aeson base containers data-default directory extra filepath
          hls-plugin-api lens lens-aeson shake shake-bench text yaml
        ];
-       benchmarkToolDepends = [ hp2pretty ];
+       benchmarkToolDepends = [ eventlog2html ];
        doHaddock = false;
        description = "LSP server for GHC";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
···
        libraryHaskellDepends = [ base ];
        description = "A fully compliant Haskell 98 lexer";
        license = lib.licenses.mit;
+     }) {};
+
+  "haskell-lexer_1_2_1" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "haskell-lexer";
+       version = "1.2.1";
+       sha256 = "0h8s19j2flby3qrvb93j1d2lpjl1jgin8lj6dqpb7c86h59f2xlx";
+       libraryHaskellDepends = [ base ];
+       description = "A fully compliant Haskell 98 lexer";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "haskell-lsp" = callPackage
···
 
   "haskell-updater" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, directory
-     , filepath, process
+     , filepath, mtl, process
      }:
      mkDerivation {
        pname = "haskell-updater";
-       version = "1.4.1.0";
-       sha256 = "1f1fgj3xs9kgn1x44izcq0pnw4v9v5nr88d3zq9z1gbik8sqm62j";
+       version = "1.5.0.0";
+       sha256 = "12xhj9hrjrrz16pvy27lqlrzi3z3zzjpaqx4l61y6q4fwsyn7li2";
+       revision = "1";
+       editedCabalFile = "0pjh7v8957k93nffvsc9a6d69hz331i8kfj7yra28am2sxvclylm";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base bytestring Cabal containers directory filepath process
+         base bytestring Cabal containers directory filepath mtl process
        ];
        description = "Rebuild Haskell dependencies in Gentoo";
        license = lib.licenses.gpl3Plus;
···
        libraryHaskellDepends = [ base containers haskell98 SDL SDL-ttf ];
        description = "Haskell game library";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "haskheap" = callPackage
···
        executableHaskellDepends = [ base ];
        description = "Haskell Evaluation inside of LaTeX code";
        license = lib.licenses.bsd3;
+       mainProgram = "haskintex";
+     }) {};
+
+  "haskintex_0_8_0_3" = callPackage
+    ({ mkDerivation, base, binary, bytestring, containers, directory
+     , filepath, haskell-src-exts, HaTeX, hint, parsec, process, text
+     , transformers
+     }:
+     mkDerivation {
+       pname = "haskintex";
+       version = "0.8.0.3";
+       sha256 = "006zmd05ady3ndqwzn60a420g5qlj74783aadxphjd41qf272q54";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base binary bytestring containers directory filepath
+         haskell-src-exts HaTeX hint parsec process text transformers
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Haskell Evaluation inside of LaTeX code";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "haskintex";
      }) {};
 
···
        pname = "hasql-interpolate";
        version = "1.0.1.0";
        sha256 = "1i323wc17bw41rpdvn7kk46ipx42v0q0zp27662xgq3khbz52bsf";
-       revision = "2";
-       editedCabalFile = "0hn900mzkwjglw1ca2j7j8w40p64nw1pk6dnlngn8305bd28v57i";
+       revision = "3";
+       editedCabalFile = "0v10qdik81lik3x6bccjxfdadqjxv7ff1cxwgka23shir5mjf5v9";
        libraryHaskellDepends = [
          aeson array base bytestring containers haskell-src-meta hasql
          iproute megaparsec mtl scientific template-haskell text time
···
        pname = "hasql-listen-notify";
        version = "0.1.0.1";
        sha256 = "00pcbps2hdjd3i1xxsfgai81hgzc24cpj8n1iqg4xf7pd2c6cps4";
-       revision = "4";
-       editedCabalFile = "0k0pi42m36pssssn5y6bldfr9r9srr2jdgi9lh1fyr9gr89z2fva";
+       revision = "5";
+       editedCabalFile = "0ciaccvwc4i7c9yi5g7nlvsd4gvdbh29fdanl2sh40wdbh0d662y";
        libraryHaskellDepends = [
          base bytestring hasql mtl postgresql-libpq text
        ];
···
        ];
        description = "An example program that shows how to use Hasql streams with Rel8";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "hasql-streaming";
      }) {};
 
···
        pname = "hedgehog";
        version = "1.5";
        sha256 = "0sl6x9q9kyrpv73565w9na9dm10wzxdl0qgiraqarffynfgn0hg9";
-       revision = "1";
-       editedCabalFile = "0ch1cvljlnbshaik4vsfnb9qzypc1blxychz5yhivhc4h9lmgg7d";
+       revision = "2";
+       editedCabalFile = "1m0b9m8dw5nw4b3w1jbp5fd0b0kqlyvvy3qsfxc7md77iafxq169";
        libraryHaskellDepends = [
          ansi-terminal async barbies base bytestring concurrent-output
          containers deepseq directory erf exceptions lifted-async mmorph
···
        pname = "hedgehog-extras";
        version = "0.7.0.0";
        sha256 = "0dhkhai2q831fb8z9cyv065gdf0468x0sbns1np74v8qnzwbhgav";
+       revision = "1";
+       editedCabalFile = "1f8xc2dr158c3nppj4rny611vfli74fpggnx1s75ln846xq2yzkj";
        libraryHaskellDepends = [
          aeson aeson-pretty async base bytestring deepseq Diff directory
          exceptions filepath hedgehog http-conduit lifted-async lifted-base
···
        pname = "hedgehog-fakedata";
        version = "0.0.1.5";
        sha256 = "00k26d83v0646klrg0k3cf94r4fnnx3ykxv7i8shjjgbkbzlzz78";
-       revision = "1";
-       editedCabalFile = "0a4lc2pi391m2ss507hrpdvdg8pk300k14cpxwmi3d5pz579w1fq";
+       revision = "2";
+       editedCabalFile = "1b8v4j8zkvdfx786nfxxdkxj57b2qh4p9h16wiy0kc3l1dsj6llm";
        libraryHaskellDepends = [ base fakedata hedgehog random ];
        testHaskellDepends = [ base containers fakedata hedgehog ];
        description = "Use 'fakedata' with 'hedgehog'";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hetero-parameter-list_0_1_0_21" = callPackage
+    ({ mkDerivation, base, data-default, template-haskell }:
+     mkDerivation {
+       pname = "hetero-parameter-list";
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+       sha256 = "10zx9hs7k1szbl100ba4s4bbjkjwvys7fsxidjc7pl72xi4zgygi";
+       libraryHaskellDepends = [ base data-default template-haskell ];
+       testHaskellDepends = [ base data-default template-haskell ];
+       description = "hetero list with parameter list";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hetero-parameter-list-with-typelevel-tools" = callPackage
     ({ mkDerivation, base, hetero-parameter-list, template-haskell
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
···
      }) {inherit (pkgs.darwin.apple_sdk.frameworks) Cocoa; 
          inherit (pkgs.darwin.apple_sdk.frameworks) CoreServices;};
 
+  "hfsevents_0_1_8" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, Cocoa, CoreServices, mtl
+     , text
+     }:
+     mkDerivation {
+       pname = "hfsevents";
+       version = "0.1.8";
+       sha256 = "0yvgdhq9258n84qiavqhb1prvb3bzq1zk5b5psgbnh5zd3p11r64";
+       libraryHaskellDepends = [ base bytestring cereal mtl text ];
+       librarySystemDepends = [ Cocoa ];
+       libraryToolDepends = [ CoreServices ];
+       description = "File/folder watching for OS X";
+       license = lib.licenses.bsd3;
+       platforms = lib.platforms.darwin;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs.darwin.apple_sdk.frameworks) Cocoa; 
+         inherit (pkgs.darwin.apple_sdk.frameworks) CoreServices;};
+
   "hfusion" = callPackage
     ({ mkDerivation, base, containers, haskell-src, mtl, pretty, syb }:
      mkDerivation {
···
        pname = "hinotify";
        version = "0.4.1";
        sha256 = "06pqfikfa61i45g92b65br83kplwmizqkm42yp8d0ddgmq0b21qk";
+       revision = "1";
+       editedCabalFile = "0nidpgp9p2dk1pifbkpkiibbm39asrz2j42s6sjn31nd9qqrgn1w";
        libraryHaskellDepends = [ async base bytestring containers unix ];
        testHaskellDepends = [ base bytestring directory unix ];
        description = "Haskell binding to inotify";
        license = lib.licenses.bsd3;
      }) {};
 
+  "hinotify_0_4_2" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, directory
+     , unix
+     }:
+     mkDerivation {
+       pname = "hinotify";
+       version = "0.4.2";
+       sha256 = "1h6hvy9zcwvp5ww592b9q9rs5v86dacq6r01k75mzjakmjbnzm57";
+       libraryHaskellDepends = [ async base bytestring containers unix ];
+       testHaskellDepends = [ base bytestring directory unix ];
+       description = "Haskell binding to inotify";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hinotify-bytestring" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory
      , posix-paths, unix, utf8-string
···
      }:
      mkDerivation {
        pname = "hix";
-       version = "0.7.2";
-       sha256 = "0n3sc5v8a7df4p4p4ch13alkv877djhbqz9qk3pb9pqvyhxy3xg6";
+       version = "0.8.0";
+       sha256 = "014rbcbg99zz9a5095avrpcqzdqarifha9jaw7hwcbpxlxs1i3jn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        mainProgram = "hkgr";
      }) {};
 
+  "hkgr_0_4_7" = callPackage
+    ({ mkDerivation, base, bytestring, directory, extra, filepath
+     , simple-cabal, simple-cmd, simple-cmd-args, simple-prompt
+     , typed-process, xdg-basedir
+     }:
+     mkDerivation {
+       pname = "hkgr";
+       version = "0.4.7";
+       sha256 = "0r01jbmbswldz9dld3k9wdsda352z9g9yls6l60r6dcxa1pah9p0";
+       isLibrary = false;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       executableHaskellDepends = [
+         base bytestring directory extra filepath simple-cabal simple-cmd
+         simple-cmd-args simple-prompt typed-process xdg-basedir
+       ];
+       description = "Simple Hackage release workflow for package maintainers";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hkgr";
+     }) {};
+
   "hkt" = callPackage
     ({ mkDerivation, base, hspec, inspection-testing, protolude, text
      }:
···
        ];
      }) {};
 
-  "hledger_1_41" = callPackage
+  "hledger_1_42_1" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
      , containers, data-default, Decimal, Diff, directory, extra
      , filepath, githash, hashable, haskeline, hledger-lib, lucid
      , math-functions, megaparsec, microlens, modern-uri, mtl, process
      , regex-tdfa, safe, shakespeare, split, tabular, tasty, temporary
-     , terminfo, text, text-ansi, time, timeit, transformers
-     , unordered-containers, utf8-string, utility-ht, wizards
+     , text, text-ansi, time, timeit, transformers, unordered-containers
+     , utf8-string, utility-ht, wizards
      }:
      mkDerivation {
        pname = "hledger";
-       version = "1.41";
-       sha256 = "0ijl7yr6svnwvk6sxm4nq35crksla8ffn3mg2dz8ai9a9gycaslk";
+       version = "1.42.1";
+       sha256 = "0cw2v3ckg3b90d7xkq7mjwb1pr7z5js9qb3bm2i9mz7284aqzn3q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          Decimal Diff directory extra filepath githash hashable haskeline
          hledger-lib lucid math-functions megaparsec microlens modern-uri
          mtl process regex-tdfa safe shakespeare split tabular tasty
-         temporary terminfo text text-ansi time timeit transformers
+         temporary text text-ansi time timeit transformers
          unordered-containers utf8-string utility-ht wizards
        ];
        executableHaskellDepends = [
          aeson ansi-terminal base bytestring cmdargs containers data-default
          Decimal directory extra filepath githash haskeline hledger-lib
          math-functions megaparsec microlens mtl process regex-tdfa safe
-         shakespeare split tabular tasty temporary terminfo text text-ansi
-         time timeit transformers unordered-containers utf8-string
-         utility-ht wizards
+         shakespeare split tabular tasty temporary text text-ansi time
+         timeit transformers unordered-containers utf8-string utility-ht
+         wizards
        ];
        testHaskellDepends = [
          aeson ansi-terminal base bytestring cmdargs containers data-default
          Decimal directory extra filepath githash haskeline hledger-lib
          math-functions megaparsec microlens mtl process regex-tdfa safe
-         shakespeare split tabular tasty temporary terminfo text text-ansi
-         time timeit transformers unordered-containers utf8-string
-         utility-ht wizards
+         shakespeare split tabular tasty temporary text text-ansi time
+         timeit transformers unordered-containers utf8-string utility-ht
+         wizards
        ];
        description = "Command-line interface for the hledger accounting system";
        license = lib.licenses.gpl3Only;
···
        pname = "hledger-iadd";
        version = "1.3.21";
        sha256 = "00x0vbfp08kqs1nbknndk9h56hcidf6xnrk0ldz45dvjrmgcv3w2";
-       revision = "6";
-       editedCabalFile = "09df7fbwvgd8fgnkjadrimyjh60w1rj29pl1837c9jipjxip0hhx";
+       revision = "8";
+       editedCabalFile = "166vkhghms83x0c03m6kg6v5fx3x8wyr445zjy6vxfsbni6ks4h7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hledger-interest";
        version = "1.6.7";
        sha256 = "1jirygghw82zi8z160j45qzfcj1l89vckqr7hrv78h3f3pim6np4";
+       revision = "1";
+       editedCabalFile = "1hl3vgwhlk15xrhafmp5y017cm4y7zkn2n8l9frsc0xz67h9571z";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.gpl3Only;
      }) {};
 
-  "hledger-lib_1_41" = callPackage
+  "hledger-lib_1_42_1" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array, base
      , base-compat, blaze-html, blaze-markup, bytestring, call-stack
      , cassava, cassava-megaparsec, cmdargs, colour, containers
      , data-default, Decimal, deepseq, directory, doclayout, doctest
-     , extra, file-embed, filepath, Glob, hashtables, lucid, megaparsec
-     , microlens, microlens-th, mtl, parser-combinators, pretty-simple
-     , process, regex-tdfa, safe, tabular, tasty, tasty-hunit
-     , template-haskell, terminal-size, text, time, timeit, transformers
-     , uglymemo, unordered-containers, utf8-string
+     , encoding, extra, file-embed, filepath, Glob, hashtables, lucid
+     , megaparsec, microlens, microlens-th, mtl, parser-combinators
+     , pretty-simple, process, regex-tdfa, safe, tabular, tasty
+     , tasty-hunit, template-haskell, terminal-size, text, time, timeit
+     , transformers, uglymemo, unordered-containers, utf8-string
      }:
      mkDerivation {
        pname = "hledger-lib";
-       version = "1.41";
-       sha256 = "1lzqd1jfvgrnmf0jr48nxf779a8cskqd49ira9whb0k5dah4shqw";
+       version = "1.42.1";
+       sha256 = "0c59vxi9w809vhw0gzpkl8iv0qbd6wv5xq6lvllxz0y7axkw7vnl";
        libraryHaskellDepends = [
          aeson aeson-pretty ansi-terminal array base base-compat blaze-html
          blaze-markup bytestring call-stack cassava cassava-megaparsec
          cmdargs colour containers data-default Decimal deepseq directory
-         doclayout extra file-embed filepath Glob hashtables lucid
+         doclayout encoding extra file-embed filepath Glob hashtables lucid
          megaparsec microlens microlens-th mtl parser-combinators
          pretty-simple process regex-tdfa safe tabular tasty tasty-hunit
          template-haskell terminal-size text time timeit transformers
···
          aeson aeson-pretty ansi-terminal array base base-compat blaze-html
          blaze-markup bytestring call-stack cassava cassava-megaparsec
          cmdargs colour containers data-default Decimal deepseq directory
-         doclayout doctest extra file-embed filepath Glob hashtables lucid
-         megaparsec microlens microlens-th mtl parser-combinators
-         pretty-simple process regex-tdfa safe tabular tasty tasty-hunit
-         template-haskell terminal-size text time timeit transformers
-         uglymemo unordered-containers utf8-string
+         doclayout doctest encoding extra file-embed filepath Glob
+         hashtables lucid megaparsec microlens microlens-th mtl
+         parser-combinators pretty-simple process regex-tdfa safe tabular
+         tasty tasty-hunit template-haskell terminal-size text time timeit
+         transformers uglymemo unordered-containers utf8-string
        ];
        description = "A library providing the core functionality of hledger";
        license = lib.licenses.gpl3Only;
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "hledger-ui_1_41" = callPackage
+  "hledger-ui_1_42_1" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, brick, cmdargs
      , containers, data-default, directory, doclayout, extra, filepath
      , fsnotify, githash, hledger, hledger-lib, megaparsec, microlens
···
      }:
      mkDerivation {
        pname = "hledger-ui";
-       version = "1.41";
-       sha256 = "01bzqx26ycz7xp4y3rvrglnf0dasr3b0yhhrmmfnp1x2h18hhsjz";
-       revision = "1";
-       editedCabalFile = "1y1ad5xymjlspk7253yw3wj6vvba16ym9a066ybjib9dfbiq434d";
+       version = "1.42.1";
+       sha256 = "1grj5j2lndyxzbfbr9mp29qy2l4gs7pcqgbmrkdb2l8qcdm83nwm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "hledger-web_1_41" = callPackage
+  "hledger-web_1_42_1" = callPackage
     ({ mkDerivation, aeson, base, base-compat, base64, blaze-html
      , blaze-markup, bytestring, case-insensitive, clientsession
      , cmdargs, conduit, conduit-extra, containers, data-default
···
      }:
      mkDerivation {
        pname = "hledger-web";
-       version = "1.41";
-       sha256 = "0z9q8c6xfkz3i819v12ks21rb4r0c225ba1a6w0h3hk06a11dinw";
+       version = "1.42.1";
+       sha256 = "13z1fzvfdacdcaabhc68ic93rbh2kw983nhcm7jzkipnp559lvnj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "hlrdb" = callPackage
-    ({ mkDerivation, base, base64, bytestring, cryptonite, hashable
-     , hedis, hlrdb-core, memory, random, store, time
-     , unordered-containers, zstd
+    ({ mkDerivation, base, base64, bytestring, cryptohash-md5, hashable
+     , hedis, hlrdb-core, random, store, time, unordered-containers
+     , zstd
      }:
      mkDerivation {
        pname = "hlrdb";
-       version = "0.4.0.0";
-       sha256 = "0cj2ff40n3v171xhvdips3als1f2x91ksxcqm7i570mwkdgbh1jr";
-       revision = "2";
-       editedCabalFile = "0yfd3l9hiplva8dp4l21pfqycswbwgvy9588gmm3h71dnr6md1sg";
+       version = "0.5.0.0";
+       sha256 = "19m4k0w8gd3p5khjy9pqjdy0mgmgibg66dxc1vw187yppl9d82an";
        libraryHaskellDepends = [
-         base base64 bytestring cryptonite hashable hedis hlrdb-core memory
+         base base64 bytestring cryptohash-md5 hashable hedis hlrdb-core
          random store time unordered-containers zstd
        ];
        description = "High-level Redis Database";
···
      }:
      mkDerivation {
        pname = "hls-graph";
-       version = "2.9.0.0";
-       sha256 = "19ifqsw6bfqy969icbgyl46ss178wjn37dfhrh6ch3k6pa3lz73l";
+       version = "2.10.0.0";
+       sha256 = "1q2ix901k3b0a05nax5lcrqnjllm6zvv63lh027mmrhg976vl0l2";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson async base bytestring containers deepseq directory exceptions
···
      }:
      mkDerivation {
        pname = "hls-plugin-api";
-       version = "2.9.0.0";
-       sha256 = "0s0yd66cbazifxqqsyw05rdwc88kbx9q434ihlzgw72mkn0pvcm0";
+       version = "2.10.0.0";
+       sha256 = "1xl2vh9jsydjsw6faij5w5amplz6qmgjadc5rp9ffl4lnd1fvvl6";
        libraryHaskellDepends = [
          aeson base co-log-core containers data-default dependent-map
          dependent-sum Diff dlist extra filepath ghc hashable hls-graph
···
      }:
      mkDerivation {
        pname = "hls-test-utils";
-       version = "2.9.0.0";
-       sha256 = "0xj7hfpa6yl4v0ysbd7abkpax5y4hj0pfhzb40wp0qp5x6prsgw7";
+       version = "2.10.0.0";
+       sha256 = "0kzqri1xslvi699gm2nasvs3zygk0y06w3x9mppksrgfs5961p0z";
        libraryHaskellDepends = [
          aeson async base bytestring containers data-default directory extra
          filepath ghcide hls-plugin-api lens lsp lsp-test lsp-types
···
      }) {inherit (pkgs) ncurses;};
 
   "hmp3-ng" = callPackage
-    ({ mkDerivation, array, base, binary, bytestring, clock, containers
+    ({ mkDerivation, array, base, bytestring, clock, containers
      , directory, filepath, hscurses, mtl, ncurses, pcre-light, process
-     , random, unix, utf8-string, zlib
+     , random, unix, utf8-string
      }:
      mkDerivation {
        pname = "hmp3-ng";
-       version = "2.15.1";
-       sha256 = "055pcj9b3s5l1lgm6kv2b4irkglqn8zjm3q4fklb7ljdgb1bg4ps";
+       version = "2.16.0";
+       sha256 = "0xhvq6jfj6argpqvbqjy784cpb75lgkmlxmamngwq44knz58pp2q";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         array base binary bytestring clock containers directory filepath
-         hscurses mtl pcre-light process random unix utf8-string zlib
+         array base bytestring clock containers directory filepath hscurses
+         mtl pcre-light process random unix utf8-string
        ];
        executableSystemDepends = [ ncurses ];
        description = "A 2019 fork of an ncurses mp3 player written in Haskell";
···
        license = lib.licenses.mit;
      }) {};
 
-  "hoauth2_2_14_2" = callPackage
-    ({ mkDerivation, aeson, base, base64, binary, bytestring
-     , containers, crypton, data-default, exceptions, hspec
+  "hoauth2_2_14_3" = callPackage
+    ({ mkDerivation, aeson, base, base64, binary, binary-instances
+     , bytestring, containers, crypton, data-default, exceptions, hspec
      , hspec-discover, http-conduit, http-types, memory, microlens, text
      , transformers, uri-bytestring, uri-bytestring-aeson
      }:
      mkDerivation {
        pname = "hoauth2";
-       version = "2.14.2";
-       sha256 = "08zra8svxrg43kzdnh882bnqjplz7zvbd9yp1p996skjz0mnzydv";
+       version = "2.14.3";
+       sha256 = "09y6s36kap2c7wwv1snrhxmgsr0p93w5ghh873q1fq8inn5iwj2w";
        libraryHaskellDepends = [
-         aeson base base64 binary bytestring containers crypton data-default
-         exceptions http-conduit http-types memory microlens text
-         transformers uri-bytestring uri-bytestring-aeson
+         aeson base base64 binary binary-instances bytestring containers
+         crypton data-default exceptions http-conduit http-types memory
+         microlens text transformers uri-bytestring uri-bytestring-aeson
        ];
-       testHaskellDepends = [ aeson base hspec uri-bytestring ];
+       testHaskellDepends = [ aeson base binary hspec uri-bytestring ];
        testToolDepends = [ hspec-discover ];
        description = "Haskell OAuth2 authentication client";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "holidays";
-       version = "0.1.0.0";
-       sha256 = "19x05ipca9aiynjrnfxlr3swcf2971gbqn5sy3dpr91m612skrc1";
+       version = "0.2.0.0";
+       sha256 = "1nxhmpn54q58k4wldlbfnvniwdf914bxyz6bnqdsrnmdmhvrh8cf";
        libraryHaskellDepends = [ base containers text time ];
        testHaskellDepends = [
          base containers tasty tasty-hunit tasty-quickcheck text time
···
      }:
      mkDerivation {
        pname = "hopenpgp-tools";
-       version = "0.23.10";
-       sha256 = "0aaf0k26i5zjnijhnyng7jyhx6qdq2fdzq4idlmj3va386rfm2as";
+       version = "0.23.11";
+       sha256 = "0kx5i26nfnpa0acba4gyv8nz1zpr35ldb59wmkvy1bya439nn19a";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hotel-california";
-       version = "0.0.6.0";
-       sha256 = "1fhlzikap5yiw8h3hk0wag7l2f56bx23xz90l2bqy4nrik6mlxvd";
+       version = "0.0.6.1";
+       sha256 = "0gldbm7aj6wi1r913i70ms0cmxqgi2q1hm0m2vsj7dcnk56i10ck";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hpack";
        version = "0.38.0";
        sha256 = "0iysz3xnxhjj49hjz9gv56awaldamrbidkiw0xd873g5yfyhyljp";
+       revision = "1";
+       editedCabalFile = "02pqfqqijvr2z3ki2rnb9nlavhzm59qbbvhq89bfdvhcicfgmmf4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "hpke" = callPackage
+    ({ mkDerivation, base, base16-bytestring, bytestring, crypton
+     , hspec, hspec-discover, memory, QuickCheck
+     }:
+     mkDerivation {
+       pname = "hpke";
+       version = "0.0.0";
+       sha256 = "0g5q37gj5aqb35zp84fb0p706g1zvyrhrjy4ajmvx0bh9zxps2vv";
+       libraryHaskellDepends = [
+         base base16-bytestring bytestring crypton memory
+       ];
+       testHaskellDepends = [
+         base base16-bytestring bytestring hspec QuickCheck
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Hybrid Public Key Encryption";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "hplayground" = callPackage
     ({ mkDerivation, base, containers, data-default, haste-compiler
      , haste-perch, monads-tf, transformers
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "hpqtypes-extras_1_17_0_1" = callPackage
+    ({ mkDerivation, base, base16-bytestring, bytestring, containers
+     , crypton, deepseq, exceptions, extra, hpqtypes, log-base, memory
+     , mtl, tasty, tasty-bench, tasty-hunit, text, text-show, uuid-types
+     }:
+     mkDerivation {
+       pname = "hpqtypes-extras";
+       version = "1.17.0.1";
+       sha256 = "1f2ipf4hwp3iqfb79bbx8h97l1cy8vyc1w5h0q1fvg2yvxl52szp";
+       libraryHaskellDepends = [
+         base base16-bytestring bytestring containers crypton exceptions
+         extra hpqtypes log-base memory mtl text text-show
+       ];
+       testHaskellDepends = [
+         base containers exceptions hpqtypes log-base tasty tasty-hunit text
+         uuid-types
+       ];
+       benchmarkHaskellDepends = [ base deepseq tasty-bench ];
+       description = "Extra utilities for hpqtypes library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hprotoc" = callPackage
     ({ mkDerivation, alex, array, base, binary, bytestring, containers
      , directory, filepath, haskell-src-exts, mtl, parsec
···
      }) {};
 
   "hs-highlight" = callPackage
-    ({ mkDerivation, base, bytestring, hspec }:
+    ({ mkDerivation, base, hspec }:
      mkDerivation {
        pname = "hs-highlight";
-       version = "1.0.3";
-       sha256 = "0m6x96v5h2xdw618y5ljp0cpy52np8lvd126sp7mqfqr318vx51x";
+       version = "1.0.4";
+       sha256 = "051plpzpnsazffxny1m48jw4s7ky8n6cx933lk45vpsirxnfpd9r";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ base bytestring ];
+       libraryHaskellDepends = [ base ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        description = "A tool to highlight terminal strings";
···
        pname = "hs-opentelemetry-instrumentation-auto";
        version = "0.1.0.1";
        sha256 = "00qsmldcn20c5vsy617w0kcn4dw0l730n74bdrp2acv1jpppaa4v";
+       revision = "1";
+       editedCabalFile = "0paa6p9w4ryr35dandqna53p56jsv3cgkw3dcw4f66j0bgaw2jgw";
        libraryHaskellDepends = [
          base bytestring containers directory ghc hs-opentelemetry-api
          parsec text time toml-parser unliftio
···
      }:
      mkDerivation {
        pname = "hs-tango";
-       version = "2.0.0";
-       sha256 = "1d78icf12k7zj1v4gnms8ddfj1ji6kzcx0r1jws4cri0y4rzwdlk";
+       version = "2.0.1";
+       sha256 = "1qwcxn6zjg7sl6pdrspdgagpkq96vmh1kqjwj4bibc1cigccd0ls";
        libraryHaskellDepends = [ base derive-storable text unliftio ];
        libraryPkgconfigDepends = [ tango ];
        benchmarkHaskellDepends = [
···
        pname = "hsc2hs";
        version = "0.68.10";
        sha256 = "0xpgbi6pssnizazz54583c50cz4axq3h78g03q4sfb7yi3bk8kkg";
-       revision = "3";
-       editedCabalFile = "0ndpgzmq2h2kv7xr9iaf957jnnykbjpd6vlii0n2rkahfckjaqr7";
+       revision = "4";
+       editedCabalFile = "0gphymx87rjky73mxk6y656jxms5xrds7q2dvcrf7mnk0gdgcpkj";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hslogger_1_3_1_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, HUnit
+     , network, network-bsd, old-locale, time, unix
+     }:
+     mkDerivation {
+       pname = "hslogger";
+       version = "1.3.1.2";
+       sha256 = "0fa52jpigkvbmb006rzvairw1syh71wnb0lrfjb46ik3dwigxdh4";
+       libraryHaskellDepends = [
+         base bytestring containers deepseq network network-bsd old-locale
+         time unix
+       ];
+       testHaskellDepends = [ base HUnit ];
+       description = "Versatile logging framework";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hslogger-reader" = callPackage
     ({ mkDerivation, attoparsec, base, hslogger, optparse-applicative
      , text, text-icu, time
···
        ];
        description = "A SPARQL query generator and DSL, and a client to query a SPARQL server";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hspear" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "hspec_2_11_12" = callPackage
+    ({ mkDerivation, base, hspec-core, hspec-discover
+     , hspec-expectations, QuickCheck
+     }:
+     mkDerivation {
+       pname = "hspec";
+       version = "2.11.12";
+       sha256 = "1zdgkn0gkcphcsfqcqwcfqiqvkz12ljks46v3czpaysndz8icfip";
+       libraryHaskellDepends = [
+         base hspec-core hspec-discover hspec-expectations QuickCheck
+       ];
+       description = "A Testing Framework for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hspec-api" = callPackage
     ({ mkDerivation, base, hspec, hspec-core, hspec-discover
      , transformers
···
        testToolDepends = [ hspec-discover ];
        description = "A Testing Framework for Haskell";
        license = lib.licenses.mit;
+     }) {};
+
+  "hspec-api_2_11_12" = callPackage
+    ({ mkDerivation, base, hspec, hspec-core, hspec-discover
+     , transformers
+     }:
+     mkDerivation {
+       pname = "hspec-api";
+       version = "2.11.12";
+       sha256 = "1xn2b2hafyq6qm3zaia9nw27ir4cg8v2qn499bz2zwnp2vkjra07";
+       libraryHaskellDepends = [ base hspec-core transformers ];
+       testHaskellDepends = [ base hspec hspec-core transformers ];
+       testToolDepends = [ hspec-discover ];
+       description = "A Testing Framework for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hspec-attoparsec" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "hspec-core_2_11_12" = callPackage
+    ({ mkDerivation, ansi-terminal, array, base, base-orphans
+     , call-stack, containers, deepseq, directory, filepath
+     , haskell-lexer, hspec-expectations, hspec-meta, HUnit, process
+     , QuickCheck, quickcheck-io, random, silently, stm, temporary
+     , tf-random, time, transformers
+     }:
+     mkDerivation {
+       pname = "hspec-core";
+       version = "2.11.12";
+       sha256 = "030400w95775jrivbi7n1nnx6j5z717rqd3986ggklb8h9hjalfc";
+       libraryHaskellDepends = [
+         ansi-terminal array base call-stack containers deepseq directory
+         filepath haskell-lexer hspec-expectations HUnit process QuickCheck
+         quickcheck-io random stm tf-random time transformers
+       ];
+       testHaskellDepends = [
+         ansi-terminal array base base-orphans call-stack containers deepseq
+         directory filepath haskell-lexer hspec-expectations hspec-meta
+         HUnit process QuickCheck quickcheck-io random silently stm
+         temporary tf-random time transformers
+       ];
+       testToolDepends = [ hspec-meta ];
+       testFlags = [
+         "--skip"
+         "'Test.Hspec.Core.Runner.hspecResult runs specs in parallel'"
+       ];
+       description = "A Testing Framework for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hspec-dirstream" = callPackage
     ({ mkDerivation, base, dirstream, filepath, hspec, hspec-core
      , pipes, pipes-safe, system-filepath, text
···
        testToolDepends = [ hspec-meta ];
        description = "Automatically discover and run Hspec tests";
        license = lib.licenses.mit;
+       mainProgram = "hspec-discover";
+       maintainers = [ lib.maintainers.maralorn ];
+     }) {};
+
+  "hspec-discover_2_11_12" = callPackage
+    ({ mkDerivation, base, directory, filepath, hspec-meta, mockery
+     , QuickCheck
+     }:
+     mkDerivation {
+       pname = "hspec-discover";
+       version = "2.11.12";
+       sha256 = "044vgsy45ff00h9z2k3jgn2m37npcjiacc4cifahrjlmwa7a7ylp";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base directory filepath ];
+       executableHaskellDepends = [ base directory filepath ];
+       testHaskellDepends = [
+         base directory filepath hspec-meta mockery QuickCheck
+       ];
+       testToolDepends = [ hspec-meta ];
+       description = "Automatically discover and run Hspec tests";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "hspec-discover";
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
···
        mainProgram = "hspec-meta-discover";
      }) {};
 
+  "hspec-meta_2_11_12" = callPackage
+    ({ mkDerivation, ansi-terminal, array, base, call-stack, containers
+     , deepseq, directory, filepath, haskell-lexer, hspec-expectations
+     , HUnit, process, QuickCheck, quickcheck-io, random, stm, tf-random
+     , time, transformers
+     }:
+     mkDerivation {
+       pname = "hspec-meta";
+       version = "2.11.12";
+       sha256 = "1612pg5gihqjxrzqqvbbgckaqiwq3rmz3rg07lrjhzklg975nj69";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-terminal array base call-stack containers deepseq directory
+         filepath haskell-lexer hspec-expectations HUnit process QuickCheck
+         quickcheck-io random stm tf-random time transformers
+       ];
+       executableHaskellDepends = [
+         ansi-terminal array base call-stack containers deepseq directory
+         filepath haskell-lexer hspec-expectations HUnit process QuickCheck
+         quickcheck-io random stm tf-random time transformers
+       ];
+       description = "A version of Hspec which is used to test Hspec itself";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hspec-meta-discover";
+     }) {};
+
   "hspec-monad-control" = callPackage
     ({ mkDerivation, base, hspec-core, monad-control, transformers
      , transformers-base
···
      }) {};
 
   "hsrelp" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, network, network-bsd
-     , utf8-string
+    ({ mkDerivation, attoparsec, base, bytestring, crypton
+     , crypton-x509, crypton-x509-store, data-default, network
+     , network-bsd, network-simple-tls, tls, utf8-string
      }:
      mkDerivation {
        pname = "hsrelp";
-       version = "0.1.1.1";
-       sha256 = "1148m5jjfmcm21j5shwmv1x5zqypyz1vidpczx9k6fi0akany2k5";
+       version = "0.2.1.1";
+       sha256 = "0mcnswdx904z6hdb3h38x7vm97fhgik6n4jcdga7s4vnca6a0gs8";
        libraryHaskellDepends = [
-         attoparsec base bytestring network network-bsd utf8-string
+         attoparsec base bytestring crypton crypton-x509 crypton-x509-store
+         data-default network network-bsd network-simple-tls tls utf8-string
        ];
        description = "RELP (Reliable Event Logging Protocol) server implementation";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.mit;
      }) {};
 
+  "http-client_0_7_19" = callPackage
+    ({ mkDerivation, array, async, base, base64-bytestring
+     , blaze-builder, bytestring, case-insensitive, containers, cookie
+     , deepseq, directory, exceptions, filepath, ghc-prim, hspec
+     , hspec-discover, http-types, iproute, mime-types, monad-control
+     , network, network-uri, random, stm, streaming-commons, text, time
+     , transformers, zlib
+     }:
+     mkDerivation {
+       pname = "http-client";
+       version = "0.7.19";
+       sha256 = "0qdd547j4jz8h6a66hh97qwd9y05li40l5f7kaaqrx78hbh1nb50";
+       libraryHaskellDepends = [
+         array async base base64-bytestring blaze-builder bytestring
+         case-insensitive containers cookie deepseq exceptions filepath
+         ghc-prim http-types iproute mime-types network network-uri random
+         stm streaming-commons text time transformers
+       ];
+       testHaskellDepends = [
+         async base blaze-builder bytestring case-insensitive containers
+         cookie deepseq directory hspec http-types monad-control network
+         network-uri streaming-commons text time transformers zlib
+       ];
+       testToolDepends = [ hspec-discover ];
+       doCheck = false;
+       description = "An HTTP client engine";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "http-client-auth" = callPackage
     ({ mkDerivation, base, base64-string, blaze-builder, bytestring
      , case-insensitive, conduit, crypto-conduit, http-client
···
        pname = "http-client-tls";
        version = "0.3.6.4";
        sha256 = "18qqzif376hv5lqv1c7sp4b90mq5cyfhybip472j9fcaxrph0mkp";
+       revision = "2";
+       editedCabalFile = "1wqn9mjwsk5qgir5l1mj74p5k8zzpvkvdhdrbsiqx8y3b4ns7q7g";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers crypton
          crypton-connection data-default exceptions http-client http-types
···
        license = lib.licenses.publicDomain;
      }) {};
 
+  "http-link-header_1_2_2" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, criterion, directory
+     , errors, hspec, hspec-attoparsec, http-api-data, network-uri
+     , QuickCheck, text, transformers
+     }:
+     mkDerivation {
+       pname = "http-link-header";
+       version = "1.2.2";
+       sha256 = "1ix1k35x2cxzjvbywkpz8c0w6mmhp6hj235ch8rmc64lsff6x1hc";
+       libraryHaskellDepends = [
+         attoparsec base bytestring errors http-api-data network-uri text
+       ];
+       testHaskellDepends = [
+         attoparsec base bytestring errors hspec hspec-attoparsec
+         http-api-data network-uri QuickCheck text
+       ];
+       benchmarkHaskellDepends = [
+         attoparsec base bytestring criterion directory errors http-api-data
+         network-uri text transformers
+       ];
+       description = "HTTP Link header parser/writer";
+       license = lib.licenses.publicDomain;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "http-listen" = callPackage
     ({ mkDerivation, base, bytestring, exceptions, HTTP, network
      , transformers
···
      }:
      mkDerivation {
        pname = "hw-kafka-avro";
-       version = "6.0.2";
-       sha256 = "13lrmpglh31srd74a1ch68g723x08wns9sapmlckm1bzs6jj7s06";
+       version = "6.1.2";
+       sha256 = "1r7wn06qkczdvbr6ghyyjfpmn8w9ps1rwcr05ab2sdqjcxrw4rk6";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-prim";
        version = "0.6.3.2";
        sha256 = "07a442g1fjzrfnz3y9mx3d2hv0ffjnbfdkmbiard8bn78vf5z80z";
-       revision = "2";
-       editedCabalFile = "1mj60fg66piw96kbvp0v4ykr1ihww97rr96ya7ayx5sz49j2hyf0";
+       revision = "3";
+       editedCabalFile = "0q3bmdmwxh1xqwril6bxv8p67ys0p1znlvzis3akkvyiiddixs4w";
        libraryHaskellDepends = [
          base bytestring deepseq ghc-prim mmap transformers unliftio-core
          vector
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "hyphenation_0_8_3" = callPackage
+    ({ mkDerivation, base, bytestring, containers, file-embed, text
+     , unordered-containers, zlib
+     }:
+     mkDerivation {
+       pname = "hyphenation";
+       version = "0.8.3";
+       sha256 = "0dpq13l67pxa9xw1axhrz6w7dlb8bwf4lfm1r157s6jhkxb6h92p";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         base bytestring containers file-embed text unordered-containers
+         zlib
+       ];
+       description = "Configurable Knuth-Liang hyphenation";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hypher" = callPackage
     ({ mkDerivation, aeson, base, bytestring, Cabal, containers
      , data-default, hashable, HTTP, http-conduit, http-types, HUnit
···
      }) {};
 
   "if-instance" = callPackage
-    ({ mkDerivation, base, ghc, ghc-tcplugin-api }:
+    ({ mkDerivation, base, ghc, ghc-tcplugin-api, transformers }:
      mkDerivation {
        pname = "if-instance";
-       version = "0.5.2.0";
-       sha256 = "1mkfx0iivdivxlmcq4lxj2l736javvk7pyx7ja9yjmjw7zp8xpa2";
-       libraryHaskellDepends = [ base ghc ghc-tcplugin-api ];
+       version = "0.6.0.0";
+       sha256 = "1pjl4dg510dp6p23hjn1rii7pf444jqn9jy6wvy6x9m8b25j2nzr";
+       libraryHaskellDepends = [ base ghc ghc-tcplugin-api transformers ];
        testHaskellDepends = [ base ghc ];
        doHaddock = false;
        description = "Branch on whether a constraint is satisfied";
···
      }:
      mkDerivation {
        pname = "ihp-hsx";
-       version = "1.4.0";
-       sha256 = "1dgx0rzhh19ldwraa2yqd5ksv537irgjb9dp6x8jvmaxi0rx9g3z";
+       version = "1.4.1";
+       sha256 = "00pq72lzdnb8dbfpaacyw2jqwz5f54cdvrbyrapd4487m2jhjc9q";
        libraryHaskellDepends = [
          base blaze-html blaze-markup bytestring containers ghc megaparsec
          string-conversions template-haskell text unordered-containers
···
      }:
      mkDerivation {
        pname = "incipit";
-       version = "0.10.0.0";
-       sha256 = "0464gn50ayfd61n2xzcdrg36vmzls3j6bi2w7113iqzbl8q8gz6j";
+       version = "0.10.0.1";
+       sha256 = "063inazql7pa5mmx0nxs3407lqlwylqmvz7d1pihzr9gynrczfds";
+       revision = "1";
+       editedCabalFile = "0ikaxbga3jrga24fknjfhkiwxi1xj5i0nyba2vl9bb7il4bkf0bf";
        libraryHaskellDepends = [
          base incipit-core polysemy-conc polysemy-log polysemy-resume
          polysemy-time
···
        license = "BSD-2-Clause-Patent";
      }) {};
 
+  "incipit-base_0_6_1_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, data-default, stm
+     , text
+     }:
+     mkDerivation {
+       pname = "incipit-base";
+       version = "0.6.1.1";
+       sha256 = "1cah83sqgwy3irkbl62rnsik5ag677nzw707ikzy862za9hg7v08";
+       libraryHaskellDepends = [
+         base bytestring containers data-default stm text
+       ];
+       description = "A Prelude for Polysemy – Base Reexports";
+       license = "BSD-2-Clause-Patent";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "incipit-core" = callPackage
     ({ mkDerivation, base, incipit-base, polysemy }:
      mkDerivation {
···
        license = "BSD-2-Clause-Patent";
      }) {};
 
+  "incipit-core_0_6_1_1" = callPackage
+    ({ mkDerivation, base, incipit-base, polysemy }:
+     mkDerivation {
+       pname = "incipit-core";
+       version = "0.6.1.1";
+       sha256 = "0kzw04m7dal5l5nx4wf5zwdli49rmlchvf2nhwdaw1wa40kx1jx6";
+       libraryHaskellDepends = [ base incipit-base polysemy ];
+       description = "A Prelude for Polysemy";
+       license = "BSD-2-Clause-Patent";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "include-env" = callPackage
     ({ mkDerivation, base, containers, template-haskell
      , th-lift-instances
···
      }:
      mkDerivation {
        pname = "inline-asm";
-       version = "0.5.0.2";
-       sha256 = "1qvr0p00zs0cxk1bj4bsd6dn7x6kqmmzmsd1jpi01fwks9kpy8d6";
+       version = "0.5.0.3";
+       sha256 = "04b9rhaijyzqv2san6yymbkihl5jggbskrmlvn02glcpkzb3xrxr";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "inline-python";
-       version = "0.1.1";
-       sha256 = "0siqxyzdxancw3m2kzbaak2dk2bzy3hbmqyv1jph9p2d80qqjlil";
+       version = "0.1.1.1";
+       sha256 = "169f3xa2v53h5pqkc6h34wswyl0y3311xq66jwshxh80ynp37nj3";
        libraryHaskellDepends = [
          base bytestring containers exceptions inline-c primitive process
          quickcheck-instances stm tasty tasty-hunit tasty-quickcheck
···
        pname = "invariant";
        version = "0.6.4";
        sha256 = "1cxfy1s3p91g5n1z85058lc27xy4xfl3dnkvxcxn3m70wd7apqm9";
+       revision = "1";
+       editedCabalFile = "1inib3bc400cghq70lqslw5a6v9cha05lkrvicayvzwk9sgn16ja";
        libraryHaskellDepends = [
          array base bifunctors comonad containers contravariant ghc-prim
          profunctors StateVar stm tagged template-haskell th-abstraction
···
        pname = "io-classes-mtl";
        version = "0.1.2.0";
        sha256 = "06lcz96rja31hk3229zxz9ip45c2xqr563kv66jc2f9zyjy7z8s7";
-       revision = "1";
-       editedCabalFile = "055spdxxq97dg60pbdz3ldc7zzdb8b0cf3frpagbz98cvx5mxfsf";
+       revision = "2";
+       editedCabalFile = "0zyg6vjl2wik8k8dswp5q08y39ajly8iisy18c94p24wi0xq1nkm";
        libraryHaskellDepends = [ array base io-classes mtl si-timers ];
        description = "Experimental MTL instances for io-classes";
        license = lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "ip2proxy";
-       version = "3.2.1";
-       sha256 = "10qqbwpwb3gr0g1nz8fm50f215y53l21i1szvv0zh62v20n4p6gz";
+       version = "3.3.0";
+       sha256 = "0634gb27s8g132vwq3qnnfwcrc5irls3h8cdin69d815adglpmfl";
        libraryHaskellDepends = [
          aeson base binary bytestring http-client http-client-tls http-types
          iproute uri-encode
···
      }:
      mkDerivation {
        pname = "itanium-abi";
-       version = "0.1.2";
-       sha256 = "0aafi7r2zxaknkjc5flg3qb6ixmwjlxcv18107b0ci2kggi11v1j";
+       version = "0.1.3";
+       sha256 = "12v0fyf4d5f5j48l24g2bpiadk8q0yypck7pvh5cj9xbd9338gjk";
        libraryHaskellDepends = [
          base boomerang exceptions text transformers unordered-containers
        ];
···
        pname = "jacinda";
        version = "3.3.0.3";
        sha256 = "1r3niy2zppimx0gn603x7gxwng11rn37776ddaa4vn0bvcy5spji";
+       revision = "1";
+       editedCabalFile = "1h4hqvv8bwbksgzmz77q0a3zdv3hwb5z01i748kzcqp2015fs6dp";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "javelin";
-       version = "0.1.4.1";
-       sha256 = "0sgwgfp04g5nx7l9y3jlnrgy4jdaisffa88vfi0ihjlnhxwbgh19";
+       version = "0.1.4.2";
+       sha256 = "09kld84lvi6lh5szd3n9kkykg78acwgn50h5qah7dmj9vlc7lch4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "javelin-frames";
-       version = "0.1.0.0";
-       sha256 = "10x0sphjgi8si1x0a61jla5jm19iyhwhgjb69cbycv675x0szpzv";
-       revision = "1";
-       editedCabalFile = "1sas9xgpsmc12azv18c4y0nkqniix220bghi51v6yyl3wl78cm4g";
+       version = "0.1.0.1";
+       sha256 = "1gw9db2jqwbnkyyxpd4wj238n34c6vd7psr909wi918d79mmlc2g";
        libraryHaskellDepends = [
          base containers these vector vector-algorithms
        ];
···
      }:
      mkDerivation {
        pname = "javelin-io";
-       version = "0.1.1.2";
-       sha256 = "1s6hg07rykc0wh1bqf455532hqwphanhnxpm6ggj5pb1xjksd81q";
+       version = "0.1.1.3";
+       sha256 = "1gjc5134m6c2sddmjifkr1cxy75k76qc9ilsjgvxp88iirgid0bp";
        libraryHaskellDepends = [
          base bytestring cassava containers javelin unordered-containers
          vector
···
        pname = "jsaddle";
        version = "0.9.9.2";
        sha256 = "0xifxq1mfx1wxcsy23h9lsq8qpnccrzq6v9qk7zfnj43ljfv9mav";
+       revision = "1";
+       editedCabalFile = "0jq5xmaw6kvz3dmq8gzhgnhhzii7i5z5igq7gam3fim9qf050wwy";
        libraryHaskellDepends = [
          aeson attoparsec base base-compat base64-bytestring bytestring
          containers deepseq exceptions filepath ghc-prim http-types lens
···
     ({ mkDerivation, base, bytestring, jsaddle }:
      mkDerivation {
        pname = "jsaddle-wasm";
-       version = "0.0.1.0";
-       sha256 = "1cv0a2nw3y429qa0hb9fv4ddhggf3w8wqawkv3gs981f7np0sg2s";
-       revision = "1";
-       editedCabalFile = "06yp4l533cgfggk05raww5n0w55l75241b1k89sx3dhk46abl7x0";
+       version = "0.1.0.0";
+       sha256 = "1z98xwraw46czjv03b6bywljqg6cli8755qzjys9cxd07biilfxh";
        libraryHaskellDepends = [ base bytestring jsaddle ];
        doHaddock = false;
-       description = "Run JSaddle JSM with the GHC WASM backend";
+       description = "Run JSaddle JSM with the GHC Wasm backend";
        license = lib.licenses.cc0;
      }) {};
 
···
        license = lib.licenses.mit;
      }) {};
 
+  "json-spec-elm-servant_0_4_4_0" = callPackage
+    ({ mkDerivation, aeson, base, binary, bound, bytestring, containers
+     , cookie, directory, elm-syntax, filepath, hspec, http-types
+     , json-spec, json-spec-elm, mtl, prettyprinter, process, servant
+     , text, time, unordered-containers, uuid
+     }:
+     mkDerivation {
+       pname = "json-spec-elm-servant";
+       version = "0.4.4.0";
+       sha256 = "0gg7658hb9nvk2s6qny53xs2brj2797rp5n69h66r2wwlxlrf6l9";
+       libraryHaskellDepends = [
+         base bound containers directory elm-syntax filepath http-types
+         json-spec json-spec-elm mtl prettyprinter process servant text
+         unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson base binary bound bytestring containers cookie directory
+         elm-syntax filepath hspec http-types json-spec json-spec-elm mtl
+         prettyprinter process servant text time unordered-containers uuid
+       ];
+       description = "Generated elm code for servant APIs";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "json-spec-openapi" = callPackage
     ({ mkDerivation, aeson, base, hspec, insert-ordered-containers
      , json-spec, lens, openapi3, text, time
···
        license = lib.licenses.mit;
      }) {};
 
+  "json-spec-openapi_1_0_1_0" = callPackage
+    ({ mkDerivation, aeson, base, hspec, insert-ordered-containers
+     , json-spec, lens, openapi3, text, time
+     }:
+     mkDerivation {
+       pname = "json-spec-openapi";
+       version = "1.0.1.0";
+       sha256 = "1hq9sbb94qkaakvhrxnmvwxkw9mgdyq5krxfjasg4yl3ic4f0alk";
+       libraryHaskellDepends = [
+         aeson base insert-ordered-containers json-spec lens openapi3 text
+       ];
+       testHaskellDepends = [
+         aeson base hspec insert-ordered-containers json-spec lens openapi3
+         text time
+       ];
+       description = "json-spec-openapi";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "json-state" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, libgit
      , time-units
···
        pname = "kan-extensions";
        version = "5.2.6";
        sha256 = "1k7cxqj9hl1b4axlw5903hrxh4vg5rdrzjmpa44xrhws3hy2i0ps";
+       revision = "1";
+       editedCabalFile = "0cq87wbjx4zppyxamqqcy2hsahs3n3k23qnp6q7lrh5303wp5fg0";
        libraryHaskellDepends = [
          adjunctions array base comonad containers contravariant
          distributive free invariant mtl profunctors semigroupoids tagged
···
        pname = "kansas-comet";
        version = "0.4.3";
        sha256 = "0c4nm5ns5acg73biysww8jam1v4kj1k9rk96bl6ad5g2nria7hlp";
-       revision = "1";
-       editedCabalFile = "1317m9sscnp3f3rmn39i7dhnz7kgqhbll71fsxw6ag1ppmipwh9x";
+       revision = "2";
+       editedCabalFile = "1mhk8gfvkmlg49p7z4fp791rlw2hnrawfw2v3abcjv2af190zi6x";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base containers data-default-class scotty stm text time
···
        mainProgram = "keter";
      }) {};
 
+  "keter_2_1_9" = callPackage
+    ({ mkDerivation, aeson, array, async, attoparsec, base
+     , blaze-builder, bytestring, case-insensitive, conduit
+     , conduit-extra, containers, directory, fast-logger, filepath
+     , fsnotify, http-client, http-conduit, http-reverse-proxy
+     , http-types, HUnit, indexed-traversable, lens, lifted-base
+     , monad-logger, mtl, network, optparse-applicative, process, random
+     , regex-tdfa, stm, tar, tasty, tasty-hunit, template-haskell, text
+     , time, tls, tls-session-manager, transformers, unix, unix-compat
+     , unliftio-core, unordered-containers, vector, wai, wai-app-static
+     , wai-extra, warp, warp-tls, wreq, yaml, zlib
+     }:
+     mkDerivation {
+       pname = "keter";
+       version = "2.1.9";
+       sha256 = "06kn3xrzpqnlynzq12b511r0dqr8dinvbq8fliqvjrn5cyyl9sk5";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson array async attoparsec base blaze-builder bytestring
+         case-insensitive conduit conduit-extra containers directory
+         fast-logger filepath fsnotify http-client http-conduit
+         http-reverse-proxy http-types indexed-traversable lifted-base
+         monad-logger mtl network optparse-applicative process random
+         regex-tdfa stm tar template-haskell text time tls
+         tls-session-manager transformers unix unix-compat unliftio-core
+         unordered-containers vector wai wai-app-static wai-extra warp
+         warp-tls yaml zlib
+       ];
+       executableHaskellDepends = [ base filepath ];
+       testHaskellDepends = [
+         base bytestring conduit http-client http-conduit http-types HUnit
+         lens monad-logger mtl stm tasty tasty-hunit transformers unix wai
+         warp wreq
+       ];
+       description = "Web application deployment manager, focusing on Haskell web frameworks. It mitigates downtime.";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "keter";
+     }) {};
+
   "keuringsdienst" = callPackage
     ({ mkDerivation, aeson, base, containers, HUnit, text }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "keyed-vals_0_2_3_2" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, http-api-data
+     , redis-glob, text
+     }:
+     mkDerivation {
+       pname = "keyed-vals";
+       version = "0.2.3.2";
+       sha256 = "1jszp5zagnqjwspglb466lq3k2hfdgaizrp4av7lyy26vbg0gia8";
+       libraryHaskellDepends = [
+         aeson base bytestring containers http-api-data redis-glob text
+       ];
+       description = "An abstract Handle for accessing collections in stores like Redis";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "keyed-vals-hspec-tests" = callPackage
     ({ mkDerivation, aeson, base, benri-hspec, bytestring, containers
      , hspec, http-api-data, keyed-vals, text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "keyed-vals-hspec-tests_0_2_3_2" = callPackage
+    ({ mkDerivation, aeson, base, benri-hspec, bytestring, containers
+     , hspec, http-api-data, keyed-vals, text
+     }:
+     mkDerivation {
+       pname = "keyed-vals-hspec-tests";
+       version = "0.2.3.2";
+       sha256 = "1cab5cj8d4vl47j1dqpvinw8vh9c62dznk2fdz9swm5cl9p0fwpx";
+       libraryHaskellDepends = [
+         aeson base benri-hspec bytestring containers hspec http-api-data
+         keyed-vals text
+       ];
+       description = "Validate a keyed-vals Handle";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "keyed-vals-mem" = callPackage
     ({ mkDerivation, base, bytestring, containers, hspec, keyed-vals
      , keyed-vals-hspec-tests, text, unliftio, unliftio-core
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "keyed-vals-mem_0_2_3_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hspec, keyed-vals
+     , keyed-vals-hspec-tests, text, unliftio, unliftio-core
+     }:
+     mkDerivation {
+       pname = "keyed-vals-mem";
+       version = "0.2.3.2";
+       sha256 = "0vqbanny1vsjjb5wsvrzxk47nz11n5dck77f42bsk0sirvgzs973";
+       libraryHaskellDepends = [
+         base bytestring containers keyed-vals text unliftio unliftio-core
+       ];
+       testHaskellDepends = [ base hspec keyed-vals-hspec-tests ];
+       description = "Implements a keyed-vals Handle using in-process memory";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "keyed-vals-redis" = callPackage
     ({ mkDerivation, base, bytestring, containers, hedis, hspec
      , hspec-tmp-proc, keyed-vals, keyed-vals-hspec-tests, QuickCheck
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "keyed-vals-redis_0_2_3_2" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hedis, hspec
+     , hspec-tmp-proc, keyed-vals, keyed-vals-hspec-tests, QuickCheck
+     , read-env-var, text, tmp-proc-redis, unliftio, unliftio-core
+     }:
+     mkDerivation {
+       pname = "keyed-vals-redis";
+       version = "0.2.3.2";
+       sha256 = "1bfs8rhvsfbkxvxa1awqywmhdwnfc224vskjd66ngm26ix8bplj0";
+       libraryHaskellDepends = [
+         base bytestring containers hedis keyed-vals read-env-var text
+         unliftio unliftio-core
+       ];
+       testHaskellDepends = [
+         base bytestring hspec hspec-tmp-proc keyed-vals-hspec-tests
+         QuickCheck text tmp-proc-redis
+       ];
+       description = "Access Redis using a keyed-vals Handle";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "keylayouts" = callPackage
     ({ mkDerivation, base, bytestring, containers, text, xeno }:
      mkDerivation {
···
        pname = "keys";
        version = "3.12.4";
        sha256 = "04l9ssmns3v2xzfrk5pxcacvl8nh26rsw5hhw22v4zxzbh9s44ll";
+       revision = "1";
+       editedCabalFile = "05ma1kakwvvm618fmlwhkz16230w3qsn3p10c3zjysjhn1g0hhyf";
        libraryHaskellDepends = [
          array base comonad containers free hashable semigroupoids
          semigroups tagged transformers transformers-compat
···
        pname = "ki";
        version = "1.0.1.2";
        sha256 = "167cak6krbgpni3dakzg4jrv1v0mgips5pg10dh2fl2d0jskrckk";
-       revision = "1";
-       editedCabalFile = "0cjgmiv41mjlzbz2c8v7vq1ni79vxp68r7f69almymmlfkhfnr2z";
+       revision = "2";
+       editedCabalFile = "19d3a6pc0qnkic7kkazi8ci5y2vqam1kx18r9g2zmqyimnk5m7vg";
        libraryHaskellDepends = [ base containers int-supply ];
        testHaskellDepends = [ base stm tasty tasty-hunit ];
        description = "A lightweight structured concurrency library";
···
        pname = "ki-unlifted";
        version = "1.0.0.2";
        sha256 = "11b4jm161znazwf2pn3qdn4dbz1g5a12dvhm03ddx6lrha7yv1xv";
-       revision = "2";
-       editedCabalFile = "0v5idgxn2rzh0xr0qi9pw8i2gg4b41wciy3pbdbhydh3qs28ak7p";
+       revision = "3";
+       editedCabalFile = "0w6fcxq04c1awpv87kw8i0w7hhkxfcl9x2ki4dvsj8fmrj9ii2z0";
        libraryHaskellDepends = [ base ki unliftio-core ];
        description = "A lightweight structured concurrency library";
        license = lib.licenses.bsd3;
···
        pname = "language-bluespec";
        version = "0.1";
        sha256 = "1an1w3sz0fj5w4gaf66fqyr471cijj1h11zmxs5247fa7vsdv167";
+       revision = "1";
+       editedCabalFile = "1khb3hhwa2y56slwcjmjaywg0clqq9agxspcp0ymk2r6kmadzn86";
        libraryHaskellDepends = [ base containers pretty text ];
        description = "An implementation of the Bluespec Haskell AST";
        license = lib.licenses.bsd3;
···
        pname = "language-c";
        version = "0.10.0";
        sha256 = "0m3dphd0r0n763a5rrg0z4fmiaqn7nkjq15l4vif332zrmgipb37";
+       revision = "1";
+       editedCabalFile = "1ffvpasi3yj59fffwdjx6c8wjby5pv42fmfzm7pisnpczmv5hsx6";
        libraryHaskellDepends = [
          array base bytestring containers deepseq directory filepath mtl
          pretty process
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "language-docker_14_0_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, data-default
+     , data-default-class, hspec, hspec-discover, hspec-megaparsec
+     , HUnit, megaparsec, prettyprinter, QuickCheck, split, text, time
+     }:
+     mkDerivation {
+       pname = "language-docker";
+       version = "14.0.1";
+       sha256 = "0xjbrislw9izq5n9lgimlmwyd46l7pnf9pa9nl49shmp5nsapjjm";
+       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
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Dockerfile parser, pretty-printer and embedded DSL";
+       license = lib.licenses.gpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "language-dockerfile" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory, filepath, free
      , Glob, hspec, HUnit, mtl, parsec, pretty, process, QuickCheck
···
        pname = "language-sygus";
        version = "0.1.1.3";
        sha256 = "15xxagcsqjchng2nr1qg6ncqch5l74m62iv58pgkcqhzqqhf3fwg";
-       revision = "2";
-       editedCabalFile = "0b1hlcj00rz1jlnfkp1wz6lsbkmahb07m6h7rbsmx3g1bqsp2j7s";
+       revision = "4";
+       editedCabalFile = "1mx9kn0p4r22asv1v0c7lwlcxc00194jnizyz2awdmm4r7nv1ycw";
        libraryHaskellDepends = [ array base hashable text ];
        libraryToolDepends = [ alex happy ];
        testHaskellDepends = [ base deepseq tasty tasty-hunit text ];
···
      }:
      mkDerivation {
        pname = "large-anon";
-       version = "0.3.1";
-       sha256 = "10wvhvmsknxmmg6rbalhp429849xp4q672ynj2kg4lz7qx45w87f";
+       version = "0.3.2";
+       sha256 = "0lj23kv7p9ax8gs7mgb37cq1x4jd3zmbz4v6fvvd1mwnkrjsnvvd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "large-generics";
        version = "0.2.2";
        sha256 = "1mvlyhna4s0997pzfkbhgg3v4l5fqj7rpx5nqjpgy7af5zp2mdgn";
+       revision = "1";
+       editedCabalFile = "1ly8qwzy3myvfsdp0dlgr80mnys6mi6b17xgh457r642qhig9cc4";
        libraryHaskellDepends = [
          aeson base deepseq generics-sop primitive sop-core
        ];
···
 
   "ldap-client-og" = callPackage
     ({ mkDerivation, asn1-encoding, asn1-types, async, base, bytestring
-     , connection, containers, hspec, ldap-client, network, process
-     , semigroups, stm, text
+     , containers, crypton-connection, hspec, hspec-discover, network
+     , process, semigroups, stm, text
      }:
      mkDerivation {
        pname = "ldap-client-og";
-       version = "0.3.0";
-       sha256 = "0sirs44j5lp0xc6c9h7qwd2wxqzcnvw06pfvwylx252j38yy4r9i";
+       version = "0.4.0";
+       sha256 = "06migywnmdd3d0cbkhs4y1v62wpa3p2s5pn5vgw269wyhxq3ph4a";
        libraryHaskellDepends = [
-         asn1-encoding asn1-types async base bytestring connection
-         containers network semigroups stm text
-       ];
-       testHaskellDepends = [
-         base bytestring hspec ldap-client process semigroups
+         asn1-encoding asn1-types async base bytestring containers
+         crypton-connection network semigroups stm text
        ];
+       testHaskellDepends = [ base bytestring hspec process semigroups ];
+       testToolDepends = [ hspec-discover ];
        description = "Pure Haskell LDAP Client Library";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ldap-scim-bridge" = callPackage
···
        ];
        description = "LEB128 and SLEB128 encoding";
        license = lib.licenses.mit;
-       maintainers = [ lib.maintainers.nomeata ];
      }) {};
 
   "leetify" = callPackage
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "lens_5_3_4" = callPackage
+    ({ mkDerivation, array, assoc, base, base-orphans, bifunctors
+     , bytestring, call-stack, comonad, containers, contravariant
+     , criterion, deepseq, distributive, exceptions, filepath, free
+     , generic-deriving, ghc-prim, hashable, HUnit, indexed-traversable
+     , indexed-traversable-instances, kan-extensions, mtl, parallel
+     , profunctors, QuickCheck, reflection, semigroupoids
+     , simple-reflect, strict, tagged, template-haskell, test-framework
+     , test-framework-hunit, test-framework-quickcheck2, text
+     , th-abstraction, these, transformers, transformers-compat
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "lens";
+       version = "5.3.4";
+       sha256 = "12n8jdwlpa5lcp2yi26a4fwncn1v1lyznaa9fasszk6qp0afvdpi";
+       libraryHaskellDepends = [
+         array assoc base base-orphans bifunctors bytestring call-stack
+         comonad containers contravariant distributive exceptions filepath
+         free ghc-prim hashable indexed-traversable
+         indexed-traversable-instances kan-extensions mtl parallel
+         profunctors reflection semigroupoids strict tagged template-haskell
+         text th-abstraction these transformers transformers-compat
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers deepseq HUnit mtl QuickCheck
+         simple-reflect test-framework test-framework-hunit
+         test-framework-quickcheck2 text transformers
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring comonad containers criterion deepseq
+         generic-deriving transformers unordered-containers vector
+       ];
+       description = "Lenses, Folds and Traversals";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lens-accelerate" = callPackage
     ({ mkDerivation, accelerate, base, lens }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "lens-toml-parser";
-       version = "0.3.0.1";
-       sha256 = "12bfjda8inn97azhkraz96lv3a1i21nxbxc4zsbpf1pfm76hripf";
+       version = "0.3.0.2";
+       sha256 = "15pbvd9r1b2pd0lhj9hr9kd5cxfvm68lmvzg4z2icfpjx1hdqf1y";
        libraryHaskellDepends = [ base profunctors text time toml-parser ];
        testHaskellDepends = [
          base containers dwergaz lens-family text toml-parser
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) leveldb;};
 
+  "leveldb-haskell_0_6_5_1" = callPackage
+    ({ mkDerivation, base, bytestring, data-default, directory
+     , exceptions, filepath, leveldb, mtl, QuickCheck, resourcet, tasty
+     , tasty-quickcheck, temporary, transformers
+     }:
+     mkDerivation {
+       pname = "leveldb-haskell";
+       version = "0.6.5.1";
+       sha256 = "09qnhznip6cxbskmsrc7rlibjf3s06l3d0g4lsv1hq1acp1b4rc6";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring data-default exceptions filepath resourcet
+         transformers
+       ];
+       librarySystemDepends = [ leveldb ];
+       testHaskellDepends = [
+         base bytestring data-default directory exceptions mtl QuickCheck
+         tasty tasty-quickcheck temporary transformers
+       ];
+       description = "Haskell bindings to LevelDB";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) leveldb;};
+
   "leveldb-haskell-fork" = callPackage
     ({ mkDerivation, base, bytestring, data-default, filepath, hspec
      , hspec-expectations, leveldb, mtl, process, QuickCheck, resourcet
···
        pname = "libsystemd-journal";
        version = "1.4.6.0";
        sha256 = "0wxf56i9mv6fm40rwzawbf829z73r4x7jchgardl770dg5zmy9yb";
+       revision = "2";
+       editedCabalFile = "0y4i59d0n5zdj3504xs6hksxzr75f784n4g4nyq1y2m4iy4ay1p4";
        libraryHaskellDepends = [
          base bytestring hashable hsyslog pipes pipes-safe semigroups text
          transformers uniplate unix-bytestring unordered-containers uuid
···
        pname = "lift-generics";
        version = "0.3";
        sha256 = "1walsrpschxg2bqw925z6cr24cznrcq04bb37azvwdcfrbl19r7a";
-       revision = "1";
-       editedCabalFile = "101rh63bgq9kwiqfzylijy28y9is6xfa13swscygr5jw3nm061mp";
+       revision = "2";
+       editedCabalFile = "1l90p9nwklklj95w00iavgf4ldgsr33c3w2vrb5gpcgigghvbmfy";
        libraryHaskellDepends = [
          base ghc-prim template-haskell th-compat
        ];
···
      }:
      mkDerivation {
        pname = "lifx-lan";
-       version = "0.8.3";
-       sha256 = "0077wdyrfz20lrd55lzv3bd1ab9cckppkm1gyzp1g23b8xwdayz5";
+       version = "0.8.4";
+       sha256 = "0b47pllqm0pcgpriyiq3iii4iw8r8x42k7yk41zc5nfrfj10q670";
        revision = "1";
-       editedCabalFile = "04956hhmg3cng3q4q26pbqy0lcrn5cv6wb57philixjsl4jlzrgp";
+       editedCabalFile = "0nl47djw1vb4ja5wdmiaxq6vld7c5hniadqs1l2f3989hg0js5lk";
        libraryHaskellDepends = [
          ansi-terminal base binary bytestring colour composition containers
          extra monad-loops mtl network random safe text time transformers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "linear_1_23_1" = callPackage
+    ({ mkDerivation, adjunctions, base, base-orphans, binary, bytes
+     , bytestring, cereal, containers, deepseq, distributive, ghc-prim
+     , hashable, HUnit, indexed-traversable, lens, QuickCheck, random
+     , reflection, semigroupoids, simple-reflect, tagged
+     , template-haskell, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, transformers, transformers-compat
+     , unordered-containers, vector, void
+     }:
+     mkDerivation {
+       pname = "linear";
+       version = "1.23.1";
+       sha256 = "0ybch2f4yc7mhxryr5f29i7j8ryq1i1n69fgldskxjrj825qkb3x";
+       libraryHaskellDepends = [
+         adjunctions base base-orphans binary bytes cereal containers
+         deepseq distributive ghc-prim hashable indexed-traversable lens
+         random reflection semigroupoids tagged template-haskell
+         transformers transformers-compat unordered-containers vector void
+       ];
+       testHaskellDepends = [
+         base binary bytestring deepseq HUnit QuickCheck reflection
+         simple-reflect test-framework test-framework-hunit
+         test-framework-quickcheck2 vector
+       ];
+       description = "Linear Algebra";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "linear-accelerate" = callPackage
     ({ mkDerivation, accelerate, base, Cabal, cabal-doctest
      , distributive, doctest, lens, linear
···
        pname = "linear-generics";
        version = "0.2.3";
        sha256 = "0093ywl8s8k92b50li28gcmqc616f6l7jkv7vslkvqzn42yrvbq2";
-       revision = "2";
-       editedCabalFile = "0qicg4wh00zph3dih63rkx97fbda4kdyp78xnra0589ry9axbxry";
+       revision = "3";
+       editedCabalFile = "1xg7v40hj38r5zqj65d3kjbzynp4vwh8fgwjsjw85lf11sl83kf8";
        libraryHaskellDepends = [
          base containers ghc-prim template-haskell th-abstraction
        ];
···
      }:
      mkDerivation {
        pname = "liquid-fixpoint";
-       version = "0.9.6.3.1";
-       sha256 = "1lad9s2slvbz0msdk43554h73zhw8cxcbj7fnj2nbj0rni8q0i0i";
+       version = "0.9.6.3.3";
+       sha256 = "07dpgi5iwi1kf182vpcy5h3xq3bjxsvp16ayafbr0wv8wxg6l5ib";
        configureFlags = [ "-fbuild-external" ];
        isLibrary = true;
        isExecutable = true;
···
      }:
      mkDerivation {
        pname = "liquid-prelude";
-       version = "0.9.2.8.2";
-       sha256 = "0ldap73vg5qxw9fh2mmfinhg78wpqf8nnpd4kd7abpxlpmni8d3r";
+       version = "0.9.10.1.2";
+       sha256 = "07a9zpp3q2albipasag02jjzcws9fcz40cja6za1555n9qhqzy96";
        setupHaskellDepends = [ base Cabal liquidhaskell-boot ];
        libraryHaskellDepends = [
          base bytestring containers ghc-prim liquidhaskell
···
      }) {};
 
   "liquidhaskell" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, containers, ghc-bignum
-     , ghc-internal, ghc-prim, liquidhaskell-boot, z3
+    ({ mkDerivation, base, bytestring, Cabal, containers, ghc-prim
+     , liquidhaskell-boot, z3
      }:
      mkDerivation {
        pname = "liquidhaskell";
-       version = "0.9.10.1";
-       sha256 = "1r3syj0c2v8x3xd2bqywf8f596r9mnf85mr2r9xvfxxd6dlmyz85";
+       version = "0.9.12.2";
+       sha256 = "1my8qsky01ksd7j5f4pfk17n9rf7aii2x43g6yrl5qc46d85bpms";
        setupHaskellDepends = [ base Cabal liquidhaskell-boot ];
        libraryHaskellDepends = [
-         base bytestring containers ghc-bignum ghc-internal ghc-prim
-         liquidhaskell-boot
+         base bytestring containers ghc-prim liquidhaskell-boot
        ];
        testSystemDepends = [ z3 ];
        description = "Liquid Types for Haskell";
···
      }) {inherit (pkgs) z3;};
 
   "liquidhaskell-boot" = callPackage
-    ({ mkDerivation, aeson, base, binary, bytestring, Cabal, cereal
-     , cmdargs, containers, data-default, data-fix, deepseq, Diff
-     , directory, exceptions, extra, filepath, fingertree, free, ghc
-     , ghc-boot, ghc-internal, ghc-paths, ghc-prim, githash, gitrev
-     , hashable, hscolour, liquid-fixpoint, megaparsec, mtl
-     , optparse-applicative, pretty, recursion-schemes, split, syb
-     , tasty, tasty-ant-xml, tasty-hunit, template-haskell, temporary
-     , text, th-compat, time, transformers, unordered-containers, vector
+    ({ mkDerivation, aeson, array, base, binary, bytestring, Cabal
+     , cereal, cmdargs, containers, deepseq, Diff, directory, exceptions
+     , extra, filepath, fingertree, free, ghc, ghc-boot, ghc-internal
+     , ghc-paths, ghc-prim, githash, gitrev, hashable, hscolour
+     , liquid-fixpoint, megaparsec, mtl, optparse-applicative, pretty
+     , split, syb, tasty, tasty-ant-xml, tasty-hunit, template-haskell
+     , temporary, text, th-compat, time, transformers
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "liquidhaskell-boot";
-       version = "0.9.10.1";
-       sha256 = "11dl8lsw0wqacfjhvs03ymrsv2gxfkgjv5mbp30vmd0c3gb34fgl";
+       version = "0.9.12.2";
+       sha256 = "1gfphzqpj36valrmsbwijac12nr5b3fkgfxbkgq8dlws983hbadr";
        libraryHaskellDepends = [
-         aeson base binary bytestring Cabal cereal cmdargs containers
-         data-default data-fix deepseq Diff directory exceptions extra
-         filepath fingertree free ghc ghc-boot ghc-prim githash gitrev
-         hashable hscolour liquid-fixpoint megaparsec mtl
-         optparse-applicative pretty recursion-schemes split syb
-         template-haskell temporary text th-compat time transformers
+         aeson array base binary bytestring Cabal cereal cmdargs containers
+         deepseq Diff directory exceptions extra filepath fingertree free
+         ghc ghc-boot ghc-prim githash gitrev hashable hscolour
+         liquid-fixpoint megaparsec mtl optparse-applicative pretty split
+         syb template-haskell temporary text th-compat time transformers
          unordered-containers vector
        ];
        testHaskellDepends = [
···
        pname = "list-shuffle";
        version = "1.0.0.1";
        sha256 = "1qcgkkhwnbrl729va8zgv5k6b4lpfy15bbkqnnx0nqz0d91xiqcr";
-       revision = "2";
-       editedCabalFile = "14qkn3kyxnlwhniqhgh7m6d4lym729ci9z1h1536bycd4cajxr32";
+       revision = "3";
+       editedCabalFile = "0hk8js5b59xr23fq58f9zp179cjcysnwaadsagz05jk3877vqzsw";
        libraryHaskellDepends = [ base primitive random ];
        testHaskellDepends = [ base hedgehog random ];
        benchmarkHaskellDepends = [ base deepseq random tasty-bench ];
···
      }:
      mkDerivation {
        pname = "llvm-pretty";
-       version = "0.12.1.0";
-       sha256 = "113avpn33gyh65yd0bbfwni044ih5vcbnv8l43siy8a4asp0xfwi";
-       revision = "1";
-       editedCabalFile = "0b7k8br3m9jb3zsh983zb7a2x85jn1z2dxxisc7jhjzvhb3xd9my";
+       version = "0.13.0.0";
+       sha256 = "02r2n4yyjxjppk8b2zsk63iznv3gaw3bpb8cz0h8vb88h0836ycx";
        libraryHaskellDepends = [
          base containers microlens microlens-th monadLib parsec pretty syb
          template-haskell th-abstraction
···
      }:
      mkDerivation {
        pname = "llvm-pretty-bc-parser";
-       version = "0.4.2.0";
-       sha256 = "1y0wvczlrmx990c9i697vy30bpl7109k9psxpldd3857cadmkmdi";
+       version = "0.5.0.0";
+       sha256 = "02aj89dhrh9fswfqnsvxh68xkwlmf52pzbm90kq0mcr0b5a3qvff";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "lock-file";
        version = "0.7.0.0";
        sha256 = "1vpaw3hh1as00p9vbj90cyd8nhjimgyp9hn8axgiwc1l47ddp6vc";
+       revision = "1";
+       editedCabalFile = "12hyv3djqasc765ihmw8r2p9n1c1r9yyh9fh9mffw7ng1nrqfph9";
        libraryHaskellDepends = [
          base data-default-class directory exceptions
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "logging_3_0_6" = callPackage
+    ({ mkDerivation, base, binary, bytestring, fast-logger, hspec
+     , lifted-base, monad-control, old-locale, regex-compat, text, time
+     , time-locale-compat, transformers, unix
+     }:
+     mkDerivation {
+       pname = "logging";
+       version = "3.0.6";
+       sha256 = "15l1dykvr4xhipnsglxjl9i5kp7bhr1wn3pczqhc42jdqn92g3m5";
+       libraryHaskellDepends = [
+         base binary bytestring fast-logger lifted-base monad-control
+         old-locale regex-compat text time time-locale-compat transformers
+       ];
+       testHaskellDepends = [ base hspec unix ];
+       description = "Simplified logging in IO for application writers";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "logging-effect" = callPackage
     ({ mkDerivation, async, base, bytestring, criterion, exceptions
      , fast-logger, free, lifted-async, monad-control, monad-logger, mtl
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "lucid_2_11_20250303" = callPackage
+    ({ mkDerivation, base, bifunctors, blaze-builder, bytestring
+     , containers, criterion, deepseq, hashable, hspec, HUnit, mmorph
+     , mtl, parsec, text, transformers
+     }:
+     mkDerivation {
+       pname = "lucid";
+       version = "2.11.20250303";
+       sha256 = "1x24nzfjrwqwn1pl8qk4zxd0rndlha79k3swykkrqm24x5bj7rmv";
+       libraryHaskellDepends = [
+         base blaze-builder bytestring containers hashable mmorph mtl text
+         transformers
+       ];
+       testHaskellDepends = [
+         base bifunctors hspec HUnit mtl parsec text
+       ];
+       benchmarkHaskellDepends = [
+         base blaze-builder bytestring criterion deepseq text transformers
+       ];
+       description = "Clear to write, read and edit DSL for HTML";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lucid-alpine" = callPackage
     ({ mkDerivation, base, lucid, text }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "lucid2_0_0_20250303" = callPackage
+    ({ mkDerivation, base, bifunctors, bytestring, containers, hspec
+     , HUnit, mtl, parsec, text, transformers
+     }:
+     mkDerivation {
+       pname = "lucid2";
+       version = "0.0.20250303";
+       sha256 = "09h6i531dp4sm1a9qr6y92ikbgb6zxjy960zylz30fb6jl3gx0la";
+       libraryHaskellDepends = [
+         base bytestring containers mtl text transformers
+       ];
+       testHaskellDepends = [
+         base bifunctors hspec HUnit mtl parsec text
+       ];
+       description = "Clear to write, read and edit DSL for HTML";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lucid2-htmx" = callPackage
     ({ mkDerivation, base, hspec, HUnit, lucid2, text }:
      mkDerivation {
···
        ];
        description = "Purely FunctionaL User Interface";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "luis-client" = callPackage
···
 
   "lz4-bytes" = callPackage
     ({ mkDerivation, base, byte-order, byteslice, primitive, run-st
-     , tasty, tasty-quickcheck
+     , tasty, tasty-hunit, tasty-quickcheck
      }:
      mkDerivation {
        pname = "lz4-bytes";
-       version = "0.1.1.1";
-       sha256 = "1caqm2c10l9030qj9sxfwh2sjq4npq97dmixakr3xg1ccsm2144x";
+       version = "0.1.2.0";
+       sha256 = "1jgsz96n7n7g4403w0h3zjvlhdh11vy4s7wqka0ppsikjjl7f1ni";
        libraryHaskellDepends = [
          base byte-order byteslice primitive run-st
        ];
        testHaskellDepends = [
-         base byteslice primitive tasty tasty-quickcheck
+         base byteslice primitive tasty tasty-hunit tasty-quickcheck
        ];
        description = "Bindings to LZ4";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "machines_0_7_4" = callPackage
+    ({ mkDerivation, adjunctions, base, comonad, conduit, containers
+     , criterion, distributive, mtl, pipes, pointed, profunctors
+     , semigroupoids, semigroups, streaming, transformers
+     , transformers-compat, void
+     }:
+     mkDerivation {
+       pname = "machines";
+       version = "0.7.4";
+       sha256 = "0bys6g1phz1i8059w950jh4j7d2pcryink8xb198a6z4rxzgxrmb";
+       libraryHaskellDepends = [
+         adjunctions base comonad containers distributive mtl pointed
+         profunctors semigroupoids semigroups transformers
+         transformers-compat void
+       ];
+       benchmarkHaskellDepends = [
+         base conduit criterion mtl pipes streaming
+       ];
+       description = "Networked stream transducers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "machines-amazonka" = callPackage
     ({ mkDerivation, amazonka, amazonka-autoscaling, amazonka-core
      , amazonka-ec2, amazonka-s3, amazonka-sts, base
···
        license = lib.licenses.mit;
      }) {};
 
+  "mailtrap_0_1_2_2" = callPackage
+    ({ mkDerivation, aeson, base, base64, blaze-html, bytestring
+     , email-validate, filepath, http-conduit, mime-types, text, time
+     , unordered-containers, uuid-types
+     }:
+     mkDerivation {
+       pname = "mailtrap";
+       version = "0.1.2.2";
+       sha256 = "13wqkr3q0jgm1c71h587wd90klfawdks7kjjmnbf8x15il4zlxvb";
+       libraryHaskellDepends = [
+         aeson base base64 blaze-html bytestring email-validate filepath
+         http-conduit mime-types text time unordered-containers uuid-types
+       ];
+       description = "Mailtrap API library";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "main-tester" = callPackage
     ({ mkDerivation, base, bytestring, directory, hspec, hspec-core
      , QuickCheck, text
···
      }:
      mkDerivation {
        pname = "mandrill";
-       version = "0.5.7.0";
-       sha256 = "13g07wlg9z1yci521f3y34i9lw24x5d4737k22s2rkajbrgdl98x";
+       version = "0.5.8.0";
+       sha256 = "06d83jkvpy5ds0ji86r9v47l3h5ag03b02n7lxbf2wrapsizpzwv";
        libraryHaskellDepends = [
          aeson base base64-bytestring blaze-html bytestring containers
          email-validate http-client http-client-tls http-types microlens-th
···
        pname = "matchable";
        version = "0.2";
        sha256 = "06k4bwckf4rpji11xky83gb0zrfbfggjf85l9kcz5yc3p1l909ma";
+       revision = "1";
+       editedCabalFile = "1g33lanj3sk5037db582pnva3yaqlr72fgd049l3y82ksw51ps1r";
        libraryHaskellDepends = [
          base base-orphans containers generically hashable tagged
          unordered-containers vector
···
        license = lib.licenses.mit;
      }) {};
 
+  "matrix_0_3_6_4" = callPackage
+    ({ mkDerivation, base, criterion, deepseq, loop, primitive
+     , QuickCheck, semigroups, tasty, tasty-quickcheck, vector
+     }:
+     mkDerivation {
+       pname = "matrix";
+       version = "0.3.6.4";
+       sha256 = "01845d364d0qdb55smrnv8v6kiigks7c2lxjsjgaiwgmay995i7q";
+       libraryHaskellDepends = [
+         base deepseq loop primitive semigroups vector
+       ];
+       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
+       benchmarkHaskellDepends = [ base criterion ];
+       description = "A native implementation of matrix operations";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "matrix-as-xyz" = callPackage
     ({ mkDerivation, base, doctest, hspec, matrix, parsec, QuickCheck
      }:
···
      }:
      mkDerivation {
        pname = "matterhorn";
-       version = "90000.0.1";
-       sha256 = "09zgjg6ymclxjbmlcrvwhd9nfjiqnx13ln52gvgk6wxkksdxb614";
+       version = "90000.1.0";
+       sha256 = "18miknhl4wk06845v2aqlis4z5br7zzz0fjg6ylc81abg38qnxrr";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "mbox-utility";
        version = "0.0.3.1";
        sha256 = "0vh9ibh4g3fssq9jfzrmaa56sk4k35r27lmz2xq4fhc62fmkia92";
-       revision = "2";
-       editedCabalFile = "185nnlv14ff0rmjbz5n4alrkgx376iy61wjyjhg0wdlagxa91z71";
+       revision = "3";
+       editedCabalFile = "10smxm3w0f8n0milq67vy1zlb7ikks1pb9bjnrk54b1wsgap5div";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "melf";
        version = "1.3.1";
        sha256 = "0ivfzsw36qy0m93h353r3963vmhirzg3a5mirqn1hfbsk24xf1dx";
-       revision = "2";
-       editedCabalFile = "0q822xj2z2xbdi8wk0dyny9k3lbpx6c3dmxrlimdnz43218x58rn";
+       revision = "3";
+       editedCabalFile = "0khbhf4v6rg1zshxsi94fphhrqlwf7n9hzccrb6fhlbl4fcdfz8n";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        mainProgram = "printmem";
      }) {};
 
+  "mem-info_0_4_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , fmt, genvalidity, genvalidity-hspec, genvalidity-text, hashable
+     , hspec, mtl, optparse-applicative, QuickCheck, temporary, text
+     , unix, validity, validity-text
+     }:
+     mkDerivation {
+       pname = "mem-info";
+       version = "0.4.1.0";
+       sha256 = "0613k5qil4j1cfh335gyjf708md9cicbhm5xji7v8fzfmzsqxx1c";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers directory filepath fmt hashable mtl
+         optparse-applicative text unix validity validity-text
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base containers directory filepath fmt genvalidity
+         genvalidity-hspec genvalidity-text hashable hspec
+         optparse-applicative QuickCheck temporary text unix
+       ];
+       description = "Print the core memory usage of programs";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "printmem";
+     }) {};
+
   "membership" = callPackage
     ({ mkDerivation, base, constraints, deepseq, hashable
      , prettyprinter, template-haskell, th-lift
···
        hydraPlatforms = lib.platforms.none;
        mainProgram = "memis";
        broken = true;
+     }) {};
+
+  "memo-map" = callPackage
+    ({ mkDerivation, base, containers, markdown-unlit, unliftio }:
+     mkDerivation {
+       pname = "memo-map";
+       version = "0.0.0.0";
+       sha256 = "0sk4cvsv7zwds9r2z3iqsah13xbihw7hggix16qixdfmzrl1lvdx";
+       libraryHaskellDepends = [ base containers unliftio ];
+       testHaskellDepends = [ base markdown-unlit ];
+       testToolDepends = [ markdown-unlit ];
+       description = "Memoization in a Map";
+       license = lib.licenses.mit;
      }) {};
 
   "memo-ptr" = callPackage
···
        pname = "microaeson";
        version = "0.1.0.2";
        sha256 = "025vnzs4j2nmkin5x8h5hbrj25spamqppg68wfqlnbrr1519lxfz";
+       revision = "1";
+       editedCabalFile = "1faq5mjz8jy739lbaizy1v5wrvkxsjzp6lhjmb06a3yv71h6m594";
        libraryHaskellDepends = [
          array base bytestring containers deepseq fail text
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "microlens_0_4_14_0" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "microlens";
+       version = "0.4.14.0";
+       sha256 = "0blj96kbgf0vivc8pv0gpvlaljxcffvxqm6zvr5n7c2g7rhjlyan";
+       libraryHaskellDepends = [ base ];
+       description = "A tiny lens library with no dependencies";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "microlens-aeson" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, bytestring, hashable
      , microlens, scientific, tasty, tasty-hunit, text, vector
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "microlens-ghc_0_4_15_1" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, microlens
+     , transformers
+     }:
+     mkDerivation {
+       pname = "microlens-ghc";
+       version = "0.4.15.1";
+       sha256 = "0xdhlby2ygjdiwnmpd1d3rr74qv7syq356f6mmq3zj607ikkbv86";
+       libraryHaskellDepends = [
+         array base bytestring containers microlens transformers
+       ];
+       description = "microlens + array, bytestring, containers, transformers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "microlens-mtl" = callPackage
     ({ mkDerivation, base, microlens, mtl, transformers
      , transformers-compat
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "microlens-mtl_0_2_1_0" = callPackage
+    ({ mkDerivation, base, microlens, mtl, transformers
+     , transformers-compat
+     }:
+     mkDerivation {
+       pname = "microlens-mtl";
+       version = "0.2.1.0";
+       sha256 = "13w4fx1kslm8yy5liwrw59y47nq773bxmv3nwg7k79gjw5r9rmzv";
+       libraryHaskellDepends = [
+         base microlens mtl transformers transformers-compat
+       ];
+       description = "microlens support for Reader/Writer/State from mtl";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "microlens-platform" = callPackage
     ({ mkDerivation, base, hashable, microlens, microlens-ghc
      , microlens-mtl, microlens-th, text, unordered-containers, vector
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "microlens-platform_0_4_4_1" = callPackage
+    ({ mkDerivation, base, hashable, microlens, microlens-ghc
+     , microlens-mtl, microlens-th, text, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "microlens-platform";
+       version = "0.4.4.1";
+       sha256 = "0d37rzskqr94grq75a00wgwlz8wrm6awxjw0r396hwwjl8abwipm";
+       libraryHaskellDepends = [
+         base hashable microlens microlens-ghc microlens-mtl microlens-th
+         text unordered-containers vector
+       ];
+       description = "microlens + all batteries included (best for apps)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "microlens-pro" = callPackage
     ({ mkDerivation, base, containers, microlens, microlens-contra
      , microlens-platform, microlens-th, mtl, profunctors, tagged
···
      }:
      mkDerivation {
        pname = "microlens-pro";
-       version = "0.2.0.2";
-       sha256 = "1n4qfv55xax420zy4g9xwh8sq3mmmcybblx80iw5kigsmvhs6kdm";
+       version = "0.2.0.4";
+       sha256 = "099ynp1winji1jn08dqayywliwk9midccfsv13cakhrdnbps8zj3";
        libraryHaskellDepends = [
          base containers microlens microlens-contra microlens-platform
          microlens-th mtl profunctors tagged template-haskell text
···
        testHaskellDepends = [ base microlens tagged ];
        description = "Automatic generation of record lenses for microlens";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "microlens-th_0_4_3_17" = callPackage
+    ({ mkDerivation, base, containers, microlens, tagged
+     , template-haskell, th-abstraction, transformers
+     }:
+     mkDerivation {
+       pname = "microlens-th";
+       version = "0.4.3.17";
+       sha256 = "150a9kgab4l6324dkf9vpvgbwarw89xfhcdhdj8awcm3gh12qxhx";
+       libraryHaskellDepends = [
+         base containers microlens template-haskell th-abstraction
+         transformers
+       ];
+       testHaskellDepends = [ base microlens tagged ];
+       description = "Automatic generation of record lenses for microlens";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "micrologger" = callPackage
···
      }:
      mkDerivation {
        pname = "minici";
-       version = "0.1.4";
-       sha256 = "1w0ngai1amkgl4k30y812b9rqhxlcbxw9r155842x8afs2bslhym";
+       version = "0.1.6";
+       sha256 = "0ljr1wx46ijxrw39cv34a07p642f7693lppnvwpnan9pfaibq670";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.mit;
      }) {};
 
+  "monad-logger_0_3_42" = 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.42";
+       sha256 = "042h2bmgzl2jjcnqbb6nj64kpwgzik0spx11ks5gb89asin488v6";
+       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
···
      }:
      mkDerivation {
        pname = "monad-logger-syslog";
-       version = "0.1.6.0";
-       sha256 = "1n4r0fl043r18683ym3k03sdm3b9wlxfzjgmnxi804kwna639rj3";
-       revision = "1";
-       editedCabalFile = "0177m5h891s49yv924c5yqbfninc6x298vbpmx3fri6cychamgbl";
+       version = "0.1.6.1";
+       sha256 = "110xnqanbagf21p6d39dy5s94bfk63bkjm42nmqj4fd3a6hslkhr";
        libraryHaskellDepends = [
          base bytestring fast-logger hsyslog monad-logger text transformers
        ];
···
        ];
        description = "A new, simple, composable concurrency abstraction";
        license = lib.licenses.mit;
+       maintainers = [ lib.maintainers.turion ];
+     }) {};
+
+  "monad-schedule_0_2_0_2" = callPackage
+    ({ mkDerivation, base, base-compat, free, generic-arbitrary, HUnit
+     , operational, QuickCheck, stm, test-framework
+     , test-framework-hunit, test-framework-quickcheck2, time
+     , time-domain, transformers
+     }:
+     mkDerivation {
+       pname = "monad-schedule";
+       version = "0.2.0.2";
+       sha256 = "12kp17zbc7y3m8nb89b235s0w31f67mz1jcbni3dkpzahn1k8681";
+       libraryHaskellDepends = [
+         base base-compat free operational stm time-domain transformers
+       ];
+       testHaskellDepends = [
+         base base-compat free generic-arbitrary HUnit operational
+         QuickCheck stm test-framework test-framework-hunit
+         test-framework-quickcheck2 time time-domain transformers
+       ];
+       description = "A new, simple, composable concurrency abstraction";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.turion ];
      }) {};
 
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "monoid-extras_0_6_4" = callPackage
+  "monoid-extras_0_6_5" = callPackage
     ({ mkDerivation, base, criterion, groups, semigroupoids, semigroups
      }:
      mkDerivation {
        pname = "monoid-extras";
-       version = "0.6.4";
-       sha256 = "19cjdacakp6n5c1kib9acw0vm2acrinmyhml5fp97a9macjll5am";
+       version = "0.6.5";
+       sha256 = "00snvxpah65dx14652dljfz8xyv1dijm38yhx81pjzz8qzsnk14f";
        libraryHaskellDepends = [ base groups semigroupoids ];
        benchmarkHaskellDepends = [ base criterion semigroups ];
        description = "Various extra monoid-related definitions and utilities";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "monoid-subclasses_1_2_6" = callPackage
+    ({ mkDerivation, base, bytestring, commutative-semigroups
+     , containers, primes, QuickCheck, quickcheck-instances, tasty
+     , tasty-quickcheck, text, vector
+     }:
+     mkDerivation {
+       pname = "monoid-subclasses";
+       version = "1.2.6";
+       sha256 = "0z7mcgph78qfzhn25vnjfzkf99i1b0ssja8ivb1iy7d6kgzamnp4";
+       libraryHaskellDepends = [
+         base bytestring commutative-semigroups containers primes text
+         vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers primes QuickCheck quickcheck-instances
+         tasty tasty-quickcheck text vector
+       ];
+       description = "Subclasses of Monoid";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "monoid-transformer" = callPackage
     ({ mkDerivation, base, semigroups }:
      mkDerivation {
···
        license = lib.licenses.asl20;
      }) {};
 
+  "monoidmap_0_0_4_4" = callPackage
+    ({ mkDerivation, base, containers, deepseq, groups
+     , monoid-subclasses, monoidmap-internal, nothunks
+     }:
+     mkDerivation {
+       pname = "monoidmap";
+       version = "0.0.4.4";
+       sha256 = "131lwh9dq1xzvsv2zcf4bp9k2y3hr4p548kw8zsds7wa38s6v0bw";
+       libraryHaskellDepends = [
+         base containers deepseq groups monoid-subclasses monoidmap-internal
+         nothunks
+       ];
+       description = "Monoidal map type";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "monoidmap-aeson" = callPackage
+    ({ mkDerivation, aeson, base, containers, hspec, hspec-discover
+     , hspec-golden-aeson, monoid-subclasses, monoidmap, QuickCheck
+     , quickcheck-classes, quickcheck-quid, text
+     }:
+     mkDerivation {
+       pname = "monoidmap-aeson";
+       version = "0.0.0.5";
+       sha256 = "1m5pw94lrybjvf6hnfzl0v974fg2i53r5s8aw4qv9cbxizhh68ag";
+       libraryHaskellDepends = [
+         aeson base containers monoid-subclasses monoidmap
+       ];
+       testHaskellDepends = [
+         aeson base containers hspec hspec-golden-aeson monoid-subclasses
+         monoidmap QuickCheck quickcheck-classes quickcheck-quid text
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "JSON support for monoidmap";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "monoidmap-examples" = callPackage
+    ({ mkDerivation, base, containers, hspec, hspec-discover
+     , monoid-subclasses, monoidmap, QuickCheck
+     }:
+     mkDerivation {
+       pname = "monoidmap-examples";
+       version = "0.0.0.0";
+       sha256 = "1pqswi2r41r7hrrzwg4ygj67jsgmmsyyqyn7n47lnf4q331l1hv6";
+       libraryHaskellDepends = [
+         base containers monoid-subclasses monoidmap
+       ];
+       testHaskellDepends = [ base containers hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
+       description = "Examples for monoidmap";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "monoidmap-internal" = callPackage
+    ({ mkDerivation, base, containers, deepseq, groups, hspec
+     , hspec-discover, monoid-subclasses, nothunks, pretty-show
+     , QuickCheck, quickcheck-classes, quickcheck-groups
+     , quickcheck-monoid-subclasses, quickcheck-quid, tasty-bench
+     , tasty-hunit, text
+     }:
+     mkDerivation {
+       pname = "monoidmap-internal";
+       version = "0.0.0.0";
+       sha256 = "0di3b4x4f5mkmi71rpfa0zv5048z4hkzzdy1zw1qla46sn1646jg";
+       libraryHaskellDepends = [
+         base containers deepseq groups monoid-subclasses nothunks
+       ];
+       testHaskellDepends = [
+         base containers groups hspec monoid-subclasses pretty-show
+         QuickCheck quickcheck-classes quickcheck-groups
+         quickcheck-monoid-subclasses quickcheck-quid text
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base containers deepseq tasty-bench tasty-hunit
+       ];
+       description = "Internal support for monoidmap";
+       license = lib.licenses.asl20;
+     }) {};
+
+  "monoidmap-quickcheck" = callPackage
+    ({ mkDerivation, base, containers, monoid-subclasses, monoidmap
+     , QuickCheck
+     }:
+     mkDerivation {
+       pname = "monoidmap-quickcheck";
+       version = "0.0.0.2";
+       sha256 = "0sqgd61a6abwr7rdiqm25cs2kl496v8ji0rax9dw0sdc3zh6m4j2";
+       libraryHaskellDepends = [
+         base containers monoid-subclasses monoidmap QuickCheck
+       ];
+       description = "QuickCheck support for monoidmap";
+       license = lib.licenses.asl20;
+     }) {};
+
   "monoidplus" = callPackage
     ({ mkDerivation, base, contravariant, semigroups, transformers }:
      mkDerivation {
···
        pname = "multiset-comb";
        version = "0.2.4.2";
        sha256 = "0vgwahb6v1hm2vrlma3qv25xz2h2gq6dv4xwbngbkmvihx18r4rd";
+       revision = "1";
+       editedCabalFile = "1b2x259wjfrkcriw3ns9nz9acnl955cyxfsx1lmkqxiwhpf3zvw1";
        libraryHaskellDepends = [ base containers transformers ];
        description = "Combinatorial algorithms over multisets";
        license = lib.licenses.bsd3;
···
        mainProgram = "mysql-json-table-test";
      }) {};
 
+  "mysql-json-table_0_1_4_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, conduit, exceptions
+     , hashable, http-api-data, mysql, mysql-simple
+     }:
+     mkDerivation {
+       pname = "mysql-json-table";
+       version = "0.1.4.1";
+       sha256 = "0f22cbxjkzrlk97nfiiwrjnql4swfsn706f36p6sgz0dz2x8xf6m";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring conduit exceptions hashable http-api-data
+         mysql mysql-simple
+       ];
+       executableHaskellDepends = [ base conduit mysql-simple ];
+       description = "Using MySQL to store id-to-json tables";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "mysql-json-table-test";
+     }) {};
+
   "mysql-pure" = callPackage
     ({ mkDerivation, attoparsec, base, binary, binary-ieee754
      , blaze-textual, bytestring, bytestring-lexing, case-insensitive
···
        pname = "named";
        version = "0.3.0.2";
        sha256 = "0glm7kfkim2k94xim0cdbyqpwgw22gwghwv0fzj0i3i70r4id3bv";
+       revision = "1";
+       editedCabalFile = "0a05d53qc4xy7vjrn2y84dcb0yrn146qa50i6zc49qcbrvdmd4w8";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        description = "Named parameters (keyword arguments) for Haskell";
···
        pname = "natural-transformation";
        version = "0.4.1";
        sha256 = "1mx4m6dy6fm56xyhm6xjavv4q3188r2xnrnqgvmqf9a5m678yskf";
+       revision = "2";
+       editedCabalFile = "19nz1qqf2zs44y0y2imvcbrdn4g9cd9l810rx1vfwpcafyw50x3l";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base containers quickcheck-instances tasty tasty-quickcheck
···
        broken = true;
      }) {};
 
+  "nestedtext" = callPackage
+    ({ mkDerivation, base, binary, bytestring, containers, directory
+     , filepath, free, generic-data, hedgehog, json, microlens-platform
+     , pipes, pipes-parse, pipes-text, tasty, tasty-discover
+     , tasty-hedgehog, tasty-hunit, text, text-short, transformers
+     , vector
+     }:
+     mkDerivation {
+       pname = "nestedtext";
+       version = "0.1.3";
+       sha256 = "1j4378wgak84pzv2mjc0mp0i8y6c9hvk0c6dwk2q4y0258gx88mj";
+       libraryHaskellDepends = [
+         base binary bytestring containers free generic-data
+         microlens-platform pipes pipes-parse pipes-text text text-short
+         transformers vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory filepath hedgehog json pipes
+         pipes-text tasty tasty-hedgehog tasty-hunit text text-short vector
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "NestedText: A Human Friendly Data Format";
+       license = lib.licenses.asl20;
+     }) {};
+
   "net-concurrent" = callPackage
     ({ mkDerivation, base, bytestring, containers, ghc-binary, hslogger
      , monad-loops, network
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "network-control_0_1_6" = callPackage
+    ({ mkDerivation, base, hspec, hspec-discover, pretty-simple
+     , psqueues, QuickCheck, text, unix-time
+     }:
+     mkDerivation {
+       pname = "network-control";
+       version = "0.1.6";
+       sha256 = "18cgla6n1s773zzbk9h5lgx36bb52if44h8m3xs5w0b22jnql9gl";
+       libraryHaskellDepends = [ base psqueues unix-time ];
+       testHaskellDepends = [ base hspec pretty-simple QuickCheck text ];
+       testToolDepends = [ hspec-discover ];
+       description = "Library to control network protocols";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "network-data" = callPackage
     ({ mkDerivation, base, bytestring, cereal, pretty }:
      mkDerivation {
···
        description = "Domain Name System data structures";
        license = lib.licenses.bsd3;
        mainProgram = "hs-network-dns-examples-resolver";
+     }) {};
+
+  "network-effectful" = callPackage
+    ({ mkDerivation, base, bytestring, effectful-core, network }:
+     mkDerivation {
+       pname = "network-effectful";
+       version = "0.2.0.1";
+       sha256 = "0a01q640dy6xpbw1fk5qa7l3q9dxcx72bzjy0x566knw0zhnw2n8";
+       libraryHaskellDepends = [ base bytestring effectful-core network ];
+       description = "Adaptation of the network library for the effectful ecosystem";
+       license = lib.licenses.bsd3;
      }) {};
 
   "network-enumerator" = callPackage
···
        libraryHaskellDepends = [ base bytestring network time-manager ];
        description = "Simple network runner library";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "network-run_0_4_4" = callPackage
+    ({ mkDerivation, base, bytestring, network, time-manager }:
+     mkDerivation {
+       pname = "network-run";
+       version = "0.4.4";
+       sha256 = "1l4zgzf0ljpda72cpzzkin6shg6idm4pzx8aa2ca7v9jh3vr6g2p";
+       libraryHaskellDepends = [ base bytestring network time-manager ];
+       description = "Simple network runner library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "network-server" = callPackage
···
        pname = "non-empty";
        version = "0.3.5";
        sha256 = "0xnxisshns862l5khb70i6pkzc9l95j33vkqlk046xl6galcxdvd";
-       revision = "2";
-       editedCabalFile = "1zppyd9xf3wrdawcf92blv7ncf5p0jria8ki72k2ydj56097knpx";
+       revision = "3";
+       editedCabalFile = "09372apcl58lw6cw0xibinskrrq5jx02a20n9qbx06dxgswzcjdh";
        libraryHaskellDepends = [
          base containers deepseq QuickCheck utility-ht
        ];
···
        license = lib.licenses.asl20;
      }) {};
 
+  "nvim-hs_2_3_2_4" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, cereal-conduit, conduit
+     , containers, data-default, deepseq, foreign-store, hslogger, hspec
+     , hspec-discover, megaparsec, messagepack, mtl, network
+     , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
+     , QuickCheck, streaming-commons, template-haskell
+     , template-haskell-compat-v0208, text, time, time-locale-compat
+     , typed-process, unliftio, unliftio-core, utf8-string, vector, void
+     }:
+     mkDerivation {
+       pname = "nvim-hs";
+       version = "2.3.2.4";
+       sha256 = "1wvmysvhmlmqm2nx8psjj6z38a49krrqwd57v2lf822lch4gi5lc";
+       libraryHaskellDepends = [
+         base bytestring cereal cereal-conduit conduit containers
+         data-default deepseq foreign-store hslogger megaparsec messagepack
+         mtl network optparse-applicative prettyprinter
+         prettyprinter-ansi-terminal streaming-commons template-haskell
+         template-haskell-compat-v0208 text time time-locale-compat
+         typed-process unliftio unliftio-core utf8-string vector void
+       ];
+       testHaskellDepends = [
+         base containers data-default deepseq hspec hspec-discover
+         prettyprinter prettyprinter-ansi-terminal QuickCheck unliftio
+         unliftio-core vector void
+       ];
+       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
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "ob" = callPackage
+    ({ mkDerivation, aeson, async, base, commonmark-simple
+     , commonmark-wikilink, containers, filepath, monad-logger, pandoc
+     , pandoc-types, relude, stm, unionmount, unliftio
+     }:
+     mkDerivation {
+       pname = "ob";
+       version = "0.1.0.0";
+       sha256 = "11palinqm0ci1hmjdkpqaawjklw8gyi8hcjknlgxq9ndmd67p2c5";
+       libraryHaskellDepends = [
+         aeson async base commonmark-simple commonmark-wikilink containers
+         filepath monad-logger pandoc pandoc-types relude stm unionmount
+         unliftio
+       ];
+       testHaskellDepends = [ base ];
+       description = "Live in-memory sync of Obsidian Markdown notes";
+       license = lib.licenses.bsd3;
      }) {};
 
   "obd" = callPackage
···
      }) {};
 
   "oeis" = callPackage
-    ({ mkDerivation, base, HTTP, HUnit, network, network-uri
-     , test-framework, test-framework-hunit
+    ({ mkDerivation, base, http-client, http-client-tls, http-types
+     , HUnit, network, network-uri, test-framework, test-framework-hunit
+     , utf8-string
      }:
      mkDerivation {
        pname = "oeis";
-       version = "0.3.10";
-       sha256 = "0aa5i0328k8pf0y439b95c3ipv70lfabvv55jp64pwb9kx6p5ymv";
-       libraryHaskellDepends = [ base HTTP network network-uri ];
+       version = "0.3.10.1";
+       sha256 = "0m7h1pbiy2xpagvggsp6a8rvafdgzr84222bp8rl4yh57lz3wmw4";
+       libraryHaskellDepends = [
+         base http-client http-client-tls http-types network network-uri
+         utf8-string
+       ];
        testHaskellDepends = [
          base HUnit test-framework test-framework-hunit
        ];
···
      }:
      mkDerivation {
        pname = "ogma-cli";
-       version = "1.6.0";
-       sha256 = "0d46b6g85y4wx75byxqb65xsg3z34fk4af2fgy8w1rd4b2k9x53q";
+       version = "1.7.0";
+       sha256 = "1ngkk3bkvjy3nz2rs0mprrwrdq3a3mzih3bjkiz0xlm6xn3kmafh";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [ base ogma-core optparse-applicative ];
···
   "ogma-core" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, directory
      , filepath, graphviz, HUnit, megaparsec, mtl, ogma-extra
-     , ogma-language-c, ogma-language-cocospec, ogma-language-copilot
-     , ogma-language-jsonspec, ogma-language-smv, ogma-language-xmlspec
-     , ogma-spec, process, QuickCheck, test-framework
-     , test-framework-hunit, test-framework-quickcheck2, text
+     , ogma-language-c, ogma-language-copilot, ogma-language-csv
+     , ogma-language-jsonspec, ogma-language-lustre, ogma-language-smv
+     , ogma-language-xlsx, ogma-language-xmlspec, ogma-spec, process
+     , QuickCheck, test-framework, test-framework-hunit
+     , test-framework-quickcheck2, text
      }:
      mkDerivation {
        pname = "ogma-core";
-       version = "1.6.0";
-       sha256 = "13cnb58lbs1n3lb044s3dwhcr88k74lawpcp1z1a4vghdwxygddk";
+       version = "1.7.0";
+       sha256 = "0f9h8wx12i4awgbcnvn30k4xydp21lg7r7spsvpm45n4x4w4d3r8";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base bytestring containers directory filepath graphviz
-         megaparsec mtl ogma-extra ogma-language-c ogma-language-cocospec
-         ogma-language-copilot ogma-language-jsonspec ogma-language-smv
-         ogma-language-xmlspec ogma-spec process text
+         megaparsec mtl ogma-extra ogma-language-c ogma-language-copilot
+         ogma-language-csv ogma-language-jsonspec ogma-language-lustre
+         ogma-language-smv ogma-language-xlsx ogma-language-xmlspec
+         ogma-spec process text
        ];
        testHaskellDepends = [
          base directory HUnit QuickCheck test-framework test-framework-hunit
···
      }:
      mkDerivation {
        pname = "ogma-extra";
-       version = "1.6.0";
-       sha256 = "1096pf2q5a3i8x5bzakgx0xkg6raxn1db0dc8fzq4gj7qd51jd2d";
+       version = "1.7.0";
+       sha256 = "1sh6gssq5w5yh7jnhflzgqh5f6kfxlsgqcgj6rjwai3miq8z7pap";
        libraryHaskellDepends = [
          aeson base bytestring Cabal directory filepath microstache text
        ];
···
      }) {};
 
   "ogma-language-c" = callPackage
-    ({ mkDerivation, array, base, BNFC, Cabal, process, QuickCheck
-     , test-framework, test-framework-quickcheck2
+    ({ mkDerivation, alex, array, base, BNFC, Cabal, happy, process
+     , QuickCheck, test-framework, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "ogma-language-c";
-       version = "1.6.0";
-       sha256 = "1gycj6505s77sfq1k483n4infa4hvvn6p6l21phwp1c7kjm38v1a";
-       setupHaskellDepends = [ base BNFC Cabal process ];
+       version = "1.7.0";
+       sha256 = "1jmgvln7fvjji5rwx8qhganj9xhviqqlfdnrc1icqirc6yzgbvi8";
+       setupHaskellDepends = [ base Cabal process ];
        libraryHaskellDepends = [ array base ];
+       libraryToolDepends = [ alex BNFC happy ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
        ];
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "ogma-language-copilot";
-       version = "1.6.0";
-       sha256 = "0c2wpxsfjhr1x3cyq66n7b789npwp051niicy727lz674ln7xi55";
+       version = "1.7.0";
+       sha256 = "1m27a4jm810piqdm22cgbm9g6ca72q774m54bjlyh100zrsq890h";
        libraryHaskellDepends = [ base ];
        description = "Ogma: Runtime Monitor translator: Copilot Language Endpoints";
        license = "unknown";
      }) {};
 
+  "ogma-language-csv" = callPackage
+    ({ mkDerivation, base, bytestring, cassava, mtl, ogma-spec, text
+     , vector
+     }:
+     mkDerivation {
+       pname = "ogma-language-csv";
+       version = "1.7.0";
+       sha256 = "06s98ci30v7kpwkgd42ycpngxzh1qarlm5d5v7yfba6fb0m0b5v6";
+       libraryHaskellDepends = [
+         base bytestring cassava mtl ogma-spec text vector
+       ];
+       description = "Ogma: Runtime Monitor translator: CSV Frontend";
+       license = "unknown";
+     }) {};
+
   "ogma-language-fret-cs" = callPackage
     ({ mkDerivation, aeson, base, ogma-extra, ogma-language-cocospec
      , ogma-language-smv, QuickCheck, test-framework
···
      }:
      mkDerivation {
        pname = "ogma-language-jsonspec";
-       version = "1.6.0";
-       sha256 = "1plx472ypczsjaj9vi131bdi6xdbs42l8an6qv0k2p596xk2238l";
+       version = "1.7.0";
+       sha256 = "1scla1xwzwzaf3p87prjbd9z6s2lc0138gfl3vxcmv963cf7wlna";
        libraryHaskellDepends = [
          aeson base bytestring jsonpath megaparsec mtl ogma-spec text
        ];
···
        broken = true;
      }) {};
 
+  "ogma-language-lustre" = callPackage
+    ({ mkDerivation, alex, array, base, BNFC, Cabal, happy, process
+     , QuickCheck, test-framework, test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "ogma-language-lustre";
+       version = "1.7.0";
+       sha256 = "12263lwgcr91x6bw99wwkywnnfxs5jiwh73h2sngy9if9b2glr3d";
+       setupHaskellDepends = [ base Cabal process ];
+       libraryHaskellDepends = [ array base ];
+       libraryToolDepends = [ alex BNFC happy ];
+       testHaskellDepends = [
+         base QuickCheck test-framework test-framework-quickcheck2
+       ];
+       description = "Ogma: Runtime Monitor translator: Lustre Language Frontend";
+       license = "unknown";
+     }) {};
+
   "ogma-language-smv" = callPackage
-    ({ mkDerivation, array, base, BNFC, Cabal, process, QuickCheck
-     , test-framework, test-framework-quickcheck2
+    ({ mkDerivation, alex, array, base, BNFC, Cabal, happy, process
+     , QuickCheck, test-framework, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "ogma-language-smv";
-       version = "1.6.0";
-       sha256 = "0rv0h9dz7ijh6hihp9k6znh66fz06c4v81ifarv0n403nw3ih96b";
-       setupHaskellDepends = [ base BNFC Cabal process ];
+       version = "1.7.0";
+       sha256 = "1qj2nrhgvx6iz3bwzpahj5yyl1ancw1asi6062nnv2pqg16lb0jy";
+       setupHaskellDepends = [ base Cabal process ];
        libraryHaskellDepends = [ array base ];
+       libraryToolDepends = [ alex BNFC happy ];
        testHaskellDepends = [
          base QuickCheck test-framework test-framework-quickcheck2
        ];
···
        broken = true;
      }) {};
 
+  "ogma-language-xlsx" = callPackage
+    ({ mkDerivation, base, bytestring, ogma-spec, text, xlsx }:
+     mkDerivation {
+       pname = "ogma-language-xlsx";
+       version = "1.7.0";
+       sha256 = "1rsdb7vc25s9rx09ccyiv3ja566zhaqmhc57qx5ajj49j1pffvs0";
+       libraryHaskellDepends = [ base bytestring ogma-spec text xlsx ];
+       description = "Ogma: Runtime Monitor translator: XLSX Frontend";
+       license = "unknown";
+     }) {};
+
   "ogma-language-xmlspec" = callPackage
     ({ mkDerivation, base, hxt, hxt-regex-xmlschema, hxt-xpath, mtl
      , ogma-spec, pretty
      }:
      mkDerivation {
        pname = "ogma-language-xmlspec";
-       version = "1.6.0";
-       sha256 = "0n8nxw987y3fqsi37g837k3qxm4h7rb2w2878b04lnfnhl4d4iqq";
+       version = "1.7.0";
+       sha256 = "08ivxc8l3f4jmvmciagi1da1d02aggl7y4zcswsinwib49254vrp";
        libraryHaskellDepends = [
          base hxt hxt-regex-xmlschema hxt-xpath mtl ogma-spec pretty
        ];
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "ogma-spec";
-       version = "1.6.0";
-       sha256 = "0q0bnw6js367dk7n5ahwiiycnma5dm8yy23f7y6vfzwk81v5ql55";
+       version = "1.7.0";
+       sha256 = "16m6yqpb7lqaaac2v5x5bi8rjk98ibxlk10rl18ra0a0iprjg9q7";
        libraryHaskellDepends = [ base ];
        description = "Ogma: Runtime Monitor translator: JSON Frontend";
        license = "unknown";
···
        broken = true;
      }) {};
 
+  "ollama-haskell_0_1_3_0" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
+     , containers, directory, filepath, http-client, http-types
+     , silently, tasty, tasty-hunit, text, time
+     }:
+     mkDerivation {
+       pname = "ollama-haskell";
+       version = "0.1.3.0";
+       sha256 = "1ds9hkjhmkaw7mgxbpbq83df30iwjmnxi343f2sbm8xl8hhc8c1g";
+       libraryHaskellDepends = [
+         aeson base base64-bytestring bytestring containers directory
+         filepath http-client http-types text time
+       ];
+       testHaskellDepends = [
+         aeson base base64-bytestring bytestring containers directory
+         filepath http-client http-types silently tasty tasty-hunit text
+         time
+       ];
+       description = "Haskell bindings for ollama";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "olwrapper" = callPackage
     ({ mkDerivation, base, bytestring, fay, fay-jquery, fay-text, lens
      , mtl, snap, snap-core, snap-loader-dynamic, snap-loader-static
···
 
   "om-http" = callPackage
     ({ mkDerivation, aeson, async, base, base64, bytestring
-     , case-insensitive, directory, filepath, http-types, mime-types
-     , monad-logger-aeson, network, om-show, safe-exceptions, servant
-     , template-haskell, text, time, unix, uuid, wai, warp
+     , case-insensitive, containers, directory, filepath, http-types
+     , mime-types, monad-logger-aeson, network, om-show, safe-exceptions
+     , servant, template-haskell, text, time, unix, uuid, wai, warp
      }:
      mkDerivation {
        pname = "om-http";
-       version = "0.4.1.0";
-       sha256 = "08qzh4xjng395v26ccvsr5bb89b3f74zm4an037n9pml668fmyya";
+       version = "0.5.0.0";
+       sha256 = "165m5dijcwa9knrn4lfk86l8gs30b98xbmp75vm6y0wc3my0dhsq";
        libraryHaskellDepends = [
-         aeson async base base64 bytestring case-insensitive directory
-         filepath http-types mime-types monad-logger-aeson network om-show
-         safe-exceptions servant template-haskell text time unix uuid wai
-         warp
+         aeson async base base64 bytestring case-insensitive containers
+         directory filepath http-types mime-types monad-logger-aeson network
+         om-show safe-exceptions servant template-haskell text time unix
+         uuid wai warp
        ];
        description = "Http utilities";
        license = lib.licenses.mit;
···
      }) {};
 
   "om-plugin-imports" = callPackage
-    ({ mkDerivation, base, containers, ghc, safe }:
+    ({ mkDerivation, base, containers, ghc, safe, time }:
      mkDerivation {
        pname = "om-plugin-imports";
-       version = "0.4.0.0.9.10";
-       sha256 = "07ghwn2jpy580mzf70x0rawmxsqsbyy1adp204vydxapp04xbv0k";
-       libraryHaskellDepends = [ base containers ghc safe ];
+       version = "0.4.0.1.9.10";
+       sha256 = "1qkgfxsd4vpxd0fbhkfz5636zc5mbhcxh80h98h67hdxkkc69ad4";
+       libraryHaskellDepends = [ base containers ghc safe time ];
        description = "Plugin-based explicit import generation";
        license = lib.licenses.mit;
      }) {};
···
        mainProgram = "example";
      }) {};
 
+  "open-browser_0_3_0_1" = callPackage
+    ({ mkDerivation, base, process }:
+     mkDerivation {
+       pname = "open-browser";
+       version = "0.3.0.1";
+       sha256 = "0gnckivfyv131f342nziyj0p57m9arq0ds8b6jylxga31snj3icn";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base process ];
+       description = "Open a web browser from Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "open-haddock" = callPackage
     ({ mkDerivation, base, basic-prelude, text, turtle }:
      mkDerivation {
···
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
+
+  "opendht-hs" = callPackage
+    ({ mkDerivation, base, bytestring, c2hs, containers, data-default
+     , lens, mtl, opendht-c, random, stm, transformers
+     }:
+     mkDerivation {
+       pname = "opendht-hs";
+       version = "0.1.0.0";
+       sha256 = "0vrqxa9vyz8r6ryvc90mqqzacjv5yqlalb7wm488zs85iszblskv";
+       libraryHaskellDepends = [
+         base bytestring containers data-default lens mtl random stm
+         transformers
+       ];
+       libraryPkgconfigDepends = [ opendht-c ];
+       libraryToolDepends = [ c2hs ];
+       description = "Haskell bindings for OpenDHT";
+       license = lib.licenses.gpl3Plus;
+     }) {opendht-c = null;};
 
   "openexchangerates" = callPackage
     ({ mkDerivation, aeson, base, containers, currency, errors, HTTP
···
      }:
      mkDerivation {
        pname = "opentracing";
-       version = "0.3.0";
-       sha256 = "1bbs2rv0rfsz3mmi04qxjirmbm9ghsx8cffa15lm4n8sxpkafz82";
+       version = "0.3.0.1";
+       sha256 = "1wcqimh37k1z1x2jzsg9siqdlwslx8b3pzg1xlicfz355hbzrf19";
        libraryHaskellDepends = [
          aeson async base base64-bytestring bytestring case-insensitive
          clock containers http-types iproute lens mtl mwc-random network
···
     ({ mkDerivation, base, http-client, lens, mtl, opentracing, text }:
      mkDerivation {
        pname = "opentracing-http-client";
-       version = "0.3.0";
-       sha256 = "1wjhb15ay6l5ynby90abrlkw7i9iwnkifzfpi39bbk7884wkl6a7";
+       version = "0.3.0.1";
+       sha256 = "1hkpw5yasz0zy55zh8m3k69fl8p316x9nqw0amfqazwrk9wwakh3";
        libraryHaskellDepends = [
          base http-client lens mtl opentracing text
        ];
···
      }:
      mkDerivation {
        pname = "opentracing-jaeger";
-       version = "0.3.0";
-       sha256 = "0a1kk98ab98pwkh9znssz8s2yfg660n509rkiwslarm910lyqmvp";
+       version = "0.3.0.1";
+       sha256 = "1vbnlh3s5gzxkby3kjmihnzs1wirjynzvdpnxkp6rxzlxz0p5bca";
        libraryHaskellDepends = [
          base bytestring exceptions hashable http-client http-types lens mtl
          network opentracing pinch QuickCheck safe-exceptions text
···
     ({ mkDerivation, base, lens, opentracing, text, wai }:
      mkDerivation {
        pname = "opentracing-wai";
-       version = "0.3.0";
-       sha256 = "1j9bamsy6yflxhk6xy1li2a1jqva07r7w3jf509wfiq4474i345k";
+       version = "0.3.0.1";
+       sha256 = "0fvb4dalycc7nmn619ssczwdpgsc2bgvzn5fbz10gzg2b6i3c67r";
        libraryHaskellDepends = [ base lens opentracing text wai ];
        description = "Middleware adding OpenTracing tracing for WAI applications";
        license = lib.licenses.asl20;
···
     ({ mkDerivation, aeson, base, opentracing, text }:
      mkDerivation {
        pname = "opentracing-zipkin-common";
-       version = "0.3.0";
-       sha256 = "1ha0f6y2rj5j7634z5pcas1425rlx0i94xiwiwqy9za54hhqaa3i";
+       version = "0.3.0.1";
+       sha256 = "1nph7csy8rfj1gs21x1skhcy6kj02892dlkvwvb8lil6z5bqk0f3";
        libraryHaskellDepends = [ aeson base opentracing text ];
        description = "Zipkin OpenTracing Backend Commons";
        license = lib.licenses.asl20;
···
      }:
      mkDerivation {
        pname = "opentracing-zipkin-v1";
-       version = "0.3.0";
-       sha256 = "1hcpmr5nr7h045nf4m82q1j7xcqi8hrm6fdw4q2xx38vz3hnph9v";
+       version = "0.3.0.1";
+       sha256 = "1jhnwsddssfsanih5vyrm459rynlm7gbkhwxddq4rm0fgf3dl36s";
        libraryHaskellDepends = [
          base bytestring exceptions hashable http-client http-types iproute
          lens opentracing opentracing-zipkin-common pinch QuickCheck text
···
      }:
      mkDerivation {
        pname = "opentracing-zipkin-v2";
-       version = "0.3.0";
-       sha256 = "1bkvg8krw9jv4c48an0g6z140ghln91vcc0igcxzj50y7vmczrh7";
+       version = "0.3.0.1";
+       sha256 = "0ccc2ljajx8qwbwmmvizdj9aqxg83wy06ghdd18ccdah5nx3bjqd";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring exceptions http-client
          http-types lens opentracing opentracing-zipkin-common text
···
        license = lib.licenses.lgpl3Only;
      }) {};
 
+  "opt-env-conf_0_9_0_0" = callPackage
+    ({ mkDerivation, aeson, autodocodec, autodocodec-nix
+     , autodocodec-schema, autodocodec-yaml, base, containers, hashable
+     , mtl, path, path-io, safe-coloured-text, safe-coloured-text-layout
+     , safe-coloured-text-terminfo, selective, text, validity
+     , validity-containers
+     }:
+     mkDerivation {
+       pname = "opt-env-conf";
+       version = "0.9.0.0";
+       sha256 = "151jppj1id7r3n32hjhgxbms17xs0wir9xd2fp5bcap19h57pbis";
+       libraryHaskellDepends = [
+         aeson autodocodec autodocodec-nix autodocodec-schema
+         autodocodec-yaml base containers hashable mtl path path-io
+         safe-coloured-text safe-coloured-text-layout
+         safe-coloured-text-terminfo selective text validity
+         validity-containers
+       ];
+       description = "Settings parsing for Haskell: command-line arguments, environment variables, and configuration values";
+       license = lib.licenses.lgpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "opt-env-conf-test" = callPackage
-    ({ mkDerivation, aeson, base, containers, genvalidity
+    ({ mkDerivation, aeson, autodocodec, base, containers, genvalidity
      , genvalidity-aeson, genvalidity-containers, genvalidity-sydtest
-     , genvalidity-text, mtl, opt-env-conf, path, pretty-show
+     , genvalidity-text, mtl, opt-env-conf, path, path-io, pretty-show
      , QuickCheck, safe-coloured-text, sydtest, sydtest-discover, text
      }:
      mkDerivation {
        pname = "opt-env-conf-test";
-       version = "0.0.0.0";
-       sha256 = "1wax19kv3slnnk9zibjsjq4nb3qjcgfznhbs1hv1kf8309a8hzvl";
-       isLibrary = true;
-       isExecutable = true;
+       version = "0.0.0.2";
+       sha256 = "0smdlkf74vkdxfddl4zmc5kh6dlx2l4v00c0f6l3gn9180kc8p4m";
        libraryHaskellDepends = [
-         base genvalidity genvalidity-containers opt-env-conf
+         aeson base genvalidity genvalidity-containers opt-env-conf
          safe-coloured-text sydtest text
        ];
-       executableHaskellDepends = [ base opt-env-conf text ];
        testHaskellDepends = [
-         aeson base containers genvalidity-aeson genvalidity-sydtest
-         genvalidity-text mtl opt-env-conf path pretty-show QuickCheck
-         safe-coloured-text sydtest text
+         aeson autodocodec base containers genvalidity-aeson
+         genvalidity-sydtest genvalidity-text mtl opt-env-conf path path-io
+         pretty-show QuickCheck safe-coloured-text sydtest text
        ];
        testToolDepends = [ sydtest-discover ];
        description = "A testing companion package for opt-env-conf";
        license = "unknown";
-       mainProgram = "opt-env-conf-example";
      }) {};
 
   "optics" = callPackage
···
        pname = "optics-th";
        version = "0.4.1";
        sha256 = "05zxljfqmhr5if7l8gld5s864nql6kqjfizsf1z7r3ydknvmff6p";
-       revision = "8";
-       editedCabalFile = "0ny8avgki1hakrfrmg848v5s4s39ql5shs4zd2clg1fsfshqljjw";
+       revision = "9";
+       editedCabalFile = "0v96pjcm6g59d49vg2a0zcaxyky1yml7rcg2q0635qq27bc01x14";
        libraryHaskellDepends = [
          base containers mtl optics-core template-haskell th-abstraction
          transformers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "packcheck_0_7_1" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "packcheck";
+       version = "0.7.1";
+       sha256 = "07a03gmcvfr8js19cdas6dy577mjpmfdbpimikr6h9krr80asjsb";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       benchmarkHaskellDepends = [ base ];
+       description = "Universal build and CI testing for Haskell packages";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "packdeps" = callPackage
     ({ mkDerivation, base, bytestring, Cabal, containers, directory
      , filepath, optparse-applicative, process, semigroups, split, tar
···
        pname = "palette";
        version = "0.3.0.4";
        sha256 = "0n8rylfpf9f0fx58c33v4nx8vwkrz8qlqr9xc1agikzh0l7dgksz";
+       revision = "1";
+       editedCabalFile = "04hr5yiplm9162n6i3xhr4v70vnxdfm0gn730qcb1yyv2v2z1vx4";
        libraryHaskellDepends = [
          array base colour containers MonadRandom
        ];
···
      }) {inherit (pkgs) pam;};
 
   "pan-os-syslog" = callPackage
-    ({ mkDerivation, base, byteslice, bytesmith, chronos, gauge, ip
-     , primitive, primitive-addr, run-st
+    ({ mkDerivation, base, byte-order, bytebuild, byteslice, bytesmith
+     , bytestring, chronos, containers, contiguous, directory, gauge, ip
+     , json-syntax, optparse-generic, primitive, primitive-addr, run-st
+     , text, text-short, transformers, uuid-bytes, wide-word, zlib
      }:
      mkDerivation {
        pname = "pan-os-syslog";
-       version = "0.1.0.0";
-       sha256 = "0ydydbql0pgd6vp9zvzjf0qzsprjaicz9vffrrp3z1xgmfynh70r";
+       version = "0.2.0.0";
+       sha256 = "0wd3wgkzi6qaarf1qy336kvyhrwwm9fydwpf90f81138rjhbdj70";
+       isLibrary = true;
+       isExecutable = true;
        libraryHaskellDepends = [
          base byteslice bytesmith chronos ip primitive primitive-addr run-st
+         uuid-bytes wide-word
+       ];
+       executableHaskellDepends = [
+         base byte-order bytebuild byteslice bytestring chronos containers
+         contiguous directory ip json-syntax optparse-generic primitive
+         run-st text text-short transformers wide-word zlib
        ];
        testHaskellDepends = [ base byteslice primitive ];
        benchmarkHaskellDepends = [ base byteslice gauge primitive ];
        description = "Parse syslog traffic from PAN-OS";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       mainProgram = "pan-os-syslog-to-avro";
        broken = true;
      }) {};
 
···
        ];
      }) {};
 
-  "pandoc_3_6_3" = callPackage
+  "pandoc_3_6_4" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
      , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
      , case-insensitive, citeproc, commonmark, commonmark-extensions
···
      }:
      mkDerivation {
        pname = "pandoc";
-       version = "3.6.3";
-       sha256 = "04sri6xn4yclalg2rglj7l7icvwg5vd6d8dfkxszkgqyr4nxcm0z";
+       version = "3.6.4";
+       sha256 = "1igqsbzvgkrwb8k9ycjha9cynz5j50gfsc050j93k4bg3yd9c0lp";
        configureFlags = [ "-f-trypandoc" ];
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
-  "pandoc-cli_3_6_3" = callPackage
+  "pandoc-cli_3_6_4" = callPackage
     ({ mkDerivation, base, hslua-cli, pandoc, pandoc-lua-engine
      , pandoc-server, safe, temporary, text, wai-extra, warp
      }:
      mkDerivation {
        pname = "pandoc-cli";
-       version = "3.6.3";
-       sha256 = "015q4m76qpi1ncrz5dmhqzg9nvm7hkc99cf7bp0mbkfkp59psm7r";
+       version = "3.6.4";
+       sha256 = "046jdqg3ysgap89npr613zzccxhd2hga33d8i588fr8x9r1syvya";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "pandoc-crossref";
-       version = "0.3.18.1";
-       sha256 = "1bzspd7jjn4ypk5vxhifkcfj4b4jm9352k15k2wc5f4xmwlkqdg4";
+       version = "0.3.18.2";
+       sha256 = "0ikgh6sdi2ny6yb65sx2zy6rs35q5qy2qpqiy8sz4b1j8i784w9g";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = lib.licenses.gpl2Plus;
      }) {};
 
+  "pandoc-lua-engine_0_4_1_1" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, citeproc, containers
+     , crypton, data-default, directory, doclayout, doctemplates
+     , exceptions, filepath, hslua, hslua-module-doclayout
+     , hslua-module-path, hslua-module-system, hslua-module-text
+     , hslua-module-version, hslua-module-zip, hslua-repl, lpeg, mtl
+     , pandoc, pandoc-lua-marshal, pandoc-types, parsec, tasty
+     , tasty-golden, tasty-hunit, tasty-lua, text
+     }:
+     mkDerivation {
+       pname = "pandoc-lua-engine";
+       version = "0.4.1.1";
+       sha256 = "1nxk3ban38bc4avqjjwisk40licxkr217dgjm991ny2kny28r4rf";
+       libraryHaskellDepends = [
+         aeson base bytestring citeproc containers crypton data-default
+         doclayout doctemplates exceptions hslua hslua-module-doclayout
+         hslua-module-path hslua-module-system hslua-module-text
+         hslua-module-version hslua-module-zip hslua-repl lpeg mtl pandoc
+         pandoc-lua-marshal pandoc-types parsec text
+       ];
+       testHaskellDepends = [
+         base bytestring data-default directory exceptions filepath hslua
+         pandoc pandoc-types tasty tasty-golden tasty-hunit tasty-lua text
+       ];
+       description = "Lua engine to power custom pandoc conversions";
+       license = lib.licenses.gpl2Plus;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "pandoc-lua-marshal" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, exceptions
      , hslua, hslua-list, hslua-marshalling, pandoc-types, QuickCheck
···
        license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) pango;};
 
+  "pango_0_13_12_0" = callPackage
+    ({ mkDerivation, array, base, Cabal, cairo, containers, directory
+     , filepath, glib, gtk2hs-buildtools, mtl, pango, pretty, process
+     , text
+     }:
+     mkDerivation {
+       pname = "pango";
+       version = "0.13.12.0";
+       sha256 = "0ahrx81picvm6mbv1vdgk19l6yyzi75z0y1shkbvc9zs23czlz62";
+       enableSeparateDataOutput = true;
+       setupHaskellDepends = [ base Cabal filepath gtk2hs-buildtools ];
+       libraryHaskellDepends = [
+         array base cairo containers directory glib mtl pretty process text
+       ];
+       libraryPkgconfigDepends = [ pango ];
+       description = "Binding to the Pango text rendering engine";
+       license = lib.licenses.lgpl21Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) pango;};
+
   "pangraph" = callPackage
     ({ mkDerivation, algebraic-graphs, attoparsec, base, bytestring
      , containers, fgl, hexml, html-entities, HUnit, text
···
        pname = "pantry";
        version = "0.10.0";
        sha256 = "1f0ck7j82km4sy1ia2iqv9aqkdr3p2h8sarbksrsx2dq68552xym";
-       revision = "2";
-       editedCabalFile = "1v2d03rzrj0gmilx2qa1c0y1srzjh96xq02sd7qarc2kjw4rjgyi";
+       revision = "3";
+       editedCabalFile = "1icnsp0j6dbbqsp2wkxbq0nwfv55fl95anh0xsl6x5gx2q4wg1gc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "parameterized-utils_2_1_10_0" = callPackage
+    ({ mkDerivation, base, base-orphans, constraints, containers
+     , deepseq, ghc-prim, hashable, hashtables, hedgehog
+     , hedgehog-classes, indexed-traversable, lens, mtl, profunctors
+     , tasty, tasty-ant-xml, tasty-hedgehog, tasty-hunit
+     , template-haskell, text, th-abstraction, vector
+     }:
+     mkDerivation {
+       pname = "parameterized-utils";
+       version = "2.1.10.0";
+       sha256 = "1gr4q79sjp1b6456b249i9ysvd0pcl3acnimvsq6b6knj2zvkshk";
+       libraryHaskellDepends = [
+         base base-orphans constraints containers deepseq ghc-prim hashable
+         hashtables indexed-traversable lens mtl profunctors
+         template-haskell text th-abstraction vector
+       ];
+       testHaskellDepends = [
+         base ghc-prim hashable hashtables hedgehog hedgehog-classes
+         indexed-traversable lens mtl tasty tasty-ant-xml tasty-hedgehog
+         tasty-hunit
+       ];
+       description = "Classes and data structures for working with data-kind indexed types";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "parametric-functor" = callPackage
     ({ mkDerivation, base, transformers }:
      mkDerivation {
···
        pname = "paramtree";
        version = "0.1.2";
        sha256 = "0qb0l68b5yldypik20fxf8rdxhkrqywvvk4n6pk6g7wnvyxvadrn";
+       revision = "1";
+       editedCabalFile = "0z8d64avy87pfd9vf9ij0vmmrimzkkhyw18xiv3nkdhrm508vcjj";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [
          base bytestring tasty tasty-golden tasty-hunit temporary
···
        pname = "park-bench";
        version = "0.1.1.0";
        sha256 = "15vbhljsnqjm3hjqxlzifvkbcysmwz3fqw2hmdlwkzsyncz4p6j9";
-       revision = "1";
-       editedCabalFile = "1ngbvkrxnx7g1p321gzh6w23q0k1akf7gg71qxa6asrra4a86b54";
+       revision = "2";
+       editedCabalFile = "0yqb96vd1dgid4fprny49zmn8p26k9m15n1qgp2nwm2bnv6a7mpx";
        libraryHaskellDepends = [ array base bytestring ghc-prim text ];
        description = "A quick-and-dirty, low-friction benchmark tool with immediate feedback";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "parser-regex";
-       version = "0.2.0.1";
-       sha256 = "0ayjy070yn9x9133n52vf51w80zsgrs0f9bmgsid9fnq3alp85ci";
+       version = "0.2.0.2";
+       sha256 = "1aqx5krvmz2mdwlpbpnwlk50c3v02lxarv6p2si23qy26v7ra22f";
        libraryHaskellDepends = [
          base containers deepseq ghc-bignum primitive text transformers
        ];
···
        pname = "parsers";
        version = "0.12.12";
        sha256 = "1g16qrhacjzfcja2wn5936xz9bwqs80xxmj189d2lwwyga5m77nx";
+       revision = "1";
+       editedCabalFile = "11y65sabwqcliqxwdss8pjvliy0w4m3b4amd1acf0jgmx4bhxdf6";
        libraryHaskellDepends = [
          attoparsec base binary charset containers mtl parsec scientific
          text transformers unordered-containers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "partialord_0_0_3" = callPackage
+    ({ mkDerivation, base, containers, hspec }:
+     mkDerivation {
+       pname = "partialord";
+       version = "0.0.3";
+       sha256 = "08qgjqvkxj7xqm3v8n7g7j5cvd9489jhf7m2rrzp92xyqhshilli";
+       libraryHaskellDepends = [ base containers ];
+       testHaskellDepends = [ base containers hspec ];
+       description = "Data structure supporting partial orders";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "partly" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring
      , binary, bytestring, optparse-applicative, QuickCheck, vector
···
   "patat" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, ansi-wl-pprint, async, base
      , base64-bytestring, bytestring, colour, containers, directory
-     , filepath, goldplate, hashable, mtl, network, network-uri
-     , optparse-applicative, pandoc, pandoc-types, process, QuickCheck
-     , random, skylighting, tasty, tasty-hunit, tasty-quickcheck
-     , terminal-size, text, time, unordered-containers, vector, wcwidth
-     , yaml
+     , filepath, goldplate, hashable, JuicyPixels, mtl, network
+     , network-uri, optparse-applicative, pandoc, pandoc-types, process
+     , QuickCheck, random, skylighting, tasty, tasty-hunit
+     , tasty-quickcheck, terminal-size, text, time, unordered-containers
+     , vector, wcwidth, yaml
      }:
      mkDerivation {
        pname = "patat";
-       version = "0.14.0.0";
-       sha256 = "1140w30njw9w87pa3l9hvmifhbff0gnm0qvw9g01577qchv1k758";
+       version = "0.14.2.0";
+       sha256 = "0shfw876xfw6xcaf4xjjj8gq2ky7k16fl6wvas952j87b5bhd7gf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson ansi-terminal ansi-wl-pprint async base base64-bytestring
-         bytestring colour containers directory filepath hashable mtl
-         network network-uri optparse-applicative pandoc pandoc-types
-         process random skylighting terminal-size text time
+         bytestring colour containers directory filepath hashable
+         JuicyPixels mtl network network-uri optparse-applicative pandoc
+         pandoc-types process random skylighting terminal-size text time
          unordered-containers vector wcwidth yaml
        ];
        executableHaskellDepends = [ base ];
···
        testHaskellDepends = [ base bytestring containers HUnit mtl ];
        description = "Portable regex library for Perl 5 compatible regular expressions";
        license = lib.licenses.bsd3;
+     }) {inherit (pkgs) pcre;};
+
+  "pcre-light_0_4_1_3" = callPackage
+    ({ mkDerivation, base, bytestring, containers, HUnit, mtl, pcre }:
+     mkDerivation {
+       pname = "pcre-light";
+       version = "0.4.1.3";
+       sha256 = "1rhlp0v32ahwlh5293xyq04my8f2ln1mfycpg01cm0qvmng2irmw";
+       revision = "1";
+       editedCabalFile = "0yafqik2hsb9x2k79kz6k5r3awk1g6gzyq7yxjb5grm3czgh4hhx";
+       libraryHaskellDepends = [ base bytestring ];
+       librarySystemDepends = [ pcre ];
+       testHaskellDepends = [ base bytestring containers HUnit mtl ];
+       description = "Portable regex library for Perl 5 compatible regular expressions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) pcre;};
 
   "pcre-light-extra" = callPackage
···
        ];
        description = "Type-safe, multi-backend data serialization";
        license = lib.licenses.mit;
+       maintainers = [ lib.maintainers.psibi ];
+     }) {};
+
+  "persistent_2_15_0_1" = callPackage
+    ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base
+     , base64-bytestring, blaze-html, bytestring, conduit, containers
+     , criterion, deepseq, fast-logger, file-embed, hspec, http-api-data
+     , lift-type, monad-logger, mtl, path-pieces, QuickCheck
+     , quickcheck-instances, resource-pool, resourcet, scientific
+     , shakespeare, silently, template-haskell, text, th-lift-instances
+     , time, transformers, unliftio, unliftio-core, unordered-containers
+     , vault, vector
+     }:
+     mkDerivation {
+       pname = "persistent";
+       version = "2.15.0.1";
+       sha256 = "12lb7b3yx07yc8adhm8f58wspnngy9x6djnly7032r01pm3w9xfj";
+       libraryHaskellDepends = [
+         aeson attoparsec attoparsec-aeson base base64-bytestring blaze-html
+         bytestring conduit containers deepseq fast-logger http-api-data
+         lift-type monad-logger mtl path-pieces resource-pool resourcet
+         scientific silently template-haskell text th-lift-instances time
+         transformers unliftio unliftio-core unordered-containers vault
+         vector
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base base64-bytestring blaze-html bytestring
+         conduit containers deepseq fast-logger hspec http-api-data
+         monad-logger mtl path-pieces QuickCheck quickcheck-instances
+         resource-pool resourcet scientific shakespeare silently
+         template-haskell text th-lift-instances time transformers unliftio
+         unliftio-core unordered-containers vector
+       ];
+       benchmarkHaskellDepends = [
+         base criterion deepseq file-embed template-haskell text
+       ];
+       description = "Type-safe, multi-backend data serialization";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.psibi ];
      }) {};
 
···
        broken = true;
      }) {};
 
+  "persistent-mtl_0_5_2" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, containers, esqueleto
+     , exceptions, monad-logger, mtl, persistent, persistent-postgresql
+     , persistent-sqlite, resource-pool, resourcet, skeletest, text
+     , transformers, unliftio, unliftio-core, unliftio-pool
+     }:
+     mkDerivation {
+       pname = "persistent-mtl";
+       version = "0.5.2";
+       sha256 = "0vam2483xqccjc9lfxgfj26hgn1qrqlhi2agbjc06l7a6a4ph1s0";
+       libraryHaskellDepends = [
+         base conduit containers exceptions monad-logger mtl persistent
+         resource-pool resourcet text transformers unliftio unliftio-core
+         unliftio-pool
+       ];
+       testHaskellDepends = [
+         base bytestring conduit containers esqueleto monad-logger
+         persistent persistent-postgresql persistent-sqlite resource-pool
+         resourcet skeletest text unliftio
+       ];
+       testToolDepends = [ skeletest ];
+       description = "Monad transformer for the persistent API";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "persistent-mysql" = callPackage
     ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
      , containers, fast-logger, hspec, http-api-data, HUnit
···
 
   "persistent-sql-lifted" = callPackage
     ({ mkDerivation, annotated-exception, base, containers, esqueleto
-     , mtl, persistent, text, unliftio-core
+     , mtl, persistent, random, text, unliftio-core, vector
      }:
      mkDerivation {
        pname = "persistent-sql-lifted";
-       version = "0.4.0.0";
-       sha256 = "0j6cn49wvgvfqdynz2k7v657hrs9zgca08q31dvhdg95gbiw5492";
+       version = "0.4.2.0";
+       sha256 = "1yd0fx23ww2q4dgjzqk9dicqzggcxh27jgx26hy7wd6mj88hcbh5";
        libraryHaskellDepends = [
-         annotated-exception base containers esqueleto mtl persistent text
-         unliftio-core
+         annotated-exception base containers esqueleto mtl persistent random
+         text unliftio-core vector
        ];
        description = "Monad classes for running queries with Persistent and Esqueleto";
        license = lib.licenses.mit;
···
     ({ mkDerivation, base, bytestring, postgresql-simple }:
      mkDerivation {
        pname = "pgvector";
-       version = "0.1.0";
-       sha256 = "0cpqcq0ly02i8njrgihh1rf0kvmfpa6clh2hx24ym7rz561ai1ms";
+       version = "0.1.1";
+       sha256 = "0wcg9kibhw74wliv39yrkvpi00jbx16jpjfi0lvpix53xdvq83c8";
        libraryHaskellDepends = [ base bytestring postgresql-simple ];
        testHaskellDepends = [ base postgresql-simple ];
        description = "pgvector support for Haskell";
···
        benchmarkHaskellDepends = [ base criterion transformers vector ];
        description = "Phantom State Transformer. Like State Monad, but without values.";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "phantom-state_0_2_1_5" = callPackage
+    ({ mkDerivation, base, criterion, transformers, vector }:
+     mkDerivation {
+       pname = "phantom-state";
+       version = "0.2.1.5";
+       sha256 = "0ylagyy8s9c4pi50j9nl63f0cx6g5pfk2dbivgcsxb8bgp28rp1z";
+       libraryHaskellDepends = [ base transformers ];
+       benchmarkHaskellDepends = [ base criterion transformers vector ];
+       description = "Phantom State Transformer. Like State Monad, but without values.";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "phasechange" = callPackage
···
        pname = "pointed";
        version = "5.0.5";
        sha256 = "1wbfpd978pnkrbi05sf0yj6f50flxr9vl5m85xv3y22hzg6rb7gr";
+       revision = "1";
+       editedCabalFile = "0419jrc452kc24m764drlihmmx3aayzrf5lvrdvq6d327bkx2byh";
        libraryHaskellDepends = [
          base comonad containers data-default-class hashable kan-extensions
          semigroupoids stm tagged transformers transformers-compat
···
        pname = "polysemy";
        version = "1.9.2.0";
        sha256 = "1qwy6a59jdlzc2y7f422yvlwvd9spsgbbpm2r7jcasgxiwq3fkr0";
-       revision = "3";
-       editedCabalFile = "0rmg93dpqfkgpl497hgwh4i3ph4ndf0kbjl89f8ipbb03zfyqp93";
+       revision = "5";
+       editedCabalFile = "1llv3i7dmkrgnxqlxg8154x61vkiq1frsjkwp1qm0hnc3gmfm1pa";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          async base containers first-class-families mtl stm syb
···
      }:
      mkDerivation {
        pname = "polysemy-chronos";
-       version = "0.7.0.0";
-       sha256 = "1x91x960zzpwlscx7mkxfqq5jvd01gkzn66zdza1z0jjrbvkda34";
+       version = "0.7.0.1";
+       sha256 = "1iihnrzj1ghh6ihhd70msswg1wwqar31xhi73qc8is5bwk0y491x";
        libraryHaskellDepends = [
          base chronos incipit-core polysemy-time
        ];
···
      }:
      mkDerivation {
        pname = "polysemy-conc";
-       version = "0.14.1.0";
-       sha256 = "19m7hnx6f53dzkvj8gkbdds9qs1zfrbzy34iznigksmzyhhsjim4";
+       version = "0.14.1.1";
+       sha256 = "1cb7jlfgrspxi7jb0zrnhdgjl2d64na5kk1nda4z34k5s93dl4n0";
        libraryHaskellDepends = [
          async base incipit-core polysemy polysemy-resume polysemy-time stm
          stm-chans torsor unagi-chan
···
   "polysemy-http" = callPackage
     ({ mkDerivation, aeson, base, case-insensitive, exon, hedgehog
      , http-client, http-client-tls, http-types, network, polysemy
-     , polysemy-plugin, prelate, servant-client, servant-server, tasty
-     , tasty-hedgehog, time, warp
+     , polysemy-plugin, prelate, servant, servant-client, servant-server
+     , tasty, tasty-hedgehog, time, warp
      }:
      mkDerivation {
        pname = "polysemy-http";
-       version = "0.13.0.1";
-       sha256 = "15zcnskyy9c60lmidbvyg5rkmnvbbp62x9cix8p4cak19d6rqp1k";
+       version = "0.13.1.0";
+       sha256 = "1a6qsypsjlf6a1nif0mhcbd1g9kdlhgwxj8zkmai35cvgp7n5ix0";
        libraryHaskellDepends = [
          aeson base case-insensitive exon http-client http-client-tls
          http-types polysemy polysemy-plugin prelate time
        ];
        testHaskellDepends = [
          aeson base exon hedgehog http-client network polysemy
-         polysemy-plugin prelate servant-client servant-server tasty
+         polysemy-plugin prelate servant servant-client servant-server tasty
          tasty-hedgehog warp
        ];
        description = "Polysemy effects for HTTP clients";
···
      }:
      mkDerivation {
        pname = "polysemy-log";
-       version = "0.11.0.0";
-       sha256 = "03vbnvbpz3cn88mp2sgdxn2w63ciz26g6y948wszd21srrcix62i";
+       version = "0.11.1.0";
+       sha256 = "0d5spw0w2l013myk4rqa936zx85jd2qiaalgcdn0r2fiyhx2xn6i";
        libraryHaskellDepends = [
          ansi-terminal async base incipit-core polysemy polysemy-conc
          polysemy-time stm time
···
      }:
      mkDerivation {
        pname = "polysemy-log-co";
-       version = "0.9.0.0";
-       sha256 = "18z75dbbqf18ff3dc641svm93fvrdaxzplbaicdy7y3dz3y7apmv";
+       version = "0.11.1.0";
+       sha256 = "18zav4w46ixdpmmwvvsjc9nkv974i28k0g625li2gs77bri1qjsz";
        libraryHaskellDepends = [
          base co-log co-log-concurrent co-log-polysemy incipit-core polysemy
          polysemy-conc polysemy-log polysemy-time stm
···
          base co-log co-log-concurrent co-log-polysemy incipit-core polysemy
          polysemy-log polysemy-test polysemy-time stm tasty
        ];
-       description = "Colog adapters for Polysemy.Log";
+       description = "Colog adapters for polysemy-log";
        license = "BSD-2-Clause-Patent";
        hydraPlatforms = lib.platforms.none;
      }) {};
···
      }:
      mkDerivation {
        pname = "polysemy-log-di";
-       version = "0.11.0.0";
-       sha256 = "00wsqawnclvqw9mi8yh9i607kjgg8vr8rz7fvrzjmdn13xrpy301";
+       version = "0.11.1.0";
+       sha256 = "0si4smmzbz1ykp4r4hbch7dyff4ab18iic4q67p1vqaimf5b7bpb";
        libraryHaskellDepends = [
          base di-polysemy incipit-core polysemy polysemy-conc polysemy-log
          polysemy-time stm
···
        pname = "polysemy-plugin";
        version = "0.4.5.2";
        sha256 = "1inl8wk36fyc6m1fp8pyxmrc82bmznr5f1zasfmxj9q5xxbig87f";
-       revision = "3";
-       editedCabalFile = "1g58g21lqmxkl5d9zmg54q7x1bjahxrfn346z05aniqpx62qrxn3";
+       revision = "5";
+       editedCabalFile = "10af9lnkqi5agr5j3v7wh6lyfg0v4lqrms9vwndhfk7jdh63km6w";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         base containers ghc ghc-tcplugins-extra polysemy syb transformers
+       ];
+       testHaskellDepends = [
+         base containers doctest ghc ghc-tcplugins-extra hspec
+         hspec-discover inspection-testing polysemy should-not-typecheck syb
+         transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Disambiguate obvious uses of effects";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "polysemy-plugin_0_4_5_3" = callPackage
+    ({ mkDerivation, base, Cabal, cabal-doctest, containers, doctest
+     , ghc, ghc-tcplugins-extra, hspec, hspec-discover
+     , inspection-testing, polysemy, should-not-typecheck, syb
+     , transformers
+     }:
+     mkDerivation {
+       pname = "polysemy-plugin";
+       version = "0.4.5.3";
+       sha256 = "09qp68y0vgh35sycbabmw676aajq3vna7cn7gd0ysd2cmm9b6bm1";
+       revision = "1";
+       editedCabalFile = "0cz007a6djra81hp29kmcn0id2ahjbjr48bf6ma4issq4wzc6y3y";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base containers ghc ghc-tcplugins-extra polysemy syb transformers
···
        testToolDepends = [ hspec-discover ];
        description = "Disambiguate obvious uses of effects";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "polysemy-process" = callPackage
···
      }:
      mkDerivation {
        pname = "polysemy-process";
-       version = "0.14.1.0";
-       sha256 = "15jg25chgy92q4k1xl3ndyn3mzc8gkh305zgihzci2lapn55q6cz";
+       version = "0.14.1.1";
+       sha256 = "1csq2mz5h1w4jigk9nmahhxjzl6v3gzk42f28ml4322zqniqkri4";
        libraryHaskellDepends = [
          async base incipit-core path path-io polysemy polysemy-conc
          polysemy-resume polysemy-time posix-pty process stm-chans
···
      }:
      mkDerivation {
        pname = "polysemy-resume";
-       version = "0.9.0.0";
-       sha256 = "1qzpj01pnzi8fapjjrvifkn7v8mw76xz3vfnd9yisxn2xpvgm85h";
+       version = "0.9.0.1";
+       sha256 = "1i9wjlsyq2b0fyspyshk4xxdqc24gqf0pykh0sd3gcd9wnfc4zcg";
        libraryHaskellDepends = [
          base incipit-core polysemy transformers
        ];
···
      }:
      mkDerivation {
        pname = "polysemy-test";
-       version = "0.10.0.0";
-       sha256 = "037bjfl0my8hbhmv5nhlv8bmhxdyk16ql9n5bzw03aqkm7pc7p6k";
+       version = "0.10.0.1";
+       sha256 = "1lsfiwz7vx3rk07wqqlrfh91wc5i4h5ij3w9nhjf54kg6gx9s8w7";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base hedgehog incipit-core path path-io polysemy tasty
···
      }:
      mkDerivation {
        pname = "polysemy-time";
-       version = "0.7.0.0";
-       sha256 = "0yjv0dz6l1a81jl7x6z4sff22qx68cf2vy0fld8v66wppfrpq199";
+       version = "0.7.0.1";
+       sha256 = "0cm1sp553irglfzljlnndly7rw5yabw5bigch7dfy5ssmiksa0kr";
        libraryHaskellDepends = [
          aeson base incipit-core template-haskell time torsor
        ];
···
      }:
      mkDerivation {
        pname = "posit";
-       version = "2022.2.0.1";
-       sha256 = "18rvn0h5fn90cmrj4g19nscl4r658v2piif4afbqqn1ylnf99chk";
+       version = "2022.2.0.2";
+       sha256 = "0zm5vmabxiznzfzv0ldc94qdw8gxm7v2b1pfia00nsv7v728jdgb";
        libraryHaskellDepends = [
          base data-dword deepseq random scientific
        ];
···
      }:
      mkDerivation {
        pname = "postgres-websockets";
-       version = "0.11.2.2";
-       sha256 = "0sjl0r6mg3b3qh4b3y2p1d4q1i6k456v3dj4vw9fhdi51rmyrhah";
+       version = "0.11.2.3";
+       sha256 = "1r4ws0bydwvp3cgy588yh0f9y9ifgrplcdk66mrzvpcp65ssd412";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "postgresql-migration";
        version = "0.2.1.8";
        sha256 = "1lr1fgr23zxhn52jarpwlcxkha23glgin71mdm34ph44xim9n6ra";
+       revision = "1";
+       editedCabalFile = "1r8j7ydf03bddxp1r9jcqg0s2mw1f9mjy6zyz9bhvj3ldrzi5931";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "ppad-aead" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, criterion, ppad-base16
+     , ppad-chacha, ppad-poly1305, primitive, tasty, tasty-hunit, text
+     }:
+     mkDerivation {
+       pname = "ppad-aead";
+       version = "0.1.0";
+       sha256 = "1vvz39m852yp3j0mdm1mx3i5rgl78z0limlgm70al34gv1gxv3mh";
+       libraryHaskellDepends = [
+         base bytestring ppad-chacha ppad-poly1305
+       ];
+       testHaskellDepends = [
+         aeson base bytestring ppad-base16 primitive tasty tasty-hunit text
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion ppad-base16
+       ];
+       description = "A pure AEAD-ChaCha20-Poly1305 construction";
+       license = lib.licenses.mit;
+     }) {};
+
   "ppad-base16" = callPackage
     ({ mkDerivation, base, base16, base16-bytestring, bytestring
-     , criterion, tasty, tasty-quickcheck, weigh
+     , criterion, tasty, tasty-hunit, tasty-quickcheck, weigh
      }:
      mkDerivation {
        pname = "ppad-base16";
-       version = "0.1.0";
-       sha256 = "0n12nac3wvf6rk5sh1bmq3prmn03hy1v3532bnq07x69n9740bcj";
+       version = "0.2.0";
+       sha256 = "1bw7zb59wnjmy0pdl8gzqgkmsa5z2sq26xnidszx0h43j00qgqjk";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
-         base base16-bytestring bytestring tasty tasty-quickcheck
+         base base16-bytestring bytestring tasty tasty-hunit
+         tasty-quickcheck
        ];
        benchmarkHaskellDepends = [
          base base16 base16-bytestring bytestring criterion weigh
···
      }:
      mkDerivation {
        pname = "ppad-base58";
-       version = "0.1.1";
-       sha256 = "1w1b5dayh1qqcqca1fs91w13360bpkndkw5xcjy52qz8a3dlp27k";
+       version = "0.2.0";
+       sha256 = "1bn0fv1vmsc698lpl8x1brgi00bl9rcnh7r8v81rcxnjqf9xfdcb";
        libraryHaskellDepends = [ base bytestring ppad-sha256 ];
        testHaskellDepends = [
          aeson base base16-bytestring bytestring tasty tasty-hunit
···
      }:
      mkDerivation {
        pname = "ppad-bech32";
-       version = "0.2.1";
-       sha256 = "1ing40mgc8i8fjb1ws9p7n0r3rz7lfcamw5f504pnkxn384khyqx";
+       version = "0.2.2";
+       sha256 = "1bp4p6adfi7awy3k2fbi3akjqr5gyiijilgxg5r0hzpnzmzpxvzr";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          array base bytestring tasty tasty-quickcheck
···
        license = lib.licenses.mit;
      }) {};
 
+  "ppad-bip32" = callPackage
+    ({ mkDerivation, array, base, bytestring, criterion, deepseq
+     , ppad-base16, ppad-base58, ppad-ripemd160, ppad-secp256k1
+     , ppad-sha256, ppad-sha512, tasty, tasty-hunit
+     }:
+     mkDerivation {
+       pname = "ppad-bip32";
+       version = "0.1.1";
+       sha256 = "0q76ffxzrbr0fiv18ghgfjrv0y61nvsb6971pl49377c2835qa1l";
+       libraryHaskellDepends = [
+         base bytestring ppad-base58 ppad-ripemd160 ppad-secp256k1
+         ppad-sha256 ppad-sha512
+       ];
+       testHaskellDepends = [
+         array base bytestring ppad-base16 ppad-base58 tasty tasty-hunit
+       ];
+       benchmarkHaskellDepends = [
+         array base bytestring criterion deepseq ppad-secp256k1
+       ];
+       description = "BIP32 hierarchical deterministic wallets";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "ppad-bip39" = callPackage
+    ({ mkDerivation, aeson, array, base, bytestring, criterion, deepseq
+     , ppad-base16, ppad-bip32, ppad-pbkdf, ppad-sha256, ppad-sha512
+     , primitive, tasty, tasty-hunit, text, text-icu, vector
+     }:
+     mkDerivation {
+       pname = "ppad-bip39";
+       version = "0.2.1";
+       sha256 = "1aqcjq1xika89qhxf54z25shg4kz8pmr6k70k48w7lyk85h3l97b";
+       libraryHaskellDepends = [
+         base bytestring ppad-pbkdf ppad-sha256 ppad-sha512 primitive text
+         text-icu
+       ];
+       testHaskellDepends = [
+         aeson array base bytestring ppad-base16 ppad-bip32 tasty
+         tasty-hunit text text-icu vector
+       ];
+       benchmarkHaskellDepends = [
+         array base bytestring criterion deepseq
+       ];
+       description = "BIP39 mnemonic codes";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "ppad-chacha" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, ppad-base16
+     , primitive, tasty, tasty-hunit
+     }:
+     mkDerivation {
+       pname = "ppad-chacha";
+       version = "0.1.0";
+       sha256 = "15idv1nrl2rl5rmx42dw1zwpdr7wvrr08j0k4vwy0s12cc40aka6";
+       libraryHaskellDepends = [ base bytestring primitive ];
+       testHaskellDepends = [
+         base bytestring ppad-base16 primitive tasty tasty-hunit
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion ppad-base16
+       ];
+       description = "A pure ChaCha20 stream cipher";
+       license = lib.licenses.mit;
+     }) {};
+
   "ppad-hkdf" = callPackage
-    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
-     , criterion, ppad-sha256, ppad-sha512, tasty, tasty-hunit, text
+    ({ mkDerivation, aeson, base, bytestring, criterion, ppad-base16
+     , ppad-sha256, ppad-sha512, tasty, tasty-hunit, text
      }:
      mkDerivation {
        pname = "ppad-hkdf";
-       version = "0.2.0";
-       sha256 = "1596cwq8plmdgrnc2hvh88h0v94r3icz0lkrbwq4nsl060vn0328";
+       version = "0.2.1";
+       sha256 = "1y5rmkaq8wgibsx6bvppbaqp13fb9al5yn4ni9x2ll685545m398";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
-         aeson base base16-bytestring bytestring ppad-sha256 ppad-sha512
-         tasty tasty-hunit text
+         aeson base bytestring ppad-base16 ppad-sha256 ppad-sha512 tasty
+         tasty-hunit text
        ];
        benchmarkHaskellDepends = [
          base bytestring criterion ppad-sha256 ppad-sha512
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "ppad-pbkdf" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, criterion, ppad-base16
+     , ppad-sha256, ppad-sha512, tasty, tasty-hunit, text
+     }:
+     mkDerivation {
+       pname = "ppad-pbkdf";
+       version = "0.1.1";
+       sha256 = "05g3k4gyjkpn9k5fhz37lq10qgzlwayf4xiy5m4kjijv7l1wcxqp";
+       libraryHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [
+         aeson base bytestring ppad-base16 ppad-sha256 ppad-sha512 tasty
+         tasty-hunit text
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion ppad-sha256 ppad-sha512
+       ];
+       description = "A password-based key derivation function";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "ppad-poly1305" = callPackage
+    ({ mkDerivation, base, bytestring, criterion, ppad-base16
+     , primitive, tasty, tasty-hunit
+     }:
+     mkDerivation {
+       pname = "ppad-poly1305";
+       version = "0.2.0";
+       sha256 = "1vv3ln9lzszx3h0dji4fqznh86qh40sl34msljddgyj3h709lzk6";
+       libraryHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [
+         base bytestring ppad-base16 primitive tasty tasty-hunit
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring criterion ppad-base16
+       ];
+       description = "A pure Poly1305 MAC";
+       license = lib.licenses.mit;
+     }) {};
+
   "ppad-ripemd160" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, bytestring
      , criterion, SHA, tasty, tasty-hunit, text
···
      }:
      mkDerivation {
        pname = "ppad-secp256k1";
-       version = "0.2.1";
-       sha256 = "1parw2ah759zpdx7ljnz8jsm59kqwzmsf7p5zv2nxivsw1xc2lgf";
+       version = "0.3.0";
+       sha256 = "1k2glxrrpgdngzy0j5mgbkh9a0a5b0cp5c1lmvaiwipik50n9rb3";
        libraryHaskellDepends = [
          base bytestring ppad-hmac-drbg ppad-sha256 primitive
        ];
        testHaskellDepends = [
-         aeson attoparsec base base16-bytestring bytestring tasty
-         tasty-hunit text
+         aeson attoparsec base base16-bytestring bytestring ppad-sha256
+         tasty tasty-hunit text
        ];
        benchmarkHaskellDepends = [
          base base16-bytestring bytestring criterion deepseq weigh
        ];
-       description = "Schnorr signatures & ECDSA on the elliptic curve secp256k1";
+       description = "Schnorr signatures, ECDSA, and ECDH on the elliptic curve secp256k1";
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
      }) {};
···
      }:
      mkDerivation {
        pname = "prelate";
-       version = "0.7.0.1";
-       sha256 = "0xbl3677vj3lf1lkp1whvmh50vx9b78j30k4flddcrziyivrfm6z";
+       version = "0.8.0.0";
+       sha256 = "1qx4s7v5lx7bbfscnccjsh25lgxdvjr975ddqd2hsm5ls8qbag5p";
        libraryHaskellDepends = [
          aeson base exon extra generic-lens incipit microlens microlens-ghc
          polysemy-chronos polysemy-conc polysemy-log polysemy-process
···
        pname = "prettyprinter-interp";
        version = "0.2.0.0";
        sha256 = "0ml068y49n0s6p0nq0qfv5dmpkpkbd9p06hkj582yn2a1h32x0ff";
-       revision = "4";
-       editedCabalFile = "05b86w6670f61hl0dxn7bjhwjx19236qi3ivknwcryim8nrb2kij";
+       revision = "5";
+       editedCabalFile = "0c7m2v51dbgzjfm4pzkbcz9dw0spr8dwqmj5jdrmcwy652vdnh9p";
        libraryHaskellDepends = [
          base prettyprinter string-interpolate template-haskell text
        ];
···
        pname = "prettyprinter-lucid";
        version = "0.2.0.1";
        sha256 = "1kmbqywn15djxsxb98qrrn9cfdpvmq8x4h29fzdx76bsv5zrlvvk";
+       revision = "1";
+       editedCabalFile = "1d5fdkd3l5kbqcqgs7lxgxqpmx4vwa9n3wxzk2bp1hak92m2w1s1";
        libraryHaskellDepends = [ base lucid prettyprinter text ];
        description = "A prettyprinter backend for lucid";
        license = lib.licenses.bsd3;
···
        pname = "probability-polynomial";
        version = "1.0.0.1";
        sha256 = "1f06x4d2cbd9j7rxgwdpxn8ff8w32xag96qk86mwggnzlw091gib";
+       revision = "1";
+       editedCabalFile = "10avhbz8k3yg1hzjp5qbkhv3mmmhrvii5mpjcxqcw9pq635x0kc8";
        libraryHaskellDepends = [
          base containers deepseq exact-combinatorics
        ];
···
        broken = true;
      }) {};
 
+  "prompt-hs" = callPackage
+    ({ mkDerivation, base, microlens, terminal, text }:
+     mkDerivation {
+       pname = "prompt-hs";
+       version = "1.0.0.0";
+       sha256 = "1xl7da4jzbnyiw4qjsbzhmc0wxa0y1wa204knlhi3g2dr3dzhj7g";
+       libraryHaskellDepends = [ base microlens terminal text ];
+       description = "A user-friendly, dependently-typed library for asking your users questions";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "pronounce" = callPackage
     ({ mkDerivation, base, binary, containers, filepath, mtl, safe
      , text
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "proto-lens-etcd" = callPackage
+    ({ mkDerivation, base, Cabal, proto-lens-protobuf-types
+     , proto-lens-protoc, proto-lens-runtime, proto-lens-setup
+     }:
+     mkDerivation {
+       pname = "proto-lens-etcd";
+       version = "0.1.0";
+       sha256 = "11z8xn863pfgg7z4nbr2paqmb3xqb5cr0jzfibisza0yvxwk7y0c";
+       setupHaskellDepends = [ base Cabal proto-lens-setup ];
+       libraryHaskellDepends = [
+         base proto-lens-protobuf-types proto-lens-runtime
+       ];
+       libraryToolDepends = [ proto-lens-protoc ];
+       description = "proto-lens-etcd - protobuffer lenses for etcd provided by protoc-lens-protoc";
+       license = lib.licenses.asl20;
+     }) {};
+
   "proto-lens-jsonpb" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
      , bytestring, proto-lens-runtime, text, vector
···
        pname = "pseudo-boolean";
        version = "0.1.11.0";
        sha256 = "04hkg7nlyrziq3pm44sqr6b5zjb5x3d70xqzblp3h7f1sc6839rr";
-       revision = "1";
-       editedCabalFile = "1myzfrrjj9j0xd9la3iv9jzlgir6l5wxmh279rykjw2whkys20ry";
+       revision = "2";
+       editedCabalFile = "10rrnb6ih4lhck257iz0sx7az36ijcxiaxn29cnjvbc2ngv5m8v9";
        libraryHaskellDepends = [
          attoparsec base bytestring bytestring-builder containers deepseq
          dlist hashable megaparsec parsec void
···
   "push-notify-apn" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, binary, bytestring
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
-     , data-default, hspec, http2, http2-client, lifted-base, mtl
-     , optparse-applicative, random, resource-pool, semigroups, text
-     , time, tls
+     , data-default, hspec, http-types, http2, http2-client, lifted-base
+     , mtl, optparse-applicative, random, resource-pool, semigroups
+     , text, time, tls
      }:
      mkDerivation {
        pname = "push-notify-apn";
-       version = "0.4.0.2";
-       sha256 = "07clkpwysni1m06jjvpgx9fkxflymnkyldkvhdw0qwmy14pk89aw";
+       version = "0.4.0.3";
+       sha256 = "024xanv7wcpmbd2mv4v8gw281gsnx5z15a39zh0v07bgiq7q04wb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson base base16-bytestring binary bytestring containers
          crypton-x509 crypton-x509-store crypton-x509-system data-default
-         http2 http2-client lifted-base mtl random resource-pool semigroups
-         text time tls
+         http-types http2 http2-client lifted-base mtl random resource-pool
+         semigroups text time tls
        ];
        executableHaskellDepends = [
          base bytestring optparse-applicative semigroups text
···
        pname = "pxsl-tools";
        version = "1.0.1";
        sha256 = "1q45l1grcja0mf1g90yxsdlr49gqrx27ycr6vln4hsqb5c0iqcfw";
+       revision = "1";
+       editedCabalFile = "08v41rrpqf2xsj7hyin2jkad6751xalwylzfs07536pj41j4vg8z";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
      }:
      mkDerivation {
        pname = "qq-bytes";
-       version = "1.0.0.0";
-       sha256 = "0b5fkysx2pfn0kyn433gizcrjwy354rx067fvn22l8ag6i6clp5z";
+       version = "1.0.0.1";
+       sha256 = "013c7vbp42bkqs5kbqmp1ag5ly8hcfr3lajlb604ghwhdp7f8kzy";
        libraryHaskellDepends = [ base bytestring template-haskell ];
        testHaskellDepends = [
          base bytestring hedgehog tasty tasty-hedgehog tasty-hunit
···
        pname = "quadratic-irrational";
        version = "0.1.1";
        sha256 = "11nksvr6wnbrphq3ymg93w2xpqw6in3j1qpgbl2f3x9bgiss2l7s";
-       revision = "2";
-       editedCabalFile = "1r6fjnjyncbcfvmgkfflmkmrs0gzr1a299pvnklh04bz1xgzbayy";
+       revision = "3";
+       editedCabalFile = "0y272jnh73ww4768zm4h5vh6ir2l1pnrmk4sbnpvjcx49n83lgs2";
        libraryHaskellDepends = [
          arithmoi base containers integer-roots transformers
        ];
···
        pname = "queues";
        version = "1.0.0";
        sha256 = "0mnn6lgd7101lrmwqy4lf04ncq8ci2kfxydm1rlh879gjvzz3lsr";
-       revision = "3";
-       editedCabalFile = "1w18xd6dsh4sl0xsc87v78ra4ja6fbaliy73sfyd432cgchiyfbh";
+       revision = "4";
+       editedCabalFile = "19appf6z8aavky899wy93487zmjzfhz6jiw1imzm6903q65w4p6r";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base containers hedgehog ];
        benchmarkHaskellDepends = [ base containers tasty-bench ];
···
      }:
      mkDerivation {
        pname = "quickcheck-dynamic";
-       version = "3.4.1";
-       sha256 = "07nixdv2x5dpbsak1mgfd7wjyjlp9nxilghx9v23x8j09257vdj9";
+       version = "4.0.0";
+       sha256 = "11cd2d1sx6qlyhc2ik20a7ppc0a8ggnf3zalbsj8i3vnj20240pa";
        libraryHaskellDepends = [ base containers mtl QuickCheck random ];
        testHaskellDepends = [
          base containers mtl QuickCheck stm tasty tasty-hunit
···
      }:
      mkDerivation {
        pname = "raaz";
-       version = "0.3.10";
-       sha256 = "08gpnkb1nj11rhqybgcfcnglf9h271r1hpgsqv9ljzzyc0d67bkp";
+       version = "0.3.11";
+       sha256 = "0w71rsr4aiv5nr9l088l8zbyj144pdk83sza4mlb61gq17i9dqkf";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "rawlock";
        version = "0.1.1.0";
        sha256 = "1hd62m0r6wiwpzm70pydrkvw2ln78436vak1jd0wiqvdh9z35szj";
-       revision = "1";
-       editedCabalFile = "1gw7ffwhzw650gm2746k88kjhyl7q525mzrqcrj6q8nn9sjabzih";
+       revision = "2";
+       editedCabalFile = "0p2cf0v6xxq1gmi74iapy1wnhk8bsid1gj6s24mjdnv4np7cbvrm";
        libraryHaskellDepends = [
          base io-classes nothunks strict-mvar strict-stm
        ];
···
      , lifted-base, mmorph, mtl, network-uri, parsec, parsers
      , QuickCheck, safe, selective, tasty, tasty-hunit, tasty-quickcheck
      , template-haskell, temporary, text, unordered-containers, xeno
+     , xmlbf, xmlbf-xeno
      }:
      mkDerivation {
        pname = "rdf4h";
-       version = "5.1.0";
-       sha256 = "09avqww8aw3lqlcfji3j9yc8szll264mv2mzkm6pdq5bzw7z460w";
+       version = "5.2.0";
+       sha256 = "03f1dcw4zii4yvq7azhcgpkf59wibjdlvkifb88jp8maiaadzr75";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          algebraic-graphs attoparsec base binary bytestring containers
          deepseq exceptions filepath hashable html-entities http-conduit
          lifted-base mmorph mtl network-uri parsec parsers selective
-         template-haskell text unordered-containers xeno
+         template-haskell text unordered-containers xeno xmlbf xmlbf-xeno
        ];
        executableHaskellDepends = [ base containers text ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "rds-data";
-       version = "0.1.1.2";
-       sha256 = "0hznv0g46a90c9c3jpc3yjgdqy3v7hkvsbzpyg0shp8h412j7ngz";
+       version = "0.1.1.4";
+       sha256 = "08q90rdpkdif5d8q22kwjk9yby2kmfsh2s80dgm55dascqsp95hr";
        isLibrary = false;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Reactive Banana bindings for SDL";
        license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "reactive-banana-sdl2" = callPackage
···
        mainProgram = "real-dice";
      }) {};
 
+  "real-dice_0_1_0_5" = callPackage
+    ({ mkDerivation, base, extra, mtl, primes, QuickCheck, random }:
+     mkDerivation {
+       pname = "real-dice";
+       version = "0.1.0.5";
+       sha256 = "0gcl7ikm22s3jgam8qpi55fj8r9wljzlw3kf62l09nlzzd1644xc";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base mtl primes ];
+       executableHaskellDepends = [ base mtl random ];
+       testHaskellDepends = [ base extra mtl primes QuickCheck ];
+       description = "Random number generation based on physical media touched by humans";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "real-dice";
+     }) {};
+
   "really-simple-xml-parser" = callPackage
     ({ mkDerivation, base, parsec }:
      mkDerivation {
···
        pname = "recover-rtti";
        version = "0.5.0";
        sha256 = "17jx201m9x14d624agxx96wkscmlppilmdsjwnh9p930504f66mp";
+       revision = "1";
+       editedCabalFile = "1m39pwdlnk20lbp45zlgwwp931rhh98qba0rwvzs2789qw3ma57m";
        libraryHaskellDepends = [
          aeson base bytestring containers ghc-heap ghc-prim mtl primitive
          sop-core stm text unordered-containers vector
···
      }:
      mkDerivation {
        pname = "recurly-client";
-       version = "0.0.0.1";
-       sha256 = "1ydaiiagjhgqidwcwr478wlpgqxdznakrqd2mhm08f5ag8idvr3y";
+       version = "0.1.0.0";
+       sha256 = "1s4zis8xn6nm865ay11rwsa9qwhk0djkq6d3xzy20lf3iagg5zzm";
        libraryHaskellDepends = [
          aeson base bytestring ghc-prim http-client http-conduit http-types
          mtl scientific text time transformers unordered-containers vector
···
        pname = "reducers";
        version = "3.12.5";
        sha256 = "0742ry9xjjmhwvlv100d3nz75k7wqr42262kw21n5mmwrka6358h";
+       revision = "1";
+       editedCabalFile = "06iyj53308dxgrji857hqnq83ga52bw2dmp1szvxzc2vbnq0qfv8";
        libraryHaskellDepends = [
          array base bytestring containers fingertree hashable semigroupoids
          text transformers unordered-containers
···
      }:
      mkDerivation {
        pname = "refined-containers";
-       version = "0.1.0.2";
-       sha256 = "03kaxj49alqaj4a0miighchpgzsm7yjyzxw2fxjmvq90lyy59524";
+       version = "0.1.2.0";
+       sha256 = "0j07viznb7l664ynpyr3ww5dymb1df69gwikmvp1vigx0vk8jgg5";
        libraryHaskellDepends = [
          adjunctions base constraints containers deepseq distributive
          hashable indexed-traversable mtl refined reflection
···
        pname = "reflection";
        version = "2.1.9";
        sha256 = "1cwzwncb7zvzdcj5s5pc1qrkh7xj6kyz9b30qq2imvnh3bjdb9y6";
+       revision = "1";
+       editedCabalFile = "1q717za8dn36gxhjbr1vmaw6hv5k4id2230yxl3a6627i34qvwpa";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base containers hspec QuickCheck ];
        testToolDepends = [ hspec-discover ];
···
      }:
      mkDerivation {
        pname = "reflex-fsnotify";
-       version = "0.3.0.1";
-       sha256 = "005nh839xxk139pqw4da2w07blnkcgfpfsw5d1pv69cwb729a1c4";
+       version = "0.3.0.2";
+       sha256 = "1hmz0awhddpnd462m1bzjqp67lzwbg60jkn3qx5cl7rhlqnf685m";
        libraryHaskellDepends = [
          base containers directory filepath fsnotify reflex
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "regex-base_0_94_0_3" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, text }:
+     mkDerivation {
+       pname = "regex-base";
+       version = "0.94.0.3";
+       sha256 = "1gs76xbda39gq8wzb8as3y49npa93vfrndf4q78hsyccb7p2vjp8";
+       libraryHaskellDepends = [ array base bytestring containers text ];
+       description = "Common \"Text.Regex.*\" API for Regex matching";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "regex-compat" = callPackage
     ({ mkDerivation, array, base, regex-base, regex-posix }:
      mkDerivation {
···
        libraryHaskellDepends = [ array base regex-base regex-posix ];
        description = "Replaces/enhances \"Text.Regex\"";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "regex-compat_0_95_2_2" = callPackage
+    ({ mkDerivation, array, base, regex-base, regex-posix }:
+     mkDerivation {
+       pname = "regex-compat";
+       version = "0.95.2.2";
+       sha256 = "071hpcqj18gygdj9scd8bm1zxg9vvp3m0sf6f7a7nsk1qgcd2zp2";
+       libraryHaskellDepends = [ array base regex-base regex-posix ];
+       description = "Replaces/enhances \"Text.Regex\"";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "regex-compat-tdfa" = callPackage
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) pcre;};
 
+  "regex-pcre_0_95_0_1" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, pcre
+     , regex-base
+     }:
+     mkDerivation {
+       pname = "regex-pcre";
+       version = "0.95.0.1";
+       sha256 = "1rdpznvbmg3ra3pjshykds8ra97yqg23nxfxw5dd6sigcv1pp5i9";
+       libraryHaskellDepends = [
+         array base bytestring containers regex-base
+       ];
+       libraryPkgconfigDepends = [ pcre ];
+       description = "PCRE Backend for \"Text.Regex\" (regex-base)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) pcre;};
+
   "regex-pcre-builtin" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, regex-base
      , text
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "regex-pcre2" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, HUnit, pcre2
+     , regex-base, utf8-string
+     }:
+     mkDerivation {
+       pname = "regex-pcre2";
+       version = "1.0.0.0";
+       sha256 = "15vzx9rkn7hxphsl907mbhwq58qvkrd4452y296r4rqk3bimaym1";
+       libraryHaskellDepends = [
+         array base bytestring containers regex-base
+       ];
+       libraryPkgconfigDepends = [ pcre2 ];
+       testHaskellDepends = [ base bytestring HUnit utf8-string ];
+       testPkgconfigDepends = [ pcre2 ];
+       description = "PCRE2 Backend for \"Text.Regex\" (regex-base)";
+       license = lib.licenses.bsd3;
+     }) {inherit (pkgs) pcre2;};
+
   "regex-pderiv" = callPackage
     ({ mkDerivation, base, bitset, bytestring, containers, deepseq
      , ghc-prim, mtl, parallel, parsec, regex-base
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "regex-posix_0_96_0_2" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, regex-base }:
+     mkDerivation {
+       pname = "regex-posix";
+       version = "0.96.0.2";
+       sha256 = "0l41mapdlq8cvlqzd15f99yrqrxlvl2n790v9p2ywpawqdh08mvy";
+       libraryHaskellDepends = [
+         array base bytestring containers regex-base
+       ];
+       description = "POSIX Backend for \"Text.Regex\" (regex-base)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "regex-posix-clib" = callPackage
     ({ mkDerivation }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "regex-rure";
-       version = "0.1.2.0";
-       sha256 = "1my3rmj2766bd00qg25wijgvw7ffk8fq965y2b97s5v00fjds33r";
-       revision = "1";
-       editedCabalFile = "0pyj0ar204q8vhcwn0i5rqjjplsw0b6yhvy57am5b3sgcki41si5";
+       version = "0.1.2.1";
+       sha256 = "04fb363nx2ip8gkm4s4wask14mbs907xnf0z46i7bfg51645fp3w";
        libraryHaskellDepends = [ base bytestring ];
        librarySystemDepends = [ rure ];
        libraryToolDepends = [ c2hs ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "regex-tdfa_1_3_2_3" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, directory
+     , doctest-parallel, filepath, mtl, parsec, regex-base, text
+     , utf8-string
+     }:
+     mkDerivation {
+       pname = "regex-tdfa";
+       version = "1.3.2.3";
+       sha256 = "0vyw69nyx1gdy4l54f5d0vnwrp2xzilbizyjd33h7r95b3wbqwc5";
+       libraryHaskellDepends = [
+         array base bytestring containers mtl parsec regex-base text
+       ];
+       testHaskellDepends = [
+         array base bytestring containers directory doctest-parallel
+         filepath mtl regex-base text utf8-string
+       ];
+       description = "Pure Haskell Tagged DFA Backend for \"Text.Regex\" (regex-base)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "regex-tdfa-pipes" = callPackage
     ({ mkDerivation, array, base, lens, monads-tf, pipes, regex-base
      , regex-tdfa
···
      }:
      mkDerivation {
        pname = "registry";
-       version = "0.6.3.0";
-       sha256 = "0cid38h4mjsbakbgvasipmagl1myjvmpbk0034n5zb8zy4dkmxkh";
+       version = "0.6.3.1";
+       sha256 = "1a0vrl9ji8k7mzgh431wqv9az4kx1qx76abprm9ablrhxhmqryy5";
        libraryHaskellDepends = [
          base containers exceptions hashable mmorph mtl multimap protolude
          resourcet semigroupoids semigroups template-haskell text
···
      }:
      mkDerivation {
        pname = "registry-aeson";
-       version = "0.3.1.0";
-       sha256 = "09agzi08nrfd6hglcwpacybz8y3z0m6mzf5gf7p26b0fd5f5jg77";
+       version = "0.3.1.1";
+       sha256 = "06cfbrplf0qpvfmc0fr73vhf95zqf0lwhphfm10378qdlanp5z10";
        libraryHaskellDepends = [
          aeson base bytestring containers protolude registry
          template-haskell text transformers unordered-containers vector
···
      }:
      mkDerivation {
        pname = "registry-hedgehog";
-       version = "0.8.2.0";
-       sha256 = "0larrg1qp15plb6gip0ghs3zdgg022bs90khias9zdcvcw1i1hvw";
+       version = "0.8.2.1";
+       sha256 = "17y9sp91qdxzvwbvngk9lidljjg84b64sk3y82n05r76ld57wh5m";
        libraryHaskellDepends = [
          base containers hedgehog mmorph multimap protolude registry tasty
          tasty-discover tasty-hedgehog tasty-th template-haskell text
···
      }:
      mkDerivation {
        pname = "registry-hedgehog-aeson";
-       version = "0.3.1.0";
-       sha256 = "0n8v3zx9ybf8yvniifipbk4f5r8jwg1glmf0i1xay8ssjlziriys";
+       version = "0.3.1.1";
+       sha256 = "0g1pvj8990c6zfb54m70z3bylzsz9vbm0ggpxnccinlgjl42igdq";
        libraryHaskellDepends = [
          aeson base containers hedgehog mmorph multimap protolude registry
          scientific tasty tasty-discover tasty-hedgehog tasty-th
···
      }:
      mkDerivation {
        pname = "registry-options";
-       version = "0.2.0.0";
-       sha256 = "1qwiabl7w25ji2pnx2wmh57q7w0bvsdi51ibczx90xn1y4y8j6wm";
+       version = "0.2.1.0";
+       sha256 = "1fdmy2822n81ikbrnfwhm96jb8fwa1bckidjvkk2v26l4fh2m06d";
        libraryHaskellDepends = [
          base boxes bytestring containers HsYAML multimap protolude registry
          template-haskell text th-lift transformers unordered-containers
···
        ];
        description = "Hey! Hey! Can u rel8?";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.sternenseemann ];
      }) {};
 
···
        pname = "relude";
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
        sha256 = "0ikp23nbzrxfalpsk6n8yg3byh43f8hp156wpxx45yc297gmgpil";
-       revision = "2";
-       editedCabalFile = "1lm9rz3y9s4kx75zmbv9n658qj1zsjihgcdz4nrqk0qqrhpvkara";
+       revision = "4";
+       editedCabalFile = "1pfhfswpmqlyhia8lwbx6yf9in3l8m09w1n6g40njqy95s0cxynz";
        libraryHaskellDepends = [
          base bytestring containers deepseq ghc-prim hashable mtl stm text
          transformers unordered-containers
···
        pname = "req";
        version = "3.13.4";
        sha256 = "0s80kl29b7d35v044yvkfa6ja40k4sm3wh26qpnscqzv2n6w8zzk";
-       revision = "2";
-       editedCabalFile = "0sll5a8yhxnh9r76954rp2m7gy4wfik05xk176rpfxhh10yg9pf4";
+       revision = "3";
+       editedCabalFile = "1vfy9adansxpk8ldmmv8iycpgdnf5wdipfxvvpricjsj6lr0zv6k";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson authenticate-oauth base blaze-builder bytestring
···
        pname = "rere";
        version = "0.2.0.1";
        sha256 = "1cbdn8jz1zcbddc0b4ahln1k7vwg0npxhmnmqaasm3byrrr6l271";
-       revision = "3";
-       editedCabalFile = "1b29gpv9zxar9rjz8z0ksyw0h56jyrfzk9ja6zfk6qmw3nj4kf3p";
+       revision = "4";
+       editedCabalFile = "1bn9hif7mb6spyplmxw5sjm5y505yvsa9xnq1aqskn5i74k0hq3h";
        libraryHaskellDepends = [
          base containers fin parsec QuickCheck transformers vec
        ];
···
        pname = "resolv";
        version = "0.2.0.2";
        sha256 = "0jz798kliih4lb16s9bjk7sa9034x1qhyrr8z9sp6ahkz4yjh3c8";
-       revision = "4";
-       editedCabalFile = "0xr36sf4ivlxvhsfxj51zbm1pjgs4j5xby6pzjfyrl74c89nw69y";
+       revision = "5";
+       editedCabalFile = "0ck1bka5c4mpzgafbnv8brld1c8z7q1nyk2kwy8jirpcgpqwda2q";
        libraryHaskellDepends = [
          base base16-bytestring binary bytestring containers
        ];
···
        pname = "resource-registry";
        version = "0.1.0.0";
        sha256 = "0mkx8hf6k0117c15kq3cyqgxbfwjjk0yywp5xf6svdi5g2xpkg5p";
+       revision = "1";
+       editedCabalFile = "0iz6imzg017jf2kn88ir4aqq9ca1aa4xx8h7nfx5dqgj9ps05j7w";
        libraryHaskellDepends = [
          base bimap containers io-classes mtl nothunks strict-stm
        ];
···
      }:
      mkDerivation {
        pname = "retroclash-lib";
-       version = "0.1.2.2";
-       sha256 = "18jkrbg3fhz64n6adxa674jng6ajrq89ib53rhjvm053qsafrllh";
-       revision = "1";
-       editedCabalFile = "0f2l2xvz704yhwb1qwk70z29j3gf1afxvszc6f1sk3cdkkxnxpsd";
+       version = "0.1.2.3";
+       sha256 = "0cxvcxldfl4nl9vhllbs4n0h8615s84mms93kj6g9nl5rvmfgkg7";
        libraryHaskellDepends = [
          barbies base clash-ghc clash-lib clash-prelude containers
          ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise
···
      }:
      mkDerivation {
        pname = "retroclash-sim";
-       version = "0.1.1";
-       sha256 = "147i7nbxyxgsvyj2wiaiipi0s8sp14y1av33yba4s148k38zsiw3";
-       revision = "1";
-       editedCabalFile = "10s1p7j3i37ykwaaf58n1cl3ha128mbl3b6jp9lhvxgxj3f7j06d";
+       version = "0.1.2";
+       sha256 = "16zr84r22474rihxi29fa6hmvk28v96a0w2qr4smffa85isfjd21";
        libraryHaskellDepends = [
          array arrows base clash-ghc clash-lib clash-prelude
          ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "roc-id_0_2_0_4" = callPackage
+    ({ mkDerivation, base, hspec, MonadRandom, Only, QuickCheck, text
+     , vector-sized
+     }:
+     mkDerivation {
+       pname = "roc-id";
+       version = "0.2.0.4";
+       sha256 = "126ijgk7wi06694xcqvjz9amg61pzi2hnx7gq631zwxa6d98czzk";
+       libraryHaskellDepends = [
+         base MonadRandom Only text vector-sized
+       ];
+       testHaskellDepends = [
+         base hspec MonadRandom Only QuickCheck text vector-sized
+       ];
+       description = "Implementation of the ROC (Taiwan) National ID standard";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "rock" = callPackage
     ({ mkDerivation, base, constraints, constraints-extras
      , dependent-hashmap, dependent-sum, deriving-compat, hashable
···
        broken = true;
      }) {};
 
+  "ron-hs" = callPackage
+       sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
+     , containers, criterion, deepseq, directory, hashable, optics-core
+     , optics-th, QuickCheck, scientific, tasty, tasty-hunit
+     , tasty-quickcheck, template-haskell, text, vector
+     }:
+     mkDerivation {
+       pname = "ron-hs";
+       version = "0.4.0";
+       sha256 = "1ya0ap14p4k9ngsnaxvrk9jxs73bapz0wxhr6y726ww70rzk5ycj";
+       libraryHaskellDepends = [
+         attoparsec base bytestring containers deepseq hashable QuickCheck
+         scientific template-haskell text vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory optics-core optics-th
+         QuickCheck tasty tasty-hunit tasty-quickcheck text vector
+       ];
+       benchmarkHaskellDepends = [
+         base base16-bytestring bytestring criterion text
+       ];
+       description = "RON format implementation in haskell";
+       license = "(Apache-2.0 OR MIT)";
+     }) {};
+
   "ron-rdt" = callPackage
     ({ mkDerivation, base, containers, Diff, hashable, integer-gmp, mtl
      , ron, text, time, transformers, unordered-containers
···
      }:
      mkDerivation {
        pname = "rustls";
-       version = "0.2.1.0";
-       sha256 = "03r88q5p6c63h4am2f9wsn9j6yw2vnlqp3f7fxy6z44y36cxjz7w";
+       version = "0.2.2.0";
+       sha256 = "0wbkqy58pf7bxssmm4ixg46inqqmik5fnfvddvl6m2zvnhvh8q9w";
        libraryHaskellDepends = [
          base bytestring containers derive-storable mtl network resourcet
          text transformers
···
        pname = "safe-json";
        version = "1.2.0.2";
        sha256 = "1zl0f3y1kih1y3i6376rkizd9kfklqxf7lnj3aipn5ph935lljrz";
+       revision = "1";
+       editedCabalFile = "06c6ni5bhyg4snkk96piknrblywpkk2r0hb6cip78djvrzi91grz";
        libraryHaskellDepends = [
          aeson base bytestring containers dlist hashable scientific tasty
          tasty-hunit tasty-quickcheck text time unordered-containers
···
        license = lib.licenses.mit;
      }) {};
 
+  "safe-json_1_2_1_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, dlist
+     , hashable, quickcheck-instances, scientific, tasty, tasty-hunit
+     , tasty-quickcheck, temporary, text, time, unordered-containers
+     , uuid, uuid-types, vector
+     }:
+     mkDerivation {
+       pname = "safe-json";
+       version = "1.2.1.0";
+       sha256 = "1yfyk840l9xnigx2c2fkfxcyvlb29ggywp87mk0g80xkgxhxjd42";
+       libraryHaskellDepends = [
+         aeson base bytestring containers dlist hashable scientific tasty
+         tasty-hunit tasty-quickcheck text time unordered-containers
+         uuid-types vector
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers dlist hashable
+         quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck
+         temporary text time unordered-containers uuid uuid-types vector
+       ];
+       description = "Automatic JSON format versioning";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "safe-lazy-io" = callPackage
     ({ mkDerivation, base, extensible-exceptions, parallel, strict-io
      }:
···
        pname = "safecopy";
        version = "0.10.4.2";
        sha256 = "0r2mf0p82gf8vnldx477b5ykrj1x7hyg13nqfn6gzb50japs6h3i";
-       revision = "10";
-       editedCabalFile = "09v9lsa5qgy4p9bigrc2jflgzgn7mfpwjln3n370zgffyas3wryr";
+       revision = "11";
+       editedCabalFile = "034pd8j432bnwpx8gh08fdbdk7mjb986gqwrailjvrcym3rdkcjm";
        libraryHaskellDepends = [
          array base bytestring cereal containers generic-data old-time
          template-haskell text time transformers vector
···
      }:
      mkDerivation {
        pname = "saltine";
-       version = "0.2.1.0";
-       sha256 = "1n9wjqgmb0rdk3fp5mva413646qi2cj7i21k80797xycyrx3v2xa";
+       version = "0.2.2.0";
+       sha256 = "1q1y460ynyki3yv08vswjja8pxdv2mnvkbsqhzg24kbyxq4b9syi";
        libraryHaskellDepends = [
          base bytestring deepseq hashable profunctors text
        ];
···
        pname = "sandwich-contexts";
        version = "0.3.0.1";
        sha256 = "005b2916y6sx8wf82q40iq9jcc7vp2anmlb3pdw0rpwdj8k66pjk";
+       libraryHaskellDepends = [
+         aeson base conduit conduit-extra containers crypton-connection
+         data-default exceptions filepath HTTP http-client http-conduit
+         http-types monad-logger mtl network process random relude retry
+         safe sandwich streaming-commons string-interpolate temporary text
+         time transformers unix-compat unliftio unliftio-core vector
+       ];
+       testHaskellDepends = [
+         base filepath postgresql-simple relude sandwich string-interpolate
+         unliftio
+       ];
+       testToolDepends = [ sandwich ];
+       description = "Contexts for the Sandwich test library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "sandwich-contexts_0_3_0_2" = callPackage
+    ({ mkDerivation, aeson, base, conduit, conduit-extra, containers
+     , crypton-connection, data-default, exceptions, filepath, HTTP
+     , http-client, http-conduit, http-types, monad-logger, mtl, network
+     , postgresql-simple, process, random, relude, retry, safe, sandwich
+     , streaming-commons, string-interpolate, temporary, text, time
+     , transformers, unix-compat, unliftio, unliftio-core, vector
+     }:
+     mkDerivation {
+       pname = "sandwich-contexts";
+       version = "0.3.0.2";
+       sha256 = "01klfrf9n1z6h1iqgb3ccch1dxihp28lh60d44xj3xmfz2q4y5iq";
        libraryHaskellDepends = [
          aeson base conduit conduit-extra containers crypton-connection
          data-default exceptions filepath HTTP http-client http-conduit
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "sandwich-quickcheck_0_2_0_0" = callPackage
+    ({ mkDerivation, base, free, QuickCheck, sandwich, text, unliftio
+     }:
+     mkDerivation {
+       pname = "sandwich-quickcheck";
+       version = "0.2.0.0";
+       sha256 = "0dmpim2hk0922wdmp85md8imih3a4f88iayial6x7plaqa7kwn7c";
+       libraryHaskellDepends = [
+         base free QuickCheck sandwich text unliftio
+       ];
+       testHaskellDepends = [
+         base free QuickCheck sandwich text unliftio
+       ];
+       description = "Sandwich integration with QuickCheck";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "sandwich-slack" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, lens
      , lens-aeson, monad-logger, mtl, safe, safe-exceptions, sandwich
···
 
   "satchmo" = callPackage
     ({ mkDerivation, array, async, base, bytestring, containers
-     , deepseq, directory, hashable, lens, minisat, mtl, process
-     , transformers
+     , deepseq, directory, hashable, microlens, microlens-mtl
+     , microlens-th, minisat, mtl, process, transformers
      }:
      mkDerivation {
        pname = "satchmo";
-       version = "2.9.9.4";
-       sha256 = "0b7wjqakjgnsjpzv92165qp4ha4mdc1p052g7y2w0ncgfnj1c49j";
+       version = "2.9.9.5";
+       sha256 = "1gv4bc3c2d17h15aw22csj354q5hvxg9h6dld73fx152i5r8bgn5";
        libraryHaskellDepends = [
          array async base bytestring containers deepseq directory hashable
-         lens minisat mtl process transformers
+         microlens microlens-mtl microlens-th minisat mtl process
+         transformers
        ];
        testHaskellDepends = [ array base ];
        description = "SAT encoding monad";
···
        pname = "satchmo-toysat";
        version = "0.2.1.0";
        sha256 = "1g6hzgdiiczwk87928xi42lv2swm218i9hs39f3zqpcp8r7fxh61";
-       revision = "2";
-       editedCabalFile = "1q9kdi7l4nzig91b7gl9vqr8285kdfcbgzbkd22204iih6j6cmmf";
+       revision = "3";
+       editedCabalFile = "1lmvfa2hh54433abk42ya72fsm5gjp6mhjqyx7k8gsrnqpfhdvjv";
        libraryHaskellDepends = [
          array base containers satchmo toysolver
        ];
···
        broken = true;
      }) {inherit (pkgs) z3;};
 
+  "sbv_11_4" = callPackage
+    ({ mkDerivation, array, async, base, base16-bytestring, bytestring
+     , containers, cryptohash-sha512, deepseq, directory, filepath
+     , libBF, mtl, pretty, process, QuickCheck, random, syb, tasty
+     , tasty-bench, tasty-golden, tasty-hunit, tasty-quickcheck
+     , template-haskell, text, time, transformers, uniplate, z3
+     }:
+     mkDerivation {
+       pname = "sbv";
+       version = "11.4";
+       sha256 = "1dap0lpx4s40kp3n2m7r3331jrx6mbxd5pa1lv03khdb09w5fhd8";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         array async base base16-bytestring bytestring containers
+         cryptohash-sha512 deepseq directory filepath libBF mtl pretty
+         process QuickCheck random syb template-haskell text time
+         transformers uniplate
+       ];
+       testHaskellDepends = [
+         base bytestring containers deepseq directory filepath mtl process
+         QuickCheck random tasty tasty-golden tasty-hunit tasty-quickcheck
+       ];
+       testSystemDepends = [ z3 ];
+       benchmarkHaskellDepends = [
+         base deepseq filepath process random tasty tasty-bench time
+       ];
+       description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {inherit (pkgs) z3;};
+
   "sbv-program" = callPackage
     ({ mkDerivation, base, bifunctors, containers, pretty-simple, sbv
      }:
···
      }:
      mkDerivation {
        pname = "sbvPlugin";
-       version = "9.10.1";
-       sha256 = "0rdz2a6y23m2h9dcxg4bxl3sqd0q81gd6krflcjhgbhjrbqkjwcx";
+       version = "9.12.1";
+       sha256 = "04xg0bk1v9m5avcnwgnlpx8gw0lm8374x34bwmlhyriw8lywnab5";
        libraryHaskellDepends = [
          base containers ghc ghc-prim mtl sbv template-haskell
        ];
···
      }) {};
 
   "scroll" = callPackage
-    ({ mkDerivation, base, bytestring, case-insensitive, containers
-     , data-default, IfElse, monad-loops, mtl, ncurses
+    ({ mkDerivation, base, base-compat, bytestring, case-insensitive
+     , containers, data-default, IfElse, monad-loops, mtl, ncurses
      , optparse-applicative, random, text, unix, vector
      }:
      mkDerivation {
        pname = "scroll";
-       version = "1.20180421";
-       sha256 = "0apzrvf99rskj4dbmn57jjxrsf19j436s8a09m950df5aws3a0wj";
+       version = "1.20250228.2";
+       sha256 = "1p1741zqsxg017d08ym1clzqcdlai487wb6q12m1q7dr6i8c0gfj";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
-         base bytestring case-insensitive containers data-default IfElse
-         monad-loops mtl ncurses optparse-applicative random text unix
-         vector
+         base base-compat bytestring case-insensitive containers
+         data-default IfElse monad-loops mtl ncurses optparse-applicative
+         random text unix vector
        ];
        description = "scroll(6), a roguelike game";
        license = lib.licenses.gpl2Only;
···
      }:
      mkDerivation {
        pname = "sdl2";
-       version = "2.5.5.0";
-       sha256 = "1kai6mmnwz9qq7q5y8c7wmcdf9qc5m167dzy3brj11jjds4smz93";
-       revision = "1";
-       editedCabalFile = "0r0lzn3hyjvzwqsrqprdzb2c167g7ip2cf07jvm1h5b53qc2a4cx";
+       version = "2.5.5.1";
+       sha256 = "1k60zwqr0kgalw3lyqy6vs9bg8bg40cp64snx8n6rh99050y5cr5";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "sel";
        version = "0.0.2.0";
        sha256 = "0gidvbkcjgyq47gh2p19iawv8jcs7ajvih4mk6pwwbkjs8iybpx4";
+       revision = "2";
+       editedCabalFile = "1p63gjj5m5yac2lcjlagmyn0ss0kvn1c0rsa8hh19885kw5xpqjy";
        libraryHaskellDepends = [
          base base16 bytestring libsodium-bindings text text-display
        ];
···
        pname = "semigroupoids";
        version = "6.0.1";
        sha256 = "07yc5759y4njlb2f7s2yy3ji9akp7xw03w7nybaga514hqq20lqx";
-       revision = "1";
-       editedCabalFile = "0kiz5zx2i955hn3yi51fa193kbdjkpdxrpsb6dl7674lbzv94n7n";
+       revision = "2";
+       editedCabalFile = "089c5hjsjm5dnxmdr1059nhy6pmz63123z0hvn6shf40v2k0dvmz";
        libraryHaskellDepends = [
          base base-orphans bifunctors comonad containers contravariant
          distributive hashable tagged template-haskell transformers
···
        license = lib.licenses.gpl3Only;
      }) {};
 
-  "sequence-formats_1_11_0_0" = callPackage
+  "sequence-formats_1_11_0_1" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, containers, errors
      , exceptions, foldl, hspec, lens-family, pipes, pipes-attoparsec
      , pipes-bytestring, pipes-safe, pipes-zlib, streaming-commons
···
      }:
      mkDerivation {
        pname = "sequence-formats";
-       version = "1.11.0.0";
-       sha256 = "0ywjcq79y5imm951azrg4zddfwv67xkj686nxph3y33z89n55mqs";
+       version = "1.11.0.1";
+       sha256 = "1qzawb3qnn76j7dvb0q8jbblbayggr5hja0x723y09nv1y9lg6g5";
        libraryHaskellDepends = [
          attoparsec base bytestring containers errors exceptions foldl
          lens-family pipes pipes-attoparsec pipes-bytestring pipes-safe
···
        pname = "serialise";
        version = "0.2.6.1";
        sha256 = "1x3p9vi6daf50xgv5xxjnclqcq9ynqg1qw7af3ppa1nizycrg533";
-       revision = "3";
-       editedCabalFile = "0msmv6shqxpfl8vz46mw4vj398h1fvjgrfv0s4dcsmfql44m1zz3";
+       revision = "4";
+       editedCabalFile = "1ipcrg5g450a3aq15l5rhngpfck8krz7c7bvhhrd8fv3q645yjbh";
        libraryHaskellDepends = [
          array base bytestring cborg containers ghc-prim half hashable
          primitive strict text these time unordered-containers vector
···
        pname = "servant";
        version = "0.20.2";
        sha256 = "0rakyjrmn05sb2gxk4bkxlb23zfwm1pjkdg9mh7b4hjgsdwy4fba";
+       revision = "1";
+       editedCabalFile = "17n769vwyyc5hshm71r33ksvn26qcz19017wl9p8xj4igav790pa";
        libraryHaskellDepends = [
        sha256 = "0m0520z20qd3vxh047izb140jbywnhi20i9av7gf6h8f8486cs0m";
          constraints containers deepseq http-api-data http-media http-types
···
        pname = "servant-auth";
        version = "0.4.2.0";
        sha256 = "0h71v9n3vd1ca9kav2b6w53wnk950hxlgp3hcnhyk7yd9aph4nwx";
+       revision = "1";
+       editedCabalFile = "1nzarwir9sncdi2fgsjl6yvq83mx0gj9z3l5d47nl15yzmblgyx4";
        libraryHaskellDepends = [
          aeson base containers jose lens servant text unordered-containers
        ];
···
        pname = "servant-auth-client";
        version = "0.4.2.0";
        sha256 = "1pvqiygnwnkj6y4mi03qnpjlp305cjmpzp7nrqmc2p6qwnl2l4q9";
+       revision = "1";
+       editedCabalFile = "0knqj557cxmjih4dxcyqgyraabsbgihlmf3p06x5rqav6ks2zr8n";
        libraryHaskellDepends = [
          base bytestring containers servant servant-auth servant-client-core
        ];
···
        pname = "servant-auth-docs";
        version = "0.2.11.0";
        sha256 = "127w2ggii2vqs60cnd5ir4azyrxnm7mhfydi156liykk2v8jkkaj";
+       revision = "1";
+       editedCabalFile = "0hnjh3ybc7x39sj4cy3m1c0zq5jwbkq5kz2zh4x1263nyddnxha9";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base lens servant servant-auth servant-docs
···
        pname = "servant-auth-server";
        version = "0.4.9.0";
        sha256 = "0fhk2z9n9ax4g7iisdgcd87wgj9wvazhl86kjh364gsj1g8a5y99";
+       revision = "1";
+       editedCabalFile = "0skvvqkyqzgjdg5b2l9fd1ri144s649g5yddpclwciraimip7gw1";
        libraryHaskellDepends = [
          aeson base base64-bytestring blaze-builder bytestring
          case-insensitive cookie data-default-class entropy http-types jose
···
        pname = "servant-auth-swagger";
        version = "0.2.11.0";
        sha256 = "1h5ckkai4qxz9c2a62l2lv0ss8az5j1lwyzs4g652zffrgx9qk28";
+       revision = "1";
+       editedCabalFile = "1djifng1y6sgxbcwavdc9w52n0wv99b0wya8byszzg5kjk2vzfkj";
        libraryHaskellDepends = [
          base lens servant servant-auth servant-swagger swagger2 text
        ];
···
        pname = "servant-client";
        version = "0.20.2";
        sha256 = "026bp0qk2bx672834yjxmqrfacyzzdssm89bd0niz1xzxzmw5r7g";
+       revision = "2";
+       editedCabalFile = "1sm0xspcsxn6n70nirpglcmx07sn6vmag8kvvw9i2dr2hcfkgk55";
        libraryHaskellDepends = [
          base base-compat bytestring containers deepseq exceptions
          http-client http-media http-types kan-extensions monad-control mtl
···
        pname = "servant-client-core";
        version = "0.20.2";
        sha256 = "10nv810ns8v1d9a2fkg9bgi7h9gm4yap1y6mg2r15d569i27rrvc";
+       revision = "1";
+       editedCabalFile = "13200adlbl8mydi35x1r8w4q9ra8y079figgjxl5jsrhvps54608";
        libraryHaskellDepends = [
          aeson base base-compat base64-bytestring bytestring constraints
          containers deepseq exceptions free http-media http-types
···
        pname = "servant-docs";
        version = "0.13.1";
        sha256 = "1gdv5yrdqfsb4am8rn9fj7gl4f1nswlcbqnp6kc33j5z0mv35z4y";
+       revision = "1";
+       editedCabalFile = "0fwjz2xmxzzibldhyql5mg3zy90ijf560vps885pi48brnz50yla";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "servant-foreign";
        version = "0.16.1";
        sha256 = "15a5cfiihmav7yq6nfp5f365649q054nk02hpf3lsaw8alpbivpp";
+       revision = "1";
+       editedCabalFile = "1qgzy6giw14gss9qny4c2p2lqid0x0al03m9i9gqlaac8zfvr7ka";
        libraryHaskellDepends = [
          base base-compat http-types lens servant text
        ];
···
        pname = "servant-http-streams";
        version = "0.20.2";
        sha256 = "029i6rqmj6q5fn32vimr92rwgfb0c5l5cm19ncrw48nh78pgp0zm";
+       revision = "1";
+       editedCabalFile = "1k1yl2n7j1j8n5d88y0i6ddxgakzd55h94my4rgmga7c8vrd2ynn";
        libraryHaskellDepends = [
          base base-compat bytestring case-insensitive containers deepseq
          exceptions http-common http-media http-streams http-types
···
        pname = "servant-quickcheck";
        version = "0.1.1.0";
        sha256 = "0hzfwqxbcgf9mxzlhw53pv99jxlpib56xjsnh8yw15j2pgb908qs";
+       revision = "1";
+       editedCabalFile = "0lppp61x971hkz3cw2ag2aqnpfjk4bk3vsf80rivhw4r2fv53p07";
        libraryHaskellDepends = [
          aeson base base-compat-batteries bytestring case-insensitive clock
          data-default-class hspec http-client http-media http-types mtl
···
        pname = "servant-server";
        version = "0.20.2";
        sha256 = "0fqgnzzgbj4w441h3v841lav7gxazakz04s354r24pq4rh6m1kqy";
+       revision = "1";
+       editedCabalFile = "0qjl1yrr0l7kynrndv8qmpzl0jz9nzb7c4v9r7kxq05nnb7xpqbz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "servant-swagger";
        version = "1.2.1";
        sha256 = "18cvybmmp8cp8scpb7hncgn8jra8v82mby1bibysn6xbjy5pqlxq";
+       revision = "1";
+       editedCabalFile = "09ji1vb4a8h2gggf08garwhzz7ms2g7jb9sa19nbwgkgg0zbvd3w";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          aeson aeson-pretty base base-compat bytestring hspec http-media
···
        doCheck = false;
        description = "Utilities for cross-compiling with Shake";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "shake-literate" = callPackage
···
        maintainers = [ lib.maintainers.danielrolls ];
      }) {};
 
-  "shellify_0_12_0_1" = callPackage
+  "shellify_0_14_0_0" = callPackage
     ({ mkDerivation, base, containers, data-default, directory, extra
-     , hspec, hspec-core, HStringTemplate, mtl, parsec, raw-strings-qq
-     , shake, text, unordered-containers
+     , hspec, hspec-core, HStringTemplate, lens, mtl
+     , optparse-applicative, parsec, raw-strings-qq, shake, text
+     , unordered-containers
      }:
      mkDerivation {
        pname = "shellify";
-       version = "0.12.0.1";
-       sha256 = "1w9cmn4pydnzf4iv3yar6q0w6ic06rs4k46vy768w0pydmspffs2";
+       version = "0.14.0.0";
+       sha256 = "09i55y57innmjbgb0x1bvrbpk0c5py0bb004wxnqpw4b8swxc60r";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base containers data-default directory extra HStringTemplate mtl
-         parsec raw-strings-qq shake text unordered-containers
+         base containers data-default directory HStringTemplate lens mtl
+         optparse-applicative parsec raw-strings-qq shake text
+         unordered-containers
+       ];
+       executableHaskellDepends = [
+         base optparse-applicative raw-strings-qq text
        ];
-       executableHaskellDepends = [ base raw-strings-qq text ];
-       testHaskellDepends = [ base hspec hspec-core raw-strings-qq text ];
+       testHaskellDepends = [
+         base data-default extra hspec hspec-core optparse-applicative
+         raw-strings-qq text
+       ];
        description = "A tool for generating shell.nix files";
        license = lib.licenses.asl20;
        hydraPlatforms = lib.platforms.none;
···
        testToolDepends = [ hspec-discover ];
        description = "Parse strings into words, like a shell would";
        license = lib.licenses.mit;
+     }) {};
+
+  "shellwords_0_1_4_3" = callPackage
+    ({ mkDerivation, base, hspec, hspec-discover, megaparsec, text }:
+     mkDerivation {
+       pname = "shellwords";
+       version = "0.1.4.3";
+       sha256 = "054pmhh6yiblycckx9702wxqdx6wj3a29j3vb8arbm9mgyfjvy26";
+       libraryHaskellDepends = [ base megaparsec text ];
+       testHaskellDepends = [ base hspec megaparsec ];
+       testToolDepends = [ hspec-discover ];
+       description = "Parse strings into words, like a shell would";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "shelly" = callPackage
···
        pname = "si-timers";
        version = "1.5.0.0";
        sha256 = "0mpxcwjvymgawy8934sa8hkzz14dwagi8lbr1gqr9q5400wzixwk";
-       revision = "1";
-       editedCabalFile = "1k5mq1hd0hsn6j5kqz7px57nc17kpbcmghqsx7svp2jy0hp8qg4i";
+       revision = "2";
+       editedCabalFile = "0v24yy53ka3cxncjxjix7fhfkfnnnbh7vykm982kvwc1sm1nc4qw";
        libraryHaskellDepends = [
          base deepseq io-classes mtl nothunks stm time
        ];
···
      }:
      mkDerivation {
        pname = "skeletest";
-       version = "0.2.0";
-       sha256 = "1mm1sy5n23ic4cc4f02r4n8n7a6kjx40v31wcnmb03ydcpljk5w8";
+       version = "0.2.1";
+       sha256 = "1jd5qfcrqqfj2sp61vs5yh4zvagyd5qqkq9g2qggbj63b789hg48";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "sketch-frp-copilot";
-       version = "1.0.10";
-       sha256 = "1qfjn3w6733d1pch7pmz7b437grah0s5vahhrccd1757ywmxq32s";
+       version = "1.0.11";
+       sha256 = "1jjdhkajglwir0mkpd0yfrzjkpmidrk0f0xb9pivz1w1xqhvl5v4";
        libraryHaskellDepends = [
          base containers copilot copilot-c99 copilot-language mtl
          optparse-applicative
···
      }:
      mkDerivation {
        pname = "slack-web";
-       version = "2.0.1.0";
-       sha256 = "08l26agaqydd6dqsknpmxcpqbm9aw8ahl0dja0sf3dxyjph7wxcn";
+       version = "2.2.0.0";
+       sha256 = "1nz59hf489b8avjkldf090xj92q194cgk7zhky1vj78i16pyarj5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "smith" = callPackage
-    ({ mkDerivation, base, bytesmith, primitive }:
+    ({ mkDerivation, base, bytesmith, contiguous, primitive }:
      mkDerivation {
        pname = "smith";
-       version = "0.1.1.0";
-       sha256 = "0ylhzs0lc7fxp54s74slffkr8rnasy4pak4snyi5jnvma0wiz55g";
-       revision = "1";
-       editedCabalFile = "00l8f3az6h9vadnyn17kg6ng3p0pp9b17gxilrkriwwjlmjvl81w";
-       libraryHaskellDepends = [ base bytesmith primitive ];
+       version = "0.2.0.0";
+       sha256 = "0yimwfp05f8ys0fk87c1p4jz1bib287vzb20wmwawdf1g13q2v8x";
+       libraryHaskellDepends = [ base bytesmith contiguous primitive ];
        description = "Parse arrays of tokens";
        license = lib.licenses.bsd3;
      }) {};
···
      }:
      mkDerivation {
        pname = "snap-extras";
-       version = "0.12.3.1";
-       sha256 = "04prc1gbir7kyakqb71mj1x3lxl09n2lybb2df7ksczv96qg6dsx";
+       version = "0.12.3.2";
+       sha256 = "1w4v3ff0hx3y08hr3q7ifklfg3d3mjvb5nn7ncmg8fxccvxv67w4";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
 
   "snappy" = callPackage
     ({ mkDerivation, base, bytestring, QuickCheck, snappy
-     , test-framework, test-framework-quickcheck2
+     , system-cxx-std-lib, test-framework, test-framework-quickcheck2
      }:
      mkDerivation {
        pname = "snappy";
-       version = "0.2.0.2";
-       sha256 = "14fdx0fikkd9krpzqrvas6mjqmmhmh0qwqzvz1kymil7d8rdyr85";
-       libraryHaskellDepends = [ base bytestring ];
+       version = "0.2.0.3";
+       sha256 = "0jy747dg58smzzr1mzrm751bkwvnaaghn65ppfkqbpqz6jw45qq2";
+       libraryHaskellDepends = [ base bytestring system-cxx-std-lib ];
        librarySystemDepends = [ snappy ];
        testHaskellDepends = [
          base bytestring QuickCheck test-framework
          test-framework-quickcheck2
        ];
-       description = "Bindings to the Google Snappy library for fast compression/decompression";
-       license = lib.licenses.bsd3;
+       description = "Fast Haskell bindings to Google’s Snappy compression library";
+       license = lib.licenses.asl20;
      }) {inherit (pkgs) snappy;};
 
   "snappy-c" = callPackage
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "snelstart-import" = callPackage
+    ({ mkDerivation, base, base64, blaze-html, bytestring, cassava
+     , hexml, neat-interpolation, optparse-applicative, shakespeare
+     , tasty, tasty-hunit, tasty-quickcheck, text, time, vector, warp
+     , yesod-core, yesod-form
+     }:
+     mkDerivation {
+       pname = "snelstart-import";
+       version = "1.1.0";
+       sha256 = "0aiqk4a7g68c88q68fdv0yfg389lmy5wgkrnr2z0fq1fpvhbj6n0";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base base64 blaze-html bytestring cassava hexml neat-interpolation
+         optparse-applicative shakespeare text time vector warp yesod-core
+         yesod-form
+       ];
+       executableHaskellDepends = [
+         base base64 blaze-html bytestring cassava hexml neat-interpolation
+         optparse-applicative shakespeare text time vector warp yesod-core
+         yesod-form
+       ];
+       testHaskellDepends = [
+         base base64 blaze-html bytestring cassava hexml neat-interpolation
+         optparse-applicative shakespeare tasty tasty-hunit tasty-quickcheck
+         text time vector warp yesod-core yesod-form
+       ];
+       description = "Import to snelstart";
+       license = lib.licenses.mit;
+       mainProgram = "snelstart-import";
+     }) {};
+
   "snipcheck" = callPackage
     ({ mkDerivation, base, containers, pandoc, process, text }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "socket-unix";
-       version = "0.2.0.0";
-       sha256 = "1b1myhhd029y8sk4cjqq0fdw3av1jbz80ksaxad0zxybdl8r2xad";
+       version = "0.2.1.0";
+       sha256 = "1f4lsqkh60d2111715qkjrgj7qv8hk3wrh0v6xzzkckvaaq41gyw";
        libraryHaskellDepends = [ base bytestring socket ];
        testHaskellDepends = [
          async base bytestring socket tasty tasty-hunit unix
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "sorted-list_0_2_3_0" = callPackage
+  "sorted-list_0_3_1_0" = callPackage
     ({ mkDerivation, base, criterion, deepseq, QuickCheck }:
      mkDerivation {
        pname = "sorted-list";
-       version = "0.2.3.0";
-       sha256 = "1vppqbgvkxrqs0jx2wx21lczdjhivzxh3cw6wmf8bmxgi9rphkwf";
-       libraryHaskellDepends = [ base deepseq ];
+       version = "0.3.1.0";
+       sha256 = "1cdwglk8963vzhg2gyx63az0nnq0n9w2j5c0x887089n4lxs7kml";
+       libraryHaskellDepends = [ base deepseq QuickCheck ];
        testHaskellDepends = [ base QuickCheck ];
        benchmarkHaskellDepends = [ base criterion ];
        description = "Type-enforced sorted lists and related functions";
···
      }:
      mkDerivation {
        pname = "stack";
-       version = "3.3.1";
-       sha256 = "0lg80szv0w01ij8lllpbkqvhjix2f0a45knqx2msk5dk6q1z75kz";
+       version = "3.5.1";
+       sha256 = "12423vw5k576c1yy0mg40cjia8j6b9jsf8p2489ixlvm192fza7f";
        configureFlags = [
          "-fdisable-git-info" "-fhide-dependency-versions"
          "-fsupported-build"
···
      }:
      mkDerivation {
        pname = "stackctl";
-       version = "1.7.3.0";
-       sha256 = "1k9j5xfiypr8afvz8pjg5dw6jm5ac7s015n6swr07g5fswbj43pn";
+       version = "1.7.3.4";
+       sha256 = "0y0prp85gf5yns5lb9285g2xqfy8w5ck2ajkpiljnmff2zqnlyzb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "statestack";
        version = "0.3.1.1";
        sha256 = "1747qzaj3xqc90fj4ddch3ra5kj52rfd1dn7a8c6fkdk68q76mfd";
-       revision = "3";
-       editedCabalFile = "0v43wd19i2pj8f4skxvxjap1rs0jxfwjicpyd9vgdfqji6jaj7a7";
+       revision = "4";
+       editedCabalFile = "0xqpmncljr202drqbq60i2llvz40k55xc3pwcjznq34566npqy16";
        libraryHaskellDepends = [ base mtl transformers ];
        description = "Simple State-like monad transformer with saveable and restorable state";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "stm-actor";
-       version = "0.3.1.0";
-       sha256 = "0s68c8lrlh2d3n9k3nq6pl31lyxnvfxyd09da133lcl0msksicmf";
+       version = "0.3.1.1";
+       sha256 = "0c94y6ancgv90nf2shskjlnkrsx9rcmz10jmcv4xxnmr2cvc16f3";
        libraryHaskellDepends = [
          base mtl stm stm-queue transformers unliftio-core
        ];
···
        pname = "streamly";
        version = "0.10.1";
        sha256 = "1iyvrhjlvfww5jmwdfx58pr5xi9jzv5h22g0nvnhgnrnxhm86sxn";
-       revision = "5";
-       editedCabalFile = "0lyranmdlbvx22dmhlqyxjd6lx9bp6i3sfvwgkjk71cwqmd0vzvf";
+       revision = "6";
+       editedCabalFile = "0jppiaqj930jcvacikaq2kri1ywj7wdmf3jsb2yi303xwp0z1kf0";
        libraryHaskellDepends = [
          atomic-primops base containers deepseq directory exceptions
          hashable heaps lockfree-queue monad-control mtl network
···
        pname = "streamly-bytestring";
        version = "0.2.2";
        sha256 = "0c1dnvmqjwk18i8mbimaa1khhj6x6ch45i57giidqin00n11n3cq";
+       revision = "1";
+       editedCabalFile = "161x23kagixbvf9zvmhdvnaxh8sixilj5rz7f51blq3c8578ljfx";
        libraryHaskellDepends = [ base bytestring streamly-core ];
        testHaskellDepends = [
          base bytestring directory filepath hspec hspec-discover QuickCheck
···
        pname = "strict-mvar";
        version = "1.5.0.0";
        sha256 = "0pj6wiy0njzl71p0d0z8asr72v4xzy22lmnj454h372ixgwidjfh";
+       revision = "1";
+       editedCabalFile = "12ilb3lnqzgjk4ncdz1ik6m55mhsqnihdh21pmpl1iz1ywn81kn4";
        libraryHaskellDepends = [ base io-classes ];
        testHaskellDepends = [
          base io-sim nothunks QuickCheck tasty tasty-quickcheck
···
        pname = "strict-stm";
        version = "1.5.0.0";
        sha256 = "1p8vjdymsjkgz0ahk83smh1mfr79r1ysv1dsw1wwn8sax4jyzwyn";
+       revision = "1";
+       editedCabalFile = "1if46i47417l1c7z8mpgv0xkfx8dyy4pp4sm2v7ca5s65bpbyd7f";
        libraryHaskellDepends = [ array base io-classes stm ];
        description = "Strict STM interface polymorphic over stm implementation";
        license = lib.licenses.asl20;
···
        maintainers = [ lib.maintainers.raehik ];
      }) {};
 
+  "strongweak_0_12_0" = callPackage
+    ({ mkDerivation, base, generic-random, hspec, hspec-discover
+     , QuickCheck, quickcheck-instances, rerefined, text
+     , text-builder-linear, vector, vector-sized
+     }:
+     mkDerivation {
+       pname = "strongweak";
+       version = "0.12.0";
+       sha256 = "1z3p0wq88h6l056pyfvchxpwrlwypnxaad0g1wqdz7nsigd3fn12";
+       libraryHaskellDepends = [
+         base rerefined text text-builder-linear vector vector-sized
+       ];
+       testHaskellDepends = [
+         base generic-random hspec QuickCheck quickcheck-instances rerefined
+         text text-builder-linear vector vector-sized
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Convert between strong and weak representations of types";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = [ lib.maintainers.raehik ];
+     }) {};
+
   "strptime" = callPackage
     ({ mkDerivation, base, bytestring, text, time }:
      mkDerivation {
···
     ({ mkDerivation, base, css-syntax, network-uri, text }:
      mkDerivation {
        pname = "stylist-traits";
-       version = "0.1.3.1";
-       sha256 = "0dw26liwvp490njpj1p8mjkanin1mmx68pd0br034ppaq3aacmnl";
-       revision = "1";
-       editedCabalFile = "0yh6jsv0irgkb094qjhdx32mzs4sn9k03kymdzx80z0yivhlkgjw";
+       version = "0.1.4.0";
+       sha256 = "01fssw9f8f7pdngk76n92lmqibyzhzgwm70468x6xzf8ipnp7g0w";
        libraryHaskellDepends = [ base css-syntax network-uri text ];
        description = "Traits, datatypes, & parsers for Haskell Stylist";
        license = lib.licenses.gpl3Only;
···
        license = lib.licenses.mit;
      }) {};
 
+  "succinct" = callPackage
+    ({ mkDerivation, aeson, appar, array, attoparsec, attoparsec-aeson
+     , base, bits-extra, bytestring, c2hs, cassava, cereal, containers
+     , criterion, deepseq, directory, dlist, doctest, doctest-discover
+     , filepath, generic-lens, ghc-prim, hedgehog, hspec, hspec-discover
+     , hw-bits, hw-hedgehog, hw-hspec-hedgehog, hw-int, hw-ip, hw-prim
+     , hw-string-parse, lens, mmap, mtl, optparse-applicative
+     , prettyprinter, QuickCheck, resourcet, safe, scientific, text
+     , transformers, unordered-containers, vector, weigh, word8
+     }:
+     mkDerivation {
+       pname = "succinct";
+       version = "0.0.0.1";
+       sha256 = "0wxm1w3417jm7lq25fj7k11nga00dwirkvqn0858x386xc8dczf9";
+       isLibrary = false;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson array attoparsec attoparsec-aeson base bits-extra bytestring
+         cereal containers deepseq directory dlist ghc-prim hedgehog hspec
+         hw-bits hw-int hw-prim lens mmap mtl prettyprinter resourcet safe
+         scientific text transformers vector word8
+       ];
+       libraryToolDepends = [ c2hs ];
+       executableHaskellDepends = [
+         aeson appar attoparsec base bits-extra bytestring deepseq directory
+         dlist generic-lens ghc-prim hedgehog hw-bits hw-ip hw-prim lens
+         mmap mtl optparse-applicative resourcet text transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson attoparsec attoparsec-aeson base bits-extra bytestring
+         cassava deepseq directory dlist doctest doctest-discover filepath
+         ghc-prim hedgehog hspec hw-bits hw-hedgehog hw-hspec-hedgehog
+         hw-int hw-prim hw-string-parse lens mmap QuickCheck scientific text
+         transformers vector weigh
+       ];
+       testToolDepends = [ doctest-discover hspec-discover ];
+       benchmarkHaskellDepends = [
+         base bits-extra bytestring cassava containers criterion deepseq
+         directory generic-lens ghc-prim hedgehog hw-bits hw-prim lens mmap
+         resourcet transformers vector
+       ];
+       doHaddock = false;
+       description = "Memory efficient JSON parser";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "suffix" = callPackage
     ({ mkDerivation, base, bytestring, containers, deepseq, primitive
      , tasty, tasty-hunit, tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "sv2v";
-       version = "0.0.12";
-       sha256 = "1sqcwvpm9c48fpghlb8bi1k3f4hm2mljcyszk5xl6b6wnh3qpql6";
-       revision = "1";
-       editedCabalFile = "1b9zamqkw21vqwxxv7cqnml4waq74gir6gcxk2g0ljn76ayaqfpr";
+       version = "0.0.13";
+       sha256 = "0gg8972im84gp60qavpmsdxcmjwzsbbg3va2f0fdxz5yqyc96cdn";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        pname = "svg-builder";
        version = "0.1.1";
        sha256 = "1k420f497lzkymmxin88ql6ib8dziic43avykv31yq65rgrf7l2g";
-       revision = "10";
-       editedCabalFile = "1a57i9fgmjaz2m68i21dp6hi1qwfmza0d1rcygvq61sxrr9gvfpr";
+       revision = "11";
+       editedCabalFile = "01dxjh49d6kysmvzv529s4jniqpc875sdnkia9dvxx6b73mrsyqs";
        libraryHaskellDepends = [
          base blaze-builder bytestring hashable text unordered-containers
        ];
···
        license = "unknown";
      }) {};
 
+  "sydtest-yesod_0_3_0_3" = callPackage
+    ({ 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.3";
+       sha256 = "1674k3frszzwmk5c94wxwgdfabbi804kbbsjcih7z5g7z6jaljh4";
+       libraryHaskellDepends = [
+         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 monad-logger 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";
+       license = "unknown";
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "syfco" = callPackage
     ({ mkDerivation, array, base, containers, convertible, directory
      , mtl, parsec, transformers
···
        broken = true;
      }) {};
 
+  "symbolise" = callPackage
+    ({ mkDerivation, base, youProbablyWantSymbolizeWithAZ }:
+     mkDerivation {
+       pname = "symbolise";
+       version = "0.0.0.1";
+       sha256 = "0hxz1nqyxz5z1467g4qd618m1fs3zbgn9qjp0c6zrvmgaglgs206";
+       libraryHaskellDepends = [ base youProbablyWantSymbolizeWithAZ ];
+       description = "You want Symbolize with a Z";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {youProbablyWantSymbolizeWithAZ = null;};
+
   "symbolize" = callPackage
-    ({ mkDerivation, async, base, bytestring, containers, deepseq
-     , doctest-parallel, hashable, hedgehog, tasty, tasty-discover
-     , tasty-golden, tasty-hedgehog, tasty-hunit, text, text-display
-     , text-short, unordered-containers
+    ({ mkDerivation, async, base, binary, bytestring, deepseq
+     , doctest-parallel, hashable, hedgehog, random, tasty, tasty-bench
+     , tasty-discover, tasty-golden, tasty-hedgehog, tasty-hunit, text
+     , text-short, vector, vector-hashtables
      }:
      mkDerivation {
        pname = "symbolize";
-       version = "0.1.0.3";
-       sha256 = "0nn9ixj0sprg2d7alx3qhjspmz00x4g371pwmg3b0xdjhfr44qzx";
+       version = "1.0.3.1";
+       sha256 = "1l2zq1hl3vjkcaszwmrk8vycsvn6wja4a57ghl8xcnq06vgbvv5n";
        libraryHaskellDepends = [
-         base bytestring containers deepseq hashable text text-display
-         text-short unordered-containers
+         base binary bytestring deepseq hashable random text text-short
+         vector vector-hashtables
        ];
        testHaskellDepends = [
-         async base bytestring containers deepseq doctest-parallel hashable
-         hedgehog tasty tasty-golden tasty-hedgehog tasty-hunit text
-         text-display text-short unordered-containers
+         async base binary bytestring deepseq doctest-parallel hashable
+         hedgehog random tasty tasty-golden tasty-hedgehog tasty-hunit text
+         text-short vector vector-hashtables
        ];
        testToolDepends = [ tasty-discover ];
+       benchmarkHaskellDepends = [
+         base binary bytestring deepseq hashable random tasty-bench text
+         text-short vector vector-hashtables
+       ];
        description = "Efficient global Symbol table, with Garbage Collection";
        license = lib.licenses.bsd3;
      }) {};
···
        testToolDepends = [ hspec-discover ];
        description = "Library for symbolic integration of mathematical expressions";
        license = lib.licenses.asl20;
+     }) {};
+
+  "synapse" = callPackage
+    ({ mkDerivation, base, easyplot, hashable, HUnit, random
+     , terminal-progress-bar, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "synapse";
+       version = "0.1.0.0";
+       sha256 = "1i6y4cq91kdlwpg9vqdbn92ypkkrk12blxpp2p70y7xxb4drc9cb";
+       libraryHaskellDepends = [
+         base hashable random terminal-progress-bar unordered-containers
+         vector
+       ];
+       testHaskellDepends = [ base easyplot HUnit random ];
+       description = "Synapse is a machine learning library written in pure Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sync" = callPackage
···
        pname = "tar";
        version = "0.6.4.0";
        sha256 = "1apkq11xg0rqbgs83hag85r4ibdw7v09n1qj0l0962d80h0aajbr";
+       revision = "1";
+       editedCabalFile = "05fqzjmcp7qqk1cb23dahszrcpk88cpasi4703irkzj90hvlj9d7";
        libraryHaskellDepends = [
          array base bytestring containers deepseq directory
          directory-ospath-streaming file-io filepath os-string time
···
        mainProgram = "target";
      }) {inherit (pkgs) z3;};
 
+  "targeted-quickcheck" = callPackage
+    ({ mkDerivation, base, containers, hspec, QuickCheck }:
+     mkDerivation {
+       pname = "targeted-quickcheck";
+       version = "0.1.0.1";
+       sha256 = "04b96vr01q19m4gvzim4nkrnmyz2lm7l8iirnw8m6vsglxc65fym";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base QuickCheck ];
+       executableHaskellDepends = [ base containers hspec QuickCheck ];
+       description = "Targeted generators for QuickCheck";
+       license = lib.licenses.mit;
+       mainProgram = "targeted-examples";
+     }) {};
+
   "tart" = callPackage
     ({ mkDerivation, array, base, binary, brick, bytestring, containers
      , directory, microlens-platform, microlens-th, mtl, text
-     , text-zipper, vector, vty
+     , text-zipper, vector, vty, vty-crossplatform
      }:
      mkDerivation {
        pname = "tart";
-       version = "0.3";
-       sha256 = "0zqj8cz4q1447an9fak73vzandd497xa745km3w4y3cffnc0zwyw";
-       revision = "1";
-       editedCabalFile = "0n8l43anikll6l81rmm5y7qj6rmzmnr502n00qyzz2jqwgygdrzy";
+       version = "0.4";
+       sha256 = "057fsq5lp7rj39kplirm0dgjsw4p9xh17b743liikzb43d45j9ar";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        executableHaskellDepends = [
          base brick containers directory microlens-platform microlens-th mtl
-         text text-zipper vector vty
+         text text-zipper vector vty vty-crossplatform
        ];
        description = "Terminal Art";
        license = lib.licenses.bsd3;
···
        pname = "tasty";
        version = "1.5.3";
        sha256 = "10076vlklbcyiz7plakrihava5sy3dvwhskjldqzhfl18jvcg82l";
+       revision = "1";
+       editedCabalFile = "1l7nwf37v29qb1m2q3264473dzhvr6r764skzi9whkr7pjfylmlx";
        libraryHaskellDepends = [
          ansi-terminal base containers optparse-applicative stm tagged
          transformers unix
···
        pname = "tasty-autocollect";
        version = "0.4.4";
        sha256 = "0bkih5566dai863sbig697wn6s6zxy7kgq9igdj7vyl3axq4wqkz";
+       revision = "1";
+       editedCabalFile = "1gilsdxd2ir5vzdaq32akdmxr3l99rzjb3yqis80y5m2m4a0hxd9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "tasty-bench";
        version = "0.4.1";
        sha256 = "0xsp557f3xn7znd61f3751bddiihpdkhh1k5hhxxzzgmy3hpfp1i";
+       revision = "1";
+       editedCabalFile = "115bbawbmp2m4ak786iqwl29n2anxrwvhscqm5nd5s0lgxs7g2n3";
        libraryHaskellDepends = [ base containers deepseq ghc-prim tasty ];
        benchmarkHaskellDepends = [ base ];
        description = "Featherlight benchmark framework";
···
        pname = "tasty-bench-fit";
        version = "0.1.1";
        sha256 = "1x1f2r3p5jsl4f8ss21mdszwl5mi7xfshql8578ff2q8nf9ah9iv";
+       revision = "1";
+       editedCabalFile = "1gf44qval0kd1sfw4awhqf8hlks8j8x062ggbgv6wpbc4djhhc5a";
        libraryHaskellDepends = [
          base containers deepseq infinite-list regression-simple tasty
          tasty-bench
···
        pname = "tasty-golden-extra";
        version = "0.1.0.0";
        sha256 = "1bfd9ql3pws2vd37nbc5a8b49p7zbq3n48slxkrrwx1szaxkp8nj";
-       revision = "1";
-       editedCabalFile = "0y2a1vcyl1i4dga07ahpm52f2z3dlp52rq4m1hh706s8g2hpf8gz";
+       revision = "2";
+       editedCabalFile = "1vj6yr1ysnn5x76r3j824gdny121z69vr9367yi3mp4jxl1w44kw";
        libraryHaskellDepends = [
          aeson aeson-diff aeson-pretty base bytestring pretty-show
          pretty-simple tasty tasty-discover tasty-golden text yaml
···
        pname = "tasty-rerun";
        version = "1.1.19";
        sha256 = "0dbj5jyms4rkb241dw2vgkzk442zga58zhg8mmw0ksi4yw0z8gbg";
-       revision = "4";
-       editedCabalFile = "1y6qmwdwwdqmjlybjjmrh22s8856kcfnl2gaq1v2z8wzn6jcfr2l";
+       revision = "5";
+       editedCabalFile = "1ary8bcrjknx68ill2mcpdmicqrf0bp092vsjyyw9kwddfz9r4hx";
        libraryHaskellDepends = [
          base containers mtl optparse-applicative split stm tagged tasty
          transformers
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "tasty-rerun_1_1_20" = callPackage
+    ({ mkDerivation, base, containers, filepath, mtl
+     , optparse-applicative, split, stm, tagged, tasty, transformers
+     }:
+     mkDerivation {
+       pname = "tasty-rerun";
+       version = "1.1.20";
+       sha256 = "0px58jm1yqbg32qf2s0yk09d2qdjxkkz9df89f31q3nzw85jv2ky";
+       libraryHaskellDepends = [
+         base containers filepath mtl optparse-applicative split stm tagged
+         tasty transformers
+       ];
+       description = "Rerun only tests which failed in a previous test run";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tasty-silver" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
      , deepseq, directory, filepath, mtl, optparse-applicative, process
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "tau";
-       version = "6.2831";
-       sha256 = "10vw3y3vimqpb22amhk7n0d0jni46j60iva1gqa28ky8lhqq8ssz";
+       version = "6.28318";
+       sha256 = "1qxrl7p9gvnfpmlbf8dig6hmfs4m1y3zsd3q5hd1i24pbkj3x8j3";
        libraryHaskellDepends = [ base ];
        description = "Tau, the ratio between any circle's circumference and radius";
        license = lib.licenses.bsd3;
···
        libraryHaskellDepends = [ base template-haskell ];
        description = "Backward-compatibility layer for Template Haskell newer than 2.8";
        license = lib.licenses.mit;
+     }) {};
+
+  "template-haskell-compat-v0208_0_1_9_5" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "template-haskell-compat-v0208";
+       version = "0.1.9.5";
+       sha256 = "07wx8k16rhhkm3mx1by4np4zdi0kgn1i9li1jnsk07ymr26rydai";
+       libraryHaskellDepends = [ base template-haskell ];
+       description = "Backward-compatibility layer for Template Haskell newer than 2.8";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "template-haskell-optics" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "test-framework_0_8_2_1" = callPackage
+    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, bytestring
+     , containers, hostname, HUnit, libxml, old-locale, QuickCheck
+     , random, regex-posix, semigroups, time, utf8-string, xml
+     }:
+     mkDerivation {
+       pname = "test-framework";
+       version = "0.8.2.1";
+       sha256 = "1yyfzf38n37yssqxm8mlzvp60n9vqkmprf1yfb9qmsya7kq53dkh";
+       revision = "1";
+       editedCabalFile = "0imq173blmc5nd77j82pxq8zskwrfcm38zik9zplp220fng2kn12";
+       libraryHaskellDepends = [
+         ansi-terminal ansi-wl-pprint base containers hostname old-locale
+         random regex-posix time xml
+       ];
+       testHaskellDepends = [
+         ansi-terminal ansi-wl-pprint base bytestring containers hostname
+         HUnit libxml old-locale QuickCheck random regex-posix semigroups
+         time utf8-string xml
+       ];
+       description = "Framework for running and organising tests, with HUnit and QuickCheck support";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "test-framework-doctest" = callPackage
     ({ mkDerivation, base, doctest, test-framework
      , test-framework-hunit
···
        ];
        description = "QuickCheck-2 support for the test-framework package";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "test-framework-quickcheck2_0_3_0_6" = callPackage
+    ({ mkDerivation, base, extensible-exceptions, QuickCheck, random
+     , test-framework
+     }:
+     mkDerivation {
+       pname = "test-framework-quickcheck2";
+       version = "0.3.0.6";
+       sha256 = "1d0w2q9sm8aayk0aj1zr2irpnqwpzixn6pdfq1i904vs1kkb2xin";
+       libraryHaskellDepends = [
+         base extensible-exceptions QuickCheck random test-framework
+       ];
+       description = "QuickCheck-2 support for the test-framework package";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "test-framework-sandbox" = callPackage
···
        pname = "testcontainers";
        version = "0.5.1.0";
        sha256 = "17739lvasks03m6f2fgqb9cgsxf4780da44ya1qy3s5672czv6dp";
+       revision = "1";
+       editedCabalFile = "1i7pqsg0la8jkh2jcgn5wyjlk9zak455pa5ibrrgfp9r5k6a5gcc";
        libraryHaskellDepends = [
          aeson aeson-optics async base bytestring directory exceptions
          http-client http-types mtl network optics-core process random
···
        license = lib.licenses.gpl2Only;
      }) {};
 
+  "texmath_0_12_9" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , mtl, pandoc-types, parsec, pretty-show, split, syb, tagged, tasty
+     , tasty-golden, text, typst-symbols, xml
+     }:
+     mkDerivation {
+       pname = "texmath";
+       version = "0.12.9";
+       sha256 = "05wfj0xyybwrnszd9y69ncl9yfp89nv4bffjaz4mg676fbb58d1f";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers mtl pandoc-types parsec split syb text
+         typst-symbols xml
+       ];
+       testHaskellDepends = [
+         base bytestring directory filepath pretty-show tagged tasty
+         tasty-golden text xml
+       ];
+       description = "Conversion between math formats";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "texrunner" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, directory, filepath
      , HUnit, io-streams, lens, mtl, process, semigroups, temporary
···
        pname = "texrunner";
        version = "0.0.2";
        sha256 = "1y6nixdinki8iq2nwwppx5kh24w0kap0x7n3kjhmvbrqjpy03pmv";
+       revision = "1";
+       editedCabalFile = "0bfb274l13jsnplywvg4g10a8h00p3qy0j88mkd8bbn67n2gxgrz";
        libraryHaskellDepends = [
          attoparsec base bytestring directory filepath io-streams mtl
          process semigroups temporary
···
        pname = "text-ansi";
        version = "0.3.0.1";
        sha256 = "0iiq5zlcjh25mf9b4vlhyc1dwglwh8b03qj1wasbngzvmphvcy00";
-       revision = "1";
-       editedCabalFile = "14i37ffh5v4ppz7s2nx9qsmjrc1baj1pvslnxk72amzyiwf2yfx6";
+       revision = "2";
+       editedCabalFile = "1bjri84hc9qqp03zjmbrgrwgk989253x7jj2xzwbq579q5yxpj8h";
        libraryHaskellDepends = [ base text text-builder-linear ];
        description = "Text styling for ANSI terminals";
        license = lib.licenses.bsd3;
···
        pname = "text-icu";
        version = "0.8.0.5";
        sha256 = "1nzd7al2vpm07xa19w9vy6f696bm4z48h0m4fljsxjg4v0wblbj4";
+       revision = "1";
+       editedCabalFile = "1zqbcsnf9943mk8i9lyj1ab2xvg6dw9k6jfjhblxqcliq53c3dpp";
        libraryHaskellDepends = [ base bytestring deepseq text time ];
        librarySystemDepends = [ icu ];
        libraryPkgconfigDepends = [ icu ];
···
        pname = "text-show";
        version = "3.11.1";
        sha256 = "18n4smbwwh9as0kpm2c18153y6lj5pbk2hy6ra9im0fwqk7xan6x";
+       revision = "1";
+       editedCabalFile = "1g96fwpf0y8hqbjiqdxz4ayyh9qwhacfynkmij80dksk7qxzwxml";
        libraryHaskellDepends = [
          array base base-compat-batteries bifunctors bytestring containers
          ghc-boot-th ghc-prim template-haskell text th-abstraction
···
        pname = "text-show-instances";
        version = "3.9.10";
        sha256 = "09cb391gi0hgkjk4ap4d83vg13lczrghmb9db96a4ckw1bp9pbc1";
-       revision = "2";
-       editedCabalFile = "0g7nb70j9amn2ixig6ncvm6shdm2klv33nyl5p8jhmrvlzqddimd";
+       revision = "3";
+       editedCabalFile = "1ghlw5jwcxpclsvffn51lhc4i7mljg0jczg78kjghwnv0prjm8r8";
        libraryHaskellDepends = [
          aeson base base-compat bifunctors binary containers directory
          ghc-boot-th haskeline hpc nonempty-vector old-locale old-time
···
        pname = "th-abstraction";
        version = "0.7.1.0";
        sha256 = "1i843j7lhq6qly9zknrw3nhb17ac3badmxwn1pfn2sscp951idpr";
+       revision = "1";
+       editedCabalFile = "1n2gpcajn2sm8zw5ibkjwvhd3k1m0lvvjrixwcq0c1xhhlyl049h";
        libraryHaskellDepends = [
          base containers ghc-prim template-haskell
        ];
···
        pname = "th-extras";
        version = "0.0.0.8";
        sha256 = "1hvpvb02j2zyg4mpdqzs3w4s7wva78npdlrnpsii7nps2fpvcmrs";
-       revision = "1";
-       editedCabalFile = "065l0xfzdq529d64qnh2s13zvswhjzv9ndyf7m7hzzbg8y83flbc";
+       revision = "2";
+       editedCabalFile = "08hbgfr7r7nqq2pak4ip1yjy53b7vhs6dgdqw522hhydfg6y9ia5";
        libraryHaskellDepends = [
          base containers syb template-haskell th-abstraction
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "th-lock" = callPackage
+    ({ mkDerivation, base, tasty, tasty-discover, tasty-hunit
+     , tasty-quickcheck, template-haskell
+     }:
+     mkDerivation {
+       pname = "th-lock";
+       version = "0.0.4";
+       sha256 = "0i5dd42wbdiqpizsiyyf51j6d9sb4yw58achpfhk5phw28qzwj8r";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [
+         base tasty tasty-discover tasty-hunit tasty-quickcheck
+         template-haskell
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Serialize compilation of modules with TH code modifing shared state";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "th-nowq" = callPackage
     ({ mkDerivation, base, markdown-unlit, template-haskell, time }:
      mkDerivation {
···
        pname = "threepenny-gui";
        version = "0.9.4.2";
        sha256 = "0ppazdc2cdhnjv0y1r1gkvl4igfbramjz5wsa5z1y1d9s88v8m2i";
+       revision = "1";
+       editedCabalFile = "11ywbqqh2r48zn9mah6rwmihizajn870jcpz0yymmzrg0h2mjwif";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "tidal-core" = callPackage
+    ({ mkDerivation, base, colour, containers, deepseq, microspec
+     , parsec, text
+     }:
+     mkDerivation {
+       pname = "tidal-core";
+       version = "1.9.6";
+       sha256 = "0lny9f5crvx61cwlwbfl7xj34i2gl4j9wlvba8ga82hhysyxzg3i";
+       libraryHaskellDepends = [
+         base colour containers deepseq parsec text
+       ];
+       testHaskellDepends = [ base containers deepseq microspec ];
+       description = "Core pattern library for TidalCycles, a pattern language for improvised music";
+       license = lib.licenses.gpl3Only;
+     }) {};
+
   "tidal-link" = callPackage
     ({ mkDerivation, base, system-cxx-std-lib }:
      mkDerivation {
···
        pname = "timeline";
        version = "0.1.1.0";
        sha256 = "15npn5wfhdg2mcvr92n7c9k7jj1jcifm6rcpmyi64mcfsb2g1ry6";
+       revision = "1";
+       editedCabalFile = "0njs6asmfkq3lvl6i1pagxaxfirq9yjrgh6iaw1vy129wq4vjp2v";
        libraryHaskellDepends = [
          base containers hedgehog indexed-traversable template-haskell text
          th-compat time
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "tls_2_1_7" = callPackage
+  "tls_2_1_9" = callPackage
     ({ mkDerivation, asn1-encoding, asn1-types, async, base
-     , base16-bytestring, bytestring, cereal, crypton, crypton-x509
-     , crypton-x509-store, crypton-x509-validation, data-default
-     , hourglass, hspec, hspec-discover, memory, mtl, network
-     , QuickCheck, serialise, transformers, unix-time, zlib
+     , base16-bytestring, base64-bytestring, bytestring, cereal, crypton
+     , crypton-x509, crypton-x509-store, crypton-x509-validation
+     , data-default, ech-config, hourglass, hpke, hspec, hspec-discover
+     , memory, mtl, network, QuickCheck, random, serialise, transformers
+     , unix-time, zlib
      }:
      mkDerivation {
        pname = "tls";
-       version = "2.1.7";
-       sha256 = "0r73z222ynyx227agg4acphf6i9948a8ikzzn31gd0kj1m2j7cwj";
+       version = "2.1.9";
+       sha256 = "0fp9mdvi0h1r6r345j5bh6lk8vz5vr9s9qh7j9nn1a3r5hhpfb8m";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          asn1-encoding asn1-types base base16-bytestring bytestring cereal
          crypton crypton-x509 crypton-x509-store crypton-x509-validation
-         data-default memory mtl network serialise transformers unix-time
-         zlib
+         data-default ech-config hpke memory mtl network random serialise
+         transformers unix-time zlib
        ];
        testHaskellDepends = [
-         asn1-types async base bytestring crypton crypton-x509
-         crypton-x509-validation hourglass hspec QuickCheck serialise
+         asn1-types async base base64-bytestring bytestring crypton
+         crypton-x509 crypton-x509-validation ech-config hourglass hspec
+         QuickCheck serialise
        ];
        testToolDepends = [ hspec-discover ];
        description = "TLS protocol native implementation";
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "tls-session-manager_0_0_8" = callPackage
+    ({ mkDerivation, auto-update, base, bytestring, clock, crypto-token
+     , memory, psqueues, serialise, tls
+     }:
+     mkDerivation {
+       pname = "tls-session-manager";
+       version = "0.0.8";
+       sha256 = "1nijzmapkjzg88aa03wznjk8hc94klph3g0mazrlmp0w4nr4hzww";
+       libraryHaskellDepends = [
+         auto-update base bytestring clock crypto-token memory psqueues
+         serialise tls
+       ];
+       description = "In-memory TLS session DB and session ticket";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "tls-sslkeylogfile" = callPackage
+    ({ mkDerivation, base, crypton-connection, crypton-x509-system
+     , data-default, http-client, http-client-tls, tls
+     }:
+     mkDerivation {
+       pname = "tls-sslkeylogfile";
+       version = "0.1.0.0";
+       sha256 = "15gqv29a0wd91r7alhm2z123x0ib95vihbpmjsyvb7plga3ds1ga";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base crypton-connection crypton-x509-system data-default
+         http-client http-client-tls tls
+       ];
+       description = "SSLKEYLOGFILE support for Haskell";
+       license = lib.licenses.mit;
+     }) {};
+
   "tlynx" = callPackage
     ({ mkDerivation, aeson, async, attoparsec, base, bytestring
      , comonad, containers, data-default, elynx-tools, elynx-tree
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "tmp-proc-postgres_0_7_2_4" = callPackage
+    ({ mkDerivation, base, bytestring, hspec, hspec-tmp-proc
+     , postgresql-simple, text, tmp-proc
+     }:
+     mkDerivation {
+       pname = "tmp-proc-postgres";
+       version = "0.7.2.4";
+       sha256 = "0dhfrd76d9pxxh9dh40qjgcn631fz34qbhb8zmndsi1infh3kgbm";
+       libraryHaskellDepends = [
+         base bytestring postgresql-simple text tmp-proc
+       ];
+       testHaskellDepends = [
+         base bytestring hspec hspec-tmp-proc postgresql-simple text
+         tmp-proc
+       ];
+       description = "Launch a PostgreSQL database in docker using tmp-proc";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tmp-proc-rabbitmq" = callPackage
     ({ mkDerivation, amqp, base, bytestring, hspec, hspec-tmp-proc
      , text, tmp-proc
      }:
      mkDerivation {
        pname = "tmp-proc-rabbitmq";
-       version = "0.7.2.3";
-       sha256 = "1hqjn3837xsvxsldwm08yyhnldjpagrrgzi6cq8ja78fibj0nk3c";
+       version = "0.7.2.4";
+       sha256 = "0ihikm3azbp841sg16xsahsal92xynh0s58m165h83z1cv3gvkli";
        libraryHaskellDepends = [ amqp base bytestring text tmp-proc ];
        testHaskellDepends = [
          amqp base bytestring hspec hspec-tmp-proc text tmp-proc
···
        ];
        description = "Launch Redis in docker using tmp-proc";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "tmp-proc-redis_0_7_2_4" = callPackage
+    ({ mkDerivation, base, bytestring, hedis, hspec, hspec-tmp-proc
+     , text, tmp-proc
+     }:
+     mkDerivation {
+       pname = "tmp-proc-redis";
+       version = "0.7.2.4";
+       sha256 = "1f4wksdmkzdj3br1qiy3y2v33ds92yw8wl29jmkh6k4zl4ahkdyc";
+       libraryHaskellDepends = [ base bytestring hedis text tmp-proc ];
+       testHaskellDepends = [
+         base bytestring hedis hspec hspec-tmp-proc text tmp-proc
+       ];
+       description = "Launch Redis in docker using tmp-proc";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tmp-proc-zipkin" = callPackage
···
        pname = "toml-reader";
        version = "0.2.1.0";
        sha256 = "1nq4f1a1gkm0xv1crq3fwp6xmr79kz6m4ls0nkj75mkcqk0mpd05";
-       revision = "4";
-       editedCabalFile = "1avm7r47cs9as0wy7y5030fvzq68bnbf4irb58jpag8cad7dglsb";
+       revision = "5";
+       editedCabalFile = "09y3lfphhm6fqwfm9s1msbzxrf13b036c6qy9qidbj1sss14fmal";
+       libraryHaskellDepends = [
+         base containers megaparsec parser-combinators text time
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers directory process tasty
+         tasty-golden tasty-hunit text time unordered-containers vector
+       ];
+       description = "TOML format parser compliant with v1.0.0.";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "toml-reader_0_2_2_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, directory
+     , megaparsec, parser-combinators, process, tasty, tasty-golden
+     , tasty-hunit, text, time, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "toml-reader";
+       version = "0.2.2.0";
+       sha256 = "01adpq3sn87shhd7nrl52wycv4ksziqnp9d5b5xhgyrsn9vrbs4n";
        libraryHaskellDepends = [
          base containers megaparsec parser-combinators text time
        ];
···
        ];
        description = "TOML format parser compliant with v1.0.0.";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "toml-reader-parse" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "tools-yj_0_1_0_23" = callPackage
+    ({ mkDerivation, base, containers, data-default, mono-traversable
+     , stm, text
+     }:
+     mkDerivation {
+       pname = "tools-yj";
+       version = "0.1.0.23";
+       sha256 = "0sj16z4aaiv6zaadmdavs5a6jm8vpfxb5kvlg1irfx5d1sybx3ys";
+       libraryHaskellDepends = [
+         base containers data-default mono-traversable stm text
+       ];
+       testHaskellDepends = [
+         base containers data-default mono-traversable stm text
+       ];
+       description = "Tribial tools";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "toolshed" = callPackage
     ({ mkDerivation, array, base, containers, data-default, deepseq
      , directory, extra, filepath, HUnit, QuickCheck, random
···
      }) {};
 
   "toysolver" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, array, base, bytestring
+    ({ mkDerivation, aeson, ansi-wl-pprint, array, base, bytestring
      , bytestring-builder, bytestring-encoding, case-insensitive, clock
      , containers, criterion, data-default, data-default-class
      , data-interval, deepseq, directory, extended-reals, filepath
···
      }:
      mkDerivation {
        pname = "toysolver";
-       version = "0.8.1";
-       sha256 = "00f3x4rq8334g2923l338vzdz9jmf4amab16awr29bkj90h1ay5a";
-       revision = "1";
-       editedCabalFile = "05pgz4yqi5n2mqjsrzqqs7m2c2h7kis8d24map5arh385d0f9xwf";
+       version = "0.9.0";
+       sha256 = "18s48wmvbv1f12k81xf8kjam4vwifk3whcasvlvarpbvnplqx2ir";
+       revision = "2";
+       editedCabalFile = "1zbvz250202qqay8qwp4asyar2ic592l7mlg4yzzidifmyka6cd7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         array base bytestring bytestring-builder bytestring-encoding
+         aeson array base bytestring bytestring-builder bytestring-encoding
          case-insensitive clock containers data-default data-default-class
          data-interval deepseq directory extended-reals filepath
          finite-field ghc-prim hashable hashtables heaps intern lattices
···
          vector-space xml-conduit zlib
        ];
        executableHaskellDepends = [
-         ansi-wl-pprint array base bytestring bytestring-builder clock
+         aeson ansi-wl-pprint array base bytestring bytestring-builder clock
          containers data-default-class filepath haskeline intern megaparsec
          MIP mtl mwc-random OptDir optparse-applicative parsec
          pseudo-boolean scientific text time transformers
          transformers-compat unbounded-delays vector
        ];
        testHaskellDepends = [
-         array base bytestring bytestring-builder containers
+         aeson array base bytestring bytestring-builder containers
          data-default-class data-interval deepseq finite-field hashable
-         intern lattices megaparsec mtl mwc-random OptDir parsec pretty
+         intern lattices megaparsec MIP mtl mwc-random OptDir parsec pretty
          pseudo-boolean QuickCheck scientific tasty tasty-hunit
          tasty-quickcheck tasty-th text transformers transformers-compat
          unordered-containers vector vector-space
···
      }:
      mkDerivation {
        pname = "tpdb";
-       version = "2.7.2";
-       sha256 = "046pyd7mwhw5csisqvr38z6ipz2fyvajqfxbjl96anwi9g2pxlr4";
+       version = "2.7.3";
+       sha256 = "10b03ixjmbhqbnqilyh4afs2mv6ss1p8fdvq9hwa84gsafq31cxz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "trace-embrace" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, cpphs
+     , deepseq, directory, filepath, generic-lens, ghc, haddock-use-refs
+     , lens, lrucache, radix-tree, refined, tagged, tasty
+     , tasty-discover, tasty-hunit, tasty-quickcheck, template-haskell
+     , temporary, text, th-lock, transformers, yaml
+     }:
+     mkDerivation {
+       pname = "trace-embrace";
+       version = "1.0.11";
+       sha256 = "0cnbw0yxaq3lpq8z66fkjsr3d9dss66l837mnbicfksbsn27m22i";
+       libraryHaskellDepends = [
+         aeson base bytestring containers cpphs deepseq directory
+         generic-lens ghc haddock-use-refs lens lrucache radix-tree refined
+         tagged template-haskell text transformers yaml
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory filepath generic-lens lens
+         lrucache refined tasty tasty-discover tasty-hunit tasty-quickcheck
+         template-haskell temporary text th-lock yaml
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Smart version of Debug.Trace module";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "trace-function-call" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "trie-simple";
        version = "0.4.3";
        sha256 = "1hbcwp1aahmnqxyzv6c2l3k1ifnzssjz66mw1gp2a63z12z4gwyg";
+       revision = "1";
+       editedCabalFile = "1sljb3lxbwr07n6j61bdp5gpsl9q0grrpijmmc41w7b4f6p3sdw6";
        libraryHaskellDepends = [
          base containers deepseq hashable indexed-traversable matchable mtl
          semialign these witherable
···
        ];
        description = "Simple Map-based Trie";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "trie-simple_0_4_4" = callPackage
+    ({ mkDerivation, base, containers, deepseq, hashable, hspec
+     , hspec-discover, indexed-traversable, matchable, mtl, mwc-random
+     , QuickCheck, semialign, tasty-bench, these, vector, witherable
+     }:
+     mkDerivation {
+       pname = "trie-simple";
+       version = "0.4.4";
+       sha256 = "16q0a39l5rvssxgbsri1jlcbk65xd9qwwyakxax49h8cii1sdkn7";
+       revision = "1";
+       editedCabalFile = "1wf5q15j83d87q19a7i78l95x1ban79nlxkgciwa46g96bggvl4c";
+       libraryHaskellDepends = [
+         base containers deepseq hashable indexed-traversable matchable mtl
+         semialign these witherable
+       ];
+       testHaskellDepends = [ base containers hspec QuickCheck vector ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base containers deepseq mwc-random tasty-bench vector
+       ];
+       description = "Simple Map-based Trie";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tries" = callPackage
···
        pname = "trifecta";
        version = "2.1.4";
        sha256 = "0a4wvj3g27xmkck150ci6wfp8lqbdlrqgi9q8y3k0cqsvfpl5n6l";
-       revision = "1";
-       editedCabalFile = "0l11slzf5f0lvd8lqimn6jlyshwy0v47369cmwagnsh1nfrnfrnk";
+       revision = "2";
+       editedCabalFile = "1r61x5lzrsax5n3a38hjk78k7p4xspz6zdw5gsyyyqwl57cd2b6g";
        libraryHaskellDepends = [
          ansi-terminal array base blaze-builder blaze-html blaze-markup
          bytestring charset comonad containers deepseq fingertree ghc-prim
···
 
   "twee" = callPackage
     ({ mkDerivation, ansi-terminal, base, containers, jukebox, pretty
-     , split, symbol, twee-lib
+     , QuickCheck, split, symbol, twee-lib
      }:
      mkDerivation {
        pname = "twee";
-       version = "2.4.2";
-       sha256 = "1m6pfxna4nby2mxalx6wa4gnnszhxfj58pc1i1by53c5fixnl1n6";
+       version = "2.5";
+       sha256 = "16vyccbs05nklzq3vm71s2qh4ahkig8vsmw2lsijlrcma03wffq8";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          ansi-terminal base containers jukebox pretty split symbol twee-lib
        ];
+       testHaskellDepends = [
+         base containers pretty QuickCheck twee-lib
+       ];
        description = "An equational theorem prover";
        license = lib.licenses.bsd3;
        mainProgram = "twee";
···
 
   "twee-lib" = callPackage
     ({ mkDerivation, base, bytestring, cereal, containers, dlist
-     , ghc-prim, pretty, primitive, random, transformers, uglymemo
+     , ghc-prim, pretty, primitive, QuickCheck, random, transformers
+     , uglymemo
      }:
      mkDerivation {
        pname = "twee-lib";
-       version = "2.4.2";
-       sha256 = "1fncqc2abb9hhy5ncb7174gy7n7wp5c9ablq07pr7k61i8ngqwd9";
-       revision = "1";
-       editedCabalFile = "1my0zlr5xbdyg0xrn5h0x40xiazx8dkimnzmrh1mfbdjckwlrdbr";
+       version = "2.5";
+       sha256 = "0svy129pd9k8ssm332ni950r0i7nj82d11ajcsgk8v4fh17b3xyx";
        libraryHaskellDepends = [
          base bytestring cereal containers dlist ghc-prim pretty primitive
-         random transformers uglymemo
+         QuickCheck random transformers uglymemo
        ];
        description = "An equational theorem prover";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "typelet";
-       version = "0.1.4";
-       sha256 = "0f5ycxi0pa2p5pfil5hlfrz01r5rk5km21fqdab7mna19bp5w9z4";
+       version = "0.1.5";
+       sha256 = "120hwkwv1zriqjhwlplqql5qs30kxydwi07w8px6zfqhk6yixkq5";
        libraryHaskellDepends = [ base containers ghc ghc-tcplugin-api ];
        testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
        description = "Plugin to faciliate type-level let";
···
        testHaskellDepends = [ base template-haskell ];
        description = "type level tools";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "typelevel-tools-yj_0_1_0_8" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "typelevel-tools-yj";
+       version = "0.1.0.8";
+       sha256 = "0fr0ilk99rij4b8m8jc9n09df5qc0xxck7cl87nrrkidyvmwh75w";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base template-haskell ];
+       description = "type level tools";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "typelits-printf" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "typst_0_6_2" = callPackage
+  "typst_0_7" = callPackage
     ({ mkDerivation, aeson, array, base, bytestring, cassava
      , containers, directory, filepath, mtl, ordered-containers, parsec
      , pretty, pretty-show, regex-tdfa, scientific, tasty, tasty-golden
···
      }:
      mkDerivation {
        pname = "typst";
-       version = "0.6.2";
-       sha256 = "1pyg45fq70pypfddb7l0b5kcjdvcyn5jhiw9piv1jwxpwdybzxq5";
+       version = "0.7";
+       sha256 = "1svcmksjvnmw38zy36fmclhjcx2k1y4h2wddgq9gbky2qdkz71mg";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "unconditional-jump";
        version = "1.0.0";
        sha256 = "1nmzqph0wchzr2cq7009d9xfchryb0nis74mcj7nbkz42r14k570";
+       revision = "1";
+       editedCabalFile = "1n1fy361n03xi9iz6997rlqnkdx0lyc8l30pi4wm18fz8c8kc1ad";
        libraryHaskellDepends = [ base int-supply ];
        description = "Unconditional jumps";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "union_0_1_3" = callPackage
+    ({ mkDerivation, base, criterion, deepseq, hashable, lens
+     , profunctors, tagged, vinyl
+     }:
+     mkDerivation {
+       pname = "union";
+       version = "0.1.3";
+       sha256 = "1msr9s021c52xgh0665wbyxs7ssrs2w0nr7yz7f7l6kjhrc3sjmr";
+       libraryHaskellDepends = [
+         base deepseq hashable profunctors tagged vinyl
+       ];
+       benchmarkHaskellDepends = [ base criterion deepseq lens ];
+       description = "Extensible type-safe unions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "union-angle" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "units-parser";
        version = "0.1.1.5";
        sha256 = "16q7q9c27wy8hx7rp34d2nhywpdkn8rb43hljx1j20kydyp0m2sb";
+       revision = "1";
+       editedCabalFile = "1rgsv7x0g150f9js092hp384vz55gc8wbsja164l7ia5qjbjxl7z";
        libraryHaskellDepends = [ base containers mtl multimap parsec ];
        testHaskellDepends = [
          base containers mtl multimap parsec syb tasty tasty-hunit
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "unix-compat_0_7_4" = callPackage
+    ({ mkDerivation, base, directory, extra, hspec, HUnit
+     , monad-parallel, temporary, unix
+     }:
+     mkDerivation {
+       pname = "unix-compat";
+       version = "0.7.4";
+       sha256 = "1x7gnyfx8bny5x021pha30frqxn4slwvg9aaal82kqcg1jb3m6v8";
+       libraryHaskellDepends = [ base unix ];
+       testHaskellDepends = [
+         base directory extra hspec HUnit monad-parallel temporary
+       ];
+       description = "Portable POSIX-compatibility layer";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "unix-fcntl" = callPackage
     ({ mkDerivation, base, foreign-var }:
      mkDerivation {
···
        ];
        description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
        license = lib.licenses.mit;
+     }) {};
+
+  "unliftio_0_2_25_1" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, deepseq
+     , directory, filepath, gauge, hspec, process, QuickCheck
+     , safe-exceptions, stm, time, transformers, unix, unliftio-core
+     }:
+     mkDerivation {
+       pname = "unliftio";
+       version = "0.2.25.1";
+       sha256 = "0vikd29av2kk8sf09f2q3x9pgg8v90znsgpqdp0c4rk9xa6nzz1v";
+       libraryHaskellDepends = [
+         async base bytestring deepseq directory filepath process
+         safe-exceptions stm time transformers unix unliftio-core
+       ];
+       testHaskellDepends = [
+         async base bytestring containers deepseq directory filepath hspec
+         process QuickCheck safe-exceptions stm time transformers unix
+         unliftio-core
+       ];
+       benchmarkHaskellDepends = [
+         async base bytestring deepseq directory filepath gauge process
+         safe-exceptions stm time transformers unix unliftio-core
+       ];
+       description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "unliftio-core" = callPackage
···
        pname = "vault";
        version = "0.3.1.5";
        sha256 = "181ksk1yixjg0jiggw5jvm8am8m8c7lim4xaixf8qnaqvxm6namc";
-       revision = "9";
-       editedCabalFile = "161akchka1ah1lhrzc0vm2f7ym0x2550scb4w2c0gl3y38n1c4jl";
+       revision = "10";
+       editedCabalFile = "03nw9b08pqhk9ck7lqcixsnh3sxz7zz3jvb3xxfmc2kksrfc4b11";
        libraryHaskellDepends = [
          base containers hashable unordered-containers
        ];
···
        broken = true;
      }) {};
 
+  "vcr" = callPackage
+    ({ mkDerivation, async, base, bytestring, case-insensitive
+     , containers, directory, filepath, hspec, hspec-discover
+     , http-client, http-client-tls, http-conduit, http-types, HUnit
+     , mockery, network-uri, text, yaml
+     }:
+     mkDerivation {
+       pname = "vcr";
+       version = "0.0.0";
+       sha256 = "0h3rjrncjhh8b0lhpj3ilz8dqfrw3qj1qr7q9vpa098nkkvfyqxf";
+       libraryHaskellDepends = [
+         async base bytestring case-insensitive containers directory
+         filepath http-client http-types HUnit network-uri text yaml
+       ];
+       testHaskellDepends = [
+         async base bytestring case-insensitive containers directory
+         filepath hspec http-client http-client-tls http-conduit http-types
+         HUnit mockery network-uri text yaml
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Record and replay HTTP interactions";
+       license = lib.licenses.mit;
+     }) {};
+
   "vcs-ignore" = callPackage
     ({ mkDerivation, base, containers, directory, doctest, exceptions
      , filepath, Glob, hspec, hspec-discover, optparse-applicative, text
···
      }:
      mkDerivation {
        pname = "vector-fftw";
-       version = "0.1.4.0";
-       sha256 = "1ns5jhdx585s3jmcslscibf7ryaya3ca1shc4ysrikrp1mzx1jky";
-       revision = "1";
-       editedCabalFile = "0ncf80jfpm8g3rgdddfqxnhmdzj1qlvczzy24na129c282yp089m";
+       version = "0.1.4.1";
+       sha256 = "0h12zg90xb5w9i9y840xyxqdvnjk2dz02sm4h4s6nkxb1db65igp";
+       revision = "2";
+       editedCabalFile = "1gl7krjim5rmw7smrshzag46zqik8icapmr8bg4vnvip1mg7wbyq";
        libraryHaskellDepends = [ base primitive storable-complex vector ];
        librarySystemDepends = [ fftw ];
        testHaskellDepends = [
···
        maintainers = [ lib.maintainers.alexfmpe ];
      }) {};
 
+  "vext" = callPackage
+    ({ mkDerivation, base, byteslice, natural-arithmetic, primitive
+     , run-st, tasty, tasty-quickcheck, transformers, unlifted
+     }:
+     mkDerivation {
+       pname = "vext";
+       version = "0.1.6.0";
+       sha256 = "1kf9yvpwf9pnqap11pirk6k5y7mw52a4xlvl7qpsnr7vbs1gilyl";
+       libraryHaskellDepends = [
+         base natural-arithmetic primitive run-st transformers unlifted
+       ];
+       testHaskellDepends = [
+         base byteslice natural-arithmetic tasty tasty-quickcheck unlifted
+       ];
+       doHaddock = false;
+       description = "Array library monomorphized with backpack";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "vflow-types" = callPackage
     ({ mkDerivation, aeson, base, bytestring, ip, json-alt
      , json-autotype, neat-interpolation, QuickCheck, quickcheck-classes
···
        pname = "visualize-cbn";
        version = "0.2.1";
        sha256 = "08gc4r4xpxigjjgs205a65hjbwip9ycciqcj0h86kw2s3bh1p3gs";
+       revision = "1";
+       editedCabalFile = "0xl1bczr8f71cw928627bg55rzz4awlhbcf2l5qfjyzb6z4ynpc4";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "vty_6_4" = callPackage
+    ({ mkDerivation, base, binary, blaze-builder, bytestring, deepseq
+     , directory, filepath, microlens, microlens-mtl, mtl, parsec, stm
+     , text, utf8-string, vector
+     }:
+     mkDerivation {
+       pname = "vty";
+       version = "6.4";
+       sha256 = "0iha15inmig2j2f4kljwb2jhbqa8vsh2aa8l7y5fsanjiciscrbi";
+       libraryHaskellDepends = [
+         base binary blaze-builder bytestring deepseq directory filepath
+         microlens microlens-mtl mtl parsec stm text utf8-string vector
+       ];
+       description = "A simple terminal UI library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "vty-crossplatform" = callPackage
     ({ mkDerivation, base, vty, vty-unix }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "wai-handler-hal";
-       version = "0.4.0.0";
-       sha256 = "1qdw8ml3b0zgb09zrv37xp83yqw9v95nm22iw4ysdlampidz8s6d";
-       revision = "2";
-       editedCabalFile = "0way2hcy49prr6sl7rga62yswm1gzvfdg6ksq8m19rxnhfw9lw0l";
+       version = "0.4.0.1";
+       sha256 = "04blpf393mimd2wma6k7wf4plc76w8a74mmazgyi8jam6ck0id40";
+       revision = "1";
+       editedCabalFile = "1b7nad5313ih8ana6mccyy1hqgrky0zfn79mfli28n3i1lrpvara";
        libraryHaskellDepends = [
          base base64-bytestring bytestring case-insensitive hal http-media
          http-types network text unordered-containers vault wai
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "wai-middleware-delegate_0_2_0_1" = callPackage
+    ({ mkDerivation, async, base, blaze-builder, bytestring
+     , bytestring-lexing, case-insensitive, conduit, conduit-extra
+     , crypton-connection, data-default, directory, filepath, fmt, hspec
+     , hspec-tmp-proc, http-client, http-client-tls, http-types, network
+     , random, resourcet, streaming-commons, temporary, test-certs, text
+     , tmp-proc, unix, vault, wai, wai-conduit, warp, warp-tls
+     }:
+     mkDerivation {
+       pname = "wai-middleware-delegate";
+       version = "0.2.0.1";
+       sha256 = "1xqrfi6rqpa8k2iix9mcgyscavjjz3qdpm3gp1dijvyxfbwwp95m";
+       libraryHaskellDepends = [
+         async base blaze-builder bytestring case-insensitive conduit
+         conduit-extra http-client http-client-tls http-types
+         streaming-commons text wai wai-conduit
+       ];
+       testHaskellDepends = [
+         async base blaze-builder bytestring bytestring-lexing
+         case-insensitive conduit conduit-extra crypton-connection
+         data-default directory filepath fmt hspec hspec-tmp-proc
+         http-client http-client-tls http-types network random resourcet
+         temporary test-certs text tmp-proc unix vault wai wai-conduit warp
+         warp-tls
+       ];
+       description = "WAI middleware that delegates handling of requests";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "wai-middleware-etag" = callPackage
     ({ mkDerivation, base, base64-bytestring, bytestring, cryptohash
      , filepath, http-date, http-types, unix-compat
···
        pname = "wai-middleware-static";
        version = "0.9.3";
        sha256 = "0ylynnxj8jh99jdg7fddd1zs9358h2m15dizjrz904s3fhls6dp1";
+       revision = "1";
+       editedCabalFile = "0clzf364cg2rhviidahqlkfcad44yns1x2s71mrgy0ywqvnbca3r";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash-sha1
          directory expiring-cache-map filepath http-types mime-types
···
        pname = "warp-systemd";
        version = "0.3.0.0";
        sha256 = "1yvkg49wla7axk8vdh5c7d0pxlhyb66ka0xiqi6a3ra3zmw5xi3c";
-       revision = "1";
-       editedCabalFile = "03fwdgmg5njsl1d0cjx8ba2cdakii6ln6mx6i6hlibzl3mmvyyhf";
+       revision = "2";
+       editedCabalFile = "09pkrig9xq95k3n1yrhfcfa8i3dkdim4nd03mgm22523jk9b3hbw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base network systemd unix wai warp ];
···
        license = lib.licenses.mit;
      }) {};
 
-  "warp-tls_3_4_12" = callPackage
+  "warp-tls_3_4_13" = callPackage
     ({ mkDerivation, base, bytestring, network, recv, streaming-commons
      , tls, tls-session-manager, wai, warp
      }:
      mkDerivation {
        pname = "warp-tls";
-       version = "3.4.12";
-       sha256 = "09gx0fr5imvn7hcx55d2cgmia1di28mx8ckdvz487x0l7wkgbaqd";
+       version = "3.4.13";
+       sha256 = "0xxcd5202qcvd1jkiaj85gd8r3www3p7mxwf2j92awvg75jh9lsi";
        libraryHaskellDepends = [
          base bytestring network recv streaming-commons tls
          tls-session-manager wai warp
···
        mainProgram = "weatherhs";
      }) {};
 
+  "weave" = callPackage
+    ({ mkDerivation, base, binary-tree, containers, data-fix
+     , transformers, weave-core
+     }:
+     mkDerivation {
+       pname = "weave";
+       version = "0.1.0.0";
+       sha256 = "07vv4blr1r35fp1w02agw685wscipy09ifhk575v0m301w5bh1qj";
+       libraryHaskellDepends = [
+         base binary-tree containers data-fix transformers weave-core
+       ];
+       doHaddock = false;
+       description = "Compositional breadth-first walks";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "weave-core" = callPackage
+    ({ mkDerivation, base, some }:
+     mkDerivation {
+       pname = "weave-core";
+       version = "0.1.0.0";
+       sha256 = "1lqz31r7a1vjqarcyk6x1rijavbpnikw8cr5zwg9c852j68sgl7q";
+       libraryHaskellDepends = [ base some ];
+       description = "Core definitions for weave";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "web-browser-in-haskell" = callPackage
     ({ mkDerivation, base, gtk, webkit }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "web-view-colonnade" = callPackage
+    ({ mkDerivation, base, colonnade, containers, text, vector
+     , web-view
+     }:
+     mkDerivation {
+       pname = "web-view-colonnade";
+       version = "0.1.0.1";
+       sha256 = "10hlpyb0zg4g9mzfw0yq0nhm6aklzi6k079dj36sfh0j0hl0vsg3";
+       libraryHaskellDepends = [
+         base colonnade containers text vector web-view
+       ];
+       testHaskellDepends = [
+         base colonnade containers text vector web-view
+       ];
+       description = "Build HTML tables using web-view and colonnade";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "web3" = callPackage
     ({ mkDerivation, base, web3-ethereum, web3-polkadot, web3-provider
      }:
···
      }) {};
 
   "webp" = callPackage
-    ({ mkDerivation, base, bytestring, c2hs, JuicyPixels, libwebp
-     , tasty, tasty-hunit, vector
+    ({ mkDerivation, base, binary, bytestring, c2hs, JuicyPixels
+     , libwebp, tasty, tasty-hunit, vector
      }:
      mkDerivation {
        pname = "webp";
-       version = "0.1.0.3";
-       sha256 = "01p55arpwq14yff0z285fdhrx0pjn9acxasapk7lr2f7ra5fql09";
-       libraryHaskellDepends = [ base bytestring JuicyPixels vector ];
+       version = "0.1.1.0";
+       sha256 = "0n1wb2xl1fb3y2wxhng7k39xb6pgc4l722f31zf0vgsnllk74kyr";
+       libraryHaskellDepends = [
+         base binary bytestring JuicyPixels vector
+       ];
        libraryPkgconfigDepends = [ libwebp ];
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [
···
        mainProgram = "quickstart";
      }) {};
 
+  "what4_1_7" = callPackage
+    ({ mkDerivation, async, attoparsec, base, bifunctors, bimap
+     , BoundedChan, bv-sized, bytestring, concurrent-extra, config-value
+     , containers, contravariant, deepseq, deriving-compat, directory
+     , exceptions, filepath, fingertree, ghc-prim, hashable, hashtables
+     , hedgehog, io-streams, lens, libBF, lumberjack, megaparsec, mtl
+     , ordered-containers, panic, parameterized-utils, parsec
+     , prettyprinter, process, QuickCheck, s-cargot, scientific, stm
+     , tasty, tasty-checklist, tasty-expected-failure, tasty-hedgehog
+     , tasty-hunit, tasty-quickcheck, tasty-sugar, template-haskell
+     , temporary, text, th-lift, th-lift-instances, time, transformers
+     , unliftio, unordered-containers, utf8-string, vector, versions
+     , zenc
+     }:
+     mkDerivation {
+       pname = "what4";
+       version = "1.7";
+       sha256 = "1iba76c7zagxxgqvfxrsk92vayyhv1vjd6dd5wj242vps29jhb3v";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         async attoparsec base bifunctors bimap BoundedChan bv-sized
+         bytestring concurrent-extra config-value containers deepseq
+         deriving-compat directory exceptions filepath fingertree ghc-prim
+         hashable hashtables io-streams lens libBF megaparsec mtl
+         ordered-containers panic parameterized-utils parsec prettyprinter
+         process s-cargot scientific stm template-haskell temporary text
+         th-lift th-lift-instances time transformers unliftio
+         unordered-containers utf8-string vector versions zenc
+       ];
+       executableHaskellDepends = [
+         base containers hedgehog mtl parameterized-utils tasty
+         tasty-hedgehog tasty-hunit transformers
+       ];
+       testHaskellDepends = [
+         async base bv-sized bytestring containers contravariant directory
+         exceptions hedgehog io-streams libBF lumberjack mtl
+         ordered-containers parameterized-utils prettyprinter process
+         QuickCheck tasty tasty-checklist tasty-expected-failure
+         tasty-hedgehog tasty-hunit tasty-quickcheck tasty-sugar temporary
+         text transformers versions
+       ];
+       description = "Solver-agnostic symbolic values support for issuing queries";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "wheb-mongo" = callPackage
     ({ mkDerivation, base, bson, mongoDB, mtl, text, Wheb }:
      mkDerivation {
···
        license = lib.licenses.bsd2;
      }) {};
 
+  "wide-word_0_1_7_0" = callPackage
+    ({ mkDerivation, base, binary, bytestring, deepseq, ghc-prim
+     , hashable, hedgehog, primitive, QuickCheck, quickcheck-classes
+     , semirings
+     }:
+     mkDerivation {
+       pname = "wide-word";
+       version = "0.1.7.0";
+       sha256 = "01rx0bcc6kanyjp1vf9icymdgkmsx279m7rby2gpb1w0d6swnss8";
+       libraryHaskellDepends = [
+         base binary deepseq ghc-prim hashable primitive
+       ];
+       testHaskellDepends = [
+         base binary bytestring ghc-prim hedgehog primitive QuickCheck
+         quickcheck-classes semirings
+       ];
+       description = "Data types for large but fixed width signed and unsigned integers";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "wide-word-instances" = callPackage
     ({ mkDerivation, base, binary, serialise, wide-word }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "wild-bind_0_1_2_11" = callPackage
+    ({ mkDerivation, base, containers, hspec, hspec-discover, microlens
+     , QuickCheck, semigroups, stm, text, transformers
+     }:
+     mkDerivation {
+       pname = "wild-bind";
+       version = "0.1.2.11";
+       sha256 = "0mdwx0qwlmm22pajvg5s3rzm6xf83z14lfxwbwh8fiphxlgyhnin";
+       libraryHaskellDepends = [
+         base containers semigroups text transformers
+       ];
+       testHaskellDepends = [
+         base hspec microlens QuickCheck stm transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Dynamic key binding framework";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "wild-bind-indicator" = callPackage
     ({ mkDerivation, async, base, containers, gi-gdk, gi-glib, gi-gtk
      , text, transformers, wild-bind
      }:
      mkDerivation {
        pname = "wild-bind-indicator";
-       version = "1.0.0.2";
-       sha256 = "0bkwzn7b7j9npxzcdng53zmrlgzc6z072yr3prn6yq8pxrqr1wfz";
+       version = "1.0.0.3";
+       sha256 = "0ihvskd09gmrf376m5bih5ywhixpj9bsssa7b8k7r7yw1q27iasy";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          async base containers gi-gdk gi-glib gi-gtk text transformers
···
      }:
      mkDerivation {
        pname = "wild-bind-task-x11";
-       version = "0.2.0.4";
-       sha256 = "0yv8w5sfcxjkhb4i5lnnpq89sd0dnbbq2jgcp5sazmvf465v7wls";
+       version = "0.2.0.5";
+       sha256 = "0za92w5yfbp6xyzr0q7ql1i62vafgh5kgqchq7grmqvb4hcq45fl";
        libraryHaskellDepends = [
          base text transformers wild-bind wild-bind-indicator wild-bind-x11
        ];
···
        testToolDepends = [ hspec-discover ];
        description = "X11-specific implementation for WildBind";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "wild-bind-x11_0_2_0_17" = callPackage
+    ({ mkDerivation, async, base, containers, fold-debounce, hspec
+     , hspec-discover, mtl, semigroups, stm, text, time, transformers
+     , wild-bind, X11
+     }:
+     mkDerivation {
+       pname = "wild-bind-x11";
+       version = "0.2.0.17";
+       sha256 = "119pd6bajvgv09vfn0rhcssqzqyh570hvdjyd1vby6fvhykymmvs";
+       libraryHaskellDepends = [
+         base containers fold-debounce mtl semigroups stm text transformers
+         wild-bind X11
+       ];
+       testHaskellDepends = [
+         async base hspec text time transformers wild-bind X11
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "X11-specific implementation for WildBind";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "willow" = callPackage
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
+  "witch_1_3_0_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, HUnit, tagged
+     , template-haskell, text, time, transformers
+     }:
+     mkDerivation {
+       pname = "witch";
+       version = "1.3.0.1";
+       sha256 = "0nbk4vxqj3ljxi0ybj02rc74ff32v6351mrj4sn9h1iw6lv81w2m";
+       libraryHaskellDepends = [
+         base bytestring containers tagged template-haskell text time
+       ];
+       testHaskellDepends = [
+         base bytestring containers HUnit tagged text time transformers
+       ];
+       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 {
···
        testToolDepends = [ hspec-discover ];
        description = "Convenient interface for interacting with WLED devices";
        license = lib.licenses.bsd3;
+       mainProgram = "wled-json-exe";
+     }) {};
+
+  "wled-json_0_0_1_1" = callPackage
+    ({ mkDerivation, aeson, barbies, base, bytestring, deriving-aeson
+     , hspec, hspec-discover, http-conduit, QuickCheck, rhine
+     }:
+     mkDerivation {
+       pname = "wled-json";
+       version = "0.0.1.1";
+       sha256 = "1d9i4qn9iyfxdd46drj811dyr9hask3sgbdim7vgkhphg5059g4p";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson barbies base bytestring deriving-aeson http-conduit
+       ];
+       executableHaskellDepends = [ base rhine ];
+       testHaskellDepends = [ aeson base hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
+       description = "Convenient interface for interacting with WLED devices";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "wled-json-exe";
      }) {};
 
···
      }) {};
 
   "wordify" = callPackage
-    ({ mkDerivation, array, base, containers, directory, errors
-     , filepath, HUnit, listsafe, mtl, parsec, QuickCheck, random, safe
-     , semigroups, split, test-framework, test-framework-hunit
-     , test-framework-quickcheck2, transformers, unordered-containers
+    ({ mkDerivation, array, base, bytestring, conduit, containers
+     , directory, errors, filepath, HUnit, listsafe, mtl, parsec
+     , QuickCheck, random, safe, semigroups, split, test-framework
+     , test-framework-hunit, test-framework-quickcheck2, text
+     , transformers, unordered-containers
      }:
      mkDerivation {
        pname = "wordify";
-       version = "0.1.0.0";
-       sha256 = "1iw3sk8sspscl29chnvd69g8l7pfz7vlpj9vyai8fkwipmc3jrwv";
+       version = "0.1.1.0";
+       sha256 = "06wfa63l2nxk39c50zyacrwh48053z0mj114i08q0ydf95lv44w5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         array base containers errors listsafe mtl parsec random safe
-         semigroups split transformers unordered-containers
+         array base bytestring conduit containers errors listsafe mtl parsec
+         random safe semigroups split text transformers unordered-containers
        ];
        executableHaskellDepends = [
          array base containers errors listsafe mtl parsec random safe
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "wstunnel";
-       maintainers = [ ];
      }) {};
 
   "wtk" = callPackage
···
     ({ mkDerivation }:
      mkDerivation {
        pname = "xz-clib";
-       version = "5.6.4";
-       sha256 = "02sd532kpixdsa5xrdnyzfk46frgcw7lcyq9w15yjpcs9xs2pnn7";
+       version = "5.8.0.1";
+       sha256 = "0dw7lfkgjikawycwp1nglbdak9ay57nnidac5fdakyhg2paw8fpl";
        doHaddock = false;
        description = "LZMA/XZ clibs";
        license = lib.licenses.bsd0;
···
      }:
      mkDerivation {
        pname = "yampa-test";
-       version = "0.14.12";
-       sha256 = "0izgyngkycrs0skmg6zisijhg9rp6gw7260pafrqvq6jakh3fawz";
+       version = "0.15";
+       sha256 = "1vs2n74r5znldkksspsqi4dhrmanblbrhwq9q7fyq4j4jzl1yp5x";
        libraryHaskellDepends = [
          base normaldistribution QuickCheck Yampa
        ];
···
      }:
      mkDerivation {
        pname = "yaya-hedgehog";
-       version = "0.3.0.3";
-       sha256 = "1adqxgpgarwka93h9xzx6443vj6b0nx4cyrh3dp38zcq2c7xji2v";
+       version = "0.3.0.4";
+       sha256 = "13dfs72bwf6gdlbjmcfqi4hz4q2z21wmp0i5adk1arp8kgfypmf3";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [ base deriving-compat hedgehog yaya ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "yaya-unsafe";
-       version = "0.4.1.2";
-       sha256 = "0n4c2zf6ds2y4433j44hi890rwjchd09qfrdx2s61vis28xqyc1k";
+       version = "0.4.1.3";
+       sha256 = "183hc024drdha6j8sqij9mv412yz0bc8mxv5jicg0qx3q1ldxr4y";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [ base comonad free lens yaya ];
        testHaskellDepends = [ base doctest hedgehog yaya yaya-hedgehog ];
···
        ];
        description = "Creation of type-safe, RESTful web applications";
        license = lib.licenses.mit;
+     }) {};
+
+  "yesod-core_1_6_27_0" = callPackage
+    ({ mkDerivation, aeson, async, attoparsec-aeson, auto-update, base
+     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
+     , clientsession, conduit, conduit-extra, containers, cookie
+     , data-default, deepseq, entropy, fast-logger, gauge, hspec
+     , hspec-expectations, http-types, HUnit, memory, monad-logger, mtl
+     , network, parsec, path-pieces, primitive, random, resourcet
+     , shakespeare, streaming-commons, template-haskell, text, time
+     , transformers, unix-compat, unliftio, unordered-containers, vector
+     , wai, wai-extra, wai-logger, warp, word8
+     }:
+     mkDerivation {
+       pname = "yesod-core";
+       version = "1.6.27.0";
+       sha256 = "104phivlhpb2b48cmvsj99x358z82xja9xz8i0mlhna40dcpx6cp";
+       libraryHaskellDepends = [
+         aeson attoparsec-aeson auto-update base blaze-html blaze-markup
+         bytestring case-insensitive cereal clientsession conduit
+         conduit-extra containers cookie data-default deepseq entropy
+         fast-logger http-types memory monad-logger mtl parsec path-pieces
+         primitive random resourcet shakespeare template-haskell text time
+         transformers unix-compat unliftio unordered-containers vector wai
+         wai-extra wai-logger warp word8
+       ];
+       testHaskellDepends = [
+         async base bytestring clientsession conduit conduit-extra
+         containers cookie hspec hspec-expectations http-types HUnit network
+         path-pieces random resourcet shakespeare streaming-commons
+         template-haskell text transformers unliftio wai wai-extra warp
+       ];
+       benchmarkHaskellDepends = [
+         base blaze-html bytestring gauge shakespeare text
+       ];
+       description = "Creation of type-safe, RESTful web applications";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-crud" = callPackage
···
      }:
      mkDerivation {
        pname = "zephyr-copilot";
-       version = "1.0.9";
-       sha256 = "1mwyrcd9a9ih31qfagkl16fyyyv814acq6z26dw5aiglzlgnymjn";
+       version = "1.0.10";
+       sha256 = "05kpn7js9cmgfk17wjxi0agg86czijf79il57d1agwwq8080s0ng";
        libraryHaskellDepends = [
          base containers copilot copilot-c99 copilot-language directory
          filepath mtl optparse-applicative sketch-frp-copilot temporary
···
      }:
      mkDerivation {
        pname = "zeugma";
-       version = "0.10.0.0";
-       sha256 = "0q1q3hhj8lf10zbb34rx317h2pr6hp8807p2zsi4n7xdgi6qjz3s";
+       version = "0.10.0.1";
+       sha256 = "15lah2yg29kw14xn2q5lyrxhzczf45l9vgv0i5v410mnlkhj8jwn";
        libraryHaskellDepends = [
          base chronos hedgehog incipit polysemy polysemy-chronos
          polysemy-process polysemy-test tasty tasty-expected-failure
···
        pname = "zip";
        version = "2.1.0";
        sha256 = "1rbrayns2q34b0cp9b6zl3k600lbgck1c214rmvmywkhmms07slm";
-       revision = "2";
-       editedCabalFile = "01yszzhbd4xj18qhz1yyi4pf9mz49xc6z32axxw8l7dhyywdmz71";
+       revision = "3";
+       editedCabalFile = "0pnj6ganama1b3q7rc50apw8xk73dxs4j66c382hryljnd1wvnf5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "zre";
-       version = "0.1.5.1";
-       sha256 = "071g9nvl4rbwkkdyi298cvf325xz1fdrp4l237f417yyf9pqybj3";
+       version = "0.1.5.2";
+       sha256 = "0886083q65rdcdf5jhmxq5crgq37hw58v4530hcccmm4ygz61jlf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [