diff --git a/flake.lock b/flake.lock
index 95a193120ddf93cb0749c702d9bb7ee321a265b6..4299055f995a09f004cbf48da4c2d2065b2cdfa9 100644
--- a/flake.lock
+++ b/flake.lock
@@ -47,11 +47,11 @@
     "horizon-gen-nix": {
       "flake": false,
       "locked": {
-        "lastModified": 1666986763,
-        "narHash": "sha256-/veAWnKs7u+e2j1kXXm3iMiKa/YOl5pacyLuV5jYOfw=",
+        "lastModified": 1667577671,
+        "narHash": "sha256-rDbpc4sbCmcT7oP+eD557zrlCYCrYumyiDJucOTNsTs=",
         "ref": "refs/heads/master",
-        "rev": "a5ed1b6ae187c8c398b8cd43d9341437ced4c03b",
-        "revCount": 21,
+        "rev": "9d3a1f027f2852dbc896d06c089556134035ddba",
+        "revCount": 31,
         "type": "git",
         "url": "https://gitlab.homotopic.tech/horizon/horizon-gen-nix"
       },
diff --git a/overlay.nix b/overlay.nix
index b9eeef90132b297def202e0aff54306340f0559b..003d43ea001990c35ecb8fc61775df0b459ec1e7 100644
--- a/overlay.nix
+++ b/overlay.nix
@@ -1,648 +1,648 @@
 {pkgs, ...}:
 
 final: prev: with pkgs.haskell.lib; {
-    Cabal = prev.callPackage (./pkgs/Cabal.nix) { };
+  Cabal = prev.callPackage (./pkgs/Cabal.nix) { };
 
-    Cabal-QuickCheck = prev.callPackage (./pkgs/Cabal-QuickCheck.nix) { };
+  Cabal-QuickCheck = prev.callPackage (./pkgs/Cabal-QuickCheck.nix) { };
 
-    Cabal-described = prev.callPackage (./pkgs/Cabal-described.nix) { };
+  Cabal-described = prev.callPackage (./pkgs/Cabal-described.nix) { };
 
-    Cabal-syntax = prev.callPackage (./pkgs/Cabal-syntax.nix) { };
+  Cabal-syntax = prev.callPackage (./pkgs/Cabal-syntax.nix) { };
 
-    Cabal-tree-diff = prev.callPackage (./pkgs/Cabal-tree-diff.nix) { };
+  Cabal-tree-diff = prev.callPackage (./pkgs/Cabal-tree-diff.nix) { };
 
-    ChasingBottoms = prev.callPackage (./pkgs/ChasingBottoms.nix) { };
+  ChasingBottoms = prev.callPackage (./pkgs/ChasingBottoms.nix) { };
 
-    HTTP = prev.callPackage (./pkgs/HTTP.nix) { };
+  HTTP = prev.callPackage (./pkgs/HTTP.nix) { };
 
-    JuicyPixels = prev.callPackage (./pkgs/JuicyPixels.nix) { };
+  JuicyPixels = prev.callPackage (./pkgs/JuicyPixels.nix) { };
 
-    OneTuple = prev.callPackage (./pkgs/OneTuple.nix) { };
+  OneTuple = prev.callPackage (./pkgs/OneTuple.nix) { };
 
-    OpenGLRaw = prev.callPackage (./pkgs/OpenGLRaw.nix) { };
+  OpenGLRaw = prev.callPackage (./pkgs/OpenGLRaw.nix) { };
 
-    PyF = prev.callPackage (./pkgs/PyF.nix) { };
+  PyF = prev.callPackage (./pkgs/PyF.nix) { };
 
-    aeson = prev.callPackage (./pkgs/aeson.nix) { };
+  aeson = prev.callPackage (./pkgs/aeson.nix) { };
 
-    aeson-pretty = prev.callPackage (./pkgs/aeson-pretty.nix) { };
+  aeson-pretty = prev.callPackage (./pkgs/aeson-pretty.nix) { };
 
-    aeson-yaml = prev.callPackage (./pkgs/aeson-yaml.nix) { };
+  aeson-yaml = prev.callPackage (./pkgs/aeson-yaml.nix) { };
 
-    ansi-terminal = prev.callPackage (./pkgs/ansi-terminal.nix) { };
+  ansi-terminal = prev.callPackage (./pkgs/ansi-terminal.nix) { };
 
-    apecs = prev.callPackage (./pkgs/apecs.nix) { };
+  apecs = prev.callPackage (./pkgs/apecs.nix) { };
 
-    assoc = prev.callPackage (./pkgs/assoc.nix) { };
+  assoc = prev.callPackage (./pkgs/assoc.nix) { };
 
-    async = prev.callPackage (./pkgs/async.nix) { };
+  async = prev.callPackage (./pkgs/async.nix) { };
 
-    autodocodec = prev.callPackage (./pkgs/autodocodec.nix) { };
+  autodocodec = prev.callPackage (./pkgs/autodocodec.nix) { };
 
-    autodocodec-schema = prev.callPackage (./pkgs/autodocodec-schema.nix) { };
+  autodocodec-schema = prev.callPackage (./pkgs/autodocodec-schema.nix) { };
 
-    autodocodec-servant-multipart = prev.callPackage (./pkgs/autodocodec-servant-multipart.nix) { };
+  autodocodec-servant-multipart = prev.callPackage (./pkgs/autodocodec-servant-multipart.nix) { };
 
-    autodocodec-yaml = prev.callPackage (./pkgs/autodocodec-yaml.nix) { };
+  autodocodec-yaml = prev.callPackage (./pkgs/autodocodec-yaml.nix) { };
 
-    base-compat = prev.callPackage (./pkgs/base-compat.nix) { };
+  base-compat = prev.callPackage (./pkgs/base-compat.nix) { };
 
-    base-compat-batteries = prev.callPackage (./pkgs/base-compat-batteries.nix) { };
+  base-compat-batteries = prev.callPackage (./pkgs/base-compat-batteries.nix) { };
 
-    base64 = prev.callPackage (./pkgs/base64.nix) { };
+  base64 = prev.callPackage (./pkgs/base64.nix) { };
 
-    basement = prev.callPackage (./pkgs/basement.nix) { };
+  basement = prev.callPackage (./pkgs/basement.nix) { };
 
-    bimap = prev.callPackage (./pkgs/bimap.nix) { };
+  bimap = prev.callPackage (./pkgs/bimap.nix) { };
 
-    binary-orphans = prev.callPackage (./pkgs/binary-orphans.nix) { };
+  binary-orphans = prev.callPackage (./pkgs/binary-orphans.nix) { };
 
-    blaze-markup = prev.callPackage (./pkgs/blaze-markup.nix) { };
+  blaze-markup = prev.callPackage (./pkgs/blaze-markup.nix) { };
 
-    boring = prev.callPackage (./pkgs/boring.nix) { };
+  boring = prev.callPackage (./pkgs/boring.nix) { };
 
-    breakpoint = prev.callPackage (./pkgs/breakpoint.nix) { };
+  breakpoint = prev.callPackage (./pkgs/breakpoint.nix) { };
 
-    brick = prev.callPackage (./pkgs/brick.nix) { };
+  brick = prev.callPackage (./pkgs/brick.nix) { };
 
-    bsb-http-chunked = prev.callPackage (./pkgs/bsb-http-chunked.nix) { };
+  bsb-http-chunked = prev.callPackage (./pkgs/bsb-http-chunked.nix) { };
 
-    bytes = prev.callPackage (./pkgs/bytes.nix) { };
+  bytes = prev.callPackage (./pkgs/bytes.nix) { };
 
-    cabal-doctest = prev.callPackage (./pkgs/cabal-doctest.nix) { };
+  cabal-doctest = prev.callPackage (./pkgs/cabal-doctest.nix) { };
 
-    cabal-install = prev.callPackage (./pkgs/cabal-install.nix) { };
+  cabal-install = prev.callPackage (./pkgs/cabal-install.nix) { };
 
-    cabal-install-solver = prev.callPackage (./pkgs/cabal-install-solver.nix) { };
+  cabal-install-solver = prev.callPackage (./pkgs/cabal-install-solver.nix) { };
 
-    cabal2nix = prev.callPackage (./pkgs/cabal2nix.nix) { };
+  cabal2nix = prev.callPackage (./pkgs/cabal2nix.nix) { };
 
-    cassava = prev.callPackage (./pkgs/cassava.nix) { };
+  cassava = prev.callPackage (./pkgs/cassava.nix) { };
 
-    cassava-megaparsec = prev.callPackage (./pkgs/cassava-megaparsec.nix) { };
+  cassava-megaparsec = prev.callPackage (./pkgs/cassava-megaparsec.nix) { };
 
-    cborg = prev.callPackage (./pkgs/cborg.nix) { };
+  cborg = prev.callPackage (./pkgs/cborg.nix) { };
 
-    cborg-json = prev.callPackage (./pkgs/cborg-json.nix) { };
+  cborg-json = prev.callPackage (./pkgs/cborg-json.nix) { };
 
-    cereal = prev.callPackage (./pkgs/cereal.nix) { };
+  cereal = prev.callPackage (./pkgs/cereal.nix) { };
 
-    citeproc = prev.callPackage (./pkgs/citeproc.nix) { };
+  citeproc = prev.callPackage (./pkgs/citeproc.nix) { };
 
-    co-log-core = prev.callPackage (./pkgs/co-log-core.nix) { };
+  co-log-core = prev.callPackage (./pkgs/co-log-core.nix) { };
 
-    co-log-polysemy = prev.callPackage (./pkgs/co-log-polysemy.nix) { };
+  co-log-polysemy = prev.callPackage (./pkgs/co-log-polysemy.nix) { };
 
-    comonad = prev.callPackage (./pkgs/comonad.nix) { };
+  comonad = prev.callPackage (./pkgs/comonad.nix) { };
 
-    compact = prev.callPackage (./pkgs/compact.nix) { };
+  compact = prev.callPackage (./pkgs/compact.nix) { };
 
-    compactable = prev.callPackage (./pkgs/compactable.nix) { };
+  compactable = prev.callPackage (./pkgs/compactable.nix) { };
 
-    composite-base = prev.callPackage (./pkgs/composite-base.nix) { };
+  composite-base = prev.callPackage (./pkgs/composite-base.nix) { };
 
-    composite-cassava = prev.callPackage (./pkgs/composite-cassava.nix) { };
+  composite-cassava = prev.callPackage (./pkgs/composite-cassava.nix) { };
 
-    composite-dhall = prev.callPackage (./pkgs/composite-dhall.nix) { };
+  composite-dhall = prev.callPackage (./pkgs/composite-dhall.nix) { };
 
-    composite-lens-extra = prev.callPackage (./pkgs/composite-lens-extra.nix) { };
+  composite-lens-extra = prev.callPackage (./pkgs/composite-lens-extra.nix) { };
 
-    composite-tuple = prev.callPackage (./pkgs/composite-tuple.nix) { };
+  composite-tuple = prev.callPackage (./pkgs/composite-tuple.nix) { };
 
-    conduit = prev.callPackage (./pkgs/conduit.nix) { };
+  conduit = prev.callPackage (./pkgs/conduit.nix) { };
 
-    conduit-extra = prev.callPackage (./pkgs/conduit-extra.nix) { };
+  conduit-extra = prev.callPackage (./pkgs/conduit-extra.nix) { };
 
-    config-ini = prev.callPackage (./pkgs/config-ini.nix) { };
+  config-ini = prev.callPackage (./pkgs/config-ini.nix) { };
 
-    constraints = prev.callPackage (./pkgs/constraints.nix) { };
+  constraints = prev.callPackage (./pkgs/constraints.nix) { };
 
-    cryptohash-sha1 = prev.callPackage (./pkgs/cryptohash-sha1.nix) { };
+  cryptohash-sha1 = prev.callPackage (./pkgs/cryptohash-sha1.nix) { };
 
-    cryptonite = prev.callPackage (./pkgs/cryptonite.nix) { };
+  cryptonite = prev.callPackage (./pkgs/cryptonite.nix) { };
 
-    cursor = prev.callPackage (./pkgs/cursor.nix) { };
+  cursor = prev.callPackage (./pkgs/cursor.nix) { };
 
-    cursor-dirforest = prev.callPackage (./pkgs/cursor-dirforest.nix) { };
+  cursor-dirforest = prev.callPackage (./pkgs/cursor-dirforest.nix) { };
 
-    cursor-dirforest-brick = prev.callPackage (./pkgs/cursor-dirforest-brick.nix) { };
+  cursor-dirforest-brick = prev.callPackage (./pkgs/cursor-dirforest-brick.nix) { };
 
-    cursor-dirforest-gen = prev.callPackage (./pkgs/cursor-dirforest-gen.nix) { };
+  cursor-dirforest-gen = prev.callPackage (./pkgs/cursor-dirforest-gen.nix) { };
 
-    data-fix = prev.callPackage (./pkgs/data-fix.nix) { };
+  data-fix = prev.callPackage (./pkgs/data-fix.nix) { };
 
-    dec = prev.callPackage (./pkgs/dec.nix) { };
+  dec = prev.callPackage (./pkgs/dec.nix) { };
 
-    dhall = prev.callPackage (./pkgs/dhall.nix) { };
+  dhall = prev.callPackage (./pkgs/dhall.nix) { };
 
-    dhall-json = prev.callPackage (./pkgs/dhall-json.nix) { };
+  dhall-json = prev.callPackage (./pkgs/dhall-json.nix) { };
 
-    dimensional = prev.callPackage (./pkgs/dimensional.nix) { };
+  dimensional = prev.callPackage (./pkgs/dimensional.nix) { };
 
-    dirforest = prev.callPackage (./pkgs/dirforest.nix) { };
+  dirforest = prev.callPackage (./pkgs/dirforest.nix) { };
 
-    distribution-nixpkgs = prev.callPackage (./pkgs/distribution-nixpkgs.nix) { };
+  distribution-nixpkgs = prev.callPackage (./pkgs/distribution-nixpkgs.nix) { };
 
-    doctest = prev.callPackage (./pkgs/doctest.nix) { };
+  doctest = prev.callPackage (./pkgs/doctest.nix) { };
 
-    double-conversion = prev.callPackage (./pkgs/double-conversion.nix) { };
+  double-conversion = prev.callPackage (./pkgs/double-conversion.nix) { };
 
-    ed25519 = prev.callPackage (./pkgs/ed25519.nix) { };
+  ed25519 = prev.callPackage (./pkgs/ed25519.nix) { };
 
-    effectful = prev.callPackage (./pkgs/effectful.nix) { };
+  effectful = prev.callPackage (./pkgs/effectful.nix) { };
 
-    effectful-cache = prev.callPackage (./pkgs/effectful-cache.nix) { };
+  effectful-cache = prev.callPackage (./pkgs/effectful-cache.nix) { };
 
-    effectful-core = prev.callPackage (./pkgs/effectful-core.nix) { };
+  effectful-core = prev.callPackage (./pkgs/effectful-core.nix) { };
 
-    effectful-th = prev.callPackage (./pkgs/effectful-th.nix) { };
+  effectful-th = prev.callPackage (./pkgs/effectful-th.nix) { };
 
-    email-validate = prev.callPackage (./pkgs/email-validate.nix) { };
+  email-validate = prev.callPackage (./pkgs/email-validate.nix) { };
 
-    extra = prev.callPackage (./pkgs/extra.nix) { };
+  extra = prev.callPackage (./pkgs/extra.nix) { };
 
-    fcf-containers = prev.callPackage (./pkgs/fcf-containers.nix) { };
+  fcf-containers = prev.callPackage (./pkgs/fcf-containers.nix) { };
 
-    finite-field = prev.callPackage (./pkgs/finite-field.nix) { };
+  finite-field = prev.callPackage (./pkgs/finite-field.nix) { };
 
-    first-class-families = prev.callPackage (./pkgs/first-class-families.nix) { };
+  first-class-families = prev.callPackage (./pkgs/first-class-families.nix) { };
 
-    foldl = prev.callPackage (./pkgs/foldl.nix) { };
+  foldl = prev.callPackage (./pkgs/foldl.nix) { };
 
-    foundation = prev.callPackage (./pkgs/foundation.nix) { };
+  foundation = prev.callPackage (./pkgs/foundation.nix) { };
 
-    fsnotify = prev.callPackage (./pkgs/fsnotify.nix) { };
+  fsnotify = prev.callPackage (./pkgs/fsnotify.nix) { };
 
-    fuzzy-time = prev.callPackage (./pkgs/fuzzy-time.nix) { };
+  fuzzy-time = prev.callPackage (./pkgs/fuzzy-time.nix) { };
 
-    generic-lens-core = prev.callPackage (./pkgs/generic-lens-core.nix) { };
+  generic-lens-core = prev.callPackage (./pkgs/generic-lens-core.nix) { };
 
-    generic-lens-lite = prev.callPackage (./pkgs/generic-lens-lite.nix) { };
+  generic-lens-lite = prev.callPackage (./pkgs/generic-lens-lite.nix) { };
 
-    generic-monoid = prev.callPackage (./pkgs/generic-monoid.nix) { };
+  generic-monoid = prev.callPackage (./pkgs/generic-monoid.nix) { };
 
-    generic-optics = prev.callPackage (./pkgs/generic-optics.nix) { };
+  generic-optics = prev.callPackage (./pkgs/generic-optics.nix) { };
 
-    generic-optics-lite = prev.callPackage (./pkgs/generic-optics-lite.nix) { };
+  generic-optics-lite = prev.callPackage (./pkgs/generic-optics-lite.nix) { };
 
-    generics-sop = prev.callPackage (./pkgs/generics-sop.nix) { };
+  generics-sop = prev.callPackage (./pkgs/generics-sop.nix) { };
 
-    genvalidity = prev.callPackage (./pkgs/genvalidity.nix) { };
+  genvalidity = prev.callPackage (./pkgs/genvalidity.nix) { };
 
-    genvalidity-aeson = prev.callPackage (./pkgs/genvalidity-aeson.nix) { };
+  genvalidity-aeson = prev.callPackage (./pkgs/genvalidity-aeson.nix) { };
 
-    genvalidity-bytestring = prev.callPackage (./pkgs/genvalidity-bytestring.nix) { };
+  genvalidity-bytestring = prev.callPackage (./pkgs/genvalidity-bytestring.nix) { };
 
-    genvalidity-case-insensitive = prev.callPackage (./pkgs/genvalidity-case-insensitive.nix) { };
+  genvalidity-case-insensitive = prev.callPackage (./pkgs/genvalidity-case-insensitive.nix) { };
 
-    genvalidity-containers = prev.callPackage (./pkgs/genvalidity-containers.nix) { };
+  genvalidity-containers = prev.callPackage (./pkgs/genvalidity-containers.nix) { };
 
-    genvalidity-criterion = prev.callPackage (./pkgs/genvalidity-criterion.nix) { };
+  genvalidity-criterion = prev.callPackage (./pkgs/genvalidity-criterion.nix) { };
 
-    genvalidity-dirforest = prev.callPackage (./pkgs/genvalidity-dirforest.nix) { };
+  genvalidity-dirforest = prev.callPackage (./pkgs/genvalidity-dirforest.nix) { };
 
-    genvalidity-hspec = prev.callPackage (./pkgs/genvalidity-hspec.nix) { };
+  genvalidity-hspec = prev.callPackage (./pkgs/genvalidity-hspec.nix) { };
 
-    genvalidity-path = prev.callPackage (./pkgs/genvalidity-path.nix) { };
+  genvalidity-path = prev.callPackage (./pkgs/genvalidity-path.nix) { };
 
-    genvalidity-persistent = prev.callPackage (./pkgs/genvalidity-persistent.nix) { };
+  genvalidity-persistent = prev.callPackage (./pkgs/genvalidity-persistent.nix) { };
 
-    genvalidity-property = prev.callPackage (./pkgs/genvalidity-property.nix) { };
+  genvalidity-property = prev.callPackage (./pkgs/genvalidity-property.nix) { };
 
-    genvalidity-scientific = prev.callPackage (./pkgs/genvalidity-scientific.nix) { };
+  genvalidity-scientific = prev.callPackage (./pkgs/genvalidity-scientific.nix) { };
 
-    genvalidity-sydtest = prev.callPackage (./pkgs/genvalidity-sydtest.nix) { };
+  genvalidity-sydtest = prev.callPackage (./pkgs/genvalidity-sydtest.nix) { };
 
-    genvalidity-sydtest-aeson = prev.callPackage (./pkgs/genvalidity-sydtest-aeson.nix) { };
+  genvalidity-sydtest-aeson = prev.callPackage (./pkgs/genvalidity-sydtest-aeson.nix) { };
 
-    genvalidity-sydtest-hashable = prev.callPackage (./pkgs/genvalidity-sydtest-hashable.nix) { };
+  genvalidity-sydtest-hashable = prev.callPackage (./pkgs/genvalidity-sydtest-hashable.nix) { };
 
-    genvalidity-sydtest-lens = prev.callPackage (./pkgs/genvalidity-sydtest-lens.nix) { };
+  genvalidity-sydtest-lens = prev.callPackage (./pkgs/genvalidity-sydtest-lens.nix) { };
 
-    genvalidity-sydtest-persistent = prev.callPackage (./pkgs/genvalidity-sydtest-persistent.nix) { };
+  genvalidity-sydtest-persistent = prev.callPackage (./pkgs/genvalidity-sydtest-persistent.nix) { };
 
-    genvalidity-text = prev.callPackage (./pkgs/genvalidity-text.nix) { };
+  genvalidity-text = prev.callPackage (./pkgs/genvalidity-text.nix) { };
 
-    genvalidity-time = prev.callPackage (./pkgs/genvalidity-time.nix) { };
+  genvalidity-time = prev.callPackage (./pkgs/genvalidity-time.nix) { };
 
-    genvalidity-unordered-containers = prev.callPackage (./pkgs/genvalidity-unordered-containers.nix) { };
+  genvalidity-unordered-containers = prev.callPackage (./pkgs/genvalidity-unordered-containers.nix) { };
 
-    genvalidity-uuid = prev.callPackage (./pkgs/genvalidity-uuid.nix) { };
+  genvalidity-uuid = prev.callPackage (./pkgs/genvalidity-uuid.nix) { };
 
-    genvalidity-vector = prev.callPackage (./pkgs/genvalidity-vector.nix) { };
+  genvalidity-vector = prev.callPackage (./pkgs/genvalidity-vector.nix) { };
 
-    ghc-byteorder = prev.callPackage (./pkgs/ghc-byteorder.nix) { };
+  ghc-byteorder = prev.callPackage (./pkgs/ghc-byteorder.nix) { };
 
-    ghc-check = prev.callPackage (./pkgs/ghc-check.nix) { };
+  ghc-check = prev.callPackage (./pkgs/ghc-check.nix) { };
 
-    ghc-exactprint = prev.callPackage (./pkgs/ghc-exactprint.nix) { };
+  ghc-exactprint = prev.callPackage (./pkgs/ghc-exactprint.nix) { };
 
-    ghc-lib-parser = prev.callPackage (./pkgs/ghc-lib-parser.nix) { };
+  ghc-lib-parser = prev.callPackage (./pkgs/ghc-lib-parser.nix) { };
 
-    ghc-lib-parser-ex = prev.callPackage (./pkgs/ghc-lib-parser-ex.nix) { };
+  ghc-lib-parser-ex = prev.callPackage (./pkgs/ghc-lib-parser-ex.nix) { };
 
-    ghc-paths = prev.callPackage (./pkgs/ghc-paths.nix) { };
+  ghc-paths = prev.callPackage (./pkgs/ghc-paths.nix) { };
 
-    ghc-tcplugins-extra = prev.callPackage (./pkgs/ghc-tcplugins-extra.nix) { };
+  ghc-tcplugins-extra = prev.callPackage (./pkgs/ghc-tcplugins-extra.nix) { };
 
-    ghc-typelits-knownnat = prev.callPackage (./pkgs/ghc-typelits-knownnat.nix) { };
+  ghc-typelits-knownnat = prev.callPackage (./pkgs/ghc-typelits-knownnat.nix) { };
 
-    ghc-typelits-natnormalise = prev.callPackage (./pkgs/ghc-typelits-natnormalise.nix) { };
+  ghc-typelits-natnormalise = prev.callPackage (./pkgs/ghc-typelits-natnormalise.nix) { };
 
-    ghcid = prev.callPackage (./pkgs/ghcid.nix) { };
+  ghcid = prev.callPackage (./pkgs/ghcid.nix) { };
 
-    hackage-security = prev.callPackage (./pkgs/hackage-security.nix) { };
+  hackage-security = prev.callPackage (./pkgs/hackage-security.nix) { };
 
-    haddock-library = prev.callPackage (./pkgs/haddock-library.nix) { };
+  haddock-library = prev.callPackage (./pkgs/haddock-library.nix) { };
 
-    hashable = prev.callPackage (./pkgs/hashable.nix) { };
+  hashable = prev.callPackage (./pkgs/hashable.nix) { };
 
-    hashing = prev.callPackage (./pkgs/hashing.nix) { };
+  hashing = prev.callPackage (./pkgs/hashing.nix) { };
 
-    hashtables = prev.callPackage (./pkgs/hashtables.nix) { };
+  hashtables = prev.callPackage (./pkgs/hashtables.nix) { };
 
-    haskell-src-meta = prev.callPackage (./pkgs/haskell-src-meta.nix) { };
+  haskell-src-meta = prev.callPackage (./pkgs/haskell-src-meta.nix) { };
 
-    hedgehog = prev.callPackage (./pkgs/hedgehog.nix) { };
+  hedgehog = prev.callPackage (./pkgs/hedgehog.nix) { };
 
-    hedgehog-golden = prev.callPackage (./pkgs/hedgehog-golden.nix) { };
+  hedgehog-golden = prev.callPackage (./pkgs/hedgehog-golden.nix) { };
 
-    hie-bios = prev.callPackage (./pkgs/hie-bios.nix) { };
+  hie-bios = prev.callPackage (./pkgs/hie-bios.nix) { };
 
-    hie-compat = prev.callPackage (./pkgs/hie-compat.nix) { };
+  hie-compat = prev.callPackage (./pkgs/hie-compat.nix) { };
 
-    hiedb = prev.callPackage (./pkgs/hiedb.nix) { };
+  hiedb = prev.callPackage (./pkgs/hiedb.nix) { };
 
-    hledger = prev.callPackage (./pkgs/hledger.nix) { };
+  hledger = prev.callPackage (./pkgs/hledger.nix) { };
 
-    hledger-lib = prev.callPackage (./pkgs/hledger-lib.nix) { };
+  hledger-lib = prev.callPackage (./pkgs/hledger-lib.nix) { };
 
-    hlint = prev.callPackage (./pkgs/hlint.nix) { };
+  hlint = prev.callPackage (./pkgs/hlint.nix) { };
 
-    hnix = prev.callPackage (./pkgs/hnix.nix) { };
+  hnix = prev.callPackage (./pkgs/hnix.nix) { };
 
-    horizon-gen-nix = prev.callPackage (./pkgs/horizon-gen-nix.nix) { };
+  horizon-gen-nix = prev.callPackage (./pkgs/horizon-gen-nix.nix) { };
 
-    hourglass = prev.callPackage (./pkgs/hourglass.nix) { };
+  hourglass = prev.callPackage (./pkgs/hourglass.nix) { };
 
-    hpack = prev.callPackage (./pkgs/hpack.nix) { };
+  hpack = prev.callPackage (./pkgs/hpack.nix) { };
 
-    hpack-dhall = prev.callPackage (./pkgs/hpack-dhall.nix) { };
+  hpack-dhall = prev.callPackage (./pkgs/hpack-dhall.nix) { };
 
-    hslua-aeson = prev.callPackage (./pkgs/hslua-aeson.nix) { };
+  hslua-aeson = prev.callPackage (./pkgs/hslua-aeson.nix) { };
 
-    hspec = prev.callPackage (./pkgs/hspec.nix) { };
+  hspec = prev.callPackage (./pkgs/hspec.nix) { };
 
-    hspec-contrib = prev.callPackage (./pkgs/hspec-contrib.nix) { };
+  hspec-contrib = prev.callPackage (./pkgs/hspec-contrib.nix) { };
 
-    hspec-core = prev.callPackage (./pkgs/hspec-core.nix) { };
+  hspec-core = prev.callPackage (./pkgs/hspec-core.nix) { };
 
-    hspec-discover = prev.callPackage (./pkgs/hspec-discover.nix) { };
+  hspec-discover = prev.callPackage (./pkgs/hspec-discover.nix) { };
 
-    hspec-meta = prev.callPackage (./pkgs/hspec-meta.nix) { };
+  hspec-meta = prev.callPackage (./pkgs/hspec-meta.nix) { };
 
-    http-client = prev.callPackage (./pkgs/http-client.nix) { };
+  http-client = prev.callPackage (./pkgs/http-client.nix) { };
 
-    http-date = prev.callPackage (./pkgs/http-date.nix) { };
+  http-date = prev.callPackage (./pkgs/http-date.nix) { };
 
-    http-types = prev.callPackage (./pkgs/http-types.nix) { };
+  http-types = prev.callPackage (./pkgs/http-types.nix) { };
 
-    http2 = prev.callPackage (./pkgs/http2.nix) { };
+  http2 = prev.callPackage (./pkgs/http2.nix) { };
 
-    incipit-base = prev.callPackage (./pkgs/incipit-base.nix) { };
+  incipit-base = prev.callPackage (./pkgs/incipit-base.nix) { };
 
-    incipit-core = prev.callPackage (./pkgs/incipit-core.nix) { };
+  incipit-core = prev.callPackage (./pkgs/incipit-core.nix) { };
 
-    indexed-traversable = prev.callPackage (./pkgs/indexed-traversable.nix) { };
+  indexed-traversable = prev.callPackage (./pkgs/indexed-traversable.nix) { };
 
-    indexed-traversable-instances = prev.callPackage (./pkgs/indexed-traversable-instances.nix) { };
+  indexed-traversable-instances = prev.callPackage (./pkgs/indexed-traversable-instances.nix) { };
 
-    infer-license = prev.callPackage (./pkgs/infer-license.nix) { };
+  infer-license = prev.callPackage (./pkgs/infer-license.nix) { };
 
-    integer-logarithms = prev.callPackage (./pkgs/integer-logarithms.nix) { };
+  integer-logarithms = prev.callPackage (./pkgs/integer-logarithms.nix) { };
 
-    invariant = prev.callPackage (./pkgs/invariant.nix) { };
+  invariant = prev.callPackage (./pkgs/invariant.nix) { };
 
-    iproute = prev.callPackage (./pkgs/iproute.nix) { };
+  iproute = prev.callPackage (./pkgs/iproute.nix) { };
 
-    kvstore-effectful = prev.callPackage (./pkgs/kvstore-effectful.nix) { };
+  kvstore-effectful = prev.callPackage (./pkgs/kvstore-effectful.nix) { };
 
-    kvstore-effectful-cache = prev.callPackage (./pkgs/kvstore-effectful-cache.nix) { };
+  kvstore-effectful-cache = prev.callPackage (./pkgs/kvstore-effectful-cache.nix) { };
 
-    kvstore-effectful-spec = prev.callPackage (./pkgs/kvstore-effectful-spec.nix) { };
+  kvstore-effectful-spec = prev.callPackage (./pkgs/kvstore-effectful-spec.nix) { };
 
-    kvstore-effectful-statemap = prev.callPackage (./pkgs/kvstore-effectful-statemap.nix) { };
+  kvstore-effectful-statemap = prev.callPackage (./pkgs/kvstore-effectful-statemap.nix) { };
 
-    lens = prev.callPackage (./pkgs/lens.nix) { };
+  lens = prev.callPackage (./pkgs/lens.nix) { };
 
-    lens-aeson = prev.callPackage (./pkgs/lens-aeson.nix) { };
+  lens-aeson = prev.callPackage (./pkgs/lens-aeson.nix) { };
 
-    lens-family-th = prev.callPackage (./pkgs/lens-family-th.nix) { };
+  lens-family-th = prev.callPackage (./pkgs/lens-family-th.nix) { };
 
-    lifted-async = prev.callPackage (./pkgs/lifted-async.nix) { };
+  lifted-async = prev.callPackage (./pkgs/lifted-async.nix) { };
 
-    linear = prev.callPackage (./pkgs/linear.nix) { };
+  linear = prev.callPackage (./pkgs/linear.nix) { };
 
-    log-effectful = prev.callPackage (./pkgs/log-effectful.nix) { };
+  log-effectful = prev.callPackage (./pkgs/log-effectful.nix) { };
 
-    lsp = prev.callPackage (./pkgs/lsp.nix) { };
+  lsp = prev.callPackage (./pkgs/lsp.nix) { };
 
-    lsp-types = prev.callPackage (./pkgs/lsp-types.nix) { };
+  lsp-types = prev.callPackage (./pkgs/lsp-types.nix) { };
 
-    lucid = prev.callPackage (./pkgs/lucid.nix) { };
+  lucid = prev.callPackage (./pkgs/lucid.nix) { };
 
-    lucid-alpine = prev.callPackage (./pkgs/lucid-alpine.nix) { };
+  lucid-alpine = prev.callPackage (./pkgs/lucid-alpine.nix) { };
 
-    lucid-aria = prev.callPackage (./pkgs/lucid-aria.nix) { };
+  lucid-aria = prev.callPackage (./pkgs/lucid-aria.nix) { };
 
-    lucid-svg = prev.callPackage (./pkgs/lucid-svg.nix) { };
+  lucid-svg = prev.callPackage (./pkgs/lucid-svg.nix) { };
 
-    memory = prev.callPackage (./pkgs/memory.nix) { };
+  memory = prev.callPackage (./pkgs/memory.nix) { };
 
-    microstache = prev.callPackage (./pkgs/microstache.nix) { };
+  microstache = prev.callPackage (./pkgs/microstache.nix) { };
 
-    monad-control = prev.callPackage (./pkgs/monad-control.nix) { };
+  monad-control = prev.callPackage (./pkgs/monad-control.nix) { };
 
-    monad-par = prev.callPackage (./pkgs/monad-par.nix) { };
+  monad-par = prev.callPackage (./pkgs/monad-par.nix) { };
 
-    monad-time = prev.callPackage (./pkgs/monad-time.nix) { };
+  monad-time = prev.callPackage (./pkgs/monad-time.nix) { };
 
-    monoid-subclasses = prev.callPackage (./pkgs/monoid-subclasses.nix) { };
+  monoid-subclasses = prev.callPackage (./pkgs/monoid-subclasses.nix) { };
 
-    net-mqtt = prev.callPackage (./pkgs/net-mqtt.nix) { };
+  net-mqtt = prev.callPackage (./pkgs/net-mqtt.nix) { };
 
-    network-byte-order = prev.callPackage (./pkgs/network-byte-order.nix) { };
+  network-byte-order = prev.callPackage (./pkgs/network-byte-order.nix) { };
 
-    newtype-generics = prev.callPackage (./pkgs/newtype-generics.nix) { };
+  newtype-generics = prev.callPackage (./pkgs/newtype-generics.nix) { };
 
-    nothunks = prev.callPackage (./pkgs/nothunks.nix) { };
+  nothunks = prev.callPackage (./pkgs/nothunks.nix) { };
 
-    odd-jobs = prev.callPackage (./pkgs/odd-jobs.nix) { };
+  odd-jobs = prev.callPackage (./pkgs/odd-jobs.nix) { };
 
-    optics = prev.callPackage (./pkgs/optics.nix) { };
+  optics = prev.callPackage (./pkgs/optics.nix) { };
 
-    optics-core = prev.callPackage (./pkgs/optics-core.nix) { };
+  optics-core = prev.callPackage (./pkgs/optics-core.nix) { };
 
-    optics-extra = prev.callPackage (./pkgs/optics-extra.nix) { };
+  optics-extra = prev.callPackage (./pkgs/optics-extra.nix) { };
 
-    optics-th = prev.callPackage (./pkgs/optics-th.nix) { };
+  optics-th = prev.callPackage (./pkgs/optics-th.nix) { };
 
-    pandoc = prev.callPackage (./pkgs/pandoc.nix) { };
+  pandoc = prev.callPackage (./pkgs/pandoc.nix) { };
 
-    parallel = prev.callPackage (./pkgs/parallel.nix) { };
+  parallel = prev.callPackage (./pkgs/parallel.nix) { };
 
-    password = prev.callPackage (./pkgs/password.nix) { };
+  password = prev.callPackage (./pkgs/password.nix) { };
 
-    password-types = prev.callPackage (./pkgs/password-types.nix) { };
+  password-types = prev.callPackage (./pkgs/password-types.nix) { };
 
-    pcg-random = prev.callPackage (./pkgs/pcg-random.nix) { };
+  pcg-random = prev.callPackage (./pkgs/pcg-random.nix) { };
 
-    pcre2 = prev.callPackage (./pkgs/pcre2.nix) { };
+  pcre2 = prev.callPackage (./pkgs/pcre2.nix) { };
 
-    persistent = prev.callPackage (./pkgs/persistent.nix) { };
+  persistent = prev.callPackage (./pkgs/persistent.nix) { };
 
-    pg-entity = prev.callPackage (./pkgs/pg-entity.nix) { };
+  pg-entity = prev.callPackage (./pkgs/pg-entity.nix) { };
 
-    pg-transact = prev.callPackage (./pkgs/pg-transact.nix) { };
+  pg-transact = prev.callPackage (./pkgs/pg-transact.nix) { };
 
-    pg-transact-effectful = prev.callPackage (./pkgs/pg-transact-effectful.nix) { };
+  pg-transact-effectful = prev.callPackage (./pkgs/pg-transact-effectful.nix) { };
 
-    polysemy = prev.callPackage (./pkgs/polysemy.nix) { };
+  polysemy = prev.callPackage (./pkgs/polysemy.nix) { };
 
-    polysemy-extra = prev.callPackage (./pkgs/polysemy-extra.nix) { };
+  polysemy-extra = prev.callPackage (./pkgs/polysemy-extra.nix) { };
 
-    polysemy-kvstore = prev.callPackage (./pkgs/polysemy-kvstore.nix) { };
+  polysemy-kvstore = prev.callPackage (./pkgs/polysemy-kvstore.nix) { };
 
-    polysemy-methodology = prev.callPackage (./pkgs/polysemy-methodology.nix) { };
+  polysemy-methodology = prev.callPackage (./pkgs/polysemy-methodology.nix) { };
 
-    polysemy-path = prev.callPackage (./pkgs/polysemy-path.nix) { };
+  polysemy-path = prev.callPackage (./pkgs/polysemy-path.nix) { };
 
-    polysemy-plugin = prev.callPackage (./pkgs/polysemy-plugin.nix) { };
+  polysemy-plugin = prev.callPackage (./pkgs/polysemy-plugin.nix) { };
 
-    polysemy-several = prev.callPackage (./pkgs/polysemy-several.nix) { };
+  polysemy-several = prev.callPackage (./pkgs/polysemy-several.nix) { };
 
-    polysemy-time = prev.callPackage (./pkgs/polysemy-time.nix) { };
+  polysemy-time = prev.callPackage (./pkgs/polysemy-time.nix) { };
 
-    polysemy-vinyl = prev.callPackage (./pkgs/polysemy-vinyl.nix) { };
+  polysemy-vinyl = prev.callPackage (./pkgs/polysemy-vinyl.nix) { };
 
-    polysemy-zoo = prev.callPackage (./pkgs/polysemy-zoo.nix) { };
+  polysemy-zoo = prev.callPackage (./pkgs/polysemy-zoo.nix) { };
 
-    postgresql-libpq = prev.callPackage (./pkgs/postgresql-libpq.nix) { };
+  postgresql-libpq = prev.callPackage (./pkgs/postgresql-libpq.nix) { };
 
-    postgresql-migration = prev.callPackage (./pkgs/postgresql-migration.nix) { };
+  postgresql-migration = prev.callPackage (./pkgs/postgresql-migration.nix) { };
 
-    postgresql-simple = prev.callPackage (./pkgs/postgresql-simple.nix) { };
+  postgresql-simple = prev.callPackage (./pkgs/postgresql-simple.nix) { };
 
-    postgresql-simple-migration = prev.callPackage (./pkgs/postgresql-simple-migration.nix) { };
+  postgresql-simple-migration = prev.callPackage (./pkgs/postgresql-simple-migration.nix) { };
 
-    pretty-simple = prev.callPackage (./pkgs/pretty-simple.nix) { };
+  pretty-simple = prev.callPackage (./pkgs/pretty-simple.nix) { };
 
-    prettyprinter-ansi-terminal = prev.callPackage (./pkgs/prettyprinter-ansi-terminal.nix) { };
+  prettyprinter-ansi-terminal = prev.callPackage (./pkgs/prettyprinter-ansi-terminal.nix) { };
 
-    primitive = prev.callPackage (./pkgs/primitive.nix) { };
+  primitive = prev.callPackage (./pkgs/primitive.nix) { };
 
-    prometheus-proc = prev.callPackage (./pkgs/prometheus-proc.nix) { };
+  prometheus-proc = prev.callPackage (./pkgs/prometheus-proc.nix) { };
 
-    proteaaudio-sdl = prev.callPackage (./pkgs/proteaaudio-sdl.nix) { };
+  proteaaudio-sdl = prev.callPackage (./pkgs/proteaaudio-sdl.nix) { };
 
-    quickcheck-dynamic = prev.callPackage (./pkgs/quickcheck-dynamic.nix) { };
+  quickcheck-dynamic = prev.callPackage (./pkgs/quickcheck-dynamic.nix) { };
 
-    quickcheck-instances = prev.callPackage (./pkgs/quickcheck-instances.nix) { };
+  quickcheck-instances = prev.callPackage (./pkgs/quickcheck-instances.nix) { };
 
-    rebase = prev.callPackage (./pkgs/rebase.nix) { };
+  rebase = prev.callPackage (./pkgs/rebase.nix) { };
 
-    refined = prev.callPackage (./pkgs/refined.nix) { };
+  refined = prev.callPackage (./pkgs/refined.nix) { };
 
-    relude = prev.callPackage (./pkgs/relude.nix) { };
+  relude = prev.callPackage (./pkgs/relude.nix) { };
 
-    rerebase = prev.callPackage (./pkgs/rerebase.nix) { };
+  rerebase = prev.callPackage (./pkgs/rerebase.nix) { };
 
-    resource-pool = prev.callPackage (./pkgs/resource-pool.nix) { };
+  resource-pool = prev.callPackage (./pkgs/resource-pool.nix) { };
 
-    retry = prev.callPackage (./pkgs/retry.nix) { };
+  retry = prev.callPackage (./pkgs/retry.nix) { };
 
-    rope-utf16-splay = prev.callPackage (./pkgs/rope-utf16-splay.nix) { };
+  rope-utf16-splay = prev.callPackage (./pkgs/rope-utf16-splay.nix) { };
 
-    safe-coloured-text = prev.callPackage (./pkgs/safe-coloured-text.nix) { };
+  safe-coloured-text = prev.callPackage (./pkgs/safe-coloured-text.nix) { };
 
-    saltine = prev.callPackage (./pkgs/saltine.nix) { };
+  saltine = prev.callPackage (./pkgs/saltine.nix) { };
 
-    scientific = prev.callPackage (./pkgs/scientific.nix) { };
+  scientific = prev.callPackage (./pkgs/scientific.nix) { };
 
-    scotty = prev.callPackage (./pkgs/scotty.nix) { };
+  scotty = prev.callPackage (./pkgs/scotty.nix) { };
 
-    sdl2 = prev.callPackage (./pkgs/sdl2.nix) { };
+  sdl2 = prev.callPackage (./pkgs/sdl2.nix) { };
 
-    sdl2-gfx = prev.callPackage (./pkgs/sdl2-gfx.nix) { };
+  sdl2-gfx = prev.callPackage (./pkgs/sdl2-gfx.nix) { };
 
-    sdl2-image = prev.callPackage (./pkgs/sdl2-image.nix) { };
+  sdl2-image = prev.callPackage (./pkgs/sdl2-image.nix) { };
 
-    sdl2-mixer = prev.callPackage (./pkgs/sdl2-mixer.nix) { };
+  sdl2-mixer = prev.callPackage (./pkgs/sdl2-mixer.nix) { };
 
-    sdl2-ttf = prev.callPackage (./pkgs/sdl2-ttf.nix) { };
+  sdl2-ttf = prev.callPackage (./pkgs/sdl2-ttf.nix) { };
 
-    semialign = prev.callPackage (./pkgs/semialign.nix) { };
+  semialign = prev.callPackage (./pkgs/semialign.nix) { };
 
-    serialise = prev.callPackage (./pkgs/serialise.nix) { };
+  serialise = prev.callPackage (./pkgs/serialise.nix) { };
 
-    servant = prev.callPackage (./pkgs/servant.nix) { };
+  servant = prev.callPackage (./pkgs/servant.nix) { };
 
-    servant-client = prev.callPackage (./pkgs/servant-client.nix) { };
+  servant-client = prev.callPackage (./pkgs/servant-client.nix) { };
 
-    servant-client-core = prev.callPackage (./pkgs/servant-client-core.nix) { };
+  servant-client-core = prev.callPackage (./pkgs/servant-client-core.nix) { };
 
-    servant-effectful = prev.callPackage (./pkgs/servant-effectful.nix) { };
+  servant-effectful = prev.callPackage (./pkgs/servant-effectful.nix) { };
 
-    servant-foreign = prev.callPackage (./pkgs/servant-foreign.nix) { };
+  servant-foreign = prev.callPackage (./pkgs/servant-foreign.nix) { };
 
-    servant-lucid = prev.callPackage (./pkgs/servant-lucid.nix) { };
+  servant-lucid = prev.callPackage (./pkgs/servant-lucid.nix) { };
 
-    servant-multipart = prev.callPackage (./pkgs/servant-multipart.nix) { };
+  servant-multipart = prev.callPackage (./pkgs/servant-multipart.nix) { };
 
-    servant-multipart-api = prev.callPackage (./pkgs/servant-multipart-api.nix) { };
+  servant-multipart-api = prev.callPackage (./pkgs/servant-multipart-api.nix) { };
 
-    servant-polysemy = prev.callPackage (./pkgs/servant-polysemy.nix) { };
+  servant-polysemy = prev.callPackage (./pkgs/servant-polysemy.nix) { };
 
-    servant-server = prev.callPackage (./pkgs/servant-server.nix) { };
+  servant-server = prev.callPackage (./pkgs/servant-server.nix) { };
 
-    servant-static-th = prev.callPackage (./pkgs/servant-static-th.nix) { };
+  servant-static-th = prev.callPackage (./pkgs/servant-static-th.nix) { };
 
-    servant-swagger = prev.callPackage (./pkgs/servant-swagger.nix) { };
+  servant-swagger = prev.callPackage (./pkgs/servant-swagger.nix) { };
 
-    servant-swagger-ui = prev.callPackage (./pkgs/servant-swagger-ui.nix) { };
+  servant-swagger-ui = prev.callPackage (./pkgs/servant-swagger-ui.nix) { };
 
-    servant-swagger-ui-core = prev.callPackage (./pkgs/servant-swagger-ui-core.nix) { };
+  servant-swagger-ui-core = prev.callPackage (./pkgs/servant-swagger-ui-core.nix) { };
 
-    shake = prev.callPackage (./pkgs/shake.nix) { };
+  shake = prev.callPackage (./pkgs/shake.nix) { };
 
-    shelly = prev.callPackage (./pkgs/shelly.nix) { };
+  shelly = prev.callPackage (./pkgs/shelly.nix) { };
 
-    singleton-bool = prev.callPackage (./pkgs/singleton-bool.nix) { };
+  singleton-bool = prev.callPackage (./pkgs/singleton-bool.nix) { };
 
-    singletons = prev.callPackage (./pkgs/singletons.nix) { };
+  singletons = prev.callPackage (./pkgs/singletons.nix) { };
 
-    slugify = prev.callPackage (./pkgs/slugify.nix) { };
+  slugify = prev.callPackage (./pkgs/slugify.nix) { };
 
-    some = prev.callPackage (./pkgs/some.nix) { };
+  some = prev.callPackage (./pkgs/some.nix) { };
 
-    sop-core = prev.callPackage (./pkgs/sop-core.nix) { };
+  sop-core = prev.callPackage (./pkgs/sop-core.nix) { };
 
-    souffle-haskell = prev.callPackage (./pkgs/souffle-haskell.nix) { };
+  souffle-haskell = prev.callPackage (./pkgs/souffle-haskell.nix) { };
 
-    split = prev.callPackage (./pkgs/split.nix) { };
+  split = prev.callPackage (./pkgs/split.nix) { };
 
-    streaming-commons = prev.callPackage (./pkgs/streaming-commons.nix) { };
+  streaming-commons = prev.callPackage (./pkgs/streaming-commons.nix) { };
 
-    string-interpolate = prev.callPackage (./pkgs/string-interpolate.nix) { };
+  string-interpolate = prev.callPackage (./pkgs/string-interpolate.nix) { };
 
-    string-qq = prev.callPackage (./pkgs/string-qq.nix) { };
+  string-qq = prev.callPackage (./pkgs/string-qq.nix) { };
 
-    swagger2 = prev.callPackage (./pkgs/swagger2.nix) { };
+  swagger2 = prev.callPackage (./pkgs/swagger2.nix) { };
 
-    syb = prev.callPackage (./pkgs/syb.nix) { };
+  syb = prev.callPackage (./pkgs/syb.nix) { };
 
-    sydtest = prev.callPackage (./pkgs/sydtest.nix) { };
+  sydtest = prev.callPackage (./pkgs/sydtest.nix) { };
 
-    sydtest-discover = prev.callPackage (./pkgs/sydtest-discover.nix) { };
+  sydtest-discover = prev.callPackage (./pkgs/sydtest-discover.nix) { };
 
-    tasty = prev.callPackage (./pkgs/tasty.nix) { };
+  tasty = prev.callPackage (./pkgs/tasty.nix) { };
 
-    tasty-discover = prev.callPackage (./pkgs/tasty-discover.nix) { };
+  tasty-discover = prev.callPackage (./pkgs/tasty-discover.nix) { };
 
-    tasty-hedgehog = prev.callPackage (./pkgs/tasty-hedgehog.nix) { };
+  tasty-hedgehog = prev.callPackage (./pkgs/tasty-hedgehog.nix) { };
 
-    tasty-hunit = prev.callPackage (./pkgs/tasty-hunit.nix) { };
+  tasty-hunit = prev.callPackage (./pkgs/tasty-hunit.nix) { };
 
-    tasty-wai = prev.callPackage (./pkgs/tasty-wai.nix) { };
+  tasty-wai = prev.callPackage (./pkgs/tasty-wai.nix) { };
 
-    text-display = prev.callPackage (./pkgs/text-display.nix) { };
+  text-display = prev.callPackage (./pkgs/text-display.nix) { };
 
-    text-metrics = prev.callPackage (./pkgs/text-metrics.nix) { };
+  text-metrics = prev.callPackage (./pkgs/text-metrics.nix) { };
 
-    text-zipper = prev.callPackage (./pkgs/text-zipper.nix) { };
+  text-zipper = prev.callPackage (./pkgs/text-zipper.nix) { };
 
-    th-extras = prev.callPackage (./pkgs/th-extras.nix) { };
+  th-extras = prev.callPackage (./pkgs/th-extras.nix) { };
 
-    th-lift-instances = prev.callPackage (./pkgs/th-lift-instances.nix) { };
+  th-lift-instances = prev.callPackage (./pkgs/th-lift-instances.nix) { };
 
-    these = prev.callPackage (./pkgs/these.nix) { };
+  these = prev.callPackage (./pkgs/these.nix) { };
 
-    these-skinny = prev.callPackage (./pkgs/these-skinny.nix) { };
+  these-skinny = prev.callPackage (./pkgs/these-skinny.nix) { };
 
-    tidal = prev.callPackage (./pkgs/tidal.nix) { };
+  tidal = prev.callPackage (./pkgs/tidal.nix) { };
 
-    time-compat = prev.callPackage (./pkgs/time-compat.nix) { };
+  time-compat = prev.callPackage (./pkgs/time-compat.nix) { };
 
-    time-effectful = prev.callPackage (./pkgs/time-effectful.nix) { };
+  time-effectful = prev.callPackage (./pkgs/time-effectful.nix) { };
 
-    type-equality = prev.callPackage (./pkgs/type-equality.nix) { };
+  type-equality = prev.callPackage (./pkgs/type-equality.nix) { };
 
-    type-errors = prev.callPackage (./pkgs/type-errors.nix) { };
+  type-errors = prev.callPackage (./pkgs/type-errors.nix) { };
 
-    type-errors-pretty = prev.callPackage (./pkgs/type-errors-pretty.nix) { };
+  type-errors-pretty = prev.callPackage (./pkgs/type-errors-pretty.nix) { };
 
-    typerep-map = prev.callPackage (./pkgs/typerep-map.nix) { };
+  typerep-map = prev.callPackage (./pkgs/typerep-map.nix) { };
 
-    unicode-collation = prev.callPackage (./pkgs/unicode-collation.nix) { };
+  unicode-collation = prev.callPackage (./pkgs/unicode-collation.nix) { };
 
-    unicode-data = prev.callPackage (./pkgs/unicode-data.nix) { };
+  unicode-data = prev.callPackage (./pkgs/unicode-data.nix) { };
 
-    unicode-transforms = prev.callPackage (./pkgs/unicode-transforms.nix) { };
+  unicode-transforms = prev.callPackage (./pkgs/unicode-transforms.nix) { };
 
-    universe-base = prev.callPackage (./pkgs/universe-base.nix) { };
+  universe-base = prev.callPackage (./pkgs/universe-base.nix) { };
 
-    unordered-containers = prev.callPackage (./pkgs/unordered-containers.nix) { };
+  unordered-containers = prev.callPackage (./pkgs/unordered-containers.nix) { };
 
-    validity = prev.callPackage (./pkgs/validity.nix) { };
+  validity = prev.callPackage (./pkgs/validity.nix) { };
 
-    validity-aeson = prev.callPackage (./pkgs/validity-aeson.nix) { };
+  validity-aeson = prev.callPackage (./pkgs/validity-aeson.nix) { };
 
-    validity-bytestring = prev.callPackage (./pkgs/validity-bytestring.nix) { };
+  validity-bytestring = prev.callPackage (./pkgs/validity-bytestring.nix) { };
 
-    validity-case-insensitive = prev.callPackage (./pkgs/validity-case-insensitive.nix) { };
+  validity-case-insensitive = prev.callPackage (./pkgs/validity-case-insensitive.nix) { };
 
-    validity-containers = prev.callPackage (./pkgs/validity-containers.nix) { };
+  validity-containers = prev.callPackage (./pkgs/validity-containers.nix) { };
 
-    validity-path = prev.callPackage (./pkgs/validity-path.nix) { };
+  validity-path = prev.callPackage (./pkgs/validity-path.nix) { };
 
-    validity-persistent = prev.callPackage (./pkgs/validity-persistent.nix) { };
+  validity-persistent = prev.callPackage (./pkgs/validity-persistent.nix) { };
 
-    validity-primitive = prev.callPackage (./pkgs/validity-primitive.nix) { };
+  validity-primitive = prev.callPackage (./pkgs/validity-primitive.nix) { };
 
-    validity-scientific = prev.callPackage (./pkgs/validity-scientific.nix) { };
+  validity-scientific = prev.callPackage (./pkgs/validity-scientific.nix) { };
 
-    validity-text = prev.callPackage (./pkgs/validity-text.nix) { };
+  validity-text = prev.callPackage (./pkgs/validity-text.nix) { };
 
-    validity-time = prev.callPackage (./pkgs/validity-time.nix) { };
+  validity-time = prev.callPackage (./pkgs/validity-time.nix) { };
 
-    validity-unordered-containers = prev.callPackage (./pkgs/validity-unordered-containers.nix) { };
+  validity-unordered-containers = prev.callPackage (./pkgs/validity-unordered-containers.nix) { };
 
-    validity-uuid = prev.callPackage (./pkgs/validity-uuid.nix) { };
+  validity-uuid = prev.callPackage (./pkgs/validity-uuid.nix) { };
 
-    validity-vector = prev.callPackage (./pkgs/validity-vector.nix) { };
+  validity-vector = prev.callPackage (./pkgs/validity-vector.nix) { };
 
-    vault = prev.callPackage (./pkgs/vault.nix) { };
+  vault = prev.callPackage (./pkgs/vault.nix) { };
 
-    vector = prev.callPackage (./pkgs/vector.nix) { };
+  vector = prev.callPackage (./pkgs/vector.nix) { };
 
-    vector-algorithms = prev.callPackage (./pkgs/vector-algorithms.nix) { };
+  vector-algorithms = prev.callPackage (./pkgs/vector-algorithms.nix) { };
 
-    vinyl = prev.callPackage (./pkgs/vinyl.nix) { };
+  vinyl = prev.callPackage (./pkgs/vinyl.nix) { };
 
-    vty = prev.callPackage (./pkgs/vty.nix) { };
+  vty = prev.callPackage (./pkgs/vty.nix) { };
 
-    wai-middleware-heartbeat = prev.callPackage (./pkgs/wai-middleware-heartbeat.nix) { };
+  wai-middleware-heartbeat = prev.callPackage (./pkgs/wai-middleware-heartbeat.nix) { };
 
-    wai-middleware-static = prev.callPackage (./pkgs/wai-middleware-static.nix) { };
+  wai-middleware-static = prev.callPackage (./pkgs/wai-middleware-static.nix) { };
 
-    warp = prev.callPackage (./pkgs/warp.nix) { };
+  warp = prev.callPackage (./pkgs/warp.nix) { };
 
-    warp-tls = prev.callPackage (./pkgs/warp-tls.nix) { };
+  warp-tls = prev.callPackage (./pkgs/warp-tls.nix) { };
 
-    with-utf8 = prev.callPackage (./pkgs/with-utf8.nix) { };
+  with-utf8 = prev.callPackage (./pkgs/with-utf8.nix) { };
 
-    witherable = prev.callPackage (./pkgs/witherable.nix) { };
+  witherable = prev.callPackage (./pkgs/witherable.nix) { };
 
-    xml-conduit = prev.callPackage (./pkgs/xml-conduit.nix) { };
+  xml-conduit = prev.callPackage (./pkgs/xml-conduit.nix) { };
 
 }
diff --git a/pkgs/Cabal-QuickCheck.nix b/pkgs/Cabal-QuickCheck.nix
index 4c696ea4d072134b186a7b0a859d77d4ff78cb99..957bcf5064352ea8d4068558164af1ac78eb9978 100644
--- a/pkgs/Cabal-QuickCheck.nix
+++ b/pkgs/Cabal-QuickCheck.nix
@@ -12,11 +12,14 @@ mkDerivation {
   version = "3.9.0.0";
   src = fetchgit {
     url = "https://gitlab.haskell.org/ghc/packages/Cabal";
-    sha256 = "1h6bzv5zdbjhmrnqa3n14s1zybjxvspiqq228ksqcm2jfs4mbf96";
-    rev = "06cbab69946768e766447b66a7ea168469a2c1a9";
+    sha256 = "13prqza1wk1gc0az8lizrm97w6rwxv5lzvy5a4gahpr2wsliqjfg";
+    rev = "e9fdb85427ad1ef11a25c8b1f2286614c86a65ff";
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/Cabal-QuickCheck/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -24,10 +27,14 @@ mkDerivation {
     Cabal-syntax
     QuickCheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "QuickCheck instances for types in Cabal";
   license = "unknown";
+  broken = false;
 }
diff --git a/pkgs/Cabal-described.nix b/pkgs/Cabal-described.nix
index d4fbfde87a938544684653d6736ae68e52fedc9a..1ecdaeb6a97d24491011fecfaa3d01f5ad3f4247 100644
--- a/pkgs/Cabal-described.nix
+++ b/pkgs/Cabal-described.nix
@@ -17,11 +17,14 @@ mkDerivation {
   version = "3.9.0.0";
   src = fetchgit {
     url = "https://gitlab.haskell.org/ghc/packages/Cabal";
-    sha256 = "1h6bzv5zdbjhmrnqa3n14s1zybjxvspiqq228ksqcm2jfs4mbf96";
-    rev = "06cbab69946768e766447b66a7ea168469a2c1a9";
+    sha256 = "13prqza1wk1gc0az8lizrm97w6rwxv5lzvy5a4gahpr2wsliqjfg";
+    rev = "e9fdb85427ad1ef11a25c8b1f2286614c86a65ff";
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/Cabal-described/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     Cabal
@@ -34,10 +37,14 @@ mkDerivation {
     tasty-quickcheck
     transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Described functionality for types in Cabal";
   license = "unknown";
+  broken = false;
 }
diff --git a/pkgs/Cabal-syntax.nix b/pkgs/Cabal-syntax.nix
index 298860bb291d19f6abff1a1a014fd0548b8e2202..552e0aa5430cc1affc39887f1d83b78752a7aa05 100644
--- a/pkgs/Cabal-syntax.nix
+++ b/pkgs/Cabal-syntax.nix
@@ -22,11 +22,14 @@ mkDerivation {
   version = "3.9.0.0";
   src = fetchgit {
     url = "https://gitlab.haskell.org/ghc/packages/Cabal";
-    sha256 = "1h6bzv5zdbjhmrnqa3n14s1zybjxvspiqq228ksqcm2jfs4mbf96";
-    rev = "06cbab69946768e766447b66a7ea168469a2c1a9";
+    sha256 = "13prqza1wk1gc0az8lizrm97w6rwxv5lzvy5a4gahpr2wsliqjfg";
+    rev = "e9fdb85427ad1ef11a25c8b1f2286614c86a65ff";
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/Cabal-syntax/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -44,11 +47,15 @@ mkDerivation {
     transformers
     unix
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://www.haskell.org/cabal/";
   description = "A library for working with .cabal files";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/Cabal-tree-diff.nix b/pkgs/Cabal-tree-diff.nix
index fb503ac99c31364664c5c92dfb026c8d566a36a9..3313a1f0084505de957863b7e2c50abcd9ae658f 100644
--- a/pkgs/Cabal-tree-diff.nix
+++ b/pkgs/Cabal-tree-diff.nix
@@ -11,16 +11,23 @@ mkDerivation {
   version = "3.9.0.0";
   src = fetchgit {
     url = "https://gitlab.haskell.org/ghc/packages/Cabal";
-    sha256 = "1h6bzv5zdbjhmrnqa3n14s1zybjxvspiqq228ksqcm2jfs4mbf96";
-    rev = "06cbab69946768e766447b66a7ea168469a2c1a9";
+    sha256 = "13prqza1wk1gc0az8lizrm97w6rwxv5lzvy5a4gahpr2wsliqjfg";
+    rev = "e9fdb85427ad1ef11a25c8b1f2286614c86a65ff";
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/Cabal-tree-diff/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base Cabal Cabal-syntax tree-diff ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "QuickCheck instances for types in Cabal";
   license = "unknown";
+  broken = false;
 }
diff --git a/pkgs/Cabal.nix b/pkgs/Cabal.nix
index 67d963aa15c1e2459b7550e718d6786e991f2bd5..b0fa564acdfd580b7d134471b745a080b7910d60 100644
--- a/pkgs/Cabal.nix
+++ b/pkgs/Cabal.nix
@@ -21,6 +21,9 @@ mkDerivation {
   pname = "Cabal";
   version = "3.8.1.0";
   sha256 = "7464cbe6c2f3d7e5d0232023a1a7330621f8b24853cb259fc89a2af85b736608";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ mtl parsec ];
   libraryHaskellDepends = [
     array
@@ -40,11 +43,15 @@ mkDerivation {
     transformers
     unix
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://www.haskell.org/cabal/";
   description = "A framework for packaging Haskell software";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/ChasingBottoms.nix b/pkgs/ChasingBottoms.nix
index 83ef3cd2688810116170f81da5d6ce23427deb75..49ab4e2c99b05c7a5e18c05d91bad526ae715586 100644
--- a/pkgs/ChasingBottoms.nix
+++ b/pkgs/ChasingBottoms.nix
@@ -12,6 +12,9 @@ mkDerivation {
   pname = "ChasingBottoms";
   version = "1.3.1.12";
   sha256 = "a018538c0196390c7ebb5c677ff5b81bd760d75ae2b21bae8ab8a47b00f6c9ef";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
@@ -29,10 +32,14 @@ mkDerivation {
     random
     syb
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "For testing partial and infinite values";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/HTTP.nix b/pkgs/HTTP.nix
index 29e12d3772e5291f9cc64072b10e39452565ba0a..198fbbe9a26fb3ae9c252167ef5edb57d683363e 100644
--- a/pkgs/HTTP.nix
+++ b/pkgs/HTTP.nix
@@ -23,6 +23,9 @@ mkDerivation {
   sha256 = "df31d8efec775124dab856d7177ddcba31be9f9e0836ebdab03d94392f2dd453";
   revision = "1";
   editedCabalFile = "04y04vbxbnblpmqqmpl8km4bkcjaj96nbxkssdr1zgbhqisxay5q";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -48,11 +51,15 @@ mkDerivation {
     test-framework
     test-framework-hunit
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell/HTTP";
   description = "A library for client-side HTTP";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/JuicyPixels.nix b/pkgs/JuicyPixels.nix
index 3fbc354ea067e64cb4fac9f16f86c52da0c419e7..512561f8edff2122b0c1eadf6cc37657186d1a77 100644
--- a/pkgs/JuicyPixels.nix
+++ b/pkgs/JuicyPixels.nix
@@ -15,6 +15,9 @@ mkDerivation {
   pname = "JuicyPixels";
   version = "3.3.8";
   sha256 = "d3a0f6ca3515a1b3d526cbf79f2e0b0aab57f208ab216f9c26437bbcd86fb63e";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     binary
@@ -27,11 +30,15 @@ mkDerivation {
     vector
     zlib
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/Twinside/Juicy.Pixels";
   description = "Picture loading/serialization (in png, jpeg, bitmap, gif, tga, tiff and radiance)";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/OneTuple.nix b/pkgs/OneTuple.nix
index 431da819a3cbe09ad778b4d4993c81bd1e2df41a..67c9217e83ecc37ecc0c006189d27e36cf9c5264 100644
--- a/pkgs/OneTuple.nix
+++ b/pkgs/OneTuple.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "98853682d52fb4cc37a45cd186fbd77cf2565d3df5171acc4cf026427e103eef";
   revision = "3";
   editedCabalFile = "0g4siv8s6dlrdsivap2qy6ig08y5bjbs93jk192zmgkp8iscncpw";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ghc-prim template-haskell ];
   testHaskellDepends = [ base hashable template-haskell ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Singleton Tuple";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/OpenGLRaw.nix b/pkgs/OpenGLRaw.nix
index ec7d9567edd7f844c6e20547d23768cbbe79ba46..37f3b9c15cc52386c24a93f394883af7d08fa440 100644
--- a/pkgs/OpenGLRaw.nix
+++ b/pkgs/OpenGLRaw.nix
@@ -13,6 +13,9 @@ mkDerivation {
   pname = "OpenGLRaw";
   version = "3.3.4.1";
   sha256 = "121abdea149ac74514efb2c1c1c319466757242d1b72a8bdf99d49535f06d31e";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -23,11 +26,15 @@ mkDerivation {
     transformers
   ];
   librarySystemDepends = [ libGL ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://www.haskell.org/haskellwiki/Opengl";
   description = "A raw binding for the OpenGL graphics system";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/PyF.nix b/pkgs/PyF.nix
index 16b9e00996b10e4e7c660f7d760e05351fa66228..7819f5e700ceb234b0a7a2f8aae9de3e3c76400e 100644
--- a/pkgs/PyF.nix
+++ b/pkgs/PyF.nix
@@ -1,22 +1,60 @@
-{ mkDerivation, base, bytestring, deepseq, filepath, ghc, ghc-boot
-, hspec, HUnit, lib, mtl, parsec, process, template-haskell
-, temporary, text, time
+{ mkDerivation
+, base
+, bytestring
+, deepseq
+, filepath
+, ghc
+, ghc-boot
+, hspec
+, HUnit
+, lib
+, mtl
+, parsec
+, process
+, template-haskell
+, temporary
+, text
+, time
 }:
 mkDerivation {
   pname = "PyF";
   version = "0.11.1.0";
   sha256 = "8fd451ac23e5e63813c464e1a8ac98ba5c2fb11599441c80fe9ebc0186e61c1f";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base bytestring ghc ghc-boot mtl parsec template-haskell text time
+    base
+    bytestring
+    ghc
+    ghc-boot
+    mtl
+    parsec
+    template-haskell
+    text
+    time
   ];
   testHaskellDepends = [
-    base bytestring deepseq filepath hspec HUnit process
-    template-haskell temporary text time
+    base
+    bytestring
+    deepseq
+    filepath
+    hspec
+    HUnit
+    process
+    template-haskell
+    temporary
+    text
+    time
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Quasiquotations for a python like interpolated string formatter";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/aeson-pretty.nix b/pkgs/aeson-pretty.nix
index 19158ce4aa5be546040af26425c5fc6128fb5ea9..b5638366ea2961a6992cb84aea56268a4f64e044 100644
--- a/pkgs/aeson-pretty.nix
+++ b/pkgs/aeson-pretty.nix
@@ -1,5 +1,15 @@
-{ mkDerivation, aeson, attoparsec, base, base-compat, bytestring
-, cmdargs, lib, scientific, text, unordered-containers, vector
+{ mkDerivation
+, aeson
+, attoparsec
+, base
+, base-compat
+, bytestring
+, cmdargs
+, lib
+, scientific
+, text
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "aeson-pretty";
@@ -9,19 +19,34 @@ mkDerivation {
   editedCabalFile = "1895w56jl4c06wfhv5zf8ayqpzkxgva2rz5xxz8fvfdiza781cgp";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base base-compat bytestring scientific text
-    unordered-containers vector
+    aeson
+    base
+    base-compat
+    bytestring
+    scientific
+    text
+    unordered-containers
+    vector
   ];
   executableHaskellDepends = [
-    aeson attoparsec base bytestring cmdargs
+    aeson
+    attoparsec
+    base
+    bytestring
+    cmdargs
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/informatikr/aeson-pretty";
   description = "JSON pretty-printing library and command-line tool";
   license = lib.licenses.bsd3;
   mainProgram = "aeson-pretty";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/aeson-yaml.nix b/pkgs/aeson-yaml.nix
index cacbbfbf2615e6508e803a0a952895ff92279eb0..254c180dd4c633fd40a5b39777f39d3cdf9c7c58 100644
--- a/pkgs/aeson-yaml.nix
+++ b/pkgs/aeson-yaml.nix
@@ -1,5 +1,15 @@
-{ mkDerivation, aeson, base, bytestring, lib, string-qq, tasty
-, tasty-discover, tasty-hunit, text, unordered-containers, vector
+{ mkDerivation
+, aeson
+, base
+, bytestring
+, lib
+, string-qq
+, tasty
+, tasty-discover
+, tasty-hunit
+, text
+, unordered-containers
+, vector
 , yaml
 }:
 mkDerivation {
@@ -10,19 +20,35 @@ mkDerivation {
   editedCabalFile = "11srm7kkslnicqvbk728kzpy58am8rz680f7l6axn2nfh5ykx8n6";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base bytestring text unordered-containers vector
+    aeson
+    base
+    bytestring
+    text
+    unordered-containers
+    vector
   ];
   testHaskellDepends = [
-    aeson base bytestring string-qq tasty tasty-hunit
-    unordered-containers yaml
+    aeson
+    base
+    bytestring
+    string-qq
+    tasty
+    tasty-hunit
+    unordered-containers
+    yaml
   ];
   testToolDepends = [ tasty-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/clovyr/aeson-yaml";
   description = "Output any Aeson value as YAML (pure Haskell library)";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/aeson.nix b/pkgs/aeson.nix
index 81eff4df555601f2068530b20020429e8d5ebf52..590ddebab6110f50fa588150265c301ba6ebf0ea 100644
--- a/pkgs/aeson.nix
+++ b/pkgs/aeson.nix
@@ -50,6 +50,9 @@ mkDerivation {
   sha256 = "0a763ef5fa16da678e5a1ee8c394825b6723182a9a755709170edc08b8f73c94";
   revision = "2";
   editedCabalFile = "0yp12cmkj5sz25kxzn6g1fz2d6acbq5rvff5dg2wg5zkjwfkhzqj";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     attoparsec
     base
@@ -122,11 +125,15 @@ mkDerivation {
     uuid-types
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell/aeson";
   description = "Fast JSON parsing and encoding";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/ansi-terminal.nix b/pkgs/ansi-terminal.nix
index ccbf7506374f9cdca0409b226355a1b5c5d8ab2d..af708f4db09ce654fad6ec7a0a79c59e07a85757 100644
--- a/pkgs/ansi-terminal.nix
+++ b/pkgs/ansi-terminal.nix
@@ -5,12 +5,17 @@ mkDerivation {
   sha256 = "f4d563ecf71fb1d304bcdcad478d97efd9f61f6d9d4797a5d56e7722a92a9e6b";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base colour ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/UnkindPartition/ansi-terminal";
   description = "Simple ANSI terminal support, with Windows compatibility";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/apecs.nix b/pkgs/apecs.nix
index dd571d31ee7133ba44f2104d93b72a657f107741..3b3b91454c5f2f10038e98b3a92581fda4a2d7b9 100644
--- a/pkgs/apecs.nix
+++ b/pkgs/apecs.nix
@@ -17,6 +17,9 @@ mkDerivation {
   sha256 = "7e134eea093551112539ab5727bb127b7a4a6906c96636024f8c0966a06b9740";
   revision = "1";
   editedCabalFile = "1n0sz1230fp65dv462ss15yma6g1dxxlamj7idgl3kg9gdwv70sn";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -28,11 +31,15 @@ mkDerivation {
   ];
   testHaskellDepends = [ base containers linear QuickCheck vector ];
   benchmarkHaskellDepends = [ base criterion linear ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/jonascarpay/apecs#readme";
   description = "Fast Entity-Component-System library for game programming";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/assoc.nix b/pkgs/assoc.nix
index 5e1df3f2e2e7d712ebb84da7159cdf0f1825772e..092e9518dfe2b9ce0ea8514ec3d15e0644044925 100644
--- a/pkgs/assoc.nix
+++ b/pkgs/assoc.nix
@@ -5,11 +5,18 @@ mkDerivation {
   sha256 = "d8988dc6e8718c7a3456515b769c9336aeeec730cf86fc5175247969ff8f144f";
   revision = "3";
   editedCabalFile = "0mrb12dx316q4gxyn68x2rl8jq0gd77zffd12r8j1r41l0xd9f4k";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base bifunctors tagged ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "swap and assoc: Symmetric and Semigroupy Bifunctors";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/async.nix b/pkgs/async.nix
index e0fe384ebe6bf26881d688120c68a7afe3891bcd..413312ca2c873c37e55908dee4763e465a59e0f3 100644
--- a/pkgs/async.nix
+++ b/pkgs/async.nix
@@ -15,6 +15,7 @@ mkDerivation {
   editedCabalFile = "1j93w1krkadqijn59yjiws1366yhcn2mad1irqrk50in6l10k51b";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base hashable stm ];
   testHaskellDepends = [
     base
@@ -23,11 +24,15 @@ mkDerivation {
     test-framework
     test-framework-hunit
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/simonmar/async";
   description = "Run IO operations asynchronously and wait for their results";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/autodocodec-schema.nix b/pkgs/autodocodec-schema.nix
index 165c045d8c45981ae73226f8494a4f1aaccade2f..90fd0f7b110e733f70bb6c14e725d14d14747548 100644
--- a/pkgs/autodocodec-schema.nix
+++ b/pkgs/autodocodec-schema.nix
@@ -1,20 +1,46 @@
-{ mkDerivation, aeson, autodocodec, base, containers, lib, mtl
-, text, unordered-containers, validity, validity-aeson
-, validity-containers, validity-text
+{ mkDerivation
+, aeson
+, autodocodec
+, base
+, containers
+, lib
+, mtl
+, text
+, unordered-containers
+, validity
+, validity-aeson
+, validity-containers
+, validity-text
 }:
 mkDerivation {
   pname = "autodocodec-schema";
   version = "0.1.0.2";
   sha256 = "7178bc6b356bf744918202312a71eb0c4fb9b2dfe70680c4acd8d8a5d0977c6f";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson autodocodec base containers mtl text unordered-containers
-    validity validity-aeson validity-containers validity-text
+    aeson
+    autodocodec
+    base
+    containers
+    mtl
+    text
+    unordered-containers
+    validity
+    validity-aeson
+    validity-containers
+    validity-text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/autodocodec#readme";
   description = "Autodocodec interpreters for JSON Schema";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/autodocodec-servant-multipart.nix b/pkgs/autodocodec-servant-multipart.nix
index 70cf395a68053915e5e9ee83b7cdacd76049b605..c76bfa0c2b4976ac39ad06370bf468ff710d0f46 100644
--- a/pkgs/autodocodec-servant-multipart.nix
+++ b/pkgs/autodocodec-servant-multipart.nix
@@ -1,20 +1,42 @@
-{ mkDerivation, aeson, autodocodec, base, bytestring, lib
-, servant-multipart, servant-multipart-api, text
-, unordered-containers, vector
+{ mkDerivation
+, aeson
+, autodocodec
+, base
+, bytestring
+, lib
+, servant-multipart
+, servant-multipart-api
+, text
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "autodocodec-servant-multipart";
   version = "0.0.0.0";
   sha256 = "fa0983ebc5d83ec0d510542adf4004011cb204aab0719428fc5bb70b8b4a5fdf";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson autodocodec base bytestring servant-multipart
-    servant-multipart-api text unordered-containers vector
+    aeson
+    autodocodec
+    base
+    bytestring
+    servant-multipart
+    servant-multipart-api
+    text
+    unordered-containers
+    vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/autodocodec#readme";
   description = "Autodocodec interpreters for Servant Multipart";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/autodocodec-yaml.nix b/pkgs/autodocodec-yaml.nix
index cf0756d16a7087673e9d494a1b4adfb6d4016ab8..ecbe1e75bee0755bbd6e75a67c22d999b95bc5e8 100644
--- a/pkgs/autodocodec-yaml.nix
+++ b/pkgs/autodocodec-yaml.nix
@@ -18,6 +18,9 @@ mkDerivation {
   pname = "autodocodec-yaml";
   version = "0.2.0.2";
   sha256 = "3d5f811541866f95f44842227bc5d643e7dfa316f1b3075c22d9f3dc6fcd9698";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     autodocodec
     autodocodec-schema
@@ -33,11 +36,15 @@ mkDerivation {
     vector
     yaml
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/autodocodec#readme";
   description = "Autodocodec interpreters for yaml";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/autodocodec.nix b/pkgs/autodocodec.nix
index 037b3e9f2e70853e1f5aa7c810f7278acd53368c..790c7c3b4c4fd3d0e7359eeb771c37c280c810e8 100644
--- a/pkgs/autodocodec.nix
+++ b/pkgs/autodocodec.nix
@@ -1,20 +1,50 @@
-{ mkDerivation, aeson, base, bytestring, containers, hashable, lib
-, mtl, scientific, text, time, unordered-containers, validity
-, validity-scientific, vector
+{ mkDerivation
+, aeson
+, base
+, bytestring
+, containers
+, hashable
+, lib
+, mtl
+, scientific
+, text
+, time
+, unordered-containers
+, validity
+, validity-scientific
+, vector
 }:
 mkDerivation {
   pname = "autodocodec";
   version = "0.2.0.1";
   sha256 = "4f4e2c2c57608a7e3060247a0f1b86e3f1257c2ba15af3c4649b9d87a6155bde";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base bytestring containers hashable mtl scientific text time
-    unordered-containers validity validity-scientific vector
+    aeson
+    base
+    bytestring
+    containers
+    hashable
+    mtl
+    scientific
+    text
+    time
+    unordered-containers
+    validity
+    validity-scientific
+    vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/autodocodec#readme";
   description = "Self-documenting encoder and decoder";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/base-compat-batteries.nix b/pkgs/base-compat-batteries.nix
index e9a13f4110e37c71f5b7b5694b0c7e7d5d833a30..634ab6d6cc9075431424b1ca6632de58bde79d4f 100644
--- a/pkgs/base-compat-batteries.nix
+++ b/pkgs/base-compat-batteries.nix
@@ -11,13 +11,20 @@ mkDerivation {
   pname = "base-compat-batteries";
   version = "0.12.2";
   sha256 = "ede9092e07f904e0759160bf1ecd3fb7eb043bae6dc89a37c3dc94829ec5eb99";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base base-compat ghc-prim ];
   testHaskellDepends = [ base hspec QuickCheck ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "base-compat with extra batteries";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/base-compat.nix b/pkgs/base-compat.nix
index 00cfe3212fa8d82be168a1f9ec692879bd621069..45c96f7aa163432835efde5abb2897faaed46860 100644
--- a/pkgs/base-compat.nix
+++ b/pkgs/base-compat.nix
@@ -3,11 +3,18 @@ mkDerivation {
   pname = "base-compat";
   version = "0.12.2";
   sha256 = "a62adc883a5ac436f80e4ae02c3c56111cf1007492f267c291139a668d2150bd";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ghc-prim unix ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "A compatibility layer for base";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/base64.nix b/pkgs/base64.nix
index cdf1df4a7140954ececfa482c584789e261f279c..bc15eb8ad4f3337a72e3afb4c412ca845712f4c9 100644
--- a/pkgs/base64.nix
+++ b/pkgs/base64.nix
@@ -19,6 +19,9 @@ mkDerivation {
   sha256 = "640a2d0afcb07e1de2e0a13a5e942b0265781c5942bd642a8793e7b019be3585";
   revision = "2";
   editedCabalFile = "0cz3zzz9k490w9nfn4hpgdw4zx4w70fwqrwsfx8svcwqssqibqw3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -47,11 +50,15 @@ mkDerivation {
     random-bytestring
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/emilypi/base64";
   description = "A modern RFC 4648-compliant Base64 library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/basement.nix b/pkgs/basement.nix
index 8beff1f5e0d89b642bf428e119d6b255c9ced02c..bd95a69dea126edff3e136384a8cdc046fde0205 100644
--- a/pkgs/basement.nix
+++ b/pkgs/basement.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "basement";
   version = "0.0.15";
   sha256 = "56c2afb6754e8d16a627331a8a5d473b3d26fd04ba5c9e0fb3475f595b915db4";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ghc-prim ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-foundation/foundation#readme";
   description = "Foundation scrap box of array & string";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/bimap.nix b/pkgs/bimap.nix
index 6c588f4fedda854d26bfe8ab5a276a9d93cb320f..a63eb60c3dee1152820214972886841b90ac1a5c 100644
--- a/pkgs/bimap.nix
+++ b/pkgs/bimap.nix
@@ -11,6 +11,9 @@ mkDerivation {
   pname = "bimap";
   version = "0.5.0";
   sha256 = "b0b44b0f2eaceb83f46dfa3d1747e080c45204c64d18bb9e63747299266f0c95";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base containers deepseq exceptions ];
   testHaskellDepends = [
     base
@@ -20,11 +23,15 @@ mkDerivation {
     QuickCheck
     template-haskell
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/joelwilliamson/bimap";
   description = "Bidirectional mapping between two key types";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/binary-orphans.nix b/pkgs/binary-orphans.nix
index 8aa7392ed699879214ac85c0c700b4f4fd438a5a..c44643920d39f63a140b6bbf210bdae29e8fd419 100644
--- a/pkgs/binary-orphans.nix
+++ b/pkgs/binary-orphans.nix
@@ -14,6 +14,9 @@ mkDerivation {
   pname = "binary-orphans";
   version = "1.0.3";
   sha256 = "e2e554823ce6758cbbfb64acb8b5905d3c226eab18b5fcaf5d7c79252114602c";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base binary transformers ];
   testHaskellDepends = [
     base
@@ -25,10 +28,14 @@ mkDerivation {
     tasty
     tasty-quickcheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Compatibility package for binary; provides instances";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/blaze-markup.nix b/pkgs/blaze-markup.nix
index 715005f49227f4a8e9a61e2add595c7647003043..0d084a51089bde71ad0cce4b2bf1e4f62a08ccea 100644
--- a/pkgs/blaze-markup.nix
+++ b/pkgs/blaze-markup.nix
@@ -17,6 +17,9 @@ mkDerivation {
   sha256 = "43fc3f6872dc8d1be8d0fe091bd4775139b42179987f33d6490a7c5f1e07a349";
   revision = "3";
   editedCabalFile = "1hn694kk615prqdn7bfzl0wvbw8bksxk4cxwmx8yhwpl0cq3fiwa";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base blaze-builder bytestring text ];
   testHaskellDepends = [
     base
@@ -30,11 +33,15 @@ mkDerivation {
     tasty-quickcheck
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://jaspervdj.be/blaze";
   description = "A blazingly fast markup combinator library for Haskell";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/boring.nix b/pkgs/boring.nix
index 0e7722d27164b8522477ffc36c8ad7fce1648dad..f4a03ecc8b4083263c08879bca51880f1a753920 100644
--- a/pkgs/boring.nix
+++ b/pkgs/boring.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "0bac533b66e754d4fc65ab8d7557eea6f7b35d16998e5e74579b25a372aa4c34";
   revision = "2";
   editedCabalFile = "04pn94i3mysi7px93k86sf29vw99sf38sl4n0gy2nma0iqsik828";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base tagged transformers ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/phadej/boring";
   description = "Boring and Absurd types";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/breakpoint.nix b/pkgs/breakpoint.nix
index d6dfc5de0f75fc14b446a31e86b9cda5ba045959..7c2c66890e77048e0e6d4e874aa74d549a010e29 100644
--- a/pkgs/breakpoint.nix
+++ b/pkgs/breakpoint.nix
@@ -1,20 +1,46 @@
-{ mkDerivation, ansi-terminal, base, containers, ghc, haskeline
-, lib, mtl, pretty-simple, tasty, tasty-hunit, template-haskell
-, text, transformers
+{ mkDerivation
+, ansi-terminal
+, base
+, containers
+, ghc
+, haskeline
+, lib
+, mtl
+, pretty-simple
+, tasty
+, tasty-hunit
+, template-haskell
+, text
+, transformers
 }:
 mkDerivation {
   pname = "breakpoint";
   version = "0.1.1.1";
   sha256 = "e24a2cafa6ea866b571fe50bcc49fbf64c14244d985918e9ffe2c7c789d5cec3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    ansi-terminal base containers ghc haskeline mtl pretty-simple
-    template-haskell text transformers
+    ansi-terminal
+    base
+    containers
+    ghc
+    haskeline
+    mtl
+    pretty-simple
+    template-haskell
+    text
+    transformers
   ];
   testHaskellDepends = [ base containers tasty tasty-hunit ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Set breakpoints using a GHC plugin";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/brick.nix b/pkgs/brick.nix
index 2b24289f616261e6b4e1c87c4abb4cfe70062231..4696b37aed273368a00529283120bb27a059d848 100644
--- a/pkgs/brick.nix
+++ b/pkgs/brick.nix
@@ -31,6 +31,7 @@ mkDerivation {
   sha256 = "4b4320ff8e6161dfe7034c7deb911f4187551c389c1d6b14501b285f9031ed52";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bimap
@@ -64,11 +65,15 @@ mkDerivation {
     vector
     vty
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/jtdaugherty/brick/";
   description = "A declarative terminal user interface library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/bsb-http-chunked.nix b/pkgs/bsb-http-chunked.nix
index 935384ab5f4dc0db6e0705245fa218306256ee12..3baedb5dd98b20b545aca138725b7b7992bee505 100644
--- a/pkgs/bsb-http-chunked.nix
+++ b/pkgs/bsb-http-chunked.nix
@@ -19,6 +19,9 @@ mkDerivation {
   sha256 = "148309e23eb8b261c1de374712372d62d8c8dc8ee504c392809c7ec33c0a0e7c";
   revision = "3";
   editedCabalFile = "15hg352id2f4x0dnvv47bdiz6gv5hp5a2mki9yzmhc7ajpk31mdd";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base bytestring ];
   testHaskellDepends = [
     attoparsec
@@ -39,11 +42,15 @@ mkDerivation {
     gauge
     semigroups
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/sjakobi/bsb-http-chunked";
   description = "Chunked HTTP transfer encoding for bytestring builders";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/bytes.nix b/pkgs/bytes.nix
index 3455ea2cd6e06aecba7424eacac3b6d3739818e8..7eee1dd64baba86ad912409f0104995cd6a2c2ee 100644
--- a/pkgs/bytes.nix
+++ b/pkgs/bytes.nix
@@ -22,6 +22,9 @@ mkDerivation {
   sha256 = "bc55f41edad589bc0ba389e8b106d7425a87390dcd5f1371e3194a9cc2c4781a";
   revision = "1";
   editedCabalFile = "0frs6ag93kmg2fw3vd686czx8g7h9qmdn1ip6wdk96d94ap0fz9i";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     binary
@@ -39,11 +42,15 @@ mkDerivation {
     unordered-containers
     void
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/ekmett/bytes";
   description = "Sharing code for serialization between binary and cereal";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/cabal-doctest.nix b/pkgs/cabal-doctest.nix
index f89090867d7704268ba829c87644951b1dd00578..20ad1610f4310d0d8856b6a82ed47b0aa3beaf53 100644
--- a/pkgs/cabal-doctest.nix
+++ b/pkgs/cabal-doctest.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "5556088496111d33810c4ae6c4a065bb37fa3315e9e8891e8000b1ab6707ba73";
   revision = "2";
   editedCabalFile = "0868js0qgfhvmyw4hjzrvmlzyqsm8dfsbmqhybxb90x44xi3r0i1";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base Cabal directory filepath ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskellari/cabal-doctest";
   description = "A Setup.hs helper for running doctests";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/cabal-install-solver.nix b/pkgs/cabal-install-solver.nix
index ee92b24b71d393c4100e7512b35af20321a4e0d3..bffb38e8421822bf0055c6625ba80a5f81b1c65e 100644
--- a/pkgs/cabal-install-solver.nix
+++ b/pkgs/cabal-install-solver.nix
@@ -19,6 +19,11 @@ mkDerivation {
   pname = "cabal-install-solver";
   version = "3.8.1.0";
   sha256 = "df2369f6c37517a3b2625bc19057d9e206bbb40386bcb607f17dc7d2e588ffe7";
+  revision = "1";
+  editedCabalFile = "1g487j20pj03pc10yaha18v73wh3ackxjgfpfqaj7xznqcbm5xwm";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -40,11 +45,15 @@ mkDerivation {
     tasty-hunit
     tasty-quickcheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://www.haskell.org/cabal/";
   description = "The command-line interface for Cabal and Hackage";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/cabal-install.nix b/pkgs/cabal-install.nix
index 2fe4c97c5fd7de099b04974a8082512bb68d7194..86476a09632bbc924c6f17ad271e266048459e7a 100644
--- a/pkgs/cabal-install.nix
+++ b/pkgs/cabal-install.nix
@@ -53,10 +53,11 @@ mkDerivation {
   pname = "cabal-install";
   version = "3.8.1.0";
   sha256 = "61ce436f2e14e12bf07ea1c81402362f46275014cd841a76566f0766d0ea67e6";
-  revision = "1";
-  editedCabalFile = "0d6g8q9g8xv69dk51d2jjnc2bv9ah59vn1p5xg1hn42filh35sa1";
+  revision = "2";
+  editedCabalFile = "1l2lvljkr1ibnr3py7xfp2csxyb3rzlhy7jlpx8gkamq9cjmi6p2";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     async
@@ -132,9 +133,12 @@ mkDerivation {
     tree-diff
     zlib
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   postInstall = ''
     mkdir -p $out/share/bash-completion
@@ -144,4 +148,5 @@ mkDerivation {
   description = "The command-line interface for Cabal and Hackage";
   license = lib.licenses.bsd3;
   mainProgram = "cabal";
+  broken = false;
 }
diff --git a/pkgs/cabal2nix.nix b/pkgs/cabal2nix.nix
index ac9e5ae1a7d990ec4ff05763feadfc31f2601f9b..d196407301fa469cf275f3b8f93ddbe3f1c6e37a 100644
--- a/pkgs/cabal2nix.nix
+++ b/pkgs/cabal2nix.nix
@@ -1,40 +1,110 @@
-{ mkDerivation, aeson, ansi-wl-pprint, base, bytestring, Cabal
-, containers, deepseq, directory, distribution-nixpkgs, fetchgit
-, filepath, hackage-db, hopenssl, hpack, language-nix, lens, lib
-, monad-par, monad-par-extras, mtl, optparse-applicative, pretty
-, process, split, tasty, tasty-golden, text, time, transformers
+{ mkDerivation
+, aeson
+, ansi-wl-pprint
+, base
+, bytestring
+, Cabal
+, containers
+, deepseq
+, directory
+, distribution-nixpkgs
+, fetchgit
+, filepath
+, hackage-db
+, hopenssl
+, hpack
+, language-nix
+, lens
+, lib
+, monad-par
+, monad-par-extras
+, mtl
+, optparse-applicative
+, pretty
+, process
+, split
+, tasty
+, tasty-golden
+, text
+, time
+, transformers
 , yaml
 }:
 mkDerivation {
   pname = "cabal2nix";
-  version = "2.19.0";
+  version = "2.19.1";
   src = fetchgit {
     url = "https://github.com/NixOS/cabal2nix";
-    sha256 = "0ym6lyp4br57442b6a9cg9bczbjqz8nz984rxwiacldqzndk8jbr";
-    rev = "b3ae6f9240d07ba103f1eb7ab22f6055e9cdb7dc";
+    sha256 = "1n4jy4xsrzywqvzicsca6kaw4bp0xdz5qfkvj7bkh4np9p3hnj08";
+    rev = "8e97f51e4bd4e5b9ff79391aa599ed8547771954";
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/cabal2nix/; echo source root reset to $sourceRoot";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   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-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
-    distribution-nixpkgs filepath hopenssl language-nix lens monad-par
-    monad-par-extras mtl optparse-applicative pretty
+    aeson
+    base
+    bytestring
+    Cabal
+    containers
+    directory
+    distribution-nixpkgs
+    filepath
+    hopenssl
+    language-nix
+    lens
+    monad-par
+    monad-par-extras
+    mtl
+    optparse-applicative
+    pretty
   ];
   testHaskellDepends = [
-    base Cabal containers directory filepath language-nix lens pretty
-    process tasty tasty-golden
+    base
+    Cabal
+    containers
+    directory
+    filepath
+    language-nix
+    lens
+    pretty
+    process
+    tasty
+    tasty-golden
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   preCheck = ''
     export PATH="$PWD/dist/build/cabal2nix:$PATH"
@@ -43,4 +113,5 @@ mkDerivation {
   homepage = "https://github.com/nixos/cabal2nix#readme";
   description = "Convert Cabal files into Nix build instructions";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/cassava-megaparsec.nix b/pkgs/cassava-megaparsec.nix
index 15673053d8eb1a025bdcedf9493c6da5f02e090c..48f8a40c38b3b0052fd133e0a98921bdb053016b 100644
--- a/pkgs/cassava-megaparsec.nix
+++ b/pkgs/cassava-megaparsec.nix
@@ -1,21 +1,46 @@
-{ mkDerivation, base, bytestring, cassava, hspec, hspec-megaparsec
-, lib, megaparsec, unordered-containers, vector
+{ mkDerivation
+, base
+, bytestring
+, cassava
+, hspec
+, hspec-megaparsec
+, lib
+, megaparsec
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "cassava-megaparsec";
   version = "2.0.4";
   sha256 = "16398f202df2898de482c156835ba6e7dea8ef71d7ac818c5cd4e72ad1f8e95d";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base bytestring cassava megaparsec unordered-containers vector
+    base
+    bytestring
+    cassava
+    megaparsec
+    unordered-containers
+    vector
   ];
   testHaskellDepends = [
-    base bytestring cassava hspec hspec-megaparsec vector
+    base
+    bytestring
+    cassava
+    hspec
+    hspec-megaparsec
+    vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/stackbuilders/cassava-megaparsec";
   description = "Megaparsec parser of CSV files that plays nicely with Cassava";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/cassava.nix b/pkgs/cassava.nix
index 3581c8633d6d1bc780c93bdd3671acaf3b23990c..f50659b544fc5be040b5ec365bd9260012d85ce5 100644
--- a/pkgs/cassava.nix
+++ b/pkgs/cassava.nix
@@ -1,28 +1,75 @@
-{ mkDerivation, array, attoparsec, base, bytestring, containers
-, deepseq, hashable, HUnit, lib, Only, QuickCheck
-, quickcheck-instances, scientific, test-framework
-, test-framework-hunit, test-framework-quickcheck2, text
-, text-short, transformers, unordered-containers, vector
+{ mkDerivation
+, array
+, attoparsec
+, base
+, bytestring
+, containers
+, deepseq
+, hashable
+, HUnit
+, lib
+, Only
+, QuickCheck
+, quickcheck-instances
+, scientific
+, test-framework
+, test-framework-hunit
+, test-framework-quickcheck2
+, text
+, text-short
+, transformers
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "cassava";
   version = "0.5.3.0";
   sha256 = "b4c8451f433ad7725cb8b9f7a7efe598ba103b16584713c91f48ae023829e9be";
   configureFlags = [ "-f-bytestring--lt-0_10_4" ];
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    array attoparsec base bytestring containers deepseq hashable Only
-    scientific text text-short transformers unordered-containers vector
+    array
+    attoparsec
+    base
+    bytestring
+    containers
+    deepseq
+    hashable
+    Only
+    scientific
+    text
+    text-short
+    transformers
+    unordered-containers
+    vector
   ];
   testHaskellDepends = [
-    attoparsec base bytestring hashable HUnit QuickCheck
-    quickcheck-instances scientific test-framework test-framework-hunit
-    test-framework-quickcheck2 text unordered-containers vector
+    attoparsec
+    base
+    bytestring
+    hashable
+    HUnit
+    QuickCheck
+    quickcheck-instances
+    scientific
+    test-framework
+    test-framework-hunit
+    test-framework-quickcheck2
+    text
+    unordered-containers
+    vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-hvr/cassava";
   description = "A CSV parsing and encoding library";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/cborg-json.nix b/pkgs/cborg-json.nix
index 39103b81d1f5f884b38748ebd52b8ab600f13b08..58b68fe5987b4f305fcb5ff0b3a6842e627e0f7a 100644
--- a/pkgs/cborg-json.nix
+++ b/pkgs/cborg-json.nix
@@ -19,6 +19,11 @@ mkDerivation {
   pname = "cborg-json";
   version = "0.2.5.0";
   sha256 = "58c373453f06fd8558e062c4fbe6dd862cb0ae28ac3c02ba3b607573bd077cd4";
+  revision = "1";
+  editedCabalFile = "0zzn2p6yl9mqw7agm5w7iiz105078gv66vxr8bqazilgssqk5wyg";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     aeson-pretty
@@ -40,11 +45,15 @@ mkDerivation {
     process
     zlib
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/well-typed/cborg";
   description = "A library for encoding JSON as CBOR";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/cborg.nix b/pkgs/cborg.nix
index 9f508ba2f7180c1672b5ab1e0f33e0122ee8de1f..8b28f71c818c3dd0bcfc9b4777e9f24bcc8a9085 100644
--- a/pkgs/cborg.nix
+++ b/pkgs/cborg.nix
@@ -26,6 +26,11 @@ mkDerivation {
   pname = "cborg";
   version = "0.2.8.0";
   sha256 = "2e59c827c273b57af0fcbbfb62f6d15faeb399e0d89d57baf8adcc60e62ab01e";
+  revision = "1";
+  editedCabalFile = "13m2shrlpvg5s9d40a2463mmckzg50y8jb47zfd6i1rg6q3q6xx6";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -57,10 +62,14 @@ mkDerivation {
     text
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Concise Binary Object Representation (CBOR)";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/cereal.nix b/pkgs/cereal.nix
index bcc990342c87b278236a4a3b250b0c1287c86651..4b476b402838752933fd5a48b90899646b5787ec 100644
--- a/pkgs/cereal.nix
+++ b/pkgs/cereal.nix
@@ -13,6 +13,9 @@ mkDerivation {
   pname = "cereal";
   version = "0.5.8.3";
   sha256 = "99905220661b26e5bd91130bd9772554938608a5b1d717240a6eb331121e0f6a";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -27,11 +30,15 @@ mkDerivation {
     test-framework
     test-framework-quickcheck2
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/GaloisInc/cereal";
   description = "A binary serialization library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/citeproc.nix b/pkgs/citeproc.nix
index a0b4ab88aa687e42c31a2c225e32ef206902d638..86ed0d6abacb471b5b944be6fc1231eda0502873 100644
--- a/pkgs/citeproc.nix
+++ b/pkgs/citeproc.nix
@@ -30,6 +30,7 @@ mkDerivation {
   sha256 = "67a852a7a9e0fa00713996e546045c11360ad9374e450cfe35154e69a0bfbfb7";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     attoparsec
@@ -64,10 +65,14 @@ mkDerivation {
     timeit
     transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Generates citations and bibliography from CSL styles";
   license = lib.licenses.bsd2;
+  broken = false;
 }
diff --git a/pkgs/co-log-core.nix b/pkgs/co-log-core.nix
index e39a227e8eedfcaa15b997581b5a1ea3a12d5fd0..c634d19d86eee54f00d87c13f3d931e448f59fa3 100644
--- a/pkgs/co-log-core.nix
+++ b/pkgs/co-log-core.nix
@@ -3,13 +3,20 @@ mkDerivation {
   pname = "co-log-core";
   version = "0.3.1.0";
   sha256 = "29720bee51dd0c89f35e27b89985a469a0436dc58750f4825874572e2a6317ec";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   testHaskellDepends = [ base doctest Glob ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/co-log/co-log-core";
   description = "Composable Contravariant Comonadic Logging Library";
   license = lib.licenses.mpl20;
+  broken = false;
 }
diff --git a/pkgs/co-log-polysemy.nix b/pkgs/co-log-polysemy.nix
index e3657b1c1e072452c20503f1f5f6ab8ba4a8fc17..34f4fd2bf1b025c2de939c3d61a37b7e72e998eb 100644
--- a/pkgs/co-log-polysemy.nix
+++ b/pkgs/co-log-polysemy.nix
@@ -5,14 +5,19 @@ mkDerivation {
   sha256 = "775989212f33126b035e1f26e836fc197c042d08811dca7ddf25b56fbdf3d7b0";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base co-log-core polysemy ];
   executableHaskellDepends = [ base co-log-core polysemy ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/co-log/co-log-polysemy";
   description = "Composable Contravariant Comonadic Logging Library";
   license = lib.licenses.mpl20;
   mainProgram = "play-colog-poly";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/comonad.nix b/pkgs/comonad.nix
index b26e36ba11097d5c59f3a869bb693813051edbc8..a89fa845aa3e46c9f0b2a6f16fa5a224ca170523 100644
--- a/pkgs/comonad.nix
+++ b/pkgs/comonad.nix
@@ -14,6 +14,9 @@ mkDerivation {
   sha256 = "ef6cdf2cc292cc43ee6aa96c581b235fdea8ab44a0bffb24dc79ae2b2ef33d13";
   revision = "1";
   editedCabalFile = "0zlgkcd61cwsdbgjz03pfbjxhj6dc25792h7rwh0zy677vbsn6hz";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
@@ -23,11 +26,15 @@ mkDerivation {
     transformers
     transformers-compat
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/ekmett/comonad/";
   description = "Comonads";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/compact.nix b/pkgs/compact.nix
index bac9585bb9e5e67c554584a5ff1db293d681deb3..97a446f99bc8d6f0e2dd34369d017e49b0a2fdd5 100644
--- a/pkgs/compact.nix
+++ b/pkgs/compact.nix
@@ -12,13 +12,20 @@ mkDerivation {
   sha256 = "03a6b534f4f8f06fe1f3921be74f90c2fab9da7f28e7520612c91c28da266277";
   revision = "1";
   editedCabalFile = "1013dkawaw3c6hvlfn9x584pq8z65fvbnp79dl6ll6r0a75rivvm";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base binary bytestring ghc-compact ];
   testHaskellDepends = [ base directory ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/ezyang/compact";
   description = "Non-GC'd, contiguous storage for immutable data structures";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/compactable.nix b/pkgs/compactable.nix
index cf683dea3826136b6e55712c0f217f8d896d707a..e32d4022abb6e98c14cf09f2269c12b86d57bfef 100644
--- a/pkgs/compactable.nix
+++ b/pkgs/compactable.nix
@@ -1,8 +1,27 @@
-{ mkDerivation, aeson, base, base-compat, bifunctors, containers
-, contravariant, data-default-class, deepseq, fetchgit, hashable
-, keys, lens, lib, QuickCheck, semigroupoids, sydtest
-, sydtest-discover, these, transformers, transformers-compat
-, unordered-containers, vector, vector-instances
+{ mkDerivation
+, aeson
+, base
+, base-compat
+, bifunctors
+, containers
+, contravariant
+, data-default-class
+, deepseq
+, fetchgit
+, hashable
+, keys
+, lens
+, lib
+, QuickCheck
+, semigroupoids
+, sydtest
+, sydtest-discover
+, these
+, transformers
+, transformers-compat
+, unordered-containers
+, vector
+, vector-instances
 }:
 mkDerivation {
   pname = "compactable";
@@ -13,19 +32,47 @@ mkDerivation {
     rev = "f63927b1e438c267f0d12f36e5b3735cfaebeeb4";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base base-compat bifunctors containers contravariant
-    data-default-class deepseq hashable keys lens QuickCheck
-    semigroupoids these transformers transformers-compat
-    unordered-containers vector vector-instances
+    aeson
+    base
+    base-compat
+    bifunctors
+    containers
+    contravariant
+    data-default-class
+    deepseq
+    hashable
+    keys
+    lens
+    QuickCheck
+    semigroupoids
+    these
+    transformers
+    transformers-compat
+    unordered-containers
+    vector
+    vector-instances
   ];
   testHaskellDepends = [
-    base containers QuickCheck sydtest sydtest-discover these vector
+    base
+    containers
+    QuickCheck
+    sydtest
+    sydtest-discover
+    these
+    vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "A typeclass for structures which can be catMaybed, filtered, and partitioned";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/composite-base.nix b/pkgs/composite-base.nix
index b1512872654a1cb9d0d1db9d246d9019f5e960bd..14ea321912323f67162ff46ce8345328f5facb61 100644
--- a/pkgs/composite-base.nix
+++ b/pkgs/composite-base.nix
@@ -20,6 +20,9 @@ mkDerivation {
   pname = "composite-base";
   version = "0.8.1.0";
   sha256 = "a8de050a65b8d3febfd48ea0d7b9bb215c8473b7dda7760d7c2df279a92258a3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     deepseq
@@ -52,11 +55,15 @@ mkDerivation {
     unliftio-core
     vinyl
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/composite-hs/composite-base#readme";
   description = "Shared utilities for composite-* packages";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/composite-cassava.nix b/pkgs/composite-cassava.nix
index 508ae206415ff1eb3e56828ae57fb17fec67e028..acf7a2600b8d7a9f7d18bd26da27ff5b4cf50eff 100644
--- a/pkgs/composite-cassava.nix
+++ b/pkgs/composite-cassava.nix
@@ -14,6 +14,9 @@ mkDerivation {
   pname = "composite-cassava";
   version = "0.0.3.1";
   sha256 = "aa776b23dcf8ad3833159777eb5e0230dd2681527d7089fd072a618cca791e8d";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     cassava
@@ -33,10 +36,14 @@ mkDerivation {
     unordered-containers
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Csv parsing functionality for composite";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/composite-dhall.nix b/pkgs/composite-dhall.nix
index 331ff31eace8690d07c6bebe81225704e3d7fab9..1840a1dfec971b82444642e6faac762d6050f095 100644
--- a/pkgs/composite-dhall.nix
+++ b/pkgs/composite-dhall.nix
@@ -12,6 +12,9 @@ mkDerivation {
   pname = "composite-dhall";
   version = "0.1.0.1";
   sha256 = "aa6c8a8a05c5aa5cc7c76440f57f9459f7f3aa07b1f4b290549a17c196c2eb34";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base composite-base dhall text vinyl ];
   testHaskellDepends = [
     base
@@ -22,10 +25,14 @@ mkDerivation {
     text
     vinyl
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Dhall instances for composite records";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/composite-lens-extra.nix b/pkgs/composite-lens-extra.nix
index 61327548013fe2743937b18496e7864d523605e1..6b3755b91776d0e02261be5717f3b1813bc1cc80 100644
--- a/pkgs/composite-lens-extra.nix
+++ b/pkgs/composite-lens-extra.nix
@@ -3,11 +3,18 @@ mkDerivation {
   pname = "composite-lens-extra";
   version = "0.1.0.0";
   sha256 = "778c01cc88cd62f9302968164e76c7bd7e0642924f5f0c1a2e880c3877fc4b24";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base composite-base lens vinyl ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Extra lens functions for composite";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/composite-tuple.nix b/pkgs/composite-tuple.nix
index 0f51d1cff3e091feeafe00e260ffd038645d4835..b7260fe23c38118ce8352deebc054d42d9bef410 100644
--- a/pkgs/composite-tuple.nix
+++ b/pkgs/composite-tuple.nix
@@ -5,11 +5,18 @@ mkDerivation {
   sha256 = "8164e73058eab642b22244057c1b4b26359d02cda53637bc1c9c8a5f30f9bd78";
   revision = "1";
   editedCabalFile = "0j7mj8g3v4x0vy4rbx00kxb7d41r3s3djbfin9f1h592ahyap1va";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base composite-base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Tuple functions for composite records";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/conduit-extra.nix b/pkgs/conduit-extra.nix
index 924aeb8ce684402b4e8be1bbad75509d66c2e762..129dbd60bf1bdb0cb9622f1868e7264dcff7c6c8 100644
--- a/pkgs/conduit-extra.nix
+++ b/pkgs/conduit-extra.nix
@@ -28,6 +28,9 @@ mkDerivation {
   pname = "conduit-extra";
   version = "1.3.6";
   sha256 = "8950c38049d892c38590d389bed49ecf880671f58ec63dd4709d9fe3d4b8f153";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     async
     attoparsec
@@ -74,11 +77,15 @@ mkDerivation {
     gauge
     transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/snoyberg/conduit";
   description = "Batteries included conduit: adapters for common libraries";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/conduit.nix b/pkgs/conduit.nix
index b4459b91ea7534784e1e6a37b6421289ea0e3921..a42c59852c25f93d00d4c89bcd5ba4ade707f25a 100644
--- a/pkgs/conduit.nix
+++ b/pkgs/conduit.nix
@@ -30,6 +30,9 @@ mkDerivation {
   pname = "conduit";
   version = "1.3.4.2";
   sha256 = "2cb9832f27c7cd50daed1309f688afc4da1bd49697cbeda8ec3f81ab0bcf2197";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -77,11 +80,15 @@ mkDerivation {
     transformers
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/snoyberg/conduit";
   description = "Streaming data processing library";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/config-ini.nix b/pkgs/config-ini.nix
index a9f1909358db064a5b1f03f390b5ed7b4346483c..26d35f783902a0c5d3698d274d3dd8508a7249bd 100644
--- a/pkgs/config-ini.nix
+++ b/pkgs/config-ini.nix
@@ -14,6 +14,9 @@ mkDerivation {
   pname = "config-ini";
   version = "0.2.5.0";
   sha256 = "6f7ce53c22392b5b41e3c0a9853e4183c3bbcb18010f9630f48a90f69bbf6f1f";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
@@ -31,11 +34,15 @@ mkDerivation {
     text
     unordered-containers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/aisamanra/config-ini";
   description = "A library for simple INI-based configuration files";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/constraints.nix b/pkgs/constraints.nix
index 07598782bb65b51bb130746d4c84e147a5848b5c..267fb7565ba73ef0e6370fa81b1f149678d9f46b 100644
--- a/pkgs/constraints.nix
+++ b/pkgs/constraints.nix
@@ -16,6 +16,9 @@ mkDerivation {
   pname = "constraints";
   version = "0.13.4";
   sha256 = "4186946df4b88c5d7cae3a42aa426f30fd5d249835ea1d290e139cebbf464434";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     binary
@@ -29,11 +32,15 @@ mkDerivation {
   ];
   testHaskellDepends = [ base hspec ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/ekmett/constraints/";
   description = "Constraint manipulation";
   license = lib.licenses.bsd2;
+  broken = false;
 }
diff --git a/pkgs/cryptohash-sha1.nix b/pkgs/cryptohash-sha1.nix
index 9637e672a8d4b67852253291579ccb2551a7c069..63031860829adb6bcd66a98d0b0ce1ec070423cb 100644
--- a/pkgs/cryptohash-sha1.nix
+++ b/pkgs/cryptohash-sha1.nix
@@ -15,6 +15,9 @@ mkDerivation {
   sha256 = "a4042c97ad02eb68e766577ca35c01970c33e96cfd74ccb4dd403e3476a23241";
   revision = "1";
   editedCabalFile = "0bz9rfl7b2iwn45m0lxcmsyi5rrv3xdgzx2lzr79bds91dw6i25b";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base bytestring ];
   testHaskellDepends = [
     base
@@ -26,11 +29,15 @@ mkDerivation {
     tasty-quickcheck
   ];
   benchmarkHaskellDepends = [ base bytestring criterion ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/hvr/cryptohash-sha1";
   description = "Fast, pure and practical SHA-1 implementation";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/cryptonite.nix b/pkgs/cryptonite.nix
index e6660effa51fa9864e9880dae4161db55669c651..0a5050cf94b5bfaafef5e92a9fd28ee9e0b1aa3f 100644
--- a/pkgs/cryptonite.nix
+++ b/pkgs/cryptonite.nix
@@ -18,6 +18,9 @@ mkDerivation {
   pname = "cryptonite";
   version = "0.30";
   sha256 = "56099c8a8aa01d2ee914b670c97c1f818186dbb886e2025b73d9c2afe3496b1d";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     basement
@@ -44,11 +47,15 @@ mkDerivation {
     memory
     random
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-crypto/cryptonite";
   description = "Cryptography Primitives sink";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/cursor-dirforest-brick.nix b/pkgs/cursor-dirforest-brick.nix
index 604db07586b4759f9bac9866e8603a80bd624ec0..48db710619bac5301a02e963e5e661916b44e654 100644
--- a/pkgs/cursor-dirforest-brick.nix
+++ b/pkgs/cursor-dirforest-brick.nix
@@ -1,5 +1,14 @@
-{ mkDerivation, base, brick, containers, cursor, cursor-brick
-, cursor-dirforest, dirforest, fetchgit, lib, vty
+{ mkDerivation
+, base
+, brick
+, containers
+, cursor
+, cursor-brick
+, cursor-dirforest
+, dirforest
+, fetchgit
+, lib
+, vty
 }:
 mkDerivation {
   pname = "cursor-dirforest-brick";
@@ -11,14 +20,27 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/cursor-dirforest-brick/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base brick containers cursor cursor-brick cursor-dirforest
-    dirforest vty
+    base
+    brick
+    containers
+    cursor
+    cursor-brick
+    cursor-dirforest
+    dirforest
+    vty
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/cursor-dirforest#readme";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/cursor-dirforest-gen.nix b/pkgs/cursor-dirforest-gen.nix
index 95ad29b24ba7c1b52068806b9b072b6d46843a5c..e3ad89ea9b95ce4005105fb48e537f381c8b8c00 100644
--- a/pkgs/cursor-dirforest-gen.nix
+++ b/pkgs/cursor-dirforest-gen.nix
@@ -1,8 +1,23 @@
-{ mkDerivation, base, containers, criterion, cursor
-, cursor-dirforest, cursor-gen, dirforest, fetchgit, filepath
-, genvalidity, genvalidity-containers, genvalidity-criterion
-, genvalidity-dirforest, genvalidity-hspec
-, genvalidity-hspec-optics, hspec, lib, path, QuickCheck
+{ mkDerivation
+, base
+, containers
+, criterion
+, cursor
+, cursor-dirforest
+, cursor-gen
+, dirforest
+, fetchgit
+, filepath
+, genvalidity
+, genvalidity-containers
+, genvalidity-criterion
+, genvalidity-dirforest
+, genvalidity-hspec
+, genvalidity-hspec-optics
+, hspec
+, lib
+, path
+, QuickCheck
 }:
 mkDerivation {
   pname = "cursor-dirforest-gen";
@@ -14,22 +29,50 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/cursor-dirforest-gen/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers cursor cursor-dirforest cursor-gen dirforest
-    filepath genvalidity genvalidity-containers genvalidity-dirforest
-    path QuickCheck
+    base
+    containers
+    cursor
+    cursor-dirforest
+    cursor-gen
+    dirforest
+    filepath
+    genvalidity
+    genvalidity-containers
+    genvalidity-dirforest
+    path
+    QuickCheck
   ];
   testHaskellDepends = [
-    base cursor cursor-dirforest cursor-gen dirforest genvalidity-hspec
-    genvalidity-hspec-optics hspec path QuickCheck
+    base
+    cursor
+    cursor-dirforest
+    cursor-gen
+    dirforest
+    genvalidity-hspec
+    genvalidity-hspec-optics
+    hspec
+    path
+    QuickCheck
   ];
   benchmarkHaskellDepends = [
-    base criterion cursor-dirforest genvalidity-criterion QuickCheck
+    base
+    criterion
+    cursor-dirforest
+    genvalidity-criterion
+    QuickCheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/cursor-dirforest#readme";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/cursor-dirforest.nix b/pkgs/cursor-dirforest.nix
index 94ec0c1a840edc6abca39aa9d02e5d6351fa69bd..50606e6ccbe399673bf53fd3dc8472135cfc5f91 100644
--- a/pkgs/cursor-dirforest.nix
+++ b/pkgs/cursor-dirforest.nix
@@ -1,5 +1,16 @@
-{ mkDerivation, base, containers, cursor, deepseq, dirforest
-, fetchgit, filepath, lib, microlens, path, text, validity
+{ mkDerivation
+, base
+, containers
+, cursor
+, deepseq
+, dirforest
+, fetchgit
+, filepath
+, lib
+, microlens
+, path
+, text
+, validity
 , validity-path
 }:
 mkDerivation {
@@ -12,14 +23,30 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/cursor-dirforest/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers cursor deepseq dirforest filepath microlens path
-    text validity validity-path
+    base
+    containers
+    cursor
+    deepseq
+    dirforest
+    filepath
+    microlens
+    path
+    text
+    validity
+    validity-path
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/cursor-dirforest#readme";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/cursor.nix b/pkgs/cursor.nix
index f794cba041458c9b5ac48d0fea63f5ce6a2314c4..0195b5a7ebb4695be377ec6bd986e9c074f71d6a 100644
--- a/pkgs/cursor.nix
+++ b/pkgs/cursor.nix
@@ -1,19 +1,40 @@
-{ mkDerivation, base, containers, deepseq, lib, microlens, text
-, validity, validity-containers, validity-text
+{ mkDerivation
+, base
+, containers
+, deepseq
+, lib
+, microlens
+, text
+, validity
+, validity-containers
+, validity-text
 }:
 mkDerivation {
   pname = "cursor";
   version = "0.3.2.0";
   sha256 = "4fe97cf1a3f179a0febb34bac2c31200cf79fd101ef07380709e9d64fdf25c24";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers deepseq microlens text validity validity-containers
+    base
+    containers
+    deepseq
+    microlens
+    text
+    validity
+    validity-containers
     validity-text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/cursor";
   description = "Purely Functional Cursors";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/data-fix.nix b/pkgs/data-fix.nix
index 61d17d73b6319cbe281aacf46f95adca155fe68c..fc311ee7b0082d19d5aa659309364eff801d7c30 100644
--- a/pkgs/data-fix.nix
+++ b/pkgs/data-fix.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "3a172d3bc0639c327345e965f9d9023e099425814b28dcdb7b60ff66d66219cc";
   revision = "3";
   editedCabalFile = "0z77i9y86wlc13396akl8qxq39rwpkhhcs5fadzk47bwn7v1gsmx";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base deepseq hashable ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/spell-music/data-fix";
   description = "Fixpoint data types";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/dec.nix b/pkgs/dec.nix
index d44d4289e5e4478bf4badefc028f66b261ff8520..02214e7db77183da7eedbd7541eedccbea8bea94 100644
--- a/pkgs/dec.nix
+++ b/pkgs/dec.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "dec";
   version = "0.0.5";
   sha256 = "e18043c7c7e68168489f164921a02efede0c0175a5012ed5451ec2242338df88";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base boring ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/phadej/vec";
   description = "Decidable propositions";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/dhall-json.nix b/pkgs/dhall-json.nix
index e31ed38e98c7182c9965c3fe382132c0f5f72cee..9f7dad85ead1c170a545e8a5584ce408ae28b9f7 100644
--- a/pkgs/dhall-json.nix
+++ b/pkgs/dhall-json.nix
@@ -1,8 +1,26 @@
-{ mkDerivation, aeson, aeson-pretty, aeson-yaml, ansi-terminal
-, base, bytestring, containers, dhall, exceptions, filepath
-, lens-family-core, lib, optparse-applicative, prettyprinter
-, prettyprinter-ansi-terminal, scientific, tasty, tasty-hunit
-, tasty-silver, text, unordered-containers, vector
+{ mkDerivation
+, aeson
+, aeson-pretty
+, aeson-yaml
+, ansi-terminal
+, base
+, bytestring
+, containers
+, dhall
+, exceptions
+, filepath
+, lens-family-core
+, lib
+, optparse-applicative
+, prettyprinter
+, prettyprinter-ansi-terminal
+, scientific
+, tasty
+, tasty-hunit
+, tasty-silver
+, text
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "dhall-json";
@@ -12,22 +30,56 @@ mkDerivation {
   editedCabalFile = "0m5sngc1j7jagn95qmjz7gpw2jgqnnafgr6nwd506q8z2jg2a3my";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson aeson-pretty aeson-yaml base bytestring containers dhall
-    exceptions filepath lens-family-core optparse-applicative
-    prettyprinter scientific text unordered-containers vector
+    aeson
+    aeson-pretty
+    aeson-yaml
+    base
+    bytestring
+    containers
+    dhall
+    exceptions
+    filepath
+    lens-family-core
+    optparse-applicative
+    prettyprinter
+    scientific
+    text
+    unordered-containers
+    vector
   ];
   executableHaskellDepends = [
-    aeson aeson-pretty ansi-terminal base bytestring dhall exceptions
-    optparse-applicative prettyprinter prettyprinter-ansi-terminal text
+    aeson
+    aeson-pretty
+    ansi-terminal
+    base
+    bytestring
+    dhall
+    exceptions
+    optparse-applicative
+    prettyprinter
+    prettyprinter-ansi-terminal
+    text
   ];
   testHaskellDepends = [
-    aeson base bytestring dhall tasty tasty-hunit tasty-silver text
+    aeson
+    base
+    bytestring
+    dhall
+    tasty
+    tasty-hunit
+    tasty-silver
+    text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Convert between Dhall and JSON or YAML";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/dhall.nix b/pkgs/dhall.nix
index fe73f8c6a62560f5bf7b46449ba914ef919c5d9a..ab0f62167be60c12f484c90f252d06fa8727ea41 100644
--- a/pkgs/dhall.nix
+++ b/pkgs/dhall.nix
@@ -75,8 +75,8 @@ mkDerivation {
   pname = "dhall";
   version = "1.41.2";
   sha256 = "6a9a026e698e5c1a1e103fcb376e8494615b03ef2450f0b6c5e6b43877cea592";
-  revision = "1";
-  editedCabalFile = "1gi2j6d3mh0wqx6756cp04c676843wdibfwv3i2wypvsk74dlvjm";
+  revision = "2";
+  editedCabalFile = "18jh1c2zinwglih5gc8av2szicyywq5q0kl2h5200sm67nxmask9";
   isLibrary = true;
   isExecutable = true;
   enableSeparateDataOutput = true;
@@ -307,11 +307,15 @@ mkDerivation {
     uri-encode
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "A configuration language guaranteed to terminate";
   license = lib.licenses.bsd3;
   mainProgram = "dhall";
+  broken = false;
 }
diff --git a/pkgs/dimensional.nix b/pkgs/dimensional.nix
index fbe1ad869f94ddc89957ade42c0a87d6f87e44db..03a0e168aba48d6fbe5c16af23cf2014379b309d 100644
--- a/pkgs/dimensional.nix
+++ b/pkgs/dimensional.nix
@@ -18,6 +18,9 @@ mkDerivation {
   pname = "dimensional";
   version = "1.5";
   sha256 = "da9ad59b8feebbc038f824bc960a099fc5ccc8cb1d234f12c230044be906a599";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     deepseq
@@ -36,11 +39,15 @@ mkDerivation {
   ];
   testToolDepends = [ hspec-discover ];
   benchmarkHaskellDepends = [ base criterion deepseq ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/bjornbm/dimensional/";
   description = "Statically checked physical dimensions";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/dirforest.nix b/pkgs/dirforest.nix
index e7d83741c2ded58147bcc9172924924ad3e2ce0d..0518e3a83f838d255edd8465f43423b112dd4a66 100644
--- a/pkgs/dirforest.nix
+++ b/pkgs/dirforest.nix
@@ -1,5 +1,15 @@
-{ mkDerivation, aeson, base, containers, deepseq, fetchgit
-, filepath, lib, path, path-io, validity, validity-containers
+{ mkDerivation
+, aeson
+, base
+, containers
+, deepseq
+, fetchgit
+, filepath
+, lib
+, path
+, path-io
+, validity
+, validity-containers
 , validity-path
 }:
 mkDerivation {
@@ -12,14 +22,29 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/dirforest/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base containers deepseq filepath path path-io validity
-    validity-containers validity-path
+    aeson
+    base
+    containers
+    deepseq
+    filepath
+    path
+    path-io
+    validity
+    validity-containers
+    validity-path
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/dirforest#readme";
   license = "unknown";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/distribution-nixpkgs.nix b/pkgs/distribution-nixpkgs.nix
index 288b16b1bc4dcdf06d9be8f1ed439eb16e46cc0e..a71f86ae20fd4628b2837ae35eec7dfe92d61bc0 100644
--- a/pkgs/distribution-nixpkgs.nix
+++ b/pkgs/distribution-nixpkgs.nix
@@ -1,5 +1,17 @@
-{ mkDerivation, aeson, base, bytestring, Cabal, containers, deepseq
-, directory, hspec, language-nix, lens, lib, pretty, process
+{ mkDerivation
+, aeson
+, base
+, bytestring
+, Cabal
+, containers
+, deepseq
+, directory
+, hspec
+, language-nix
+, lens
+, lib
+, pretty
+, process
 }:
 mkDerivation {
   pname = "distribution-nixpkgs";
@@ -7,19 +19,40 @@ mkDerivation {
   sha256 = "c9f04b175ea93074bea78b508e1e9c44a17f6151cafa375cfdbfe668b08ff900";
   revision = "1";
   editedCabalFile = "0xzrh7kfla9c43jjjnd2r13xsp994gdkxkwgav2kl50qxzdb88nx";
+  isLibrary = true;
+  isExecutable = false;
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
-    aeson base bytestring Cabal containers deepseq language-nix lens
-    pretty process
+    aeson
+    base
+    bytestring
+    Cabal
+    containers
+    deepseq
+    language-nix
+    lens
+    pretty
+    process
   ];
   testHaskellDepends = [
-    aeson base Cabal deepseq directory hspec language-nix lens
+    aeson
+    base
+    Cabal
+    deepseq
+    directory
+    hspec
+    language-nix
+    lens
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NixOS/cabal2nix/tree/master/distribution-nixpkgs#readme";
   description = "Types and functions to manipulate the Nixpkgs distribution";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/doctest.nix b/pkgs/doctest.nix
index 0375527273f29a85023892743a2d2c3b4599425f..61aa251d9edfa5930aad1675d43db6ee0da5f935 100644
--- a/pkgs/doctest.nix
+++ b/pkgs/doctest.nix
@@ -34,6 +34,7 @@ mkDerivation {
   };
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     base-compat
@@ -85,12 +86,16 @@ mkDerivation {
     transformers
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/sol/doctest#readme";
   description = "Test interactive Haskell examples";
   license = lib.licenses.mit;
   mainProgram = "doctest";
+  broken = false;
 }
diff --git a/pkgs/double-conversion.nix b/pkgs/double-conversion.nix
index 5f889a133edea9b94d24a0821263598cd70f8313..8f1b404e83addc099bdd7dfaf9b59b40d38864d1 100644
--- a/pkgs/double-conversion.nix
+++ b/pkgs/double-conversion.nix
@@ -20,6 +20,9 @@ mkDerivation {
     rev = "5d092e0664442eaac8ae1d101dba57ce9b1c9b03";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -36,11 +39,15 @@ mkDerivation {
     test-framework-quickcheck2
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell/double-conversion";
   description = "Fast conversion between single and double precision floating point and text";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/ed25519.nix b/pkgs/ed25519.nix
index 978b4a71595bd8ab7c3f413c88c56e07ee343d48..e9202e816ea3942cad9960192a843adfefb66093 100644
--- a/pkgs/ed25519.nix
+++ b/pkgs/ed25519.nix
@@ -21,6 +21,9 @@ mkDerivation {
     rev = "faf8fe90aa1cd2492ea1e64c55f5c59fc0322210";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base bytestring ghc-prim ];
   testHaskellDepends = [
     base
@@ -32,11 +35,15 @@ mkDerivation {
     QuickCheck
   ];
   benchmarkHaskellDepends = [ base bytestring criterion deepseq ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://thoughtpolice.github.com/hs-ed25519";
   description = "Ed25519 cryptographic signatures";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/effectful-cache.nix b/pkgs/effectful-cache.nix
index df4587e3ddaa150bfe8f46605e40bb155da69e6e..53ed9d7e72f10e02afbbf28db3b637fe469e2224 100644
--- a/pkgs/effectful-cache.nix
+++ b/pkgs/effectful-cache.nix
@@ -17,6 +17,9 @@ mkDerivation {
     rev = "0a5581da7c21a05a9ab1762a6da6997090fe311d";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base cache effectful-core hashable ];
   testHaskellDepends = [
     base
@@ -26,10 +29,14 @@ mkDerivation {
     tasty
     tasty-hunit
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-effectful/effectful-cache/tree/main/effectful-cache#readme";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/effectful-core.nix b/pkgs/effectful-core.nix
index de5471b2a09569627bf0b301c3c88376cd52ba0b..b62687dad4a2527fdc5e94922bd5bb443e622791 100644
--- a/pkgs/effectful-core.nix
+++ b/pkgs/effectful-core.nix
@@ -12,6 +12,9 @@ mkDerivation {
   pname = "effectful-core";
   version = "2.1.0.0";
   sha256 = "93920bb5b58d6c92f51823c95e436a1a35c40fa677ee4f96014267698c43efd1";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
@@ -21,10 +24,14 @@ mkDerivation {
     transformers-base
     unliftio-core
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "An easy to use, performant extensible effects library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/effectful-th.nix b/pkgs/effectful-th.nix
index 65b61c5416a51a24318da8a2f3d545d346a160d8..04587a613108ae7310223524b02bb51bfcc7f7a8 100644
--- a/pkgs/effectful-th.nix
+++ b/pkgs/effectful-th.nix
@@ -13,6 +13,9 @@ mkDerivation {
   sha256 = "302605bbc2bb8a1b97308d9611faf5e121958b846cbeb9421e2657a902ef7a63";
   revision = "3";
   editedCabalFile = "1nqwvgdvqgh4dvkidyaga7jd95p3hn54hy5gwadsvyf9lll4vjck";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
@@ -22,10 +25,14 @@ mkDerivation {
     th-abstraction
   ];
   testHaskellDepends = [ base effectful ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Template Haskell utilities for the effectful library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/effectful.nix b/pkgs/effectful.nix
index 47c505f4361f799278fd643b95bd82c6d63fe63b..0777cab56d3ae07f2e5fd28e6afb9d2e3a7d6976 100644
--- a/pkgs/effectful.nix
+++ b/pkgs/effectful.nix
@@ -22,6 +22,9 @@ mkDerivation {
   pname = "effectful";
   version = "2.1.0.0";
   sha256 = "76147d4d761d3267607a5f71c5925cbb2e8ae538aacaf6c6ddd9574eabec739b";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     async
     base
@@ -51,10 +54,14 @@ mkDerivation {
     unix
     unliftio
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "An easy to use, performant extensible effects library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/email-validate.nix b/pkgs/email-validate.nix
index 05e17e100668b7c43936108667803c44955e625f..059626789e00072dd8efc024ca777232db64f4eb 100644
--- a/pkgs/email-validate.nix
+++ b/pkgs/email-validate.nix
@@ -12,6 +12,9 @@ mkDerivation {
   pname = "email-validate";
   version = "2.3.2.16";
   sha256 = "b8e5f155c1ba78ae25be88858b201d138cd1363519572edd9a13a9d086f023b3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     attoparsec
     base
@@ -19,11 +22,15 @@ mkDerivation {
     template-haskell
   ];
   testHaskellDepends = [ base bytestring doctest hspec QuickCheck ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/Porges/email-validate-hs";
   description = "Email address validation";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/extra.nix b/pkgs/extra.nix
index 3147160cd9c08dd107c77f127ec9fd2bb0517bf0..73ed1bbce985dd3b3d44b90463b6c6248c8c34ff 100644
--- a/pkgs/extra.nix
+++ b/pkgs/extra.nix
@@ -14,6 +14,9 @@ mkDerivation {
   pname = "extra";
   version = "1.7.12";
   sha256 = "e571a9ec1d8865f0fbb0e0ba1eb575f783b0365c80db19b54a93600bae43b03c";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     clock
@@ -31,11 +34,15 @@ mkDerivation {
     quickcheck-instances
     unix
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/ndmitchell/extra#readme";
   description = "Extra functions I use";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/fcf-containers.nix b/pkgs/fcf-containers.nix
index 4eb346b79be39dc875648279bbbd3c325e917919..a608d5dabd0e7995ab7eed90b90d0a19fa997f82 100644
--- a/pkgs/fcf-containers.nix
+++ b/pkgs/fcf-containers.nix
@@ -12,6 +12,7 @@ mkDerivation {
   sha256 = "1a8fedce82b6daca5a0ea0e9b1913da3e908db2cea0f6efbfa9f1305d1df6488";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base first-class-families ghc-prim mtl ];
   executableHaskellDepends = [ base first-class-families ];
   testHaskellDepends = [
@@ -20,11 +21,15 @@ mkDerivation {
     first-class-families
     ghc-prim
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/gspia/fcf-containers";
   description = "Data structures and algorithms for first-class-families";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/finite-field.nix b/pkgs/finite-field.nix
index b55e72960d47c31a99298469e790fe380a0556f0..397efd2b32fd773c90abef134f92368789111a4e 100644
--- a/pkgs/finite-field.nix
+++ b/pkgs/finite-field.nix
@@ -17,6 +17,9 @@ mkDerivation {
   pname = "finite-field";
   version = "0.10.0";
   sha256 = "b279ac001447da39cae504ecd3fc5efed43814fdf6f680c0d4a8afd7086882b3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     deepseq
@@ -37,10 +40,14 @@ mkDerivation {
     tasty-quickcheck
     tasty-th
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Finite Fields";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/first-class-families.nix b/pkgs/first-class-families.nix
index a32fb46570c275dac59072b4fa93a9c67a44c174..b0f56fa72d1a5b3654dee38694e8a71a13853bef 100644
--- a/pkgs/first-class-families.nix
+++ b/pkgs/first-class-families.nix
@@ -5,13 +5,20 @@ mkDerivation {
   sha256 = "4a1c8fbdbe01757ea8dc3190050d7a4a72c86e205d23676182292fe192c1da72";
   revision = "2";
   editedCabalFile = "0idiqb4ckwa7hya827gc2cbjh83wmz3cppnl124834pkla2h99np";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   testHaskellDepends = [ base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/Lysxia/first-class-families#readme";
   description = "First-class type families";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/foldl.nix b/pkgs/foldl.nix
index 73c72080e72851dd49b175cf9a591aac2cf8085b..46c82dcc6acf5c22f67f5e842e9c6458dd2580c8 100644
--- a/pkgs/foldl.nix
+++ b/pkgs/foldl.nix
@@ -23,6 +23,9 @@ mkDerivation {
   sha256 = "4f59360d96fb9ff10861944dd8a89b2448ea2b7dedc376546f4de80125f5c47d";
   revision = "5";
   editedCabalFile = "1b97k85zryid7x2ygi92ilv480ahfjn5yf1f4blllwyxn7zgvjv4";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -41,10 +44,14 @@ mkDerivation {
   ];
   testHaskellDepends = [ base doctest ];
   benchmarkHaskellDepends = [ base criterion ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Composable, streaming, and efficient left folds";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/foundation.nix b/pkgs/foundation.nix
index 09f3a18d75b22b260ce713ede96fd261504d264e..584d41b5d5f7db9118ab39105bc41009a0ef446a 100644
--- a/pkgs/foundation.nix
+++ b/pkgs/foundation.nix
@@ -3,14 +3,21 @@ mkDerivation {
   pname = "foundation";
   version = "0.0.29";
   sha256 = "34839bab424ffd5aed228271d75b15a84ed94eab515e44be909a9b37948173c1";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base basement ghc-prim ];
   testHaskellDepends = [ base basement ];
   benchmarkHaskellDepends = [ base basement gauge ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-foundation/foundation";
   description = "Alternative prelude with batteries and no dependencies";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/fsnotify.nix b/pkgs/fsnotify.nix
index 08d17e8f140293478f6095e41065485a3f4a16ba..378d2859da491cebb07e4dc6d65fa6d521406750 100644
--- a/pkgs/fsnotify.nix
+++ b/pkgs/fsnotify.nix
@@ -1,25 +1,70 @@
-{ mkDerivation, async, base, bytestring, containers, directory
-, exceptions, filepath, hinotify, lib, monad-control, random, retry
-, safe-exceptions, sandwich, temporary, text, time, unix
-, unix-compat, unliftio
+{ mkDerivation
+, async
+, base
+, bytestring
+, containers
+, directory
+, exceptions
+, filepath
+, hinotify
+, lib
+, monad-control
+, random
+, retry
+, safe-exceptions
+, sandwich
+, temporary
+, text
+, time
+, unix
+, unix-compat
+, unliftio
 }:
 mkDerivation {
   pname = "fsnotify";
   version = "0.4.1.0";
   sha256 = "d130fb4a871a181a3d1485f24da85aa49d6ff9022ce08f8401b4626143eaf7ef";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    async base bytestring containers directory filepath hinotify
-    monad-control safe-exceptions text time unix unix-compat
+    async
+    base
+    bytestring
+    containers
+    directory
+    filepath
+    hinotify
+    monad-control
+    safe-exceptions
+    text
+    time
+    unix
+    unix-compat
   ];
   testHaskellDepends = [
-    async base directory exceptions filepath random retry
-    safe-exceptions sandwich temporary unix-compat unliftio
+    async
+    base
+    directory
+    exceptions
+    filepath
+    random
+    retry
+    safe-exceptions
+    sandwich
+    temporary
+    unix-compat
+    unliftio
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-fswatch/hfsnotify";
   description = "Cross platform library for file change notification";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/fuzzy-time.nix b/pkgs/fuzzy-time.nix
index 9ff15c0638114cae3d95525d408db963b9d0fc56..6b9e71d515772a921159b67f07d670ac8cf00bf6 100644
--- a/pkgs/fuzzy-time.nix
+++ b/pkgs/fuzzy-time.nix
@@ -1,17 +1,39 @@
-{ mkDerivation, base, containers, deepseq, lib, megaparsec, text
-, time, validity, validity-time
+{ mkDerivation
+, base
+, containers
+, deepseq
+, lib
+, megaparsec
+, text
+, time
+, validity
+, validity-time
 }:
 mkDerivation {
   pname = "fuzzy-time";
   version = "0.2.0.3";
   sha256 = "5ee4ce435d95810f4d3ae9bbe860fa34ad1d81d4cfe54c9804a809e0b48dc28e";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers deepseq megaparsec text time validity validity-time
+    base
+    containers
+    deepseq
+    megaparsec
+    text
+    time
+    validity
+    validity-time
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/fuzzy-time";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/generic-lens-core.nix b/pkgs/generic-lens-core.nix
index 3b899c2af0a90881729e9c5e3e4087a2333c4ec4..d7c62b836bb924591eb727e3424745849e5b5d9a 100644
--- a/pkgs/generic-lens-core.nix
+++ b/pkgs/generic-lens-core.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "8ee6f17baa52db80763a46814be391418441861b2e519bed8c047db37c622422";
   revision = "1";
   editedCabalFile = "1dbjhd6k7ypqa9f4h9v2xndgb4mjhfli3n1vjm8r8ga0kfndbqfn";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base indexed-profunctors text ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/kcsongor/generic-lens";
   description = "Generically derive traversals, lenses and prisms";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/generic-lens-lite.nix b/pkgs/generic-lens-lite.nix
index 31bd80896e726f8630bee43f51ece06a87a7f61f..7fcd03b2e3722f009c6d96578983ae41ba833283 100644
--- a/pkgs/generic-lens-lite.nix
+++ b/pkgs/generic-lens-lite.nix
@@ -5,13 +5,20 @@ mkDerivation {
   sha256 = "865db698880aa050641e43124ce2f3aed064e33c25d3aec85aa040e3e105e01f";
   revision = "4";
   editedCabalFile = "1aw808ifylrwjpsf754gzq4npmh7c872cy2fsm7r2gpjgk7mkpp6";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   testHaskellDepends = [ base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/phadej/generic-lens-lite";
   description = "Monomorphic field lens like with generic-lens";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/generic-monoid.nix b/pkgs/generic-monoid.nix
index e0d5d45cc222c9fbeff1c122ec4ac85a99b86aa4..55c9fa13993946008812fb5466e7954424eb247a 100644
--- a/pkgs/generic-monoid.nix
+++ b/pkgs/generic-monoid.nix
@@ -3,13 +3,20 @@ mkDerivation {
   pname = "generic-monoid";
   version = "0.1.0.1";
   sha256 = "cfd072ad70af41c1b94ac24e42e2635f37ed2a54e8f4be871be78b18b66b2adf";
-  revision = "1";
-  editedCabalFile = "17dfarnbv6si8rgajb3jqsbc4k1nxmvga2h1lhmpnq43n2fdkqkq";
+  revision = "2";
+  editedCabalFile = "0p3hk9c6qn5kbgi3a4my3rq5cc43wcl93hx6axgzi5wkvimpv653";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Derive monoid instances for product types";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/generic-optics-lite.nix b/pkgs/generic-optics-lite.nix
index c3c3084bfda3b55e14fa1ad9f702577954ab5f78..4966dfd561be13f811252c4da763dd60f6a02c36 100644
--- a/pkgs/generic-optics-lite.nix
+++ b/pkgs/generic-optics-lite.nix
@@ -5,13 +5,20 @@ mkDerivation {
   sha256 = "b1a75e89e612c8866e47e922db65a7250e3e3890b26309db4d466665c3d4c56d";
   revision = "4";
   editedCabalFile = "1k5lkdzzdqq743bcw0shhwxj2i7ywh7rihdgasy543i5mvcp0cr4";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base generic-lens-lite optics-core ];
   testHaskellDepends = [ base optics-core ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/phadej/generic-lens-lite";
   description = "Monomorphic field opics like with generic-lens";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/generic-optics.nix b/pkgs/generic-optics.nix
index 8424519362328959d5a3b317407c000fbf9a12d6..232fbff20fe82fe197bc80413d12b815491957d7 100644
--- a/pkgs/generic-optics.nix
+++ b/pkgs/generic-optics.nix
@@ -14,6 +14,9 @@ mkDerivation {
   sha256 = "5f1c422a22277d5f0fb5fb7493789e02b13e6d5b36ecd33fd44e8796e75a87af";
   revision = "1";
   editedCabalFile = "13wkbs8x0clkqzi4xqin89qywpky8jkpz9cxgwsglbpcyw11jvgq";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     generic-lens-core
@@ -27,11 +30,15 @@ mkDerivation {
     inspection-testing
     optics-core
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/kcsongor/generic-lens";
   description = "Generically derive traversals, lenses and prisms";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/generics-sop.nix b/pkgs/generics-sop.nix
index 4dd6281f4360f4577597994c1aa3d15bbe369ecc..40b5a8f128c2e9aea62b6f1f6756fa9083b728aa 100644
--- a/pkgs/generics-sop.nix
+++ b/pkgs/generics-sop.nix
@@ -14,6 +14,9 @@ mkDerivation {
   sha256 = "639d4140520d608a73a81186aca6db40fcb03ec8a818dbce79fcb0b39aa70b25";
   revision = "1";
   editedCabalFile = "1s8bx25yrjqy1cj9y1s1m8a8qlby9dxjzin16yymz7g39fqcqxz8";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     ghc-prim
@@ -28,10 +31,14 @@ mkDerivation {
     deepseq
     template-haskell
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Generic Programming using True Sums of Products";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/genvalidity-aeson.nix b/pkgs/genvalidity-aeson.nix
index 62d3ef19725215b6c03bf541d84bea37f8fa0b8b..33d6e120fe4818e3766b728bcf06fde058cf49f5 100644
--- a/pkgs/genvalidity-aeson.nix
+++ b/pkgs/genvalidity-aeson.nix
@@ -20,6 +20,9 @@ mkDerivation {
   pname = "genvalidity-aeson";
   version = "1.0.0.1";
   sha256 = "6101f09c02b925209673d6aed691e64e60a127f41aff1750b27dc7e18caeba48";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     base
@@ -46,11 +49,15 @@ mkDerivation {
     criterion
     genvalidity-criterion
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for aeson";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/genvalidity-bytestring.nix b/pkgs/genvalidity-bytestring.nix
index 57eb5f05c2fb67dbf903363ef9668b2699ebe4cb..eebba6a44a1a37df085f6de3fb4657eab7945e18 100644
--- a/pkgs/genvalidity-bytestring.nix
+++ b/pkgs/genvalidity-bytestring.nix
@@ -17,6 +17,9 @@ mkDerivation {
   pname = "genvalidity-bytestring";
   version = "1.0.0.1";
   sha256 = "3311f83fabcd549785b009868c63e53723774fa35fe755fe7bfc537c082c6dbb";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -44,11 +47,15 @@ mkDerivation {
     genvalidity-criterion
     QuickCheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for ByteString";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/genvalidity-case-insensitive.nix b/pkgs/genvalidity-case-insensitive.nix
index b2d51ce2391654872659ffcd0c3823b8e4d9bb38..24f2902b031dfdc58afd7deacfd7012d5719a919 100644
--- a/pkgs/genvalidity-case-insensitive.nix
+++ b/pkgs/genvalidity-case-insensitive.nix
@@ -1,26 +1,51 @@
-{ mkDerivation, base, case-insensitive, criterion, genvalidity
-, genvalidity-criterion, genvalidity-hspec, hspec, lib, QuickCheck
+{ mkDerivation
+, base
+, case-insensitive
+, criterion
+, genvalidity
+, genvalidity-criterion
+, genvalidity-hspec
+, hspec
+, lib
+, QuickCheck
 , validity-case-insensitive
 }:
 mkDerivation {
   pname = "genvalidity-case-insensitive";
   version = "0.0.0.1";
   sha256 = "40e26a8a2f53ae592f87d85bcffce28a1c8af2ffdb977ac88d5ed7df99970aa9";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base case-insensitive genvalidity validity-case-insensitive
+    base
+    case-insensitive
+    genvalidity
+    validity-case-insensitive
   ];
   testHaskellDepends = [
-    base case-insensitive genvalidity-hspec hspec
+    base
+    case-insensitive
+    genvalidity-hspec
+    hspec
   ];
   benchmarkHaskellDepends = [
-    base case-insensitive criterion genvalidity genvalidity-criterion
+    base
+    case-insensitive
+    criterion
+    genvalidity
+    genvalidity-criterion
     QuickCheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for case-insensitive";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-containers.nix b/pkgs/genvalidity-containers.nix
index 666cd1de78d85715aed3ef196ce7939271329a3b..f2e0229cf0e2fd2e1769600abce6d9d194c2cab1 100644
--- a/pkgs/genvalidity-containers.nix
+++ b/pkgs/genvalidity-containers.nix
@@ -1,27 +1,60 @@
-{ mkDerivation, base, containers, criterion, genvalidity
-, genvalidity-criterion, genvalidity-hspec, genvalidity-property
-, hspec, lib, QuickCheck, validity, validity-containers
+{ mkDerivation
+, base
+, containers
+, criterion
+, genvalidity
+, genvalidity-criterion
+, genvalidity-hspec
+, genvalidity-property
+, hspec
+, lib
+, QuickCheck
+, validity
+, validity-containers
 }:
 mkDerivation {
   pname = "genvalidity-containers";
   version = "1.0.0.1";
   sha256 = "3726836f06ef2f7ed26c088530e7af63b8869d9aaec63ae8135d32ceac88b994";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers genvalidity QuickCheck validity validity-containers
+    base
+    containers
+    genvalidity
+    QuickCheck
+    validity
+    validity-containers
   ];
   testHaskellDepends = [
-    base containers genvalidity genvalidity-hspec genvalidity-property
-    hspec QuickCheck validity validity-containers
+    base
+    containers
+    genvalidity
+    genvalidity-hspec
+    genvalidity-property
+    hspec
+    QuickCheck
+    validity
+    validity-containers
   ];
   benchmarkHaskellDepends = [
-    base containers criterion genvalidity genvalidity-criterion
+    base
+    containers
+    criterion
+    genvalidity
+    genvalidity-criterion
     QuickCheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for containers";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-criterion.nix b/pkgs/genvalidity-criterion.nix
index 42235cf247d1e85e79a0f1da2c35fa03b9f64223..5a44656d5c0e69a8dc19a4d887246f85ade77716 100644
--- a/pkgs/genvalidity-criterion.nix
+++ b/pkgs/genvalidity-criterion.nix
@@ -1,21 +1,42 @@
-{ mkDerivation, base, criterion, deepseq, genvalidity, lib
-, QuickCheck, vector
+{ mkDerivation
+, base
+, criterion
+, deepseq
+, genvalidity
+, lib
+, QuickCheck
+, vector
 }:
 mkDerivation {
   pname = "genvalidity-criterion";
   version = "1.1.0.0";
   sha256 = "a94329cad18ba86cbeb05b6c76bc88b5fc94fa7a1a1024671fbb63f7b3dd4e56";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base criterion deepseq genvalidity QuickCheck vector
+    base
+    criterion
+    deepseq
+    genvalidity
+    QuickCheck
+    vector
   ];
   benchmarkHaskellDepends = [
-    base criterion genvalidity QuickCheck
+    base
+    criterion
+    genvalidity
+    QuickCheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Criterion benchmarks for generators";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-dirforest.nix b/pkgs/genvalidity-dirforest.nix
index 8c8ca4809009a788e40c785a7d0504fdbfa38162..077b4ff2940780f990289851bad912efd8d926f5 100644
--- a/pkgs/genvalidity-dirforest.nix
+++ b/pkgs/genvalidity-dirforest.nix
@@ -1,8 +1,25 @@
-{ mkDerivation, base, bytestring, containers, criterion, dirforest
-, fetchgit, filepath, genvalidity, genvalidity-bytestring
-, genvalidity-containers, genvalidity-criterion, genvalidity-hspec
-, genvalidity-hspec-aeson, genvalidity-path, genvalidity-text
-, hspec, lib, path, path-io, pretty-show, QuickCheck
+{ mkDerivation
+, base
+, bytestring
+, containers
+, criterion
+, dirforest
+, fetchgit
+, filepath
+, genvalidity
+, genvalidity-bytestring
+, genvalidity-containers
+, genvalidity-criterion
+, genvalidity-hspec
+, genvalidity-hspec-aeson
+, genvalidity-path
+, genvalidity-text
+, hspec
+, lib
+, path
+, path-io
+, pretty-show
+, QuickCheck
 }:
 mkDerivation {
   pname = "genvalidity-dirforest";
@@ -14,23 +31,51 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/genvalidity-dirforest/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers dirforest filepath genvalidity
-    genvalidity-containers genvalidity-path path QuickCheck
+    base
+    containers
+    dirforest
+    filepath
+    genvalidity
+    genvalidity-containers
+    genvalidity-path
+    path
+    QuickCheck
   ];
   testHaskellDepends = [
-    base bytestring containers dirforest filepath
-    genvalidity-bytestring genvalidity-hspec genvalidity-hspec-aeson
-    hspec path path-io pretty-show QuickCheck
+    base
+    bytestring
+    containers
+    dirforest
+    filepath
+    genvalidity-bytestring
+    genvalidity-hspec
+    genvalidity-hspec-aeson
+    hspec
+    path
+    path-io
+    pretty-show
+    QuickCheck
   ];
   benchmarkHaskellDepends = [
-    base criterion dirforest genvalidity genvalidity-criterion
+    base
+    criterion
+    dirforest
+    genvalidity
+    genvalidity-criterion
     genvalidity-text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/dirforest#readme";
   license = "unknown";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-hspec.nix b/pkgs/genvalidity-hspec.nix
index 07a5d281a3dc043711bcdbbb8c32bea1ff8a4e3b..bd4047af8c64dcfb28190f0d9c33758246c91e6e 100644
--- a/pkgs/genvalidity-hspec.nix
+++ b/pkgs/genvalidity-hspec.nix
@@ -13,6 +13,9 @@ mkDerivation {
   pname = "genvalidity-hspec";
   version = "1.0.0.2";
   sha256 = "84f9a27f7345616162e80081b867961734fc750acdbac40e64c5db4d7f055b03";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     genvalidity
@@ -30,11 +33,15 @@ mkDerivation {
     hspec-core
     QuickCheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Standard spec's for GenValidity instances";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/genvalidity-path.nix b/pkgs/genvalidity-path.nix
index 2a2d6edb508a97a72c7186c644eaf85b9f426bfe..cd7649db941bafdc7eaee3774d9b5b8571e24c24 100644
--- a/pkgs/genvalidity-path.nix
+++ b/pkgs/genvalidity-path.nix
@@ -1,22 +1,47 @@
-{ mkDerivation, base, criterion, genvalidity, genvalidity-criterion
-, genvalidity-hspec, hspec, lib, path, QuickCheck, validity-path
+{ mkDerivation
+, base
+, criterion
+, genvalidity
+, genvalidity-criterion
+, genvalidity-hspec
+, hspec
+, lib
+, path
+, QuickCheck
+, validity-path
 }:
 mkDerivation {
   pname = "genvalidity-path";
   version = "1.0.0.1";
   sha256 = "3fb4081a0f578a5cf00564bab49013784f8b4395ef2c4e005960772475924ee5";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base genvalidity path QuickCheck validity-path
+    base
+    genvalidity
+    path
+    QuickCheck
+    validity-path
   ];
   testHaskellDepends = [ base genvalidity-hspec hspec path ];
   benchmarkHaskellDepends = [
-    base criterion genvalidity genvalidity-criterion path QuickCheck
+    base
+    criterion
+    genvalidity
+    genvalidity-criterion
+    path
+    QuickCheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for Path";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-persistent.nix b/pkgs/genvalidity-persistent.nix
index bc89e28b929269d5ceb3fb873144edf5a4ffe18e..e5933812067d69f30325d5452b955d7b6fc3709e 100644
--- a/pkgs/genvalidity-persistent.nix
+++ b/pkgs/genvalidity-persistent.nix
@@ -1,29 +1,65 @@
-{ mkDerivation, base, containers, criterion, deepseq, genvalidity
-, genvalidity-containers, genvalidity-criterion, genvalidity-hspec
-, hspec, lib, persistent, persistent-template, QuickCheck
-, validity-containers, validity-persistent
+{ mkDerivation
+, base
+, containers
+, criterion
+, deepseq
+, genvalidity
+, genvalidity-containers
+, genvalidity-criterion
+, genvalidity-hspec
+, hspec
+, lib
+, persistent
+, persistent-template
+, QuickCheck
+, validity-containers
+, validity-persistent
 }:
 mkDerivation {
   pname = "genvalidity-persistent";
   version = "1.0.0.1";
   sha256 = "5982eb6b9b9d5e31287d6de76a5fb25d3721a3274cde107dfd19ccb214a571c0";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers genvalidity genvalidity-containers persistent
-    QuickCheck validity-containers validity-persistent
+    base
+    containers
+    genvalidity
+    genvalidity-containers
+    persistent
+    QuickCheck
+    validity-containers
+    validity-persistent
   ];
   testHaskellDepends = [
-    base genvalidity genvalidity-hspec hspec persistent
-    persistent-template QuickCheck validity-containers
+    base
+    genvalidity
+    genvalidity-hspec
+    hspec
+    persistent
+    persistent-template
+    QuickCheck
+    validity-containers
   ];
   benchmarkHaskellDepends = [
-    base criterion deepseq genvalidity genvalidity-criterion persistent
+    base
+    criterion
+    deepseq
+    genvalidity
+    genvalidity-criterion
+    persistent
     persistent-template
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for Persistent";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-property.nix b/pkgs/genvalidity-property.nix
index 60e451008f8d91eebd7fcaf158f7bf20a6b41638..9eb8b34b202d57bb00f8b5440343df1063924311 100644
--- a/pkgs/genvalidity-property.nix
+++ b/pkgs/genvalidity-property.nix
@@ -1,19 +1,37 @@
-{ mkDerivation, base, genvalidity, hspec, lib, pretty-show
-, QuickCheck, validity
+{ mkDerivation
+, base
+, genvalidity
+, hspec
+, lib
+, pretty-show
+, QuickCheck
+, validity
 }:
 mkDerivation {
   pname = "genvalidity-property";
   version = "1.0.0.0";
   sha256 = "9c5e385ac5dd5b554d8ff07422261248178bcee8f226b2c7ca93cd4c006eacdb";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base genvalidity hspec pretty-show QuickCheck validity
+    base
+    genvalidity
+    hspec
+    pretty-show
+    QuickCheck
+    validity
   ];
   testHaskellDepends = [ base genvalidity hspec QuickCheck ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Standard properties for functions on `Validity` types";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-scientific.nix b/pkgs/genvalidity-scientific.nix
index 9bb4f8ada0d015fc9917f1be8d68472201190715..c8a62fa7ec56214ef64ce85a7680dc9eff44525f 100644
--- a/pkgs/genvalidity-scientific.nix
+++ b/pkgs/genvalidity-scientific.nix
@@ -13,6 +13,9 @@ mkDerivation {
   pname = "genvalidity-scientific";
   version = "1.0.0.0";
   sha256 = "b85e13c3f54ed955f6d568503d9cda49162f3a4af7560acac62df8a565502176";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     genvalidity
@@ -29,11 +32,15 @@ mkDerivation {
     QuickCheck
     scientific
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for Scientific";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/genvalidity-sydtest-aeson.nix b/pkgs/genvalidity-sydtest-aeson.nix
index fe539e05a08aca29168a4c6500656cbf1dd9b07f..f4f64dad8e400b9bfa87f7ee3a02ce6e619f1422 100644
--- a/pkgs/genvalidity-sydtest-aeson.nix
+++ b/pkgs/genvalidity-sydtest-aeson.nix
@@ -18,6 +18,9 @@ mkDerivation {
   pname = "genvalidity-sydtest-aeson";
   version = "1.0.0.0";
   sha256 = "02ecfc0ecabc6310018ce8ecca220d6388367294c4a1e6b2bbfc9d5de00116d9";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     base
@@ -41,11 +44,15 @@ mkDerivation {
     validity
   ];
   testToolDepends = [ sydtest-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://cs-syd.eu";
   description = "Standard spec's for aeson-related instances in sydtest";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/genvalidity-sydtest-hashable.nix b/pkgs/genvalidity-sydtest-hashable.nix
index 3c3c0fe320eaa55bd1db5a5e268c6656504a70b3..f86dc39a5fdfb4a9f8a4bb861f2e36a8b9b841eb 100644
--- a/pkgs/genvalidity-sydtest-hashable.nix
+++ b/pkgs/genvalidity-sydtest-hashable.nix
@@ -1,24 +1,49 @@
-{ mkDerivation, base, genvalidity, genvalidity-sydtest, hashable
-, lib, QuickCheck, sydtest, sydtest-discover, validity
+{ mkDerivation
+, base
+, genvalidity
+, genvalidity-sydtest
+, hashable
+, lib
+, QuickCheck
+, sydtest
+, sydtest-discover
+, validity
 }:
 mkDerivation {
   pname = "genvalidity-sydtest-hashable";
   version = "1.0.0.0";
   sha256 = "5f4442eb5902c86d72b8340152069d3c3cdb768d8eee0d81e469a650ad178814";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base genvalidity genvalidity-sydtest hashable QuickCheck sydtest
+    base
+    genvalidity
+    genvalidity-sydtest
+    hashable
+    QuickCheck
+    sydtest
     validity
   ];
   testHaskellDepends = [
-    base genvalidity genvalidity-sydtest hashable QuickCheck sydtest
+    base
+    genvalidity
+    genvalidity-sydtest
+    hashable
+    QuickCheck
+    sydtest
     validity
   ];
   testToolDepends = [ sydtest-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Standard spec's for Hashable instances for sydtest";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-sydtest-lens.nix b/pkgs/genvalidity-sydtest-lens.nix
index 811fb30a5567155807877dfb26a397aaab56f947..533e6407dc8b60d01255052bd97b4fa15840e0bb 100644
--- a/pkgs/genvalidity-sydtest-lens.nix
+++ b/pkgs/genvalidity-sydtest-lens.nix
@@ -1,22 +1,47 @@
-{ mkDerivation, base, genvalidity, genvalidity-sydtest, lib
-, microlens, QuickCheck, sydtest, sydtest-discover, validity
+{ mkDerivation
+, base
+, genvalidity
+, genvalidity-sydtest
+, lib
+, microlens
+, QuickCheck
+, sydtest
+, sydtest-discover
+, validity
 }:
 mkDerivation {
   pname = "genvalidity-sydtest-lens";
   version = "1.0.0.0";
   sha256 = "a9ca038b9a7bed8d6df36cf8c1b395ef031ae60f0fd1088dc7ab22b7a05f6f7b";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base genvalidity genvalidity-sydtest microlens QuickCheck sydtest
+    base
+    genvalidity
+    genvalidity-sydtest
+    microlens
+    QuickCheck
+    sydtest
   ];
   testHaskellDepends = [
-    base genvalidity genvalidity-sydtest microlens sydtest validity
+    base
+    genvalidity
+    genvalidity-sydtest
+    microlens
+    sydtest
+    validity
   ];
   testToolDepends = [ sydtest-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://cs-syd.eu";
   description = "Standard spec's for lens for sydtest";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-sydtest-persistent.nix b/pkgs/genvalidity-sydtest-persistent.nix
index 8461748c62ac14e07f54666e7ce915a96984da26..2d0eddf4aa2170b779e3e362b65f7f6ce5ff8d73 100644
--- a/pkgs/genvalidity-sydtest-persistent.nix
+++ b/pkgs/genvalidity-sydtest-persistent.nix
@@ -1,25 +1,53 @@
-{ mkDerivation, base, genvalidity, genvalidity-sydtest
-, genvalidity-text, lib, persistent, QuickCheck, sydtest
-, sydtest-discover, text, validity
+{ mkDerivation
+, base
+, genvalidity
+, genvalidity-sydtest
+, genvalidity-text
+, lib
+, persistent
+, QuickCheck
+, sydtest
+, sydtest-discover
+, text
+, validity
 }:
 mkDerivation {
   pname = "genvalidity-sydtest-persistent";
   version = "1.0.0.0";
   sha256 = "d73bae6746156e37ac1f518e8f7aef31a8e5fe2bbc5d7cfbdf39ced313e552da";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base genvalidity genvalidity-sydtest persistent QuickCheck sydtest
+    base
+    genvalidity
+    genvalidity-sydtest
+    persistent
+    QuickCheck
+    sydtest
     text
   ];
   testHaskellDepends = [
-    base genvalidity genvalidity-sydtest genvalidity-text persistent
-    QuickCheck sydtest text validity
+    base
+    genvalidity
+    genvalidity-sydtest
+    genvalidity-text
+    persistent
+    QuickCheck
+    sydtest
+    text
+    validity
   ];
   testToolDepends = [ sydtest-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://cs-syd.eu";
   description = "Standard spec's for persistent-related instances for sydtest";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-sydtest.nix b/pkgs/genvalidity-sydtest.nix
index f63c094e151a298977561e4beb69aee093eb27f1..da713d8186e913a2821410d8564a7e311b610216 100644
--- a/pkgs/genvalidity-sydtest.nix
+++ b/pkgs/genvalidity-sydtest.nix
@@ -1,20 +1,39 @@
-{ mkDerivation, base, genvalidity, lib, pretty-show, QuickCheck
-, sydtest, sydtest-discover, validity
+{ mkDerivation
+, base
+, genvalidity
+, lib
+, pretty-show
+, QuickCheck
+, sydtest
+, sydtest-discover
+, validity
 }:
 mkDerivation {
   pname = "genvalidity-sydtest";
   version = "1.0.0.0";
   sha256 = "8550737541526c8f51b29b70aa5b45ef33eb41b5e7ef29c97ad1b1ac91366687";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base genvalidity pretty-show QuickCheck sydtest validity
+    base
+    genvalidity
+    pretty-show
+    QuickCheck
+    sydtest
+    validity
   ];
   testHaskellDepends = [ base genvalidity QuickCheck sydtest ];
   testToolDepends = [ sydtest-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Standard properties for functions on `Validity` types for the sydtest framework";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-text.nix b/pkgs/genvalidity-text.nix
index 5e420052dba0ed93b9cfa0f6e6274b2a8b4cca2d..adad4b1ae7f7837c18a6bd2227cc3e3eb71747c2 100644
--- a/pkgs/genvalidity-text.nix
+++ b/pkgs/genvalidity-text.nix
@@ -17,6 +17,9 @@ mkDerivation {
   pname = "genvalidity-text";
   version = "1.0.0.1";
   sha256 = "96e19453e45d76cb89794801588a6d9726c5092fef5cd053e7abe4322f553be3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -43,11 +46,15 @@ mkDerivation {
     QuickCheck
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for Text";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/genvalidity-time.nix b/pkgs/genvalidity-time.nix
index 97f7fe1d04c2b31c38f3b81b0033d4415aea7494..93a6f1112169a45e91becc23bc01906134cf3e78 100644
--- a/pkgs/genvalidity-time.nix
+++ b/pkgs/genvalidity-time.nix
@@ -1,22 +1,45 @@
-{ mkDerivation, base, criterion, genvalidity, genvalidity-criterion
-, genvalidity-hspec, hspec, lib, QuickCheck, time, validity-time
+{ mkDerivation
+, base
+, criterion
+, genvalidity
+, genvalidity-criterion
+, genvalidity-hspec
+, hspec
+, lib
+, QuickCheck
+, time
+, validity-time
 }:
 mkDerivation {
   pname = "genvalidity-time";
   version = "1.0.0.1";
   sha256 = "867c5a77aa2750e6b574f63b5bc23e037d8e0e393d627df49df46497d9346c94";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base genvalidity QuickCheck time validity-time
+    base
+    genvalidity
+    QuickCheck
+    time
+    validity-time
   ];
   testHaskellDepends = [ base genvalidity-hspec hspec time ];
   benchmarkHaskellDepends = [
-    base criterion genvalidity-criterion time
+    base
+    criterion
+    genvalidity-criterion
+    time
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for time";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-unordered-containers.nix b/pkgs/genvalidity-unordered-containers.nix
index 1875a45e015a0a345090a6053549d5bfaaac1efd..3bfcfde1a9764ccc6ac8655c1651b6e6f6ef132d 100644
--- a/pkgs/genvalidity-unordered-containers.nix
+++ b/pkgs/genvalidity-unordered-containers.nix
@@ -14,6 +14,9 @@ mkDerivation {
   pname = "genvalidity-unordered-containers";
   version = "1.0.0.0";
   sha256 = "b325c19594853133b62019ad35ed86616b92ac1afd18a5f49a801e3e453fa6e9";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     genvalidity
@@ -31,11 +34,15 @@ mkDerivation {
     unordered-containers
     validity
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for unordered-containers";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/genvalidity-uuid.nix b/pkgs/genvalidity-uuid.nix
index b2a62cee709acbd47ceea85b572f0341c12944df..85bc88b56375b4206b01a231371ca3d85640b837 100644
--- a/pkgs/genvalidity-uuid.nix
+++ b/pkgs/genvalidity-uuid.nix
@@ -1,25 +1,56 @@
-{ mkDerivation, base, criterion, genvalidity, genvalidity-criterion
-, genvalidity-hspec, hspec, lib, QuickCheck, uuid, validity
+{ mkDerivation
+, base
+, criterion
+, genvalidity
+, genvalidity-criterion
+, genvalidity-hspec
+, hspec
+, lib
+, QuickCheck
+, uuid
+, validity
 , validity-uuid
 }:
 mkDerivation {
   pname = "genvalidity-uuid";
   version = "1.0.0.1";
   sha256 = "b3348b59221f8c39ce5e6e5b4e390216304dae6c43bee9339424efd5f075d696";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base genvalidity QuickCheck uuid validity validity-uuid
+    base
+    genvalidity
+    QuickCheck
+    uuid
+    validity
+    validity-uuid
   ];
   testHaskellDepends = [
-    base genvalidity genvalidity-hspec hspec QuickCheck uuid
+    base
+    genvalidity
+    genvalidity-hspec
+    hspec
+    QuickCheck
+    uuid
   ];
   benchmarkHaskellDepends = [
-    base criterion genvalidity genvalidity-criterion QuickCheck uuid
+    base
+    criterion
+    genvalidity
+    genvalidity-criterion
+    QuickCheck
+    uuid
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for UUID";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/genvalidity-vector.nix b/pkgs/genvalidity-vector.nix
index 7d244fd64a86e5d2825ae9eccf8f1d0e427132fc..cc91d8418ed042fda262928dcf487900383a71c0 100644
--- a/pkgs/genvalidity-vector.nix
+++ b/pkgs/genvalidity-vector.nix
@@ -13,6 +13,9 @@ mkDerivation {
   pname = "genvalidity-vector";
   version = "1.0.0.0";
   sha256 = "fe0dd139da3cafe4a4e05ed19e3efb46743f92743f95615fefbd8027dd925fd0";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     genvalidity
@@ -28,11 +31,15 @@ mkDerivation {
     hspec
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "GenValidity support for vector";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/genvalidity.nix b/pkgs/genvalidity.nix
index bfae45e1c887a9da83596b6993f6723e77bcc6cb..cb902df2bfc5d9f74d62a6927054c18d8200e7b8 100644
--- a/pkgs/genvalidity.nix
+++ b/pkgs/genvalidity.nix
@@ -1,17 +1,30 @@
-{ mkDerivation, base, hspec, hspec-core, lib, QuickCheck, random
+{ mkDerivation
+, base
+, hspec
+, hspec-core
+, lib
+, QuickCheck
+, random
 , validity
 }:
 mkDerivation {
   pname = "genvalidity";
   version = "1.1.0.0";
   sha256 = "5897d7640a93ad6cd12177375009cad5189ba147edff80ded0c2a508ff5bbb23";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base QuickCheck random validity ];
   testHaskellDepends = [ base hspec hspec-core QuickCheck ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Testing utilities for the validity library";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/ghc-byteorder.nix b/pkgs/ghc-byteorder.nix
index aca29e0ce3a8ed0119e0fc772713ab538d180198..e12f0f29f740f8f3ed9ac2df67d5822d7e87f01c 100644
--- a/pkgs/ghc-byteorder.nix
+++ b/pkgs/ghc-byteorder.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "86e50a89798181db4f44ec3848fc52940c73098e88549a351ceb54fefc691fb6";
   revision = "3";
   editedCabalFile = "088rz5c0pq2r1w3msy0y9hl4gca8s8nblpcz7w2f5sx5pajg8flj";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   testHaskellDepends = [ base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "\"GHC.ByteOrder\" API Compatibility Layer";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/ghc-check.nix b/pkgs/ghc-check.nix
index f7afb738049e4de11d36d2a41228c669fc6c50da..be11524313056e5f2e8bb27f50baa5e77d2726ea 100644
--- a/pkgs/ghc-check.nix
+++ b/pkgs/ghc-check.nix
@@ -17,6 +17,9 @@ mkDerivation {
   pname = "ghc-check";
   version = "0.5.0.8";
   sha256 = "1025a8353fb7c318b27b8dc6b268d22f1f64c271031ed0ce4defb0f9100d7cd4";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
@@ -31,10 +34,14 @@ mkDerivation {
     th-compat
     transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "detect mismatches between compile-time and run-time versions of the ghc api";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/ghc-exactprint.nix b/pkgs/ghc-exactprint.nix
index 7628f6187035fc002f2a2d7b49defb69ace8807c..43030830b979bcc88cb9c563b5c059fa771307e1 100644
--- a/pkgs/ghc-exactprint.nix
+++ b/pkgs/ghc-exactprint.nix
@@ -26,6 +26,7 @@ mkDerivation {
   sha256 = "8eb59736bbf052a380d5c72277abad05802730b37629ea67a4517b2d88dd40fa";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -61,10 +62,14 @@ mkDerivation {
     silently
     syb
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "ExactPrint for GHC";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/ghc-lib-parser-ex.nix b/pkgs/ghc-lib-parser-ex.nix
index e715402f5ad0b3dd534defc453b216f741d3b87e..285bc7e4cc7da6b6c51aa57e7566b601393eada8 100644
--- a/pkgs/ghc-lib-parser-ex.nix
+++ b/pkgs/ghc-lib-parser-ex.nix
@@ -15,6 +15,9 @@ mkDerivation {
   pname = "ghc-lib-parser-ex";
   version = "9.4.0.0";
   sha256 = "ce3ff339a0a259a18ae921c547b35732eaca1a567a33fba1a7c65c16c973191b";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -32,11 +35,15 @@ mkDerivation {
     tasty-hunit
     uniplate
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/shayne-fletcher/ghc-lib-parser-ex#readme";
   description = "Algorithms on GHC parse trees";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/ghc-lib-parser.nix b/pkgs/ghc-lib-parser.nix
index 795e8fcf224fd57d1577d442afa0e0ecb2004344..57328be4cc69755baf6ebc7f6fefe65eea92c19c 100644
--- a/pkgs/ghc-lib-parser.nix
+++ b/pkgs/ghc-lib-parser.nix
@@ -23,6 +23,8 @@ mkDerivation {
   pname = "ghc-lib-parser";
   version = "9.4.2.20220822";
   sha256 = "3eb1fd79734728fffb39c98a4a42747d0db2d35380fec8ab24bbea5d76b93847";
+  isLibrary = true;
+  isExecutable = false;
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
     array
@@ -43,11 +45,15 @@ mkDerivation {
     unix
   ];
   libraryToolDepends = [ alex happy ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/digital-asset/ghc-lib";
   description = "The GHC API, decoupled from GHC versions";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/ghc-paths.nix b/pkgs/ghc-paths.nix
index 27e88a00d73caf247e28fe98bcf377a566bdb5f5..8d1e0013de998c79c3428b1180e6308b851e9f26 100644
--- a/pkgs/ghc-paths.nix
+++ b/pkgs/ghc-paths.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "6ecbe676d073cb07989c61ce4c5709c4e67cbefdd2d55a4095f9388b6fe2c484";
   revision = "4";
   editedCabalFile = "1d5za4k498q48wk6cz0jm3d68rh5ldz6adr8vp24nn7jv17g770w";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ base Cabal directory ];
   libraryHaskellDepends = [ base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Knowledge of GHC's installation directories";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/ghc-tcplugins-extra.nix b/pkgs/ghc-tcplugins-extra.nix
index 63eb1593c87b40984894d085298abcf6560a23b7..c9db96f5a01a4b9ec8dfef033824d86c2cc1c717 100644
--- a/pkgs/ghc-tcplugins-extra.nix
+++ b/pkgs/ghc-tcplugins-extra.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "ghc-tcplugins-extra";
   version = "0.4.3";
   sha256 = "e985cda6fc983f703c3ae319e62e1253e25422785ec11992cb3faaaad67480a1";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ghc ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/clash-lang/ghc-tcplugins-extra#readme";
   description = "Utilities for writing GHC type-checker plugins";
   license = lib.licenses.bsd2;
+  broken = false;
 }
diff --git a/pkgs/ghc-typelits-knownnat.nix b/pkgs/ghc-typelits-knownnat.nix
index c9066d12fa5cb24196c15c66e69915b9805ad64d..fe66f6f408e60cc452549229e7dc5826af8ffa7f 100644
--- a/pkgs/ghc-typelits-knownnat.nix
+++ b/pkgs/ghc-typelits-knownnat.nix
@@ -1,23 +1,48 @@
-{ mkDerivation, base, ghc, ghc-prim, ghc-tcplugins-extra
-, ghc-typelits-natnormalise, lib, tasty, tasty-hunit
-, tasty-quickcheck, template-haskell, transformers
+{ mkDerivation
+, base
+, ghc
+, ghc-prim
+, ghc-tcplugins-extra
+, ghc-typelits-natnormalise
+, lib
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, template-haskell
+, transformers
 }:
 mkDerivation {
   pname = "ghc-typelits-knownnat";
   version = "0.7.7";
   sha256 = "c79018557e88cd1b3937d15d9fb75c4cc7e6b44856ad53b15ae4c421a385f92c";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base ghc ghc-prim ghc-tcplugins-extra ghc-typelits-natnormalise
-    template-haskell transformers
+    base
+    ghc
+    ghc-prim
+    ghc-tcplugins-extra
+    ghc-typelits-natnormalise
+    template-haskell
+    transformers
   ];
   testHaskellDepends = [
-    base ghc-typelits-natnormalise tasty tasty-hunit tasty-quickcheck
+    base
+    ghc-typelits-natnormalise
+    tasty
+    tasty-hunit
+    tasty-quickcheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://clash-lang.org/";
   description = "Derive KnownNat constraints from other KnownNat constraints";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/ghc-typelits-natnormalise.nix b/pkgs/ghc-typelits-natnormalise.nix
index 995febea01f08e2e705368d7d1b92e3714c85825..96038d38bbd73a43a745e0ff35f150d2935c5bdf 100644
--- a/pkgs/ghc-typelits-natnormalise.nix
+++ b/pkgs/ghc-typelits-natnormalise.nix
@@ -1,22 +1,47 @@
-{ mkDerivation, base, containers, ghc, ghc-bignum, ghc-prim
-, ghc-tcplugins-extra, lib, tasty, tasty-hunit, template-haskell
+{ mkDerivation
+, base
+, containers
+, ghc
+, ghc-bignum
+, ghc-prim
+, ghc-tcplugins-extra
+, lib
+, tasty
+, tasty-hunit
+, template-haskell
 , transformers
 }:
 mkDerivation {
   pname = "ghc-typelits-natnormalise";
   version = "0.7.7";
   sha256 = "90ea374a1d58c1cd6cd3fb156f99873aae90bfb419279ca178372f2287d7175f";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers ghc ghc-bignum ghc-tcplugins-extra transformers
+    base
+    containers
+    ghc
+    ghc-bignum
+    ghc-tcplugins-extra
+    transformers
   ];
   testHaskellDepends = [
-    base ghc-prim tasty tasty-hunit template-haskell
+    base
+    ghc-prim
+    tasty
+    tasty-hunit
+    template-haskell
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://www.clash-lang.org/";
   description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/ghcid.nix b/pkgs/ghcid.nix
index fbb1bf01671a12f6691afa1efd01579aa6f958e0..3c9b6425b6a4280323e34ea9d7fde1fd75df231b 100644
--- a/pkgs/ghcid.nix
+++ b/pkgs/ghcid.nix
@@ -1,6 +1,19 @@
-{ mkDerivation, ansi-terminal, base, cmdargs, containers, directory
-, extra, filepath, fsnotify, lib, process, tasty, tasty-hunit
-, terminal-size, time, unix
+{ mkDerivation
+, ansi-terminal
+, base
+, cmdargs
+, containers
+, directory
+, extra
+, filepath
+, fsnotify
+, lib
+, process
+, tasty
+, tasty-hunit
+, terminal-size
+, time
+, unix
 }:
 mkDerivation {
   pname = "ghcid";
@@ -8,23 +21,57 @@ mkDerivation {
   sha256 = "92c96e439dd1e0b760181d17ac2ff84f96d0d4871c2f03296a3278095ec858f8";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    ansi-terminal base cmdargs directory extra filepath process time
+    ansi-terminal
+    base
+    cmdargs
+    directory
+    extra
+    filepath
+    process
+    time
   ];
   executableHaskellDepends = [
-    ansi-terminal base cmdargs containers directory extra filepath
-    fsnotify process terminal-size time unix
+    ansi-terminal
+    base
+    cmdargs
+    containers
+    directory
+    extra
+    filepath
+    fsnotify
+    process
+    terminal-size
+    time
+    unix
   ];
   testHaskellDepends = [
-    ansi-terminal base cmdargs containers directory extra filepath
-    fsnotify process tasty tasty-hunit terminal-size time unix
+    ansi-terminal
+    base
+    cmdargs
+    containers
+    directory
+    extra
+    filepath
+    fsnotify
+    process
+    tasty
+    tasty-hunit
+    terminal-size
+    time
+    unix
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/ndmitchell/ghcid#readme";
   description = "GHCi based bare bones IDE";
   license = lib.licenses.bsd3;
   mainProgram = "ghcid";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/hackage-security.nix b/pkgs/hackage-security.nix
index 967f1f018aede1cb57eddc529a4769efa7042077..99733fcc25a803d873be44cb8a9ba666db4de8e8 100644
--- a/pkgs/hackage-security.nix
+++ b/pkgs/hackage-security.nix
@@ -39,6 +39,9 @@ mkDerivation {
   sha256 = "a833a31610220506557e96fb6e3e8b05a2e1db8e7ebc06e91bbb699ddde0b276";
   revision = "1";
   editedCabalFile = "01fhp3kzc1wfvixzgnz4y52bzm4sickk1cj7pksrwmbi90dghv0s";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     base16-bytestring
@@ -84,11 +87,15 @@ mkDerivation {
     vector
     zlib
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell/hackage-security";
   description = "Hackage security library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/haddock-library.nix b/pkgs/haddock-library.nix
index 03bb077e1ab97108e9cc657b113700a1af0f36ff..3af3edf426f86500f46e05559406e0e18851ced0 100644
--- a/pkgs/haddock-library.nix
+++ b/pkgs/haddock-library.nix
@@ -1,6 +1,18 @@
-{ mkDerivation, base, base-compat, containers, deepseq, directory
-, filepath, hspec, hspec-discover, lib, optparse-applicative
-, parsec, QuickCheck, text, tree-diff
+{ mkDerivation
+, base
+, base-compat
+, containers
+, deepseq
+, directory
+, filepath
+, hspec
+, hspec-discover
+, lib
+, optparse-applicative
+, parsec
+, QuickCheck
+, text
+, tree-diff
 }:
 mkDerivation {
   pname = "haddock-library";
@@ -8,17 +20,34 @@ mkDerivation {
   sha256 = "7c075ec9a378b0a2d9d605e72135201e6c7ff316564f2c974113582f43bea20a";
   revision = "1";
   editedCabalFile = "0mqwr0vbpj9zw7f1p5kdd7hsr76gs1ijmh8h9hak47nphffi1fxv";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base containers parsec text ];
   testHaskellDepends = [
-    base base-compat containers deepseq directory filepath hspec
-    optparse-applicative parsec QuickCheck text tree-diff
+    base
+    base-compat
+    containers
+    deepseq
+    directory
+    filepath
+    hspec
+    optparse-applicative
+    parsec
+    QuickCheck
+    text
+    tree-diff
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://www.haskell.org/haddock/";
   description = "Library exposing some functionality of Haddock";
   license = lib.licenses.bsd2;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/hashable.nix b/pkgs/hashable.nix
index 70854eb4cba9e6ed15d36e6e577a89844bbb619c..72fcb78582499f1fc6876067d9bb25b08a0344d6 100644
--- a/pkgs/hashable.nix
+++ b/pkgs/hashable.nix
@@ -19,6 +19,9 @@ mkDerivation {
   pname = "hashable";
   version = "1.4.1.0";
   sha256 = "e1b305c280e66ad827edeaedd6933b9fc4174f626882877eab2a08344e665e87";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -41,11 +44,15 @@ mkDerivation {
     text
     unix
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/haskell-unordered-containers/hashable";
   description = "A class for types that can be converted to a hash value";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/hashing.nix b/pkgs/hashing.nix
index c041019fac3d593e1cf7f4fe69ee389afb3c9b4b..9509958fe1f82a2347207bb80f5118d55e832d9f 100644
--- a/pkgs/hashing.nix
+++ b/pkgs/hashing.nix
@@ -16,6 +16,7 @@ mkDerivation {
   editedCabalFile = "1rwl68jiivw7f2f5cg73sr3dawlbmklnwyiwivrcsihrg4b1z1lq";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ array base bytestring ];
   executableHaskellDepends = [
     array
@@ -33,12 +34,16 @@ mkDerivation {
     QuickCheck
     template-haskell
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/wangbj/hashing";
   description = "A pure haskell library implements several hash algorithms";
   license = lib.licenses.mit;
   mainProgram = "hashing-exe";
+  broken = false;
 }
diff --git a/pkgs/hashtables.nix b/pkgs/hashtables.nix
index c40b0c141a2772dbf11a846c1d8313d7ae400001..7d32e9c746cca87114f0de127e8b1ed4f50ce12b 100644
--- a/pkgs/hashtables.nix
+++ b/pkgs/hashtables.nix
@@ -16,6 +16,9 @@ mkDerivation {
   pname = "hashtables";
   version = "1.3";
   sha256 = "af785a6d13842ebbd804b0ec174dd957a2591b224434e3ce883f537321f90dd3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     ghc-prim
@@ -36,11 +39,15 @@ mkDerivation {
     test-framework-quickcheck2
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/gregorycollins/hashtables";
   description = "Mutable hash tables in the ST monad";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/haskell-src-meta.nix b/pkgs/haskell-src-meta.nix
index 2744558e3cc83d679b665947fe64797500953230..050abdea0ff54b27e65e4d4f41b819191a325754 100644
--- a/pkgs/haskell-src-meta.nix
+++ b/pkgs/haskell-src-meta.nix
@@ -15,6 +15,9 @@ mkDerivation {
   pname = "haskell-src-meta";
   version = "0.8.11";
   sha256 = "3ca7fb27deceb3116682c24d9c122dc4c328a7566c39076c924f407556077af2";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     haskell-src-exts
@@ -34,10 +37,14 @@ mkDerivation {
     tasty-hunit
     template-haskell
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Parse source to template-haskell abstract syntax";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/hedgehog-golden.nix b/pkgs/hedgehog-golden.nix
index 589cb605e922fef2484df1463a189b407d22462d..950d0db1857121e75615372bfbf1528d8a192475 100644
--- a/pkgs/hedgehog-golden.nix
+++ b/pkgs/hedgehog-golden.nix
@@ -22,6 +22,8 @@ mkDerivation {
     rev = "4ab2906b3f0be5e31ee5a8585e45d43392694246";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
     aeson
@@ -36,11 +38,15 @@ mkDerivation {
     text
   ];
   testHaskellDepends = [ aeson base hedgehog with-utf8 ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/felixmulder/hedgehog-golden";
   description = "Golden testing capabilities for hedgehog using Aeson";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/hedgehog.nix b/pkgs/hedgehog.nix
index 50df676ac179ec2abf9a81dfb57fbb91679fb860..63ffaa332ad47d327d8dbbb5bdd5b4d480429b24 100644
--- a/pkgs/hedgehog.nix
+++ b/pkgs/hedgehog.nix
@@ -31,6 +31,9 @@ mkDerivation {
   pname = "hedgehog";
   version = "1.2";
   sha256 = "2859c7daa665250bb249614da7b55507c6315d9b80e456f1a74f33abfeaf8e7e";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     ansi-terminal
     async
@@ -68,11 +71,15 @@ mkDerivation {
     text
     transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://hedgehog.qa";
   description = "Release with confidence";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/hie-bios.nix b/pkgs/hie-bios.nix
index 91a015e70595d98c3d344134c95ecd034be9491b..dbf747ef24320bac00b16863a54b9a6854f778d7 100644
--- a/pkgs/hie-bios.nix
+++ b/pkgs/hie-bios.nix
@@ -1,9 +1,36 @@
-{ mkDerivation, aeson, base, base16-bytestring, bytestring
-, co-log-core, conduit, conduit-extra, containers, cryptohash-sha1
-, deepseq, directory, exceptions, extra, file-embed, filepath, ghc
-, lib, optparse-applicative, prettyprinter, process, tagged, tasty
-, tasty-expected-failure, tasty-hunit, temporary, text, time
-, transformers, unix-compat, unordered-containers, vector, yaml
+{ mkDerivation
+, aeson
+, base
+, base16-bytestring
+, bytestring
+, co-log-core
+, conduit
+, conduit-extra
+, containers
+, cryptohash-sha1
+, deepseq
+, directory
+, exceptions
+, extra
+, file-embed
+, filepath
+, ghc
+, lib
+, optparse-applicative
+, prettyprinter
+, process
+, tagged
+, tasty
+, tasty-expected-failure
+, tasty-hunit
+, temporary
+, text
+, time
+, transformers
+, unix-compat
+, unordered-containers
+, vector
+, yaml
 }:
 mkDerivation {
   pname = "hie-bios";
@@ -11,28 +38,71 @@ mkDerivation {
   sha256 = "9708bf4309e904771bf590dd4e683e0b5c18e486ed499be8ceff5119a25f0eef";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base base16-bytestring bytestring co-log-core conduit
-    conduit-extra containers cryptohash-sha1 deepseq directory
-    exceptions extra file-embed filepath ghc prettyprinter process
-    temporary text time transformers unix-compat unordered-containers
-    vector yaml
+    aeson
+    base
+    base16-bytestring
+    bytestring
+    co-log-core
+    conduit
+    conduit-extra
+    containers
+    cryptohash-sha1
+    deepseq
+    directory
+    exceptions
+    extra
+    file-embed
+    filepath
+    ghc
+    prettyprinter
+    process
+    temporary
+    text
+    time
+    transformers
+    unix-compat
+    unordered-containers
+    vector
+    yaml
   ];
   executableHaskellDepends = [
-    base co-log-core directory filepath ghc optparse-applicative
+    base
+    co-log-core
+    directory
+    filepath
+    ghc
+    optparse-applicative
     prettyprinter
   ];
   testHaskellDepends = [
-    aeson base directory extra filepath ghc tagged tasty
-    tasty-expected-failure tasty-hunit temporary text transformers
-    unordered-containers yaml
+    aeson
+    base
+    directory
+    extra
+    filepath
+    ghc
+    tagged
+    tasty
+    tasty-expected-failure
+    tasty-hunit
+    temporary
+    text
+    transformers
+    unordered-containers
+    yaml
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/mpickering/hie-bios";
   description = "Set up a GHC API session";
   license = lib.licenses.bsd3;
   mainProgram = "hie-bios";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/hie-compat.nix b/pkgs/hie-compat.nix
index 8e207544c31e13d28cbd9d5a9e0282acdadaa3b8..de553f47bff4a818183df05c67382afa05d6d86a 100644
--- a/pkgs/hie-compat.nix
+++ b/pkgs/hie-compat.nix
@@ -14,6 +14,9 @@ mkDerivation {
   pname = "hie-compat";
   version = "0.3.0.0";
   sha256 = "ab02e969106971f7ef980515f802447c579c088b2e227eb8982999605f392199";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -25,11 +28,15 @@ mkDerivation {
     ghc-boot
     transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell/haskell-language-server/tree/master/hie-compat#readme";
   description = "HIE files for GHC 8.6 and other HIE file backports";
   license = lib.licenses.asl20;
+  broken = false;
 }
diff --git a/pkgs/hiedb.nix b/pkgs/hiedb.nix
index 94a285ee46bf5e8f2780398176a1ce409994a2cc..32eee4687037e7a5cadc28809ff018c8e7cf8468 100644
--- a/pkgs/hiedb.nix
+++ b/pkgs/hiedb.nix
@@ -28,6 +28,7 @@ mkDerivation {
   sha256 = "9cca518eaa6a5d747c32ca7f50c7ba3c7454fb96239796bbbd6d2cc7cb61b908";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     algebraic-graphs
     ansi-terminal
@@ -58,11 +59,15 @@ mkDerivation {
     process
     temporary
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Generates a references DB from .hie files";
   license = lib.licenses.bsd3;
   mainProgram = "hiedb";
+  broken = false;
 }
diff --git a/pkgs/hledger-lib.nix b/pkgs/hledger-lib.nix
index 6e072669b9d29846597c7af602fe051e2a6d196c..bd0145b76910c2ebb73f293318b86f645f7f20d8 100644
--- a/pkgs/hledger-lib.nix
+++ b/pkgs/hledger-lib.nix
@@ -1,39 +1,154 @@
-{ mkDerivation, aeson, aeson-pretty, ansi-terminal, array, base
-, blaze-markup, breakpoint, bytestring, call-stack, cassava
-, cassava-megaparsec, cmdargs, containers, data-default, Decimal
-, deepseq, directory, doclayout, doctest, extra, file-embed
-, filepath, Glob, hashtables, lib, megaparsec, microlens
-, microlens-th, mtl, parser-combinators, pretty-simple, regex-tdfa
-, safe, tabular, tasty, tasty-hunit, template-haskell, text, time
-, timeit, transformers, uglymemo, unordered-containers, utf8-string
+{ mkDerivation
+, aeson
+, aeson-pretty
+, ansi-terminal
+, array
+, base
+, blaze-markup
+, breakpoint
+, bytestring
+, call-stack
+, cassava
+, cassava-megaparsec
+, cmdargs
+, containers
+, data-default
+, Decimal
+, deepseq
+, directory
+, doclayout
+, doctest
+, extra
+, file-embed
+, filepath
+, Glob
+, hashtables
+, lib
+, megaparsec
+, microlens
+, microlens-th
+, mtl
+, parser-combinators
+, pretty-simple
+, regex-tdfa
+, safe
+, tabular
+, tasty
+, tasty-hunit
+, template-haskell
+, text
+, time
+, timeit
+, transformers
+, uglymemo
+, unordered-containers
+, utf8-string
 }:
 mkDerivation {
   pname = "hledger-lib";
   version = "1.27.1";
   sha256 = "0bf2ab283435a3c49b91a2f18e124f7b27d8203a4db6ef8a1df71ae6fcb55270";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson aeson-pretty ansi-terminal array base blaze-markup breakpoint
-    bytestring call-stack cassava cassava-megaparsec cmdargs containers
-    data-default Decimal deepseq directory doclayout extra file-embed
-    filepath Glob hashtables megaparsec microlens microlens-th mtl
-    parser-combinators pretty-simple regex-tdfa safe tabular tasty
-    tasty-hunit template-haskell text time timeit transformers uglymemo
-    unordered-containers utf8-string
+    aeson
+    aeson-pretty
+    ansi-terminal
+    array
+    base
+    blaze-markup
+    breakpoint
+    bytestring
+    call-stack
+    cassava
+    cassava-megaparsec
+    cmdargs
+    containers
+    data-default
+    Decimal
+    deepseq
+    directory
+    doclayout
+    extra
+    file-embed
+    filepath
+    Glob
+    hashtables
+    megaparsec
+    microlens
+    microlens-th
+    mtl
+    parser-combinators
+    pretty-simple
+    regex-tdfa
+    safe
+    tabular
+    tasty
+    tasty-hunit
+    template-haskell
+    text
+    time
+    timeit
+    transformers
+    uglymemo
+    unordered-containers
+    utf8-string
   ];
   testHaskellDepends = [
-    aeson aeson-pretty ansi-terminal array base blaze-markup breakpoint
-    bytestring call-stack cassava cassava-megaparsec cmdargs containers
-    data-default Decimal deepseq directory doclayout doctest extra
-    file-embed filepath Glob hashtables megaparsec microlens
-    microlens-th mtl parser-combinators pretty-simple regex-tdfa safe
-    tabular tasty tasty-hunit template-haskell text time timeit
-    transformers uglymemo unordered-containers utf8-string
+    aeson
+    aeson-pretty
+    ansi-terminal
+    array
+    base
+    blaze-markup
+    breakpoint
+    bytestring
+    call-stack
+    cassava
+    cassava-megaparsec
+    cmdargs
+    containers
+    data-default
+    Decimal
+    deepseq
+    directory
+    doclayout
+    doctest
+    extra
+    file-embed
+    filepath
+    Glob
+    hashtables
+    megaparsec
+    microlens
+    microlens-th
+    mtl
+    parser-combinators
+    pretty-simple
+    regex-tdfa
+    safe
+    tabular
+    tasty
+    tasty-hunit
+    template-haskell
+    text
+    time
+    timeit
+    transformers
+    uglymemo
+    unordered-containers
+    utf8-string
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://hledger.org";
   description = "A reusable library providing the core functionality of hledger";
   license = lib.licenses.gpl3Only;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/hledger.nix b/pkgs/hledger.nix
index f951a7a330a6538752ec98b0e0f56a03dba47871..6d21bf7fa0d8cc1c54265f9278b7f15ffb86e691 100644
--- a/pkgs/hledger.nix
+++ b/pkgs/hledger.nix
@@ -1,10 +1,44 @@
-{ mkDerivation, aeson, ansi-terminal, base, breakpoint, bytestring
-, cmdargs, containers, data-default, Decimal, Diff, directory
-, extra, filepath, githash, hashable, haskeline, hledger-lib, lib
-, lucid, math-functions, megaparsec, microlens, mtl, process
-, regex-tdfa, safe, shakespeare, split, tabular, tasty, temporary
-, terminfo, text, time, timeit, transformers, unordered-containers
-, utf8-string, utility-ht, wizards
+{ mkDerivation
+, aeson
+, ansi-terminal
+, base
+, breakpoint
+, bytestring
+, cmdargs
+, containers
+, data-default
+, Decimal
+, Diff
+, directory
+, extra
+, filepath
+, githash
+, hashable
+, haskeline
+, hledger-lib
+, lib
+, lucid
+, math-functions
+, megaparsec
+, microlens
+, mtl
+, process
+, regex-tdfa
+, safe
+, shakespeare
+, split
+, tabular
+, tasty
+, temporary
+, terminfo
+, text
+, time
+, timeit
+, transformers
+, unordered-containers
+, utf8-string
+, utility-ht
+, wizards
 }:
 mkDerivation {
   pname = "hledger";
@@ -12,36 +46,134 @@ mkDerivation {
   sha256 = "0bb7f637c5dfe0deaf6ea463b68a23fc08c4d581e78a81319e5e687fea41af61";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson ansi-terminal base breakpoint bytestring cmdargs containers
-    data-default Decimal Diff directory extra filepath githash hashable
-    haskeline hledger-lib lucid math-functions megaparsec microlens mtl
-    process regex-tdfa safe shakespeare split tabular tasty temporary
-    terminfo text time timeit transformers unordered-containers
-    utf8-string utility-ht wizards
+    aeson
+    ansi-terminal
+    base
+    breakpoint
+    bytestring
+    cmdargs
+    containers
+    data-default
+    Decimal
+    Diff
+    directory
+    extra
+    filepath
+    githash
+    hashable
+    haskeline
+    hledger-lib
+    lucid
+    math-functions
+    megaparsec
+    microlens
+    mtl
+    process
+    regex-tdfa
+    safe
+    shakespeare
+    split
+    tabular
+    tasty
+    temporary
+    terminfo
+    text
+    time
+    timeit
+    transformers
+    unordered-containers
+    utf8-string
+    utility-ht
+    wizards
   ];
   executableHaskellDepends = [
-    aeson ansi-terminal base breakpoint 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 time timeit transformers unordered-containers utf8-string
-    utility-ht wizards
+    aeson
+    ansi-terminal
+    base
+    breakpoint
+    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
+    time
+    timeit
+    transformers
+    unordered-containers
+    utf8-string
+    utility-ht
+    wizards
   ];
   testHaskellDepends = [
-    aeson ansi-terminal base breakpoint 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 time timeit transformers unordered-containers utf8-string
-    utility-ht wizards
+    aeson
+    ansi-terminal
+    base
+    breakpoint
+    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
+    time
+    timeit
+    transformers
+    unordered-containers
+    utf8-string
+    utility-ht
+    wizards
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://hledger.org";
   description = "Command-line interface for the hledger accounting system";
   license = lib.licenses.gpl3Only;
   mainProgram = "hledger";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/hlint.nix b/pkgs/hlint.nix
index 1f422da015a210a3fa58a3964487b587c26b0f26..fa9c25e3ac1a5024e5c556c0a6a7198731b54795 100644
--- a/pkgs/hlint.nix
+++ b/pkgs/hlint.nix
@@ -63,12 +63,16 @@ mkDerivation {
     yaml
   ];
   executableHaskellDepends = [ base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/ndmitchell/hlint#readme";
   description = "Source code suggestions";
   license = lib.licenses.bsd3;
   mainProgram = "hlint";
+  broken = false;
 }
diff --git a/pkgs/hnix.nix b/pkgs/hnix.nix
index f8667fde20634a0c9c996004d6587df3901e4af9..45ccb4d485346f20e71229bbaef92073e28884e4 100644
--- a/pkgs/hnix.nix
+++ b/pkgs/hnix.nix
@@ -82,6 +82,7 @@ mkDerivation {
   };
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     array
@@ -203,12 +204,16 @@ mkDerivation {
     template-haskell
     time
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-nix/hnix#readme";
   description = "Haskell implementation of the Nix language";
   license = lib.licenses.bsd3;
   mainProgram = "hnix";
+  broken = false;
 }
diff --git a/pkgs/horizon-gen-nix.nix b/pkgs/horizon-gen-nix.nix
index d731c0f6059a7d74f48ac01f90d54e417784248f..d423b6203bfe69a99a304d513a2cf8eb9062fccc 100644
--- a/pkgs/horizon-gen-nix.nix
+++ b/pkgs/horizon-gen-nix.nix
@@ -1,6 +1,20 @@
-{ mkDerivation, base, Cabal-syntax, cabal2nix, containers, data-fix
-, dhall, directory, fetchgit, language-nix, lens, lib, megaparsec
-, path, path-dhall-instance, pretty, text
+{ mkDerivation
+, base
+, Cabal-syntax
+, cabal2nix
+, containers
+, data-fix
+, dhall
+, directory
+, fetchgit
+, language-nix
+, lens
+, lib
+, megaparsec
+, path
+, path-dhall-instance
+, pretty
+, text
 }:
 mkDerivation {
   pname = "horizon-gen-nix";
@@ -13,16 +27,33 @@ mkDerivation {
   };
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base Cabal-syntax cabal2nix containers data-fix dhall directory
-    language-nix lens megaparsec path path-dhall-instance pretty text
+    base
+    Cabal-syntax
+    cabal2nix
+    containers
+    data-fix
+    dhall
+    directory
+    language-nix
+    lens
+    megaparsec
+    path
+    path-dhall-instance
+    pretty
+    text
   ];
   executableHaskellDepends = [ base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Short description of your package";
   license = lib.licenses.bsd3;
   mainProgram = "horizon-gen-nix";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/hourglass.nix b/pkgs/hourglass.nix
index dfe7e6932880bf6d6897522758a0e6c3b4395a22..7cb60696594528ff1a54dd2f6acada6584598a0c 100644
--- a/pkgs/hourglass.nix
+++ b/pkgs/hourglass.nix
@@ -15,6 +15,9 @@ mkDerivation {
   pname = "hourglass";
   version = "0.2.12";
   sha256 = "44335b5c402e80c60f1db6a74462be4ea29d1a9043aa994334ffee1164f1ca4a";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base deepseq ];
   testHaskellDepends = [
     base
@@ -35,11 +38,15 @@ mkDerivation {
     old-locale
     time
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/vincenthz/hs-hourglass";
   description = "simple performant time related library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/hpack-dhall.nix b/pkgs/hpack-dhall.nix
index 254f3f666f197a9d7aabdccfb9b1adbbf1626ad5..ca5c2a4e87514f9acabc76f9a4901119cd3d732d 100644
--- a/pkgs/hpack-dhall.nix
+++ b/pkgs/hpack-dhall.nix
@@ -1,7 +1,26 @@
-{ mkDerivation, aeson, aeson-pretty, base, bytestring, Cabal, dhall
-, dhall-json, Diff, directory, filepath, hpack, lib, megaparsec
-, microlens, optparse-applicative, prettyprinter, tasty
-, tasty-golden, text, transformers, utf8-string, yaml
+{ mkDerivation
+, aeson
+, aeson-pretty
+, base
+, bytestring
+, Cabal
+, dhall
+, dhall-json
+, Diff
+, directory
+, filepath
+, hpack
+, lib
+, megaparsec
+, microlens
+, optparse-applicative
+, prettyprinter
+, tasty
+, tasty-golden
+, text
+, transformers
+, utf8-string
+, yaml
 }:
 mkDerivation {
   pname = "hpack-dhall";
@@ -9,25 +28,71 @@ mkDerivation {
   sha256 = "798053584b64213fdb724b79368f71094ef5912af1cf46efe991501bd51d98c3";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson aeson-pretty base bytestring dhall dhall-json filepath hpack
-    megaparsec microlens prettyprinter text transformers yaml
+    aeson
+    aeson-pretty
+    base
+    bytestring
+    dhall
+    dhall-json
+    filepath
+    hpack
+    megaparsec
+    microlens
+    prettyprinter
+    text
+    transformers
+    yaml
   ];
   executableHaskellDepends = [
-    aeson aeson-pretty base bytestring dhall dhall-json filepath hpack
-    megaparsec microlens optparse-applicative prettyprinter text
-    transformers yaml
+    aeson
+    aeson-pretty
+    base
+    bytestring
+    dhall
+    dhall-json
+    filepath
+    hpack
+    megaparsec
+    microlens
+    optparse-applicative
+    prettyprinter
+    text
+    transformers
+    yaml
   ];
   testHaskellDepends = [
-    aeson aeson-pretty base bytestring Cabal dhall dhall-json Diff
-    directory filepath hpack megaparsec microlens prettyprinter tasty
-    tasty-golden text transformers utf8-string yaml
+    aeson
+    aeson-pretty
+    base
+    bytestring
+    Cabal
+    dhall
+    dhall-json
+    Diff
+    directory
+    filepath
+    hpack
+    megaparsec
+    microlens
+    prettyprinter
+    tasty
+    tasty-golden
+    text
+    transformers
+    utf8-string
+    yaml
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/cabalism/hpack-dhall#readme";
   description = "hpack's dhalling";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/hpack.nix b/pkgs/hpack.nix
index 1fc0a088e3b892bab882dc13fd22e18866294dbc..c4e4ba5fad80dc98542a429de7b732ecb7cdcf71 100644
--- a/pkgs/hpack.nix
+++ b/pkgs/hpack.nix
@@ -1,9 +1,35 @@
-{ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
-, containers, cryptonite, deepseq, directory, filepath, Glob, hspec
-, hspec-discover, http-client, http-client-tls, http-types, HUnit
-, infer-license, interpolate, lib, mockery, pretty, QuickCheck
-, scientific, template-haskell, temporary, text, transformers
-, unordered-containers, vector, yaml
+{ mkDerivation
+, aeson
+, base
+, bifunctors
+, bytestring
+, Cabal
+, containers
+, cryptonite
+, deepseq
+, directory
+, filepath
+, Glob
+, hspec
+, hspec-discover
+, http-client
+, http-client-tls
+, http-types
+, HUnit
+, infer-license
+, interpolate
+, lib
+, mockery
+, pretty
+, QuickCheck
+, scientific
+, template-haskell
+, temporary
+, text
+, transformers
+, unordered-containers
+, vector
+, yaml
 }:
 mkDerivation {
   pname = "hpack";
@@ -13,32 +39,97 @@ mkDerivation {
   editedCabalFile = "1x0rmra2fpfzmhhw090iila2drfdmb1y28ybypmgbi0asa1zl751";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base bifunctors bytestring Cabal containers cryptonite
-    deepseq directory filepath Glob http-client http-client-tls
-    http-types infer-license pretty scientific text transformers
-    unordered-containers vector yaml
+    aeson
+    base
+    bifunctors
+    bytestring
+    Cabal
+    containers
+    cryptonite
+    deepseq
+    directory
+    filepath
+    Glob
+    http-client
+    http-client-tls
+    http-types
+    infer-license
+    pretty
+    scientific
+    text
+    transformers
+    unordered-containers
+    vector
+    yaml
   ];
   executableHaskellDepends = [
-    aeson base bifunctors bytestring Cabal containers cryptonite
-    deepseq directory filepath Glob http-client http-client-tls
-    http-types infer-license pretty scientific text transformers
-    unordered-containers vector yaml
+    aeson
+    base
+    bifunctors
+    bytestring
+    Cabal
+    containers
+    cryptonite
+    deepseq
+    directory
+    filepath
+    Glob
+    http-client
+    http-client-tls
+    http-types
+    infer-license
+    pretty
+    scientific
+    text
+    transformers
+    unordered-containers
+    vector
+    yaml
   ];
   testHaskellDepends = [
-    aeson base bifunctors bytestring Cabal containers cryptonite
-    deepseq directory filepath Glob hspec http-client http-client-tls
-    http-types HUnit infer-license interpolate mockery pretty
-    QuickCheck scientific template-haskell temporary text transformers
-    unordered-containers vector yaml
+    aeson
+    base
+    bifunctors
+    bytestring
+    Cabal
+    containers
+    cryptonite
+    deepseq
+    directory
+    filepath
+    Glob
+    hspec
+    http-client
+    http-client-tls
+    http-types
+    HUnit
+    infer-license
+    interpolate
+    mockery
+    pretty
+    QuickCheck
+    scientific
+    template-haskell
+    temporary
+    text
+    transformers
+    unordered-containers
+    vector
+    yaml
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/sol/hpack#readme";
   description = "A modern format for Haskell packages";
   license = lib.licenses.mit;
   mainProgram = "hpack";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/hslua-aeson.nix b/pkgs/hslua-aeson.nix
index 9658c7157b8133224bb97ac916638b1438fd3ead..ce391d66ec08a7f76b842e0629b22850f425043b 100644
--- a/pkgs/hslua-aeson.nix
+++ b/pkgs/hslua-aeson.nix
@@ -21,6 +21,9 @@ mkDerivation {
   pname = "hslua-aeson";
   version = "2.2.1";
   sha256 = "ab221cf59b915fba43deed51514a3703f7b0e504a2e26c6c787cb855bc9af545";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     base
@@ -53,11 +56,15 @@ mkDerivation {
     unordered-containers
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://hslua.org/";
   description = "Allow aeson data types to be used with Lua";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/hspec-contrib.nix b/pkgs/hspec-contrib.nix
index 4f761e27b91eca543868a326a44f391e3b4b5a09..e23240299bb0ce7c014f32c9d2eeb04cf7daff27 100644
--- a/pkgs/hspec-contrib.nix
+++ b/pkgs/hspec-contrib.nix
@@ -1,18 +1,31 @@
-{ mkDerivation, base, hspec, hspec-core, hspec-discover, HUnit, lib
+{ mkDerivation
+, base
+, hspec
+, hspec-core
+, hspec-discover
+, HUnit
+, lib
 , QuickCheck
 }:
 mkDerivation {
   pname = "hspec-contrib";
   version = "0.5.1.1";
   sha256 = "fde656a694dafbb8e147c1ca41eff5eef6a273f79fbae1bc0722e128852dcbdb";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base hspec-core HUnit ];
   testHaskellDepends = [ base hspec hspec-core HUnit QuickCheck ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://hspec.github.io/";
   description = "Contributed functionality for Hspec";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/hspec-core.nix b/pkgs/hspec-core.nix
index 860db35d11c5abbab00a21931fcc985e2e84bd13..c9ba87e5546ed5ef4004156573aa2e6d06079564 100644
--- a/pkgs/hspec-core.nix
+++ b/pkgs/hspec-core.nix
@@ -29,6 +29,9 @@ mkDerivation {
   pname = "hspec-core";
   version = "2.10.0.1";
   sha256 = "144b16e45019c910c857cf4c6815a1f928ded861fc7047d64e1809dd2695a93c";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     ansi-terminal
     array
@@ -77,12 +80,16 @@ mkDerivation {
     transformers
   ];
   testToolDepends = [ hspec-meta ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   testTarget = "--test-option=--skip --test-option='Test.Hspec.Core.Runner.hspecResult runs specs in parallel'";
   homepage = "http://hspec.github.io/";
   description = "A Testing Framework for Haskell";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/hspec-discover.nix b/pkgs/hspec-discover.nix
index bbcc8e0f18437e30cefee836bb406104167e32d0..e2866e8cd0c833a57c3ce5616839b7d27f0e1fe5 100644
--- a/pkgs/hspec-discover.nix
+++ b/pkgs/hspec-discover.nix
@@ -13,6 +13,7 @@ mkDerivation {
   sha256 = "3f55defbe8d5493ff73ffdf84cbe8550fbb44d73f796ab31b5387a4c128047fc";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base directory filepath ];
   executableHaskellDepends = [ base directory filepath ];
   testHaskellDepends = [
@@ -24,12 +25,16 @@ mkDerivation {
     QuickCheck
   ];
   testToolDepends = [ hspec-meta ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://hspec.github.io/";
   description = "Automatically discover and run Hspec tests";
   license = lib.licenses.mit;
   mainProgram = "hspec-discover";
+  broken = false;
 }
diff --git a/pkgs/hspec-meta.nix b/pkgs/hspec-meta.nix
index 2c745b94c51100c136f9cc7c5b5e070f952d4ef2..29b5001827dc5352c1ce83bc9b47aa2d7ce94e93 100644
--- a/pkgs/hspec-meta.nix
+++ b/pkgs/hspec-meta.nix
@@ -24,6 +24,7 @@ mkDerivation {
   sha256 = "d546154ac439c445d0d8a70f0977b7332ed8bc325cd902451f544656f5e55de5";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     ansi-terminal
     array
@@ -61,12 +62,16 @@ mkDerivation {
     time
     transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://hspec.github.io/";
   description = "A version of Hspec which is used to test Hspec itself";
   license = lib.licenses.mit;
   mainProgram = "hspec-meta-discover";
+  broken = false;
 }
diff --git a/pkgs/hspec.nix b/pkgs/hspec.nix
index 14ba949a398a265e2a5f8e82e9b5237372a761c6..f6377015a668eb3fa3ba54c21dfe9cc69fb476ac 100644
--- a/pkgs/hspec.nix
+++ b/pkgs/hspec.nix
@@ -10,6 +10,9 @@ mkDerivation {
   pname = "hspec";
   version = "2.10.3";
   sha256 = "e381944a27b5e736e514264f534218268785bcf8177d27126c68780fd9df07f2";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     hspec-core
@@ -17,11 +20,15 @@ mkDerivation {
     hspec-expectations
     QuickCheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://hspec.github.io/";
   description = "A Testing Framework for Haskell";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/http-client.nix b/pkgs/http-client.nix
index 6035410e39e32eed75a073a08aee9d7c6bfaa80c..1dc8a16f1632ca9d66785c31cdaf444c9f369a8b 100644
--- a/pkgs/http-client.nix
+++ b/pkgs/http-client.nix
@@ -34,6 +34,9 @@ mkDerivation {
   pname = "http-client";
   version = "0.7.13.1";
   sha256 = "c98e86a0382fa877e320d83dbbd173c41c966a60a32c9bc597058929a7aa0e27";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     async
@@ -82,11 +85,15 @@ mkDerivation {
     zlib
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/snoyberg/http-client";
   description = "An HTTP client engine";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/http-date.nix b/pkgs/http-date.nix
index 274de6271c0c578615ba16ed944ddb72cfaff723..91aba55875fbe5d19898e6d6ff7bc24981113a1b 100644
--- a/pkgs/http-date.nix
+++ b/pkgs/http-date.nix
@@ -13,6 +13,9 @@ mkDerivation {
   pname = "http-date";
   version = "0.0.11";
   sha256 = "32f923ac1ad9bdfeadce7c52a03c9ba6225ba60dc14137cb1cdf32ea84ccf4d3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ array attoparsec base bytestring time ];
   testHaskellDepends = [
     base
@@ -22,10 +25,14 @@ mkDerivation {
     old-locale
     time
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "HTTP Date parser/formatter";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/http-types.nix b/pkgs/http-types.nix
index 700b30164ff19a5fdd13191bf1429691d2a75304..a31627dd35adca0de54743213712a428e0ae26e5 100644
--- a/pkgs/http-types.nix
+++ b/pkgs/http-types.nix
@@ -14,6 +14,9 @@ mkDerivation {
   pname = "http-types";
   version = "0.12.3";
   sha256 = "4e8a4a66477459fa436a331c75e46857ec8026283df984d54f90576cd3024016";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -30,11 +33,15 @@ mkDerivation {
     quickcheck-instances
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/aristidb/http-types";
   description = "Generic HTTP types for Haskell (for both client and server code)";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/http2.nix b/pkgs/http2.nix
index f9ebd07609f4cfaf26f4bd9cca01a10a4a22aa22..ca080088168fb4f6daba08185bf6d313dea722f0 100644
--- a/pkgs/http2.nix
+++ b/pkgs/http2.nix
@@ -37,6 +37,7 @@ mkDerivation {
   sha256 = "1bae426d9b9c7266b89ae13b8ad7dfb548d16efe4c4dda6c0fa35b7b474c69cf";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     async
@@ -87,11 +88,15 @@ mkDerivation {
     psqueues
     stm
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/kazu-yamamoto/http2";
   description = "HTTP/2 library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/incipit-base.nix b/pkgs/incipit-base.nix
index fbc82ea3526b6114bd6024ccb8261a0f1a94661e..d54648dfccc88bb038ae5432f2265000f5bcd19c 100644
--- a/pkgs/incipit-base.nix
+++ b/pkgs/incipit-base.nix
@@ -11,6 +11,9 @@ mkDerivation {
   pname = "incipit-base";
   version = "0.3.0.0";
   sha256 = "d12c13e0bd90276ec71595df68368cbbdaaf58ba79a171c805ec2285413ee41a";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -19,11 +22,15 @@ mkDerivation {
     stm
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/tek/incipit-core#readme";
   description = "A Prelude for Polysemy – Base Reexports";
   license = "BSD-2-Clause-Patent";
+  broken = false;
 }
diff --git a/pkgs/incipit-core.nix b/pkgs/incipit-core.nix
index f675befc8572debc02aed04a46019ff5c6951a7a..ef9cab8d74a6e81505c4cee5864b2815bde856f5 100644
--- a/pkgs/incipit-core.nix
+++ b/pkgs/incipit-core.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "incipit-core";
   version = "0.3.0.0";
   sha256 = "1f6b16d4252ba229c69dfd56450d8b252a8bf2e69c739a565b0d9dbee66f1a3f";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base incipit-base polysemy ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/tek/incipit-core#readme";
   description = "A Prelude for Polysemy";
   license = "BSD-2-Clause-Patent";
+  broken = false;
 }
diff --git a/pkgs/indexed-traversable-instances.nix b/pkgs/indexed-traversable-instances.nix
index f1dbbde4b39e6e27bc597fa5df1aaffe046fff0e..3b36fcd1224d3d3a673ffdb613f6f0296275fd03 100644
--- a/pkgs/indexed-traversable-instances.nix
+++ b/pkgs/indexed-traversable-instances.nix
@@ -17,6 +17,9 @@ mkDerivation {
   pname = "indexed-traversable-instances";
   version = "0.1.1.1";
   sha256 = "895ee5063d59e2b58930ca6fa54885bb11f19c8b7c7ba6c7b014f9431cdcc0b0";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     indexed-traversable
@@ -38,10 +41,14 @@ mkDerivation {
     unordered-containers
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "More instances of FunctorWithIndex, FoldableWithIndex, TraversableWithIndex";
   license = lib.licenses.bsd2;
+  broken = false;
 }
diff --git a/pkgs/indexed-traversable.nix b/pkgs/indexed-traversable.nix
index 9c51a0dfb02573c7fefc0ebbdd1f278468c54140..f476fa61b59b8645525c31adb5906158a330b2e9 100644
--- a/pkgs/indexed-traversable.nix
+++ b/pkgs/indexed-traversable.nix
@@ -5,11 +5,18 @@ mkDerivation {
   sha256 = "516858ee7198b1fed1b93c665157f9855fd947379db7f115d48c1b0d670e698d";
   revision = "2";
   editedCabalFile = "0l2k9jrmixkkf7qzzq0bqgvk6axaqi9sxxkpb4dgj8frmc4bg8aj";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ array base containers transformers ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "FunctorWithIndex, FoldableWithIndex, TraversableWithIndex";
   license = lib.licenses.bsd2;
+  broken = false;
 }
diff --git a/pkgs/infer-license.nix b/pkgs/infer-license.nix
index 3228cabbc2a97eef06ecf701c3f70820bbf31386..de57bd85dbfd25819e4ad762da039410ea92d2a6 100644
--- a/pkgs/infer-license.nix
+++ b/pkgs/infer-license.nix
@@ -1,20 +1,42 @@
-{ mkDerivation, base, directory, filepath, hspec, lib, text
+{ mkDerivation
+, base
+, directory
+, filepath
+, hspec
+, lib
+, text
 , text-metrics
 }:
 mkDerivation {
   pname = "infer-license";
   version = "0.2.0";
   sha256 = "12e6fe616575159c03cf6fd4a4f30021ecf264a529ab4e4edd6e96e296a98e72";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base directory filepath text text-metrics
+    base
+    directory
+    filepath
+    text
+    text-metrics
   ];
   testHaskellDepends = [
-    base directory filepath hspec text text-metrics
+    base
+    directory
+    filepath
+    hspec
+    text
+    text-metrics
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Infer software license from a given license file";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/integer-logarithms.nix b/pkgs/integer-logarithms.nix
index 71b827789c2c4d02a77fe29b49481053fdb73dd2..55779bc76568660c71386e5ded14ff0cfa84f78f 100644
--- a/pkgs/integer-logarithms.nix
+++ b/pkgs/integer-logarithms.nix
@@ -17,6 +17,9 @@ mkDerivation {
   sha256 = "9b0a9f9fab609b15cd015865721fb05f744a1bc77ae92fd133872de528bbea7f";
   revision = "3";
   editedCabalFile = "0z81yksgx20d0rva41blsjcp3jsp1qy9sy385fpig0l074fzv6ym";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ array base ghc-bignum ghc-prim ];
   testHaskellDepends = [
     base
@@ -27,11 +30,15 @@ mkDerivation {
     tasty-quickcheck
     tasty-smallcheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskellari/integer-logarithms";
   description = "Integer logarithms";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/invariant.nix b/pkgs/invariant.nix
index b39f3ff85365fb16faf698d97b9a1702c7d8db6f..8f9fa84e08f8c64ad0cfbcb00b82325c7c883dac 100644
--- a/pkgs/invariant.nix
+++ b/pkgs/invariant.nix
@@ -26,6 +26,9 @@ mkDerivation {
   sha256 = "b52b2a798c514e2f3bb37d9d629078f433745fa8a25756198c4d33751d7bce1d";
   revision = "1";
   editedCabalFile = "0551ll1swnrmq09j89jqnxl4qnirbbpdpsdym23adaf36qdd7v37";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -46,11 +49,15 @@ mkDerivation {
   ];
   testHaskellDepends = [ base hspec QuickCheck template-haskell ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/nfrisby/invariant-functors";
   description = "Haskell98 invariant functors";
   license = lib.licenses.bsd2;
+  broken = false;
 }
diff --git a/pkgs/iproute.nix b/pkgs/iproute.nix
index 85c61ab826c41cd6593293f33b861c5c0a751cc8..f253dae12d4d2320d17125a424a562ed7b95b59b 100644
--- a/pkgs/iproute.nix
+++ b/pkgs/iproute.nix
@@ -15,6 +15,9 @@ mkDerivation {
   pname = "iproute";
   version = "1.7.12";
   sha256 = "f1751d1579fcbc1d9f86d9d1c9ede48cb71cbeb1d7b2043491c6216e4f236b63";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     appar
     base
@@ -35,11 +38,15 @@ mkDerivation {
     QuickCheck
     safe
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://www.mew.org/~kazu/proj/iproute/";
   description = "IP Routing Table";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/kvstore-effectful-cache.nix b/pkgs/kvstore-effectful-cache.nix
index ffe0f1f0dd3014dd543d93f108974bc234b6ba40..bd5d64ab6c168a69b28da7bd488007c18b0c87af 100644
--- a/pkgs/kvstore-effectful-cache.nix
+++ b/pkgs/kvstore-effectful-cache.nix
@@ -1,6 +1,19 @@
-{ mkDerivation, base, cache, containers, effectful, effectful-cache
-, effectful-core, fetchgit, hashable, hedgehog, kvstore-effectful
-, kvstore-effectful-spec, lib, tasty, tasty-hedgehog, transformers
+{ mkDerivation
+, base
+, cache
+, containers
+, effectful
+, effectful-cache
+, effectful-core
+, fetchgit
+, hashable
+, hedgehog
+, kvstore-effectful
+, kvstore-effectful-spec
+, lib
+, tasty
+, tasty-hedgehog
+, transformers
 }:
 mkDerivation {
   pname = "kvstore-effectful-cache";
@@ -12,18 +25,40 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/kvstore-effectful-cache/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base cache containers effectful effectful-cache hashable
+    base
+    cache
+    containers
+    effectful
+    effectful-cache
+    hashable
     kvstore-effectful
   ];
   testHaskellDepends = [
-    base cache containers effectful effectful-cache effectful-core
-    hashable hedgehog kvstore-effectful kvstore-effectful-spec tasty
-    tasty-hedgehog transformers
+    base
+    cache
+    containers
+    effectful
+    effectful-cache
+    effectful-core
+    hashable
+    hedgehog
+    kvstore-effectful
+    kvstore-effectful-spec
+    tasty
+    tasty-hedgehog
+    transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/kvstore-effectful-spec.nix b/pkgs/kvstore-effectful-spec.nix
index c0536bc9bfb736e305954b5947888022b2404a83..e1ba007cf8d26af8134fc7c05bbb4f5d5785108a 100644
--- a/pkgs/kvstore-effectful-spec.nix
+++ b/pkgs/kvstore-effectful-spec.nix
@@ -1,5 +1,14 @@
-{ mkDerivation, base, containers, effectful, effectful-core
-, fetchgit, hedgehog, kvstore-effectful, lib, tasty, tasty-hedgehog
+{ mkDerivation
+, base
+, containers
+, effectful
+, effectful-core
+, fetchgit
+, hedgehog
+, kvstore-effectful
+, lib
+, tasty
+, tasty-hedgehog
 , transformers
 }:
 mkDerivation {
@@ -12,13 +21,27 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/kvstore-effectful-spec/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers effectful effectful-core hedgehog kvstore-effectful
-    tasty tasty-hedgehog transformers
+    base
+    containers
+    effectful
+    effectful-core
+    hedgehog
+    kvstore-effectful
+    tasty
+    tasty-hedgehog
+    transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/kvstore-effectful-statemap.nix b/pkgs/kvstore-effectful-statemap.nix
index 5e7ed14701b4330be6877a9078e0247b57140092..fbbc2e0c8e1c544e60f5297519c24853b420ae18 100644
--- a/pkgs/kvstore-effectful-statemap.nix
+++ b/pkgs/kvstore-effectful-statemap.nix
@@ -1,6 +1,16 @@
-{ mkDerivation, base, containers, effectful, effectful-core
-, fetchgit, hedgehog, kvstore-effectful, kvstore-effectful-spec
-, lib, tasty, tasty-hedgehog, transformers
+{ mkDerivation
+, base
+, containers
+, effectful
+, effectful-core
+, fetchgit
+, hedgehog
+, kvstore-effectful
+, kvstore-effectful-spec
+, lib
+, tasty
+, tasty-hedgehog
+, transformers
 }:
 mkDerivation {
   pname = "kvstore-effectful-statemap";
@@ -12,16 +22,34 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/kvstore-effectful-statemap/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers effectful kvstore-effectful
+    base
+    containers
+    effectful
+    kvstore-effectful
   ];
   testHaskellDepends = [
-    base containers effectful effectful-core hedgehog kvstore-effectful
-    kvstore-effectful-spec tasty tasty-hedgehog transformers
+    base
+    containers
+    effectful
+    effectful-core
+    hedgehog
+    kvstore-effectful
+    kvstore-effectful-spec
+    tasty
+    tasty-hedgehog
+    transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/kvstore-effectful.nix b/pkgs/kvstore-effectful.nix
index 71223992a21a15f9d871b3b91696d1c5579ea549..14c59d28513dc04872aa1ba19e12058dc478a749 100644
--- a/pkgs/kvstore-effectful.nix
+++ b/pkgs/kvstore-effectful.nix
@@ -9,10 +9,17 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/kvstore-effectful/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base containers effectful ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/lens-aeson.nix b/pkgs/lens-aeson.nix
index 1eabb8fd4c66a39f86bdd7f45c43f0d3018aa148..b00c9cfe487d741fe3dd6937ea905d441539cc5f 100644
--- a/pkgs/lens-aeson.nix
+++ b/pkgs/lens-aeson.nix
@@ -17,6 +17,9 @@ mkDerivation {
   sha256 = "347199fe28324940bfa9dfb29010ae37510854cc51f8ef88d0a621afe6daa023";
   revision = "3";
   editedCabalFile = "0lqpl5fhl94fm3xcwf8ssz7yg9nyfxp9bw2z959x7hg6bcqmv9p1";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     attoparsec
@@ -29,11 +32,15 @@ mkDerivation {
     unordered-containers
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/lens/lens-aeson/";
   description = "Law-abiding lenses for aeson";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/lens-family-th.nix b/pkgs/lens-family-th.nix
index 4c740b22e6f99e7d149ec8e96f09a37d06168bf7..15875dae722bad6c6aef79ab6bcd85b7a94f3636 100644
--- a/pkgs/lens-family-th.nix
+++ b/pkgs/lens-family-th.nix
@@ -3,13 +3,20 @@ mkDerivation {
   pname = "lens-family-th";
   version = "0.5.2.1";
   sha256 = "b01d6bb9325fa1729325ebc94b70ccf7957bbe71cb11367b3acd791a143213f1";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base template-haskell ];
   testHaskellDepends = [ base hspec template-haskell transformers ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/DanBurton/lens-family-th#readme";
   description = "Generate lens-family style lenses";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/lens.nix b/pkgs/lens.nix
index d994a55f007b2fdc7cc2309f8c2f60a7c32e4eab..90be3e63afce8470211d3f1073653f4b1d82e669 100644
--- a/pkgs/lens.nix
+++ b/pkgs/lens.nix
@@ -49,6 +49,9 @@ mkDerivation {
   pname = "lens";
   version = "5.2";
   sha256 = "b33e2ebede468d9e8acb79d20bb5a5947fc3bec13cc39b122aa131c5e6dcd188";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     assoc
@@ -111,11 +114,15 @@ mkDerivation {
     unordered-containers
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/ekmett/lens/";
   description = "Lenses, Folds and Traversals";
   license = lib.licenses.bsd2;
+  broken = false;
 }
diff --git a/pkgs/lifted-async.nix b/pkgs/lifted-async.nix
index 35714f6c8e7f788796d158a3d43fb35f07b9f11f..5b5f6cfff8c8c5abe90893acf0735a4289d811a3 100644
--- a/pkgs/lifted-async.nix
+++ b/pkgs/lifted-async.nix
@@ -19,6 +19,9 @@ mkDerivation {
   pname = "lifted-async";
   version = "0.10.2.1";
   sha256 = "0d05715f44bb5464f97bac46302a81338271375b07c54c90efb33b1c0e298e48";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     async
     base
@@ -40,11 +43,15 @@ mkDerivation {
     tasty-th
   ];
   benchmarkHaskellDepends = [ async base deepseq tasty-bench ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/maoe/lifted-async";
   description = "Run lifted IO operations asynchronously and wait for their results";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/linear.nix b/pkgs/linear.nix
index 7f14b8dc41ccf8fca3acce38ab4ccda87e32d39a..25cd99d4a474d52b60576087ab4b5bcd214d5611 100644
--- a/pkgs/linear.nix
+++ b/pkgs/linear.nix
@@ -34,6 +34,9 @@ mkDerivation {
   pname = "linear";
   version = "1.21.10";
   sha256 = "b90733227c9d4047e087a0083785e8293dc623169161c6dab12ece1ac90d7ab4";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     adjunctions
     base
@@ -72,11 +75,15 @@ mkDerivation {
     test-framework-hunit
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/ekmett/linear/";
   description = "Linear Algebra";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/log-effectful.nix b/pkgs/log-effectful.nix
index 31fca645b8379d6ae3bd3d39dd8187cf85524619..239097121e84ef67f1391eb9a5071af668ed10d4 100644
--- a/pkgs/log-effectful.nix
+++ b/pkgs/log-effectful.nix
@@ -1,5 +1,12 @@
-{ mkDerivation, aeson, base, effectful-core, fetchgit, lib
-, log-base, text, time
+{ mkDerivation
+, aeson
+, base
+, effectful-core
+, fetchgit
+, lib
+, log-base
+, text
+, time
 }:
 mkDerivation {
   pname = "log-effectful";
@@ -10,12 +17,19 @@ mkDerivation {
     rev = "910c79e10d5ac3353f2a1551103a2b63229c3f57";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base effectful-core log-base text time ];
   testHaskellDepends = [ aeson base effectful-core log-base text ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Adaptation of the log library for the effectful ecosystem";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/lsp-types.nix b/pkgs/lsp-types.nix
index 25eda49a48d99f1c8398795edb92053b27841883..98fb4bc9f038a60d9c31c1cc00e297e860dab3e8 100644
--- a/pkgs/lsp-types.nix
+++ b/pkgs/lsp-types.nix
@@ -31,6 +31,9 @@ mkDerivation {
   pname = "lsp-types";
   version = "1.6.0.0";
   sha256 = "385dc4fb3c7fcdb5c6cb26cf9f589b879cdb28dc7a452a6dc628dec369c19802";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     base
@@ -67,11 +70,15 @@ mkDerivation {
     tuple
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell/lsp";
   description = "Haskell library for the Microsoft Language Server Protocol, data types";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/lsp.nix b/pkgs/lsp.nix
index 154933c0838d9ec36caac7ce7468a47f1867841e..93f22d9eb6ceb3447b699042d043ba96c179e20e 100644
--- a/pkgs/lsp.nix
+++ b/pkgs/lsp.nix
@@ -35,6 +35,7 @@ mkDerivation {
   sha256 = "896803766e8ceabeacc72743f4b92cf7766b2a1f09be270b29d0a39692b00470";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     async
@@ -73,11 +74,15 @@ mkDerivation {
     unordered-containers
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell/lsp";
   description = "Haskell library for the Microsoft Language Server Protocol";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/lucid-alpine.nix b/pkgs/lucid-alpine.nix
index b6ee02604dd36caa65d8d527641b5a5cabc612c0..1aca63dca34a716f2158463a3f5305d7f84e3a56 100644
--- a/pkgs/lucid-alpine.nix
+++ b/pkgs/lucid-alpine.nix
@@ -5,15 +5,20 @@ mkDerivation {
   sha256 = "fd7919480fa483ce19ac5c8774eac78ed541f62be12d36d690fcd8b8baacccdc";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base lucid text ];
   executableHaskellDepends = [ base lucid text ];
   testHaskellDepends = [ base lucid text ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/MonadicSystems/lucid-alpine#readme";
   description = "Use Alpine.js in your lucid templates";
   license = lib.licenses.bsd3;
   mainProgram = "lucid-alpine-exe";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/lucid-aria.nix b/pkgs/lucid-aria.nix
index b5033e09c254d1eeab21b2f7c40498e45fca8719..9055e72b79a7ddd39cbe950c2b62dbeaf935e691 100644
--- a/pkgs/lucid-aria.nix
+++ b/pkgs/lucid-aria.nix
@@ -3,13 +3,20 @@ mkDerivation {
   pname = "lucid-aria";
   version = "0.1.0.1";
   sha256 = "ff30430e76e1224eee79667a0d28a513fb88f223036debdd06dd1e33f650b088";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base lucid text ];
   testHaskellDepends = [ base hspec HUnit lucid ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://git.sr.ht/~rycee/lucid-aria";
   description = "Provides ARIA attributes for Lucid templates";
   license = lib.licenses.asl20;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/lucid-svg.nix b/pkgs/lucid-svg.nix
index a90a4ab8d018ab5851e1f58174c8a037802e6473..0f8ec726f378f78ef2b10691db9cf7c52708a20e 100644
--- a/pkgs/lucid-svg.nix
+++ b/pkgs/lucid-svg.nix
@@ -1,17 +1,34 @@
-{ mkDerivation, base, blaze-builder, lib, lucid, text, transformers
+{ mkDerivation
+, base
+, blaze-builder
+, lib
+, lucid
+, text
+, transformers
 }:
 mkDerivation {
   pname = "lucid-svg";
   version = "0.7.1";
   sha256 = "16b89597d0d2ba99939f327309ff7dbac2e475784d18c94e646833057ec12eb3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base blaze-builder lucid text transformers
+    base
+    blaze-builder
+    lucid
+    text
+    transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/jeffreyrosenbluth/lucid-svg.git";
   description = "DSL for SVG using lucid for HTML";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/lucid.nix b/pkgs/lucid.nix
index 67cb551b583f33946812a862cb8a74b99aaa07d9..bb9b337264ed74da6f61874da2d9f2306453e346 100644
--- a/pkgs/lucid.nix
+++ b/pkgs/lucid.nix
@@ -22,6 +22,9 @@ mkDerivation {
   sha256 = "dcf57142ca1ad5e6dcecfaf4dba703031886c286f8b07ba8cd4470b077e6798e";
   revision = "1";
   editedCabalFile = "0wipmh3xcs00x8lbq5j780rdc2klfj67nzni21qc1pdbhr2whn9d";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     blaze-builder
@@ -51,11 +54,15 @@ mkDerivation {
     text
     transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/chrisdone/lucid";
   description = "Clear to write, read and edit DSL for HTML";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/memory.nix b/pkgs/memory.nix
index 9b382e769e7f4b9b392fa07513553eecbe68638f..693eb27045c4c72ef4c898847cd3e8cec7469324 100644
--- a/pkgs/memory.nix
+++ b/pkgs/memory.nix
@@ -11,6 +11,9 @@ mkDerivation {
   pname = "memory";
   version = "0.18.0";
   sha256 = "fd4eb6f638e24b81b4e6cdd68772a531726f2f67686c8969d3407d82f7862e3e";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     basement
@@ -19,11 +22,15 @@ mkDerivation {
     ghc-prim
   ];
   testHaskellDepends = [ base basement bytestring foundation ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/vincenthz/hs-memory";
   description = "memory and related abstraction stuff";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/microstache.nix b/pkgs/microstache.nix
index 321968ab11b602d9e6e98f45381bccd2b4996a76..9664368c9410f5375e2c12620e51c96ee97c27a9 100644
--- a/pkgs/microstache.nix
+++ b/pkgs/microstache.nix
@@ -1,24 +1,61 @@
-{ mkDerivation, aeson, base, base-orphans, bytestring, containers
-, deepseq, directory, filepath, lib, parsec, tasty, tasty-hunit
-, text, transformers, unordered-containers, vector
+{ mkDerivation
+, aeson
+, base
+, base-orphans
+, bytestring
+, containers
+, deepseq
+, directory
+, filepath
+, lib
+, parsec
+, tasty
+, tasty-hunit
+, text
+, transformers
+, unordered-containers
+, vector
 }:
 mkDerivation {
   pname = "microstache";
   version = "1.0.2.2";
   sha256 = "f0a1dbef45a137e1af0e29ea4b9585788217cc1c6f1db7d68a4f659916dd36ac";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base containers deepseq directory filepath parsec text
-    transformers unordered-containers vector
+    aeson
+    base
+    containers
+    deepseq
+    directory
+    filepath
+    parsec
+    text
+    transformers
+    unordered-containers
+    vector
   ];
   testHaskellDepends = [
-    aeson base base-orphans bytestring containers parsec tasty
-    tasty-hunit text
+    aeson
+    base
+    base-orphans
+    bytestring
+    containers
+    parsec
+    tasty
+    tasty-hunit
+    text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskellari/microstache";
   description = "Mustache templates for Haskell";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/monad-control.nix b/pkgs/monad-control.nix
index 8be6ec049de6ed6e2e01c8aa04b3caa63c0b832b..0aa42b4138426b499885d9963032bfe839e9c761 100644
--- a/pkgs/monad-control.nix
+++ b/pkgs/monad-control.nix
@@ -1,18 +1,34 @@
-{ mkDerivation, base, lib, stm, transformers, transformers-base
+{ mkDerivation
+, base
+, lib
+, stm
+, transformers
+, transformers-base
 , transformers-compat
 }:
 mkDerivation {
   pname = "monad-control";
   version = "1.0.3.1";
   sha256 = "ae0baea04d99375ef788140367179994a7178d400a8ce0d9026846546772713c";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base stm transformers transformers-base transformers-compat
+    base
+    stm
+    transformers
+    transformers-base
+    transformers-compat
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/basvandijk/monad-control";
   description = "Lift control operations, like exception catching, through monad transformers";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/monad-par.nix b/pkgs/monad-par.nix
index 109e5e73c30346cb1bba8138e03305d324162574..69410fd1bab34aa4a2f08c36dbd198ccb0fa65e5 100644
--- a/pkgs/monad-par.nix
+++ b/pkgs/monad-par.nix
@@ -1,8 +1,22 @@
-{ mkDerivation, abstract-deque, abstract-par, array, base
-, containers, deepseq, HUnit, lib, monad-par-extras, mtl
-, mwc-random, parallel, QuickCheck, test-framework
-, test-framework-hunit, test-framework-quickcheck2
-, test-framework-th, time
+{ mkDerivation
+, abstract-deque
+, abstract-par
+, array
+, base
+, containers
+, deepseq
+, HUnit
+, lib
+, monad-par-extras
+, mtl
+, mwc-random
+, parallel
+, QuickCheck
+, test-framework
+, test-framework-hunit
+, test-framework-quickcheck2
+, test-framework-th
+, time
 }:
 mkDerivation {
   pname = "monad-par";
@@ -10,21 +24,48 @@ mkDerivation {
   sha256 = "823ad5666cbcaefe2c6e0ff131daa0713dff9b3b534fb809643b869e5e4a15a9";
   revision = "2";
   editedCabalFile = "1q4npp0vrsjpxk7n7rcf3lgqg1sf2qx628ciiw48al9y9xlznsaz";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    abstract-deque abstract-par array base containers deepseq
-    monad-par-extras mtl mwc-random parallel
+    abstract-deque
+    abstract-par
+    array
+    base
+    containers
+    deepseq
+    monad-par-extras
+    mtl
+    mwc-random
+    parallel
   ];
   testHaskellDepends = [
-    abstract-deque abstract-par array base containers deepseq HUnit
-    monad-par-extras mtl mwc-random QuickCheck test-framework
-    test-framework-hunit test-framework-quickcheck2 test-framework-th
+    abstract-deque
+    abstract-par
+    array
+    base
+    containers
+    deepseq
+    HUnit
+    monad-par-extras
+    mtl
+    mwc-random
+    QuickCheck
+    test-framework
+    test-framework-hunit
+    test-framework-quickcheck2
+    test-framework-th
     time
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/simonmar/monad-par";
   description = "A library for parallel programming based on a monad";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/monad-time.nix b/pkgs/monad-time.nix
index e17085ea27bf50bae431dfc4aa0465fbd620c48b..698337fc01ae40a0ebdd48b9a30da34ca6bb70fa 100644
--- a/pkgs/monad-time.nix
+++ b/pkgs/monad-time.nix
@@ -3,13 +3,20 @@ mkDerivation {
   pname = "monad-time";
   version = "0.4.0.0";
   sha256 = "b4493edf9e7f839cb4ccfcdd53845de493bffbb3ceb4fbb54ba173db68192960";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base mtl time ];
   testHaskellDepends = [ base mtl time ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/scrive/monad-time";
   description = "Type class for monads which carry the notion of the current time";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/monoid-subclasses.nix b/pkgs/monoid-subclasses.nix
index f3d7815ecea61580bc26f3000965b6cd2b94060e..2deecefc85db3dd53a44ead7da2e159e1216a33b 100644
--- a/pkgs/monoid-subclasses.nix
+++ b/pkgs/monoid-subclasses.nix
@@ -17,6 +17,9 @@ mkDerivation {
   sha256 = "9bf112d64c08438733e17fc0ef8fb2bae004d043ea9672c541f1d20c429cf4d9";
   revision = "1";
   editedCabalFile = "0y8sw3zsmz5ssn2gl2fsqg44n7xf3xsf6vhrzwnkbaa97hj76nh2";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -37,11 +40,15 @@ mkDerivation {
     text
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/blamario/monoid-subclasses/";
   description = "Subclasses of Monoid";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/net-mqtt.nix b/pkgs/net-mqtt.nix
index 60506e290fb01fb7079812f8de1672799ca68b4a..380203618a7c1d868bb55af60ffbb245f006dfa0 100644
--- a/pkgs/net-mqtt.nix
+++ b/pkgs/net-mqtt.nix
@@ -30,6 +30,7 @@ mkDerivation {
   sha256 = "c3e30f445a7aef4374b015ceb4239d659bab81dfb879f1675a17b458f4f44da9";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     async
     attoparsec
@@ -93,11 +94,15 @@ mkDerivation {
     text
     websockets
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/dustin/mqtt-hs#readme";
   description = "An MQTT Protocol Implementation";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/network-byte-order.nix b/pkgs/network-byte-order.nix
index 696506cb012de2b0cb5034f9de8b9297a8fda33c..aa2d6f4b259696a60bf497f662a294d689757019 100644
--- a/pkgs/network-byte-order.nix
+++ b/pkgs/network-byte-order.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "f2b0ccc9b759d686af30aac874fc394c13c1fc8a3db00fac401c9339c263dc5e";
   revision = "1";
   editedCabalFile = "0fpyfd1adg9fr7w6afxkx306c0kaz3ji3x78sl29v9j3mh4vdn13";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base bytestring ];
   testHaskellDepends = [ base bytestring doctest ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Network byte order utilities";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/newtype-generics.nix b/pkgs/newtype-generics.nix
index acd3f35a9568f3c9203b5f26d5c7f4b4a074b72e..14b957ad9a06c3c9c4071544c6ecdd7b72898a75 100644
--- a/pkgs/newtype-generics.nix
+++ b/pkgs/newtype-generics.nix
@@ -12,15 +12,22 @@ mkDerivation {
   sha256 = "a1ac6052020a09f1bc5000a141d2edd4b31a82f95ce5957b7eedad40c065a74e";
   revision = "1";
   editedCabalFile = "0xgc7sxs1p3qibgwbikjdrhn47j7m4gk5x1wrv9hncks6hd6hsyf";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   testHaskellDepends = [ base hspec ];
   testToolDepends = [ hspec-discover ];
   benchmarkHaskellDepends = [ base gauge semigroups ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/sjakobi/newtype-generics";
   description = "A typeclass and set of functions for working with newtypes";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/nothunks.nix b/pkgs/nothunks.nix
index c8d482b43249b956e4d2512ba677edd5ab8089c6..081416bdfc7ba04dad89441c3129ef7abeedf410 100644
--- a/pkgs/nothunks.nix
+++ b/pkgs/nothunks.nix
@@ -18,6 +18,9 @@ mkDerivation {
   pname = "nothunks";
   version = "0.1.3";
   sha256 = "c191e9c3d86ca006bf8d85adfd936ff997759120b0fcfaf4960a56d8bd850e53";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -38,10 +41,14 @@ mkDerivation {
     tasty
     tasty-hedgehog
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Examine values for unexpected thunks";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/odd-jobs.nix b/pkgs/odd-jobs.nix
index 7d6b10f22412c786f1f1e93d82f787e25f0d6f99..6cfd2c4aa2916d5ac24c2fb05eda472fc5b903d1 100644
--- a/pkgs/odd-jobs.nix
+++ b/pkgs/odd-jobs.nix
@@ -1,13 +1,51 @@
-{ mkDerivation, aeson, base, bytestring, containers, daemons
-, directory, either, fast-logger, fetchgit, filepath, foreign-store
-, friendly-time, generic-deriving, hedgehog, hostname, lib
-, lifted-async, lifted-base, lucid, mmorph, monad-control
-, monad-logger, mtl, optparse-applicative, postgresql-simple
-, random, resource-pool, safe, servant, servant-lucid
-, servant-server, servant-static-th, string-conv, tasty
-, tasty-discover, tasty-hedgehog, tasty-hunit, text
-, text-conversions, time, timing-convenience, unix, unliftio
-, unliftio-core, unordered-containers, wai, warp
+{ mkDerivation
+, aeson
+, base
+, bytestring
+, containers
+, daemons
+, directory
+, either
+, fast-logger
+, fetchgit
+, filepath
+, foreign-store
+, friendly-time
+, generic-deriving
+, hedgehog
+, hostname
+, lib
+, lifted-async
+, lifted-base
+, lucid
+, mmorph
+, monad-control
+, monad-logger
+, mtl
+, optparse-applicative
+, postgresql-simple
+, random
+, resource-pool
+, safe
+, servant
+, servant-lucid
+, servant-server
+, servant-static-th
+, string-conv
+, tasty
+, tasty-discover
+, tasty-hedgehog
+, tasty-hunit
+, text
+, text-conversions
+, time
+, timing-convenience
+, unix
+, unliftio
+, unliftio-core
+, unordered-containers
+, wai
+, warp
 }:
 mkDerivation {
   pname = "odd-jobs";
@@ -20,40 +58,136 @@ mkDerivation {
   };
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base bytestring daemons directory either fast-logger filepath
-    friendly-time generic-deriving hostname lucid monad-control
-    monad-logger mtl optparse-applicative postgresql-simple
-    resource-pool safe servant servant-lucid servant-server
-    servant-static-th string-conv text text-conversions time
-    timing-convenience unix unliftio unliftio-core unordered-containers
-    wai warp
+    aeson
+    base
+    bytestring
+    daemons
+    directory
+    either
+    fast-logger
+    filepath
+    friendly-time
+    generic-deriving
+    hostname
+    lucid
+    monad-control
+    monad-logger
+    mtl
+    optparse-applicative
+    postgresql-simple
+    resource-pool
+    safe
+    servant
+    servant-lucid
+    servant-server
+    servant-static-th
+    string-conv
+    text
+    text-conversions
+    time
+    timing-convenience
+    unix
+    unliftio
+    unliftio-core
+    unordered-containers
+    wai
+    warp
   ];
   executableHaskellDepends = [
-    aeson base bytestring daemons directory either fast-logger filepath
-    foreign-store friendly-time generic-deriving hostname lucid
-    monad-control monad-logger mtl optparse-applicative
-    postgresql-simple resource-pool safe servant servant-lucid
-    servant-server servant-static-th string-conv text text-conversions
-    time timing-convenience unix unliftio unliftio-core
-    unordered-containers wai warp
+    aeson
+    base
+    bytestring
+    daemons
+    directory
+    either
+    fast-logger
+    filepath
+    foreign-store
+    friendly-time
+    generic-deriving
+    hostname
+    lucid
+    monad-control
+    monad-logger
+    mtl
+    optparse-applicative
+    postgresql-simple
+    resource-pool
+    safe
+    servant
+    servant-lucid
+    servant-server
+    servant-static-th
+    string-conv
+    text
+    text-conversions
+    time
+    timing-convenience
+    unix
+    unliftio
+    unliftio-core
+    unordered-containers
+    wai
+    warp
   ];
   testHaskellDepends = [
-    aeson base bytestring containers daemons directory either
-    fast-logger filepath friendly-time generic-deriving hedgehog
-    hostname lifted-async lifted-base lucid mmorph monad-control
-    monad-logger mtl optparse-applicative postgresql-simple random
-    resource-pool safe servant servant-lucid servant-server
-    servant-static-th string-conv tasty tasty-discover tasty-hedgehog
-    tasty-hunit text text-conversions time timing-convenience unix
-    unliftio unliftio-core unordered-containers wai warp
+    aeson
+    base
+    bytestring
+    containers
+    daemons
+    directory
+    either
+    fast-logger
+    filepath
+    friendly-time
+    generic-deriving
+    hedgehog
+    hostname
+    lifted-async
+    lifted-base
+    lucid
+    mmorph
+    monad-control
+    monad-logger
+    mtl
+    optparse-applicative
+    postgresql-simple
+    random
+    resource-pool
+    safe
+    servant
+    servant-lucid
+    servant-server
+    servant-static-th
+    string-conv
+    tasty
+    tasty-discover
+    tasty-hedgehog
+    tasty-hunit
+    text
+    text-conversions
+    time
+    timing-convenience
+    unix
+    unliftio
+    unliftio-core
+    unordered-containers
+    wai
+    warp
   ];
   testToolDepends = [ tasty-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://www.haskelltutorials.com/odd-jobs";
   description = "A full-featured PostgreSQL-backed job queue (with an admin UI)";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/optics-core.nix b/pkgs/optics-core.nix
index e67aa7cbac1996b5da363233b402fe0f64fc9344..b330679bbd8d99dd776f25a176b3785c62049796 100644
--- a/pkgs/optics-core.nix
+++ b/pkgs/optics-core.nix
@@ -13,6 +13,9 @@ mkDerivation {
   sha256 = "ca64e215f31719482a9449b5d56fbd589367e639d2b1869f7965a3970442949a";
   revision = "1";
   editedCabalFile = "0sqwlbl6x0197bpkq7jvn9j5iwyr54z8qwmxbij6qlwjyfld2qxi";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -21,10 +24,14 @@ mkDerivation {
     indexed-traversable
     transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Optics as an abstract interface: core definitions";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/optics-extra.nix b/pkgs/optics-extra.nix
index f24ad183e9679c9c56e2e6b4892dbbd0d5097f84..2470825d35e1bf7efce9e18b47cac30473f8ef9a 100644
--- a/pkgs/optics-extra.nix
+++ b/pkgs/optics-extra.nix
@@ -20,6 +20,9 @@ mkDerivation {
   sha256 = "7e23a7a325e3448354614d3d958279c9ac2fdd0831ceee2808830e7a962fca41";
   revision = "1";
   editedCabalFile = "0bpr1bkb7mmww028n8ikwa0qhdl7ybxpb9s887dlp3dvxr5iq8nq";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -35,10 +38,14 @@ mkDerivation {
     unordered-containers
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Extra utilities and instances for optics-core";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/optics-th.nix b/pkgs/optics-th.nix
index c95ee757bf31e12b9a932c6eece3746ad182dfd1..d8b40f4d17fb076c37ff3b47ccdc7b3cbe164e67 100644
--- a/pkgs/optics-th.nix
+++ b/pkgs/optics-th.nix
@@ -15,6 +15,9 @@ mkDerivation {
   sha256 = "d73857b79dcd8f7c7e70fa4727f134145b62902e8d3e448f8b25c38a9da4fd17";
   revision = "2";
   editedCabalFile = "1fl217q7s0g8a46p2smanhhdj0jqvc9n3lagcnpphkv3fzfgrcbz";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
@@ -25,10 +28,14 @@ mkDerivation {
     transformers
   ];
   testHaskellDepends = [ base optics-core tagged ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Optics construction using TemplateHaskell";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/optics.nix b/pkgs/optics.nix
index e155925209ec7ba32466ae5c63b1b561963e388f..bfe641fbf022486ce60370e679dc64409310d793 100644
--- a/pkgs/optics.nix
+++ b/pkgs/optics.nix
@@ -26,6 +26,9 @@ mkDerivation {
   pname = "optics";
   version = "0.4.2";
   sha256 = "ebe7553704d3491f02777dc6f02a2cf170d4b87ce5265139ce759314460533c7";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -60,10 +63,14 @@ mkDerivation {
     unordered-containers
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Optics as an abstract interface";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/pandoc.nix b/pkgs/pandoc.nix
index 7b22c189bc18ee82c9895f986038a0e571df6ecd..ada04e9aa41781df8139eb26406d88eaf73df383 100644
--- a/pkgs/pandoc.nix
+++ b/pkgs/pandoc.nix
@@ -207,9 +207,12 @@ mkDerivation {
     tasty-bench
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   postInstall = ''
     mkdir -p $out/share/man/man1
@@ -219,4 +222,5 @@ mkDerivation {
   description = "Conversion between markup formats";
   license = lib.licenses.gpl2Plus;
   mainProgram = "pandoc";
+  broken = false;
 }
diff --git a/pkgs/parallel.nix b/pkgs/parallel.nix
index 54b29d0ad764266212480140775e3f6355bfbff4..9af8d1ae4e813bbcb28c185d5c90356404c2e7bb 100644
--- a/pkgs/parallel.nix
+++ b/pkgs/parallel.nix
@@ -5,11 +5,18 @@ mkDerivation {
   sha256 = "170453a71a2a8b31cca63125533f7771d7debeb639700bdabdd779c34d8a6ef6";
   revision = "5";
   editedCabalFile = "1q45wzpf2sda0244l55gakl3g5zqhcb27m86nhl3vslcjc35mpbf";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ array base containers deepseq ghc-prim ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Parallel programming library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/password-types.nix b/pkgs/password-types.nix
index c53387aa7b706bf5229616553da1fe42b766c82d..1306f4331626ebfd7c0427241b187e9999fb157e 100644
--- a/pkgs/password-types.nix
+++ b/pkgs/password-types.nix
@@ -1,6 +1,18 @@
-{ mkDerivation, base, base-compat, bytestring, Cabal, cabal-doctest
-, doctest, lib, memory, QuickCheck, quickcheck-instances, tasty
-, tasty-quickcheck, template-haskell, text
+{ mkDerivation
+, base
+, base-compat
+, bytestring
+, Cabal
+, cabal-doctest
+, doctest
+, lib
+, memory
+, QuickCheck
+, quickcheck-instances
+, tasty
+, tasty-quickcheck
+, template-haskell
+, text
 }:
 mkDerivation {
   pname = "password-types";
@@ -8,17 +20,31 @@ mkDerivation {
   sha256 = "6551d60c61c90509592e32ee021a927539d5f391cdfd94b76ca51add05c60a24";
   revision = "3";
   editedCabalFile = "0i6djm9zsb95qdan0vr9shilhmzjxqsqrjy9v16hcaph49wnw7pr";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [ base bytestring memory text ];
   testHaskellDepends = [
-    base base-compat doctest QuickCheck quickcheck-instances tasty
-    tasty-quickcheck template-haskell text
+    base
+    base-compat
+    doctest
+    QuickCheck
+    quickcheck-instances
+    tasty
+    tasty-quickcheck
+    template-haskell
+    text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/cdepillabout/password/tree/master/password-types#readme";
   description = "Types for handling passwords";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/password.nix b/pkgs/password.nix
index 640186126672931b4437ceb3924a7511403a5566..4453470140c66d93de517751f03dcdb52aeb80c4 100644
--- a/pkgs/password.nix
+++ b/pkgs/password.nix
@@ -1,27 +1,68 @@
-{ mkDerivation, base, base-compat, base64, bytestring, Cabal
-, cabal-doctest, cryptonite, doctest, lib, memory, password-types
-, QuickCheck, quickcheck-instances, scrypt, tasty, tasty-hunit
-, tasty-quickcheck, template-haskell, text
+{ mkDerivation
+, base
+, base-compat
+, base64
+, bytestring
+, Cabal
+, cabal-doctest
+, cryptonite
+, doctest
+, lib
+, memory
+, password-types
+, QuickCheck
+, quickcheck-instances
+, scrypt
+, tasty
+, tasty-hunit
+, tasty-quickcheck
+, template-haskell
+, text
 }:
 mkDerivation {
   pname = "password";
   version = "3.0.2.0";
   sha256 = "14c5b664ec2d3064059f8de7170c4eb10e847397de9f98a841b8ea5ea6cf4c24";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
-    base base64 bytestring cryptonite memory password-types
-    template-haskell text
+    base
+    base64
+    bytestring
+    cryptonite
+    memory
+    password-types
+    template-haskell
+    text
   ];
   testHaskellDepends = [
-    base base-compat bytestring cryptonite doctest memory
-    password-types QuickCheck quickcheck-instances scrypt tasty
-    tasty-hunit tasty-quickcheck template-haskell text
+    base
+    base-compat
+    bytestring
+    cryptonite
+    doctest
+    memory
+    password-types
+    QuickCheck
+    quickcheck-instances
+    scrypt
+    tasty
+    tasty-hunit
+    tasty-quickcheck
+    template-haskell
+    text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/cdepillabout/password/tree/master/password#readme";
   description = "Hashing and checking of passwords";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/pcg-random.nix b/pkgs/pcg-random.nix
index 33cde9a56b19c74d8c63f09fce99831ecb21a698..15abbf7de94b4fc351fb00ab3315cf8202eaf790 100644
--- a/pkgs/pcg-random.nix
+++ b/pkgs/pcg-random.nix
@@ -13,6 +13,9 @@ mkDerivation {
   pname = "pcg-random";
   version = "0.1.3.7";
   sha256 = "e6c8c26841b5d0d6d9e2816e952e397062730fd1a0bc13cf7c3ebcba6dc1d2d0";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
     base
@@ -22,11 +25,15 @@ mkDerivation {
     random
   ];
   testHaskellDepends = [ base doctest ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/cchalmers/pcg-random";
   description = "Haskell bindings to the PCG random number generator";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/pcre2.nix b/pkgs/pcre2.nix
index b86fa555479f3241802bbf6cc8d018462c418a58..9ef3b0ef69b8ece07332c1d107e986821c377e34 100644
--- a/pkgs/pcre2.nix
+++ b/pkgs/pcre2.nix
@@ -1,27 +1,63 @@
-{ mkDerivation, base, containers, criterion, hspec, lib, microlens
-, microlens-platform, mtl, pcre-light, regex-pcre-builtin
-, template-haskell, text
+{ mkDerivation
+, base
+, containers
+, criterion
+, hspec
+, lib
+, microlens
+, microlens-platform
+, mtl
+, pcre-light
+, regex-pcre-builtin
+, template-haskell
+, text
 }:
 mkDerivation {
   pname = "pcre2";
   version = "2.2.1";
   sha256 = "d48d8669d68f2858d825fb08b3730cfeb49eed964b093b39e78052fd1f510870";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers microlens mtl template-haskell text
+    base
+    containers
+    microlens
+    mtl
+    template-haskell
+    text
   ];
   testHaskellDepends = [
-    base containers hspec microlens microlens-platform mtl
-    template-haskell text
+    base
+    containers
+    hspec
+    microlens
+    microlens-platform
+    mtl
+    template-haskell
+    text
   ];
   benchmarkHaskellDepends = [
-    base containers criterion microlens microlens-platform mtl
-    pcre-light regex-pcre-builtin template-haskell text
+    base
+    containers
+    criterion
+    microlens
+    microlens-platform
+    mtl
+    pcre-light
+    regex-pcre-builtin
+    template-haskell
+    text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/sjshuck/hs-pcre2#readme";
   description = "Regular expressions via the PCRE2 C library (included)";
   license = lib.licenses.asl20;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/persistent.nix b/pkgs/persistent.nix
index da7a2b98dbf2da56c113ba4a60de9040ab598efe..cfbf1213d1a29d46bc05cb273f913f7054908744 100644
--- a/pkgs/persistent.nix
+++ b/pkgs/persistent.nix
@@ -1,38 +1,129 @@
-{ mkDerivation, aeson, attoparsec, base, base64-bytestring
-, blaze-html, bytestring, conduit, containers, criterion, deepseq
-, fast-logger, file-embed, hspec, http-api-data, lib, 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
+, aeson
+, attoparsec
+, base
+, base64-bytestring
+, blaze-html
+, bytestring
+, conduit
+, containers
+, criterion
+, deepseq
+, fast-logger
+, file-embed
+, hspec
+, http-api-data
+, lib
+, 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.14.3.0";
   sha256 = "1288244f62d334dbe65cae6157098de38419b8445d5cc227281e688310189a19";
+  revision = "1";
+  editedCabalFile = "1qbi74kmjk07wgib2y6pscjbr8mazlj490928h5bvahw10jx3611";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson attoparsec base base64-bytestring blaze-html bytestring
-    conduit containers 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
+    aeson
+    attoparsec
+    base
+    base64-bytestring
+    blaze-html
+    bytestring
+    conduit
+    containers
+    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 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
+    aeson
+    attoparsec
+    base
+    base64-bytestring
+    blaze-html
+    bytestring
+    conduit
+    containers
+    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
+    base
+    criterion
+    deepseq
+    file-embed
+    template-haskell
+    text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://www.yesodweb.com/book/persistent";
   description = "Type-safe, multi-backend data serialization";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/pg-entity.nix b/pkgs/pg-entity.nix
index 832ec4e77b9663cad189d4cc152dc5b4932aeab2..acdd031cc1aa531cde4b533aa3c2efa7b5c2fc09 100644
--- a/pkgs/pg-entity.nix
+++ b/pkgs/pg-entity.nix
@@ -1,9 +1,31 @@
-{ mkDerivation, aeson, base, bytestring, colourista, containers
-, exceptions, hedgehog, lib, monad-control, mtl, optics-core
-, parsec, pg-transact, postgresql-simple
-, postgresql-simple-migration, resource-pool, safe-exceptions
-, tasty, tasty-hunit, template-haskell, text, text-display
-, text-manipulate, time, tmp-postgres, uuid, vector
+{ mkDerivation
+, aeson
+, base
+, bytestring
+, colourista
+, containers
+, exceptions
+, hedgehog
+, lib
+, monad-control
+, mtl
+, optics-core
+, parsec
+, pg-transact
+, postgresql-simple
+, postgresql-simple-migration
+, resource-pool
+, safe-exceptions
+, tasty
+, tasty-hunit
+, template-haskell
+, text
+, text-display
+, text-manipulate
+, time
+, tmp-postgres
+, uuid
+, vector
 }:
 mkDerivation {
   pname = "pg-entity";
@@ -11,22 +33,57 @@ mkDerivation {
   sha256 = "3bcc0981b43722de34b2d610ddfef8c43fb97607297a0b4052a4d2425364113d";
   revision = "1";
   editedCabalFile = "03f0isq7vdjc1xbdchb5l0ggbf61jkxn2q1bii6sx8nphfgk4c9j";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base bytestring colourista exceptions monad-control parsec
-    pg-transact postgresql-simple resource-pool safe-exceptions
-    template-haskell text text-display text-manipulate time uuid vector
+    base
+    bytestring
+    colourista
+    exceptions
+    monad-control
+    parsec
+    pg-transact
+    postgresql-simple
+    resource-pool
+    safe-exceptions
+    template-haskell
+    text
+    text-display
+    text-manipulate
+    time
+    uuid
+    vector
   ];
   testHaskellDepends = [
-    aeson base containers hedgehog mtl optics-core pg-transact
-    postgresql-simple postgresql-simple-migration resource-pool
-    safe-exceptions tasty tasty-hunit text time tmp-postgres uuid
+    aeson
+    base
+    containers
+    hedgehog
+    mtl
+    optics-core
+    pg-transact
+    postgresql-simple
+    postgresql-simple-migration
+    resource-pool
+    safe-exceptions
+    tasty
+    tasty-hunit
+    text
+    time
+    tmp-postgres
+    uuid
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://tchoutri.github.io/pg-entity";
   description = "A pleasant PostgreSQL layer";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/pg-transact-effectful.nix b/pkgs/pg-transact-effectful.nix
index f593baa56bcc698c3431e51e1c1fb1a6455bb62a..7b6254b883911c526fa51d1beed00424c6718b3b 100644
--- a/pkgs/pg-transact-effectful.nix
+++ b/pkgs/pg-transact-effectful.nix
@@ -1,5 +1,12 @@
-{ mkDerivation, base, effectful-core, fetchgit, lib, mtl
-, pg-transact, postgresql-simple, resource-pool
+{ mkDerivation
+, base
+, effectful-core
+, fetchgit
+, lib
+, mtl
+, pg-transact
+, postgresql-simple
+, resource-pool
 }:
 mkDerivation {
   pname = "pg-transact-effectful";
@@ -10,13 +17,25 @@ mkDerivation {
     rev = "45730b124c7c21f1dcfd85667fda1c19b8ec9723";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base effectful-core mtl pg-transact postgresql-simple resource-pool
+    base
+    effectful-core
+    mtl
+    pg-transact
+    postgresql-simple
+    resource-pool
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/kleidukos/pg-transact-effectful/";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/pg-transact.nix b/pkgs/pg-transact.nix
index 44951201932dd0a2db58279edb8a12bb1c9a37ae..8f334c445e0f3a4646a997f802d47928a58685d0 100644
--- a/pkgs/pg-transact.nix
+++ b/pkgs/pg-transact.nix
@@ -1,27 +1,61 @@
-{ mkDerivation, async, base, bytestring, criterion, deepseq
-, exceptions, hspec, hspec-expectations-lifted, lib, monad-control
-, postgresql-libpq, postgresql-simple, tmp-postgres, transformers
+{ mkDerivation
+, async
+, base
+, bytestring
+, criterion
+, deepseq
+, exceptions
+, hspec
+, hspec-expectations-lifted
+, lib
+, monad-control
+, postgresql-libpq
+, postgresql-simple
+, tmp-postgres
+, transformers
 }:
 mkDerivation {
   pname = "pg-transact";
   version = "0.3.2.0";
   sha256 = "af109e82fee758d159654b9c02c396197852cbd909b5f02dbbd4ef0613270432";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base bytestring exceptions monad-control postgresql-simple
+    base
+    bytestring
+    exceptions
+    monad-control
+    postgresql-simple
     transformers
   ];
   testHaskellDepends = [
-    async base bytestring exceptions hspec hspec-expectations-lifted
-    postgresql-libpq postgresql-simple tmp-postgres
+    async
+    base
+    bytestring
+    exceptions
+    hspec
+    hspec-expectations-lifted
+    postgresql-libpq
+    postgresql-simple
+    tmp-postgres
   ];
   benchmarkHaskellDepends = [
-    base criterion deepseq postgresql-simple tmp-postgres
+    base
+    criterion
+    deepseq
+    postgresql-simple
+    tmp-postgres
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/jfischoff/pg-transact#readme";
   description = "A postgresql-simple transaction monad";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/polysemy-extra.nix b/pkgs/polysemy-extra.nix
index 5cd75a029e6cd529b7bff4f6e027e2c172ce850d..a1bee0ebf6cea5c7671f94dcfeeda4ef3de23a0c 100644
--- a/pkgs/polysemy-extra.nix
+++ b/pkgs/polysemy-extra.nix
@@ -9,16 +9,23 @@ mkDerivation {
   pname = "polysemy-extra";
   version = "0.2.1.0";
   sha256 = "523b9f267afbe492238e072fa39c1153e5fb471709d0c77802125a96494c5ec0";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
     polysemy
     polysemy-kvstore
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Extra Input and Output functions for polysemy";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/polysemy-kvstore.nix b/pkgs/polysemy-kvstore.nix
index 6d9a19506501950fac175a54c80f84ce8ded2ccb..9180bf5178bf91c5455941859b4d55d20eb8ee91 100644
--- a/pkgs/polysemy-kvstore.nix
+++ b/pkgs/polysemy-kvstore.nix
@@ -3,11 +3,18 @@ mkDerivation {
   pname = "polysemy-kvstore";
   version = "0.1.3.0";
   sha256 = "8d88fddae6477be9e36cb34d4cdbf226cc548207ef761b83a3513feb780ccbf0";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base containers polysemy ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "KVStore effect for polysemy";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/polysemy-methodology.nix b/pkgs/polysemy-methodology.nix
index 4d1679e2675904f29becacaaa54fe5a6b60a6aa1..ff14fe8598729e636087fe1f278bdf16d1e31088 100644
--- a/pkgs/polysemy-methodology.nix
+++ b/pkgs/polysemy-methodology.nix
@@ -11,16 +11,23 @@ mkDerivation {
   sha256 = "2fccb2a89981389d2a2be827025177a32f4196cd46c69992d53af8aa0b35ad9e";
   revision = "2";
   editedCabalFile = "0dpancn85f8j3pxhk43lik6fbznp502cc68rkhqkan791kh1bbc7";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     polysemy
     polysemy-kvstore
     polysemy-several
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Domain modelling algebra for polysemy";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/polysemy-path.nix b/pkgs/polysemy-path.nix
index 3a478300a43f8dcb65efa6b4dc5a2cfee9571159..49f9292dd789726cf6898691ca5786bc77350306 100644
--- a/pkgs/polysemy-path.nix
+++ b/pkgs/polysemy-path.nix
@@ -5,11 +5,18 @@ mkDerivation {
   sha256 = "d9c245e9ff1afbd519179cf3fbcfbf3934360721cfdfc35364f86e314854aa6a";
   revision = "1";
   editedCabalFile = "0x9b1zm804bnmjs0qbrx23s1mzgb6h9dqfchf8i3ri7x1sy24ibh";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base path polysemy polysemy-extra ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Polysemy versions of Path functions";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/polysemy-plugin.nix b/pkgs/polysemy-plugin.nix
index d46efadb9946053b870ab439921f0c1b8d1cf51a..3794a083893a653aabb2fe27a42d82112fb7a32d 100644
--- a/pkgs/polysemy-plugin.nix
+++ b/pkgs/polysemy-plugin.nix
@@ -1,6 +1,19 @@
-{ mkDerivation, base, Cabal, cabal-doctest, containers, doctest
-, fetchgit, ghc, ghc-tcplugins-extra, hspec, hspec-discover
-, inspection-testing, lib, polysemy, should-not-typecheck, syb
+{ mkDerivation
+, base
+, Cabal
+, cabal-doctest
+, containers
+, doctest
+, fetchgit
+, ghc
+, ghc-tcplugins-extra
+, hspec
+, hspec-discover
+, inspection-testing
+, lib
+, polysemy
+, should-not-typecheck
+, syb
 , transformers
 }:
 mkDerivation {
@@ -13,20 +26,42 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/polysemy-plugin/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
-    base containers ghc ghc-tcplugins-extra polysemy syb transformers
+    base
+    containers
+    ghc
+    ghc-tcplugins-extra
+    polysemy
+    syb
+    transformers
   ];
   testHaskellDepends = [
-    base containers doctest ghc ghc-tcplugins-extra hspec
-    inspection-testing polysemy should-not-typecheck syb transformers
+    base
+    containers
+    doctest
+    ghc
+    ghc-tcplugins-extra
+    hspec
+    inspection-testing
+    polysemy
+    should-not-typecheck
+    syb
+    transformers
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/polysemy-research/polysemy#readme";
   description = "Disambiguate obvious uses of effects";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/polysemy-several.nix b/pkgs/polysemy-several.nix
index f2fbc4611bfecf6d34b4524fd5a01c6fa4d7f170..742bc0cfcec252b38a565c9b06fbe5c57a000533 100644
--- a/pkgs/polysemy-several.nix
+++ b/pkgs/polysemy-several.nix
@@ -3,11 +3,18 @@ mkDerivation {
   pname = "polysemy-several";
   version = "0.1.1.0";
   sha256 = "dc02a59d49b4c43b94022a3ab0a6b3cc2556e76fa1077529a4c2da31dede7641";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base polysemy ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Run several effects at once, taken from the polysemy-zoo";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/polysemy-time.nix b/pkgs/polysemy-time.nix
index 9abed2ca1a58045998de1abb5ec13a2d066376bc..2fc1e7f372a8dc25e5c4c505c7bf0cb05a114986 100644
--- a/pkgs/polysemy-time.nix
+++ b/pkgs/polysemy-time.nix
@@ -14,6 +14,9 @@ mkDerivation {
   pname = "polysemy-time";
   version = "0.5.1.0";
   sha256 = "857dbbe99e6e6a1a061aa9cac88a630f2bddc0c748ed8ec8d076b3b44d11e59a";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     base
@@ -30,11 +33,15 @@ mkDerivation {
     tasty
     time
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/tek/polysemy-time#readme";
   description = "Polysemy effects for time";
   license = "BSD-2-Clause-Patent";
+  broken = false;
 }
diff --git a/pkgs/polysemy-vinyl.nix b/pkgs/polysemy-vinyl.nix
index 174c2a2eea683f4ec774bf53751fa15993b89cfe..00d920a582d1bdd9c429ea7adb165339fad112c4 100644
--- a/pkgs/polysemy-vinyl.nix
+++ b/pkgs/polysemy-vinyl.nix
@@ -12,6 +12,9 @@ mkDerivation {
   sha256 = "84cdb95360548060eeb586e9948b8a751a55e8a5b06cfc50013a3227b60dc91b";
   revision = "1";
   editedCabalFile = "13f289dxr03habyggn3vl7lzrl2r3a9r0y0bisrfmq48qaiv08n1";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     polysemy
@@ -19,10 +22,14 @@ mkDerivation {
     polysemy-several
     vinyl
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Functions for mapping vinyl records in polysemy";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/polysemy-zoo.nix b/pkgs/polysemy-zoo.nix
index a4a07430774a443ce051e094f3500128394423aa..b95e166d2f75d8d85227b15c5e80a72adf0f63ba 100644
--- a/pkgs/polysemy-zoo.nix
+++ b/pkgs/polysemy-zoo.nix
@@ -23,6 +23,9 @@ mkDerivation {
   pname = "polysemy-zoo";
   version = "0.8.0.0";
   sha256 = "8c46937c61c980ac3024c4eeb1bf32a686eb2c5bcc2a65fad25d102512c89afa";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     async
     base
@@ -60,11 +63,15 @@ mkDerivation {
     transformers
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/isovector/polysemy-zoo#readme";
   description = "Experimental, user-contributed effects and interpreters for polysemy";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/polysemy.nix b/pkgs/polysemy.nix
index bf7e3cc18dce677650fe8b1c7883d4ceb5cfc515..77723fb2d6a349b8b91ed63b71fcef8d10014745 100644
--- a/pkgs/polysemy.nix
+++ b/pkgs/polysemy.nix
@@ -27,6 +27,9 @@ mkDerivation {
   pname = "polysemy";
   version = "1.7.1.0";
   sha256 = "4c9556c0c3f38f5fa655567106ecb53cd357e6ffaf8289753ba6dc26fd4bc224";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
     async
@@ -80,11 +83,15 @@ mkDerivation {
     type-errors
     unagi-chan
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/polysemy-research/polysemy#readme";
   description = "Higher-order, low-boilerplate free monads";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/postgresql-libpq.nix b/pkgs/postgresql-libpq.nix
index 7305d9c8be68a9b1d95240c6f245ec0e2a31eac2..69b3a3684f71afc0919c54e12672e7fbecd65188 100644
--- a/pkgs/postgresql-libpq.nix
+++ b/pkgs/postgresql-libpq.nix
@@ -5,15 +5,22 @@ mkDerivation {
   sha256 = "e3e246dcd55352fce514969a72a6fe37771102034fb8e662fdc7ae780b83d6bd";
   revision = "3";
   editedCabalFile = "02cj493a2qxl5hddiq0579079s398hdqqy164pig6d61nl7q66cs";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ base Cabal ];
   libraryHaskellDepends = [ base bytestring unix ];
   librarySystemDepends = [ postgresql ];
   testHaskellDepends = [ base bytestring ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskellari/postgresql-libpq";
   description = "low-level binding to libpq";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/postgresql-migration.nix b/pkgs/postgresql-migration.nix
index ca4e031767e5ef118a7dc36dac649a8554a22954..13532d1e2eada280a6114f1df39a7fb45174c143 100644
--- a/pkgs/postgresql-migration.nix
+++ b/pkgs/postgresql-migration.nix
@@ -1,5 +1,15 @@
-{ mkDerivation, base, base64-bytestring, bytestring, cryptohash
-, directory, filepath, hspec, lib, postgresql-simple, text, time
+{ mkDerivation
+, base
+, base64-bytestring
+, bytestring
+, cryptohash
+, directory
+, filepath
+, hspec
+, lib
+, postgresql-simple
+, text
+, time
 }:
 mkDerivation {
   pname = "postgresql-migration";
@@ -7,21 +17,39 @@ mkDerivation {
   sha256 = "1a208648901a320650da06d4bde50caf95560721fd9c7aae005cc647d57b195d";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base base64-bytestring bytestring cryptohash directory filepath
-    postgresql-simple text time
+    base
+    base64-bytestring
+    bytestring
+    cryptohash
+    directory
+    filepath
+    postgresql-simple
+    text
+    time
   ];
   executableHaskellDepends = [
-    base base64-bytestring bytestring cryptohash directory
-    postgresql-simple text time
+    base
+    base64-bytestring
+    bytestring
+    cryptohash
+    directory
+    postgresql-simple
+    text
+    time
   ];
   testHaskellDepends = [ base bytestring hspec postgresql-simple ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/andrevdm/postgresql-migration";
   description = "PostgreSQL Schema Migrations";
   license = lib.licenses.bsd3;
   mainProgram = "migrate";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/postgresql-simple-migration.nix b/pkgs/postgresql-simple-migration.nix
index 065062b4df4366a73fe9271f2d0e6f0067f2ed70..be6aadaa8aa5228599a0b0c2ad37a5db62df820b 100644
--- a/pkgs/postgresql-simple-migration.nix
+++ b/pkgs/postgresql-simple-migration.nix
@@ -1,5 +1,14 @@
-{ mkDerivation, base, base64-bytestring, bytestring, cryptohash
-, directory, hspec, lib, postgresql-simple, text, time
+{ mkDerivation
+, base
+, base64-bytestring
+, bytestring
+, cryptohash
+, directory
+, hspec
+, lib
+, postgresql-simple
+, text
+, time
 }:
 mkDerivation {
   pname = "postgresql-simple-migration";
@@ -9,21 +18,37 @@ mkDerivation {
   editedCabalFile = "1a0a5295j207x0pzbhy5inv8qimrh76dmmp26zgaw073n1i8yg8j";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base base64-bytestring bytestring cryptohash directory
-    postgresql-simple time
+    base
+    base64-bytestring
+    bytestring
+    cryptohash
+    directory
+    postgresql-simple
+    time
   ];
   executableHaskellDepends = [
-    base base64-bytestring bytestring cryptohash directory
-    postgresql-simple text time
+    base
+    base64-bytestring
+    bytestring
+    cryptohash
+    directory
+    postgresql-simple
+    text
+    time
   ];
   testHaskellDepends = [ base bytestring hspec postgresql-simple ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/ameingast/postgresql-simple-migration";
   description = "PostgreSQL Schema Migrations";
   license = lib.licenses.bsd3;
   mainProgram = "migrate";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/postgresql-simple.nix b/pkgs/postgresql-simple.nix
index 233b8084abd9df4ed15f71991b0fdf20c3c78a1d..54184491aad2c26dbbccb7f80c4dfcdbdd0935ab 100644
--- a/pkgs/postgresql-simple.nix
+++ b/pkgs/postgresql-simple.nix
@@ -32,6 +32,9 @@ mkDerivation {
   sha256 = "6d90394203ea3aa27cae4492569ab14bf175cd2d30112e565ffb92dbe95ce267";
   revision = "8";
   editedCabalFile = "1qavb3qs1g307pc19k9y3yvqp0c1srwsplijvayn9ldp0bxdy6q8";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     attoparsec
@@ -71,10 +74,14 @@ mkDerivation {
     vector
   ];
   benchmarkHaskellDepends = [ base vector ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Mid-Level PostgreSQL client library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/pretty-simple.nix b/pkgs/pretty-simple.nix
index 7171590a522f42be8f55e39e4c102d15e4fe4388..47466118686c914d9c4b94cf255d4ab66778faf5 100644
--- a/pkgs/pretty-simple.nix
+++ b/pkgs/pretty-simple.nix
@@ -22,6 +22,7 @@ mkDerivation {
   sha256 = "dae179b1a967e1d443f135e5b3f5abdf378e515fb8ea86e091bc487dc1a25d4a";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
     base
@@ -41,12 +42,16 @@ mkDerivation {
     template-haskell
   ];
   benchmarkHaskellDepends = [ base criterion text ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/cdepillabout/pretty-simple";
   description = "pretty printer for data types with a 'Show' instance";
   license = lib.licenses.bsd3;
   mainProgram = "pretty-simple";
+  broken = false;
 }
diff --git a/pkgs/prettyprinter-ansi-terminal.nix b/pkgs/prettyprinter-ansi-terminal.nix
index bfb45f1f5bdb3b838f8159c0d684590445f3b375..d918d28125a36d820d550b62d0e417d0c9ccc8e1 100644
--- a/pkgs/prettyprinter-ansi-terminal.nix
+++ b/pkgs/prettyprinter-ansi-terminal.nix
@@ -15,6 +15,9 @@ mkDerivation {
   pname = "prettyprinter-ansi-terminal";
   version = "1.1.3";
   sha256 = "813739308ad6050620578994effe21058a170a341716acf52573fae42b5b1db3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ ansi-terminal base prettyprinter text ];
   testHaskellDepends = [ base doctest ];
   benchmarkHaskellDepends = [
@@ -27,11 +30,15 @@ mkDerivation {
     QuickCheck
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/quchen/prettyprinter";
   description = "ANSI terminal backend for the »prettyprinter« package";
   license = lib.licenses.bsd2;
+  broken = false;
 }
diff --git a/pkgs/primitive.nix b/pkgs/primitive.nix
index ad2442fd2a49e5d52126789c759c6f975910fff8..64b4656c16487a0f9fd983175b73029808a314c4 100644
--- a/pkgs/primitive.nix
+++ b/pkgs/primitive.nix
@@ -18,6 +18,9 @@ mkDerivation {
   pname = "primitive";
   version = "0.7.4.0";
   sha256 = "5b2d6dc2812eb2f6a115f05fcbe3e723d3aeff7894b012c617e075130581add5";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     deepseq
@@ -42,11 +45,15 @@ mkDerivation {
     tasty-bench
     transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell/primitive";
   description = "Primitive memory-related operations";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/prometheus-proc.nix b/pkgs/prometheus-proc.nix
index 35be48eb217bbf74f9f2f7d0e74daa70fdd87bf0..7bff550d7780f556de0b667c8fd58d2bce016a09 100644
--- a/pkgs/prometheus-proc.nix
+++ b/pkgs/prometheus-proc.nix
@@ -1,19 +1,40 @@
-{ mkDerivation, base, directory, filepath, lib, prometheus-client
-, regex-applicative, text, unix, unix-memory
+{ mkDerivation
+, base
+, directory
+, filepath
+, lib
+, prometheus-client
+, regex-applicative
+, text
+, unix
+, unix-memory
 }:
 mkDerivation {
   pname = "prometheus-proc";
   version = "0.1.4.0";
   sha256 = "de92520596bb07957a13cede7a0b43eb6fec5ec6f92d5b466141cf5058b02c6a";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base directory filepath prometheus-client regex-applicative text
-    unix unix-memory
+    base
+    directory
+    filepath
+    prometheus-client
+    regex-applicative
+    text
+    unix
+    unix-memory
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/fimad/prometheus-haskell";
   description = "Export metrics from /proc for the current process";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/proteaaudio-sdl.nix b/pkgs/proteaaudio-sdl.nix
index c4e02db3400000d42792b1a7f1fa73b92beb61b6..ee8484b6dd292f4ec365ce14b5d3c9bb5253f18f 100644
--- a/pkgs/proteaaudio-sdl.nix
+++ b/pkgs/proteaaudio-sdl.nix
@@ -5,14 +5,19 @@ mkDerivation {
   sha256 = "8c65a869e7f9af19fc9f7a596b5f12f1551b9008a76b5b85460f304eb6cdc662";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base bytestring ];
   librarySystemDepends = [ SDL2 ];
   libraryPkgconfigDepends = [ SDL2 ];
   libraryToolDepends = [ c2hs ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Simple audio library for SDL";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/quickcheck-dynamic.nix b/pkgs/quickcheck-dynamic.nix
index f6d2839ab7cde6d29b76e8e89a6cc754a96cc265..b3cd8e6452e946865cb64c59fb3fef378f86ee2e 100644
--- a/pkgs/quickcheck-dynamic.nix
+++ b/pkgs/quickcheck-dynamic.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "quickcheck-dynamic";
   version = "2.0.0";
   sha256 = "78082446894d9522a1e9f9589f758fef2fcb7778d9427fe8ce1cedc156ea48ed";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base mtl QuickCheck random ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/input-output-hk/quickcheck-dynamic#readme";
   description = "A library for stateful property-based testing";
   license = lib.licenses.asl20;
+  broken = false;
 }
diff --git a/pkgs/quickcheck-instances.nix b/pkgs/quickcheck-instances.nix
index a4a0986d594c063676242854e625dadd2f45a686..de4fa03155de618094e7a104dc4c70eed44cc95b 100644
--- a/pkgs/quickcheck-instances.nix
+++ b/pkgs/quickcheck-instances.nix
@@ -31,6 +31,9 @@ mkDerivation {
   pname = "quickcheck-instances";
   version = "0.3.28";
   sha256 = "c4111b7b49d5814120cb6055705d04eda7dd32a536057167c646aa77b68ccccb";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -68,11 +71,15 @@ mkDerivation {
     uuid-types
   ];
   benchmarkHaskellDepends = [ base bytestring QuickCheck ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskellari/qc-instances";
   description = "Common quickcheck instances";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/rebase.nix b/pkgs/rebase.nix
index f976214cfb614b543ab1863c8a89636650343795..1694f28b7363b13e438117df2d1fa0e926541de7 100644
--- a/pkgs/rebase.nix
+++ b/pkgs/rebase.nix
@@ -34,6 +34,9 @@ mkDerivation {
   sha256 = "0d76253ba464eee3363ff0ef4f0f470ca1711cd7acc907089b6eac15f8acad64";
   revision = "1";
   editedCabalFile = "048h2ir37j09s0z7fb364p7smyhzq6h4705qklhvylak9242gz2n";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bifunctors
@@ -63,11 +66,15 @@ mkDerivation {
     vector-instances
     void
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/nikita-volkov/rebase";
   description = "A more progressive alternative to the \"base\" package";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/refined.nix b/pkgs/refined.nix
index 19bba77fbcb65f0b936ace6c9f548465663f126a..b6b377bc78f9544c2deeb35f49fa650116be4335 100644
--- a/pkgs/refined.nix
+++ b/pkgs/refined.nix
@@ -1,21 +1,47 @@
-{ mkDerivation, aeson, base, bytestring, deepseq, exceptions
-, hashable, lib, mtl, QuickCheck, template-haskell, text
+{ mkDerivation
+, aeson
+, base
+, bytestring
+, deepseq
+, exceptions
+, hashable
+, lib
+, mtl
+, QuickCheck
+, template-haskell
+, text
 , these-skinny
 }:
 mkDerivation {
   pname = "refined";
   version = "0.8";
   sha256 = "3a477dd64a741708e32223a5deb79d297a36804ede759a8a50ed96c7bcad7f62";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base bytestring deepseq exceptions hashable mtl QuickCheck
-    template-haskell text these-skinny
+    aeson
+    base
+    bytestring
+    deepseq
+    exceptions
+    hashable
+    mtl
+    QuickCheck
+    template-haskell
+    text
+    these-skinny
   ];
   testHaskellDepends = [ base QuickCheck ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/nikita-volkov/refined";
   description = "Refinement types with static and runtime checking";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/relude.nix b/pkgs/relude.nix
index 52504119925a73ee80556abf02b5b524679a3533..7f6fb91de2fe95e919f95cb8d96245a189142af3 100644
--- a/pkgs/relude.nix
+++ b/pkgs/relude.nix
@@ -20,6 +20,9 @@ mkDerivation {
   pname = "relude";
   version = "1.1.0.0";
   sha256 = "b51df08a93ef1331dd56389e158e67ac7b68c62cc1561c2890d3572c764ab609";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -47,11 +50,15 @@ mkDerivation {
     tasty-bench
     unordered-containers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/kowainik/relude";
   description = "Safe, performant, user-friendly and lightweight Haskell Standard Library";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/rerebase.nix b/pkgs/rerebase.nix
index 7b64c9ac198f63e30c1faded45959c7c22cc7bc8..ddad44bea8e190a7e6e34f2569e9367ddf447ebe 100644
--- a/pkgs/rerebase.nix
+++ b/pkgs/rerebase.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "rerebase";
   version = "1.15.0.3";
   sha256 = "a2b18cff71a2a67c0a956385134ac2b5bbe2379a17d6dbe66bb4c0d79bd6b44b";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ rebase ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/nikita-volkov/rerebase";
   description = "Reexports from \"base\" with a bunch of other standard libraries";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/resource-pool.nix b/pkgs/resource-pool.nix
index 0c48bfb82d0db4770b848361781362781fa0c0c8..edaa09f253d7a7b66dfc85acacf68a7846231a2d 100644
--- a/pkgs/resource-pool.nix
+++ b/pkgs/resource-pool.nix
@@ -3,11 +3,18 @@ mkDerivation {
   pname = "resource-pool";
   version = "0.3.1.0";
   sha256 = "fe14a0f90526ff5e1629ff6bf19025ebb18354352718abc7814095d001f58c4e";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base primitive time ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "A high-performance striped resource pooling implementation";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/retry.nix b/pkgs/retry.nix
index 3c2cde7035edec5ecb68c926498d062be21eb38b..6578075b3a477283cba67459d9cf07c3ef8c5353 100644
--- a/pkgs/retry.nix
+++ b/pkgs/retry.nix
@@ -20,6 +20,9 @@ mkDerivation {
   pname = "retry";
   version = "0.9.3.0";
   sha256 = "c11e5dcb6fc9b7a327ebdf9188edcbe39fce64e728294e41a61e9ad94fa84ecd";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     exceptions
@@ -47,11 +50,15 @@ mkDerivation {
     transformers
     unliftio-core
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/Soostone/retry";
   description = "Retry combinators for monadic actions that may fail";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/rope-utf16-splay.nix b/pkgs/rope-utf16-splay.nix
index b08f639666805b9cd30e02a588c3830ab7bb2526..a55d27ea7bfd9db68352a7a0aad4326ff26f86f4 100644
--- a/pkgs/rope-utf16-splay.nix
+++ b/pkgs/rope-utf16-splay.nix
@@ -11,6 +11,9 @@ mkDerivation {
   pname = "rope-utf16-splay";
   version = "0.4.0.0";
   sha256 = "c189f1ccac3a2bf92dd2b7f85b194364983813d350870011ac71165f5b2f5fee";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base text ];
   testHaskellDepends = [
     base
@@ -20,11 +23,15 @@ mkDerivation {
     tasty-quickcheck
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/ollef/rope-utf16-splay";
   description = "Ropes optimised for updating using UTF-16 code units and row/column pairs";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/safe-coloured-text.nix b/pkgs/safe-coloured-text.nix
index 39b372807d16b6984f5be4c47e98643dd17ecf13..5f96c2e47f5da3915f945bc419368d8916eab923 100644
--- a/pkgs/safe-coloured-text.nix
+++ b/pkgs/safe-coloured-text.nix
@@ -11,6 +11,9 @@ mkDerivation {
   pname = "safe-coloured-text";
   version = "0.2.0.1";
   sha256 = "b1604a221ee28e672a5b876a9f368ebbd65d56cc93afeb486083857d7c9b1759";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -19,11 +22,15 @@ mkDerivation {
     validity-bytestring
     validity-text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/safe-coloured-text#readme";
   description = "Safely output coloured text";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/saltine.nix b/pkgs/saltine.nix
index e74e19a31d903f80069eb99e628e1f2be838701d..4e72a0e9df8067911dfc5d62aefaeef99b69b98c 100644
--- a/pkgs/saltine.nix
+++ b/pkgs/saltine.nix
@@ -14,6 +14,9 @@ mkDerivation {
   pname = "saltine";
   version = "0.1.1.1";
   sha256 = "a75b1aae629bef09c1b14364abbf8998420e0737bf2f3515ca18055ef336f9ad";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base bytestring hashable profunctors ];
   libraryPkgconfigDepends = [ libsodium ];
   testHaskellDepends = [
@@ -24,10 +27,14 @@ mkDerivation {
     test-framework
     test-framework-quickcheck2
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Cryptography that's easy to digest (NaCl/libsodium bindings)";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/scientific.nix b/pkgs/scientific.nix
index 9e85fbde6c2638c42be1374e0d1240fecccf4e39..8b2c14e94da3376cd2fc3a558e38b7cccfc6c848 100644
--- a/pkgs/scientific.nix
+++ b/pkgs/scientific.nix
@@ -24,6 +24,9 @@ mkDerivation {
   sha256 = "a3a121c4b3d68fb8b9f8c709ab012e48f090ed553609247a805ad070d6b343a9";
   revision = "3";
   editedCabalFile = "1n67w1b64q59nn4845z3kr8rm0x0p7bi3cyp6n1dpnfs8k4l8x2i";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     binary
@@ -49,11 +52,15 @@ mkDerivation {
     text
   ];
   benchmarkHaskellDepends = [ base criterion ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/basvandijk/scientific";
   description = "Numbers represented using scientific notation";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/scotty.nix b/pkgs/scotty.nix
index e71c7f9327c266b13814c07384d280d6f3dbe6be..cdbb05db6f6cd22440f605383628ad037e3206b4 100644
--- a/pkgs/scotty.nix
+++ b/pkgs/scotty.nix
@@ -37,6 +37,9 @@ mkDerivation {
   sha256 = "e1d77ee05eaa4b1871566b33683da9ab15dda8f7c42875701d62caf7db7defd2";
   revision = "9";
   editedCabalFile = "0d61dgx6wq682mz8ryq2a10v1z4yi0dik8b5psi0ragl2qip191j";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     base
@@ -86,11 +89,15 @@ mkDerivation {
     transformers
     weigh
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/scotty-web/scotty";
   description = "Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/sdl2-gfx.nix b/pkgs/sdl2-gfx.nix
index a090bd4424e70f41b691d7b27e963c284c27331c..2aca82b0fc42286434780db8ce24571303abcde3 100644
--- a/pkgs/sdl2-gfx.nix
+++ b/pkgs/sdl2-gfx.nix
@@ -15,6 +15,7 @@ mkDerivation {
   sha256 = "bcab7e1f8f7a60dec2db07c6680eb3f16e88511829a6ef9cd82ddce91c293565";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     lifted-base
@@ -28,11 +29,15 @@ mkDerivation {
   executableHaskellDepends = [ base sdl2 vector ];
   executableSystemDepends = [ SDL2_gfx ];
   executablePkgconfigDepends = [ SDL2 SDL2_gfx ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Haskell bindings to SDL2_gfx";
   license = lib.licenses.mit;
   mainProgram = "sdl2-gfx-example";
+  broken = false;
 }
diff --git a/pkgs/sdl2-image.nix b/pkgs/sdl2-image.nix
index d976ed46e5c188247e72d034ec4a8cbb521d6504..66b3464607201dc704e2b62d1925086a7fafe578 100644
--- a/pkgs/sdl2-image.nix
+++ b/pkgs/sdl2-image.nix
@@ -14,6 +14,7 @@ mkDerivation {
   sha256 = "d22403d966e0f18ecc33fadda8e611e2e90bc718e8d6647177f5118264a5920d";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -26,11 +27,15 @@ mkDerivation {
   executableHaskellDepends = [ base sdl2 text ];
   executableSystemDepends = [ SDL2_image ];
   executablePkgconfigDepends = [ SDL2 SDL2_image ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Haskell bindings to SDL2_image";
   license = lib.licenses.mit;
   mainProgram = "sdl2-image-example";
+  broken = false;
 }
diff --git a/pkgs/sdl2-mixer.nix b/pkgs/sdl2-mixer.nix
index 21f6272951982509b3eb30591216609198f2ca50..9d85be991c059f57be984b966dde24d5a271a879 100644
--- a/pkgs/sdl2-mixer.nix
+++ b/pkgs/sdl2-mixer.nix
@@ -16,6 +16,7 @@ mkDerivation {
   sha256 = "58141826af5d491794a74484fda770859e2271b0ede44cc75f2e562b70b7cf99";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -31,10 +32,14 @@ mkDerivation {
   executableHaskellDepends = [ base data-default-class sdl2 vector ];
   executableSystemDepends = [ SDL2_mixer ];
   executablePkgconfigDepends = [ SDL2_mixer ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Haskell bindings to SDL2_mixer";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/sdl2-ttf.nix b/pkgs/sdl2-ttf.nix
index b1e94b9789da32be9ff12f153439b5c3eba6bc82..8213057a69868f50724cf33161fd7bdced797c5e 100644
--- a/pkgs/sdl2-ttf.nix
+++ b/pkgs/sdl2-ttf.nix
@@ -16,6 +16,7 @@ mkDerivation {
   sha256 = "b60219fe8144c5d61b140b4607432b24fb93e947c504a8e2f89517175ba6a56a";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -26,10 +27,14 @@ mkDerivation {
     transformers
   ];
   libraryPkgconfigDepends = [ SDL2 SDL2_ttf ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Bindings to SDL2_ttf";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/sdl2.nix b/pkgs/sdl2.nix
index 74d2f5938d91cd555e5dee5d021c5cd5b201655e..9b7b0d5301cf35ec39b69b3cd61aff231900f475 100644
--- a/pkgs/sdl2.nix
+++ b/pkgs/sdl2.nix
@@ -32,10 +32,14 @@ mkDerivation {
   librarySystemDepends = [ SDL2 ];
   libraryPkgconfigDepends = [ SDL2 ];
   testHaskellDepends = [ base deepseq linear vector weigh ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Both high- and low-level bindings to the SDL library (version 2.0.6+).";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/semialign.nix b/pkgs/semialign.nix
index 350a4f53b3c0e68f6eb1dffea96fa9d18a32ab5f..32e23a3ab7f246e5143a9ff4743982ab97cda51e 100644
--- a/pkgs/semialign.nix
+++ b/pkgs/semialign.nix
@@ -18,6 +18,9 @@ mkDerivation {
   sha256 = "d900697041ae4b0cca3243273a2b3e80bcf74d937405d6a5ff34dc33ee952132";
   revision = "3";
   editedCabalFile = "0dbcdnksik508i12arh3s6bis6779lx5f1df0jkc0bp797inhd7f";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
@@ -31,11 +34,15 @@ mkDerivation {
     unordered-containers
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskellari/these";
   description = "Align and Zip type-classes from the common Semialign ancestor";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/serialise.nix b/pkgs/serialise.nix
index 33844d32798a459fa1c0b90b424fb2831bfb810c..33423726a7a3cf752a7aa84dab75f563821b9e32 100644
--- a/pkgs/serialise.nix
+++ b/pkgs/serialise.nix
@@ -39,6 +39,11 @@ mkDerivation {
   pname = "serialise";
   version = "0.2.6.0";
   sha256 = "93ff1888e1972999f14663072b38efcfd0c1481b4ec8e30ddc9c5ce97681a516";
+  revision = "1";
+  editedCabalFile = "0rlsi4jq2d1dak2fps5flcn27lywjlhvsi0x2k2lvnjqawnfb3f9";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     base
@@ -100,11 +105,15 @@ mkDerivation {
     vector
     zlib
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/well-typed/cborg";
   description = "A binary serialisation library for Haskell values";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/servant-client-core.nix b/pkgs/servant-client-core.nix
index a5ca50c3fd800ab813deac9a202827021c5dc11c..b66f10f8d1f313328a984f4b9a7b25b1d294d5e4 100644
--- a/pkgs/servant-client-core.nix
+++ b/pkgs/servant-client-core.nix
@@ -34,6 +34,9 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/servant-client-core/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     base
@@ -57,11 +60,15 @@ mkDerivation {
   ];
   testHaskellDepends = [ base base-compat deepseq hspec QuickCheck ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://docs.servant.dev/";
   description = "Core functionality and class for client function generation for servant APIs";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/servant-client.nix b/pkgs/servant-client.nix
index 7535d1ab52418aa41489a29eee9300dd2d1f7acb..d64115d3ebbfae20796eda061e5621755278c817 100644
--- a/pkgs/servant-client.nix
+++ b/pkgs/servant-client.nix
@@ -47,6 +47,9 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/servant-client/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     base-compat
@@ -99,11 +102,15 @@ mkDerivation {
     warp
   ];
   testToolDepends = [ hspec-discover markdown-unlit ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://docs.servant.dev/";
   description = "Automatic derivation of querying functions for servant";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/servant-effectful.nix b/pkgs/servant-effectful.nix
index 450fea63ecbade7eeb9f80e93acfa4b8c225e4d8..3fe386a01f3f6b55eb883b12c5f15f0c93b57114 100644
--- a/pkgs/servant-effectful.nix
+++ b/pkgs/servant-effectful.nix
@@ -1,5 +1,16 @@
-{ mkDerivation, base, effectful-core, fetchgit, hashable, lib, mtl
-, servant, servant-server, tasty, tasty-hunit, wai, warp
+{ mkDerivation
+, base
+, effectful-core
+, fetchgit
+, hashable
+, lib
+, mtl
+, servant
+, servant-server
+, tasty
+, tasty-hunit
+, wai
+, warp
 }:
 mkDerivation {
   pname = "servant-effectful";
@@ -10,17 +21,36 @@ mkDerivation {
     rev = "65e3041c6cfbc315b20ad22ca18f61dda104eec8";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base effectful-core hashable mtl servant servant-server wai warp
+    base
+    effectful-core
+    hashable
+    mtl
+    servant
+    servant-server
+    wai
+    warp
   ];
   testHaskellDepends = [
-    base effectful-core hashable servant servant-server tasty
+    base
+    effectful-core
+    hashable
+    servant
+    servant-server
+    tasty
     tasty-hunit
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-effectful/servant-effectful/tree/main/servant-effectful#readme";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/servant-foreign.nix b/pkgs/servant-foreign.nix
index 254868abc940c339f72dead0e98ef0e648ad590b..8ced7d4fe49e3a56c232a1f09d2a15bd80466fee 100644
--- a/pkgs/servant-foreign.nix
+++ b/pkgs/servant-foreign.nix
@@ -20,6 +20,9 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/servant-foreign/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     base-compat
@@ -30,11 +33,15 @@ mkDerivation {
   ];
   testHaskellDepends = [ base hspec servant ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://docs.servant.dev/";
   description = "Helpers for generating clients for servant APIs in any programming language";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/servant-lucid.nix b/pkgs/servant-lucid.nix
index 702260d9fa35cb29c1ff6b4ab6abbc8ddd43177d..07e04e0d4921907c1fe5218aa1feaa602861c3d7 100644
--- a/pkgs/servant-lucid.nix
+++ b/pkgs/servant-lucid.nix
@@ -13,13 +13,20 @@ mkDerivation {
   pname = "servant-lucid";
   version = "0.9.0.5";
   sha256 = "df55d4cb266bb95f31f658bef0e13c17a7b16e13068cc9931160620885911d7a";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base http-media lucid servant text ];
   testHaskellDepends = [ base lucid servant-server wai warp ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://haskell-servant.readthedocs.org/";
   description = "Servant support for lucid";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/servant-multipart-api.nix b/pkgs/servant-multipart-api.nix
index a77552165189abcb49a210601aa3b9e59c8c6f61..d36a12821be2ab41e5dd3dfafbdf4eb3363f6035 100644
--- a/pkgs/servant-multipart-api.nix
+++ b/pkgs/servant-multipart-api.nix
@@ -12,6 +12,9 @@ mkDerivation {
   sha256 = "92d5c3b1ccbcde7abcff6eb639d7dbb836222452a965e73ebd40bf775e522ebe";
   revision = "3";
   editedCabalFile = "1zhiszjg8n37g25sh2cnw509n0v4b89fd93j466f2gzwkxfaaw0m";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -19,11 +22,15 @@ mkDerivation {
     text
     transformers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-servant/servant-multipart#readme";
   description = "multipart/form-data (e.g file upload) support for servant";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/servant-multipart.nix b/pkgs/servant-multipart.nix
index 1edc16d6a573020d06ba67917981917da5e009d3..cf3139fd7db14b5e529a5c844af7262c529feae1 100644
--- a/pkgs/servant-multipart.nix
+++ b/pkgs/servant-multipart.nix
@@ -22,8 +22,11 @@ mkDerivation {
   pname = "servant-multipart";
   version = "0.12.1";
   sha256 = "c5236fa4922a869947988d52ab9f5b0a19abf57bb0467e2eb34560f8c79aa5dc";
-  revision = "3";
-  editedCabalFile = "1wkbwd6gypmv7aziaag3gzwgvvqx4bw8i4qp2vpmc7ip2ydm10ml";
+  revision = "4";
+  editedCabalFile = "0z4n3a1cdb082nwh3ig68wjk617cvwpq0n9ivsab55nvsr2wsm8q";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -50,11 +53,15 @@ mkDerivation {
     tasty-wai
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-servant/servant-multipart#readme";
   description = "multipart/form-data (e.g file upload) support for servant";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/servant-polysemy.nix b/pkgs/servant-polysemy.nix
index 960626f79bd813b5683bca96c8239966558eaa73..ac7c08c02ecc310351f97c2b7cd6a1f0a8e18087 100644
--- a/pkgs/servant-polysemy.nix
+++ b/pkgs/servant-polysemy.nix
@@ -1,7 +1,23 @@
-{ mkDerivation, base, deepseq, http-client, http-client-tls, lens
-, lib, mtl, polysemy, polysemy-plugin, polysemy-zoo, servant
-, servant-client, servant-server, servant-swagger
-, servant-swagger-ui, swagger2, text, wai, warp
+{ mkDerivation
+, base
+, deepseq
+, http-client
+, http-client-tls
+, lens
+, lib
+, mtl
+, polysemy
+, polysemy-plugin
+, polysemy-zoo
+, servant
+, servant-client
+, servant-server
+, servant-swagger
+, servant-swagger-ui
+, swagger2
+, text
+, wai
+, warp
 }:
 mkDerivation {
   pname = "servant-polysemy";
@@ -9,20 +25,50 @@ mkDerivation {
   sha256 = "11a10a26a55962dc36518ca8d1b0d21d29a6bf9bdceb54d0988642709d715e8c";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base deepseq http-client http-client-tls mtl polysemy
-    polysemy-plugin polysemy-zoo servant-client servant-server wai warp
+    base
+    deepseq
+    http-client
+    http-client-tls
+    mtl
+    polysemy
+    polysemy-plugin
+    polysemy-zoo
+    servant-client
+    servant-server
+    wai
+    warp
   ];
   executableHaskellDepends = [
-    base deepseq http-client http-client-tls lens mtl polysemy
-    polysemy-plugin polysemy-zoo servant servant-client servant-server
-    servant-swagger servant-swagger-ui swagger2 text wai warp
+    base
+    deepseq
+    http-client
+    http-client-tls
+    lens
+    mtl
+    polysemy
+    polysemy-plugin
+    polysemy-zoo
+    servant
+    servant-client
+    servant-server
+    servant-swagger
+    servant-swagger-ui
+    swagger2
+    text
+    wai
+    warp
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/AJChapman/servant-polysemy#readme";
   description = "Utilities for using servant in a polysemy stack";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/servant-server.nix b/pkgs/servant-server.nix
index ce1b1603e134ba1342ac2d9531f26157cadec4f0..eff771e3dcfaf7aac4b8c89129b88016cc950fc6 100644
--- a/pkgs/servant-server.nix
+++ b/pkgs/servant-server.nix
@@ -1,11 +1,44 @@
-{ mkDerivation, aeson, base, base-compat, base64-bytestring
-, bytestring, constraints, containers, directory, exceptions
-, fetchgit, filepath, hspec, hspec-discover, hspec-wai
-, http-api-data, http-media, http-types, lib, monad-control, mtl
-, network, network-uri, QuickCheck, resourcet, safe, servant
-, should-not-typecheck, sop-core, string-conversions, tagged
-, temporary, text, transformers, transformers-base
-, transformers-compat, wai, wai-app-static, wai-extra, warp, word8
+{ mkDerivation
+, aeson
+, base
+, base-compat
+, base64-bytestring
+, bytestring
+, constraints
+, containers
+, directory
+, exceptions
+, fetchgit
+, filepath
+, hspec
+, hspec-discover
+, hspec-wai
+, http-api-data
+, http-media
+, http-types
+, lib
+, monad-control
+, mtl
+, network
+, network-uri
+, QuickCheck
+, resourcet
+, safe
+, servant
+, should-not-typecheck
+, sop-core
+, string-conversions
+, tagged
+, temporary
+, text
+, transformers
+, transformers-base
+, transformers-compat
+, wai
+, wai-app-static
+, wai-extra
+, warp
+, word8
 }:
 mkDerivation {
   pname = "servant-server";
@@ -19,29 +52,80 @@ mkDerivation {
   postUnpack = "sourceRoot+=/servant-server/; echo source root reset to $sourceRoot";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base base-compat base64-bytestring bytestring constraints
-    containers exceptions filepath http-api-data http-media http-types
-    monad-control mtl network network-uri resourcet servant sop-core
-    string-conversions tagged text transformers transformers-base wai
-    wai-app-static word8
+    base
+    base-compat
+    base64-bytestring
+    bytestring
+    constraints
+    containers
+    exceptions
+    filepath
+    http-api-data
+    http-media
+    http-types
+    monad-control
+    mtl
+    network
+    network-uri
+    resourcet
+    servant
+    sop-core
+    string-conversions
+    tagged
+    text
+    transformers
+    transformers-base
+    wai
+    wai-app-static
+    word8
   ];
   executableHaskellDepends = [
-    aeson base base-compat servant text wai warp
+    aeson
+    base
+    base-compat
+    servant
+    text
+    wai
+    warp
   ];
   testHaskellDepends = [
-    aeson base base-compat base64-bytestring bytestring directory hspec
-    hspec-wai http-types mtl QuickCheck resourcet safe servant
-    should-not-typecheck sop-core string-conversions temporary text
-    transformers transformers-compat wai wai-extra
+    aeson
+    base
+    base-compat
+    base64-bytestring
+    bytestring
+    directory
+    hspec
+    hspec-wai
+    http-types
+    mtl
+    QuickCheck
+    resourcet
+    safe
+    servant
+    should-not-typecheck
+    sop-core
+    string-conversions
+    temporary
+    text
+    transformers
+    transformers-compat
+    wai
+    wai-extra
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://docs.servant.dev/";
   description = "A family of combinators for defining webservices APIs and serving them";
   license = lib.licenses.bsd3;
   mainProgram = "greet";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/servant-static-th.nix b/pkgs/servant-static-th.nix
index ce451b2257091f37d71e3a62bcae143cb69d66c2..6952c8da15845be97af184ddc70d4c8a7d17f93c 100644
--- a/pkgs/servant-static-th.nix
+++ b/pkgs/servant-static-th.nix
@@ -1,7 +1,25 @@
-{ mkDerivation, base, blaze-html, bytestring, containers, directory
-, doctest, filepath, Glob, hspec-wai, http-media, lib, semigroups
-, servant, servant-blaze, servant-server, tasty, tasty-hspec
-, tasty-hunit, template-haskell, text, wai
+{ mkDerivation
+, base
+, blaze-html
+, bytestring
+, containers
+, directory
+, doctest
+, filepath
+, Glob
+, hspec-wai
+, http-media
+, lib
+, semigroups
+, servant
+, servant-blaze
+, servant-server
+, tasty
+, tasty-hspec
+, tasty-hunit
+, template-haskell
+, text
+, wai
 }:
 mkDerivation {
   pname = "servant-static-th";
@@ -9,21 +27,48 @@ mkDerivation {
   sha256 = "25d4ca76d10bcaef4ae33571c3629d015b92297bb0391806d7f06f91e6327ec6";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base blaze-html bytestring containers directory filepath http-media
-    semigroups servant servant-blaze servant-server template-haskell
+    base
+    blaze-html
+    bytestring
+    containers
+    directory
+    filepath
+    http-media
+    semigroups
+    servant
+    servant-blaze
+    servant-server
+    template-haskell
     text
   ];
   testHaskellDepends = [
-    base blaze-html bytestring directory doctest filepath Glob
-    hspec-wai servant servant-blaze servant-server tasty tasty-hspec
-    tasty-hunit wai
+    base
+    blaze-html
+    bytestring
+    directory
+    doctest
+    filepath
+    Glob
+    hspec-wai
+    servant
+    servant-blaze
+    servant-server
+    tasty
+    tasty-hspec
+    tasty-hunit
+    wai
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/cdepillabout/servant-static-th";
   description = "Embed a directory of static files in your Servant server";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/servant-swagger-ui-core.nix b/pkgs/servant-swagger-ui-core.nix
index 39c1c25d984d885b18b4dc2957048d0c5b9f7d2e..bdaf988037a8bc42b761f69c4dd9b535fae43e9e 100644
--- a/pkgs/servant-swagger-ui-core.nix
+++ b/pkgs/servant-swagger-ui-core.nix
@@ -1,6 +1,17 @@
-{ mkDerivation, aeson, base, blaze-markup, bytestring, http-media
-, lib, servant, servant-blaze, servant-server, text, transformers
-, transformers-compat, wai-app-static
+{ mkDerivation
+, aeson
+, base
+, blaze-markup
+, bytestring
+, http-media
+, lib
+, servant
+, servant-blaze
+, servant-server
+, text
+, transformers
+, transformers-compat
+, wai-app-static
 }:
 mkDerivation {
   pname = "servant-swagger-ui-core";
@@ -8,15 +19,32 @@ mkDerivation {
   sha256 = "ed0bf0b2fbdb1751350df6780335de00ae08dd90ac4728a88369f4b132cf7b32";
   revision = "4";
   editedCabalFile = "16183mrmxipa3l3ffpibsrr41mbi2iikw66y80hplmnl6jjhnyzd";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base blaze-markup bytestring http-media servant servant-blaze
-    servant-server text transformers transformers-compat wai-app-static
+    aeson
+    base
+    blaze-markup
+    bytestring
+    http-media
+    servant
+    servant-blaze
+    servant-server
+    text
+    transformers
+    transformers-compat
+    wai-app-static
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-servant/servant-swagger-ui";
   description = "Servant swagger ui core components";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/servant-swagger-ui.nix b/pkgs/servant-swagger-ui.nix
index 7519f80c108102ba7752b061f684bfd9fafffb15..3094c8c66c6c3bfd761bcb1696a9ba8f34f262a2 100644
--- a/pkgs/servant-swagger-ui.nix
+++ b/pkgs/servant-swagger-ui.nix
@@ -1,5 +1,13 @@
-{ mkDerivation, aeson, base, bytestring, file-embed-lzma, lib
-, servant, servant-server, servant-swagger-ui-core, text
+{ mkDerivation
+, aeson
+, base
+, bytestring
+, file-embed-lzma
+, lib
+, servant
+, servant-server
+, servant-swagger-ui-core
+, text
 }:
 mkDerivation {
   pname = "servant-swagger-ui";
@@ -7,15 +15,28 @@ mkDerivation {
   sha256 = "efa528edc055dc6c9e83dfdfe4b892be439bbcfb83a73847f6cfdb35c42f878b";
   revision = "2";
   editedCabalFile = "05g4gnvr8ljg5mszan5cr9zzi40p6d8sr7343mm2yc3ps45vy9g1";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base bytestring file-embed-lzma servant servant-server
-    servant-swagger-ui-core text
+    aeson
+    base
+    bytestring
+    file-embed-lzma
+    servant
+    servant-server
+    servant-swagger-ui-core
+    text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-servant/servant-swagger-ui";
   description = "Servant swagger ui";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/servant-swagger.nix b/pkgs/servant-swagger.nix
index 67fb44354ecaef5f8c4f07e18b5fd12d00ae94e6..8a0af1d9e38955070d4bf78fc7560aad09b75933 100644
--- a/pkgs/servant-swagger.nix
+++ b/pkgs/servant-swagger.nix
@@ -1,31 +1,86 @@
-{ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring
-, Cabal, cabal-doctest, directory, doctest, filepath, hspec
-, hspec-discover, http-media, insert-ordered-containers, lens
-, lens-aeson, lib, QuickCheck, servant, singleton-bool, swagger2
-, template-haskell, text, time, unordered-containers, utf8-string
+{ mkDerivation
+, aeson
+, aeson-pretty
+, base
+, base-compat
+, bytestring
+, Cabal
+, cabal-doctest
+, directory
+, doctest
+, filepath
+, hspec
+, hspec-discover
+, http-media
+, insert-ordered-containers
+, lens
+, lens-aeson
+, lib
+, QuickCheck
+, servant
+, singleton-bool
+, swagger2
+, template-haskell
+, text
+, time
+, unordered-containers
+, utf8-string
 , vector
 }:
 mkDerivation {
   pname = "servant-swagger";
   version = "1.1.11";
   sha256 = "f4b985007ab0520c177f8dcf7bfabf8cc88d480e087db5ea5b1d311c079676cf";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
-    aeson aeson-pretty base base-compat bytestring hspec http-media
-    insert-ordered-containers lens QuickCheck servant singleton-bool
-    swagger2 text unordered-containers
+    aeson
+    aeson-pretty
+    base
+    base-compat
+    bytestring
+    hspec
+    http-media
+    insert-ordered-containers
+    lens
+    QuickCheck
+    servant
+    singleton-bool
+    swagger2
+    text
+    unordered-containers
   ];
   testHaskellDepends = [
-    aeson base base-compat directory doctest filepath hspec lens
-    lens-aeson QuickCheck servant swagger2 template-haskell text time
-    utf8-string vector
+    aeson
+    base
+    base-compat
+    directory
+    doctest
+    filepath
+    hspec
+    lens
+    lens-aeson
+    QuickCheck
+    servant
+    swagger2
+    template-haskell
+    text
+    time
+    utf8-string
+    vector
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-servant/servant/tree/master/servant-swagger#readme";
   description = "Generate a Swagger/OpenAPI/OAS 2.0 specification for your servant API.";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/servant.nix b/pkgs/servant.nix
index 76f7bdc59f36f7dbb48b397f2a8ddea1dce25b64..ae44195370e25d1d086178d1e5f06209ace61edc 100644
--- a/pkgs/servant.nix
+++ b/pkgs/servant.nix
@@ -38,6 +38,9 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/servant/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     aeson
     attoparsec
@@ -78,11 +81,15 @@ mkDerivation {
     transformers
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://docs.servant.dev/";
   description = "A family of combinators for defining webservices APIs";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/shake.nix b/pkgs/shake.nix
index 3fbe12c6af86c4f4bc48ecf21699ae65a7ddd70a..f691efad81e7b1f05ea96efff98127c0dac7c3a0 100644
--- a/pkgs/shake.nix
+++ b/pkgs/shake.nix
@@ -100,12 +100,16 @@ mkDerivation {
     unordered-containers
     utf8-string
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://shakebuild.com";
   description = "Build system library, like Make, but more accurate dependencies";
   license = lib.licenses.bsd3;
   mainProgram = "shake";
+  broken = false;
 }
diff --git a/pkgs/shelly.nix b/pkgs/shelly.nix
index f195e6ee89947e6af7c0838ae71e2b14ee1bd7b5..4434940a2984cbed088d505cfe4baf324c2264a0 100644
--- a/pkgs/shelly.nix
+++ b/pkgs/shelly.nix
@@ -30,6 +30,7 @@ mkDerivation {
   editedCabalFile = "07c1rjwvg2ldam6yaksvrr9f703b7d1rcw0482ns5yi2f7y1kczp";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     async
     base
@@ -64,11 +65,15 @@ mkDerivation {
     transformers
     unix-compat
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/yesodweb/Shelly.hs";
   description = "shell-like (systems) programming in Haskell";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/singleton-bool.nix b/pkgs/singleton-bool.nix
index 095b8cc3d8044184a72d931d0ca473d70d8e7f89..d376513149357ca09b51b4fe1f707657b90e9a01 100644
--- a/pkgs/singleton-bool.nix
+++ b/pkgs/singleton-bool.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "5ca3f4802ba0dd89d1817e78f7fbf6900fb5f176f10fc00bdfe395fe572383dd";
   revision = "2";
   editedCabalFile = "1l4nx664awgwzk3ih5idsgnj220jqdr1c55241xjv7fz7lwyhh5r";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base boring dec deepseq some ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/phadej/singleton-bool#readme";
   description = "Type level booleans";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/singletons.nix b/pkgs/singletons.nix
index 0e47c5e875de04542940380c8a4d3d2be933204e..7e9f7489a2b1c9184682e54ffbfb53e6e9411e45 100644
--- a/pkgs/singletons.nix
+++ b/pkgs/singletons.nix
@@ -3,13 +3,20 @@ mkDerivation {
   pname = "singletons";
   version = "3.0.2";
   sha256 = "f568ee129ef6438a4325f145f17fa4a3074b3564c72fd35ba1f68dcee14d5e82";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   testHaskellDepends = [ base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://www.github.com/goldfirere/singletons";
   description = "Basic singleton types and definitions";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/slugify.nix b/pkgs/slugify.nix
index 1b878fd52d0151768fab5c56625f3b71eeff1ed7..c58ffd2ccac01d9a1270746a9d7afe435264b7fd 100644
--- a/pkgs/slugify.nix
+++ b/pkgs/slugify.nix
@@ -1,18 +1,31 @@
-{ mkDerivation, base, hspec, hspec-discover, lib, QuickCheck, text
+{ mkDerivation
+, base
+, hspec
+, hspec-discover
+, lib
+, QuickCheck
+, text
 , unicode-transforms
 }:
 mkDerivation {
   pname = "slugify";
   version = "0.1.0.1";
   sha256 = "7b6304a31eef16fe291fd24b539a875795500e53f4b2d244a6203438c65db4c0";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base text unicode-transforms ];
   testHaskellDepends = [ base hspec QuickCheck text ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/hapytex/slugify#readme";
   description = "Convert text into slugs";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/some.nix b/pkgs/some.nix
index 7e0599d8f338230cb868a7db6ddaddaccacb039b..ed0dc780eeb94dc97303ff617ffa34b5bd99d383 100644
--- a/pkgs/some.nix
+++ b/pkgs/some.nix
@@ -5,13 +5,20 @@ mkDerivation {
   sha256 = "446f9586d1cc9b7507f08ef7b178a7cff971bcf258d9658deacb7b65f18e3874";
   revision = "1";
   editedCabalFile = "0hwq21d0y2iwcrkdhqkq76fna90dsdzrkk6ryh9hbg71lf768ih9";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base deepseq ];
   testHaskellDepends = [ base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskellari/some";
   description = "Existential type: Some";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/sop-core.nix b/pkgs/sop-core.nix
index 5629df14322625fce6e4e265b4a0376f78f4dce8..8f6cc776d937c6557af7a6885a80f00d4945cce9 100644
--- a/pkgs/sop-core.nix
+++ b/pkgs/sop-core.nix
@@ -5,11 +5,18 @@ mkDerivation {
   sha256 = "dac367f1608c9bd6c5dd1697e2a30e1b760617023b96e1df7d44c6c017999db0";
   revision = "1";
   editedCabalFile = "1d4sagrlhmvai3f4hvb9rn8aqsjbvi00z0mzv1gds9nblshk83xd";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base deepseq ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "True Sums of Products";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/souffle-haskell.nix b/pkgs/souffle-haskell.nix
index 4414c221ae080caca83bad0349006b4bda8731f7..19556ad08477ed28b22ae67579db5106b4b47a22 100644
--- a/pkgs/souffle-haskell.nix
+++ b/pkgs/souffle-haskell.nix
@@ -1,26 +1,70 @@
-{ mkDerivation, array, base, bytestring, criterion, deepseq
-, directory, filepath, hedgehog, hspec, hspec-hedgehog, lib, mtl
-, process, profunctors, temporary, text, text-short
-, type-errors-pretty, vector
+{ mkDerivation
+, array
+, base
+, bytestring
+, criterion
+, deepseq
+, directory
+, filepath
+, hedgehog
+, hspec
+, hspec-hedgehog
+, lib
+, mtl
+, process
+, profunctors
+, temporary
+, text
+, text-short
+, type-errors-pretty
+, vector
 }:
 mkDerivation {
   pname = "souffle-haskell";
   version = "3.5.0";
   sha256 = "79c9fc06da1265be3668e9ff1d23d9814d4d47a067cdb3c4f1949bea384ac3e8";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    array base bytestring deepseq directory filepath mtl process
-    profunctors temporary text text-short type-errors-pretty vector
+    array
+    base
+    bytestring
+    deepseq
+    directory
+    filepath
+    mtl
+    process
+    profunctors
+    temporary
+    text
+    text-short
+    type-errors-pretty
+    vector
   ];
   testHaskellDepends = [
-    array base directory hedgehog hspec hspec-hedgehog profunctors
-    temporary text text-short vector
+    array
+    base
+    directory
+    hedgehog
+    hspec
+    hspec-hedgehog
+    profunctors
+    temporary
+    text
+    text-short
+    vector
   ];
   benchmarkHaskellDepends = [ base criterion deepseq text vector ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/luc-tielen/souffle-haskell#README.md";
   description = "Souffle Datalog bindings for Haskell";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/split.nix b/pkgs/split.nix
index 02218df23bed06cb77300e1287e363e729547b53..2c479d96a33558f429b9ea12b6bc2a21898f97c5 100644
--- a/pkgs/split.nix
+++ b/pkgs/split.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "1dcd674f7c5f276f33300f5fd59e49d1ac6fc92ae949fd06a0f6d3e9d9ac1413";
   revision = "2";
   editedCabalFile = "1c8bcssxq5rkxkixgms6w6x6lzf4n7cxk6cx6av1dp3lixdy9j34";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   testHaskellDepends = [ base QuickCheck ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Combinator library for splitting lists";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/streaming-commons.nix b/pkgs/streaming-commons.nix
index 0bd01eee8579912f701b2ff1736ef320614e9321..63ab1b8a723269e8e18e17eed609d03c993c9e69 100644
--- a/pkgs/streaming-commons.nix
+++ b/pkgs/streaming-commons.nix
@@ -22,6 +22,9 @@ mkDerivation {
   pname = "streaming-commons";
   version = "0.2.2.4";
   sha256 = "56a1408cce710cddfb04d73757efba439c98fb8043515083a45136902214ccf2";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     async
@@ -51,11 +54,15 @@ mkDerivation {
     zlib
   ];
   benchmarkHaskellDepends = [ base bytestring deepseq gauge text ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/fpco/streaming-commons";
   description = "Common lower-level functions needed by various streaming data libraries";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/string-interpolate.nix b/pkgs/string-interpolate.nix
index 9a500ab499b0aaf185d8af61bab46766a8929d65..60b0c9807f2c5b9f3ed0a27ffd91a13955853c28 100644
--- a/pkgs/string-interpolate.nix
+++ b/pkgs/string-interpolate.nix
@@ -28,6 +28,9 @@ mkDerivation {
   sha256 = "17c214e2a644c433d79e3d6b9e5dab9077d79be9de4b9e208308e3196b82b73e";
   revision = "1";
   editedCabalFile = "1nrpng7r59a25z4qns8vy26rvp1wgn5f4bs8ism40q66ags8f2ad";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -63,11 +66,15 @@ mkDerivation {
     QuickCheck
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://gitlab.com/williamyaoh/string-interpolate/blob/master/README.md";
   description = "Haskell string/text/bytestring interpolation that just works";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/string-qq.nix b/pkgs/string-qq.nix
index 76beb9d32bfd82d90563d2f3f868dd7056e3d97b..3aef9fb63702fb05f66c2d62ecfe903fe94e58ad 100644
--- a/pkgs/string-qq.nix
+++ b/pkgs/string-qq.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "string-qq";
   version = "0.0.4";
   sha256 = "c85b9c1e27596ea8e765e4b630b7be53c331c51b680ad46cc2d248d3099fdd71";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base template-haskell ];
   testHaskellDepends = [ base HUnit text ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "QuasiQuoter for non-interpolated strings, texts and bytestrings";
   license = lib.licenses.publicDomain;
+  broken = false;
 }
diff --git a/pkgs/swagger2.nix b/pkgs/swagger2.nix
index 8f2ee2bb25cd5799ebcd643af8d1926c87239761..7359a7607f4ed12fb55a6aa6c221a8afb81ba2b5 100644
--- a/pkgs/swagger2.nix
+++ b/pkgs/swagger2.nix
@@ -1,35 +1,108 @@
-{ mkDerivation, aeson, aeson-pretty, base, base-compat-batteries
-, bytestring, Cabal, cabal-doctest, containers, cookie, doctest
-, generics-sop, Glob, hashable, hspec, hspec-discover, http-media
-, HUnit, insert-ordered-containers, lens, lib, mtl, network
-, optics-core, optics-th, QuickCheck, quickcheck-instances
-, scientific, template-haskell, text, time, transformers
-, unordered-containers, utf8-string, uuid-types, vector
+{ mkDerivation
+, aeson
+, aeson-pretty
+, base
+, base-compat-batteries
+, bytestring
+, Cabal
+, cabal-doctest
+, containers
+, cookie
+, doctest
+, generics-sop
+, Glob
+, hashable
+, hspec
+, hspec-discover
+, http-media
+, HUnit
+, insert-ordered-containers
+, lens
+, lib
+, mtl
+, network
+, optics-core
+, optics-th
+, QuickCheck
+, quickcheck-instances
+, scientific
+, template-haskell
+, text
+, time
+, transformers
+, unordered-containers
+, utf8-string
+, uuid-types
+, vector
 }:
 mkDerivation {
   pname = "swagger2";
   version = "2.8.5";
   sha256 = "660787d11c0aebd6668dcace2414d54e42fbb63dd703cd2491fb9bab4f31299b";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
-    aeson aeson-pretty base base-compat-batteries bytestring containers
-    cookie generics-sop hashable http-media insert-ordered-containers
-    lens mtl network optics-core optics-th QuickCheck scientific
-    template-haskell text time transformers unordered-containers
-    uuid-types vector
+    aeson
+    aeson-pretty
+    base
+    base-compat-batteries
+    bytestring
+    containers
+    cookie
+    generics-sop
+    hashable
+    http-media
+    insert-ordered-containers
+    lens
+    mtl
+    network
+    optics-core
+    optics-th
+    QuickCheck
+    scientific
+    template-haskell
+    text
+    time
+    transformers
+    unordered-containers
+    uuid-types
+    vector
   ];
   testHaskellDepends = [
-    aeson base base-compat-batteries bytestring containers doctest Glob
-    hashable hspec HUnit insert-ordered-containers lens mtl QuickCheck
-    quickcheck-instances template-haskell text time
-    unordered-containers utf8-string vector
+    aeson
+    base
+    base-compat-batteries
+    bytestring
+    containers
+    doctest
+    Glob
+    hashable
+    hspec
+    HUnit
+    insert-ordered-containers
+    lens
+    mtl
+    QuickCheck
+    quickcheck-instances
+    template-haskell
+    text
+    time
+    unordered-containers
+    utf8-string
+    vector
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/GetShopTV/swagger2";
   description = "Swagger 2.0 data model";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/syb.nix b/pkgs/syb.nix
index 6baf6b4c813fc3a02aab33894b0e7ee2205a314b..fe2428fddf4a391fb599375dad75325806e1edc8 100644
--- a/pkgs/syb.nix
+++ b/pkgs/syb.nix
@@ -3,13 +3,20 @@ mkDerivation {
   pname = "syb";
   version = "0.7.2.1";
   sha256 = "1807c66f77e66786739387f0ae9f16d150d1cfa9d626afcb729f0e9b442a8d96";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   testHaskellDepends = [ base containers mtl tasty tasty-hunit ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB";
   description = "Scrap Your Boilerplate";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/sydtest-discover.nix b/pkgs/sydtest-discover.nix
index f16a3bb6313f2408f6e9e8e6c84745c9e5832044..5f5bbec465c99ffb384228c3d059319895804c15 100644
--- a/pkgs/sydtest-discover.nix
+++ b/pkgs/sydtest-discover.nix
@@ -12,6 +12,7 @@ mkDerivation {
   sha256 = "fbc0b1a7bae9a40e9aec7bda706c11f6bb6cbefc840ad2ee350380cb925459d9";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     filepath
@@ -20,12 +21,16 @@ mkDerivation {
     path-io
   ];
   executableHaskellDepends = [ base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/sydtest#readme";
   description = "Automatic test suite discovery for sydtest";
   license = "unknown";
   mainProgram = "sydtest-discover";
+  broken = false;
 }
diff --git a/pkgs/sydtest.nix b/pkgs/sydtest.nix
index a63ac4eeeb09b6aaab1966fea7d9d1f7cffc6990..cc1ecec8f1db80338ba5bc7923962925091e3b7d 100644
--- a/pkgs/sydtest.nix
+++ b/pkgs/sydtest.nix
@@ -1,30 +1,89 @@
-{ mkDerivation, async, autodocodec, autodocodec-yaml, base
-, bytestring, containers, Diff, dlist, envparse, filepath, lib
-, MonadRandom, mtl, optparse-applicative, path, path-io
-, pretty-show, QuickCheck, quickcheck-io, random, random-shuffle
-, safe, safe-coloured-text, safe-coloured-text-terminfo, split, stm
-, sydtest-discover, text
+{ mkDerivation
+, async
+, autodocodec
+, autodocodec-yaml
+, base
+, bytestring
+, containers
+, Diff
+, dlist
+, envparse
+, filepath
+, lib
+, MonadRandom
+, mtl
+, optparse-applicative
+, path
+, path-io
+, pretty-show
+, QuickCheck
+, quickcheck-io
+, random
+, random-shuffle
+, safe
+, safe-coloured-text
+, safe-coloured-text-terminfo
+, split
+, stm
+, sydtest-discover
+, text
 }:
 mkDerivation {
   pname = "sydtest";
   version = "0.13.0.0";
   sha256 = "856583d832d8b9e52a4d0ba6290b70e984ad1663cb300464961800ea8c2f4a57";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    async autodocodec autodocodec-yaml base bytestring containers Diff
-    dlist envparse filepath MonadRandom mtl optparse-applicative path
-    path-io pretty-show QuickCheck quickcheck-io random random-shuffle
-    safe safe-coloured-text safe-coloured-text-terminfo split stm text
+    async
+    autodocodec
+    autodocodec-yaml
+    base
+    bytestring
+    containers
+    Diff
+    dlist
+    envparse
+    filepath
+    MonadRandom
+    mtl
+    optparse-applicative
+    path
+    path-io
+    pretty-show
+    QuickCheck
+    quickcheck-io
+    random
+    random-shuffle
+    safe
+    safe-coloured-text
+    safe-coloured-text-terminfo
+    split
+    stm
+    text
   ];
   testHaskellDepends = [
-    base bytestring path path-io QuickCheck random safe-coloured-text
-    stm text
+    base
+    bytestring
+    path
+    path-io
+    QuickCheck
+    random
+    safe-coloured-text
+    stm
+    text
   ];
   testToolDepends = [ sydtest-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/sydtest#readme";
   description = "A modern testing framework for Haskell with good defaults and advanced testing features";
   license = "unknown";
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/tasty-discover.nix b/pkgs/tasty-discover.nix
index e03846d27878b6bcee471395683846646606d27b..7ce9c94d6a7d0428c8a17dfed7f97d6c05718595 100644
--- a/pkgs/tasty-discover.nix
+++ b/pkgs/tasty-discover.nix
@@ -25,6 +25,7 @@ mkDerivation {
   editedCabalFile = "1a44ak08ja1j78lrqm46szihy9nzx2vrvvdb8bwf6961fymd5697";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
@@ -58,12 +59,16 @@ mkDerivation {
     tasty-quickcheck
     tasty-smallcheck
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-works/tasty-discover";
   description = "Test discovery for the tasty framework";
   license = lib.licenses.mit;
   mainProgram = "tasty-discover";
+  broken = false;
 }
diff --git a/pkgs/tasty-hedgehog.nix b/pkgs/tasty-hedgehog.nix
index d695a0ee65ed4fe38720a14a829d8fe9ea711605..cd9647d4eb0a0f7135b441a31bc94fe5668bd927 100644
--- a/pkgs/tasty-hedgehog.nix
+++ b/pkgs/tasty-hedgehog.nix
@@ -16,6 +16,9 @@ mkDerivation {
     rev = "4a3477578ed21aa82e5b74f387d08e5d750635d6";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base hedgehog tagged tasty ];
   testHaskellDepends = [
     base
@@ -23,11 +26,15 @@ mkDerivation {
     tasty
     tasty-expected-failure
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/qfpl/tasty-hedgehog";
   description = "Integration for tasty and hedgehog";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/tasty-hunit.nix b/pkgs/tasty-hunit.nix
index 6e06d75b74c6054cd0c5bceba240688bb033bd11..12258a67695afcc47f3e954c04b65158ee402081 100644
--- a/pkgs/tasty-hunit.nix
+++ b/pkgs/tasty-hunit.nix
@@ -9,12 +9,19 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/hunit/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base call-stack tasty ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/UnkindPartition/tasty";
   description = "HUnit support for the Tasty test framework";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/tasty-wai.nix b/pkgs/tasty-wai.nix
index 871d6f2cc518bb432bee9843f3821b1bf5b38614..4dfd076728f3e222492e3786b5ec9607cbd15ea4 100644
--- a/pkgs/tasty-wai.nix
+++ b/pkgs/tasty-wai.nix
@@ -12,6 +12,9 @@ mkDerivation {
   pname = "tasty-wai";
   version = "0.1.2.0";
   sha256 = "6f6f224d6dee893ce550f512832389a9ae0e490917a99b5362c9a4f73f16dca3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -22,10 +25,14 @@ mkDerivation {
     wai-extra
   ];
   testHaskellDepends = [ base http-types tasty wai ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Test 'wai' endpoints via Test.Tasty";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/tasty.nix b/pkgs/tasty.nix
index fc9bb65f77a9051fd479a4cf8f8888b17f93d33e..1345e387315d4153283dc85a666dc2f70d6e12f9 100644
--- a/pkgs/tasty.nix
+++ b/pkgs/tasty.nix
@@ -20,6 +20,9 @@ mkDerivation {
     fetchSubmodules = true;
   };
   postUnpack = "sourceRoot+=/core/; echo source root reset to $sourceRoot";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     ansi-terminal
     base
@@ -30,11 +33,15 @@ mkDerivation {
     transformers
     unix
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/UnkindPartition/tasty";
   description = "Modern and extensible testing framework";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/text-display.nix b/pkgs/text-display.nix
index 9fb5b8a571c3c63cb4cbe2d43b7464fa519d3c83..404953f8c547a96bc30728897e87b11e4ebf8075 100644
--- a/pkgs/text-display.nix
+++ b/pkgs/text-display.nix
@@ -1,19 +1,37 @@
-{ mkDerivation, base, bytestring, hspec, lib, quickcheck-text
-, should-not-typecheck, text
+{ mkDerivation
+, base
+, bytestring
+, hspec
+, lib
+, quickcheck-text
+, should-not-typecheck
+, text
 }:
 mkDerivation {
   pname = "text-display";
   version = "0.0.3.0";
   sha256 = "4c7b94ba7776874f4dbbf0a686e8039fd1d174af7ba7477bac92c8af198d6fae";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base bytestring text ];
   testHaskellDepends = [
-    base bytestring hspec quickcheck-text should-not-typecheck text
+    base
+    bytestring
+    hspec
+    quickcheck-text
+    should-not-typecheck
+    text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-text/text-display#readme";
   description = "A typeclass for user-facing output";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/text-metrics.nix b/pkgs/text-metrics.nix
index 19123b21017ceeeb7411647b5f54f15845a36e7a..2d0ac265b534c80b03fe1ae348187354b9b35487 100644
--- a/pkgs/text-metrics.nix
+++ b/pkgs/text-metrics.nix
@@ -1,5 +1,14 @@
-{ mkDerivation, base, containers, criterion, deepseq, hspec, lib
-, QuickCheck, text, vector, weigh
+{ mkDerivation
+, base
+, containers
+, criterion
+, deepseq
+, hspec
+, lib
+, QuickCheck
+, text
+, vector
+, weigh
 }:
 mkDerivation {
   pname = "text-metrics";
@@ -7,14 +16,21 @@ mkDerivation {
   sha256 = "bdd730a8f1ebc98a2d56edd73d94ebba6062ee1b49d4d019ffc2c37eaadd836e";
   revision = "2";
   editedCabalFile = "0h146i2dvv21nc5z1x9a5a9c2v5ml2kvd10krd5p5aaqpng6i1g4";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base containers text vector ];
   testHaskellDepends = [ base hspec QuickCheck text ];
   benchmarkHaskellDepends = [ base criterion deepseq text weigh ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/mrkkrp/text-metrics";
   description = "Calculate various string metrics efficiently";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/text-zipper.nix b/pkgs/text-zipper.nix
index e93a95f69720e231faa2b75a95a327ea1395b8f1..899f24f1b93166aaa6cb2faba3d9bbe491111e89 100644
--- a/pkgs/text-zipper.nix
+++ b/pkgs/text-zipper.nix
@@ -11,14 +11,20 @@ mkDerivation {
   pname = "text-zipper";
   version = "0.12";
   sha256 = "86aba7244c9ed0d8e24e9d1fa64ee317a062e7bd777018053517daefb0696702";
+  isLibrary = true;
+  isExecutable = false;
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [ base deepseq text vector ];
   testHaskellDepends = [ base hspec QuickCheck text ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/jtdaugherty/text-zipper/";
   description = "A text editor zipper library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/th-extras.nix b/pkgs/th-extras.nix
index c7d15fdf20c1c182aba0eb5fc622c2ebb3318d5f..c7f7c4df82c5a3a6443f84fad021bc5a742358e5 100644
--- a/pkgs/th-extras.nix
+++ b/pkgs/th-extras.nix
@@ -10,6 +10,9 @@ mkDerivation {
   pname = "th-extras";
   version = "0.0.0.6";
   sha256 = "02bf23940c0233a6ef6f61868e827ebd4554afe8d71cef2a1eb8e286a7f07c4a";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
@@ -17,11 +20,15 @@ mkDerivation {
     template-haskell
     th-abstraction
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/mokus0/th-extras";
   description = "A grab bag of functions for use with Template Haskell";
   license = lib.licenses.publicDomain;
+  broken = false;
 }
diff --git a/pkgs/th-lift-instances.nix b/pkgs/th-lift-instances.nix
index ac155b86a258311dbf30761a309fa846a6cee017..ed7f3df89cdbf8bc6f6c785b05e099cb10134d9f 100644
--- a/pkgs/th-lift-instances.nix
+++ b/pkgs/th-lift-instances.nix
@@ -14,6 +14,9 @@ mkDerivation {
   pname = "th-lift-instances";
   version = "0.1.20";
   sha256 = "f533c3f95addcca461a0ccd1aafef75dd801bfa6599c0d1184d54bfffb61d870";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -33,11 +36,15 @@ mkDerivation {
     text
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/bennofs/th-lift-instances/";
   description = "Lift instances for template-haskell for common data types";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/these-skinny.nix b/pkgs/these-skinny.nix
index 387a8e21e7400238c02cbf91f0b03f42f368848c..1c6e340e59ffc769038607b6791b0d17fe42c783 100644
--- a/pkgs/these-skinny.nix
+++ b/pkgs/these-skinny.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "726933193bb33d9731a2ed794c07c3ff8952fb0baef5ebbd7dc3b2a3e5746cd9";
   revision = "1";
   editedCabalFile = "1paqqcdbqr91gvvs0anq30pkdd37g70ql4v11lszl6dzjl6yy3d5";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base deepseq ghc-prim ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/chessai/these-skinny";
   description = "A fork of the 'these' package without the dependency bloat";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/these.nix b/pkgs/these.nix
index 716277969cce46a106f06098a082a83caab9f6a4..5955b275415156969fbbd799c601215c42ecac42 100644
--- a/pkgs/these.nix
+++ b/pkgs/these.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "d798c9f56e17def441e8f51e54cc11afdb3e76c6a9d1e9ee154e9a78da0bf508";
   revision = "6";
   editedCabalFile = "12ll5l8m482qkb8zn79vx51bqlwc89fgixf8jv33a32b4qzc3499";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ assoc base binary deepseq hashable ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskellari/these";
   description = "An either-or-both data type";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/tidal.nix b/pkgs/tidal.nix
index bffe676f34c63fd9e1fb85695d3f19600e6f9d28..6eb1aef316e8099d07d55d2592e62bdc7e901c89 100644
--- a/pkgs/tidal.nix
+++ b/pkgs/tidal.nix
@@ -26,6 +26,8 @@ mkDerivation {
   sha256 = "093611c3d977bc5972a4446573de5358e80ef015185ed84ad27af82415040000";
   revision = "1";
   editedCabalFile = "0mnxl1ynxf2cgqlrbkshw8qngiw7b6lf0lsjkd6hjhkh2xbxgxzx";
+  isLibrary = true;
+  isExecutable = false;
   enableSeparateDataOutput = true;
   libraryHaskellDepends = [
     base
@@ -54,11 +56,15 @@ mkDerivation {
     parsec
   ];
   benchmarkHaskellDepends = [ base criterion weigh ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://tidalcycles.org/";
   description = "Pattern language for improvised music";
   license = lib.licenses.gpl3Only;
+  broken = false;
 }
diff --git a/pkgs/time-compat.nix b/pkgs/time-compat.nix
index 6e2431480ba6b320eb2dbe9d1ac499565290056c..443529e0d4317c2eb8c3f491667c9b6609ab60f1 100644
--- a/pkgs/time-compat.nix
+++ b/pkgs/time-compat.nix
@@ -19,6 +19,9 @@ mkDerivation {
   sha256 = "ad07bb00eb9678c2136d3680752b00acc4cbc522654bb3199bf31c61ef1e6b80";
   revision = "4";
   editedCabalFile = "1n39yfk21xz8y1xvkh01651yysk2zp5qac22l5pq2hi7scczmxaw";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     base-orphans
@@ -39,11 +42,15 @@ mkDerivation {
     tasty-quickcheck
     time
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskellari/time-compat";
   description = "Compatibility package for time";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/time-effectful.nix b/pkgs/time-effectful.nix
index 36ff42455fc17b9032e1c4d7bbe1bff6b9d551e4..8765b72257341a809534c52be673dc33e2cfdfc2 100644
--- a/pkgs/time-effectful.nix
+++ b/pkgs/time-effectful.nix
@@ -1,5 +1,11 @@
-{ mkDerivation, base, effectful-core, fetchgit, lib, tasty
-, tasty-hunit, time
+{ mkDerivation
+, base
+, effectful-core
+, fetchgit
+, lib
+, tasty
+, tasty-hunit
+, time
 }:
 mkDerivation {
   pname = "time-effectful";
@@ -10,14 +16,25 @@ mkDerivation {
     rev = "e212239b685e1ecf7ee95dd1e944cc563351907f";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base effectful-core time ];
   testHaskellDepends = [
-    base effectful-core tasty tasty-hunit time
+    base
+    effectful-core
+    tasty
+    tasty-hunit
+    time
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-effectful/time-effectful#readme";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/type-equality.nix b/pkgs/type-equality.nix
index ff355c8be651924f077bc24e97cb0715906c110d..1489ac82ab97108d7f36aa3a4d50185a90848940 100644
--- a/pkgs/type-equality.nix
+++ b/pkgs/type-equality.nix
@@ -5,12 +5,19 @@ mkDerivation {
   sha256 = "4728b502a211454ef682a10d7a3e817c22d06ba509df114bb267ef9d43a08ce8";
   revision = "4";
   editedCabalFile = "0sajw67mmk5syhbrwx4bz82j5cjhm04n4kjl0pp3dnphxg1m5nbw";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/hesselink/type-equality";
   description = "Data.Type.Equality compat package";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/type-errors-pretty.nix b/pkgs/type-errors-pretty.nix
index b4578211384a2fac096bcb80f098f8f9636a4866..5c82144e9957c45a98b3748732d77e9e347bd932 100644
--- a/pkgs/type-errors-pretty.nix
+++ b/pkgs/type-errors-pretty.nix
@@ -3,13 +3,20 @@ mkDerivation {
   pname = "type-errors-pretty";
   version = "0.0.1.2";
   sha256 = "cb2cfc24870d02a1eb96565eae12e1b28a11206b78a9ed87cca59dc36b59ed07";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   testHaskellDepends = [ base doctest Glob ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/kowainik/type-errors-pretty";
   description = "Combinators for writing pretty type errors easily";
   license = lib.licenses.mpl20;
+  broken = false;
 }
diff --git a/pkgs/type-errors.nix b/pkgs/type-errors.nix
index 9544ac1c4fbde3c6a633742a741b9c99fa59d788..04ef8c45293075cedfd5885118d49d88cf4a4e2a 100644
--- a/pkgs/type-errors.nix
+++ b/pkgs/type-errors.nix
@@ -13,6 +13,9 @@ mkDerivation {
   sha256 = "174d509c30ec806117a244add923fee578ba5f3505b0156f4e03a32023892eb4";
   revision = "3";
   editedCabalFile = "0ig8qd2g8rd5n78039xhbq7n8r514f8kvbh0mgajav2a5lp549s1";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     first-class-families
@@ -28,11 +31,15 @@ mkDerivation {
     template-haskell
     th-abstraction
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/isovector/type-errors#readme";
   description = "Tools for writing better type errors";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/typerep-map.nix b/pkgs/typerep-map.nix
index 8670f918cc0f600cd7395f2119c268011905b79b..09f5b2abadf30645717ee7ad89351899953343e7 100644
--- a/pkgs/typerep-map.nix
+++ b/pkgs/typerep-map.nix
@@ -1,6 +1,19 @@
-{ mkDerivation, base, containers, criterion, deepseq, dependent-map
-, dependent-sum, fetchgit, ghc-prim, ghc-typelits-knownnat
-, hedgehog, hspec, hspec-hedgehog, lib, primitive, vector
+{ mkDerivation
+, base
+, containers
+, criterion
+, deepseq
+, dependent-map
+, dependent-sum
+, fetchgit
+, ghc-prim
+, ghc-typelits-knownnat
+, hedgehog
+, hspec
+, hspec-hedgehog
+, lib
+, primitive
+, vector
 }:
 mkDerivation {
   pname = "typerep-map";
@@ -11,21 +24,41 @@ mkDerivation {
     rev = "75b7cd5d45986be07420a6821d352ad2adc0b697";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base containers deepseq ghc-prim primitive vector
+    base
+    containers
+    deepseq
+    ghc-prim
+    primitive
+    vector
   ];
   testHaskellDepends = [
-    base ghc-typelits-knownnat hedgehog hspec hspec-hedgehog
+    base
+    ghc-typelits-knownnat
+    hedgehog
+    hspec
+    hspec-hedgehog
   ];
   benchmarkHaskellDepends = [
-    base criterion deepseq dependent-map dependent-sum
+    base
+    criterion
+    deepseq
+    dependent-map
+    dependent-sum
     ghc-typelits-knownnat
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/kowainik/typerep-map";
   description = "Efficient implementation of a dependent map with types as keys";
   license = lib.licenses.mpl20;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/unicode-collation.nix b/pkgs/unicode-collation.nix
index afd9f4e314076c1f0b587d61010c1fbbcbf478a4..46103768660bc1ec8a0e1e45ee6316eca6129e65 100644
--- a/pkgs/unicode-collation.nix
+++ b/pkgs/unicode-collation.nix
@@ -23,6 +23,7 @@ mkDerivation {
   sha256 = "ec54952221a8bb79d5dbd9abd4501ffcce4be07fbe500928394c108ea010cb66";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     binary
@@ -50,11 +51,15 @@ mkDerivation {
     text
     text-icu
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/jgm/unicode-collation";
   description = "Haskell implementation of the Unicode Collation Algorithm";
   license = lib.licenses.bsd2;
+  broken = false;
 }
diff --git a/pkgs/unicode-data.nix b/pkgs/unicode-data.nix
index 91b49480afdfb2a898f48590ace8236099a830e0..a248300a2847e48c8dc8542c185ed835b6e335f6 100644
--- a/pkgs/unicode-data.nix
+++ b/pkgs/unicode-data.nix
@@ -13,15 +13,20 @@ mkDerivation {
   sha256 = "4890d5a26cae879ea573dc07408e833ad49937a9a551a3bbdc4fa77718644127";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   testHaskellDepends = [ base hspec ];
   testToolDepends = [ hspec-discover ];
   benchmarkHaskellDepends = [ base deepseq tasty tasty-bench ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/composewell/unicode-data";
   description = "Access Unicode Character Database (UCD)";
   license = lib.licenses.asl20;
+  broken = false;
 }
diff --git a/pkgs/unicode-transforms.nix b/pkgs/unicode-transforms.nix
index 83ea2637f94951ea3c8636e724d98a9bdb94fdd7..c46495c7c29e8be29bd2758170ffbdd193fc0339 100644
--- a/pkgs/unicode-transforms.nix
+++ b/pkgs/unicode-transforms.nix
@@ -18,10 +18,11 @@ mkDerivation {
   pname = "unicode-transforms";
   version = "0.4.0.1";
   sha256 = "3278e1e1d648da4bcd7368658ae091a89080e88a2f44db9df5136711e99649fc";
-  revision = "1";
-  editedCabalFile = "0ml5j3j3dan7fgbyd3vgmlrij7bgszgfh244b1sppciis1v4m94p";
+  revision = "2";
+  editedCabalFile = "1imm3svpz2shilj2kmmmcyy5yd4c1mpmz5v1gvjrr98hrab2i9x7";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -48,11 +49,15 @@ mkDerivation {
     tasty-bench
     text
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/composewell/unicode-transforms";
   description = "Unicode normalization";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/universe-base.nix b/pkgs/universe-base.nix
index 90451507185300f38fd6a27233ae55d4a2d66c2d..cb81b787cea3e1f765c18e527ddc3b52df7e00ae 100644
--- a/pkgs/universe-base.nix
+++ b/pkgs/universe-base.nix
@@ -1,4 +1,9 @@
-{ mkDerivation, base, containers, lib, QuickCheck, tagged
+{ mkDerivation
+, base
+, containers
+, lib
+, QuickCheck
+, tagged
 , transformers
 }:
 mkDerivation {
@@ -7,13 +12,20 @@ mkDerivation {
   sha256 = "c59dfe99b76435d13483eff888e020a282ae8451b7b692dc98f348dcec95db52";
   revision = "3";
   editedCabalFile = "0hnd5vxsncwyjsindfmsvp9jbixanhmzczhrmd8s8g6imgb0mzyk";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base containers tagged transformers ];
   testHaskellDepends = [ base containers QuickCheck ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/dmwit/universe";
   description = "A class for finite and recursively enumerable types";
   license = lib.licenses.bsd3;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/unordered-containers.nix b/pkgs/unordered-containers.nix
index dfb2eefbdb8ef4894ba11ae040f396395454385b..762caacd1356bc4919cb8b19af3ce71298c47bc7 100644
--- a/pkgs/unordered-containers.nix
+++ b/pkgs/unordered-containers.nix
@@ -24,6 +24,9 @@ mkDerivation {
   sha256 = "1b27bec5e0d522b27a6029ebf4c4a6d40acbc083c787008e32fb55c4b1d128d2";
   revision = "1";
   editedCabalFile = "0fcax3apnpxxy9maymclr6s2b4c28d3pkl3plbg0lv1mn0mh84fv";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base deepseq hashable template-haskell ];
   testHaskellDepends = [
     base
@@ -49,11 +52,15 @@ mkDerivation {
     random
     tasty-bench
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell-unordered-containers/unordered-containers";
   description = "Efficient hashing-based container types";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/validity-aeson.nix b/pkgs/validity-aeson.nix
index 7ec82ff5feaae7dcc03eb4fad4f0710e95bfe70e..198948ffbae2c0f71fe29d3106d9a39977dac23a 100644
--- a/pkgs/validity-aeson.nix
+++ b/pkgs/validity-aeson.nix
@@ -1,21 +1,40 @@
-{ mkDerivation, aeson, base, hspec, lib, validity
-, validity-scientific, validity-text, validity-unordered-containers
+{ mkDerivation
+, aeson
+, base
+, hspec
+, lib
+, validity
+, validity-scientific
+, validity-text
+, validity-unordered-containers
 , validity-vector
 }:
 mkDerivation {
   pname = "validity-aeson";
   version = "0.2.0.5";
   sha256 = "b232c3bb0a3a1ae342f41c42eb90e8931421e409ed4930c2b89246a521ae623e";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    aeson base validity validity-scientific validity-text
-    validity-unordered-containers validity-vector
+    aeson
+    base
+    validity
+    validity-scientific
+    validity-text
+    validity-unordered-containers
+    validity-vector
   ];
   testHaskellDepends = [ aeson base hspec validity ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for aeson";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-bytestring.nix b/pkgs/validity-bytestring.nix
index 8682ceaacf7815cfb7aa9787c06629d2f35d5fc5..5c871a2b2143d6b3121906bafa580461830145e0 100644
--- a/pkgs/validity-bytestring.nix
+++ b/pkgs/validity-bytestring.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "validity-bytestring";
   version = "0.4.1.1";
   sha256 = "7db8912c29ceff3fd8943a61845f9c0738d7238ca49bce2e6f3c6bc490bd6732";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base bytestring validity ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for bytestring";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-case-insensitive.nix b/pkgs/validity-case-insensitive.nix
index c838f45cb86c2e5b3312e0db97a0cb15f08e439f..1a8104449875857d04028a48a277b62503bd33f7 100644
--- a/pkgs/validity-case-insensitive.nix
+++ b/pkgs/validity-case-insensitive.nix
@@ -1,19 +1,35 @@
-{ mkDerivation, base, case-insensitive, genvalidity-hspec, hspec
-, lib, validity
+{ mkDerivation
+, base
+, case-insensitive
+, genvalidity-hspec
+, hspec
+, lib
+, validity
 }:
 mkDerivation {
   pname = "validity-case-insensitive";
   version = "0.0.0.0";
   sha256 = "2d5896b50bcfa69f68242a05ad6d08bc8b61975ab5041749ecc5551cf7ebb71c";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base case-insensitive validity ];
   testHaskellDepends = [
-    base case-insensitive genvalidity-hspec hspec validity
+    base
+    case-insensitive
+    genvalidity-hspec
+    hspec
+    validity
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for case-insensitive";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-containers.nix b/pkgs/validity-containers.nix
index 459b2f4c3e9beac60065434a50b1a0957cacfda6..2d7c8ef6ed1d1e4fbb5612ff68bd88135ad0677b 100644
--- a/pkgs/validity-containers.nix
+++ b/pkgs/validity-containers.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "validity-containers";
   version = "0.5.0.4";
   sha256 = "8de2ac38381ecc4fd7f3bfe48b2a398de8b9e018ddf84420178d94dc80b985e3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base containers validity ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for containers";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-path.nix b/pkgs/validity-path.nix
index 16324f8e9e9cc8cb62e922b5b8cb019d629d6e28..17b04e051100a37345e78c6629a061c77e5f130c 100644
--- a/pkgs/validity-path.nix
+++ b/pkgs/validity-path.nix
@@ -1,19 +1,37 @@
-{ mkDerivation, base, filepath, genvalidity-hspec, hspec, lib, path
+{ mkDerivation
+, base
+, filepath
+, genvalidity-hspec
+, hspec
+, lib
+, path
 , validity
 }:
 mkDerivation {
   pname = "validity-path";
   version = "0.4.0.1";
   sha256 = "fda2d4f9f453e2c51d62c549ce7dd39390b834558b7aa8a527a3978b9f14e002";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base filepath path validity ];
   testHaskellDepends = [
-    base filepath genvalidity-hspec hspec path validity
+    base
+    filepath
+    genvalidity-hspec
+    hspec
+    path
+    validity
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for Path";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-persistent.nix b/pkgs/validity-persistent.nix
index 4c015a3f967a48f0a281381b9db87be16fd9cdf8..24cdaed7b2b644b6ee84b2a463185a6ad4573dfd 100644
--- a/pkgs/validity-persistent.nix
+++ b/pkgs/validity-persistent.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "validity-persistent";
   version = "0.0.0.0";
   sha256 = "cc38e8f31ef26e1d9a277181792902e568b71e4a159d006e08738e222d8f7e0a";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base hspec persistent validity ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://cs-syd.eu";
   description = "Validity instances for persistent-related types";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-primitive.nix b/pkgs/validity-primitive.nix
index 4547fe923671bc3e19483f506babe0a5d987e153..a5e2b2d4c31b31ea366b9a859a97f598bde60de9 100644
--- a/pkgs/validity-primitive.nix
+++ b/pkgs/validity-primitive.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "validity-primitive";
   version = "0.0.0.1";
   sha256 = "3ecdef8e94f2a51b0bbcf807b22cc153eeb072f4386d4a8da388898c43f23c65";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base primitive validity ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for primitive";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-scientific.nix b/pkgs/validity-scientific.nix
index 635477507c0707a61ee3a0080f3904168c712148..f880d1e44d7f390d1803880e6ce9d264ed124088 100644
--- a/pkgs/validity-scientific.nix
+++ b/pkgs/validity-scientific.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "validity-scientific";
   version = "0.2.0.3";
   sha256 = "773a4a35933637d0bade859dd0e8acadc781d9ccd3b057d60e7ffaaa20e5186f";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base scientific validity ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for scientific";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-text.nix b/pkgs/validity-text.nix
index 9b9fe080bec900edd182aa35deea90425389573e..40a0d3d082c102dcb41838c552c67a7a7bc8de68 100644
--- a/pkgs/validity-text.nix
+++ b/pkgs/validity-text.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "validity-text";
   version = "0.3.1.3";
   sha256 = "7aee83b507181886d824a0c45b835888494874d7d22f1aa5859062354a93fd45";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base bytestring text validity ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for text";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-time.nix b/pkgs/validity-time.nix
index bb1c25b1d656029f7db96c751b3b3f74834bb6e9..84e1f6f300f2d87b324720bf6dfd588558b477bc 100644
--- a/pkgs/validity-time.nix
+++ b/pkgs/validity-time.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "validity-time";
   version = "0.5.0.0";
   sha256 = "610ab49ee19f81da54072e54468d96dfd00e5f46d29ddbbc63f23498a0d763c6";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base time validity ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for time";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-unordered-containers.nix b/pkgs/validity-unordered-containers.nix
index 14ec2d646e81115a512ed1c76b1fa43b00300bf2..af152e5b4fd8f93ee64d1b46bfe4baa2d9ef789e 100644
--- a/pkgs/validity-unordered-containers.nix
+++ b/pkgs/validity-unordered-containers.nix
@@ -1,17 +1,32 @@
-{ mkDerivation, base, hashable, lib, unordered-containers, validity
+{ mkDerivation
+, base
+, hashable
+, lib
+, unordered-containers
+, validity
 }:
 mkDerivation {
   pname = "validity-unordered-containers";
   version = "0.2.0.3";
   sha256 = "f20d6b20b9695379f3478b357cd7c0968c3726ef4336eb0c652b84a34e332a87";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
-    base hashable unordered-containers validity
+    base
+    hashable
+    unordered-containers
+    validity
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for unordered-containers";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-uuid.nix b/pkgs/validity-uuid.nix
index bc48f240e9f91db6b798d756ecc960861afff907..6e7b21d6609d8ceb374810e31708f12b55cfca92 100644
--- a/pkgs/validity-uuid.nix
+++ b/pkgs/validity-uuid.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "validity-uuid";
   version = "0.1.0.3";
   sha256 = "343529cf3d3cafb63277fe8df7154c77593903284752a2cccb5a1f50114e9fd4";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base uuid validity ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for uuid";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity-vector.nix b/pkgs/validity-vector.nix
index bfa1e2b8b229f4ef31030f295181668d747d7e47..dc7922882cca41d18a916e04d46e6870f198216d 100644
--- a/pkgs/validity-vector.nix
+++ b/pkgs/validity-vector.nix
@@ -3,12 +3,19 @@ mkDerivation {
   pname = "validity-vector";
   version = "0.2.0.3";
   sha256 = "3e6c66c10220da63a9d02f77df6394a1428332295961ac948b648199e0686e49";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base hashable validity vector ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity instances for vector";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/validity.nix b/pkgs/validity.nix
index b98faf9d50a7476c5c7f7139b8ac0491f45477fc..b98b493b43fbfe34336e8a8df74415697af2c874 100644
--- a/pkgs/validity.nix
+++ b/pkgs/validity.nix
@@ -3,13 +3,20 @@ mkDerivation {
   pname = "validity";
   version = "0.12.0.1";
   sha256 = "1c3ce2052b73a47bd6ea6cb757e0dac5cf1cacf3558cb06b5ab725ad30d73ec9";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base ];
   testHaskellDepends = [ base hspec ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/NorfairKing/validity#readme";
   description = "Validity typeclass";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/vault.nix b/pkgs/vault.nix
index 34ae89743a1ff476ec7e6e13216e949a08035e7f..8f21612c4580e00ad296c64f02f4be70b6d4c5a0 100644
--- a/pkgs/vault.nix
+++ b/pkgs/vault.nix
@@ -11,17 +11,24 @@ mkDerivation {
   sha256 = "ac2a6b6adf58598c5c8faa931ae961a8a2aa50ddb2f0f7a2044ff6e8c3d433a0";
   revision = "2";
   editedCabalFile = "1bjwv3nv8jfhrdxa5kn3gvgxmyalpq7592bvyl7bpvcc7bbkfkf3";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     containers
     hashable
     unordered-containers
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/HeinrichApfelmus/vault";
   description = "a persistent store for values of arbitrary types";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/vector-algorithms.nix b/pkgs/vector-algorithms.nix
index 5b72fa9085063f77bc7df97eea49786cbeb6096b..13715dbac163821b10c662c3a6be98fb09d75d06 100644
--- a/pkgs/vector-algorithms.nix
+++ b/pkgs/vector-algorithms.nix
@@ -15,6 +15,9 @@ mkDerivation {
   sha256 = "2ba7c0d3a8f26ef3ada24ff4abe81609225ecbab3b5754f048f8a0a3ecc33841";
   revision = "1";
   editedCabalFile = "1bma0m4g7770y4xnqsinspqkgf4swpdwddfbcby81szjxd8mik1l";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bitvec
@@ -30,11 +33,15 @@ mkDerivation {
     vector
   ];
   benchmarkHaskellDepends = [ base mwc-random vector ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/erikd/vector-algorithms/";
   description = "Efficient algorithms for vector arrays";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/vector.nix b/pkgs/vector.nix
index d274c6c67a1fe7665798a3470f5fcd4dcad19126..e0b82c357c50b7e49010ce6024fd5cc821e5aca1 100644
--- a/pkgs/vector.nix
+++ b/pkgs/vector.nix
@@ -23,6 +23,9 @@ mkDerivation {
   sha256 = "c5d3167d15e12f52e00879ddf304a591672a74e369cc47bc5c7fa1d5a8d15b4f";
   revision = "1";
   editedCabalFile = "12cwdaqsy9dv7j7cwq6r6kdyfxqiya8khm6ccaabjhhpa2aqwljl";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base deepseq primitive vector-stream ];
   testHaskellDepends = [
     base
@@ -40,11 +43,15 @@ mkDerivation {
     transformers
   ];
   benchmarkHaskellDepends = [ base random tasty tasty-bench ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/haskell/vector";
   description = "Efficient Arrays";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/vinyl.nix b/pkgs/vinyl.nix
index 48556f36933a8fe9d5a09b1bfa66aaa6b257938a..ae4e32386ec6478f6e9fc23a374f4137a4fcc2aa 100644
--- a/pkgs/vinyl.nix
+++ b/pkgs/vinyl.nix
@@ -24,6 +24,9 @@ mkDerivation {
   pname = "vinyl";
   version = "0.14.3";
   sha256 = "e6789cbf9d3db493065cc85251e1a4596e4ab561c857d2757ae2593dd53ce6d2";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ array base deepseq ghc-prim ];
   testHaskellDepends = [
     aeson
@@ -48,10 +51,14 @@ mkDerivation {
     tagged
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Extensible Records";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/vty.nix b/pkgs/vty.nix
index 4192d8003985664acd519307c4d919b2ce71690e..2d2735a6b0a129acd46ba22a9fbde75ac99c3c66 100644
--- a/pkgs/vty.nix
+++ b/pkgs/vty.nix
@@ -40,6 +40,7 @@ mkDerivation {
   sha256 = "67e1376b735232c3a5e7fa3c3eff00fdc457bdd5ba7dcf3a758aee6b8b60cdf0";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     ansi-terminal
     base
@@ -100,11 +101,15 @@ mkDerivation {
     utf8-string
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/jtdaugherty/vty";
   description = "A simple terminal UI library";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/wai-middleware-heartbeat.nix b/pkgs/wai-middleware-heartbeat.nix
index 30e3d857254cfbb3737549f73ebe83a11d9d3c8c..d467e5b63e28264b257a0a2a6ae125574c50e755 100644
--- a/pkgs/wai-middleware-heartbeat.nix
+++ b/pkgs/wai-middleware-heartbeat.nix
@@ -8,11 +8,18 @@ mkDerivation {
     rev = "bd7dbbe83d25c00fcd2cf5c77736af904910c596";
     fetchSubmodules = true;
   };
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base http-types wai ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   description = "Heartbeat middleware for the WAI ecosystem";
   license = lib.licenses.mit;
-}
\ No newline at end of file
+  broken = false;
+}
diff --git a/pkgs/wai-middleware-static.nix b/pkgs/wai-middleware-static.nix
index 1e8a3bd78236e5a62f11330b057b06e629e06e59..a1649e13f17628ca3910561afe36897b89bb0e53 100644
--- a/pkgs/wai-middleware-static.nix
+++ b/pkgs/wai-middleware-static.nix
@@ -29,6 +29,9 @@ mkDerivation {
   sha256 = "6c0c87558f04807896377535f7801a16b4ddfd9de1a203ef5a45de915907d5fa";
   revision = "1";
   editedCabalFile = "1zran8wpwizrwdw23a5qckmiplyk6xf2z8x4his0ipfy2zzl5ql6";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     base16-bytestring
@@ -57,11 +60,15 @@ mkDerivation {
     wai-extra
   ];
   testToolDepends = [ hspec-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/scotty-web/wai-middleware-static";
   description = "WAI middleware that serves requests to static files";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/warp-tls.nix b/pkgs/warp-tls.nix
index 6193f03c92307845de022c5f527f0cb20849e88d..4fbd10c9798d31f5ad7a80d5b39ea621714b598d 100644
--- a/pkgs/warp-tls.nix
+++ b/pkgs/warp-tls.nix
@@ -16,6 +16,9 @@ mkDerivation {
   pname = "warp-tls";
   version = "3.3.3";
   sha256 = "5c44be7a903b863b330d1b9c152100ed7d1709f972e25401018bab407d3f69a0";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     bytestring
@@ -29,11 +32,15 @@ mkDerivation {
     wai
     warp
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/yesodweb/wai";
   description = "HTTP over TLS support for Warp via the TLS package";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/warp.nix b/pkgs/warp.nix
index bd6121e30ebd7754d64fa804d2a08532924ecbc6..47dae7ae5b3ec1759daddef032c4e928ee5544b9 100644
--- a/pkgs/warp.nix
+++ b/pkgs/warp.nix
@@ -41,6 +41,9 @@ mkDerivation {
   pname = "warp";
   version = "3.3.22";
   sha256 = "ea26386fa12f86bc8d04446cc551ccc5c918debe4ad947f6c6bf514da3f04f3e";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     array
     auto-update
@@ -122,11 +125,15 @@ mkDerivation {
     unliftio
     x509
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/yesodweb/wai";
   description = "A fast, light-weight web server for WAI applications";
   license = lib.licenses.mit;
+  broken = false;
 }
diff --git a/pkgs/with-utf8.nix b/pkgs/with-utf8.nix
index 4df52c1bb70301cd3ca09e692847f22df0e3cae2..1d1cfea73316f338a4ae4736c71a92984ed78c55 100644
--- a/pkgs/with-utf8.nix
+++ b/pkgs/with-utf8.nix
@@ -23,6 +23,7 @@ mkDerivation {
   sha256 = "0707ce5868c96379ed4f8486e1791a798cf2a254fda9801a7fb65944aeb5b035";
   isLibrary = true;
   isExecutable = true;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [ base safe-exceptions text ];
   executableHaskellDepends = [
     base
@@ -47,12 +48,16 @@ mkDerivation {
     unix
   ];
   testToolDepends = [ tasty-discover ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/serokell/haskell-with-utf8#readme";
   description = "Get your IO right on the first try";
   license = lib.licenses.mpl20;
   mainProgram = "utf8-troubleshoot";
+  broken = false;
 }
diff --git a/pkgs/witherable.nix b/pkgs/witherable.nix
index 599c7105801048092081ae5c25ce850033024337..3b425720eb2c92b191a5c4be9b944389c4e1fb02 100644
--- a/pkgs/witherable.nix
+++ b/pkgs/witherable.nix
@@ -20,6 +20,9 @@ mkDerivation {
   sha256 = "790d2bb274283419173bd89104439860675a9410f70f21912973ecd9098b4104";
   revision = "3";
   editedCabalFile = "1f2bvl41by904lnr0dk6qgasqwadq2w48l7fj51bp2h8bqbkdjyc";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   libraryHaskellDepends = [
     base
     base-orphans
@@ -43,11 +46,15 @@ mkDerivation {
     unordered-containers
     vector
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "https://github.com/fumieval/witherable";
   description = "filterable traversable";
   license = lib.licenses.bsd3;
+  broken = false;
 }
diff --git a/pkgs/xml-conduit.nix b/pkgs/xml-conduit.nix
index 2d806feb8d66dd41d7729a322ee21cc8e0f0e6e8..c6e4cfc0b6342bfe662b71344843cdd304621db1 100644
--- a/pkgs/xml-conduit.nix
+++ b/pkgs/xml-conduit.nix
@@ -24,8 +24,11 @@ mkDerivation {
   pname = "xml-conduit";
   version = "1.9.1.1";
   sha256 = "bdb117606c0b56ca735564465b14b50f77f84c9e52e31d966ac8d4556d3ff0ff";
-  revision = "1";
-  editedCabalFile = "0x4is0956lfpxnxf2hqv5yvl1v8r1d41h3a22qqkvbqi13xz2hzv";
+  revision = "2";
+  editedCabalFile = "0m6sknp9xxz8a3dhvyfpyjvxp8ph511w19j4vj1qsd6hl2pazjy6";
+  isLibrary = true;
+  isExecutable = false;
+  enableSeparateDataOutput = false;
   setupHaskellDepends = [ base Cabal cabal-doctest ];
   libraryHaskellDepends = [
     attoparsec
@@ -58,11 +61,15 @@ mkDerivation {
     transformers
     xml-types
   ];
+  enableLibraryProfiling = false;
+  enableExecutableProfiling = false;
   doHaddock = false;
   jailbreak = true;
   doCheck = false;
+  doBenchmark = false;
   hyperlinkSource = false;
   homepage = "http://github.com/snoyberg/xml";
   description = "Pure-Haskell utilities for dealing with XML with the conduit package";
   license = lib.licenses.mit;
+  broken = false;
 }