Merge master into staging-next

doc/languages-frameworks/haskell.section.md

···
 
 Every haskell package set has its own haskell-aware `mkDerivation` which is used
 to build its packages. Generally you won't have to interact with this builder
-since [cabal2nix][cabal2nix] can generate packages
+since [cabal2nix](#haskell-cabal2nix) can generate packages
 using it for an arbitrary cabal package definition. Still it is useful to know
 the parameters it takes when you need to
 [override](#haskell-overriding-haskell-packages) a generated Nix expression.
···
 Note that this feature is automatically disabled when cross-compiling, since it
 requires executing the binaries in question.
 
+## Import-from-Derivation helpers {#haskell-import-from-derivation}
+
+### cabal2nix {#haskell-cabal2nix}
+
+[`cabal2nix`][cabal2nix] can generate Nix package definitions for arbitrary
+Haskell packages using [import from derivation][import-from-derivation].
+`cabal2nix` will generate Nix expressions that look like this:
+
+```nix
+# cabal get mtl-2.2.1 && cd mtl-2.2.1 && cabal2nix .
+{ mkDerivation, base, lib, transformers }:
+mkDerivation {
+  pname = "mtl";
+  version = "2.2.1";
+  src = ./.;
+  libraryHaskellDepends = [ base transformers ];
+  homepage = "http://github.com/ekmett/mtl";
+  description = "Monad classes, using functional dependencies";
+  license = lib.licenses.bsd3;
+}
+```
+
+This expression should be called with `haskellPackages.callPackage`, which will
+supply [`haskellPackages.mkDerivation`](#haskell-mkderivation) and the Haskell
+dependencies as arguments.
+
+`callCabal2nix name src args`
+: Create a package named `name` from the source derivation `src` using
+  `cabal2nix`.
+
+  `args` are extra arguments provided to `haskellPackages.callPackage`.
+
+`callCabal2nixWithOptions name src opts args`
+: Create a package named `name` from the source derivation `src` using
+  `cabal2nix`.
+
+  `opts` are extra options for calling `cabal2nix`. If `opts` is a string, it
+  will be used as extra command line arguments for `cabal2nix`, e.g. `--subpath
+  path/to/dir/containing/cabal-file`. Otherwise, `opts` should be an AttrSet
+  which can contain the following attributes:
+
+  `extraCabal2nixOptions`
+  : Extra command line arguments for `cabal2nix`.
+
+  `srcModifier`
+  : A function which is used to modify the given `src` instead of the default
+    filter.
+
+    The default source filter will remove all files from `src` except for
+    `.cabal` files and `package.yaml` files.
+
 <!--
 
-TODO(@NixOS/haskell): finish these planned sections
-### Overriding the entire package set
+`callHackage`
+: TODO
+
+`callHackageDirect`
+: TODO
 
+`developPackage`
+: TODO
 
-## Import-from-Derivation helpers
+-->
 
-* `callCabal2nix`
-* `callHackage`, `callHackageDirect`
-* `developPackage`
+<!--
+
+TODO(@NixOS/haskell): finish these planned sections
+### Overriding the entire package set
 
 ## Contributing {#haskell-contributing}
 
···
 [profiling]: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/profiling.html
 [search.nixos.org]: https://search.nixos.org
 [turtle]: https://hackage.haskell.org/package/turtle
+[import-from-derivation]: https://nixos.org/manual/nix/stable/language/import-from-derivation

maintainers/maintainer-list.nix

···
     githubId = 69802930;
     name = "patka";
   };
+  patrickdag = {
+    email = "[e-mail]";
+    github = "PatrickDaG";
+    githubId = 58092422;
+    name = "Patrick";
+    keys = [{
+      fingerprint = "5E4C 3D74 80C2 35FE 2F0B  D23F 7DD6 A72E C899 617D";
+    }];
+  };
   patricksjackson = {
     email = "[e-mail]";
     github = "patricksjackson";

nixos/doc/manual/release-notes/rl-2405.section.md

···
 
 - [xdg-terminal-exec](https://github.com/Vladimir-csp/xdg-terminal-exec), the proposed Default Terminal Execution Specification.
 
+- [your_spotify](https://github.com/Yooooomi/your_spotify), a self hosted Spotify tracking dashboard. Available as [services.your_spotify](#opt-services.your_spotify.enable)
+
 - [RustDesk](https://rustdesk.com), a full-featured open source remote control alternative for self-hosting and security with minimal configuration. Alternative to TeamViewer. Available as [services.rustdesk-server](#opt-services.rustdesk-server.enable).
 
 - [Scrutiny](https://github.com/AnalogJ/scrutiny), a S.M.A.R.T monitoring tool for hard disks with a web frontend. Available as [services.scrutiny](#opt-services.scrutiny.enable).

nixos/modules/module-list.nix

···
   ./services/web-apps/windmill.nix
   ./services/web-apps/wordpress.nix
   ./services/web-apps/writefreely.nix
+  ./services/web-apps/your_spotify.nix
   ./services/web-apps/youtrack.nix
   ./services/web-apps/zabbix.nix
   ./services/web-apps/zitadel.nix

nixos/modules/services/mail/stalwart-mail.nix

···
       store.blob.path = mkDefault "${dataDir}/data/blobs";
       storage.data = mkDefault "db";
       storage.fts = mkDefault "db";
+      storage.lookup = mkDefault "db";
       storage.blob = mkDefault "blob";
       resolver.type = mkDefault "system";
       resolver.public-suffix = mkDefault ["https://publicsuffix.org/list/public_suffix_list.dat"];

nixos/modules/services/networking/vsftpd.nix

···
       }
       {
         assertion = (cfg.enableVirtualUsers -> cfg.userDbPath != null)
-                 && (cfg.enableVirtualUsers -> cfg.localUsers != null);
+                 && (cfg.enableVirtualUsers -> cfg.localUsers);
         message = "vsftpd: If enableVirtualUsers is true, you need to setup both the userDbPath and localUsers options.";
       }];
 

nixos/modules/services/web-apps/your_spotify.nix

···
+{
+  pkgs,
+  config,
+  lib,
+  ...
+}: let
+  inherit
+    (lib)
+    boolToString
+    concatMapAttrs
+    concatStrings
+    isBool
+    mapAttrsToList
+    mkEnableOption
+    mkIf
+    mkOption
+    mkPackageOption
+    optionalAttrs
+    types
+    mkDefault
+    ;
+  cfg = config.services.your_spotify;
+
+  configEnv = concatMapAttrs (name: value:
+    optionalAttrs (value != null) {
+      ${name} =
+        if isBool value
+        then boolToString value
+        else toString value;
+    })
+  cfg.settings;
+
+  configFile = pkgs.writeText "your_spotify.env" (concatStrings (mapAttrsToList (name: value: "${name}=${value}\n") configEnv));
+in {
+  options.services.your_spotify = let
+    inherit (types) nullOr port str path package;
+  in {
+    enable = mkEnableOption "your_spotify";
+
+    enableLocalDB = mkEnableOption "a local mongodb instance";
+    nginxVirtualHost = mkOption {
+      type = nullOr str;
+      default = null;
+      description = ''
+        If set creates an nginx virtual host for the client.
+        In most cases this should be the CLIENT_ENDPOINT without
+        protocol prefix.
+      '';
+    };
+
+    package = mkPackageOption pkgs "your_spotify" {};
+
+    clientPackage = mkOption {
+      type = package;
+      description = "Client package to use.";
+    };
+
+    spotifySecretFile = mkOption {
+      type = path;
+      description = ''
+        A file containing the secret key of your Spotify application.
+        Refer to: [Creating the Spotify Application](https://github.com/Yooooomi/your_spotify#creating-the-spotify-application).
+      '';
+    };
+
+    settings = mkOption {
+      description = ''
+        Your Spotify Configuration. Refer to [Your Spotify](https://github.com/Yooooomi/your_spotify) for definitions and values.
+      '';
+      example = lib.literalExpression ''
+        {
+          CLIENT_ENDPOINT = "https://example.com";
+          API_ENDPOINT = "https://api.example.com";
+          SPOTIFY_PUBLIC = "spotify_client_id";
+        }
+      '';
+      type = types.submodule {
+        freeformType = types.attrsOf types.str;
+        options = {
+          CLIENT_ENDPOINT = mkOption {
+            type = str;
+            description = ''
+              The endpoint of your web application.
+              Has to include a protocol Prefix (e.g. `http://`)
+            '';
+            example = "https://your_spotify.example.org";
+          };
+          API_ENDPOINT = mkOption {
+            type = str;
+            description = ''
+              The endpoint of your server
+              This api has to be reachable from the device you use the website from not from the server.
+              This means that for example you may need two nginx virtual hosts if you want to expose this on the
+              internet.
+              Has to include a protocol Prefix (e.g. `http://`)
+            '';
+            example = "https://localhost:3000";
+          };
+          SPOTIFY_PUBLIC = mkOption {
+            type = str;
+            description = ''
+              The public client ID of your Spotify application.
+              Refer to: [Creating the Spotify Application](https://github.com/Yooooomi/your_spotify#creating-the-spotify-application)
+            '';
+          };
+          MONGO_ENDPOINT = mkOption {
+            type = str;
+            description = ''The endpoint of the Mongo database.'';
+            default = "mongodb://localhost:27017/your_spotify";
+          };
+          PORT = mkOption {
+            type = port;
+            description = "The port of the api server";
+            default = 3000;
+          };
+        };
+      };
+    };
+  };
+
+  config = mkIf cfg.enable {
+    services.your_spotify.clientPackage = mkDefault (cfg.package.client.override {apiEndpoint = cfg.settings.API_ENDPOINT;});
+    systemd.services.your_spotify = {
+      after = ["network.target"];
+      script = ''
+        export SPOTIFY_SECRET=$(< "$CREDENTIALS_DIRECTORY/SPOTIFY_SECRET")
+        ${lib.getExe' cfg.package "your_spotify_migrate"}
+        exec ${lib.getExe cfg.package}
+      '';
+      serviceConfig = {
+        User = "your_spotify";
+        Group = "your_spotify";
+        DynamicUser = true;
+        EnvironmentFile = [configFile];
+        StateDirectory = "your_spotify";
+        LimitNOFILE = "1048576";
+        PrivateTmp = true;
+        PrivateDevices = true;
+        StateDirectoryMode = "0700";
+        Restart = "always";
+
+        LoadCredential = ["SPOTIFY_SECRET:${cfg.spotifySecretFile}"];
+
+        # Hardening
+        CapabilityBoundingSet = "";
+        LockPersonality = true;
+        #MemoryDenyWriteExecute = true; # Leads to coredump because V8 does JIT
+        PrivateUsers = true;
+        ProtectClock = true;
+        ProtectControlGroups = true;
+        ProtectHome = true;
+        ProtectHostname = true;
+        ProtectKernelLogs = true;
+        ProtectKernelModules = true;
+        ProtectKernelTunables = true;
+        ProtectProc = "invisible";
+        ProcSubset = "pid";
+        ProtectSystem = "strict";
+        RestrictAddressFamilies = [
+          "AF_INET"
+          "AF_INET6"
+          "AF_NETLINK"
+        ];
+        RestrictNamespaces = true;
+        RestrictRealtime = true;
+        SystemCallArchitectures = "native";
+        SystemCallFilter = [
+          "@system-service"
+          "@pkey"
+        ];
+        UMask = "0077";
+      };
+      wantedBy = ["multi-user.target"];
+    };
+    services.nginx = mkIf (cfg.nginxVirtualHost != null) {
+      enable = true;
+      virtualHosts.${cfg.nginxVirtualHost} = {
+        root = cfg.clientPackage;
+        locations."/".extraConfig = ''
+          add_header Content-Security-Policy "frame-ancestors 'none';" ;
+          add_header X-Content-Type-Options "nosniff" ;
+          try_files = $uri $uri/ /index.html ;
+        '';
+      };
+    };
+    services.mongodb = mkIf cfg.enableLocalDB {
+      enable = true;
+    };
+  };
+  meta.maintainers = with lib.maintainers; [patrickdag];
+}

nixos/tests/all-tests.nix

···
   yabar = handleTest ./yabar.nix {};
   ydotool = handleTest ./ydotool.nix {};
   yggdrasil = handleTest ./yggdrasil.nix {};
+  your_spotify = handleTest ./your_spotify.nix {};
   zammad = handleTest ./zammad.nix {};
   zeronet-conservancy = handleTest ./zeronet-conservancy.nix {};
   zfs = handleTest ./zfs.nix {};

nixos/tests/stalwart-mail.nix

···
           };
         };
 
-        session.auth.mechanisms = [ "PLAIN" ];
-        session.auth.directory = "in-memory";
-        storage.directory = "in-memory";  # shared with imap
+        resolver.public-suffix = [ ];  # do not fetch from web in sandbox
 
-        session.rcpt.directory = "in-memory";
-        queue.outbound.next-hop = [ "local" ];
+        session.auth.mechanisms = "[plain]";
+        session.auth.directory = "'in-memory'";
+        storage.directory = "in-memory";
+
+        session.rcpt.directory = "'in-memory'";
+        queue.outbound.next-hop = "'local'";
 
         directory."in-memory" = {
           type = "memory";

nixos/tests/your_spotify.nix

···
+import ./make-test-python.nix ({pkgs, ...}: {
+  name = "your_spotify";
+  meta = with pkgs.lib.maintainers; {
+    maintainers = [patrickdag];
+  };
+
+  nodes.machine = {
+    services.your_spotify = {
+      enable = true;
+      spotifySecretFile = pkgs.writeText "spotifySecretFile" "deadbeef";
+      settings = {
+        CLIENT_ENDPOINT = "http://localhost";
+        API_ENDPOINT = "http://localhost:3000";
+        SPOTIFY_PUBLIC = "beefdead";
+      };
+      enableLocalDB = true;
+      nginxVirtualHost = "localhost";
+    };
+  };
+
+  testScript = ''
+    machine.wait_for_unit("your_spotify.service")
+
+    machine.wait_for_open_port(3000)
+    machine.wait_for_open_port(80)
+
+    out = machine.succeed("curl --fail -X GET 'http://localhost:3000/'")
+    assert "Hello !" in out
+
+    out = machine.succeed("curl --fail -X GET 'http://localhost:80/'")
+    assert "<title>Your Spotify</title>" in out
+  '';
+})

pkgs/applications/audio/eartag/default.nix

···
 , gtk4
 , librsvg
 , python3Packages
+, blueprint-compiler
 }:
 
 python3Packages.buildPythonApplication rec {
   pname = "eartag";
-  version = "0.6.0";
+  version = "0.6.1";
   format = "other";
 
   src = fetchFromGitLab {
···
     owner = "World";
     repo = pname;
     rev = version;
-    hash = "sha256-MfffIqxfelwP+9wsFvQfEIMkav7j5LJEHjLPOsuYdtQ=";
+    hash = "sha256-CAJz9p1PJxq3VDxzZEHD860xINCQF722bPaf7psNztY=";
   };
 
   postPatch = ''
···
     gettext
     gobject-introspection
     wrapGAppsHook4
+    blueprint-compiler
   ] ++ lib.optional stdenv.isDarwin gtk4; # for gtk4-update-icon-cache
 
   buildInputs = [

pkgs/applications/editors/heh/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "heh";
-  version = "0.4.1";
+  version = "0.5.0";
 
   src = fetchFromGitHub {
     owner = "ndd7xv";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-IIF/bkTLwR8pCs/hJ625T3NsiKf/6Zf1cW2i4lsiK4U=";
+    hash = "sha256-zkb+HogwioqxZ+BTl7bcDQx9i9uWhT2QdAIXpHqvDl0=";
   };
 
-  cargoHash = "sha256-tDvqaNVuzv1BlS/oNI1D/WV1b5uHreT3Ak/6ruqKXQc=";
+  cargoHash = "sha256-YcTaLq04NhmnJ1pdbiKMRIBSFvHNWNgoAS8Uz8uGGAw=";
 
   meta = with lib; {
     description = "A cross-platform terminal UI used for modifying file data in hex or ASCII.";

pkgs/applications/emulators/cdemu/analyzer.nix

···
-{ stdenv, cmake, pkg-config, callPackage, makeWrapper, gobject-introspection, wrapGAppsHook3
-, python3Packages, gtk3, glib, libxml2, gnuplot, gnome, gdk-pixbuf, librsvg, intltool, libmirage }:
-stdenv.mkDerivation {
+{ cmake, pkg-config, callPackage, gobject-introspection, wrapGAppsHook3
+, python3Packages, libxml2, gnuplot, gnome, gdk-pixbuf, intltool, libmirage }:
+python3Packages.buildPythonApplication {
 
   inherit (callPackage ./common-drv-attrs.nix {
     version = "3.2.6";
···
     hash = "sha256-7I8RUgd+k3cEzskJGbziv1f0/eo5QQXn62wGh/Y5ozc=";
   }) pname version src meta;
 
-  buildInputs = [ libxml2 gnuplot libmirage gnome.adwaita-icon-theme gdk-pixbuf librsvg
-                  python3Packages.pygobject3 python3Packages.matplotlib ];
-  nativeBuildInputs = [ cmake pkg-config wrapGAppsHook3 intltool ];
+  buildInputs = [ libxml2 gnuplot libmirage gnome.adwaita-icon-theme gdk-pixbuf ];
+  propagatedBuildInputs = with python3Packages; [ pygobject3 matplotlib ];
+  nativeBuildInputs = [ cmake pkg-config wrapGAppsHook3 intltool gobject-introspection ];
 
+  pyproject = false;
   dontWrapGApps = true;
-  postFixup = ''
-    wrapProgram $out/bin/image-analyzer \
-      ''${gappsWrapperArgs[@]} \
-      --set PYTHONPATH "$PYTHONPATH"
+  preFixup = ''
+    makeWrapperArgs+=("''${gappsWrapperArgs[@]}")
   '';
+
 }

pkgs/applications/emulators/cdemu/client.nix

···
-{ stdenv, callPackage, python3Packages, cmake, pkg-config, intltool, wrapGAppsNoGuiHook }:
-stdenv.mkDerivation {
+{ callPackage, python3Packages, cmake, pkg-config, intltool, wrapGAppsNoGuiHook, gobject-introspection }:
+python3Packages.buildPythonApplication {
 
   inherit (callPackage ./common-drv-attrs.nix {
     version = "3.2.5";
···
     hash = "sha256-py2F61v8vO0BCM18GCflAiD48deZjbMM6wqoCDZsOd8=";
   }) pname version src meta;
 
-  nativeBuildInputs = [ cmake pkg-config intltool wrapGAppsNoGuiHook ];
-  buildInputs = with python3Packages; [ dbus-python pygobject3 ];
+  nativeBuildInputs = [ cmake pkg-config intltool wrapGAppsNoGuiHook gobject-introspection ];
+  propagatedBuildInputs = with python3Packages; [ dbus-python pygobject3 ];
 
+  pyproject = false;
   dontWrapGApps = true;
-  postFixup = ''
-    wrapProgram $out/bin/cdemu \
-      ''${gappsWrapperArgs[@]} \
-      --set PYTHONPATH "$PYTHONPATH"
+  preFixup = ''
+    makeWrapperArgs+=("''${gappsWrapperArgs[@]}")
   '';
 
 }

pkgs/applications/emulators/cdemu/gui.nix

···
-{ stdenv, callPackage, cmake, pkg-config, wrapGAppsHook3
-, python3Packages, libnotify, intltool, gnome, gdk-pixbuf, librsvg }:
-stdenv.mkDerivation {
+{ callPackage, cmake, pkg-config, wrapGAppsHook3, gobject-introspection
+, python3Packages, libnotify, intltool, gnome, gdk-pixbuf }:
+python3Packages.buildPythonApplication {
 
   inherit (callPackage ./common-drv-attrs.nix {
     version = "3.2.6";
···
     hash = "sha256-w4vzKoSotL5Cjfr4Cu4YhNSWXJqS+n/vySrwvbhR1zA=";
   }) pname version src meta;
 
-  nativeBuildInputs = [ cmake pkg-config wrapGAppsHook3 intltool ];
-  buildInputs = [ python3Packages.pygobject3 libnotify gnome.adwaita-icon-theme gdk-pixbuf librsvg ];
+  nativeBuildInputs = [ cmake pkg-config wrapGAppsHook3 intltool gobject-introspection ];
+  buildInputs = [ libnotify gnome.adwaita-icon-theme gdk-pixbuf ];
+  propagatedBuildInputs = with python3Packages; [ pygobject3 ];
 
+  pyproject = false;
   dontWrapGApps = true;
-  postFixup = ''
-    wrapProgram $out/bin/gcdemu \
-      ''${gappsWrapperArgs[@]} \
-      --set PYTHONPATH "$PYTHONPATH"
+  preFixup = ''
+    makeWrapperArgs+=("''${gappsWrapperArgs[@]}")
   '';
 
 }

pkgs/applications/emulators/cdemu/libmirage.nix

···
-{ stdenv, callPackage, cmake, pkg-config
+{ stdenv, callPackage, cmake, pkg-config, gobject-introspection
 , glib, libsndfile, zlib, bzip2, xz, libsamplerate, intltool
 , pcre, util-linux, libselinux, libsepol }:
 
···
   PKG_CONFIG_GOBJECT_INTROSPECTION_1_0_GIRDIR = "${placeholder "out"}/share/gir-1.0";
   PKG_CONFIG_GOBJECT_INTROSPECTION_1_0_TYPELIBDIR = "${placeholder "out"}/lib/girepository-1.0";
   buildInputs = [ glib libsndfile zlib bzip2 xz libsamplerate ];
-  nativeBuildInputs = [ cmake pkg-config intltool ];
+  nativeBuildInputs = [ cmake pkg-config intltool gobject-introspection ];
   propagatedBuildInputs = [ pcre util-linux libselinux libsepol ];
+
 }

pkgs/applications/networking/cluster/civo/default.nix

···
 
 buildGoModule rec {
   pname = "civo";
-  version = "1.0.82";
+  version = "1.0.83";
 
   src = fetchFromGitHub {
     owner  = "civo";
     repo   = "cli";
     rev    = "v${version}";
-    sha256 = "sha256-pwi0Z0dO2z8Ovlt9gKyVNrh0ZZ2M9xnahBmbTNK2Bnw=";
+    sha256 = "sha256-jRs8RMdTq5xylcYBN59+JzXlJlTJRp7bJVMvEmvzSnc=";
   };
 
   vendorHash = "sha256-NYNp4KGcVma4ltkq2SJZJOaeKS0j/X2TlUrOnptxiYE=";

pkgs/applications/networking/cluster/clusterctl/default.nix

···
 
 buildGoModule rec {
   pname = "clusterctl";
-  version = "1.7.1";
+  version = "1.7.2";
 
   src = fetchFromGitHub {
     owner = "kubernetes-sigs";
     repo = "cluster-api";
     rev = "v${version}";
-    hash = "sha256-e+Ut6xoNUY9cJjjJ43P0siEa+G1igllcb8veirk1UX0=";
+    hash = "sha256-ZZkDc5INjUoNc9zcwbOa9WRIkkLr9bm3mohsSe3tKI4=";
   };
 
   vendorHash = "sha256-ALRnccGjPGuAITtuz79Cao95NhvSczAzspSMXytlw+A=";

pkgs/applications/networking/cluster/kubebuilder/default.nix

···
 
 buildGoModule rec {
   pname = "kubebuilder";
-  version = "3.14.2";
+  version = "3.15.0";
 
   src = fetchFromGitHub {
     owner = "kubernetes-sigs";
     repo = "kubebuilder";
     rev = "v${version}";
-    hash = "sha256-bs/16MEZZOv+5cfr35HDqhnJxza9mQfjd8ALjJifRf8=";
+    hash = "sha256-YaISsW+USP9M4Mblluo+SXSwGspiTiiPFA3VvLmhqaQ=";
   };
 
-  vendorHash = "sha256-eLLWzVQ9ANIWSdqjmggrboCwcUKVGdrJD2coCLmzAK4=";
+  vendorHash = "sha256-g9QjalRLc2NUsyd7Do1PWw9oD9ATuJGMRaqSaC6AcD0=";
 
   subPackages = ["cmd"];
 

pkgs/applications/networking/remote/wayvnc/default.nix

···
       headless one, so it is also possible to run wayvnc without a physical
       display attached.
     '';
+    mainProgram = "wayvnc";
     inherit (src.meta) homepage;
     changelog = "https://github.com/any1/wayvnc/releases/tag/v${version}";
     license = licenses.isc;

pkgs/applications/science/math/polymake/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "polymake";
-  version = "4.11";
+  version = "4.12";
 
   src = fetchurl {
     # "The minimal version is a packager friendly version which omits
     # the bundled sources of cdd, lrs, libnormaliz, nauty and jReality."
     url = "https://polymake.org/lib/exe/fetch.php/download/polymake-${version}-minimal.tar.bz2";
-    sha256 = "sha256-XfbwrNcAEZvQxLV2Z2KFL/vYV3ZbXcyIgC/10hCK3SM=";
+    sha256 = "sha256-vVpmf/ykv3641RE0Awzj3zsW3Z0OgA+v2xzoNYZ2QNk=";
   };
 
   nativeBuildInputs = [

pkgs/applications/virtualization/docker/default.nix

···
   # Get revisions from
   # https://github.com/moby/moby/tree/${version}/hack/dockerfile/install/*
   docker_24 = callPackage dockerGen rec {
-    version = "24.0.5";
+    version = "24.0.9";
     cliRev = "v${version}";
-    cliHash = "sha256-u1quVGTx/p8BDyRn33vYyyuE5BOhWMnGQ5uVX0PZ5mg=";
+    cliHash = "sha256-nXIZtE0X1OoQT908IGuRhVHb0tiLbqQLP0Md3YWt0/Q=";
     mobyRev = "v${version}";
-    mobyHash = "sha256-JQjRz1fHZlQRkNw/R8WWLV8caN3/U3mrKKQXbZt2crU=";
-    runcRev = "v1.1.8";
-    runcHash = "sha256-rDJYEc64KW4Qa3Eg2oUjJqIKrg6THb5hxQFFbvb9Zp4=";
-    containerdRev = "v1.7.1";
-    containerdHash = "sha256-WwedtcsrDQwMQcKFO5nnPiHyGJpl5hXZlmpbBe1/ftY=";
+    mobyHash = "sha256-KRS99heyMAPBnjjr7If8TOlJf6v6866S7J3YGkOhFiA=";
+    runcRev = "v1.1.12";
+    runcHash = "sha256-N77CU5XiGYIdwQNPFyluXjseTeaYuNJ//OsEUS0g/v0=";
+    containerdRev = "v1.7.13";
+    containerdHash = "sha256-y3CYDZbA2QjIn1vyq/p1F1pAVxQHi/0a6hGWZCRWzyk=";
     tiniRev = "v0.19.0";
     tiniHash = "sha256-ZDKu/8yE5G0RYFJdhgmCdN3obJNyRWv6K/Gd17zc1sI=";
   };

pkgs/by-name/bi/bitmagnet/package.nix

···
 
 buildGoModule rec {
   pname = "bitmagnet";
-  version = "0.7.14";
+  version = "0.8.0";
 
   src = fetchFromGitHub {
     owner = "bitmagnet-io";
     repo = "bitmagnet";
     rev = "v${version}";
-    hash = "sha256-TaxoQdjdHw8h6w6wKBHL/CVxWFK/RG2tJ//MtUEOwfU=";
+    hash = "sha256-P5GfPRIrwLLMBRgoN6d092HiThMghEj1zcaf6BU+IWU=";
   };
 
-  vendorHash = "sha256-y9RfaAx9AQS117J3+p/Yy8Mn5In1jmZmW4IxKjeV8T8=";
+  vendorHash = "sha256-exKQTsyP7LL63WHZ8/WchLh4y0Oj9LC4lxiZTOfWARU=";
 
-  ldflags = [ "-s" "-w" ];
+  ldflags = [ "-s" "-w" "-X github.com/bitmagnet-io/bitmagnet/internal/version.GitTag=v${version}" ];
 
   passthru = {
     updateScript = nix-update-script { };

pkgs/by-name/ma/makima/package.nix

···
 
 rustPlatform.buildRustPackage rec{
   pname = "makima";
-  version = "0.6.6";
+  version = "0.7.2";
 
   src = fetchFromGitHub {
     owner = "cyber-sushi";
     repo = "makima";
     rev = "v${version}";
-    hash = "sha256-Orl79ETROaQzAraGGgYQSSreASanYQHkpEetIR8kJmo=";
+    hash = "sha256-pLEMKVi1CXp9Jqy+D0Wibhfq8PAH2bm3e1G7jShEKsU=";
   };
 
-  cargoHash = "sha256-npnAbzy2EN3tK1/pSJnnucMj5lLn30lrgKtcPDl0HQQ=";
+  cargoHash = "sha256-EiqmNu0GUE/zFrWkIqrcxZEpv26J39GeWa+tmTlJq4A=";
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ udev ];

pkgs/by-name/mi/misconfig-mapper/package.nix

···
 
 buildGoModule rec {
   pname = "misconfig-mapper";
-  version = "1.1.0";
+  version = "1.1.1";
 
   src = fetchFromGitHub {
     owner = "intigriti";
     repo = "misconfig-mapper";
     rev = "refs/tags/v${version}";
-    hash = "sha256-5FzXtqC8C4iDC8xBalKHlNeSIJ0msMVC7jUXZxSLkLY=";
+    hash = "sha256-D9VQthfkWC+qmqIZKIVuFuf9ZDNtyRmjh7tT/QGhQig=";
   };
 
-  vendorHash = "sha256-b2AVWjZXNQPV84sS2wu5xUadZEme/T96O4dGiV5G0dA=";
+  vendorHash = "sha256-lkVTgnWdk9eW6QtKScK8NckcXGzsHeIwjSoUx85AGU8=";
 
   ldflags = [
     "-s"

pkgs/by-name/py/pyright/package.nix

···
 { lib, buildNpmPackage, fetchFromGitHub, runCommand, jq }:
 
 let
-  version = "1.1.361";
+  version = "1.1.362";
 
   src = fetchFromGitHub {
     owner = "Microsoft";
     repo = "pyright";
     rev = "${version}";
-    hash = "sha256-Prp8LlkSxK2zuVi1lYtI4MdBTGrGhA52Cl5a016ttDY=";
+    hash = "sha256-sz+Om2bfsJJTe2W8l49pI+K9phCTwoczeG1Q7qlMIig=";
   };
 
   patchedPackageJSON = runCommand "package.json" { } ''
···
     pname = "pyright-internal";
     inherit version src;
     sourceRoot = "${src.name}/packages/pyright-internal";
-    npmDepsHash = "sha256-kWDMbzLTDIyG9fUixEJ8Uap4wJmLiu0CQWKr9K5hAJQ=";
+    npmDepsHash = "sha256-xcr9j5/90gfV/r0yI9ifj6Nrr9WrawwvukuVkl387r4=";
     dontNpmBuild = true;
     installPhase = ''
       runHook preInstall
···
   inherit version src;
 
   sourceRoot = "${src.name}/packages/pyright";
-  npmDepsHash = "sha256-6Drw9H5eTxpZVrQZpUIarcu3a6UpU/8qX1MzM4q5IfY=";
+  npmDepsHash = "sha256-79tXMdOt1XH3KTT46bq35J4AcCVyoB2d4KEkr9EjqVY=";
 
   postPatch = ''
     chmod +w ../../

pkgs/by-name/ri/ripunzip/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "ripunzip";
-  version = "1.1.0";
+  version = "1.2.1";
 
   src = fetchFromGitHub {
     owner = "google";
     repo = "ripunzip";
     rev = "v${version}";
-    hash = "sha256-GyP4OPnPKhu9nXYXIfWCVLF/thwWiP0OqAQY/1D05LE=";
+    hash = "sha256-WcqN3Li0UiEhntKlQkGUrkP9N1I3NrjaGzIs9Q5i4y4=";
   };
 
-  cargoHash = "sha256-Jv9bCHT5xl/2CPnSuWd9HZuaGOttBC5iAbbpr3jaIhM=";
+  cargoHash = "sha256-CezigBDU632UVaeFNv+iM2dQQUabKhOP43etp6vjxTg=";
 
   buildInputs = [ openssl ]
     ++ lib.optionals stdenv.isDarwin (with darwin.apple_sdk.frameworks; [ Security SystemConfiguration ]);

pkgs/by-name/sp/spade/Cargo.lock

···
 
 [[package]]
 name = "spade"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "atty",
  "clap",
···
 
 [[package]]
 name = "spade-ast"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "num",
  "spade-common",
···
 
 [[package]]
 name = "spade-ast-lowering"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "itertools",
  "local-impl",
···
 
 [[package]]
 name = "spade-common"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "codespan",
  "codespan-reporting 0.12.0",
···
 
 [[package]]
 name = "spade-diagnostics"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "codespan",
  "codespan-reporting 0.12.0",
···
 
 [[package]]
 name = "spade-hir"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "codespan-reporting 0.12.0",
  "colored",
···
 
 [[package]]
 name = "spade-hir-lowering"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "codespan",
  "codespan-reporting 0.12.0",
···
 
 [[package]]
 name = "spade-macros"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "proc-macro2",
  "quote",
···
 
 [[package]]
 name = "spade-mir"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "codespan",
  "codespan-reporting 0.12.0",
···
 
 [[package]]
 name = "spade-parser"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "codespan",
  "colored",
···
 
 [[package]]
 name = "spade-python"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "codespan-reporting 0.12.0",
  "color-eyre",
···
 
 [[package]]
 name = "spade-simulation-ext"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "codespan-reporting 0.12.0",
  "color-eyre",
···
 
 [[package]]
 name = "spade-tests"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "codespan-reporting 0.12.0",
  "colored",
···
 
 [[package]]
 name = "spade-typeinference"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "assert_matches",
  "codespan",
···
 
 [[package]]
 name = "spade-types"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "num",
  "serde",
···
 
 [[package]]
 name = "spade-wordlength-inference"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "codespan",
  "codespan-reporting 0.12.0",

pkgs/by-name/sp/spade/package.nix

···
 , rustPlatform
 , fetchFromGitLab
 , stdenv
+, nix-update
+, writeScript
+, git
 }:
 
 rustPlatform.buildRustPackage rec {
   pname = "spade";
-  version = "0.7.0";
+  version = "0.8.0";
 
   src = fetchFromGitLab {
     owner = "spade-lang";
     repo = "spade";
     rev = "v${version}";
-    hash = "sha256-oJfOgWobjt+DAVdP465E8iLMJCdqhs0vzJJFgRqVAP8=";
+    hash = "sha256-J3AdXuN1WLKFED9YeBly68umPlx05Wl+mhT2YbBsJVk=";
     # only needed for vatch, which contains test data
     fetchSubmodules = true;
   };
···
       "tracing-tree-0.2.0" = "sha256-/JNeAKjAXmKPh0et8958yS7joORDbid9dhFB0VUAhZc=";
     };
   };
+
+  # rust + gitlab is a rare combo
+  passthru.updateScript = [
+    (writeScript "update-spade" ''
+      VERSION="$(
+        ${lib.getExe git} ls-remote --tags --sort -version:refname ${lib.escapeShellArg src.gitRepoUrl} \
+          | cut -f2 | grep ^refs/tags/v | cut -d/ -f3- | cut -c2- \
+          | sort --version-sort --reverse | head -n1
+      )"
+      exec ${lib.getExe nix-update} --version "$VERSION" "$@"
+    '')
+  ];
 
   meta = with lib; {
     description = "A better hardware description language";

pkgs/by-name/te/tenv/package.nix

···
 
 buildGoModule rec {
   pname = "tenv";
-  version = "1.10.1";
+  version = "1.11.0";
 
   src = fetchFromGitHub {
     owner = "tofuutils";
     repo = "tenv";
     rev = "v${version}";
-    hash = "sha256-c283egT5KOcR+PjwWnKkCI3RKr+Tqa6a+ORsjq4wuXs=";
+    hash = "sha256-LjgcI3E6K6b8fca9HdLyyIJJMHFxRtHdvWQb19jFHpA=";
   };
 
-  vendorHash = "sha256-GAUpQbZfaF3N2RaQO0ZDe8DywOZwIfXNImsZCk6iB+U=";
+  vendorHash = "sha256-teog4VJGDOYsABuE2/fvOtcWvC8mM36rJQI6KZb3eS8=";
 
   # Tests disabled for requiring network access to release.hashicorp.com
   doCheck = false;

pkgs/by-name/ti/tiny-dfr/package.nix

···
+{ lib, rustPlatform, fetchFromGitHub, pkg-config
+, cairo, gdk-pixbuf, glib, libinput, libxml2, pango, udev
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "tiny-dfr";
+  version = "0.2.0";
+
+  src = fetchFromGitHub {
+    owner = "WhatAmISupposedToPutHere";
+    repo = "tiny-dfr";
+    rev = "v${version}";
+    hash = "sha256-oawKYrfXAQ5RFMdUCG7F12wHcnFif++44s2KsX9ns6U=";
+  };
+
+  cargoHash = "sha256-QOkztErJLFXPxCb8MvaXi7jGXeI5A0q8LwZtYddzUZE=";
+
+  nativeBuildInputs = [ pkg-config ];
+  buildInputs = [ cairo gdk-pixbuf glib libinput libxml2 pango udev ];
+
+  postConfigure = ''
+    substituteInPlace etc/systemd/system/tiny-dfr.service \
+        --replace-fail /usr/bin $out/bin
+    substituteInPlace src/*.rs --replace-quiet /usr/share $out/share
+  '';
+
+  postInstall = ''
+    cp -R etc $out/lib
+    cp -R share $out
+  '';
+
+  meta = with lib; {
+    homepage = "https://github.com/WhatAmISupposedToPutHere/tiny-dfr";
+    description = "The most basic dynamic function row daemon possible";
+    license = [ licenses.asl20 licenses.mit ];
+    mainProgram = "tiny-dfr";
+    maintainers = [ maintainers.qyliss ];
+    platforms = platforms.linux;
+  };
+}

pkgs/by-name/up/upsun/package.nix

···
-{ stdenvNoCC, lib, fetchurl }:
+{
+  stdenvNoCC,
+  lib,
+  fetchurl,
+  testers,
+  upsun
+}:
 
-stdenvNoCC.mkDerivation rec {
+stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "upsun";
-  version = "5.0.12";
+  version = "5.0.13";
 
-  src = {
-    x86_64-darwin = (fetchurl {
-      url = "https://github.com/platformsh/cli/releases/download/${version}/upsun_${version}_darwin_all.tar.gz";
-      hash = "sha256-RwTMJwvkuX/okHSyxzpvaD6uD8fheVbr7bgBC2eMQOo=";
-    });
-    aarch64-darwin = (fetchurl {
-      url = "https://github.com/platformsh/cli/releases/download/${version}/upsun_${version}_darwin_all.tar.gz";
-      hash = "sha256-RwTMJwvkuX/okHSyxzpvaD6uD8fheVbr7bgBC2eMQOo=";
-    });
-    x86_64-linux = (fetchurl {
-      url = "https://github.com/platformsh/cli/releases/download/${version}/upsun_${version}_linux_amd64.tar.gz";
-      hash = "sha256-svEPMVY7r7pAoXwFIMYqCEduqR3Nkocaguf2nIGt+G8=";
-    });
-    aarch64-linux = (fetchurl {
-      url = "https://github.com/platformsh/cli/releases/download/${version}/upsun_${version}_linux_arm64.tar.gz";
-      hash = "sha256-ZraS/PqSPL/kcj5o6hzDdL70IV2IWXOma6OHCiXIDQc=";
-    });
-  }.${stdenvNoCC.system} or (throw "${pname}-${version}: ${stdenvNoCC.system} is unsupported.");
+  src =
+    {
+      x86_64-darwin = fetchurl {
+        url = "https://github.com/platformsh/cli/releases/download/${finalAttrs.version}/upsun_${finalAttrs.version}_darwin_all.tar.gz";
+        hash = "sha256-5JKXtAUnqrlufyNE05uZjEDfJv557auYPriTxvUbMJI=";
+      };
+      aarch64-darwin = fetchurl {
+        url = "https://github.com/platformsh/cli/releases/download/${finalAttrs.version}/upsun_${finalAttrs.version}_darwin_all.tar.gz";
+        hash = "sha256-5JKXtAUnqrlufyNE05uZjEDfJv557auYPriTxvUbMJI=";
+      };
+      x86_64-linux = fetchurl {
+        url = "https://github.com/platformsh/cli/releases/download/${finalAttrs.version}/upsun_${finalAttrs.version}_linux_amd64.tar.gz";
+        hash = "sha256-fjVL/sbO1wmaJ4qZpUMV/4Q4Jzf0p6qx0ElRdY5EUJU=";
+      };
+      aarch64-linux = fetchurl {
+        url = "https://github.com/platformsh/cli/releases/download/${finalAttrs.version}/upsun_${finalAttrs.version}_linux_arm64.tar.gz";
+        hash = "sha256-MNlQkwsg5SuIQJBDy7yVtcda1odpaUZezCgrat6OW2Q=";
+      };
+    }
+    .${stdenvNoCC.system}
+      or (throw "${finalAttrs.pname}-${finalAttrs.version}: ${stdenvNoCC.system} is unsupported.");
 
   dontConfigure = true;
   dontBuild = true;
 
   sourceRoot = ".";
   installPhase = ''
+    runHook preInstall
+
     install -Dm755 upsun $out/bin/upsun
+
+    runHook postInstall
   '';
 
+  passthru = {
+    tests.version = testers.testVersion {
+      inherit (finalAttrs) version;
+      package = upsun;
+    };
+  };
+
   meta = {
-    homepage = "https://github.com/platformsh/cli";
     description = "The unified tool for managing your Upsun services from the command line";
+    homepage = "https://github.com/platformsh/cli";
+    license = lib.licenses.mit;
     mainProgram = "upsun";
     maintainers = with lib.maintainers; [ spk ];
-    license = lib.licenses.mit;
     platforms = [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin" ];
     sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
   };
-}
+})

pkgs/by-name/yo/your_spotify/client.nix

···
+{
+  apiEndpoint ? "http://localhost:3000",
+  fetchYarnDeps,
+  your_spotify,
+  mkYarnPackage,
+  fixup-yarn-lock,
+  src,
+  version,
+  yarn,
+}:
+mkYarnPackage rec {
+  inherit version src;
+  pname = "your_spotify_client";
+  name = "your_spotify_client-${version}";
+  packageJSON = ./package.json;
+  offlineCache = fetchYarnDeps {
+    yarnLock = src + "/yarn.lock";
+    hash = "sha256-5SgknaRVzgO2Dzc8MhAaM8UERWMv+PrItzevoWHbWnA=";
+  };
+  configurePhase = ''
+    runHook preConfigure
+
+    export HOME=$(mktemp -d)
+    yarn config --offline set yarn-offline-mirror $offlineCache
+    fixup-yarn-lock yarn.lock
+    yarn install --offline --frozen-lockfile --ignore-platform --ignore-scripts --no-progress --non-interactive
+    patchShebangs node_modules/
+
+    runHook postConfigure
+  '';
+  buildPhase = ''
+    runHook preBuild
+    pushd ./apps/client/
+    yarn --offline run build
+    export API_ENDPOINT="${apiEndpoint}"
+    substituteInPlace scripts/run/variables.sh --replace-quiet '/app/apps/client/' "./"
+
+    chmod +x ./scripts/run/variables.sh
+    patchShebangs --build ./scripts/run/variables.sh
+
+    ./scripts/run/variables.sh
+
+    popd
+    runHook postBuild
+  '';
+  nativeBuildInputs = [yarn fixup-yarn-lock];
+
+  installPhase = ''
+    runHook preInstall
+    mkdir -p $out
+    cp -r ./apps/client/build/* $out
+    runHook postInstall
+  '';
+  doDist = false;
+  meta = {
+    inherit (your_spotify.meta) homepage changelog description license maintainers;
+  };
+}

pkgs/by-name/yo/your_spotify/package.json

···
+{
+  "name": "@your_spotify/root",
+  "version": "1.10.1",
+  "repository": "[e-mail]:Yooooomi/your_spotify.git",
+  "author": "Timothee <[e-mail]>",
+  "private": true,
+  "workspaces": [
+    "apps/*"
+  ]
+}

pkgs/by-name/yo/your_spotify/package.nix

···
+{
+  callPackage,
+  fetchFromGitHub,
+  fetchYarnDeps,
+  lib,
+  makeWrapper,
+  mkYarnPackage,
+  nodejs,
+  fixup-yarn-lock,
+  yarn,
+}: let
+  version = "1.10.1";
+  src = fetchFromGitHub {
+    owner = "Yooooomi";
+    repo = "your_spotify";
+    rev = "refs/tags/${version}";
+    hash = "sha256-e82j2blGxQLWAlBNuAnFvlD9vwMk4/mRI0Vf7vuaPA0=";
+  };
+  client = callPackage ./client.nix {inherit src version;};
+in
+  mkYarnPackage rec {
+    inherit version src;
+    pname = "your_spotify_server";
+    name = "your_spotify_server-${version}";
+    packageJSON = ./package.json;
+    offlineCache = fetchYarnDeps {
+      yarnLock = src + "/yarn.lock";
+      hash = "sha256-5SgknaRVzgO2Dzc8MhAaM8UERWMv+PrItzevoWHbWnA=";
+    };
+
+    configurePhase = ''
+      runHook preConfigure
+
+      export HOME=$(mktemp -d)
+      yarn config --offline set yarn-offline-mirror $offlineCache
+      fixup-yarn-lock yarn.lock
+
+      runHook postConfigure
+    '';
+
+    buildPhase = ''
+      runHook preBuild
+
+      yarn install --offline --frozen-lockfile --ignore-platform --ignore-scripts --no-progress --non-interactive
+      patchShebangs node_modules/
+
+      pushd ./apps/server/
+      yarn --offline run build
+      popd
+
+      rm -r node_modules
+      export NODE_ENV="production"
+      yarn install --offline --frozen-lockfile --ignore-platform --ignore-scripts --no-progress --non-interactive
+      patchShebangs node_modules/
+
+      runHook postBuild
+    '';
+    nativeBuildInputs = [makeWrapper yarn fixup-yarn-lock];
+    installPhase = ''
+      runHook preInstall
+
+      mkdir -p $out/share/your_spotify
+      cp -r node_modules $out/share/your_spotify/node_modules
+      cp -r ./apps/server/{lib,package.json} $out
+      mkdir -p $out/bin
+      makeWrapper ${lib.escapeShellArg (lib.getExe nodejs)} "$out/bin/your_spotify_migrate" \
+        --add-flags "$out/lib/migrations.js" --set NODE_PATH "$out/share/your_spotify/node_modules"
+      makeWrapper ${lib.escapeShellArg (lib.getExe nodejs)} "$out/bin/your_spotify_server" \
+        --add-flags "$out/lib/index.js" --set NODE_PATH "$out/share/your_spotify/node_modules"
+
+      runHook postInstall
+    '';
+    doDist = false;
+    passthru = {
+      inherit client;
+    };
+    meta = with lib; {
+      homepage = "https://github.com/Yooooomi/your_spotify";
+      changelog = "https://github.com/Yooooomi/your_spotify/releases/tag/${version}";
+      description = "Self-hosted application that tracks what you listen and offers you a dashboard to explore statistics about it";
+      license = licenses.gpl3Only;
+      maintainers = with maintainers; [patrickdag];
+      mainProgram = "your_spotify_server";
+    };
+  }

pkgs/data/fonts/cozette/default.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "cozette";
-  version = "1.24.0";
+  version = "1.24.1";
 
   src = fetchzip {
     url = "https://github.com/slavfox/Cozette/releases/download/v.${version}/CozetteFonts-v-${builtins.replaceStrings ["."] ["-"] version}.zip";
-    hash = "sha256-BA3pVcqZnakoYhF00OqDzo4GwRB5txGKN/ou2EvadWo=";
+    hash = "sha256-G3/m0g3pdPHUlSLnJhGIFem6UOyEf1VxjOvz/0E9Vr0=";
   };
 
   installPhase = ''

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "4eb9a5fde06b5d7343665582243debaf1d77e0a9",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/4eb9a5fde06b5d7343665582243debaf1d77e0a9.tar.gz",
-  "sha256": "0dzyfr1gv79riy2vh840b5hqly8rs10zhj01zi9nfn7jd9pzql28",
-  "msg": "Update from Hackage at 2024-04-16T17:36:35Z"
+  "commit": "9e419b038d7108160caf4efc41ebd5dfc4d51821",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/9e419b038d7108160caf4efc41ebd5dfc4d51821.tar.gz",
+  "sha256": "1vqsxznsq6s1hfb3b7ghs0fqa1rapqccjcz5jy3h9w3dq4v3gfqz",
+  "msg": "Update from Hackage at 2024-04-27T10:57:54Z"
 }

pkgs/development/compilers/ghc/9.10.1.nix

···
+import ./common-hadrian.nix rec {
+  version = "9.10.1";
+  sha256 = "bf386a302d4ee054791ffd51748900f15d71760fd199157922d120cc1f89e2f7";
+}

pkgs/development/compilers/ghc/common-hadrian.nix

···
 , xattr
 , autoSignDarwinBinariesHook
 , bash
+, srcOnly
 
 , libiconv ? null, ncurses
 , glibcLocales ? null
···
         return $ verbosity >= Verbose
   ''
 
-, ghcSrc ? (if rev != null then fetchgit else fetchurl) ({
-    inherit url sha256;
-  } // lib.optionalAttrs (rev != null) {
-    inherit rev;
-  } // lib.optionalAttrs (postFetch != null) {
-    inherit postFetch;
-  })
+, ghcSrc ?
+    srcOnly {
+      name = "ghc-${version}"; # -source appended by srcOnly
+      src =
+        (if rev != null then fetchgit else fetchurl) ({
+          inherit url sha256;
+        } // lib.optionalAttrs (rev != null) {
+          inherit rev;
+        } // lib.optionalAttrs (postFetch != null) {
+          inherit postFetch;
+        });
+
+      patches =
+        let
+          # Disable haddock generating pretty source listings to stay under 3GB on aarch64-linux
+          enableHyperlinkedSource =
+            lib.versionAtLeast version "9.8" ||
+            !(stdenv.hostPlatform.isAarch64 && stdenv.hostPlatform.isLinux);
+        in
+        [
+          # Fix docs build with Sphinx >= 7 https://gitlab.haskell.org/ghc/ghc/-/issues/24129
+          (if lib.versionAtLeast version "9.8"
+           then ./docs-sphinx-7-ghc98.patch
+           else ./docs-sphinx-7.patch )
+        ]
+        ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [
+          # Prevent the paths module from emitting symbols that we don't use
+          # when building with separate outputs.
+          #
+          # These cause problems as they're not eliminated by GHC's dead code
+          # elimination on aarch64-darwin. (see
+          # https://github.com/NixOS/nixpkgs/issues/140774 for details).
+          ./Cabal-at-least-3.6-paths-fix-cycle-aarch64-darwin.patch
+        ]
+        # Prevents passing --hyperlinked-source to haddock. This is a custom
+        # workaround as we wait for this to be configurable via userSettings or
+        # similar. https://gitlab.haskell.org/ghc/ghc/-/issues/23625
+        ++ lib.optionals (!enableHyperlinkedSource) [
+          # TODO(@sternenseemann): Doesn't apply for GHC >= 9.8
+          ../../tools/haskell/hadrian/disable-hyperlinked-source.patch
+        ]
+        # Incorrect bounds on Cabal in hadrian
+        # https://gitlab.haskell.org/ghc/ghc/-/issues/24100
+        ++ lib.optionals (lib.elem version [ "9.8.1" "9.8.2" ]) [
+          ../../tools/haskell/hadrian/hadrian-9.8.1-allow-Cabal-3.10.patch
+        ];
+    }
 
   # GHC's build system hadrian built from the GHC-to-build's source tree
   # using our bootstrap GHC.
 , hadrian ? import ../../tools/haskell/hadrian/make-hadrian.nix { inherit bootPkgs lib; } {
-    ghcSrc = ghcSrc;
+    inherit ghcSrc;
     ghcVersion = version;
     userSettings = hadrianUserSettings;
-    # Disable haddock generating pretty source listings to stay under 3GB on aarch64-linux
-    enableHyperlinkedSource =
-      # TODO(@sternenseemann): Disabling currently doesn't work with GHC >= 9.8
-      lib.versionAtLeast version "9.8" ||
-      !(stdenv.hostPlatform.isAarch64 && stdenv.hostPlatform.isLinux);
   }
 
 , #  Whether to build sphinx documentation.
···
   src = ghcSrc;
 
   enableParallelBuilding = true;
-
-  patches = [
-    # Fix docs build with Sphinx >= 7 https://gitlab.haskell.org/ghc/ghc/-/issues/24129
-    (if lib.versionAtLeast version "9.8"
-      then ./docs-sphinx-7-ghc98.patch
-      else ./docs-sphinx-7.patch )
-  ] ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [
-    # Prevent the paths module from emitting symbols that we don't use
-    # when building with separate outputs.
-    #
-    # These cause problems as they're not eliminated by GHC's dead code
-    # elimination on aarch64-darwin. (see
-    # https://github.com/NixOS/nixpkgs/issues/140774 for details).
-    ./Cabal-at-least-3.6-paths-fix-cycle-aarch64-darwin.patch
-  ];
 
   postPatch = ''
     patchShebangs --build .

pkgs/development/compilers/zulu/22.nix

···
       zuluVersion = "22.28.91";
       jdkVersion = "22.0.0";
       hash =
-        if enableJavaFX then "sha256-HvMiODsz+puu1xtxG2RRXH/PWCk91PGNZ7UcOd9orqQ="
+        if enableJavaFX then "sha256-+qUrZ+GlspSP3RLTAbgEtFm0B0fzX/VD1WUl6mk2c/0="
         else "sha256-HvMiODsz+puu1xtxG2RRXH/PWCk91PGNZ7UcOd9orqQ=";
     };
 
···
       zuluVersion = "22.28.91";
       jdkVersion = "22.0.0";
       hash =
-        if enableJavaFX then "sha256-Y6PSNQjHRXukwux2sVbvpTIqT+Cg+KeG1C0iSEwyKZw="
+        if enableJavaFX then "sha256-QkFwbc2YFEWb5rddhH4a+zmtsrXxUBSuS8yg9qUb728="
         else "sha256-Y6PSNQjHRXukwux2sVbvpTIqT+Cg+KeG1C0iSEwyKZw=";
     };
 
···
       zuluVersion = "22.28.91";
       jdkVersion = "22.0.0";
       hash =
-        if enableJavaFX then "sha256-o0VkWB4+PzBmNNWy+FZlyjTgukBTe6owfydb3YNfEE0="
+        if enableJavaFX then "sha256-256UP6MtUReQYqCKVt0ThN9BVDyKLAMXQTdpcDB9t24="
         else "sha256-o0VkWB4+PzBmNNWy+FZlyjTgukBTe6owfydb3YNfEE0=";
     };
   };

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

···
   Rlang-QQ = dontCheck super.Rlang-QQ;
   safecopy = dontCheck super.safecopy;
   sai-shape-syb = dontCheck super.sai-shape-syb;
-  saltine = dontCheck super.saltine; # https://github.com/tel/saltine/pull/56
   scp-streams = dontCheck super.scp-streams;
   sdl2 = dontCheck super.sdl2; # the test suite needs an x server
   separated = dontCheck super.separated;
···
   translatable-intset = dontCheck super.translatable-intset;
   ua-parser = dontCheck super.ua-parser;
   unagi-chan = dontCheck super.unagi-chan;
+  universe-some = dontCheck super.universe-some;
   wai-logger = dontCheck super.wai-logger;
   WebBits = dontCheck super.WebBits;                    # http://hydra.cryp.to/build/499604/log/raw
   webdriver = dontCheck super.webdriver;
···
   # https://github.com/haskell/hoopl/issues/50
   hoopl = dontCheck super.hoopl;
 
-  # Generate shell completion for spago
-  spago = self.generateOptparseApplicativeCompletions [ "spago" ] super.spago;
-
   # https://github.com/DanielG/cabal-helper/pull/123
   cabal-helper = doJailbreak super.cabal-helper;
 
···
     (dontCheckIf (!pkgs.postgresql.doCheck))
   ];
 
+  # Requires pqueue <1.5 but it works fine with pqueue-1.5.0.0
+  # https://github.com/haskell-beam/beam/pull/705
+  beam-migrate = doJailbreak super.beam-migrate;
+
   users-postgresql-simple = addTestToolDepends [
     pkgs.postgresql
     pkgs.postgresqlTestHook
   ] super.users-postgresql-simple;
 
+  # Need https://github.com/obsidiansystems/gargoyle/pull/45
+  gargoyle = doJailbreak super.gargoyle;
+  gargoyle-postgresql = doJailbreak super.gargoyle-postgresql;
+  gargoyle-postgresql-nix = doJailbreak (addBuildTool [pkgs.postgresql] super.gargoyle-postgresql-nix);
+  gargoyle-postgresql-connect = doJailbreak super.gargoyle-postgresql-connect;
+
   # PortMidi needs an environment variable to have ALSA find its plugins:
   # https://github.com/NixOS/nixpkgs/issues/6860
   PortMidi = overrideCabal (drv: {
···
 
   # Fix build with attr-2.4.48 (see #53716)
   xattr = appendPatch ./patches/xattr-fix-build.patch super.xattr;
-
-  patch = dontCheck super.patch;
 
   esqueleto =
     overrideCabal
···
   # 2021-12-26: Too strict bounds on doctest
   polysemy-plugin = doJailbreak super.polysemy-plugin;
 
-  # hasn’t bumped upper bounds
-  # upstream: https://github.com/obsidiansystems/which/pull/6
-  which = doJailbreak super.which;
-
-
   # 2024-02-28: The Hackage version dhall-lsp-server-1.1.3 requires
   # lsp-1.4.0.0 which is hard to build with this LTS. However, the latest
   # git version of dhall-lsp-server works with lsp-2.1.0.0, and only
···
       doJailbreak
     ];
 
-  # 2022-03-16: lens bound can be loosened https://github.com/ghcjs/jsaddle-dom/issues/19
   jsaddle-dom = overrideCabal (old: {
     postPatch = old.postPatch or "" + ''
-      sed -i 's/lens.*4.20/lens/' jsaddle-dom.cabal
       rm Setup.hs
     '';
-  }) (doJailbreak super.jsaddle-dom);
+  }) super.jsaddle-dom;
   jsaddle-hello = doJailbreak super.jsaddle-hello;
   ghcjs-dom-hello = doJailbreak super.ghcjs-dom-hello;
 
···
   # https://github.com/adnelson/semver-range/issues/15
   semver-range = dontCheck super.semver-range;
 
-  # https://github.com/obsidiansystems/dependent-sum/issues/55
-  dependent-sum = doJailbreak super.dependent-sum;
-
   # 2022-06-19: Disable checks because of https://github.com/reflex-frp/reflex/issues/475
   reflex = doJailbreak (dontCheck super.reflex);
 
···
   # Issue reported upstream, no bug tracker url yet.
   darcs = doJailbreak super.darcs;
 
-  # Too strict version bounds on cryptonite and github.
-  # PRs are merged, will be fixed next release or Hackage revision.
-  nix-thunk = appendPatches [
-    (fetchpatch {
-      url = "https://github.com/obsidiansystems/nix-thunk/commit/49d27a85dd39cd9413c99958c67e596756a502b5.patch";
-      sha256 = "1p1n0123yrbdqyfk4kx3gq6bdv65l1bxgbsg51ckcwclg54xp2p5";
-    })
-    (fetchpatch {
-      url = "https://github.com/obsidiansystems/nix-thunk/commit/512867c651977265d5d8f456b538f7a364ec8a8b.patch";
-      sha256 = "121yg26y4g28k8xv7y1j6c3pxm17vsjn3vi62kkc8g928c47yd02";
-    })
-  ] super.nix-thunk;
+  # Need https://github.com/obsidiansystems/cli-extras/pull/12 and more
+  cli-extras = doJailbreak super.cli-extras;
+
+  # https://github.com/obsidiansystems/cli-git/pull/7 turned into a flat patch
+  cli-git = lib.pipe super.cli-git [
+    (appendPatch (fetchpatch {
+      url = "https://github.com/obsidiansystems/cli-git/commit/be378a97e2f46522174231b77c952f759df3fad6.patch";
+      sha256 = "sha256-6RrhqkKpnb+FTHxccHNx6pdC7ClfqcJ2eoo+W7h+JUo=";
+      excludes = [ ".github/**" ];
+    }))
+    doJailbreak
+    (addBuildTool pkgs.git)
+  ];
+
+  # Need https://github.com/obsidiansystems/cli-nix/pull/5 and more
+  cli-nix = addBuildTools [
+    pkgs.nix
+    pkgs.nix-prefetch-git
+  ] (doJailbreak super.cli-nix);
+
+  # https://github.com/obsidiansystems/nix-thunk/pull/51/
+  nix-thunk = appendPatch (fetchpatch {
+    url = "https://github.com/obsidiansystems/nix-thunk/commit/c3dc3e799e8ce7756330f98b9f73f59c4b7a5502.patch";
+    sha256 = "sha256-C1ii1FXiCPFfw5NzyQZ0cEG6kIYGohVsnHycpYEJ24Q=";
+  }) (doJailbreak super.nix-thunk);
 
   # list `modbus` in librarySystemDepends, correct to `libmodbus`
   libmodbus = doJailbreak (addExtraLibrary pkgs.libmodbus super.libmodbus);
···
 
   ginger = doJailbreak super.ginger;
 
-  # Too strict version bounds on cryptonite
-  # https://github.com/obsidiansystems/haveibeenpwned/issues/7
-  haveibeenpwned = doJailbreak super.haveibeenpwned;
+  # 2024-05-05 syntax changes: https://github.com/obsidiansystems/haveibeenpwned/pull/9
+  haveibeenpwned = appendPatch
+    (fetchpatch {
+      url = "https://github.com/obsidiansystems/haveibeenpwned/pull/9/commits/14c134eec7de12f755b2d4667727762a8a1a6476.patch";
+      sha256 = "sha256-fau5+b6tufJ+MscrLgbYvvBsekPe8R6QAy/4H31dcQ4";
+    })
+    (doJailbreak super.haveibeenpwned);
+
 
   # Too strict version bounds on ghc-events
   # https://github.com/mpickering/hs-speedscope/issues/16
···
             compiler: ${self.ghc.haskellCompilerName}
 
             core-packages:
-              # Hack: The following package is a core package of GHCJS. If we don't declare
-              # it, then hackage2nix will generate a Hackage database where all dependants
-              # of this library are marked as "broken".
-              - ghcjs-base-0
-
             EOF
 
             ghc-pkg list \
···
   # 2022-03-16: Upstream stopped updating bounds https://github.com/haskell-hvr/base-noprelude/pull/15
   base-noprelude = doJailbreak super.base-noprelude;
 
-  # 2022-03-16: Bounds need to be loosened https://github.com/obsidiansystems/dependent-sum-aeson-orphans/issues/10
-  dependent-sum-aeson-orphans = doJailbreak super.dependent-sum-aeson-orphans;
+  # 2025-05-05: Bounds need to be loosened https://github.com/obsidiansystems/dependent-sum-aeson-orphans/pull/13
+  dependent-monoidal-map = appendPatch (fetchpatch {
+    url = "https://github.com/obsidiansystems/dependent-monoidal-map/commit/3f8be15fa9bd2796d1c917e9f0979b4d6c62cf91.patch";
+    hash = "sha256-QKDUh4jO8xZrThrkjTVNnkoVY+GejxOhpXOVA4+n1H8=";
+  }) super.dependent-monoidal-map;
+
+  # 2025-05-05: Bounds need to be loosened https://github.com/obsidiansystems/dependent-sum-aeson-orphans/pull/13
+  dependent-sum-aeson-orphans = appendPatch (fetchpatch {
+    url = "https://github.com/obsidiansystems/dependent-sum-aeson-orphans/commit/9b4698154303a9865d7d68a2f01d280a8a39f108.patch";
+    hash = "sha256-Pzjl2yp01XsYWcyhpLnsuccg7bOACgv+RpafauUox8c=";
+  }) super.dependent-sum-aeson-orphans;
+
+  # https://github.com/obsidiansystems/dependent-sum/pull/73
+  dependent-sum-template = appendPatch (fetchpatch {
+    url = "https://github.com/obsidiansystems/dependent-sum/commit/619727ba1792e39a68d23c62e75a923672e87a54.patch";
+    hash = "sha256-SyD1/KrX1KUjrR82fvI+BRcqLC2Q3AbvSeKNrdGstjg=";
+    relative = "dependent-sum-template";
+  }) super.dependent-sum-template;
+
+  aeson-gadt-th = appendPatch (fetchpatch {
+    url = "https://github.com/obsidiansystems/aeson-gadt-th/commit/8f6922a6440019dece637d73d70766c473bcd6c0.patch";
+    hash = "sha256-564DhfiubwNV8nAj8L5DzsWn4MdzqqaYYNmOSPUa7ys=";
+    excludes = [ ".github/**" ];
+  }) super.aeson-gadt-th;
 
   # Too strict bounds on chell: https://github.com/fpco/haskell-filesystem/issues/24
   system-fileio = doJailbreak super.system-fileio;
···
   # https://github.com/ngless-toolkit/ngless/issues/152
   NGLess = dontCheck super.NGLess;
 
-  # Raise version bounds for hspec
+  # Raise version bounds: https://github.com/well-typed/lens-sop/pull/4
+  lens-sop = appendPatches [
+    (fetchpatch {
+      url = "https://github.com/well-typed/lens-sop/commit/d8657f27c12191a7c0a91701c0fcd9a590e0090e.patch";
+      sha256 = "sha256-9ODfbOb6Bs3EVTY9b7cUvkNmqzzZPWUmgmlAneaN3Tw=";
+    })
+    (fetchpatch {
+      url = "https://github.com/well-typed/lens-sop/commit/b7ecffdeb836d19373871659e2f8cd24da6f7312.patch";
+      sha256 = "sha256-hDUQ2fW9Qyom65YvtW9bsbz7XtueRmdsAbAB42D+gu4=";
+    })
+  ] super.lens-sop;
+
+  # Raise version bounds: https://github.com/kosmikus/records-sop/pull/15
   records-sop = appendPatch (fetchpatch {
-    url = "https://github.com/kosmikus/records-sop/pull/11/commits/d88831388ab3041190130fec3cdd679a4217b3c7.patch";
-    sha256 = "sha256-O+v/OxvqnlWX3HaDvDIBZnJ+Og3xs/SJqI3gaouU3ZI=";
+    url = "https://github.com/kosmikus/records-sop/commit/fb149f453a816ff14d0cb20b3ea56b80ff49d9f1.patch";
+    sha256 = "sha256-iHiF4EWL/GjJFnr/6aR+yMZKLMLAZK+gsgSxG8YaeDI=";
   }) super.records-sop;
+
+  # Need https://github.com/well-typed/large-records/pull/151
+  large-generics = doJailbreak super.large-generics;
 
   # Fix build failures for ghc 9 (https://github.com/mokus0/polynomial/pull/20)
   polynomial = appendPatch (fetchpatch {
···
 
   # Requires a newer zlib version than stackage provides
   futhark = super.futhark.override {
-    zlib = self.zlib_0_7_0_0;
+    zlib = self.zlib_0_7_1_0;
   };
 
   # Tests rely on (missing) submodule
···
   # 2024-03-25: HSH broken because of the unix-2.8.0.0 breaking change
   HSH = appendPatches [./patches/HSH-unix-openFd.patch] super.HSH;
 
+  # Support unix < 2.8 to build in older ghc than 9.6
+  linux-namespaces = appendPatch
+    (fetchpatch {
+      url = "https://github.com/redneb/hs-linux-namespaces/commit/f4a3546541bb6c7172fdd03e177a961da60e3951.patch";
+      sha256 = "sha256-6Qv7NWIbzR3ktMGFogw5597bIqPH7Z4hoFvvBQAoquY=";
+    })
+    super.linux-namespaces;
+
   inherit
     (let
       unbreakRepa = packageName: drv: lib.pipe drv [
···
 
   # Too strict bounds on text. Can be removed after https://github.com/alx741/currencies/pull/3 is merged
   currencies = doJailbreak super.currencies;
+
+  # https://github.com/awakesecurity/proto3-wire/pull/104
+  proto3-wire = appendPatch (pkgs.fetchpatch {
+    url = "https://github.com/awakesecurity/proto3-wire/commit/c1cadeb5fca2e82c5b28e2811c01f5b37eb21ed8.patch";
+    hash = "sha256-tFOWpjGmZANC7H82QapZ36raaNWuZ6F3BgjxnfTXpMs=";
+  }) super.proto3-wire;
+
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
 
   # Tests fail on macOS https://github.com/mrkkrp/zip/issues/112
   zip = dontCheck super.zip;
+
+  # cabal lib set as unbuildable in linux so callCabal2nix generates a dummy derivation
+  jsaddle-wkwebview = overrideCabal (drv: {
+    libraryFrameworkDepends = with pkgs.buildPackages.darwin.apple_sdk.frameworks; [ Cocoa WebKit ];
+    libraryHaskellDepends = with self; [ aeson data-default jsaddle ];
+  }) super.jsaddle-wkwebview;
+
 } // lib.optionalAttrs pkgs.stdenv.isAarch64 {  # aarch64-darwin
 
   # https://github.com/fpco/unliftio/issues/87

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

···
   base-noprelude = doJailbreak super.base-noprelude;
   unliftio-core = doJailbreak super.unliftio-core;
 
-  # Jailbreaking because monoidal-containers hasn’t bumped it's base dependency for 8.10.
-  monoidal-containers = doJailbreak super.monoidal-containers;
-
   # Jailbreak to fix the build.
   brick = doJailbreak super.brick;
   exact-pi = doJailbreak super.exact-pi;

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

···
       sha256 = "sha256-b7u9GiIAd2xpOrM0MfILHNb6Nt7070lNRIadn2l3DfQ=";
     })];
   }) super.ConfigFile;
+
+  # This runs into the following GHC bug currently affecting 9.6.* and 9.8.* as
+  # well as 9.10.1: https://gitlab.haskell.org/ghc/ghc/-/issues/24432
+  inherit (lib.mapAttrs (_: overrideCabal (drv: {
+      badPlatforms = drv.badPlatforms or [ ] ++ [ "aarch64-linux" ];
+    })) super)
+    mueval
+    lambdabot
+    lambdabot-haskell-plugins
+    ;
 }
 # super.ghc is required to break infinite recursion as Nix is strict in the attrNames
 // lib.optionalAttrs (pkgs.stdenv.hostPlatform.isAarch64 && lib.versionOlder super.ghc.version "9.6.4") {

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

···
   #
   blaze-svg = doJailbreak super.blaze-svg; # base <4.19
   commutative-semigroups = doJailbreak super.commutative-semigroups; # base < 4.19
+  dependent-sum-template = doJailbreak super.dependent-sum-template_0_2_0_1; # template-haskell < 2.21
   diagrams-lib = doJailbreak super.diagrams-lib; # base <4.19, text <2.1
   diagrams-postscript = doJailbreak super.diagrams-postscript;  # base <4.19, bytestring <0.12
   diagrams-svg = doJailbreak super.diagrams-svg;  # base <4.19, text <2.1
+  generics-sop = doJailbreak super.generics-sop_0_5_1_4; # th-abstraction >=0.6 && <0.7
   ghc-trace-events = doJailbreak super.ghc-trace-events; # text < 2.1, bytestring < 0.12, base < 4.19
+  hashing = doJailbreak super.hashing; # bytestring <0.12
+  json-sop = doJailbreak super.json-sop; # aeson <2.2, base <4.19, text <2.1
   primitive-unlifted = doJailbreak super.primitive-unlifted; # bytestring < 0.12
   statestack = doJailbreak super.statestack; # base < 4.19
   newtype-generics = doJailbreak super.newtype-generics; # base < 4.19
···
   terminfo_0_4_1_6 = doJailbreak super.terminfo_0_4_1_6;
   HaskellNet-SSL = doJailbreak super.HaskellNet-SSL; # bytestring >=0.9 && <0.12
   raven-haskell = doJailbreak super.raven-haskell; # aeson <2.2
+  saltine = doJailbreak super.saltine; # bytestring  && <0.12, deepseq <1.5, text > 1.2 && <1.3 || >=2.0 && <2.1
   stripe-concepts = doJailbreak super.stripe-concepts; # text >=1.2.5 && <1.3 || >=2.0 && <2.1
   stripe-signature = doJailbreak super.stripe-signature; # text >=1.2.5 && <1.3 || >=2.0 && <2.1
   string-random = doJailbreak super.string-random; # text >=1.2.2.1 && <2.1
   inflections = doJailbreak super.inflections; # text >=0.2 && <2.1
+  universe-some = doJailbreak super.universe-some; # th-abstraction < 0.7
 
   #
   # Test suite issues
···
         sha256 = "Q4fA2J/Tq+WernBo+UIMdj604ILOMlIYkG4Pr046DfM=";
       })
     super.libmpd;
+
+  # Loosen bounds
+  patch = appendPatch (pkgs.fetchpatch {
+    url = "https://github.com/reflex-frp/patch/commit/91fed138483a7bf2b098d45b9e5cc36191776320.patch";
+    sha256 = "sha256-/KLfIshia88lU5G/hA7ild7+a2mqc7qgSa9AEBqEqkQ=";
+  }) super.patch;
+  reflex = appendPatch (pkgs.fetchpatch {
+    url = "https://github.com/reflex-frp/reflex/commit/0ac53ca3eab2649dd3f3edc585e10af8d13b28cd.patch";
+    sha256 = "sha256-umjwgdSKebJdRrXjwHhsi8HBqotx1vFibY9ttLkyT/0=";
+  }) super.reflex;
 
 }

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

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

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

···
   - acme-memorandom # failure in job https://hydra.nixos.org/build/233222926 at 2023-09-02
   - acme-miscorder # failure in job https://hydra.nixos.org/build/233209957 at 2023-09-02
   - acme-mutable-package # failure in job https://hydra.nixos.org/build/233213349 at 2023-09-02
+  - acme-not-a-joke # failure in job https://hydra.nixos.org/build/259604911 at 2024-05-15
   - acme-now # failure in job https://hydra.nixos.org/build/233243289 at 2023-09-02
   - acme-numbersystem # failure in job https://hydra.nixos.org/build/233208106 at 2023-09-02
   - acme-operators # failure in job https://hydra.nixos.org/build/233248282 at 2023-09-02
···
   - aeson-flat # failure in job https://hydra.nixos.org/build/233220787 at 2023-09-02
   - aeson-flatten # failure in job https://hydra.nixos.org/build/233242954 at 2023-09-02
   - aeson-flowtyped # failure in job https://hydra.nixos.org/build/233245878 at 2023-09-02
-  - aeson-gadt-th # failure in job https://hydra.nixos.org/build/233247060 at 2023-09-02
   - aeson-generics-typescript # failure in job https://hydra.nixos.org/build/245703304 at 2024-01-07
   - aeson-injector # failure in job https://hydra.nixos.org/build/233200351 at 2023-09-02
   - aeson-json-ast # failure in job https://hydra.nixos.org/build/233249406 at 2023-09-02
···
   - bash # failure in job https://hydra.nixos.org/build/252719390 at 2024-03-16
   - basic-gps # failure in job https://hydra.nixos.org/build/252718385 at 2024-03-16
   - basics # failure in job https://hydra.nixos.org/build/236678238 at 2023-10-04
-  - basic-sop # failure in job https://hydra.nixos.org/build/233253357 at 2023-09-02
   - baskell # failure in job https://hydra.nixos.org/build/233246705 at 2023-09-02
   - battlenet # failure in job https://hydra.nixos.org/build/233260076 at 2023-09-02
   - battleplace # failure in job https://hydra.nixos.org/build/233230199 at 2023-09-02
···
   - bdo # failure in job https://hydra.nixos.org/build/233216486 at 2023-09-02
   - beamable # failure in job https://hydra.nixos.org/build/233211619 at 2023-09-02
   - beam # failure in job https://hydra.nixos.org/build/233213313 at 2023-09-02
-  - beam-migrate # failure in job https://hydra.nixos.org/build/252730758 at 2024-03-16
   - beam-mysql # failure in job https://hydra.nixos.org/build/233253237 at 2023-09-02
   - beam-newtype-field # failure in job https://hydra.nixos.org/build/233206317 at 2023-09-02
   - bech32 # failure in job https://hydra.nixos.org/build/233194823 at 2023-09-02
···
   - cayene-lpp # failure in job https://hydra.nixos.org/build/233228959 at 2023-09-02
   - cayley-client # failure in job https://hydra.nixos.org/build/233260112 at 2023-09-02
   - cblrepo # failure in job https://hydra.nixos.org/build/233251926 at 2023-09-02
-  - cbor-tool # failure in job https://hydra.nixos.org/build/233198797 at 2023-09-02
   - CCA # failure in job https://hydra.nixos.org/build/233206723 at 2023-09-02
   - ccast # failure in job https://hydra.nixos.org/build/233254517 at 2023-09-02
   - CC-delcont-cxe # failure in job https://hydra.nixos.org/build/233190865 at 2023-09-02
···
   - changelog-d # failure in job https://hydra.nixos.org/build/253689337 at 2024-03-31
   - changelog-d # failure in job https://hydra.nixos.org/build/255671571 at 2024-04-16
   - changelog-d # failure in job https://hydra.nixos.org/build/257082502 at 2024-04-27
+  - changelog-d # failure in job https://hydra.nixos.org/build/259607598 at 2024-05-15
   - changelogged # failure in job https://hydra.nixos.org/build/233211675 at 2023-09-02
   - character-cases # failure in job https://hydra.nixos.org/build/233197636 at 2023-09-02
   - charter # failure in job https://hydra.nixos.org/build/233237264 at 2023-09-02
···
   - clevercss # failure in job https://hydra.nixos.org/build/233206298 at 2023-09-02
   - clexer # failure in job https://hydra.nixos.org/build/233229804 at 2023-09-02
   - cli-builder # failure in job https://hydra.nixos.org/build/233209961 at 2023-09-02
-  - cli-extras # failure in job https://hydra.nixos.org/build/233226908 at 2023-09-02
   - CLI # failure in job https://hydra.nixos.org/build/233191087 at 2023-09-02
   - clif # failure in job https://hydra.nixos.org/build/233197110 at 2023-09-02
   - clifm # failure in job https://hydra.nixos.org/build/233227426 at 2023-09-02
···
   - core-haskell # failure in job https://hydra.nixos.org/build/233222588 at 2023-09-02
   - corenlp-types # failure in job https://hydra.nixos.org/build/243808366 at 2024-01-01
   - core-warn # failure in job https://hydra.nixos.org/build/233204404 at 2023-09-02
+  - cornelis # failure in job https://hydra.nixos.org/build/259604220 at 2024-05-15
   - Coroutine # failure in job https://hydra.nixos.org/build/233211213 at 2023-09-02
   - coroutine-object # failure in job https://hydra.nixos.org/build/233220413 at 2023-09-02
   - couchdb-conduit # failure in job https://hydra.nixos.org/build/233227244 at 2023-09-02
···
   - dense-int-set # failure in job https://hydra.nixos.org/build/233214797 at 2023-09-02
   - dependency # failure in job https://hydra.nixos.org/build/252727325 at 2024-03-16
   - dependent-hashmap # failure in job https://hydra.nixos.org/build/233202881 at 2023-09-02
-  - dependent-monoidal-map # failure in job https://hydra.nixos.org/build/233212829 at 2023-09-02
   - dep-t # failure in job https://hydra.nixos.org/build/233217847 at 2023-09-02
   - deptrack-core # failure in job https://hydra.nixos.org/build/233239143 at 2023-09-02
   - derangement # failure in job https://hydra.nixos.org/build/233209660 at 2023-09-02
···
   - dijkstra-simple # failure in job https://hydra.nixos.org/build/233218373 at 2023-09-02
   - DimensionalHash # failure in job https://hydra.nixos.org/build/233230945 at 2023-09-02
   - dino # failure in job https://hydra.nixos.org/build/252725815 at 2024-03-16
+  - diohsc # failure in job https://hydra.nixos.org/build/259625302 at 2024-05-15
   - diophantine # failure in job https://hydra.nixos.org/build/233229215 at 2023-09-02
   - diplomacy # failure in job https://hydra.nixos.org/build/233207895 at 2023-09-02
   - direct-binary-files # failure in job https://hydra.nixos.org/build/233246387 at 2023-09-02
···
   - erlang # failure in job https://hydra.nixos.org/build/233195837 at 2023-09-02
   - erlang-ffi # failure in job https://hydra.nixos.org/build/233233314 at 2023-09-02
   - eros # failure in job https://hydra.nixos.org/build/233247983 at 2023-09-02
+  - errata # failure in job https://hydra.nixos.org/build/259627186 at 2024-05-15
   - errno # failure in job https://hydra.nixos.org/build/252725782 at 2024-03-16
   - error-context # failure in job https://hydra.nixos.org/build/233245027 at 2023-09-02
   - error-continuations # failure in job https://hydra.nixos.org/build/233232357 at 2023-09-02
···
   - gang-of-threads # failure in job https://hydra.nixos.org/build/252716251 at 2024-03-16
   - Ganymede # failure in job https://hydra.nixos.org/build/233248892 at 2023-09-02
   - garepinoh # failure in job https://hydra.nixos.org/build/233238111 at 2023-09-02
-  - gargoyle # failure in job https://hydra.nixos.org/build/233196445 at 2023-09-02
   - gas # failure in job https://hydra.nixos.org/build/233233966 at 2023-09-02
   - gasp # failure in job https://hydra.nixos.org/build/252731457 at 2024-03-16
   - gather # failure in job https://hydra.nixos.org/build/233208848 at 2023-09-02
···
   - hat # failure in job https://hydra.nixos.org/build/233243655 at 2023-09-02
   - hats # failure in job https://hydra.nixos.org/build/233256724 at 2023-09-02
   - hatt # failure in job https://hydra.nixos.org/build/233195039 at 2023-09-02
-  - haveibeenpwned # failure in job https://hydra.nixos.org/build/233253058 at 2023-09-02
   - haven # failure in job https://hydra.nixos.org/build/233216806 at 2023-09-02
   - haverer # failure in job https://hydra.nixos.org/build/233210491 at 2023-09-02
   - hax # failure in job https://hydra.nixos.org/build/233212147 at 2023-09-02
···
   - jort # failure in job https://hydra.nixos.org/build/233195250 at 2023-09-02
   - joy-rewrite # failure in job https://hydra.nixos.org/build/233201002 at 2023-09-02
   - jpeg # failure in job https://hydra.nixos.org/build/233204056 at 2023-09-02
-  - jsaddle-clib # failure in job https://hydra.nixos.org/build/233203899 at 2023-09-02
-  - jsaddle-wkwebview # failure in job https://hydra.nixos.org/build/233242986 at 2023-09-02
   - js-good-parts # failure in job https://hydra.nixos.org/build/233198958 at 2023-09-02
   - json2 # failure in job https://hydra.nixos.org/build/233242447 at 2023-09-02
   - json-alt # failure in job https://hydra.nixos.org/build/233242230 at 2023-09-02
···
   - language-webidl # failure in job https://hydra.nixos.org/build/233194656 at 2023-09-02
   - laop # failure in job https://hydra.nixos.org/build/233204106 at 2023-09-02
   - LargeCardinalHierarchy # failure in job https://hydra.nixos.org/build/233250339 at 2023-09-02
-  - large-generics # failure in job https://hydra.nixos.org/build/233210324 at 2023-09-02
+  - large-records
   - Lastik # failure in job https://hydra.nixos.org/build/233194460 at 2023-09-02
   - latest-npm-version # failure in job https://hydra.nixos.org/build/233239108 at 2023-09-02
   - latex-formulae-image # failure in job https://hydra.nixos.org/build/233251243 at 2023-09-02
···
   - lens-process # failure in job https://hydra.nixos.org/build/233242948 at 2023-09-02
   - lensref # failure in job https://hydra.nixos.org/build/233205479 at 2023-09-02
   - lens-simple # failure in job https://hydra.nixos.org/build/233245452 at 2023-09-02
-  - lens-sop # failure in job https://hydra.nixos.org/build/252721754 at 2024-03-16
   - lens-tell # failure in job https://hydra.nixos.org/build/233234619 at 2023-09-02
   - lens-text-encoding # failure in job https://hydra.nixos.org/build/233222713 at 2023-09-02
   - lens-th-rewrite # failure in job https://hydra.nixos.org/build/233201025 at 2023-09-02
···
   - op2 # failure in job https://hydra.nixos.org/build/255683846 at 2024-04-16
   - opaleye-classy # failure in job https://hydra.nixos.org/build/233214120 at 2023-09-02
   - opaleye-sqlite # failure in job https://hydra.nixos.org/build/233191474 at 2023-09-02
+  - opaleye-textsearch # failure in job https://hydra.nixos.org/build/259602432 at 2024-05-15
   - opaleye-trans # failure in job https://hydra.nixos.org/build/233210536 at 2023-09-02
   - open-adt # failure in job https://hydra.nixos.org/build/233201191 at 2023-09-02
   - OpenAFP # failure in job https://hydra.nixos.org/build/233249295 at 2023-09-02
···
   - process-sequential # failure in job https://hydra.nixos.org/build/233221064 at 2023-09-02
   - procrastinating-variable # failure in job https://hydra.nixos.org/build/233229350 at 2023-09-02
   - procstat # failure in job https://hydra.nixos.org/build/233256320 at 2023-09-02
+  - prodapi # failure in job https://hydra.nixos.org/build/259624456 at 2024-05-15
   - product-isomorphic # failure in job https://hydra.nixos.org/build/233230736 at 2023-09-02
   - prof2pretty # failure in job https://hydra.nixos.org/build/233240665 at 2023-09-02
   - prof-flamegraph # failure in job https://hydra.nixos.org/build/233254675 at 2023-09-02
···
   - pro-source # failure in job https://hydra.nixos.org/build/233226793 at 2023-09-02
   - prosper # failure in job https://hydra.nixos.org/build/233244079 at 2023-09-02
   - proteaaudio # failure in job https://hydra.nixos.org/build/233225498 at 2023-09-02
-  - proto3-wire # failure in job https://hydra.nixos.org/build/233208217 at 2023-09-02
   - protocol-buffers # failure in job https://hydra.nixos.org/build/233220653 at 2023-09-02
   - protocol-buffers-fork # failure in job https://hydra.nixos.org/build/233228361 at 2023-09-02
   - protocol # failure in job https://hydra.nixos.org/build/233224436 at 2023-09-02
-  - proto-lens-arbitrary # failure in job https://hydra.nixos.org/build/233239393 at 2023-09-02
   - proto-lens-combinators # failure in job https://hydra.nixos.org/build/252726979 at 2024-03-16
   - protolude-lifted # failure in job https://hydra.nixos.org/build/233196312 at 2023-09-02
   - proton-haskell # failure in job https://hydra.nixos.org/build/233214383 at 2023-09-02
···
   - record-encode # failure in job https://hydra.nixos.org/build/233216156 at 2023-09-02
   - record # failure in job https://hydra.nixos.org/build/233242406 at 2023-09-02
   - records # failure in job https://hydra.nixos.org/build/233254822 at 2023-09-02
-  - records-sop # failure in job https://hydra.nixos.org/build/233251652 at 2023-09-02
   - record-wrangler # failure in job https://hydra.nixos.org/build/233212838 at 2023-09-02
   - rec-smallarray # failure in job https://hydra.nixos.org/build/233258592 at 2023-09-02
   - recursive-line-count # failure in job https://hydra.nixos.org/build/252736942 at 2024-03-16
···
   - stm-firehose # failure in job https://hydra.nixos.org/build/233220943 at 2023-09-02
   - stm-lifted # failure in job https://hydra.nixos.org/build/252726872 at 2024-03-16
   - stm-promise # failure in job https://hydra.nixos.org/build/233204293 at 2023-09-02
+  - stm-queue # failure in job https://hydra.nixos.org/build/259624889 at 2024-05-15
   - stm-stats # failure in job https://hydra.nixos.org/build/233214914 at 2023-09-02
   - stochastic # failure in job https://hydra.nixos.org/build/233242019 at 2023-09-02
   - Stomp # failure in job https://hydra.nixos.org/build/233252583 at 2023-09-02
···
   - universal-binary # failure in job https://hydra.nixos.org/build/233240583 at 2023-09-02
   - universe-instances-base # failure in job https://hydra.nixos.org/build/233197845 at 2023-09-02
   - universe-instances-trans # failure in job https://hydra.nixos.org/build/233235623 at 2023-09-02
-  - universe-some # failure in job https://hydra.nixos.org/build/233254356 at 2023-09-02
   - unix-handle # failure in job https://hydra.nixos.org/build/233233273 at 2023-09-02
   - unix-memory # failure in job https://hydra.nixos.org/build/252735802 at 2024-03-16
   - unix-process-conduit # failure in job https://hydra.nixos.org/build/233191509 at 2023-09-02

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

···
   - gi-gdkx11 < 4
   # 2021-11-09: ghc-bignum is bundled starting with 9.0.1; only 1.0 builds with GHCs prior to 9.2.1
   - ghc-bignum == 1.0
+  - hie-bios == 0.13.1
+  # 2024-05-10: need to match hlegder from stackage
+  - hledger-ui < 1.33
 
 extra-packages:
   - Cabal-syntax == 3.6.*               # Dummy package that ensures packages depending on Cabal-syntax can work for Cabal < 3.8
   - Cabal == 3.2.*                      # Used for packages needing newer Cabal on ghc 8.6 and 8.8
   - Cabal == 3.6.*                      # used for packages needing newer Cabal on ghc 8.10 and 9.0
   - Cabal-syntax == 3.8.*               # version required for ormolu and fourmolu on ghc 9.2 and 9.0
-  - Cabal-syntax == 3.10.*              # newest version required for cabal-install and other packages
+  - Cabal-syntax == 3.10.*              # version required for cabal-install and other packages
+  - Cabal == 3.10.*                     # version required for cabal-install and other packages
   - directory == 1.3.7.*                # required to build cabal-install 3.10.* with GHC 9.2
   - Diff < 0.4                          # required by liquidhaskell-0.8.10.2: https://github.com/ucsd-progsys/liquidhaskell/issues/1729
   - aeson < 2                           # required by pantry-0.5.2
···
   - attoparsec == 0.13.*                # 2022-02-23: Needed to compile elm for now
   - base16-bytestring < 1               # required for cabal-install etc.
   - basement < 0.0.15                   # 2022-08-30: last version to support GHC < 8.10
-  - bower-json == 1.0.0.1               # 2022-05-21: Needed for spago 0.20.9
   - brick == 0.70.*                     # 2022-08-13: needed by taskell
   - brittany == 0.13.1.2                # 2022-09-20: needed for hls on ghc 8.8
   - crackNum < 3.0                      # 2021-05-21: 3.0 removed the lib which sbv 7.13 uses
···
   - algebraic-graphs < 0.7              # 2023-08-14: Needed for building weeder < 2.6.0
   - fuzzyset == 0.2.4                   # 2023-12-20: Needed for building postgrest > 10
   - ShellCheck == 0.9.0                 # 2024-03-21: pinned by haskell-ci
+  - versions < 6                        # 2024-04-22: required by spago-0.21
+  - fsnotify < 0.4                      # 2024-04-22: required by spago-0.21
 
 package-maintainers:
   abbradar:
···
   monomer:                                      [ platforms.darwin ] # depends on mesa
   monomer-hagrid:                               [ platforms.darwin ] # depends on mesa
   mptcp-pm:                                     [ platforms.darwin ]
-  mueval:                                       [ aarch64-linux ] # https://hydra.nixos.org/build/257076117/nixlog/2 https://gitlab.haskell.org/ghc/ghc/-/issues/24432
   nanovg:                                       [ platforms.darwin ] # depends on mesa
   netlink:                                      [ platforms.darwin ]
   notifications-tray-icon:                      [ platforms.darwin ] # depends on gi-dbusmenu
···
   htune:                                        [ platforms.linux ] # depends on alsa-pcm
   hw-prim-bits:                                 [ platforms.x86 ] # x86 assembler
   inline-asm:                                   [ platforms.x86 ] # x86 assembler
+  jsaddle-wkwebview:                            [ platforms.darwin ]
   keid-core:                                    [ x86_64-linux ] # geomancy (only x86), vulkan (no i686, no darwin, …)
   keid-frp-banana:                              [ x86_64-linux ] # geomancy (only x86), vulkan (no i686, no darwin, …)
   keid-geometry:                                [ x86_64-linux ] # geomancy (only x86), vulkan (no i686, no darwin, …)

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

···
-# Stackage LTS 22.17
+# Stackage LTS 22.18
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - atom-basic ==0.2.5
   - atom-conduit ==0.9.0.1
   - atomic-counter ==0.1.2.1
-  - atomic-primops ==0.8.5
+  - atomic-primops ==0.8.7
   - atomic-write ==0.2.0.7
   - attoparsec ==0.14.4
   - attoparsec-aeson ==2.1.0.0
···
   - doctest-exitcode-stdio ==0.0
   - doctest-extract ==0.1.2
   - doctest-lib ==0.1.1
-  - doctest-parallel ==0.3.1
+  - doctest-parallel ==0.3.1.1
   - doldol ==0.4.1.2
   - do-list ==1.0.1
   - domain ==0.1.1.5
···
   - haskoin-node ==1.0.1
   - haskoin-store-data ==1.2.5
   - hasktags ==0.73.0
-  - hasql ==1.6.4.3
+  - hasql ==1.6.4.4
   - hasql-dynamic-statements ==0.3.1.5
   - hasql-implicits ==0.1.1.2
   - hasql-interpolate ==0.2.1.0
···
   - hsini ==0.5.2.2
   - hsinstall ==2.8
   - HSlippyMap ==3.0.1
-  - hslogger ==1.3.1.0
+  - hslogger ==1.3.1.1
   - hslua ==2.3.1
   - hslua-aeson ==2.3.1
   - hslua-classes ==2.3.1
···
   - microlens ==0.4.13.1
   - microlens-aeson ==2.5.2
   - microlens-contra ==0.1.0.3
-  - microlens-ghc ==0.4.14.2
+  - microlens-ghc ==0.4.14.3
   - microlens-mtl ==0.2.0.3
   - microlens-platform ==0.4.3.5
-  - microlens-th ==0.4.3.14
+  - microlens-th ==0.4.3.15
   - microspec ==0.2.1.3
   - microstache ==1.0.2.3
   - midair ==0.2.0.1
···
   - network-messagepack-rpc ==0.1.2.0
   - network-messagepack-rpc-websocket ==0.1.1.1
   - network-multicast ==0.3.2
-  - network-run ==0.2.7
+  - network-run ==0.2.8
   - network-simple ==0.4.5
   - network-transport ==0.5.7
   - network-uri ==2.6.4.2
···
   - proto-lens-optparse ==0.1.1.12
   - proto-lens-runtime ==0.7.0.6
   - protolude ==0.3.4
-  - proxied ==0.3.1
+  - proxied ==0.3.2
   - psql-helpers ==0.1.0.0
   - PSQueue ==1.2.0
   - psqueues ==0.2.8.0
···
   - secp256k1-haskell ==1.1.0
   - securemem ==0.1.10
   - selections ==0.3.0.0
-  - selective ==0.7
+  - selective ==0.7.0.1
   - semialign ==1.3
   - semigroupoids ==6.0.0.1
   - semigroups ==0.20
···
   - symengine ==0.1.2.0
   - symmetry-operations-symbols ==0.0.2.1
   - synthesizer-alsa ==0.5.0.6
-  - synthesizer-core ==0.8.3
+  - synthesizer-core ==0.8.4
   - synthesizer-dimensional ==0.8.1.1
   - synthesizer-midi ==0.6.1.2
   - sysinfo ==0.1.1
···
   - text-regex-replace ==0.1.1.5
   - text-rope ==0.2
   - text-short ==0.1.5
-  - text-show ==3.10.4
-  - text-show-instances ==3.9.7
+  - text-show ==3.10.5
+  - text-show-instances ==3.9.8
   - text-zipper ==0.13
   - tfp ==1.0.2
   - tf-random ==0.5
···
   - wai-websockets ==3.0.1.2
   - wakame ==0.1.0.0
   - warp ==3.3.31
-  - warp-tls ==3.4.4
+  - warp-tls ==3.4.5
   - wave ==0.2.1
   - wcwidth ==0.0.2
   - webdriver ==0.12.0.0
···
   - writer-cps-transformers ==0.5.6.1
   - ws ==0.0.6
   - wss-client ==0.3.0.0
-  - wuss ==2.0.1.7
+  - wuss ==2.0.1.8
   - X11 ==1.10.3
   - X11-xft ==0.3.4
   - x11-xim ==0.0.9.0
···
   - zeromq4-patterns ==0.3.1.0
   - zigzag ==0.0.1.0
   - zim-parser ==0.2.1.0
-  - zip ==2.0.0
+  - zip ==2.0.1
   - zip-archive ==0.4.3.2
   - zippers ==0.3.2
   - zip-stream ==0.2.2.0

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

···
  - bdcs-api
  - beam-automigrate
  - beam-postgres
- - beam-sqlite
  - beam-th
  - bearriver
  - beautifHOL
  - bech32-th
- - beeminder-api
+ - bech32-th_1_1_6
  - bein
  - belka
  - bff
···
  - cleff-plugin
  - cless
  - cleveland
- - cli-git
- - cli-nix
  - click-clack
  - clickhouse-haskell
  - clifford
···
  - funion
  - funnyprint
  - funsat
- - fused-effects-squeal
  - fwgl-glfw
  - fwgl-javascript
  - fxpak
···
  - galois-fft
  - galois-field
  - gamma
- - gargoyle-postgresql
- - gargoyle-postgresql-connect
- - gargoyle-postgresql-nix
  - gbs-downloader
  - gbu
  - gdax
···
  - haskanoid
  - haskdeep
  - haskeem
- - haskell-abci
  - haskell-admin
  - haskell-admin-health
  - haskell-admin-managed-functions
···
  - json-query
  - json-rpc-client
  - json-schema
- - json-sop
  - json-spec-elm
  - json-spec-elm-servant
  - json-spec-openapi
···
  - language-qux
  - language-spelling
  - large-anon
- - large-records
  - lat
  - latex-formulae-hakyll
  - latex-formulae-pandoc
···
  - lol-typing
  - loli
  - longshot
+ - looksee
  - looksee-trip
  - loop-effin
  - lorentz
···
  - metar-http
  - metronome
  - micro-gateway
+ - microdns
  - microformats2-types
  - midimory
  - mighttpd
···
  - ngx-export-tools-extra
  - nikepub
  - nirum
- - nix-thunk
  - nkjp
  - nlp-scores-scripts
  - nom
···
  - process-qq
  - process-streaming
  - procrastinating-structure
+ - prodapi-proxy
+ - prodapi-userauth
  - producer
  - product
  - prof2dot
···
  - reflex-backend-wai
  - reflex-dom-colonnade
  - reflex-dynamic-containers
- - reflex-gadt-api
  - reflex-gloss-scene
  - reflex-libtelnet
  - reflex-localize
···
  - si-clock
  - sibe
  - sigma-ij
- - signable
  - signals
  - signature
  - silvi
···
  - sproxy
  - sproxy-web
  - sproxy2
+ - sq
  - sql-simple-mysql
  - sql-simple-pool
  - sql-simple-postgresql
···
  - sqlcli-odbc
  - sqlite-simple-interpolate
  - sqlite-simple-typed
- - squeal-postgresql
- - squeal-postgresql-ltree
- - squeal-postgresql-uuid-ossp
  - squeeze
  - sr-extra
  - srt-dhall
···
  - unitym-servant
  - unitym-yesod
  - universal
- - universe
- - universe-dependent-sum
  - universe-th
  - unix-fcntl
  - unpacked-these
···
  - verifiable-expressions
  - verismith
  - versioning-servant
- - vessel
  - vflow-types
  - vformat-aeson
  - vformat-time
  - vfr-waypoints
  - vigilance
  - vimeta
- - vinyl-generics
  - vinyl-operational
  - vision
  - visual-graphrewrite

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

···
         url = "https://github.com/purescript/purescript-docs-search/releases/download/v0.0.11/purescript-docs-search";
         sha256 = "1hjdprm990vyxz86fgq14ajn0lkams7i00h8k2i2g1a0hjdwppq6";
       };
-
-      spagoDocs = overrideCabal (drv: {
+    in
+    lib.pipe (super.spago.override {
+      versions = self.versions_5_0_5;
+      fsnotify = self.fsnotify_0_3_0_1;
+    }) [
+      (overrideCabal (drv: {
         postUnpack = (drv.postUnpack or "") + ''
           # Spago includes the following two files directly into the binary
           # with Template Haskell.  They are fetched at build-time from the
···
             "$sourceRoot/templates/docs-search-app-0.0.11.js" \
             "$sourceRoot/templates/purescript-docs-search-0.0.11"
         '';
-      }) super.spago;
-
-      spagoOldAeson = spagoDocs.overrideScope (hfinal: hprev: {
-        # spago is not yet updated for aeson 2.0
-        aeson = hfinal.aeson_1_5_6_0;
-        # bower-json 1.1.0.0 only supports aeson 2.0, so we pull in the older version here.
-        bower-json = hprev.bower-json_1_0_0_1;
-      });
+      }))
 
       # Tests require network access.
-      spagoWithoutChecks = dontCheck spagoOldAeson;
-    in
-    # spago doesn't currently build with ghc92.  Top-level spago is pulled from
-    # ghc90 and explicitly marked unbroken.
-    markBroken spagoWithoutChecks;
+      dontCheck
+
+      # Overly strict upper bound on text
+      doJailbreak
+
+      # Generate shell completion for spago
+      (self.generateOptparseApplicativeCompletions [ "spago" ])
+    ];
 
   # checks SQL statements at compile time, and so requires a running PostgreSQL
   # database to run it's test suite
···
   pvar = dontCheck super.pvar;
 
   kmonad = enableSeparateBinOutput super.kmonad;
+
+  xmobar = enableSeparateBinOutput super.xmobar;
 }

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

···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "Cabal_3_12_0_0" = callPackage
+    ({ mkDerivation, array, base, bytestring, Cabal-syntax, containers
+     , deepseq, directory, filepath, mtl, parsec, pretty, process, time
+     , transformers, unix
+     }:
+     mkDerivation {
+       pname = "Cabal";
+       version = "3.12.0.0";
+       sha256 = "0cqs1i4qyf4y2xyq8wgk1xbjy5ra9bk5pc8y9bhl82cvqm625qpp";
+       setupHaskellDepends = [ mtl parsec ];
+       libraryHaskellDepends = [
+         array base bytestring Cabal-syntax containers deepseq directory
+         filepath mtl parsec pretty process time transformers unix
+       ];
+       doCheck = false;
+       description = "A framework for packaging Haskell software";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "Cabal-ide-backend" = callPackage
     ({ mkDerivation, array, base, binary, bytestring, Cabal, containers
      , deepseq, directory, extensible-exceptions, filepath, HUnit
···
          array base binary bytestring containers deepseq directory filepath
          mtl parsec pretty text time transformers unix
        ];
+       description = "A library for working with .cabal files";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "Cabal-syntax_3_12_0_0" = callPackage
+    ({ mkDerivation, alex, array, base, binary, bytestring, containers
+     , deepseq, directory, filepath, mtl, parsec, pretty, text, time
+     , transformers
+     }:
+     mkDerivation {
+       pname = "Cabal-syntax";
+       version = "3.12.0.0";
+       sha256 = "090zv977zp85q6kwa2nwyh0plrb73dhss2wx00jdxz7v8zl2masp";
+       libraryHaskellDepends = [
+         array base binary bytestring containers deepseq directory filepath
+         mtl parsec pretty text time transformers
+       ];
+       libraryToolDepends = [ alex ];
        description = "A library for working with .cabal files";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
        ];
        description = "For testing partial and infinite values";
        license = lib.licenses.mit;
+     }) {};
+
+  "ChasingBottoms_1_3_1_14" = callPackage
+    ({ mkDerivation, array, base, containers, mtl, QuickCheck, random
+     , syb
+     }:
+     mkDerivation {
+       pname = "ChasingBottoms";
+       version = "1.3.1.14";
+       sha256 = "0rmpi7n0b9spvx84645z2zcnnvg75s40zl05c8iigzciyjax3v5y";
+       libraryHaskellDepends = [
+         base containers mtl QuickCheck random syb
+       ];
+       testHaskellDepends = [
+         array base containers mtl QuickCheck random syb
+       ];
+       description = "For testing partial and infinite values";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "CheatSheet" = callPackage
···
        pname = "HsYAML";
        version = "0.2.1.3";
        sha256 = "144xixvi6nfhg1rjq5aglj0vmvpf482rxzn5vlv19n4gbfnaj9p0";
+       revision = "1";
+       editedCabalFile = "0nxnk3lajarvfk0841x4zhqv7m3avscd21bzlnlism7dymq0dkh1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.gpl2Only;
      }) {};
 
+  "HsYAML_0_2_1_4" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, mtl, parsec
+     , QuickCheck, tasty, tasty-quickcheck, text, transformers
+     }:
+     mkDerivation {
+       pname = "HsYAML";
+       version = "0.2.1.4";
+       sha256 = "09hsva1qnnnyvbf7860wqpi5b3i6hbshf3wmhx3fm4hi7i3ak05m";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers deepseq mtl parsec text transformers
+       ];
+       testHaskellDepends = [
+         base bytestring containers mtl QuickCheck tasty tasty-quickcheck
+         text
+       ];
+       description = "Pure Haskell YAML 1.2 processor";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "HsYAML-aeson" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, HsYAML, mtl
      , scientific, text, unordered-containers, vector
···
        testHaskellDepends = [ base deepseq process ];
        description = "Automatic testing of Haskell programs";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "QuickCheck_2_15" = callPackage
+    ({ mkDerivation, base, containers, deepseq, process, random
+     , splitmix, template-haskell, transformers
+     }:
+     mkDerivation {
+       pname = "QuickCheck";
+       version = "2.15";
+       sha256 = "10hd896c8vb19aj3q0dg90aymsiq73ffxgx8z1p39w7x21m2vdnc";
+       libraryHaskellDepends = [
+         base containers deepseq random splitmix template-haskell
+         transformers
+       ];
+       testHaskellDepends = [ base containers deepseq process ];
+       description = "Automatic testing of Haskell programs";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "QuickCheck-GenT" = callPackage
···
        pname = "acid-state";
        version = "0.16.1.3";
        sha256 = "0vmggxzp6alv92ycwc9bc53vn73s1cbn8rhmbcb2jvcglyakvws5";
+       revision = "1";
+       editedCabalFile = "17m2071y2vam37ixgqa4rgfmcrwvc4x0k6a89hz70fmpzx52hhad";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "acme-not-a-joke" = callPackage
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+     , cryptohash-sha256, filepath, jose, lens, text, time, wreq
+     }:
+     mkDerivation {
+       pname = "acme-not-a-joke";
+       version = "0.1.0.0";
+       sha256 = "016zaz5mlbj9v1mwx8208azgvazdz7ng2g6971kjmsp3jxdp27v5";
+       libraryHaskellDepends = [
+         aeson base base16-bytestring bytestring cryptohash-sha256 filepath
+         jose lens text time wreq
+       ];
+       description = "implements ACME clients (rfc-8555)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "acme-now" = callPackage
     ({ mkDerivation, base, time }:
      mkDerivation {
···
        pname = "active";
        version = "0.2.1";
        sha256 = "150kwir36aj9q219qi80mlqd0vxm4941dh6x4xp58rbd5a3mhmv1";
+       revision = "2";
+       editedCabalFile = "16gc6vksf5gn5v6m9zbiphb2bd2chbypk8iykn1y7ak3f8g30asn";
        libraryHaskellDepends = [
          base lens linear semigroupoids semigroups vector
        ];
···
        ];
        description = "Derivation of Aeson instances for GADTs";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "readme";
-       broken = true;
      }) {};
 
   "aeson-generic-compat" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "ansi-terminal_1_1" = callPackage
+  "ansi-terminal_1_1_1" = callPackage
     ({ mkDerivation, ansi-terminal-types, base, colour }:
      mkDerivation {
        pname = "ansi-terminal";
-       version = "1.1";
-       sha256 = "0lxjf546x2b382hhg8ws2ay9yhva9kk07ki8lmgpbndsprbn4paj";
+       version = "1.1.1";
+       sha256 = "0k5wl5b9bzvkgplg4rgsz92rkps18s1qy5p560ypzad5z36qyi3y";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ ansi-terminal-types base colour ];
···
        pname = "ansi-terminal-game";
        version = "1.9.3.0";
        sha256 = "1yy7hzdcawdmwl8wqzabbamzjdg260xbwryj0hdjn7b0n6qlqymk";
+       revision = "1";
+       editedCabalFile = "0r2jm1yrprhh7wy06xxf3xw6m56wx5w4x3flig6cwgvgqk08py0s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, ghc-prim, primitive }:
      mkDerivation {
        pname = "atomic-primops";
-       version = "0.8.5";
-       sha256 = "07wbza3xrgxbbdajgayyvbdki69v12rz2z3yfiy0gf5dqfa5g98w";
+       version = "0.8.7";
+       sha256 = "1xwws46hwb0m2zqyllkb9rb0jjiqq0xp128dv03w3l5kz0ixk9jv";
        libraryHaskellDepends = [ base ghc-prim primitive ];
        description = "A safe approach to CAS and other atomic ops in Haskell";
        license = lib.licenses.bsd3;
-     }) {};
-
-  "atomic-primops_0_8_6" = callPackage
-    ({ mkDerivation, base, ghc-prim, primitive }:
-     mkDerivation {
-       pname = "atomic-primops";
-       version = "0.8.6";
-       sha256 = "1cas7m0v94fkd1s7hqpl5vf270z5yjd4rnq0glkcz4gy44h06jyl";
-       libraryHaskellDepends = [ base ghc-prim primitive ];
-       description = "A safe approach to CAS and other atomic ops in Haskell";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "atomic-primops-foreign" = callPackage
···
        testHaskellDepends = [ base exceptions hspec HUnit retry ];
        description = "Efficiently run periodic, on-demand actions";
        license = lib.licenses.mit;
+     }) {};
+
+  "auto-update_0_2_0" = callPackage
+    ({ mkDerivation, base, exceptions, hspec, hspec-discover, HUnit
+     , retry
+     }:
+     mkDerivation {
+       pname = "auto-update";
+       version = "0.2.0";
+       sha256 = "13z0h0zjccf8fj0lfcbjhrzfpq1cw9kc9aciycs97lrr6iz7y6m2";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base exceptions hspec HUnit retry ];
+       testToolDepends = [ hspec-discover ];
+       description = "Efficiently run periodic, on-demand actions";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "autoapply" = callPackage
···
        pname = "bank-holiday-germany";
        version = "1.3.0.0";
        sha256 = "1agf4flql5xkj2rpdbdxpmvajhigcwzbxsmrh76bckmcj2b38k9f";
+       revision = "1";
+       editedCabalFile = "15hkd2s9hd7xml0r8cq3apsnzh1a9k34vyljz7bfl811krx01f0j";
        libraryHaskellDepends = [ base time ];
        testHaskellDepends = [
          base doctest hedgehog hspec hspec-hedgehog time
···
        ];
        description = "Basic examples and functions for generics-sop";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "basics" = callPackage
···
        ];
        description = "SQL DDL support and migrations support library for Beam";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "beam-mysql" = callPackage
···
        ];
        description = "Beam driver for SQLite";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "beam-th" = callPackage
···
      }:
      mkDerivation {
        pname = "bearriver";
-       version = "0.14.7";
-       sha256 = "1yxjqsy24af1i36haax1bqizmwgimqkgygwimqrcmbazmrjdcfj2";
+       version = "0.14.8";
+       sha256 = "06wnlshgf2anp3xg3vf0cz6lxjn0rpfvnjfn568dj007km8y2n9p";
        libraryHaskellDepends = [
          base deepseq dunai MonadRandom mtl simple-affine-space transformers
        ];
···
        broken = true;
      }) {};
 
+  "bech32_1_1_6" = callPackage
+    ({ mkDerivation, array, base, base58-bytestring, bytestring
+     , containers, deepseq, extra, hspec, hspec-discover, memory
+     , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal
+     , process, QuickCheck, text, vector
+     }:
+     mkDerivation {
+       pname = "bech32";
+       version = "1.1.6";
+       sha256 = "03a0xf1c7zjirg4y3rv0frrqifzqsqx327hdcvxzbpgflwgs225h";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base bytestring containers extra text
+       ];
+       executableHaskellDepends = [
+         base base58-bytestring bytestring extra memory optparse-applicative
+         prettyprinter prettyprinter-ansi-terminal text
+       ];
+       testHaskellDepends = [
+         base base58-bytestring bytestring containers deepseq extra hspec
+         memory process QuickCheck text vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Implementation of the Bech32 cryptocurrency address format (BIP 0173)";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "bech32";
+       broken = true;
+     }) {};
+
   "bech32-th" = callPackage
     ({ mkDerivation, base, bech32, hspec, hspec-discover
      , template-haskell, text
···
        pname = "bech32-th";
        version = "1.1.5";
        sha256 = "15k2ak8nkxanzcgl8wbsyan9aph5ci0f51zrzhyrrk1hnk70yj6w";
+       libraryHaskellDepends = [ base bech32 template-haskell text ];
+       testHaskellDepends = [ base bech32 hspec template-haskell ];
+       testToolDepends = [ hspec-discover ];
+       description = "Template Haskell extensions to the Bech32 library";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "bech32-th_1_1_6" = callPackage
+    ({ mkDerivation, base, bech32, hspec, hspec-discover
+     , template-haskell, text
+     }:
+     mkDerivation {
+       pname = "bech32-th";
+       version = "1.1.6";
+       sha256 = "0y1hw7419sw84gs13wh40qj9m1snyz0ly5aasmkynjpb9ixhn54k";
        libraryHaskellDepends = [ base bech32 template-haskell text ];
        testHaskellDepends = [ base bech32 hspec template-haskell ];
        testToolDepends = [ hspec-discover ];
···
        ];
        description = "Bindings to the beeminder.com JSON API";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bein" = callPackage
···
        pname = "blank-canvas";
        version = "0.7.4";
        sha256 = "1qm0ms3jk8m5zv81lh3pn5n04afyq7bpn9lc137ddmm9blnkzndi";
-       revision = "2";
-       editedCabalFile = "1ksinbzz47750ka0cfam41v3pfqyw2dvzj8xypq6q317zjliicab";
+       revision = "3";
+       editedCabalFile = "02ci5si3bzcf2f29zi7npvbgq6x1d9jgn97p2n6yn1kfj5g4ff7m";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base base-compat-batteries base64-bytestring bytestring
···
     ({ mkDerivation, bluefin-internal }:
      mkDerivation {
        pname = "bluefin";
-       version = "0.0.4.2";
-       sha256 = "08r1xma5kg7kcc88lflq59kz3qs1qix2pg4hq882pabis0lnwr64";
+       version = "0.0.4.3";
+       sha256 = "13hb0wn232j2rxavjrxhnxadv683zdcvg08744pjm1scyv3p4012";
        libraryHaskellDepends = [ bluefin-internal ];
        description = "The Bluefin effect system";
        license = lib.licenses.mit;
···
        pname = "bm";
        version = "0.2.0.0";
        sha256 = "17dnv1vdsh43nc8b0p92d01nz1zvxd9bfcghlz0w6c8wc5yflg31";
-       revision = "3";
-       editedCabalFile = "0nz83kp7gymlvnsap29ki2m6gy3aal902bazal5232slmsg49d7a";
+       revision = "4";
+       editedCabalFile = "11mj69y43chqr50m9g8shqdyc3q31hha9gjqx05dn1dnkz3xgzxb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "bower-json_1_0_0_1" = callPackage
-    ({ mkDerivation, aeson, aeson-better-errors, base, bytestring
-     , deepseq, ghc-prim, mtl, scientific, tasty, tasty-hunit, text
-     , transformers, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "bower-json";
-       version = "1.0.0.1";
-       sha256 = "0wvygg3rdbxzrmr61a9w6ddv9pfric85ih8hnxyk0ydzn7i59abs";
-       libraryHaskellDepends = [
-         aeson aeson-better-errors base bytestring deepseq ghc-prim mtl
-         scientific text transformers unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson base bytestring tasty tasty-hunit text unordered-containers
-       ];
-       description = "Read bower.json from Haskell";
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
   "bower-json" = callPackage
     ({ mkDerivation, aeson, aeson-better-errors, base, bytestring
      , deepseq, ghc-prim, mtl, scientific, tasty, tasty-hunit, text
···
      }) {};
 
   "bowtie" = callPackage
-    ({ mkDerivation, base, bifunctors, comonad, mtl
-     , nonempty-containers, prettyprinter, recursion-schemes
-     , semigroupoids
+    ({ mkDerivation, base, bifunctors, comonad, dependent-map, mtl
+     , nonempty-containers, optics, prettyprinter, recursion-schemes
+     , semigroupoids, some
      }:
      mkDerivation {
        pname = "bowtie";
-       version = "0.3.1";
-       sha256 = "04g44lfvbnh84vqwf3mvqwgnxfbc4w8lhx2a6g9jxl79fbsdzpwa";
+       version = "0.4.0";
+       sha256 = "1azsd73srpq0ly25dj1in0fgv8ja1b0sx0q23hbw43af5y885k7s";
        libraryHaskellDepends = [
-         base bifunctors comonad mtl nonempty-containers prettyprinter
-         recursion-schemes semigroupoids
+         base bifunctors comonad dependent-map mtl nonempty-containers
+         optics prettyprinter recursion-schemes semigroupoids some
        ];
        description = "Tying knots in polynomial functors";
        license = lib.licenses.bsd3;
···
        pname = "brotli";
        version = "0.0.0.1";
        sha256 = "0fp8vhqzl6i1vvb4fw4zya6cgkzmj0yaaw94jdf2kggm3gn8zwfc";
-       revision = "4";
-       editedCabalFile = "1p6zr2yr1hd6k9vkpgwdidrkiykv09av2q77f37bfg0985b0xwpx";
+       revision = "5";
+       editedCabalFile = "06a4fsqw1xz4jmvfz4kybf1xg0l5w5klr77c5mibl39aafa0wnf5";
        libraryHaskellDepends = [ base bytestring transformers ];
        libraryPkgconfigDepends = [ brotli ];
        testHaskellDepends = [
···
        pname = "brotli-streams";
        version = "0.0.0.0";
        sha256 = "14jc1nhm50razsl99d95amdf4njf75dnzx8vqkihgrgp7qisyz3z";
-       revision = "8";
-       editedCabalFile = "05ri1yv1q2h0zlbcqgk1rpyb7p36zb6asrj6f3w0yyr4s5hsqwww";
+       revision = "9";
+       editedCabalFile = "1rhy0d1jy3v9r1skg3bdlnjj5avxy968ih1cyg9x9yb7rbyf3za5";
        libraryHaskellDepends = [ base brotli bytestring io-streams ];
        testHaskellDepends = [
          base bytestring HUnit io-streams QuickCheck test-framework
···
        ];
        description = "Parse and render URI templates";
        license = lib.licenses.mit;
+     }) {};
+
+  "burrito_2_0_1_9" = callPackage
+    ({ mkDerivation, base, bytestring, containers, hspec, parsec
+     , QuickCheck, template-haskell, text, transformers
+     }:
+     mkDerivation {
+       pname = "burrito";
+       version = "2.0.1.9";
+       sha256 = "0sz9j9yv7whwvxrnh4v3r5fz8z4v9c7c2s45kpvsgvshds9vbr7f";
+       libraryHaskellDepends = [
+         base bytestring containers parsec template-haskell text
+         transformers
+       ];
+       testHaskellDepends = [
+         base bytestring containers hspec parsec QuickCheck template-haskell
+         text transformers
+       ];
+       description = "Parse and render URI templates";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "burst-detection" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "bytestring-lexing_0_5_0_12" = callPackage
+    ({ mkDerivation, base, bytestring, tasty, tasty-quickcheck
+     , tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "bytestring-lexing";
+       version = "0.5.0.12";
+       sha256 = "09g5x7jwz9kby578rlj8c6f6zi0pzs169rsqd1vsn3q9gimkpj3j";
+       libraryHaskellDepends = [ base bytestring ];
+       testHaskellDepends = [
+         base bytestring tasty tasty-quickcheck tasty-smallcheck
+       ];
+       description = "Efficiently parse and produce common integral and fractional numbers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bytestring-mmap" = callPackage
     ({ mkDerivation, base, bytestring, unix }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "bytestring-trie_0_2_7_3" = callPackage
+    ({ mkDerivation, base, binary, bytestring, criterion, deepseq
+     , QuickCheck, smallcheck, tasty, tasty-hunit, tasty-quickcheck
+     , tasty-smallcheck
+     }:
+     mkDerivation {
+       pname = "bytestring-trie";
+       version = "0.2.7.3";
+       sha256 = "0cxhsczvfn0cxh4mmhv70rskrc023gy0gl57xiggbf64ng5c60f7";
+       libraryHaskellDepends = [ base binary bytestring deepseq ];
+       testHaskellDepends = [
+         base binary bytestring deepseq QuickCheck smallcheck tasty
+         tasty-hunit tasty-quickcheck tasty-smallcheck
+       ];
+       benchmarkHaskellDepends = [
+         base binary bytestring criterion deepseq QuickCheck
+       ];
+       description = "An efficient finite map from bytestrings to values";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "bytestring-typenats" = callPackage
     ({ mkDerivation, base, binary, blake2, bytestring, cereal
      , criterion, cryptohash, deepseq, entropy, QuickCheck
···
 
   "cabal-gild" = callPackage
     ({ mkDerivation, base, bytestring, Cabal-syntax, containers
-     , directory, exceptions, filepath, hspec, parsec, pretty, text
-     , transformers
+     , directory, exceptions, filepath, hspec, parsec, pretty, temporary
+     , text, transformers
      }:
      mkDerivation {
        pname = "cabal-gild";
-       version = "1.3.0.1";
-       sha256 = "18sa7c3rniczb218lzi9iizfi1czllp9hy4ai1djz4hvqvbmlh9r";
+       version = "1.3.1.0";
+       sha256 = "1ghrzw1fqslyhy9hmsmwwyv7kfbzf3bm9d0bzvf2k62s7yihrs4p";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
-         base bytestring containers exceptions filepath hspec transformers
+         base bytestring containers directory exceptions filepath hspec
+         temporary transformers
        ];
        description = "Formats package descriptions";
        license = lib.licenses.mit;
···
        broken = true;
      }) {};
 
+  "call-alloy_0_5_0_1" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, directory
+     , exceptions, extra, file-embed, filepath, hspec, process, split
+     , string-interpolate, transformers, trifecta, unix
+     }:
+     mkDerivation {
+       pname = "call-alloy";
+       version = "0.5.0.1";
+       sha256 = "0c34yd6l0650qk760mmgsfgmwvhqhs43nzm7nhzkps5z1p966wmc";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         async base bytestring containers directory exceptions extra
+         filepath process split transformers trifecta unix
+       ];
+       testHaskellDepends = [
+         async base bytestring containers directory exceptions extra
+         file-embed filepath hspec process split string-interpolate
+         transformers trifecta unix
+       ];
+       description = "A simple library to call Alloy given a specification";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "call-haskell-from-anything" = callPackage
     ({ mkDerivation, base, bytestring, data-msgpack, mtl
      , storable-endian, template-haskell
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "cassava_0_5_3_1" = callPackage
+    ({ mkDerivation, array, attoparsec, base, bytestring, containers
+     , deepseq, hashable, HUnit, 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.1";
+       sha256 = "14kz47i6f9c747h2mf8cf6r22gib4a2ggh57fviz0z9sr6y760av";
+       configureFlags = [ "-f-bytestring--lt-0_10_4" ];
+       libraryHaskellDepends = [
+         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
+       ];
+       description = "A CSV parsing and encoding library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "cassava-conduit" = callPackage
     ({ mkDerivation, array, base, bifunctors, bytestring, cassava
      , conduit, containers, criterion, mtl, QuickCheck, text
···
        ];
        description = "A tool for manipulating CBOR";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "cbor-tool";
-       broken = true;
      }) {};
 
   "cborg" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "chimera_0_4_0_0" = callPackage
+  "chimera_0_4_1_0" = callPackage
     ({ mkDerivation, adjunctions, base, distributive, infinite-list
      , mtl, primitive, QuickCheck, random, tasty, tasty-bench
      , tasty-hunit, tasty-quickcheck, tasty-smallcheck, transformers
···
      }:
      mkDerivation {
        pname = "chimera";
-       version = "0.4.0.0";
-       sha256 = "0fwwirx911421d48p0hsd8r2hhik1hsf8z7gqysd0cr2riz4b6q7";
+       version = "0.4.1.0";
+       sha256 = "1wxw0d9dq7q3a9rn3h69yjiyi94xhyip1ssii982rm35jsywak49";
        libraryHaskellDepends = [
          adjunctions base distributive infinite-list mtl primitive
          transformers vector
        ];
        testHaskellDepends = [
-         base QuickCheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck
-         vector
+         base infinite-list QuickCheck tasty tasty-hunit tasty-quickcheck
+         tasty-smallcheck vector
        ];
        benchmarkHaskellDepends = [
          base mtl random tasty tasty-bench vector
···
      }:
      mkDerivation {
        pname = "clashilator";
-       version = "0.1.3";
-       sha256 = "00w9jm0pq2sxd1pv3fgxflbv7gwawiqicmf8q5jx7l3lwccha718";
+       version = "0.1.4";
+       sha256 = "1221csxfv7m95c782l85aww9mjxfj7x7snpc451j13qv37ia62cn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Miscellaneous utilities for building and working with command line interfaces";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "cli-git" = callPackage
···
        ];
        description = "Bindings to the git command-line interface";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "cli-nix" = callPackage
···
        ];
        description = "Bindings to the nix command-line interface";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "cli-setup" = callPackage
···
        license = "BSD-2-Clause-Patent";
      }) {};
 
+  "cornelis" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, containers
+     , diff-loc, directory, filepath, fingertree, generic-lens, hspec
+     , lens, levenshtein, megaparsec, mtl, nvim-hs, nvim-hs-contrib
+     , prettyprinter, process, QuickCheck, random, resourcet, temporary
+     , text, transformers, unagi-chan, unliftio-core, vector
+     }:
+     mkDerivation {
+       pname = "cornelis";
+       version = "0.2.0.0";
+       sha256 = "10frpbc0944pv5vc4qlh5blww8z5y6318gb5lhlrm3pm28sbxy1k";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson async base bytestring containers diff-loc directory filepath
+         fingertree generic-lens hspec lens levenshtein megaparsec mtl
+         nvim-hs nvim-hs-contrib prettyprinter process QuickCheck random
+         resourcet text transformers unagi-chan unliftio-core vector
+       ];
+       executableHaskellDepends = [
+         aeson async base bytestring containers diff-loc directory filepath
+         fingertree generic-lens hspec lens levenshtein megaparsec mtl
+         nvim-hs nvim-hs-contrib prettyprinter process QuickCheck random
+         resourcet text transformers unagi-chan unliftio-core vector
+       ];
+       testHaskellDepends = [
+         aeson async base bytestring containers diff-loc directory filepath
+         fingertree generic-lens hspec lens levenshtein megaparsec mtl
+         nvim-hs nvim-hs-contrib prettyprinter process QuickCheck random
+         resourcet temporary text transformers unagi-chan unliftio-core
+         vector
+       ];
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "cornelis";
+       broken = true;
+     }) {};
+
   "coroutine-enumerator" = callPackage
     ({ mkDerivation, base, enumerator, monad-coroutine }:
      mkDerivation {
···
        pname = "cryptohash-md5";
        version = "0.11.101.0";
        sha256 = "018g13hkmq5782i24b4518hcd926fl6x6fh5hd7b9wlxwc5dn21v";
-       revision = "3";
-       editedCabalFile = "1v7gv0xa9yfkxq3g9j79ppzn6hjf467aajzb4x5882yflibfi9ki";
+       revision = "4";
+       editedCabalFile = "1m077jax8jz68i9c0nl27465qmcww97wziwmy8apxcfkgfifzlx6";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base base16-bytestring bytestring pureMD5 tasty tasty-hunit
···
        pname = "cryptohash-sha1";
        version = "0.11.101.0";
        sha256 = "0h9jl9v38gj0vnscqx7xdklk634p05fa6z2pcvknisq2mnbjq154";
-       revision = "3";
-       editedCabalFile = "08f68cjmdrwx76id4hcyp3jxs8dsnb1jv9pfkm5x7gsvxmrk6pdw";
+       revision = "4";
+       editedCabalFile = "1m0q2zmljjxr1v5szzb7xlbf2gnmaxnsgbvr9v3lgy3az192gdjr";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base base16-bytestring bytestring SHA tasty tasty-hunit
···
        pname = "cryptohash-sha256";
        version = "0.11.102.1";
        sha256 = "1xkb7iqplbw4fy1122p79xf1zcb7k44rl0wmfj1q06l7cdqxr9vk";
-       revision = "3";
-       editedCabalFile = "1204ybm4685yc78mpyriwbplg3ppciid3g1b79562zwqc58hdnq3";
+       revision = "4";
+       editedCabalFile = "1gdc6clkyx5dlf8g9pn8gbknvwjjhbnm1sy6pai7rarvgdm7a390";
        configureFlags = [ "-fuse-cbits" ];
        isLibrary = true;
        isExecutable = true;
···
        pname = "cryptohash-sha512";
        version = "0.11.102.0";
        sha256 = "0b48qwgyn68rfbq4fh6fmsk1kc07n8qq95217n8gjnlzvsh2395z";
-       revision = "2";
-       editedCabalFile = "1v1d8bv54vwwz31z8pdni6pa5lzm5zaxkzdg0857jzghzkdzg7d5";
+       revision = "3";
+       editedCabalFile = "0n2b0q0a45vrklg69qa4rblijg9j87lqm1v4r3rwkqgl9y2f5bq1";
        libraryHaskellDepends = [ base bytestring ];
        testHaskellDepends = [
          base base16-bytestring bytestring SHA tasty tasty-hunit
···
        ];
        description = "Cryptography Primitives sink";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "crypton_1_0_0" = callPackage
+    ({ mkDerivation, base, basement, bytestring, deepseq, gauge
+     , ghc-prim, integer-gmp, memory, random, tasty, tasty-hunit
+     , tasty-kat, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "crypton";
+       version = "1.0.0";
+       sha256 = "1q1kv37hv8cl6hykvssbd4hsd0zj8a562q42jr2gwk59lnwklhcx";
+       libraryHaskellDepends = [
+         base basement bytestring deepseq ghc-prim integer-gmp memory
+       ];
+       testHaskellDepends = [
+         base bytestring memory tasty tasty-hunit tasty-kat tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring deepseq gauge memory random
+       ];
+       description = "Cryptography Primitives sink";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "crypton-conduit" = callPackage
···
     ({ mkDerivation, base, parsec, text }:
      mkDerivation {
        pname = "curly-expander";
-       version = "0.3.0.2";
-       sha256 = "0ag6yqg260y9hal6kzp3phsfa3rwj6lxd8g6k85x81s2lilxgynx";
+       version = "0.3.0.3";
+       sha256 = "07fqwq9k7ig0xyncyv39j48qv4wjfhdjvddm2v2h1rw93jxj06cf";
        libraryHaskellDepends = [ base parsec text ];
        testHaskellDepends = [ base parsec text ];
        description = "Curly braces (brackets) expanding";
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "dani-servant-lucid2" = callPackage
+    ({ mkDerivation, base, http-media, http-types, lucid2, servant
+     , servant-server
+     }:
+     mkDerivation {
+       pname = "dani-servant-lucid2";
+       version = "0.1.0.0";
+       sha256 = "0zgxzc6gfkhfv873bdvwqaw2f7fqyqk94ayacnnbi4ml55mypx3v";
+       libraryHaskellDepends = [
+         base http-media http-types lucid2 servant servant-server
+       ];
+       testHaskellDepends = [ base http-media lucid2 servant-server ];
+       doHaddock = false;
+       description = "Servant support for lucid2";
+       license = lib.licenses.bsd3;
      }) {};
 
   "danibot" = callPackage
···
        license = lib.licenses.asl20;
      }) {};
 
+  "dbus_1_3_4" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, conduit, containers
+     , criterion, deepseq, directory, exceptions, extra, filepath, lens
+     , network, parsec, process, QuickCheck, random, resourcet, split
+     , tasty, tasty-hunit, tasty-quickcheck, template-haskell, temporary
+     , text, th-lift, transformers, unix, vector, xml-conduit, xml-types
+     }:
+     mkDerivation {
+       pname = "dbus";
+       version = "1.3.4";
+       sha256 = "01q5jdlvf0mfvr2wfy3z4mkamj6ypzyni0919g99p2byx6aynq98";
+       libraryHaskellDepends = [
+         base bytestring cereal conduit containers deepseq exceptions
+         filepath lens network parsec random split template-haskell text
+         th-lift transformers unix vector xml-conduit xml-types
+       ];
+       testHaskellDepends = [
+         base bytestring cereal containers directory extra filepath network
+         parsec process QuickCheck random resourcet tasty tasty-hunit
+         tasty-quickcheck temporary text transformers unix vector
+       ];
+       benchmarkHaskellDepends = [ base criterion ];
+       doCheck = false;
+       description = "A client library for the D-Bus IPC system";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "dbus-app-launcher" = callPackage
     ({ mkDerivation, base, containers, dbus, extra, unix }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "demangler";
-       version = "1.2.0.0";
-       sha256 = "1pv4qhmn5hmksrv868f2mdln938hin917s856xmfpmlnc9zgp6ml";
+       version = "1.3.2.0";
+       sha256 = "1fabcnvdbsy4q2phz4w06qj1wwabczg4ha25za8fr8jqfgl5zpqh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Dependent map that uses semigroup mappend";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "dependent-state" = callPackage
···
        pname = "diagrams-core";
        version = "1.5.1.1";
        sha256 = "168kjikw3x21pjgfy3lmxmrm89g9zlhbypkmzdg5xz9rl7acn7rc";
+       revision = "1";
+       editedCabalFile = "1ii5qcwdzaljzq39vrvrsjf06ydnvvyr5q44ks566c347vna7igb";
        libraryHaskellDepends = [
          adjunctions base containers distributive dual-tree lens linear
          monoid-extras mtl profunctors semigroups unordered-containers
···
      }:
      mkDerivation {
        pname = "diohsc";
-       version = "0.1.14.6";
-       sha256 = "00856rbgk7xq6mq1q58ibzbbkag6jh3zqvyzapjw6baj83gd4br3";
+       version = "0.1.14.7";
+       sha256 = "0vyjp0p48d4m3wc0rzi4jljnv9yx0lfiwnxhismrpmf0cr0jfyzh";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        description = "Gemini client";
        license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "diohsc";
+       broken = true;
      }) {};
 
   "diophantine" = callPackage
···
      }) {};
 
   "dnf-repo" = callPackage
-    ({ mkDerivation, base, directory, extra, filepath, Glob
+    ({ mkDerivation, base, curl, directory, extra, filepath, Glob
      , http-directory, simple-cmd, simple-cmd-args, simple-prompt
      }:
      mkDerivation {
        pname = "dnf-repo";
-       version = "0.5.5";
-       sha256 = "0yj0dizzdhrb44hzr7b6pa5wy5bik4m8pz6ckx4r3lg9rkgqhjfk";
+       version = "0.6";
+       sha256 = "1420jj5kmvj2h3ix8v6hmf4fdkzn1ixbvxg9fi7zfdfll7831gk0";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
-         base directory extra filepath Glob http-directory simple-cmd
+         base curl directory extra filepath Glob http-directory simple-cmd
          simple-cmd-args simple-prompt
        ];
        testHaskellDepends = [ base simple-cmd ];
-       description = "DNF wrapper tool to control repos";
-       license = lib.licenses.bsd3;
+       description = "A dnf wrapper with fine control of enabled repos";
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        mainProgram = "dnf-repo";
      }) {};
···
      }:
      mkDerivation {
        pname = "doctest-parallel";
-       version = "0.3.1";
-       sha256 = "0lbiwi2jc6d68hhkvsgwhrwrbhw9f56r2mqnp7l6i779gpzdriqd";
-       libraryHaskellDepends = [
-         base base-compat Cabal code-page containers deepseq directory
-         exceptions filepath ghc ghc-paths Glob process random syb
-         template-haskell transformers unordered-containers
-       ];
-       testHaskellDepends = [
-         base base-compat code-page containers deepseq directory exceptions
-         filepath ghc ghc-paths hspec hspec-core HUnit mockery process
-         QuickCheck setenv silently stringbuilder syb transformers
-       ];
-       doHaddock = false;
-       description = "Test interactive Haskell examples";
-       license = lib.licenses.mit;
-     }) {};
-
-  "doctest-parallel_0_3_1_1" = callPackage
-    ({ mkDerivation, base, base-compat, Cabal, code-page, containers
-     , deepseq, directory, exceptions, filepath, ghc, ghc-paths, Glob
-     , hspec, hspec-core, HUnit, mockery, process, QuickCheck, random
-     , setenv, silently, stringbuilder, syb, template-haskell
-     , transformers, unordered-containers
-     }:
-     mkDerivation {
-       pname = "doctest-parallel";
        version = "0.3.1.1";
        sha256 = "1xpk020024vsqh27sp225hx50i1hn5fkhxiyww6wqnhrkxypjkwa";
        libraryHaskellDepends = [
···
        doHaddock = false;
        description = "Test interactive Haskell examples";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "doctest-prop" = callPackage
···
      }:
      mkDerivation {
        pname = "dunai";
-       version = "0.12.2";
-       sha256 = "07qij8dmfawdhzd3aldg2kwy0rrma2yybiwd3w989kfih4mf6mbp";
+       version = "0.12.3";
+       sha256 = "10262cqc6ynbpvqpa3ijfacwyid4fxqxks6rm68brmqrzdqyh6wk";
        libraryHaskellDepends = [
          base MonadRandom simple-affine-space transformers transformers-base
        ];
···
     ({ mkDerivation, base, dunai, normaldistribution, QuickCheck }:
      mkDerivation {
        pname = "dunai-test";
-       version = "0.12.2";
-       sha256 = "093p31bcbpwn4bsz1id946d5mxk2an2akxm2xvpls9vydvm255zw";
+       version = "0.12.3";
+       sha256 = "0whmsiixv1iid1cd3faz0zib8hv4v09yclq6a7ypz4zyvjyk0szh";
        libraryHaskellDepends = [
          base dunai normaldistribution QuickCheck
        ];
···
        pname = "either";
        version = "5.0.2";
        sha256 = "1gl748ia68bldbqb2fl7vjv44g0y8ivn659fjmy1qyypgyb5p95z";
-       revision = "1";
-       editedCabalFile = "1w2rxrj0gc3a7p74pybji8yy2zsjnhxyi4zhlmx4qsyz6w616ggv";
+       revision = "2";
+       editedCabalFile = "1lx6ls938vssg75ib2fr1ww4nsig2rkhjc6x57yfinx1yb9r62vz";
        libraryHaskellDepends = [
          base bifunctors mtl profunctors semigroupoids
        ];
···
        testToolDepends = [ hspec-discover ];
        description = "Source code error pretty printing";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "errata-example";
+       broken = true;
      }) {};
 
   "errno" = callPackage
···
        broken = true;
      }) {};
 
-  "exceptions_0_10_7" = callPackage
+  "exceptions_0_10_8" = callPackage
     ({ mkDerivation, base, mtl, QuickCheck, stm, template-haskell
      , test-framework, test-framework-hunit, test-framework-quickcheck2
      , transformers
      }:
      mkDerivation {
        pname = "exceptions";
-       version = "0.10.7";
-       sha256 = "0jb0ah5k2mb4clhb34c59f615vzl54lhx3hf6njqsgdmr3jashls";
-       revision = "2";
-       editedCabalFile = "14zz1abaj62p7f0gmnxr2ss1cpciin64zy7yz3vhkcvy1k00ynm8";
+       version = "0.10.8";
+       sha256 = "125mgcw94x7d47ps0lkiq0g2hzzfjkmcq3gfkbi7w78az0sdjq4d";
+       revision = "1";
+       editedCabalFile = "0rxaahjp8zmp3xhdvvfgkb9qz1j9vsjgr9gz2jxnq69nbnrxj7y3";
        libraryHaskellDepends = [
          base mtl stm template-haskell transformers
        ];
···
      }:
      mkDerivation {
        pname = "extism";
-       version = "1.2.0.3";
-       sha256 = "12kaar2jhhxg7pkq5hll7w2iqrahp4d8qw76qypzhqnhzv4s9zmc";
+       version = "1.2.1.0";
+       sha256 = "0x2vwc5r812i3jk7z9y8qfkxlq3acqv560y1z97fsahkb1frydqy";
        libraryHaskellDepends = [
          base binary bytestring extism-manifest json uuid
        ];
···
     ({ mkDerivation, base, base64-bytestring, bytestring, json }:
      mkDerivation {
        pname = "extism-manifest";
-       version = "1.2.0.3";
-       sha256 = "07ypncyml5p1p0yy3x45s8gj5vz8z0xjzpcy2q8mdxpk5qgaa6z1";
+       version = "1.2.1.0";
+       sha256 = "1jxv93grdvr02q7gqg1gg9vqjirn3z84x8992zz3spgf4p1h2f2i";
        libraryHaskellDepends = [ base base64-bytestring bytestring json ];
        description = "Extism manifest bindings";
        license = lib.licenses.bsd3;
···
        pname = "filepath";
        version = "1.5.2.0";
        sha256 = "19vq749100f1nfjn9cpw99wx392x6rf439ly5lm965w5zas6sq6j";
+       revision = "1";
+       editedCabalFile = "16j1jjkf1rlyqwndpv6kphyc5s3ffqmh155f8j6xrvd7rd1sixwa";
        libraryHaskellDepends = [
          base bytestring deepseq exceptions os-string template-haskell
        ];
···
        pname = "foldable1-classes-compat";
        version = "0.1";
        sha256 = "04pzjppmb195ffgxdzh8dh39z5dalr5wd6sifcnbg9p1b3rw6myh";
-       revision = "4";
-       editedCabalFile = "0kpsp659y563h2vanhrdnbza9skq1j9sm6y3fg2j4p1xsgnkqjzv";
+       revision = "6";
+       editedCabalFile = "13g7igqcq6nr0sqschzm7scrpq90nhjjkjq1866ww8ikkq7w9wgj";
        libraryHaskellDepends = [ base ghc-prim tagged ];
        testHaskellDepends = [
          base containers QuickCheck quickcheck-instances test-framework
···
        broken = true;
      }) {};
 
+  "fsnotify_0_3_0_1" = callPackage
+    ({ mkDerivation, async, base, bytestring, containers, directory
+     , filepath, hinotify, random, shelly, tasty, tasty-hunit, temporary
+     , text, time, unix, unix-compat
+     }:
+     mkDerivation {
+       pname = "fsnotify";
+       version = "0.3.0.1";
+       sha256 = "19bdbz9wb9jvln6yg6qm0hz0w84bypvkxf0wjhgrgd52f9gidlny";
+       revision = "2";
+       editedCabalFile = "12m0y5583plk9pikvwqy1rc0yyvicxf8j5nz0nwxb4grsgfqrv7v";
+       libraryHaskellDepends = [
+         async base bytestring containers directory filepath hinotify shelly
+         text time unix unix-compat
+       ];
+       testHaskellDepends = [
+         async base directory filepath random tasty tasty-hunit temporary
+         unix-compat
+       ];
+       description = "Cross platform library for file change notification";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "fsnotify" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, directory
      , exceptions, filepath, hinotify, monad-control, random, retry
···
        ];
        description = "A fused-effects adapter for squeal-postgresql";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "fused-effects-th" = callPackage
···
        ];
        description = "Automatically spin up and spin down local daemons";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "gargoyle-postgresql" = callPackage
···
        ];
        description = "Manage PostgreSQL servers with gargoyle";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gargoyle-postgresql-connect" = callPackage
···
        ];
        description = "Connect to gargoyle-managed postgresql instances";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gargoyle-postgresql-nix" = callPackage
···
        ];
        description = "Manage PostgreSQL servers with gargoyle and nix";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "garlic-bread" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
-  "ghcjs-base_0_8_0_0" = callPackage
+  "ghcjs-base" = callPackage
     ({ mkDerivation }:
      mkDerivation {
        pname = "ghcjs-base";
···
        sha256 = "1bbgvyw4vbwi7whidldrxi46hjx9hsg3hp6l2py30528n7hfdpdp";
        description = "base library for GHCJS";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghcjs-base-stub" = callPackage
···
      }:
      mkDerivation {
   "hmumps" = callPackage
-       version = "0.4.1.0";
-  "hmumps" = callPackage
+       version = "0.5.0.1";
+       sha256 = "0wrvasr5kbz27ddwlmpxwzda4ya5phyn21hwi2ci7xgcfb0q3szh";
        revision = "2";
-  "hmumps" = callPackage
+       editedCabalFile = "0sihj9hivxc3w3fr8yc8bp6wnphjspvm1fwgzx3iimsw26vb21cd";
        libraryHaskellDepends = [
   "hmumps" = callPackage
   "hmumps" = callPackage
···
        pname = "hakyll";
        version = "4.16.2.0";
        sha256 = "1p3x9f1ha6dkis71nzbxh1h7mzldsj4qvmfx3f0vng7y1ydlcw0z";
-       revision = "5";
-       editedCabalFile = "01ny9jsz0drdh497pvhlnwxn946db8a1qc1fxy96l3pjc6plvxcb";
+       revision = "6";
+       editedCabalFile = "1pdasij9bz7pzfb9f3lvvixzch7ac3xhqqx5cd3wjl40annawsaw";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "half";
        version = "0.3.1";
        sha256 = "1l8m2spqg0ac50qys2jk5b32v6wxklbbk5ypjp3ga6z14hkw7bz2";
-       revision = "1";
-       editedCabalFile = "0z0sdic28ji6lq9hz9fh534igy6g3g7b1q799cmwkga23dkicgzl";
+       revision = "2";
+       editedCabalFile = "01yv2wdiljx7nsija2dgxim0h9fca7c47nw3jrhy2n3gpcnsrfdn";
        libraryHaskellDepends = [ base binary deepseq template-haskell ];
        testHaskellDepends = [
          base binary bytestring QuickCheck test-framework
···
        ];
        description = "Haskell Application BlockChain Interface (ABCI) Server Library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "haskell-abci-counter";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "haskellish";
-       version = "0.3.2.2";
-       sha256 = "07h421qychchii79s2cbpcfvh6h8qipd6wl9qn5jkdg9d2gycc34";
+       version = "0.3.2.3";
+       sha256 = "0hvnyrh5i6iwzlisdqv0cw952w2kxs1k9c9yc7qmvwr01wfm88lr";
        libraryHaskellDepends = [
          base containers haskell-src-exts mtl template-haskell text
        ];
···
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "1.5.0";
-       sha256 = "01lrrbz6811jcj47bj2ah0i23jkx2gdl326s2hx03rvfnygbz1bq";
+       version = "1.5.2";
+       sha256 = "0yqmhzp0056y5ws4qxps90brcyczpmh02vxq9mszf36kqzgpbgyf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hasql";
-       version = "1.6.4.3";
-       sha256 = "1qy50xnpbikvqqv82wqy9491fgvnl8721xszvjyfhw4r7bf0gn3n";
+       version = "1.6.4.4";
+       sha256 = "1mwr9v5q5wvf1bk4lc7pdyyqf26snw23mxsz0j4mnrk7ybk6daad";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring bytestring-strict-builder
          contravariant dlist hashable hashtables mtl network-ip
-         postgresql-binary postgresql-libpq profunctors scientific text
-         text-builder time transformers uuid vector
+         postgresql-binary postgresql-libpq profunctors rerebase scientific
+         text text-builder time transformers uuid vector
        ];
        testHaskellDepends = [
          contravariant-extras quickcheck-instances rerebase tasty
          tasty-hunit tasty-quickcheck
        ];
        benchmarkHaskellDepends = [ criterion rerebase ];
+       doHaddock = false;
        description = "An efficient PostgreSQL driver with a flexible mapping API";
        license = lib.licenses.mit;
      }) {};
···
        license = lib.licenses.mit;
      }) {};
 
-  "hasql-pool_1_0_1" = callPackage
+  "hasql-pool_1_1" = callPackage
     ({ mkDerivation, async, base, bytestring, hasql, hspec, random
      , rerebase, stm, text, time, uuid
      }:
      mkDerivation {
        pname = "hasql-pool";
-       version = "1.0.1";
-       sha256 = "1z14fdpw1vjr07xz9mjv04i4implk71l61b1p3b1kl34zgvllg1y";
+       version = "1.1";
+       sha256 = "0hqr2l7yasbrb17xs000d4rzjg18y56basw4rfydzphl9yf5ihil";
        libraryHaskellDepends = [
          base bytestring hasql stm text time uuid
        ];
···
        ];
        description = "Library for checking for weak/compromised passwords";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "readme";
-       broken = true;
      }) {};
 
   "haven" = callPackage
···
        pname = "haxr";
        version = "3000.11.5";
        sha256 = "1n2q7r0a6c24xbvdnl7ql5cc25sbbalmdc75rmlpazhkazq8jy99";
-       revision = "2";
-       editedCabalFile = "0nra68lczd019nxcgdxh82k6h846dwjd14k9ql1ngh6g35sq9hdq";
+       revision = "3";
+       editedCabalFile = "1a14kyf9lv2jw8pvb0ypcmmcks9jqbnpf485g005s3wnggd7w7wr";
        libraryHaskellDepends = [
          array base base-compat base64-bytestring blaze-builder bytestring
          HaXml HsOpenSSL http-streams http-types io-streams mtl mtl-compat
···
     ({ mkDerivation, aeson, aeson-pretty, async, base, bytestring
      , deepseq, Diff, directory, exceptions, filepath, hedgehog
      , http-conduit, lifted-async, lifted-base, mmorph, monad-control
-     , mtl, network, process, resourcet, stm, tar, temporary, text, time
-     , transformers, transformers-base, unliftio, yaml, zlib
+     , mtl, network, process, resourcet, stm, tar, tasty, tasty-discover
+     , tasty-hedgehog, temporary, text, time, transformers
+     , transformers-base, unliftio, yaml, zlib
      }:
      mkDerivation {
        pname = "hedgehog-extras";
-       version = "0.6.1.0";
-       sha256 = "1j0b78l1dbffwgmkjlxcycccgl62gglc0cmmbdmgaxr75hmdcm2d";
+       version = "0.6.2.0";
+       sha256 = "0rnfp09q7pdzrs4f7yrbrklnjs8h2zk621wiclchmd1wgc06qwdh";
        libraryHaskellDepends = [
          aeson aeson-pretty async base bytestring deepseq Diff directory
          exceptions filepath hedgehog http-conduit lifted-async lifted-base
···
          temporary text time transformers transformers-base unliftio yaml
          zlib
        ];
+       testHaskellDepends = [
+         base hedgehog network tasty tasty-hedgehog
+       ];
+       testToolDepends = [ tasty-discover ];
        description = "Supplemental library for hedgehog";
        license = lib.licenses.asl20;
      }) {};
···
        pname = "heist";
        version = "1.1.1.2";
        sha256 = "1377740si611j0szp64axy0xj1fi2a6w8i9s3xij89h34m7rb3rz";
+       revision = "1";
+       editedCabalFile = "0glg856n9w1pf74d0kr3v10saw26z54j32mb12hd3xqh8xq34lf6";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-builder blaze-html bytestring
          containers directory directory-tree dlist filepath hashable
···
        mainProgram = "hie-bios";
      }) {};
 
+  "hie-bios_0_14_0" = callPackage
+    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
+     , co-log-core, conduit, conduit-extra, cryptohash-sha1, deepseq
+     , directory, exceptions, extra, file-embed, filepath, ghc
+     , optparse-applicative, prettyprinter, tasty
+     , tasty-expected-failure, tasty-hunit, template-haskell, temporary
+     , text, time, transformers, unix-compat, unordered-containers, yaml
+     }:
+     mkDerivation {
+       pname = "hie-bios";
+       version = "0.14.0";
+       sha256 = "1caszgj3x3l13q6w26snx49yqyzjfgiik4403gl3mfalkrgbvk2g";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base base16-bytestring bytestring co-log-core conduit
+         conduit-extra cryptohash-sha1 deepseq directory exceptions extra
+         file-embed filepath ghc prettyprinter template-haskell temporary
+         text time transformers unix-compat unordered-containers yaml
+       ];
+       executableHaskellDepends = [
+         base co-log-core directory filepath optparse-applicative
+         prettyprinter
+       ];
+       testHaskellDepends = [
+         aeson base co-log-core directory extra filepath ghc prettyprinter
+         tasty tasty-expected-failure tasty-hunit temporary transformers
+         yaml
+       ];
+       description = "Set up a GHC API session";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hie-bios";
+     }) {};
+
   "hie-compat" = callPackage
     ({ mkDerivation, array, base, bytestring, containers, directory
      , filepath, ghc, ghc-boot, transformers
···
        ];
      }) {};
 
+  "hledger_1_33" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
+     , containers, data-default, Decimal, Diff, directory, extra
+     , filepath, githash, hashable, haskeline, hledger-lib, lucid
+     , math-functions, megaparsec, microlens, mtl, process, regex-tdfa
+     , safe, shakespeare, split, tabular, tasty, temporary, terminfo
+     , text, text-ansi, time, timeit, transformers, unordered-containers
+     , utf8-string, utility-ht, wizards
+     }:
+     mkDerivation {
+       pname = "hledger";
+       version = "1.33";
+       sha256 = "118pk5vgj8k1g4lkvknhrf5vid4y7dvs3b5g5q6wf5j9g0kya1wi";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson ansi-terminal base bytestring cmdargs containers data-default
+         Decimal Diff directory extra filepath githash hashable haskeline
+         hledger-lib lucid math-functions megaparsec microlens mtl process
+         regex-tdfa safe shakespeare split tabular tasty temporary terminfo
+         text text-ansi time timeit transformers unordered-containers
+         utf8-string utility-ht wizards
+       ];
+       executableHaskellDepends = [
+         aeson ansi-terminal base bytestring cmdargs containers data-default
+         Decimal directory extra filepath githash haskeline hledger-lib
+         math-functions megaparsec microlens mtl process regex-tdfa safe
+         shakespeare split tabular tasty temporary terminfo text text-ansi
+         time timeit transformers unordered-containers utf8-string
+         utility-ht wizards
+       ];
+       testHaskellDepends = [
+         aeson ansi-terminal base bytestring cmdargs containers data-default
+         Decimal directory extra filepath githash haskeline hledger-lib
+         math-functions megaparsec microlens mtl process regex-tdfa safe
+         shakespeare split tabular tasty temporary terminfo text text-ansi
+         time timeit transformers unordered-containers utf8-string
+         utility-ht wizards
+       ];
+       description = "Command-line interface for the hledger accounting system";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hledger";
+       maintainers = [
+         lib.maintainers.maralorn lib.maintainers.sternenseemann
+       ];
+     }) {};
+
   "hledger-api" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, data-default
      , Decimal, docopt, either, hledger, hledger-lib, microlens
···
        broken = true;
      }) {};
 
+  "hledger-iadd_1_3_21" = callPackage
+    ({ mkDerivation, base, brick, containers, directory, free
+     , hledger-lib, hspec, hspec-discover, megaparsec, microlens
+     , microlens-mtl, microlens-th, optparse-applicative, QuickCheck
+     , quickcheck-instances, text, text-zipper, time, transformers
+     , unordered-containers, vector, vty, xdg-basedir
+     }:
+     mkDerivation {
+       pname = "hledger-iadd";
+       version = "1.3.21";
+       sha256 = "00x0vbfp08kqs1nbknndk9h56hcidf6xnrk0ldz45dvjrmgcv3w2";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base brick containers directory free hledger-lib megaparsec
+         microlens microlens-mtl microlens-th optparse-applicative text
+         text-zipper time transformers unordered-containers vector vty
+         xdg-basedir
+       ];
+       executableHaskellDepends = [
+         base brick directory free hledger-lib megaparsec microlens
+         microlens-mtl microlens-th optparse-applicative text text-zipper
+         time transformers unordered-containers vector vty xdg-basedir
+       ];
+       testHaskellDepends = [
+         base free hledger-lib hspec megaparsec QuickCheck
+         quickcheck-instances text text-zipper time transformers vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A terminal UI as drop-in replacement for hledger add";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hledger-iadd";
+       broken = true;
+     }) {};
+
   "hledger-interest" = callPackage
     ({ mkDerivation, base, Cabal, Decimal, hledger-lib, mtl, text, time
      }:
···
        pname = "hledger-interest";
        version = "1.6.6";
        sha256 = "0hklpg9sgghrcvkrgz7kfr8jc6kwsv8zzpbbg0c3idhbdxwg74d8";
-       revision = "2";
-       editedCabalFile = "0bb1bhybiaih7fc54y3n24xrcpxv6k6iccv2c6byypbcv4jx8m8d";
+       revision = "3";
+       editedCabalFile = "0yywynp3yrdssh2vr7jwp0izr890hfn9kjy6cl9ad8mx1qfyg771";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "hledger-lib_1_33" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array, base
+     , base-compat, blaze-markup, bytestring, call-stack, cassava
+     , cassava-megaparsec, cmdargs, colour, containers, data-default
+     , Decimal, deepseq, directory, doclayout, extra, file-embed
+     , filepath, Glob, hashtables, megaparsec, microlens, microlens-th
+     , mtl, pager, parser-combinators, pretty-simple, regex-tdfa, safe
+     , tabular, tasty, tasty-hunit, template-haskell, terminal-size
+     , text, text-ansi, time, timeit, transformers, uglymemo
+     , unordered-containers, utf8-string
+     }:
+     mkDerivation {
+       pname = "hledger-lib";
+       version = "1.33";
+       sha256 = "15f1wqb0zsrn491lfv0ryiy04fah5sifig7n4rvj53m02shrn35r";
+       libraryHaskellDepends = [
+         aeson aeson-pretty ansi-terminal array base base-compat
+         blaze-markup bytestring call-stack cassava cassava-megaparsec
+         cmdargs colour containers data-default Decimal deepseq directory
+         doclayout extra file-embed filepath Glob hashtables megaparsec
+         microlens microlens-th mtl pager parser-combinators pretty-simple
+         regex-tdfa safe tabular tasty tasty-hunit template-haskell
+         terminal-size text text-ansi time timeit transformers uglymemo
+         unordered-containers utf8-string
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty ansi-terminal array base base-compat
+         blaze-markup bytestring call-stack cassava cassava-megaparsec
+         cmdargs colour containers data-default Decimal deepseq directory
+         doclayout extra file-embed filepath Glob hashtables megaparsec
+         microlens microlens-th mtl pager parser-combinators pretty-simple
+         regex-tdfa safe tabular tasty tasty-hunit template-haskell
+         terminal-size text text-ansi time timeit transformers uglymemo
+         unordered-containers utf8-string
+       ];
+       description = "A library providing the core functionality of hledger";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hledger-makeitso" = callPackage
     ({ mkDerivation, base, containers, foldl, HUnit, stm, text, time
      , turtle
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
+  "hledger-ui_1_33" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, brick, cmdargs
+     , containers, data-default, directory, doclayout, extra, filepath
+     , fsnotify, hledger, hledger-lib, megaparsec, microlens
+     , microlens-platform, mtl, process, safe, split, text, text-zipper
+     , time, transformers, unix, vector, vty, vty-crossplatform
+     }:
+     mkDerivation {
+       pname = "hledger-ui";
+       version = "1.33";
+       sha256 = "1zdysls1jng3rlxjb90dmiz4iavgaf656kkljld6q15575v5f3qj";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-terminal async base brick cmdargs containers data-default
+         directory doclayout extra filepath fsnotify hledger hledger-lib
+         megaparsec microlens microlens-platform mtl process safe split text
+         text-zipper time transformers unix vector vty vty-crossplatform
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Terminal interface for the hledger accounting system";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hledger-ui";
+       maintainers = [ lib.maintainers.maralorn ];
+     }) {};
+
   "hledger-vty" = callPackage
     ({ mkDerivation, base, cmdargs, hledger, hledger-lib, HUnit, safe
      , time, vty
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
+  "hledger-web_1_33" = callPackage
+    ({ mkDerivation, aeson, base, base64, blaze-html, blaze-markup
+     , bytestring, case-insensitive, clientsession, cmdargs, conduit
+     , conduit-extra, containers, data-default, Decimal, directory
+     , extra, filepath, hjsmin, hledger, hledger-lib, hspec, http-client
+     , http-conduit, http-types, megaparsec, mtl, network, safe
+     , shakespeare, template-haskell, text, time, transformers
+     , unix-compat, unordered-containers, utf8-string, wai, wai-cors
+     , wai-extra, wai-handler-launch, warp, yaml, yesod, yesod-core
+     , yesod-form, yesod-static, yesod-test
+     }:
+     mkDerivation {
+       pname = "hledger-web";
+       version = "1.33";
+       sha256 = "1ylfi63yb868ygb5mbp9nvklzdrx169bhfhqnq4w78pipk6kqznk";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base base64 blaze-html blaze-markup bytestring
+         case-insensitive clientsession cmdargs conduit conduit-extra
+         containers data-default Decimal directory extra filepath hjsmin
+         hledger hledger-lib hspec http-client http-conduit http-types
+         megaparsec mtl network safe shakespeare template-haskell text time
+         transformers unix-compat unordered-containers utf8-string wai
+         wai-cors wai-extra wai-handler-launch warp yaml yesod yesod-core
+         yesod-form yesod-static yesod-test
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       description = "Web user interface for the hledger accounting system";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hledger-web";
+       maintainers = [ lib.maintainers.maralorn ];
+     }) {};
+
   "hlex" = callPackage
     ({ mkDerivation, base, HUnit, regex-tdfa }:
      mkDerivation {
···
        pname = "horizontal-rule";
        version = "0.6.0.0";
        sha256 = "03rh58znaghcf1gicbwbxkx5ya4lv7qi8b2lq5nawi35ljars02x";
-       revision = "3";
-       editedCabalFile = "06jfn80vrss7vz4g3wxbn2cz5x77sm8mw03d9lvchsnxmpw1yhxc";
+       revision = "4";
+       editedCabalFile = "0bax92xg4rd92y7fv332bqfl6k2wk8k1dbmrgr6a5p4vx36l58f0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base terminal-size text ];
···
        mainProgram = "hpc-codecov";
      }) {};
 
+  "hpc-codecov_0_6_0_0" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, directory
+     , filepath, hpc, process, tasty, tasty-golden, tasty-hunit, time
+     }:
+     mkDerivation {
+       pname = "hpc-codecov";
+       version = "0.6.0.0";
+       sha256 = "1if8nmqv6pcv92ww8ncaxkvaawdr9shmsdsnr9xvzfmhqjq83q7w";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base bytestring containers directory filepath hpc time
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base directory filepath hpc process tasty tasty-golden tasty-hunit
+       ];
+       description = "Generate reports from hpc data";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hpc-codecov";
+     }) {};
+
   "hpc-coveralls" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, Cabal, cmdargs
      , containers, curl, directory, directory-tree, hpc, HUnit, process
···
      }:
      mkDerivation {
        pname = "hslogger";
-       version = "1.3.1.0";
-       sha256 = "0nyar9xcblx5jwks85y8f4jfy9k1h4ss6rvj4mdbiidrq3v688vz";
-       revision = "9";
-       editedCabalFile = "1isrz8a09n88fww66qdrq76xlglai8sq14jk2ibv79g045qapj1g";
-       libraryHaskellDepends = [
-         base bytestring containers deepseq network network-bsd old-locale
-         time unix
-       ];
-       testHaskellDepends = [ base HUnit ];
-       description = "Versatile logging framework";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "hslogger_1_3_1_1" = callPackage
-    ({ mkDerivation, base, bytestring, containers, deepseq, HUnit
-     , network, network-bsd, old-locale, time, unix
-     }:
-     mkDerivation {
-       pname = "hslogger";
        version = "1.3.1.1";
        sha256 = "0k8imyj2531j6k3c2bn0bavr175km2vwjlwg89vjvl00gdb107c4";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base HUnit ];
        description = "Versatile logging framework";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hslogger-reader" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "hspec_2_11_8" = callPackage
+    ({ mkDerivation, base, hspec-core, hspec-discover
+     , hspec-expectations, QuickCheck
+     }:
+     mkDerivation {
+       pname = "hspec";
+       version = "2.11.8";
+       sha256 = "1w0ryyr9h1f87jgz56yl09x3yvd9zm2w1bj70k5p6pzdyz984cjr";
+       libraryHaskellDepends = [
+         base hspec-core hspec-discover hspec-expectations QuickCheck
+       ];
+       description = "A Testing Framework for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hspec-api" = callPackage
     ({ mkDerivation, base, hspec, hspec-core, hspec-discover
      , transformers
···
        license = lib.licenses.mit;
      }) {};
 
+  "hspec-api_2_11_8" = callPackage
+    ({ mkDerivation, base, hspec, hspec-core, hspec-discover
+     , transformers
+     }:
+     mkDerivation {
+       pname = "hspec-api";
+       version = "2.11.8";
+       sha256 = "02hhmxgd4vz5jakp3nd6cwslh8qmqnlg6j3fq7my8lbdim95wnf6";
+       libraryHaskellDepends = [ base hspec-core transformers ];
+       testHaskellDepends = [ base hspec hspec-core transformers ];
+       testToolDepends = [ hspec-discover ];
+       description = "A Testing Framework for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hspec-attoparsec" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, hspec
      , hspec-expectations, text
···
        pname = "hspec-core";
        version = "2.7.10";
        sha256 = "12k9yp5gznrda449ir60d5wv3xl7nnyffkb5mhfc0svw9f8lxlv1";
-       revision = "1";
-       editedCabalFile = "0g6x70fqwblf2dzjgq6hp4nj5vqrbfvzphl3j8a73h1966zhrxy9";
+       revision = "2";
+       editedCabalFile = "0l16mgxgapnihrvbwvhbz9i60v5fx68mhpv6zww9b68bdj6cpbsk";
        libraryHaskellDepends = [
          ansi-terminal array base call-stack clock deepseq directory
          filepath hspec-expectations HUnit QuickCheck quickcheck-io random
···
        pname = "hspec-core";
        version = "2.11.7";
        sha256 = "0d5i67vm1skqyign9mi711vhyl72l98cii27vvlbg6x7p239pykg";
+       revision = "1";
+       editedCabalFile = "1bm87k49mbcnm5h7l87c05y6hssgl9bj1wkkmzixvsqq8kqp0h7m";
        libraryHaskellDepends = [
          ansi-terminal array base call-stack deepseq directory filepath
          haskell-lexer hspec-expectations HUnit process QuickCheck
···
        license = lib.licenses.mit;
      }) {};
 
+  "hspec-core_2_11_8" = callPackage
+    ({ mkDerivation, ansi-terminal, array, base, base-orphans
+     , call-stack, deepseq, directory, filepath, haskell-lexer
+     , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
+     , quickcheck-io, random, silently, stm, temporary, tf-random, time
+     , transformers
+     }:
+     mkDerivation {
+       pname = "hspec-core";
+       version = "2.11.8";
+       sha256 = "18zaiac5s830q01hq9ai67z5sk0ilvhz471vxabraif3rznrsmla";
+       libraryHaskellDepends = [
+         ansi-terminal array base call-stack deepseq directory filepath
+         haskell-lexer hspec-expectations HUnit process QuickCheck
+         quickcheck-io random stm tf-random time transformers
+       ];
+       testHaskellDepends = [
+         ansi-terminal array base base-orphans call-stack deepseq directory
+         filepath haskell-lexer hspec-expectations hspec-meta HUnit process
+         QuickCheck quickcheck-io random silently stm temporary tf-random
+         time transformers
+       ];
+       testToolDepends = [ hspec-meta ];
+       testTarget = "--test-option=--skip --test-option='Test.Hspec.Core.Runner.hspecResult runs specs in parallel'";
+       description = "A Testing Framework for Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hspec-dirstream" = callPackage
     ({ mkDerivation, base, dirstream, filepath, hspec, hspec-core
      , pipes, pipes-safe, system-filepath, text
···
        testToolDepends = [ hspec-meta ];
        description = "Automatically discover and run Hspec tests";
        license = lib.licenses.mit;
+       mainProgram = "hspec-discover";
+       maintainers = [ lib.maintainers.maralorn ];
+     }) {};
+
+  "hspec-discover_2_11_8" = callPackage
+    ({ mkDerivation, base, directory, filepath, hspec-meta, mockery
+     , QuickCheck
+     }:
+     mkDerivation {
+       pname = "hspec-discover";
+       version = "2.11.8";
+       sha256 = "0s81mjb7an628c0gr3g74navnxzfahdl92zixdgys2is5rbd6yqf";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base directory filepath ];
+       executableHaskellDepends = [ base directory filepath ];
+       testHaskellDepends = [
+         base directory filepath hspec-meta mockery QuickCheck
+       ];
+       testToolDepends = [ hspec-meta ];
+       description = "Automatically discover and run Hspec tests";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        mainProgram = "hspec-discover";
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
···
        mainProgram = "hspec-meta-discover";
      }) {};
 
+  "hspec-meta_2_11_8" = callPackage
+    ({ mkDerivation, ansi-terminal, array, base, call-stack, deepseq
+     , directory, filepath, haskell-lexer, hspec-expectations, HUnit
+     , process, QuickCheck, quickcheck-io, random, stm, tf-random, time
+     , transformers
+     }:
+     mkDerivation {
+       pname = "hspec-meta";
+       version = "2.11.8";
+       sha256 = "0diwxrp6rkf0pchfnfhc5xdbhv9arbbmpgl8hyw5afbfmqjsd4kv";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         ansi-terminal array base call-stack deepseq directory filepath
+         haskell-lexer hspec-expectations HUnit process QuickCheck
+         quickcheck-io random stm tf-random time transformers
+       ];
+       executableHaskellDepends = [
+         ansi-terminal array base call-stack deepseq directory filepath
+         haskell-lexer hspec-expectations HUnit process QuickCheck
+         quickcheck-io random stm tf-random time transformers
+       ];
+       description = "A version of Hspec which is used to test Hspec itself";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hspec-meta-discover";
+     }) {};
+
   "hspec-monad-control" = callPackage
     ({ mkDerivation, base, hspec-core, monad-control, transformers
      , transformers-base
···
      }) {};
 
   "hspray" = callPackage
-    ({ mkDerivation, base, containers, hashable, matrix
+    ({ mkDerivation, base, containers, extra, hashable, matrix
      , numeric-prelude, tasty, tasty-bench, tasty-hunit, text
      , unordered-containers
      }:
      mkDerivation {
        pname = "hspray";
-       version = "0.2.6.0";
-       sha256 = "1g9qm69bwf8cz5ly9jy1yflqya8nabkgbm64irdvl99vs4ry59vc";
+       version = "0.3.0.0";
+       sha256 = "1byk1i2fawyv36k8ap9pg9hpyvzd0zrj82h3gnrdj1ah5m3qg8sf";
        libraryHaskellDepends = [
-         base containers hashable matrix numeric-prelude text
+         base containers extra hashable matrix numeric-prelude text
          unordered-containers
        ];
-       testHaskellDepends = [ base numeric-prelude tasty tasty-hunit ];
-       benchmarkHaskellDepends = [ base tasty-bench ];
-       description = "Multivariate polynomials";
+       testHaskellDepends = [
+         base matrix numeric-prelude tasty tasty-hunit unordered-containers
+       ];
+       benchmarkHaskellDepends = [ base numeric-prelude tasty-bench ];
+       description = "Multivariate polynomials and fractions of multivariate polynomials";
        license = lib.licenses.gpl3Only;
      }) {};
 
···
      }:
      mkDerivation {
        pname = "htalkat";
-       version = "0.1.2.4";
-       sha256 = "0ckqri1ilkjgr71774y7hsdp3w9if5yr99lldxsprmz5k30csrnx";
+       version = "0.1.2.5";
+       sha256 = "043y9pmjqd7b45bmiddnc4dv8vk5mgl3gz8xc3aqmg8vf2drmvp5";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "http-semantics" = callPackage
+    ({ mkDerivation, array, base, bytestring, case-insensitive
+     , http-types, network, network-byte-order, time-manager
+     , utf8-string
+     }:
+     mkDerivation {
+       pname = "http-semantics";
+       version = "0.0.0";
+       sha256 = "04wi14c0hy2dpzazv6v49100dc4r16rzkii14625xkijcgjlcx7w";
+       libraryHaskellDepends = [
+         array base bytestring case-insensitive http-types network
+         network-byte-order time-manager utf8-string
+       ];
+       description = "HTTP senmatics libarry";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "http-server" = callPackage
     ({ mkDerivation, base, HTTP, mime, network, network-uri, text, unix
      , url, utf8-string
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "http2_5_1_4" = callPackage
+  "http2_5_2_1" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, array, async, base
      , base16-bytestring, bytestring, case-insensitive, containers
      , crypton, directory, filepath, gauge, Glob, hspec, hspec-discover
-     , http-types, network, network-byte-order, network-control
-     , network-run, random, stm, text, time-manager, typed-process
-     , unix-time, unliftio, unordered-containers, utf8-string, vector
+     , http-semantics, http-types, network, network-byte-order
+     , network-control, network-run, random, stm, text, time-manager
+     , typed-process, unix-time, unliftio, unordered-containers
+     , utf8-string, vector
      }:
      mkDerivation {
        pname = "http2";
-       version = "5.1.4";
-       sha256 = "0asf51bfzbn0nxp0zn58089ym1c4wkcmh67qdd0s094r1qh9d5x2";
+       version = "5.2.1";
+       sha256 = "0qgyykw866m06d8br6ppwwq3dxzm028gssjq402qfs46axxkxzdf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         array async base bytestring case-insensitive containers http-types
-         network network-byte-order network-control stm time-manager
-         unix-time unliftio utf8-string
+         array async base bytestring case-insensitive containers
+         http-semantics http-types network network-byte-order
+         network-control stm time-manager unix-time unliftio utf8-string
        ];
        testHaskellDepends = [
          aeson aeson-pretty async base base16-bytestring bytestring crypton
-         directory filepath Glob hspec http-types network network-byte-order
-         network-run random text typed-process unordered-containers vector
+         directory filepath Glob hspec http-semantics http-types network
+         network-byte-order network-run random text typed-process unliftio
+         unordered-containers vector
        ];
        testToolDepends = [ hspec-discover ];
        benchmarkHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "http2-grpc-proto-lens";
-       version = "0.1.0.0";
-       sha256 = "0nhygkv1z7qrhnrgms3kzzay5h5qqrdi4081v896prwjl2xd2p4f";
+       version = "0.1.1.0";
+       sha256 = "07x1qv819sh5axw3irdam07j00pfhrh7c5f9fl9dqj3sq60ssvkn";
        libraryHaskellDepends = [
          base binary bytestring case-insensitive http2-grpc-types proto-lens
          zlib
···
        pname = "http2-grpc-proto3-wire";
        version = "0.1.0.0";
        sha256 = "00k7sm7z0q8k1zr3lcsyaciylk03c18cpdciqq33rfj6p7jwyphv";
-       revision = "1";
-       editedCabalFile = "0454bzkjf63avp8rckl5pp3l30nc41d3ixzbh9diaml70hkhsv2g";
+       revision = "2";
+       editedCabalFile = "141gxfhdy2dchxy7mymp6fp7iwf8ww0gsn7p1d0kcc5qr62my31f";
        libraryHaskellDepends = [
          base binary bytestring case-insensitive http2-grpc-types
          proto3-wire zlib
···
      }:
      mkDerivation {
        pname = "http2-tls";
-       version = "0.2.8";
-       sha256 = "0zb9wgwlyd4lac3ivcm9s49xjx226fiqxnx11rb39fnkyvldw01w";
+       version = "0.2.11";
+       sha256 = "1vi55fk0n168j42n83mdiifqksh7d2fq3pyg3fq06b7bj1597khm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
   "http3" = callPackage
     ({ mkDerivation, array, attoparsec, base, base16-bytestring
      , bytestring, case-insensitive, conduit, conduit-extra, containers
-     , crypton, hspec, hspec-discover, http-types, http2, iproute
-     , network, network-byte-order, quic, QuickCheck, sockaddr, stm
-     , time-manager, tls, unliftio
+     , crypton, hspec, hspec-discover, http-semantics, http-types, http2
+     , iproute, network, network-byte-order, quic, QuickCheck, sockaddr
+     , stm, time-manager, tls, unliftio
      }:
      mkDerivation {
        pname = "http3";
-       version = "0.0.10";
-       sha256 = "0azhvf92wxxx9rlj2l8xc77ch7n52jpd7yjilzjfd55v06v9k2hz";
+       version = "0.0.11";
+       sha256 = "1z3hqalylraxmx18h82gljpbaslzd8mz2ndv8g15mhfac6jjz4rd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         array base bytestring case-insensitive containers http-types http2
-         network network-byte-order quic sockaddr stm time-manager unliftio
+         array base bytestring case-insensitive containers http-semantics
+         http-types http2 network network-byte-order quic sockaddr stm
+         time-manager unliftio
        ];
        testHaskellDepends = [
          attoparsec base base16-bytestring bytestring conduit conduit-extra
-         crypton hspec http-types http2 iproute network quic QuickCheck stm
-         tls unliftio
+         crypton hspec http-semantics http-types http2 iproute network quic
+         QuickCheck stm tls unliftio
        ];
        testToolDepends = [ hspec-discover ];
        description = "HTTP/3 library";
···
        pname = "hw-string-parse";
        version = "0.0.0.5";
        sha256 = "0sg5s84pqyl93wm052ifrqv90cyc28awh4i6vcd8zbq746wdqz4k";
-       revision = "2";
-       editedCabalFile = "0580mz2gr11jc6lyyrnp5jxijzbir8qcsq979bc91jwcvc99kc5r";
+       revision = "3";
+       editedCabalFile = "1vsr2b5j8iz28h163ymv3cm03f975qhjbw5jfzzs6f4j4m53dh49";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base bytestring doctest doctest-discover hspec QuickCheck vector
···
 
   "interval-patterns" = callPackage
     ({ mkDerivation, base, containers, deepseq, groups, hashable, heaps
-     , hspec, lattices, QuickCheck, semirings, time, time-compat
+     , hspec, lattices, parsec, QuickCheck, semirings, text, time
+     , time-compat
      }:
      mkDerivation {
        pname = "interval-patterns";
-       version = "0.7.2";
-       sha256 = "1cwv7yfc64zffa05mq300bb6zwdkgk85mjh10dzgnj1g1rd5z593";
+       version = "0.8.0";
+       sha256 = "1paciwq4wzl0kqkl5zzj486dsq5pg6275nj15gicv1czj7m9ncg9";
        libraryHaskellDepends = [
          base containers deepseq groups hashable heaps lattices semirings
          time time-compat
        ];
        testHaskellDepends = [
-         base containers deepseq groups hashable heaps hspec lattices
-         QuickCheck semirings time time-compat
+         base containers deepseq groups hashable heaps hspec lattices parsec
+         QuickCheck semirings text time time-compat
        ];
        description = "Intervals, and monoids thereof";
        license = lib.licenses.bsd3;
···
        pname = "io-streams";
        version = "1.5.2.2";
        sha256 = "1zn4iyd18g9jc1qdgixp6hi56nj7czy4jdz2xca59hcn2q2xarfk";
-       revision = "4";
-       editedCabalFile = "12xc9y7ynxrw9gbqgr6kxslcdssbgkb361qiw3bgvimngjspjqzj";
+       revision = "5";
+       editedCabalFile = "0zwqb5wlwjs85j28z4znxpmf4m4svjbgzq8djybwvdhgniansyic";
        configureFlags = [ "-fnointeractivetests" ];
        libraryHaskellDepends = [
          attoparsec base bytestring network primitive process text time
···
        pname = "io-streams-haproxy";
        version = "1.0.1.0";
        sha256 = "1dcn5hd4fiwyq7m01r6fi93vfvygca5s6mz87c78m0zyj29clkmp";
-       revision = "8";
-       editedCabalFile = "03gzlz7hg2jvnx2355r65201680lcm59ln7azzb118abirl460s6";
+       revision = "9";
+       editedCabalFile = "1waziyv0f1iap83abgn4ax1zwbdbhfhzh72smzm1azqzl6ggcdq2";
        libraryHaskellDepends = [
          attoparsec base bytestring io-streams network transformers
        ];
···
 
   "jackpolynomials" = callPackage
     ({ mkDerivation, array, base, combinat, containers, hspray
-     , hypergeomatrix, ilist, lens, numeric-prelude, tasty, tasty-hunit
+     , hypergeomatrix, ilist, lens, miniterion, numeric-prelude, tasty
+     , tasty-hunit
      }:
      mkDerivation {
        pname = "jackpolynomials";
-       version = "1.2.1.0";
-       sha256 = "1iwzsld7xxrlzsx5vs84lgbgdjrds316fryf1y40l6pb57cli582";
+       version = "1.2.2.0";
+       sha256 = "0pi4d848502hmrl2n9gin0zh426w91cbxvzjmcwd24idzgqqac1f";
        libraryHaskellDepends = [
          array base combinat containers hspray ilist lens numeric-prelude
        ];
        testHaskellDepends = [
          base hspray hypergeomatrix tasty tasty-hunit
        ];
+       benchmarkHaskellDepends = [ base hspray miniterion ];
        description = "Jack, zonal, Schur and skew Schur polynomials";
        license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
···
        pname = "javelin";
        version = "0.1.2.0";
        sha256 = "12xzs05dkkbn93yh1f5l7m64j3rifcz9qnd5nqqd62cj6nic10xl";
+       revision = "1";
+       editedCabalFile = "03pdxr80s9ah2yv3kxs76r1dz0j75zvcaylskm203c3cqg1f7scx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "javelin-io";
        version = "0.1.1.1";
        sha256 = "1c6w0p7yjbc3yw12f5bflgacvivzc1n0dxgmz2qn06yiraw6jyv6";
+       revision = "1";
+       editedCabalFile = "0z25nvwh5wzsaa022gp4pc5bxk1xqrfj98q6ni3mh4r3kydcm50g";
        libraryHaskellDepends = [
          base bytestring cassava containers javelin unordered-containers
          vector
···
        ];
        description = "Interface for JavaScript that works with GHCJS and GHC";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "jsaddle-dom" = callPackage
···
        sha256 = "0r8payj72akz951jmv7frllj8cxpwgjyci7gad7250s7nmnd9f1s";
        description = "Interface for JavaScript that works with GHCJS and GHC";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       platforms = lib.platforms.darwin;
      }) {};
 
   "jsc" = callPackage
···
        ];
        description = "Generics JSON (de)serialization using generics-sop";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "json-spec" = callPackage
···
        pname = "kansas-comet";
        version = "0.4.2";
        sha256 = "01g30ck1nhj8qwz475mvwvmd8nc1yqxl5qi84c957gp116kig2v7";
-       revision = "2";
-       editedCabalFile = "1qila4mpczr0wrg4wn7pi65s7243w1flpdmj6v80684r33knspzc";
+       revision = "3";
+       editedCabalFile = "00wy4v9xdnp4801qww61gpqfshnbymmh4571rs56lq2f1apzifgv";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base containers data-default-class scotty stm text time
···
        pname = "keycode";
        version = "0.2.2";
        sha256 = "046k8d1h5wwadf5z4pppjkc3g7v2zxlzb06s1xgixc42y5y41yan";
-       revision = "10";
-       editedCabalFile = "1k2vh3pyxvhfxcx8ra16dl6jrgc5hz0wc4hn9w20z347v1hr51nq";
+       revision = "11";
+       editedCabalFile = "0il646ra0nb0fy1310im1y82w9gh08j6vwi7hw7kpxy1h9q6jp4j";
        libraryHaskellDepends = [
          base containers ghc-prim template-haskell
        ];
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "language-docker_13_0_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, data-default
+     , data-default-class, hspec, hspec-discover, hspec-megaparsec
+     , HUnit, megaparsec, prettyprinter, QuickCheck, split, text, time
+     }:
+     mkDerivation {
+       pname = "language-docker";
+       version = "13.0.0";
+       sha256 = "16ywhy8bah81x9agckqbkad0h7k6gzxgds5frbj4nvs7x8xp6vh8";
+       libraryHaskellDepends = [
+         base bytestring containers data-default data-default-class
+         megaparsec prettyprinter split text time
+       ];
+       testHaskellDepends = [
+         base bytestring containers data-default data-default-class hspec
+         hspec-megaparsec HUnit megaparsec prettyprinter QuickCheck split
+         text time
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Dockerfile parser, pretty-printer and embedded DSL";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "language-dockerfile" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory, filepath, free
      , Glob, hspec, HUnit, mtl, parsec, pretty, process, QuickCheck
···
      }) {};
 
   "language-toolkit" = callPackage
-    ({ mkDerivation, base, containers, deepseq, directory, filepath
-     , haskeline, parallel, process, transformers
+    ({ mkDerivation, array, base, containers, deepseq, directory
+     , exceptions, filepath, finite-semigroups, haskeline, parallel
+     , process, transformers
      }:
      mkDerivation {
        pname = "language-toolkit";
-       version = "1.1.0.0";
-       sha256 = "0ffr53jggh3c01v802xywy387jv5wa5vwwyvipiqpxwqcspr4nd7";
-       revision = "4";
-       editedCabalFile = "13m1qsn04yc4q04xihjivb6pz73gv0sn9d5qxb9q1a4cg63k21c8";
+       version = "1.2.0.0";
+       sha256 = "1nc94p3bnn6mdliag4pdgvb5mx5qcj0libqrpm7nwxhhs2ys8vd1";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ base containers deepseq parallel ];
+       libraryHaskellDepends = [
+         array base containers deepseq finite-semigroups parallel
+       ];
        executableHaskellDepends = [
-         base containers deepseq directory filepath haskeline parallel
-         process transformers
+         base containers deepseq directory exceptions filepath
+         finite-semigroups haskeline parallel process transformers
        ];
        description = "A set of tools for analyzing languages via logic and automata";
        license = lib.licenses.mit;
···
        ];
        description = "Generic programming API for large-records and large-anon";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "large-hashable" = callPackage
···
        description = "Efficient compilation for large records, linear in the size of the record";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "largeword" = callPackage
···
        pname = "lens-properties";
        version = "4.11.1";
        sha256 = "1caciyn75na3f25q9qxjl7ibjam22xlhl5k2pqfiak10lxsmnz2g";
-       revision = "6";
-       editedCabalFile = "10c8phmf4znr6a9gkzvi2b9q9b9qc8cmslaxlx2hv59j62216h0f";
+       revision = "7";
+       editedCabalFile = "14n9yzar4zfqigyayxhi11a0g954nb4jcz0fahgpxyl2vbg7h1ch";
        libraryHaskellDepends = [ base lens QuickCheck transformers ];
        description = "QuickCheck properties for lens";
        license = lib.licenses.bsd3;
···
        ];
        description = "Computing lenses generically using generics-sop";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "lens-tell" = callPackage
···
      }:
      mkDerivation {
        pname = "libsecp256k1";
-       version = "0.1.5";
-       sha256 = "1x9f9ym6ssxbk404argf2y455bv2qxrcyy7brkql1fpqphl6g1dp";
+       version = "0.2.0";
+       sha256 = "08mgdpcc70jw0v2jn69g6xxpl0xcfr82ybwah0i0rqh5pqjsi9zw";
        libraryHaskellDepends = [
          base bytestring deepseq entropy hashable hedgehog memory
          transformers
···
 
   "libyaml-streamly" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, libyaml
-     , safe-exceptions, streamly
+     , safe-exceptions, streamly-core
      }:
      mkDerivation {
        pname = "libyaml-streamly";
-       version = "0.2.2.1";
-       sha256 = "01dq36mwp7kpkn05hs7dhn9lxnjy9gp2p39ync01d73x7a1ic548";
+       version = "0.2.3.0";
+       sha256 = "1jmrxnxh3qps3wa8b0hjlwxgc36j0hk2b6jkxsaymx03rjvml2zn";
        libraryHaskellDepends = [
-         base bytestring deepseq safe-exceptions streamly
+         base bytestring deepseq safe-exceptions streamly-core
        ];
        libraryPkgconfigDepends = [ libyaml ];
        description = "Low-level, streaming YAML interface via streamly";
···
        pname = "lift-generics";
        version = "0.2.1";
        sha256 = "1qkzq8hcb6j15cslv577bmhjcxmljzsrryysdgd7r99kr3q445b4";
-       revision = "6";
-       editedCabalFile = "0px8gjhzw1fvzbd1jha8kcc3p603hc8ki4kwi26vhg7n3ldy5nay";
+       revision = "7";
+       editedCabalFile = "1v61s0fhl87q6rvnw4qz0bvl75mpa2ag3yvjji6lbs9g6b8lh23q";
        libraryHaskellDepends = [
          base generic-deriving ghc-prim template-haskell th-compat
        ];
···
        pname = "literatex";
        version = "0.3.0.0";
        sha256 = "0ph3s26hxvnkdqc3s09d3ka1p224zmgwc3k6zi7jmma0sgrmnm9x";
-       revision = "6";
-       editedCabalFile = "0kg4sqfjqx3abd0y0qhakaabpz62x6j535gkqgiz3zkkbkc0drpz";
+       revision = "7";
+       editedCabalFile = "0w03xl8i6j47li8cp0issjf6k2n5kwkhp461pp5spsw0hkb4gl3i";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "A simple text parser with decent errors";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "looksee-trip" = callPackage
···
     ({ mkDerivation, base, containers, Glob, parsec, text }:
      mkDerivation {
        pname = "lsql-csv";
-       version = "0.1.0.2";
-       sha256 = "1ja2xbjl11i1cc77qszgphy9v859rzxc87z6l6kp8cz58095qb4v";
+       version = "0.1.0.3";
+       sha256 = "0pvv2skbwnwn685hj75iwlxkgw9x1q7bjk5gdm5101kdnnnp464q";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers Glob parsec text ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "lucid2_0_0_20240424" = callPackage
+    ({ mkDerivation, base, bifunctors, bytestring, containers, hspec
+     , HUnit, mtl, parsec, text, transformers
+     }:
+     mkDerivation {
+       pname = "lucid2";
+       version = "0.0.20240424";
+       sha256 = "1ccpcbq84y53dxna700rfn6gaxn6xywqfdn27xpvbrl79w5x5p1j";
+       libraryHaskellDepends = [
+         base bytestring containers mtl text transformers
+       ];
+       testHaskellDepends = [
+         base bifunctors hspec HUnit mtl parsec text
+       ];
+       description = "Clear to write, read and edit DSL for HTML";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "lucid2-htmx" = callPackage
     ({ mkDerivation, base, hspec, HUnit, lucid2, text }:
      mkDerivation {
···
        pname = "megaparsec-tests";
        version = "9.6.1";
        sha256 = "1l3rmg4ymw4czqkkb3502g322ijdg11c1img9l4p6ipy7hdzw52n";
+       revision = "1";
+       editedCabalFile = "0vycmn3c32z1bk19612277df41in55rkyk23gk3m007drsaq3xdl";
        libraryHaskellDepends = [
          base bytestring containers hspec hspec-megaparsec megaparsec mtl
   "hmumps" = callPackage
···
        pname = "microaeson";
        version = "0.1.0.1";
        sha256 = "0rx5gm7apazc0sm65v687ab5106ximka9khizxq1lbckd2x0cq3q";
-       revision = "8";
-       editedCabalFile = "1w9pm69vm0r3zkmcls3zd6b0vc3ifvsjmwj2wk7gc23pj4bwzwlb";
+       revision = "9";
+       editedCabalFile = "0w43nprqacq6vx645263x7sirnv4jkw985gyynhxfldyp3yw895h";
        libraryHaskellDepends = [
          array base bytestring containers deepseq fail text
        ];
···
        description = "microc compiler";
        license = lib.licenses.bsd3;
        mainProgram = "microc-exe";
+     }) {};
+
+  "microdns" = callPackage
+    ({ mkDerivation, aeson, async, base, base16-bytestring, bytestring
+     , case-insensitive, cryptohash-sha256, dns, ip, iproute, megaparsec
+     , network, optparse-generic, prodapi, prometheus-client, servant
+     , servant-server, streaming-commons, text, wai-extra, warp
+     , warp-tls
+     }:
+     mkDerivation {
+       pname = "microdns";
+       version = "0.1.0.0";
+       sha256 = "0wr24630jqhfnnngrnvbc5zd96jj4rgc02g2gd24vywdspk2nk56";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         aeson async base base16-bytestring bytestring case-insensitive
+         cryptohash-sha256 dns ip iproute megaparsec network
+         optparse-generic prodapi prometheus-client servant servant-server
+         streaming-commons text wai-extra warp warp-tls
+       ];
+       description = "a minimalistic DNS-authoritative server";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "microdns";
      }) {};
 
   "microformats2-parser" = callPackage
···
      }:
      mkDerivation {
        pname = "microlens-ghc";
-       version = "0.4.14.2";
-       sha256 = "17fdc5jpqlq3q61mf6qia7a18kqq4nfpbrv2j2n4a4cx62kcbraq";
+       version = "0.4.14.3";
+       sha256 = "13sczn286n6yjjhnf3nsjq1l43rgxawr61ma1f4pmwd4aj1ihdcp";
        libraryHaskellDepends = [
          array base bytestring containers microlens transformers
        ];
···
      }:
      mkDerivation {
        pname = "microlens-pro";
-       version = "0.2.0";
-       sha256 = "03vadipi3qkyz6xyf2by8jqq453gvpisqhwvrhaykbwx6pxrzwnj";
+       version = "0.2.0.1";
+       sha256 = "16bb5myflaxwksqkl890vg3349sd5lcr6g2iaq8kn82k3wkq0ynm";
        libraryHaskellDepends = [
          base containers microlens microlens-contra microlens-platform
          microlens-th mtl profunctors tagged template-haskell text
···
      }:
      mkDerivation {
        pname = "microlens-th";
-       version = "0.4.3.14";
-       sha256 = "0sjvzywcar5fxmpbdj5ili4m4pcz77hnk27i99qsdrxjzmmwkycj";
+       version = "0.4.3.15";
+       sha256 = "1ja59samyqng78v9lhrwa6x4vd5vvr9jkrm3pyi2kbcp28kv7khg";
        libraryHaskellDepends = [
          base containers microlens template-haskell th-abstraction
          transformers
···
      }:
      mkDerivation {
        pname = "mmzk-typeid";
-       version = "0.5.0.2";
-       sha256 = "0ricw68ymglh4nh1ncyfhcwaw82apc8wi4nsqas7y1a9fk4pbgp2";
+       version = "0.6.0.1";
+       sha256 = "0dcwa97whwwk267cvbmvixya465v7hyc45i0s1jvgxqjhmpy3p6d";
        libraryHaskellDepends = [
          aeson array base binary bytestring entropy hashable random text
          time uuid uuid-types
···
      }:
      mkDerivation {
        pname = "monoidmap";
-       version = "0.0.1.2";
-       sha256 = "1gva15h7jkll43529c6q7w4z27cbx8rpddda1gg27w6i7i9rv4dh";
+       version = "0.0.1.3";
+       sha256 = "1hi4sqky1wwgx5i9cjn6dsf5dim9k5lw74j8a0wghq2rwab7b2ng";
        libraryHaskellDepends = [
          base containers deepseq groups monoid-subclasses
          nonempty-containers nothunks
···
        pname = "mueval";
        version = "0.9.4";
        sha256 = "1r6gm1drfkblf6vl36z1kbjpvz5dmcjn4hnlm8r59m794palwzzk";
+       revision = "1";
+       editedCabalFile = "141maqz3b1d877fxnispbbcsc3yg7iil0smgdmw1zjb2cdrlmqh2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Safely evaluate pure Haskell expressions";
        license = lib.licenses.bsd3;
-       badPlatforms = [ "aarch64-linux" ];
        mainProgram = "mueval";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "national-australia-bank";
-       version = "0.0.3";
-       sha256 = "11jh9lap1763qhpybylhsjvnqsiba1757rlcddqp391j4n2pmb51";
+       version = "0.0.4";
+       sha256 = "0fyymrwmkx58xgadvwsrpsigrdwz63hjwkqk6hjw3ish2q7527ss";
        libraryHaskellDepends = [
          base bytestring containers digit directory filepath lens mtl parsec
          sv time transformers utf8-string validation
···
      }:
      mkDerivation {
        pname = "network-arbitrary";
-       version = "0.7.0.0";
-       sha256 = "0n3c9hm8p404diksx23l4afa7i4lcl92m2zp2aw4zy8n9vhpz8sv";
+       version = "1.0.0.0";
+       sha256 = "00h1qwnk2clybf06d172pjmf87qb7jwsdn2l1a08hszq1pxyb9ch";
        libraryHaskellDepends = [
          base bytestring http-media http-types network-uri QuickCheck
        ];
···
     ({ mkDerivation, base, bytestring, network, time-manager }:
      mkDerivation {
        pname = "network-run";
-       version = "0.2.7";
-       sha256 = "14x55n79cg74xbjcii00nyi0y7zxh7lw03qdkl4inm1smfsm7zjl";
-       libraryHaskellDepends = [ base bytestring network time-manager ];
-       description = "Simple network runner library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "network-run_0_2_8" = callPackage
-    ({ mkDerivation, base, bytestring, network, time-manager }:
-     mkDerivation {
-       pname = "network-run";
        version = "0.2.8";
        sha256 = "1yqqvb9l17n2r4giigppj12xdpvx0m13yyhlx5ss3r4qkdj2b962";
        libraryHaskellDepends = [ base bytestring network time-manager ];
        description = "Simple network runner library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "network-server" = callPackage
···
      }:
      mkDerivation {
        pname = "ngx-export-distribution";
-       version = "0.5.4.0";
-       sha256 = "0w7pvv44l4kllfgvsmszxja8wzimiskkqa1nna21cfhfkfc78h03";
+       version = "0.5.4.1";
+       sha256 = "17dqaclyn40jqvmsffilhly1darmzi2p1viaqsylijibx60hn04r";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base Cabal directory filepath ];
···
        ];
        description = "Lightweight dependency management with Nix";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "nix-thunk";
      }) {};
 
···
        broken = true;
      }) {};
 
+  "opaleye-textsearch" = callPackage
+    ({ mkDerivation, base, opaleye }:
+     mkDerivation {
+       pname = "opaleye-textsearch";
+       version = "0.1.0.0";
+       sha256 = "01wck3d21if4fnna3xj5k75g2yn6443jd3aq30nvb8p7sdvj6019";
+       libraryHaskellDepends = [ base opaleye ];
+       testHaskellDepends = [ base ];
+       description = "Text search utilities for Opaleye";
+       license = lib.licenses.agpl3Plus;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "opaleye-trans" = callPackage
     ({ mkDerivation, base, exceptions, mtl, opaleye, postgresql-simple
      , product-profunctors, transformers
···
        pname = "os-string";
        version = "2.0.2";
        sha256 = "18fay8gmlwskfhdikkhb21za1zpmjvsp33f9afbp2ri9jrp14lq9";
+       revision = "1";
+       editedCabalFile = "09mfw49by3k1i1l0jwfm43wqzwijzn0hqpwi6f7gpjxdg7wvsmvk";
        libraryHaskellDepends = [
          base bytestring deepseq exceptions template-haskell
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "os-string_2_0_2_1" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, exceptions, QuickCheck
+     , quickcheck-classes-base, random, tasty-bench, template-haskell
+     }:
+     mkDerivation {
+       pname = "os-string";
+       version = "2.0.2.1";
+       sha256 = "1ppz0hnqra91pf18n2dqyxy59lrryk50cgllvxk6pfgwfkavglkx";
+       libraryHaskellDepends = [
+         base bytestring deepseq exceptions template-haskell
+       ];
+       testHaskellDepends = [
+         base bytestring deepseq QuickCheck quickcheck-classes-base
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring deepseq random tasty-bench
+       ];
+       description = "Library for manipulating Operating system strings";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "osc" = callPackage
     ({ mkDerivation, attoparsec, base, binary, bytestring
      , data-binary-ieee754, network
···
        pname = "pandoc-lua-marshal";
        version = "0.2.6";
        sha256 = "029wqihgkcdfyy21pdc4gj8hh2av9c29nypcabxch8bfkz6lq0lw";
+       revision = "1";
+       editedCabalFile = "15rdndh2axp1mzpnygb3ilvdkd7gv0h9zdlv9hjaiavas6s28y4v";
        libraryHaskellDepends = [
          aeson base bytestring containers exceptions hslua hslua-list
          hslua-marshalling pandoc-types safe text
···
        pname = "pandoc-types";
        version = "1.23.1";
        sha256 = "1hd18l1c5yh7x24gsligkbraadq12hn7mim16xyjnicdsa1s03xd";
-       revision = "1";
-       editedCabalFile = "02yaziq3xyz9zqr4qrqm4drlqpa3xnxmm5x0ci52c5p5dr3c3b3d";
+       revision = "2";
+       editedCabalFile = "1whymq4w5z08l5ng829kn8aslczda6svi6c6q72cnv200mlq7d1c";
        libraryHaskellDepends = [
          aeson base bytestring containers deepseq ghc-prim QuickCheck syb
          text transformers
···
        pname = "parser-combinators-tests";
        version = "1.3.0";
        sha256 = "0sw6ws7za93y3lbmxp6jp1k17zi3wdg7698ab133kcw82f6mzba2";
+       revision = "1";
+       editedCabalFile = "0h6lwj0mdlirlwcadjvyblvgqg6yksw2bnp77qkjxm2kk3rw56hn";
        isLibrary = false;
        isExecutable = false;
        testHaskellDepends = [
···
        pname = "phatsort";
        version = "0.6.0.0";
        sha256 = "1cjmamla9383fk9715jxzlw87qnd26hpkcqhk4vvgld51nraf2pl";
-       revision = "3";
-       editedCabalFile = "0fjd37sigkccr9dw70z3yy8hjn7p210b5nn52lj1hf0jlks81q0a";
+       revision = "4";
+       editedCabalFile = "0q5ilnq24n4zwhavvp2qxr5j91p3msj7ssb7qfbxvkzdml879bp7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "pointfree";
-       version = "1.1.1.11";
-       sha256 = "17xaxmyys7x1l3v3a72fdkb8klr0xp0mnh6aspfa7ysakagblnf0";
+       version = "1.1.1.12";
+       sha256 = "0mrrdmslcdk2ld8g78i00jwidn765w3l7la0qdlawc2lc17w2ili";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) postgresql;};
 
+  "postgresql-libpq_0_10_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, postgresql, tasty
+     , tasty-hunit, unix
+     }:
+     mkDerivation {
+       pname = "postgresql-libpq";
+       version = "0.10.1.0";
+       sha256 = "1w49zp3izxi3s4mq71i93i4s08kwcv1j0j6m5cfpxcp5s4h12pwq";
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [ base bytestring unix ];
+       librarySystemDepends = [ postgresql ];
+       testHaskellDepends = [ base bytestring tasty tasty-hunit ];
+       description = "low-level binding to libpq";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) postgresql;};
+
   "postgresql-libpq-notify" = callPackage
     ({ mkDerivation, async, base, hspec, postgres-options
      , postgresql-libpq, stm, text, tmp-postgres
···
        mainProgram = "example-netcat-test";
      }) {};
 
+  "prodapi" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, containers
+     , contravariant, directory, http-api-data, http-client, http-media
+     , lucid, process-extras, prometheus-client, prometheus-metrics-ghc
+     , servant, servant-client, servant-server, text, time, uuid, wai
+     }:
+     mkDerivation {
+       pname = "prodapi";
+       version = "0.1.0.0";
+       sha256 = "0hqfxkg2il8sbbav5qwpydqvvj5zd9r9i2x7jlqxbdfg9jz2fr16";
+       libraryHaskellDepends = [
+         aeson async base bytestring containers contravariant directory
+         http-api-data http-client http-media lucid process-extras
+         prometheus-client prometheus-metrics-ghc servant servant-client
+         servant-server text time uuid wai
+       ];
+       description = "Some curated and opinionated packages for building Haskell services";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "prodapi-proxy" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, http-client
+     , http-reverse-proxy, http-types, prodapi, prometheus-client
+     , random-shuffle, servant, servant-server, text, time, tls, wai
+     , warp-tls
+     }:
+     mkDerivation {
+       pname = "prodapi-proxy";
+       version = "0.1.0.0";
+       sha256 = "14zhvfwvkdxa2pi0p4nzn30001xsdmgx7dg3rnbv2b319jjq5pbm";
+       libraryHaskellDepends = [
+         aeson base bytestring containers http-client http-reverse-proxy
+         http-types prodapi prometheus-client random-shuffle servant
+         servant-server text time tls wai warp-tls
+       ];
+       description = "write an HTTP proxy with prodapi counters";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "prodapi-userauth" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, cookie
+     , http-api-data, jwt, lucid, postgresql-simple, prodapi
+     , prometheus-client, servant, servant-server, text, time, uuid, wai
+     }:
+     mkDerivation {
+       pname = "prodapi-userauth";
+       version = "0.1.0.0";
+       sha256 = "0xmizx7xrh3hqxddnh699bhz1k8jy157n3rzn35akczp75d7gv1h";
+       libraryHaskellDepends = [
+         aeson base bytestring containers cookie http-api-data jwt lucid
+         postgresql-simple prodapi prometheus-client servant servant-server
+         text time uuid wai
+       ];
+       description = "a base lib for performing user-authentication in prodapi services";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "producer" = callPackage
     ({ mkDerivation, base, checkers, QuickCheck, tasty, tasty-auto
      , tasty-hunit, tasty-quickcheck
···
        ];
        description = "Arbitrary instances for proto-lens";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "proto-lens-combinators" = callPackage
···
 
   "proto3-wire" = callPackage
     ({ mkDerivation, base, bytestring, cereal, containers, criterion
-     , deepseq, doctest, ghc-prim, hashable, parameterized, primitive
-     , QuickCheck, random, safe, tasty, tasty-hunit, tasty-quickcheck
+     , deepseq, doctest, hashable, parameterized, primitive, QuickCheck
+     , random, safe, tasty, tasty-hunit, tasty-quickcheck
      , template-haskell, text, text-short, transformers
      , unordered-containers, vector, word-compat
      }:
      mkDerivation {
        pname = "proto3-wire";
-       version = "1.4.1";
-       sha256 = "0liy2qnx9y10ad79nfw0idp2c5mz37pwb1h07f82g4rbg66qn465";
+       version = "1.4.2";
+       sha256 = "0ly8nc5z6ri1bj5l8h0r23kwsjr0m7nrwbyzxscp5q4880rqx492";
        libraryHaskellDepends = [
-         base bytestring cereal containers deepseq ghc-prim hashable
-         parameterized primitive QuickCheck safe template-haskell text
-         text-short transformers unordered-containers vector word-compat
+         base bytestring cereal containers deepseq hashable parameterized
+         primitive QuickCheck safe template-haskell text text-short
+         transformers unordered-containers vector word-compat
        ];
        testHaskellDepends = [
          base bytestring cereal doctest QuickCheck tasty tasty-hunit
···
        benchmarkHaskellDepends = [ base bytestring criterion random ];
        description = "A low-level implementation of the Protocol Buffers (version 3) wire format";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "protobuf" = callPackage
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "proxied";
-       version = "0.3.1";
-       sha256 = "0ldcyvzg5i4axkn5qwgkc8vrc0f0715842ca41d7237p1bh98s4r";
+       version = "0.3.2";
+       sha256 = "137g3xwjan292ablfqz32g7kbjyj43nvwq0ah9syq1ivz1w71ay2";
        libraryHaskellDepends = [ base ];
        description = "Make functions consume Proxy instead of undefined";
        license = lib.licenses.bsd3;
···
        pname = "quic";
        version = "0.1.20";
        sha256 = "0zzpdb07xrgx3bcvnfmn778yamk6q86lqmj1ir1h3g82gcknzfxm";
+       revision = "1";
+       editedCabalFile = "0nnl78qiczrsqzjhfvwc89m6v1kyvaysph5v1m9bi37ainvy8222";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "quickcheck-classes";
        version = "0.6.5.0";
        sha256 = "19iw15mvb7gws3ljdxqwsbb4pmfc0sfflf8szgmrhiqr3k82mqv2";
-       revision = "2";
-       editedCabalFile = "0gldr9kcij41b8imsyf11q26kd1nf8vhfh8wd9i1fn01jbxzgi37";
+       revision = "3";
+       editedCabalFile = "1pawam5rsdcdv21fqc87khzqjm0ixwzklfxd6gk3b2qrr5q66bn5";
        libraryHaskellDepends = [
          aeson base containers primitive primitive-addr QuickCheck
          quickcheck-classes-base semigroupoids semirings transformers vector
···
        license = lib.licenses.asl20;
      }) {};
 
+  "quickcheck-groups_0_0_1_2" = callPackage
+    ({ mkDerivation, base, groups, hspec, hspec-discover, pretty-show
+     , QuickCheck, quickcheck-classes, quickcheck-instances
+     , semigroupoids
+     }:
+     mkDerivation {
+       pname = "quickcheck-groups";
+       version = "0.0.1.2";
+       sha256 = "0pv1j93g4cmfsh4yijrcc7qgrkggk92jmhl1qjj83yzszm4fb80p";
+       libraryHaskellDepends = [
+         base groups pretty-show QuickCheck quickcheck-classes
+         quickcheck-instances semigroupoids
+       ];
+       testHaskellDepends = [
+         base groups hspec QuickCheck quickcheck-classes
+       ];
+       testToolDepends = [ hspec-discover ];
+       doHaddock = false;
+       description = "Testing group class instances with QuickCheck";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "quickcheck-higherorder" = callPackage
     ({ mkDerivation, base, QuickCheck, tasty, tasty-hunit
      , tasty-quickcheck, test-fun
···
        license = lib.licenses.asl20;
      }) {};
 
+  "quickcheck-monoid-subclasses_0_3_0_3" = callPackage
+    ({ mkDerivation, base, bytestring, commutative-semigroups
+     , containers, hspec, hspec-discover, monoid-subclasses, pretty-show
+     , QuickCheck, quickcheck-classes, quickcheck-instances
+     , semigroupoids, text, vector
+     }:
+     mkDerivation {
+       pname = "quickcheck-monoid-subclasses";
+       version = "0.3.0.3";
+       sha256 = "0z7i93f9r6f0c8xvyja8v4gwm4ydhymir9lzncails53v2aw1g71";
+       libraryHaskellDepends = [
+         base containers monoid-subclasses pretty-show QuickCheck
+         quickcheck-classes quickcheck-instances semigroupoids
+       ];
+       testHaskellDepends = [
+         base bytestring commutative-semigroups containers hspec
+         monoid-subclasses QuickCheck quickcheck-classes
+         quickcheck-instances text vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       doHaddock = false;
+       description = "Testing monoid subclass instances with QuickCheck";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "quickcheck-poly" = callPackage
     ({ mkDerivation, base, haskell98, hint, MonadCatchIO-mtl
      , QuickCheck, regex-compat, regex-tdfa
···
      }:
      mkDerivation {
        pname = "quickcheck-quid";
-       version = "0.0.1.2";
-       sha256 = "1chdbkd1as9ln6cgcv62w3vqw821ybmyh500k80a3c244ipwf8ny";
+       version = "0.0.1.3";
+       sha256 = "0f2y91znim4745fdgl37y2lgv1qf3isn698w2ix15ibcs6yvkczy";
        libraryHaskellDepends = [
          base containers deepseq extra hashable QuickCheck text
        ];
···
      }) {};
 
   "radix-tree" = callPackage
-    ({ mkDerivation, base, bytestring, containers, deepseq, gauge
-     , hashtables, HUnit, primitive, QuickCheck, tasty, tasty-hunit
-     , tasty-quickcheck, text, unordered-containers
+    ({ mkDerivation, base, bytestring, containers, deepseq, hspec
+     , primitive, random, template-haskell, text
      }:
      mkDerivation {
        pname = "radix-tree";
-       version = "0.1";
-       sha256 = "0hdlj97gzqb5rgyj5ybb4kki9b6xrlavcbz7i9w8q81vwjyv8cka";
+       version = "1.0.0.0";
+       sha256 = "1cyh6fqrl175mzl2g2565r0wv2jay0xgmv8fih91jqg5rrvgs4hq";
        libraryHaskellDepends = [
-         base bytestring containers deepseq primitive
+         base bytestring deepseq primitive template-haskell text
        ];
        testHaskellDepends = [
-         base bytestring containers HUnit QuickCheck tasty tasty-hunit
-         tasty-quickcheck
+         base bytestring containers hspec primitive random text
        ];
-       benchmarkHaskellDepends = [
-         base bytestring containers deepseq gauge hashtables text
-         unordered-containers
-       ];
-       description = "Radix tree data structive over short byte-strings";
+       description = "Radix trees";
        license = lib.licenses.bsd3;
      }) {};
 
···
        broken = true;
      }) {};
 
+  "rattletrap_13_0_2" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
+     , containers, filepath, http-client, http-client-tls, text
+     }:
+     mkDerivation {
+       pname = "rattletrap";
+       version = "13.0.2";
+       sha256 = "0yrq5ydwp3p1mw5srk2x4rsv4x466xlkb7468v1mgvhnbd9i85cf";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty array base bytestring containers filepath
+         http-client http-client-tls text
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [ base bytestring filepath ];
+       description = "Parse and generate Rocket League replays";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "rattletrap";
+       broken = true;
+     }) {};
+
   "raven-haskell" = callPackage
     ({ mkDerivation, aeson, base, bytestring, http-conduit, mtl
      , network, random, resourcet, text, time, unordered-containers
···
        ];
        description = "Record subtyping and record utilities with generics-sop";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "records-th" = callPackage
···
        ];
        description = "Interact with a GADT API in your reflex-dom application";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "readme";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "resourcet-extra";
-       version = "0.1.0";
-       sha256 = "1vmb0yh94vj507gw8narrwv9vh1imlq4s7373zh9zrpd4x4h9d15";
+       version = "0.1.1";
+       sha256 = "09da35ik9ic0dx82w1wss4dainp96dzk7lc0cvjyfyzarsyig5z1";
        libraryHaskellDepends = [
          async base containers resourcet safe-exceptions unliftio-core
        ];
···
        broken = true;
      }) {};
 
+  "roc-id_0_2_0_2" = callPackage
+    ({ mkDerivation, base, hspec, MonadRandom, Only, QuickCheck, text
+     , vector-sized
+     }:
+     mkDerivation {
+       pname = "roc-id";
+       version = "0.2.0.2";
+       sha256 = "1sx66ixilvfzwnic16balzfdynpc891b3lj8gsyp9xd6z059pa61";
+       libraryHaskellDepends = [
+         base MonadRandom Only text vector-sized
+       ];
+       testHaskellDepends = [
+         base hspec MonadRandom Only QuickCheck text vector-sized
+       ];
+       description = "Implementation of the ROC (Taiwan) National ID standard";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "rock" = callPackage
     ({ mkDerivation, base, constraints, constraints-extras
      , dependent-hashmap, dependent-sum, deriving-compat, hashable
···
        pname = "safe-json";
        version = "1.2.0.1";
        sha256 = "1y03smd9fjxqfs5q2zi8138k3aafwx691327xavsa2b7q27bvi5b";
+       revision = "1";
+       editedCabalFile = "1f2fax632djf5vq502ms7qj5jagfw8lz7f0vg53acj9qsnx8pkhp";
        libraryHaskellDepends = [
          aeson base bytestring containers dlist hashable scientific tasty
          tasty-hunit tasty-quickcheck text time unordered-containers
···
        pname = "safecopy";
        version = "0.10.4.2";
        sha256 = "0r2mf0p82gf8vnldx477b5ykrj1x7hyg13nqfn6gzb50japs6h3i";
-       revision = "8";
-       editedCabalFile = "03w9x2p5cnwngwl698p12vm62gbbd5n3ckw6p9hm0j177jdhsynr";
+       revision = "9";
+       editedCabalFile = "0mx9d1apd25wg0v6k48kldfbj3vg4vliz7jfxnny91yhb46hql4z";
        libraryHaskellDepends = [
          array base bytestring cereal containers generic-data old-time
          template-haskell text time transformers vector
···
 
   "sak" = callPackage
     ({ mkDerivation, base, bytestring, bz2, cpphs, directory, filepath
-     , lz4-hs, lzlib, lzma, lzo, optparse-applicative, parallel-io
-     , unix-compat, zlib, zstd
+     , lz4-hs, lzlib, lzma-static, lzo, optparse-applicative
+     , parallel-io, unix-compat, zlib, zstd
      }:
      mkDerivation {
        pname = "sak";
-       version = "0.1.3.1";
-       sha256 = "12vharmp5f0ffxy4j5kjwqnffc87y4wmzvgcfvp6prqyjfh87qfy";
+       version = "0.1.3.2";
+       sha256 = "00l01hl0biy4dhs11j2wsd7lqvg3pp20lyppdvf1fjyh2k1jlyiw";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
-         base bytestring bz2 directory filepath lz4-hs lzlib lzma lzo
+         base bytestring bz2 directory filepath lz4-hs lzlib lzma-static lzo
          optparse-applicative parallel-io unix-compat zlib zstd
        ];
        executableToolDepends = [ cpphs ];
···
     ({ mkDerivation, base, containers, QuickCheck, transformers }:
      mkDerivation {
        pname = "selective";
-       version = "0.7";
-       sha256 = "0dhwfhfp57fmg86h5hkizchnk94zdgbpxxfv0r3xp65a7aq546fg";
-       revision = "2";
-       editedCabalFile = "1lrbw2ii7361hwijfaaw8zrlfqz14dik7wjb23bvn2749kvxms1s";
-       libraryHaskellDepends = [ base containers transformers ];
+       version = "0.7.0.1";
+       sha256 = "1qxfnqidlqw5hbsqs80i77nrkanz73jzyd4w157gamkr3kklpyyv";
+       libraryHaskellDepends = [ base transformers ];
        testHaskellDepends = [ base containers QuickCheck transformers ];
        description = "Selective applicative functors";
        license = lib.licenses.mit;
···
        pname = "shelly";
        version = "1.12.1";
        sha256 = "0xqcz0105cvvhngnlzbn2pfrh17vx5p20a1c4c9rp3124922cnhk";
+       revision = "1";
+       editedCabalFile = "0f71dbh0a3xb82y578z95wchspm2r4i38wiv1s5ls6p6vchk7phm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Deterministic serialisation and signatures with proto-lens support";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "signable-haskell-protoc" = callPackage
···
 
   "smcdel" = callPackage
     ({ mkDerivation, alex, ansi-terminal, array, base, bytestring
-     , cassava, containers, criterion, cudd, deepseq, directory
-     , file-embed, filepath, graphviz, happy, HasCacBDD, hspec
-     , js-jquery, process, QuickCheck, sandwich, sandwich-webdriver
-     , scientific, scotty, split, tagged, template-haskell, temporary
-     , text, time, vector, warp, webdriver
+     , cassava, containers, criterion, decision-diagrams, directory
+     , filepath, graphviz, happy, HasCacBDD, hspec, process, QuickCheck
+     , scientific, split, tagged, temporary, text, time, vector
      }:
      mkDerivation {
        pname = "smcdel";
-       version = "1.2.0";
-       sha256 = "0ssijqlfnd1nx6w8j1sl4bhwhw78dsbipxlbdknwx340np7rmx11";
+       version = "1.3.0";
+       sha256 = "09hc0i5v685fsa9slrqmfpqw353x0814r9x5bgw9qjvyrmjqdz2l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         array base containers cudd directory graphviz HasCacBDD process
-         QuickCheck tagged temporary text time
+         array base containers decision-diagrams directory filepath graphviz
+         HasCacBDD process QuickCheck tagged temporary text time
        ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [
-         ansi-terminal base deepseq directory file-embed filepath HasCacBDD
-         js-jquery process scotty template-haskell text warp
+         ansi-terminal base directory filepath process
        ];
        executableToolDepends = [ alex happy ];
        testHaskellDepends = [
-         base containers HasCacBDD hspec process QuickCheck sandwich
-         sandwich-webdriver text webdriver
+         base containers HasCacBDD hspec QuickCheck
        ];
        testToolDepends = [ alex happy ];
        benchmarkHaskellDepends = [
···
        description = "Symbolic Model Checking for Dynamic Epistemic Logic";
        license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
+       mainProgram = "smcdel";
      }) {};
 
   "sme" = callPackage
···
        pname = "snap";
        version = "1.1.3.3";
        sha256 = "1mqckzm9gasa04ls691zgw4c6m53mgcj86yd2p5qvy07mpn9rdvx";
+       revision = "1";
+       editedCabalFile = "06f9xcj6s7ci01v5gkrd1qhrhnnpwijiac83m6nhjpsisx1d11g3";
        libraryHaskellDepends = [
          aeson attoparsec attoparsec-aeson base bytestring cereal
          clientsession configurator containers directory directory-tree
···
        pname = "snap-core";
        version = "1.0.5.1";
        sha256 = "00h5xijkjvnhcgxpw3vmkpf5nwfpknqflvxgig6gvsy4wahc2157";
-       revision = "4";
-       editedCabalFile = "11rgmi28yhdpmzc72zxql70q6zrxnihkrv5lvabggyc9008dhyj8";
+       revision = "5";
+       editedCabalFile = "02szs3kljcfzg9kvnv6m8mykrm5big6ki4a7hzian5bb2jpjw4f1";
        libraryHaskellDepends = [
          attoparsec base bytestring bytestring-builder case-insensitive
          containers directory filepath hashable HUnit io-streams lifted-base
···
        pname = "snap-server";
        version = "1.1.2.1";
        sha256 = "0znadz0av6k31s8d175904d2kajxayl38sva3dqh5ckdfkymfx54";
-       revision = "3";
-       editedCabalFile = "0adjcah7hx47cg066jbjjgn7wz8pvkm0fc87fyz8c7lc0sdmp84f";
+       revision = "4";
+       editedCabalFile = "02h1gdhd4wi57145s3jjnrghszzry624q55kjry0d54mmxrzgsh1";
        configureFlags = [ "-fopenssl" ];
        isLibrary = true;
        isExecutable = true;
···
        broken = true;
      }) {};
 
+  "sq" = callPackage
+    ({ mkDerivation, aeson, async, async-pool, attoparsec, base, binary
+     , bytestring, clock, containers, contravariant, criterion, deepseq
+     , df1, di, di-core, di-df1, direct-sqlite, directory, exceptions
+     , filepath, foldl, hedgehog, profunctors, ref-tf, resource-pool
+     , resourcet, resourcet-extra, safe-exceptions, stm, streaming
+     , tasty, tasty-hedgehog, tasty-hunit, template-haskell, text, time
+     , transformers
+     }:
+     mkDerivation {
+       pname = "sq";
+       version = "0.0.1";
+       sha256 = "064ysq4hvz218l0kcy04axq2g9nvina9q2a5yssgj8jx5qnv289h";
+       libraryHaskellDepends = [
+         aeson async attoparsec base binary bytestring clock containers
+         contravariant deepseq di-core di-df1 direct-sqlite directory
+         exceptions filepath foldl profunctors ref-tf resource-pool
+         resourcet resourcet-extra safe-exceptions stm streaming
+         template-haskell text time transformers
+       ];
+       testHaskellDepends = [
+         aeson async base binary bytestring df1 di di-core hedgehog ref-tf
+         resourcet resourcet-extra safe-exceptions tasty tasty-hedgehog
+         tasty-hunit text time
+       ];
+       benchmarkHaskellDepends = [
+         async async-pool base containers criterion df1 di di-core resourcet
+         resourcet-extra safe-exceptions stm
+       ];
+       description = "High-level SQLite client";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "sqel" = callPackage
     ({ mkDerivation, aeson, base, chronos, composition, containers
      , contravariant, exon, extra, first-class-families, generic-lens
···
        ];
        description = "Squeal PostgreSQL Library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "example";
      }) {};
 
···
        ];
        description = "LTree extension for Squeal";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "squeal-postgresql-uuid-ossp" = callPackage
···
        libraryHaskellDepends = [ base squeal-postgresql ];
        description = "UUID OSSP extension for Squeal";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "squeather" = callPackage
···
        mainProgram = "stack-all";
      }) {};
 
-  "stack-all_0_5_1" = callPackage
+  "stack-all_0_5_2" = callPackage
     ({ mkDerivation, aeson, base, cached-json-file, config-ini
      , directory, extra, filepath, http-query, process, simple-cmd
      , simple-cmd-args, text
      }:
      mkDerivation {
        pname = "stack-all";
-       version = "0.5.1";
-       sha256 = "0s1kxilmzrdwf44gx7wrpxd443kyfwx435ps68hzv0qyz5q8k5nw";
+       version = "0.5.2";
+       sha256 = "0ih25r2avwl6f2nqxa7sqaf070mnr27baw9wxfyr2pvv9i9nv6an";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        ];
        description = "An implementation of a real-time concurrent queue";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "stm-queue-extras" = callPackage
···
        pname = "string-interpolate";
        version = "0.3.3.0";
        sha256 = "1m4m9ivi29q90fvrinigqwz4qmnxnbi895l1gmsrp7j0bmwjxhrb";
+       revision = "1";
+       editedCabalFile = "1xys5lmy4xj9z2yj3lnhcv43wi4yqgchkbkd0adr8m6snfpabbcl";
        libraryHaskellDepends = [
          base bytestring haskell-src-exts haskell-src-meta split
          template-haskell text text-conversions utf8-string
···
        pname = "structs";
        version = "0.1.9";
        sha256 = "033vx729k9jn4w4hs3kp8nlnf0ylsqgg3q4cmb7zjfpgk4bk511w";
-       revision = "1";
-       editedCabalFile = "1kqpzh7grxz0any100sk42v54idmvh27zh8k9q0yq684frmwf4mh";
+       revision = "2";
+       editedCabalFile = "1lkx7hflya4v5pkwrf3n01rx6z9rficy2s8k2b3xx8fsch932a4s";
        libraryHaskellDepends = [
          base deepseq ghc-prim primitive template-haskell th-abstraction
        ];
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "symbol-parser" = callPackage
+    ({ mkDerivation, base, defun-core, type-spec }:
+     mkDerivation {
+       pname = "symbol-parser";
+       version = "0.3.0";
+       sha256 = "08p1zr1v6rfba0k36zppl2hgz08n9nibxbc4vwj8b59f47m39k9q";
+       libraryHaskellDepends = [ base defun-core ];
+       testHaskellDepends = [ base defun-core type-spec ];
+       description = "Type level string parser combinators";
+       license = lib.licenses.mit;
+     }) {};
+
   "symbolic-link" = callPackage
     ({ mkDerivation, base, directory, tasty, tasty-hunit, unix }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "synthesizer-core";
-       version = "0.8.3";
-       sha256 = "0a12qmr7fdlz5mbrki9nd1fl07670hll3wrdpp1apvf6zd36h7mn";
-       revision = "4";
-       editedCabalFile = "0xacplyxilmrly1nxdiz42divjiky7lz5aq5lizn7ax2n0jy1sdg";
-       libraryHaskellDepends = [
-         array base binary bytestring containers deepseq event-list
-         explicit-exception filepath non-empty non-negative numeric-prelude
-         numeric-quest process QuickCheck random sample-frame-np semigroups
-         sox storable-record storable-tuple storablevector transformers
-         utility-ht
-       ];
-       testHaskellDepends = [
-         base containers event-list non-empty non-negative numeric-prelude
-         QuickCheck random storable-tuple storablevector transformers
-         utility-ht
-       ];
-       benchmarkHaskellDepends = [
-         array base binary bytestring directory numeric-prelude old-time
-         storable-tuple storablevector timeit utility-ht
-       ];
-       description = "Audio signal processing coded in Haskell: Low level part";
-       license = "GPL";
-       maintainers = [ lib.maintainers.thielema ];
-     }) {};
-
-  "synthesizer-core_0_8_4" = callPackage
-    ({ mkDerivation, array, base, binary, bytestring, containers
-     , deepseq, directory, event-list, explicit-exception, filepath
-     , non-empty, non-negative, numeric-prelude, numeric-quest, old-time
-     , process, QuickCheck, random, sample-frame-np, semigroups, sox
-     , storable-record, storable-tuple, storablevector, timeit
-     , transformers, utility-ht
-     }:
-     mkDerivation {
-       pname = "synthesizer-core";
        version = "0.8.4";
        sha256 = "11m5zvnwzrsd5ylyc6xd4k56ypmmwzyhixvzc55hgjfpsx9snks9";
        revision = "1";
···
        ];
        description = "Audio signal processing coded in Haskell: Low level part";
        license = "GPL";
-       hydraPlatforms = lib.platforms.none;
        maintainers = [ lib.maintainers.thielema ];
      }) {};
 
···
        pname = "tasty-lua";
        version = "1.1.1";
        sha256 = "186322a9gwndnpis4r7nzlca4iymrz712bbbxpm0pxsw63xary06";
+       revision = "1";
+       editedCabalFile = "180jy8dhr7mdfgj5xgnwddm5lh8ahbvs78y07g9zgpsxkdnm5ghn";
        libraryHaskellDepends = [
          base bytestring file-embed hslua-core hslua-marshalling
          lua-arbitrary QuickCheck tasty text
···
        pname = "tasty-quickcheck";
        version = "0.10.3";
        sha256 = "02lw6gk83b6wc9dwd3shin58zqy9isgx4zh7z0whs0wkzwzkpyyg";
-       revision = "1";
-       editedCabalFile = "0rk57yzsrw8lbzjwcsd3pnfwic12cvnpv245g2dsw50dvqd2922k";
+       revision = "2";
+       editedCabalFile = "0j2g1cngc5xk190jsm2k7kh25y1afmbr37abi09wvlyq8ja4n59r";
        libraryHaskellDepends = [
          base optparse-applicative QuickCheck random tagged tasty
        ];
···
      }:
      mkDerivation {
        pname = "text-show";
-       version = "3.10.4";
-       sha256 = "0kjpl9wbvn5zcpwjyrvdnkcp260rizff598cmqh4py8225fl5bmz";
-       revision = "3";
-       editedCabalFile = "0zsds6226kymk9a6jq9hc45knp3rjwc3rmiar0kccjzd6khf7s9c";
+       version = "3.10.5";
+       sha256 = "0sn8mgj7f6jric4zyfigkf8abwwx3j9k0l9jy1lhrc5ih7w6xffm";
+       revision = "1";
+       editedCabalFile = "1q5bnaxcwpwn80sr7vbk87cxz8s46b2bxrsljq6h1sfdskvc5xkd";
        libraryHaskellDepends = [
          array base base-compat-batteries bifunctors bytestring
          bytestring-builder containers generic-deriving ghc-boot-th ghc-prim
···
      }:
      mkDerivation {
        pname = "text-show-instances";
-       version = "3.9.7";
-       sha256 = "1rxsg0i304wanzgd792nj7pgkmw3iq0n7pwsg27h55vi7kp2rmiw";
+       version = "3.9.8";
+       sha256 = "13h2nfbmqzll9glifi7n9dkmaxks72w8ciwzwk106iygzpbrnw3c";
+       revision = "1";
+       editedCabalFile = "17nzy1wr318m90bdmj37rrzwsfhri28azgaqrvpl5igllc4d0480";
        libraryHaskellDepends = [
          aeson base base-compat bifunctors binary containers directory
          ghc-boot-th haskeline hpc nonempty-vector old-locale old-time
···
        pname = "th-compat";
        version = "0.1.5";
        sha256 = "07ia72hl6c1rqx1gl3zpvig7d8sw2ssbgf4wq1ipgbdgqypmzxc1";
+       revision = "1";
+       editedCabalFile = "0gyqnv9x7vb82ll1mppnv1w6wzmpzv40wkq0rpgxf68inwlf6vha";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [
          base base-compat hspec mtl template-haskell
···
        pname = "th-expand-syns";
        version = "0.4.11.0";
        sha256 = "1l7pkc16vnjgiam31745av14j7ngnr5mqmgp77xwd3h7fg75kkca";
-       revision = "3";
-       editedCabalFile = "1wgylchq9q30yf1f19rr6pvh7mkpwzdy4ij2r7174fjb1wkgnnx7";
+       revision = "4";
+       editedCabalFile = "0vjznxgzzvlr39hq0pqvachaihsbp0m2fwrii89rjzhx0mlfy4l7";
        libraryHaskellDepends = [
          base containers syb template-haskell th-abstraction
        ];
···
        pname = "th-orphans";
        version = "0.13.14";
        sha256 = "0z07qcbbsj2b3j9p1qr4jvlpa7qgjfjvymkjd6vbizka1wd2mnwx";
-       revision = "2";
-       editedCabalFile = "1kjb7ik4js6bpsdb32sna8xcxamia02fhx1wcbg831mnf2qfpp6w";
+       revision = "3";
+       editedCabalFile = "19gh8f082ia27ch7xjj41vwlp7234sv545hhb3kcwkmw9brc67aj";
        libraryHaskellDepends = [
          base mtl template-haskell th-compat th-lift th-reify-many
        ];
···
        pname = "time";
        version = "1.14";
        sha256 = "0gkzffnvi33ksw4zln0d31dpmqiyl8gicrx04g8j13kjr5ygx86z";
+       revision = "1";
+       editedCabalFile = "13brg65cvava8w5wlfp3jwn7mpkprad1chws2v14jw1lgzh5b14i";
        libraryHaskellDepends = [ base deepseq template-haskell ];
        testHaskellDepends = [
          base deepseq QuickCheck random tasty tasty-hunit tasty-quickcheck
···
        license = lib.licenses.mit;
      }) {};
 
+  "time-manager_0_1_0" = callPackage
+    ({ mkDerivation, auto-update, base, unliftio }:
+     mkDerivation {
+       pname = "time-manager";
+       version = "0.1.0";
+       sha256 = "1r2wgi160nkky220bdwknld1ymfpq4541pzbhmkna670r1ahzcb2";
+       libraryHaskellDepends = [ auto-update base unliftio ];
+       description = "Scalable timer";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "time-out" = callPackage
     ({ mkDerivation, base, data-default-class, exceptions
      , time-interval, time-units, transformers
···
        pname = "timers-tick";
        version = "0.5.0.4";
        sha256 = "0q10njbdkiknqyvp276qpac7286z204f0a7qm7hafxzn7wrrp9mn";
+       revision = "1";
+       editedCabalFile = "1l4fcrdkmf96a962a5rhv7r1hbxzq7258d1qr25j8bsyci1jrzcd";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec QuickCheck ];
        description = "tick based timers";
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "tls_2_0_2" = callPackage
+  "tls_2_0_5" = callPackage
     ({ mkDerivation, asn1-encoding, asn1-types, async, base
      , base16-bytestring, bytestring, cereal, crypton, crypton-x509
      , crypton-x509-store, crypton-x509-validation, data-default-class
···
      }:
      mkDerivation {
        pname = "tls";
-       version = "2.0.2";
-       sha256 = "188m4p63h3wl0rjh8w99amyl6y0r3camk76f5ivnd56vxf3cx74g";
+       version = "2.0.5";
+       sha256 = "1qgwgbhp19a28ibb73h1ahkrwsjnv3hndfj3bsp9fb1s4856vn6z";
+       revision = "1";
+       editedCabalFile = "0717sfkj6jzpnp0r5013m3z6s25fnnrcd07lfdlpzxhs5fdjnk36";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "tls-session-manager";
        version = "0.0.5";
        sha256 = "0zfls8ckskip43vrjvvqafv0c9wb5a6j507j2fjjczb0gm9gdq5m";
-       revision = "1";
-       editedCabalFile = "109d07s6gp5flhhnsy96fnz1i0y9r7j2c06ql7k9gv8xaa8pa9s9";
+       revision = "2";
+       editedCabalFile = "1qlm2y0zjcf3dsqnv0pi730bmbl4nqk3r0a826fydpaphv1xgh6v";
        libraryHaskellDepends = [
          auto-update base basement bytestring clock crypto-token memory
          psqueues serialise tls
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "tmp-proc_0_6_1_0" = callPackage
-    ({ mkDerivation, async, base, bytestring, data-default, hspec
-     , http-client, http-types, mtl, network, process, text, tls
+  "tmp-proc_0_6_2_1" = callPackage
+    ({ mkDerivation, async, base, bytestring, crypton-connection
+     , crypton-x509-system, data-default, directory, filepath, fmt
+     , hspec, http-client, http-client-tls, http-types, mtl, mustache
+     , network, process, random, temporary, test-certs, text, tls, unix
      , unliftio, wai, warp, warp-tls
      }:
      mkDerivation {
        pname = "tmp-proc";
-       version = "0.6.1.0";
-       sha256 = "0qhapmpwlslcr0b4r4031arhixmfm5dwhjz6qhcbjdf1q7jq68lr";
+       version = "0.6.2.1";
+       sha256 = "1c636l8543fb2mpd9w2gx3njkk3b9lxs59x4r74pv5vg9idz11dk";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         async base bytestring mtl network process text tls unliftio wai
-         warp warp-tls
+         async base bytestring fmt mtl network process random text tls
+         unliftio wai warp warp-tls
        ];
        testHaskellDepends = [
-         base bytestring data-default hspec http-client http-types text wai
-         warp
+         base bytestring crypton-connection crypton-x509-system data-default
+         directory filepath hspec http-client http-client-tls http-types
+         mustache temporary test-certs text tls unix wai warp warp-tls
        ];
        description = "Run 'tmp' processes in integration tests";
        license = lib.licenses.bsd3;
···
        pname = "tomland";
        version = "1.3.3.2";
        sha256 = "152jqjv6n7n2hdysn903wfhpwh6vp8wmjiymzasazprasdcxpywm";
-       revision = "2";
-       editedCabalFile = "03xx2wqwyp11yxdnlwxi110wkm6shwpfgzdnzjwdw6cqijdc6zc8";
+       revision = "3";
+       editedCabalFile = "06kwxbrqvcpzk4dw4pk8icj9mf16rnaz2g301y0q57gdikxj8yca";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        broken = true;
      }) {};
 
+  "typeably" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "typeably";
+       version = "0.1.0";
+       sha256 = "1fz0yblkw304fvg138h31am930f4kdvsrf9r3nxnxcc21jzy18ps";
+       libraryHaskellDepends = [ base ];
+       description = "DerivingVia Typeable counterpart to Generically";
+       license = lib.licenses.mit;
+     }) {};
+
   "typechain" = callPackage
     ({ mkDerivation, aeson, base, bytestring, exceptions, http-conduit
      , lens, mtl, split, template-haskell, unordered-containers
···
        ];
        description = "A class for finite and recursively enumerable types";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "universe-base" = callPackage
···
        libraryHaskellDepends = [ base universe-some ];
        description = "Universe instances for types from dependent-sum";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "universe-instances-base" = callPackage
···
        testHaskellDepends = [ base some template-haskell universe-base ];
        description = "Universe instances for Some from some";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "universe-th" = callPackage
···
      }:
      mkDerivation {
        pname = "utxorpc";
-       version = "0.0.4.4";
-       sha256 = "0is31qp6vbbbs4qnbbyh2wlcwrh2jkjq4ffml2nb4sbb47cl459z";
+       version = "0.0.5.1";
+       sha256 = "1k46h256vdzwqbg7g44la8k41rlwwa4xjpzl1506zr3dsxvjgab2";
        libraryHaskellDepends = [
          base proto-lens proto-lens-protobuf-types proto-lens-runtime
        ];
···
      }:
      mkDerivation {
        pname = "utxorpc-client";
-       version = "0.0.1.1";
-       sha256 = "1l588nhg9ssqdwdx6pvqsj4mgl88rp4fbnba8ph4hf9jqf9j81ci";
-       revision = "1";
-       editedCabalFile = "1lqarn3bycipy6rbqy9p4ypsq0xvpm0qwmjpgkqs0ivr6wp9vnas";
+       version = "0.0.2.0";
+       sha256 = "1i9gzr4dlhy3j0x2mx9idgc16r0yz7qw72z6gc10s4vlbbrc1mnb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "utxorpc-server";
-       version = "0.0.1.1";
-       sha256 = "025lrc650b0kjw1z5vsjqg1ylb8zjv4bm5jrlk8dilb5yipk3zjq";
-       revision = "1";
-       editedCabalFile = "06hxrc4d93v814yiv09x6f7pjphx9hk3jbgv6cnwi4bx9ryp7sak";
+       version = "0.0.2.0";
+       sha256 = "1sbbyhf4av2vrqnz2g7gzm0q28bchw2jqnyqr42az7jddki9r93l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "vector-hashtables";
        version = "0.1.1.4";
        sha256 = "0nvi9j18v8xfb3p2q65bi9f3rzrw2bc2nz2q096flxjf72ipapac";
+       revision = "1";
+       editedCabalFile = "1n3s6czg2h51dwqwfisi943agsi5x1fin5ja6waz67gyp1cc77hc";
        libraryHaskellDepends = [ base hashable primitive vector ];
        testHaskellDepends = [
          base containers hashable hspec primitive QuickCheck
···
        ];
        description = "Efficient vector-based mutable hashtables implementation";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "vector-hashtables_0_1_2_0" = callPackage
+    ({ mkDerivation, base, containers, criterion, hashable, hashtables
+     , hspec, hspec-discover, primitive, QuickCheck
+     , quickcheck-instances, unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "vector-hashtables";
+       version = "0.1.2.0";
+       sha256 = "1s0c3d4f61rgvb0i8c2m3lazxbxg2cpv1pq4k4lnr7nga7sama9r";
+       libraryHaskellDepends = [ base hashable primitive vector ];
+       testHaskellDepends = [
+         base containers hashable hspec primitive QuickCheck
+         quickcheck-instances vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       benchmarkHaskellDepends = [
+         base criterion hashtables primitive unordered-containers vector
+       ];
+       description = "Efficient vector-based mutable hashtables implementation";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "vector-heterogenous" = callPackage
···
        pname = "vector-th-unbox";
        version = "0.2.2";
        sha256 = "0j81m09xxv24zziv0nanfppckzmas5184jr3npjhc9w49r3cm94a";
-       revision = "5";
-       editedCabalFile = "1mw2ssj6a772cvw2mf0r5qvz4blaq8k194p6bj0wnl1plr16r90b";
+       revision = "6";
+       editedCabalFile = "1pdl1xvr1b4zg32b9d8jv4jakjnd5id5wdj2czgzajr6xlkvyhir";
        libraryHaskellDepends = [ base template-haskell vector ];
        testHaskellDepends = [ base data-default vector ];
        description = "Deriver for Data.Vector.Unboxed using Template Haskell";
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "versions_5_0_5" = callPackage
+    ({ mkDerivation, base, deepseq, hashable, megaparsec, microlens
+     , parser-combinators, QuickCheck, tasty, tasty-hunit
+     , tasty-quickcheck, text
+     }:
+     mkDerivation {
+       pname = "versions";
+       version = "5.0.5";
+       sha256 = "01kn3ilizzm5n05nz0qry1vjb6bj8dzinyqn3mbshds298acn70c";
+       libraryHaskellDepends = [
+         base deepseq hashable megaparsec parser-combinators text
+       ];
+       testHaskellDepends = [
+         base megaparsec microlens QuickCheck tasty tasty-hunit
+         tasty-quickcheck text
+       ];
+       description = "Types and parsers for software version numbers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "versions" = callPackage
     ({ mkDerivation, base, deepseq, hashable, megaparsec, microlens
      , parser-combinators, tasty, tasty-hunit, template-haskell, text
···
        doHaddock = false;
        description = "Functor-parametric containers";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "vflow-types" = callPackage
···
        ];
        description = "Convert plain records to vinyl (and vice versa), generically";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "vinyl-gl" = callPackage
···
      }:
      mkDerivation {
        pname = "vty-windows";
-       version = "0.2.0.2";
-       sha256 = "12dd00lp5vx8fijj6i3ihd5553k9b127lh25li50dimkxf5vrwjv";
+       version = "0.2.0.3";
+       sha256 = "12f91izwg4r18zvdbnkwd8jk7agdyy3w3bcljrm92hib43i210id";
        libraryHaskellDepends = [
          base blaze-builder bytestring containers deepseq directory filepath
          microlens microlens-mtl microlens-th mtl parsec stm transformers
···
        pname = "wai-middleware-static";
        version = "0.9.2";
        sha256 = "1ynm0xcr3pj5bbph78p1kpyxvd0n3a0gfdbm6yb7i004ixaqf33c";
-       revision = "4";
-       editedCabalFile = "0kmy18qq2mc5mlmnx6xaj1wkk63jl0s4fn16zbd6cyb6jb8n2lq4";
+       revision = "5";
+       editedCabalFile = "059vp0ipdgfpldzmqqhkayak6dicj8qhpb2qcwdk8y31bcg7895m";
        libraryHaskellDepends = [
          base base16-bytestring bytestring containers cryptohash-sha1
          directory expiring-cache-map filepath http-types mime-types
···
        license = lib.licenses.mit;
      }) {};
 
-  "warp_3_4_0" = callPackage
+  "warp_3_4_1" = callPackage
     ({ mkDerivation, array, auto-update, base, bsb-http-chunked
      , bytestring, case-insensitive, containers, crypton-x509, directory
      , gauge, ghc-prim, hashable, hspec, hspec-discover, http-client
···
      }:
      mkDerivation {
        pname = "warp";
-       version = "3.4.0";
-       sha256 = "0p68qzap25na55gnc521c8yvdf4zfy86l2x8cqfw9kmr28f71s75";
+       version = "3.4.1";
+       sha256 = "0f4cs9qb3cpagryijzw46r5y5bd2srvb4b3phffydj5aim253jfp";
        libraryHaskellDepends = [
          array auto-update base bsb-http-chunked bytestring case-insensitive
          containers crypton-x509 ghc-prim hashable http-date http-types
···
      }:
      mkDerivation {
        pname = "warp-tls";
-       version = "3.4.4";
-       sha256 = "1l8lxqakz5c060sif6qz3nz019xan5zhdf5l8xmwy00aq8ccs6ba";
+       version = "3.4.5";
+       sha256 = "0j4m5idjg7fa8snc46lhf5gwwdgq004pjmqzfcb78pf1px1y0gwy";
        libraryHaskellDepends = [
          base bytestring data-default-class network recv streaming-commons
          tls tls-session-manager unliftio wai warp
···
      }:
      mkDerivation {
        pname = "wuss";
-       version = "2.0.1.7";
-       sha256 = "09ad7bxkg46kgmkf49n86wqkzpsz277kiiwhw81awgivfacqkcvy";
+       version = "2.0.1.8";
+       sha256 = "1pdh44r11yxyjgyb8la28crsm7sk09fshmqcgxyxczwfjsa85dpk";
        libraryHaskellDepends = [
          base bytestring crypton-connection exceptions network websockets
        ];
···
        pname = "xor";
        version = "0.0.1.2";
        sha256 = "0c0a1zg0kwp3jdlgw6y1l6qp00680khxa3sizx5wafdv09rwmrxc";
-       revision = "2";
-       editedCabalFile = "160vvj5icka4i76b7x2qg3l9gvxib0shgs5zrvj27r587vd81rl5";
+       revision = "3";
+       editedCabalFile = "0lj7kp8119cbl5g3ndnkr4fjgcwk6liar79j4rvrf1zyr5xflknr";
        libraryHaskellDepends = [ base bytestring ghc-byteorder ];
        testHaskellDepends = [
          base bytestring ghc-byteorder QuickCheck tasty tasty-hunit
···
     ({ mkDerivation, aeson, attoparsec, base, base-compat, bytestring
      , containers, criterion, deepseq, directory, filepath, hspec
      , hspec-discover, HUnit, libyaml-streamly, megaparsec, mockery, mtl
-     , raw-strings-qq, safe-exceptions, scientific, streamly, strict
-     , template-haskell, temporary, text, transformers
+     , raw-strings-qq, safe-exceptions, scientific, streamly-core
+     , strict, template-haskell, temporary, text, transformers
      , unordered-containers, vector, versions
      }:
      mkDerivation {
        pname = "yaml-streamly";
-       version = "0.12.4";
-       sha256 = "06cr9qqxxck6qgdc0lizjlkzm9j0mhyj4p64wymhkwd70dyhlfmz";
+       version = "0.12.5";
+       sha256 = "0gkgbqki58snxzsd1wa0gs22bwx6fax0b32zc3dy53n9fyivbwiz";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson attoparsec base bytestring containers deepseq directory
-         filepath libyaml-streamly mtl safe-exceptions scientific streamly
-         template-haskell text transformers unordered-containers vector
+         filepath libyaml-streamly mtl safe-exceptions scientific
+         streamly-core template-haskell text transformers
+         unordered-containers vector
        ];
        testHaskellDepends = [
          aeson base base-compat bytestring directory hspec HUnit
-         libyaml-streamly mockery raw-strings-qq scientific streamly
+         libyaml-streamly mockery raw-strings-qq scientific streamly-core
          temporary text unordered-containers vector
        ];
        testToolDepends = [ hspec-discover ];
···
        pname = "yampa-canvas";
        version = "0.2.3";
        sha256 = "0a1pq1psmc4490isr19z4prnqq1w3374vkfmzpw9s20s2p6k5y7r";
-       revision = "12";
-       editedCabalFile = "0j9n3xd4hxir1x46yrr8vwrbr8yziw5xfjzvn2j57jrx0qs9c0fb";
+       revision = "13";
+       editedCabalFile = "1401zbwg52q3y277h60c0ahwz105iakxfqpvi50bc8q6w56g7jbq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base blank-canvas stm time Yampa ];
···
      }:
      mkDerivation {
        pname = "zip";
-       version = "2.0.0";
-       sha256 = "1j3gwhgcn2j2jsdg4dw7a5y1pw0n273zkfk782pvzjqmccaywbdp";
-       revision = "3";
-       editedCabalFile = "1b6izcvvrhdra0jxp2s7xk9xv41iwq3yc9bpi44nmc2fj4ra4r2v";
+       version = "2.0.1";
+       sha256 = "0djjj1r30hfair0qq9vzla4qlaw60gmg2963vwch9pgiylzm2f5h";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        executableHaskellDepends = [ base filepath ];
        testHaskellDepends = [
-         base bytestring conduit containers directory dlist exceptions
-         filepath hspec QuickCheck temporary text time transformers
+         base bytestring conduit containers directory dlist filepath hspec
+         QuickCheck temporary text time
        ];
        description = "Operations on zip archives";
        license = lib.licenses.bsd3;
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) zlib;};
 
-  "zlib_0_7_0_0" = callPackage
+  "zlib_0_7_1_0" = callPackage
     ({ mkDerivation, base, bytestring, QuickCheck, tasty
      , tasty-quickcheck, zlib
      }:
      mkDerivation {
        pname = "zlib";
-       version = "0.7.0.0";
-       sha256 = "0ivszx31jw560axchxz9g646baw2rs6fr1ih0d5mmzz1w42w4hvy";
-       revision = "1";
-       editedCabalFile = "1fiwhzs7sp3ck75ii176pakmwjqcjlv0fiqcqka6r8p9jdf958b4";
+       version = "0.7.1.0";
+       sha256 = "1g2md8z0ijcbrqlx9q9i49myi2lnlvzmma1ajmsd5y0xp2v3ipbf";
        libraryHaskellDepends = [ base bytestring ];
        libraryPkgconfigDepends = [ zlib ];
        testHaskellDepends = [
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "zlib-clib" = callPackage
+    ({ mkDerivation }:
+     mkDerivation {
+       pname = "zlib-clib";
+       version = "1.3.1";
+       sha256 = "153aldw8vqy6wzz7knbzyfkxsr3gsv5hjf4y84s12ifx2fi8zfkn";
+       doHaddock = false;
+       description = "zlib C library bits";
+       license = lib.licenses.zlib;
      }) {};
 
   "zlib-conduit" = callPackage

pkgs/development/haskell-modules/make-package-set.nix

···
       }) firstRevision;
 
     # Creates a Haskell package from a source package by calling cabal2nix on the source.
-    callCabal2nixWithOptions = name: src: extraCabal2nixOptions: args:
+    callCabal2nixWithOptions = name: src: opts: args:
       let
-        filter = path: type:
+        extraCabal2nixOptions = if builtins.isString opts
+                                then opts
+                                else opts.extraCabal2nixOptions or "";
+        srcModifier = opts.srcModifier or null;
+        defaultFilter = path: type:
                    pkgs.lib.hasSuffix ".cabal" path ||
                    baseNameOf path == "package.yaml";
         expr = self.haskellSrc2nix {
           inherit name extraCabal2nixOptions;
-          src = if pkgs.lib.canCleanSource src
-                  then pkgs.lib.cleanSourceWith { inherit src filter; }
+          src = if srcModifier != null
+                then srcModifier src
+                else if pkgs.lib.canCleanSource src
+                then pkgs.lib.cleanSourceWith { inherit src; filter = defaultFilter; }
                 else src;
         };
       in overrideCabal (orig: {

pkgs/development/interpreters/octave/build-env.nix

···
       addPkgLocalList $out ${octave}
 
       wrapOctavePrograms "${lib.concatStringsSep " " packages}"
+      # We also need to modify the Exec= line of the desktop file, so it will point
+      # to the wrapper we generated above.
+      rm $out/share/applications # should be a symlink to ${octave}/share/applications
+      mkdir $out/share/applications
+      substitute \
+        ${octave}/share/applications/org.octave.Octave.desktop \
+        $out/share/applications/org.octave.Octave.desktop \
+        --replace-fail ${octave}/bin/octave $out/bin/octave
      '' + postBuild;
 
   inherit (octave) meta;

pkgs/development/libraries/libdatachannel/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libdatachannel";
-  version = "0.21.0";
+  version = "0.21.1";
 
   src = fetchFromGitHub {
     owner = "paullouisageneau";
     repo = "libdatachannel";
     rev = "v${version}";
-    hash = "sha256-hxXDovJAmuh15jFaxY9aESoTVVJ3u2twsX31U3txans=";
+    hash = "sha256-sTdA4kCIdY3l/YUNKbXzRDS1O0AFx90k94W3cJpfLIY=";
   };
 
   outputs = [ "out" "dev" ];

pkgs/development/libraries/libgpiod/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libgpiod";
-  version = "2.1.1";
+  version = "2.1.2";
 
   src = fetchurl {
     url = "https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/snapshot/libgpiod-${version}.tar.gz";
-    hash = "sha256-CvQ6YInWn50HXPZ8oq5ZcrkIHjjms9Rs6jfWfi32+5s=";
+    hash = "sha256-sb3x4/dSOGlfk+RCBiuvwGkXDyv08M1LjgScpnExofA=";
   };
 
   nativeBuildInputs = [

pkgs/development/libraries/science/astronomy/wcslib/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "wcslib";
-  version = "8.2.2";
+  version = "8.3";
 
   src = fetchurl {
     url = "ftp://ftp.atnf.csiro.au/pub/software/wcslib/${pname}-${version}.tar.bz2";
-    sha256 = "sha256-YpgiCugX9OVSJkOsTD2iYjvnCjSEsaTzcGC+4+S9eDM=";
+    sha256 = "sha256-Qx6jQXknu8Arib+jQV3AtGaLDyGjtG+4o1JeL89hRQg=";
   };
 
   nativeBuildInputs = [ flex ];

pkgs/development/ocaml-modules/uring/default.nix

···
 
 buildDunePackage rec {
   pname = "uring";
-  version = "0.8";
+  version = "0.9";
 
   minimalOCamlVersion = "4.12";
 
   src = fetchurl {
     url = "https://github.com/ocaml-multicore/ocaml-${pname}/releases/download/v${version}/${pname}-${version}.tbz";
-    hash = "sha256-4OGst19vqEzuNVxO5xxtzS+mEilEBFoEc7lC3j3sTk4=";
+    hash = "sha256-eXWIxfL9UsKKf4sanBjKfr6Od4fPDctVnkU+wjIXW0M=";
   };
-
-  patches = [
-    (fetchpatch {
-      name = "musl-1.2.5.patch";
-      url = "https://github.com/ocaml-multicore/ocaml-uring/commit/abe340086574c124061434054937d1f19ee6bb71.patch";
-      hash = "sha256-J4ZQAdQZ9fhT3/vAh5FYMyvMllTowe4GyHJy5RGUTv0=";
-    })
-  ];
 
   propagatedBuildInputs = [
     cstruct

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

···
+{
+  lib,
+  buildPythonPackage,
+  fetchFromGitHub,
+  pytestCheckHook,
+  python-dateutil,
+  setuptools,
+}:
+buildPythonPackage rec {
+  pname = "filedate";
+  version = "3.0";
+  pyproject = true;
+
+  src = fetchFromGitHub {
+    owner = "kubinka0505";
+    repo = "filedate";
+    rev = version;
+    hash = "sha256-HvuGP+QlUlfAUfFmaVVvtPHGdrbWVxghQipnqTTvAQc=";
+  };
+
+  sourceRoot = "${src.name}/Files";
+
+  # The repo stores everything in "src" and uses setup.py to move "src" ->
+  # "filedate" before calling setup() and then tries to rename "filedate" back
+  # to "src" after.
+  postPatch = ''
+    mv src filedate
+    substituteInPlace setup.py \
+      --replace-fail "__title__ = os.path.basename(os.path.dirname(os.path.dirname(__file__)))" '__title__ = "filedate"'
+    substituteInPlace setup.py \
+      --replace-fail "cleanup = True" "cleanup = False"
+
+    # Disable renaming "filedate" dir back to "src"
+    substituteInPlace setup.py \
+      --replace-fail "if os.path.exists(__title__):" ""
+    substituteInPlace setup.py \
+      --replace-fail "	os.rename(__title__, directory)" ""
+  '';
+
+  build-system = [ setuptools ];
+
+  dependencies = [ python-dateutil ];
+
+  pythonImportsCheck = [ "filedate" ];
+
+  nativeCheckInputs = [ pytestCheckHook ];
+
+  pytestFlagsArray = [ "tests/unit.py" ];
+
+  disabledTests = [ "test_created" ];
+
+  meta = {
+    description = "Simple, convenient and cross-platform file date changing library";
+    homepage = "https://github.com/kubinka0505/filedate";
+    changelog = "https://github.com/kubinka0505/filedate/blob/${src.rev}/Documents/ChangeLog.md";
+    license = lib.licenses.gpl3Only;
+    maintainers = with lib.maintainers; [ thornycrackers ];
+  };
+}

pkgs/development/tools/gosec/default.nix

···
 
 buildGoModule rec {
   pname = "gosec";
-  version = "2.19.0";
+  version = "2.20.0";
 
   src = fetchFromGitHub {
     owner = "securego";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-Yb0NEvGx0Ds3t2VjhSWw4oILmN1kR9Dlqe45/VRbu0A=";
+    hash = "sha256-QQD24Z755AurBFXZj/wlRBJegQ74kTvWVy2cN5PnblY=";
   };
 
-  vendorHash = "sha256-yphsGkubJyXDrlCAKh9tdKI5cDldNXvJ22fs3rY5I4Y=";
+  vendorHash = "sha256-VWbsSS3j8zgsZQzsO/ZyKoOUqhNhmMmDICImUZHmC9Y=";
 
   subPackages = [
     "cmd/gosec"

pkgs/development/tools/haskell/hadrian/disable-hyperlinked-source.patch

···
 diff --git a/hadrian/src/Settings/Builders/Haddock.hs b/hadrian/src/Settings/Builders/Haddock.hs
 index 902b2f85e2..429a441c3b 100644
---- a/src/Settings/Builders/Haddock.hs
-+++ b/src/Settings/Builders/Haddock.hs
+--- a/hadrian/src/Settings/Builders/Haddock.hs
++++ b/hadrian/src/Settings/Builders/Haddock.hs
 @@ -57,7 +57,6 @@ haddockBuilderArgs = mconcat
              , arg $ "--odir=" ++ takeDirectory output
              , arg $ "--dump-interface=" ++ output

pkgs/development/tools/haskell/hadrian/hadrian-9.8.1-allow-Cabal-3.10.patch

···
 diff --git a/hadrian.cabal b/hadrian.cabal
 index 70fded11aa..3893537f05 100644
---- a/hadrian.cabal
-+++ b/hadrian.cabal
+--- a/hadrian/hadrian.cabal
++++ b/hadrian/hadrian.cabal
 @@ -150,7 +150,7 @@ executable hadrian
                         , TypeOperators
      other-extensions:    MultiParamTypeClasses

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

···
 , ghcVersion
   # Customization
 , userSettings ? null
-, enableHyperlinkedSource
 }:
 
 mkDerivation {
···
   postUnpack = ''
     sourceRoot="$sourceRoot/hadrian"
   '';
-  patches = lib.optionals (!enableHyperlinkedSource) [
-    ./disable-hyperlinked-source.patch
-  ] ++ lib.optionals (lib.elem ghcVersion [ "9.8.1" "9.8.2" ]) [
-    # Incorrect bounds on Cabal
-    # https://gitlab.haskell.org/ghc/ghc/-/issues/24100
-    ./hadrian-9.8.1-allow-Cabal-3.10.patch
-  ];
   # Overwrite UserSettings.hs with a provided custom one
   postPatch = lib.optionalString (userSettings != null) ''
     install -m644 "${writeText "UserSettings.hs" userSettings}" src/UserSettings.hs

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

···
   # Contents of a non-default UserSettings.hs to use when building hadrian, if any.
   # Should be a string or null.
 , userSettings ? null
-  # Whether to pass --hyperlinked-source to haddock or not. This is a custom
-  # workaround as we wait for this to be configurable via userSettings or similar.
-  # https://gitlab.haskell.org/ghc/ghc/-/issues/23625
-, enableHyperlinkedSource ? false
 }:
 
 let
···
 in
 
 callPackage' ./hadrian.nix ({
-  inherit userSettings enableHyperlinkedSource;
+  inherit userSettings;
 } // lib.optionalAttrs (lib.versionAtLeast ghcVersion "9.9") {
   # Starting with GHC 9.9 development, additional in tree packages are required
   # to build hadrian. (Hackage-released conditional dependencies are handled

pkgs/development/tools/melange/default.nix

···
 
 buildGoModule rec {
   pname = "melange";
-  version = "0.6.11";
+  version = "0.7.0";
 
   src = fetchFromGitHub {
     owner = "chainguard-dev";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-/P85vrcKWZHXNUIlzLpc9v0I5KEL7HUyr1SM2207l7o=";
+    hash = "sha256-RkX6jS3Oh0pRn7kwNDRi8RQ2apLx3W82yQYI1JLJXjQ=";
     # populate values that require us to use git. By doing this in postFetch we
     # can delete .git afterwards and maintain better reproducibility of the src.
     leaveDotGit = true;
···
     '';
   };
 
-  vendorHash = "sha256-R1Fo4N5q00ePkddOJKauC6iDPGMYk15FIKEXqWy6ifQ=";
+  vendorHash = "sha256-0IBpnwAkvrGkll/mE67BXb/TmwYJyX2oG/aBqsKcn4g=";
 
   subPackages = [ "." ];
 

pkgs/development/tools/purescript/spago/default.nix

···
 { haskell
+, haskellPackages
 , lib
 
 # The following are only needed for the passthru.tests:
+, spago
 , cacert
 , git
 , nodejs
···
 , runCommand
 }:
 
-let
-  spago =
-    lib.pipe
-      haskell.packages.ghc90.spago
-      [ haskell.lib.compose.justStaticExecutables
-        (haskell.lib.compose.overrideCabal (oldAttrs: {
-          changelog = "https://github.com/purescript/spago/releases/tag/${oldAttrs.version}";
-        }))
-      ];
-in
+lib.pipe
+  haskellPackages.spago
+  [
+    haskell.lib.compose.justStaticExecutables
 
-spago.overrideAttrs (oldAttrs: {
-  passthru = (oldAttrs.passthru or {}) // {
-    updateScript = ./update.sh;
+    (haskell.lib.compose.overrideCabal (oldAttrs: {
+      changelog = "https://github.com/purescript/spago/releases/tag/${oldAttrs.version}";
 
-    # These tests can be run with the following command.  The tests access the
-    # network, so they cannot be run in the nix sandbox.  sudo is needed in
-    # order to change the sandbox option.
-    #
-    # $ sudo nix-build -A spago.passthru.tests --option sandbox relaxed
-    #
-    tests =
-      runCommand
-        "spago-tests"
-        {
-          __noChroot = true;
-          nativeBuildInputs = [
-            cacert
-            git
-            nodejs
-            purescript
-            spago
-          ];
-        }
-        ''
-          # spago expects HOME to be set because it creates a cache file under
-          # home.
-          HOME=$(pwd)
+      passthru = (oldAttrs.passthru or {}) // {
+        updateScript = ./update.sh;
 
-          spago --verbose init
-          spago --verbose build
-          spago --verbose test
+        # These tests can be run with the following command.  The tests access the
+        # network, so they cannot be run in the nix sandbox.  sudo is needed in
+        # order to change the sandbox option.
+        #
+        # $ sudo nix-build -A spago.passthru.tests --option sandbox relaxed
+        #
+        tests =
+          runCommand
+            "spago-tests"
+            {
+              __noChroot = true;
+              nativeBuildInputs = [
+                cacert
+                git
+                nodejs
+                purescript
+                spago
+              ];
+            }
+            ''
+              # spago expects HOME to be set because it creates a cache file under
+              # home.
+              HOME=$(pwd)
 
-          touch $out
-        '';
-  };
-  meta = (oldAttrs.meta or {}) // {
-    mainProgram = "spago";
-  };
-})
+              spago --verbose init
+              spago --verbose build
+              spago --verbose test
+
+              touch $out
+            '';
+      };
+    }))
+  ]

pkgs/development/tools/purescript/spago/spago.nix

···
 , optparse-applicative, prettyprinter, process, QuickCheck, retry
 , rio, rio-orphans, safe, semver-range, stm, stringsearch, tar
 , template-haskell, temporary, text, time, transformers, turtle
-, unliftio, unordered-containers, utf8-string, versions, with-utf8
-, zlib
+, unliftio, unordered-containers, uri-encode, utf8-string, versions
+, with-utf8, yaml, zlib
 }:
 mkDerivation {
   pname = "spago";
-  version = "0.20.9";
+  version = "0.21.0";
   src = fetchgit {
     url = "https://github.com/purescript/spago.git";
-    sha256 = "00vdqg7vaw3d9zwh47886lw9fhhlwjagzhaj3aqz4xm92pjavhih";
-    rev = "d16d4914200783fbd820ba89dbdf67270454faf5";
+    sha256 = "1v5y15nhw6smnir0y7y854pa70iv8asxsqph2y8rz1c9lkz5d41g";
+    rev = "c354f4a461f65fcb83aaa843830ea1589f6c7179";
     fetchSubmodules = true;
   };
   isLibrary = true;
···
     optparse-applicative prettyprinter process retry rio rio-orphans
     safe semver-range stm stringsearch tar template-haskell temporary
     text time transformers turtle unliftio unordered-containers
-    utf8-string versions with-utf8 zlib
+    uri-encode utf8-string versions with-utf8 yaml zlib
   ];
   executableHaskellDepends = [
     ansi-terminal base text turtle with-utf8
···
   testToolDepends = [ hspec-discover ];
   homepage = "https://github.com/purescript/spago#readme";
   license = lib.licenses.bsd3;
+  mainProgram = "spago";
 }

pkgs/development/tools/wabt/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "wabt";
-  version = "1.0.34";
+  version = "1.0.35";
 
   src = fetchFromGitHub {
     owner = "WebAssembly";
     repo = "wabt";
     rev = version;
-    sha256 = "sha256-KlaMc3k1y6KviMDrMbKPcJOywJasrPZrnvSos8hgu+8=";
+    sha256 = "sha256-oWyHR2HRDA/N5Rm9EXhOi+lZ2N7In6HmE74ZL2Nyu9A=";
     fetchSubmodules = true;
   };
 

pkgs/os-specific/linux/fnotifystat/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "fnotifystat";
-  version = "0.02.11";
+  version = "0.03.00";
 
   src = fetchFromGitHub {
     owner = "ColinIanKing";
     repo = pname;
     rev = "V${version}";
-    hash = "sha256-CwjaDL5pt2HMUhq0Q3s6Ssp3jr9uwCdVhT1JzlKcQQw=";
+    hash = "sha256-UGww0/m+JMftQyAguc8UpPrtIphjCq9TINabFaAKN0A=";
   };
 
   installFlags = [

pkgs/servers/klipper/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "klipper";
-  version = "0.12.0-unstable-2024-04-20";
+  version = "0.12.0-unstable-2024-05-14";
 
   src = fetchFromGitHub {
     owner = "KevinOConnor";
     repo = "klipper";
-    rev = "2f6e94c94cae036b70b02df996dc12e2e61e5dcb";
-    sha256 = "sha256-qDV0L86NLQl8O/w9yuTnMZ0MdYfFn+u+jFUCDl5p1LY=";
+    rev = "e0cbd7b5fc1ce6d1dfbc8daf8e59f57bf3c5e5b9";
+    sha256 = "sha256-fPeFul9BLWuw6T4IdRROCd9BY0e6sxr82Q3orDZnye8=";
   };
 
   sourceRoot = "${src.name}/klippy";

pkgs/servers/mail/stalwart/default.nix

···
 , stdenv
 , darwin
 , nix-update-script
+, nixosTests
 , rocksdb_8_3
 }:
 
···
   # Tests require reading to /etc/resolv.conf
   doCheck = false;
 
-  passthru.update-script = nix-update-script { };
+  passthru = {
+    update-script = nix-update-script { };
+    tests.stalwart-mail = nixosTests.stalwart-mail;
+  };
 
   meta = with lib; {
     description = "Secure & Modern All-in-One Mail Server (IMAP, JMAP, SMTP)";

pkgs/servers/search/weaviate/default.nix

···
 
 buildGoModule rec {
   pname = "weaviate";
-  version = "1.24.11";
+  version = "1.25.0";
 
   src = fetchFromGitHub {
     owner = "weaviate";
     repo = "weaviate";
     rev = "v${version}";
-    hash = "sha256-rXe9svvHu/6sQhHJ++jwb5gJEeVwoK/Z8rV7swUM3Kk=";
+    hash = "sha256-3ZjsFIxrlDCkbiIPNH+nkCwl9SEGA1h6632ZlIc9HBc=";
   };
 
-  vendorHash = "sha256-f7LskkQbsPwNmrzLTze0C66y++7Vqtb15tjW142TQmE=";
+  vendorHash = "sha256-4QSc4dU1bEpKpiG7FwSq/BbnFL94DqgjQo6zN67d8Sw=";
 
   subPackages = [ "cmd/weaviate-server" ];
 

pkgs/servers/x11/xorg/xwayland.nix

···
 , fetchpatch
 , fontutil
 , lib
+, libdecor
 , libei
 , libGL
 , libGLU
···
 , pkg-config
 , pixman
 , stdenv
+, systemd
 , wayland
 , wayland-protocols
 , wayland-scanner
···
 
 stdenv.mkDerivation rec {
   pname = "xwayland";
-  version = "23.2.6";
+  version = "24.1.0";
 
   src = fetchurl {
     url = "mirror://xorg/individual/xserver/${pname}-${version}.tar.xz";
-    hash = "sha256-HJo2a058ytug+b0xPFnq4S0jvXJUOyKibq+LIINc/G0=";
+    hash = "sha256-vvIcTxiAek7VccTi32CrY7VGa71QLszrJIW4kqt23MI=";
   };
 
   patches = [
-    # Backport fix for libei scrolling
-    # Notably affects Steam Input, but also anything else using xtest
+    # Backport fix for pkg-config generation to make CMake happy
     # FIXME: remove when merged
-    # Upstream PR: https://gitlab.freedesktop.org/xorg/xserver/-/merge_requests/1531
+    # Upstream PR: https://gitlab.freedesktop.org/xorg/xserver/-/merge_requests/1543
     (fetchpatch {
-      url = "https://gitlab.freedesktop.org/xorg/xserver/-/commit/317712eb5a1aa4a1c3d737a8fcaee57add9981c9.patch";
-      hash = "sha256-TZo38Pyr9IJUF+3bqlmF4M84XGgo9G6WFTvbaP9r0XU=";
+      url = "https://gitlab.freedesktop.org/xorg/xserver/-/commit/8cb1c21a4240a5b6bf4aeeef51819639b4e0ad24.patch";
+      hash = "sha256-MZPP9QgYO4RFJ/vcjkpu7SVSo5Dh09ZdZjOwTopjdYQ=";
     })
   ];
 
···
   ];
   buildInputs = [
     egl-wayland
+    libdecor
     libepoxy
     libei
     fontutil
···
     mesa
     openssl
     pixman
+    systemd
     wayland
     wayland-protocols
     xkbcomp
···
     libunwind
   ];
   mesonFlags = [
-    (lib.mesonBool "xwayland_eglstream" true)
     (lib.mesonBool "xcsecurity" true)
     (lib.mesonOption "default_font_path" defaultFontPath)
     (lib.mesonOption "xkb_bin_dir" "${xkbcomp}/bin")
···
     homepage = "https://wayland.freedesktop.org/xserver.html";
     license = licenses.mit;
     mainProgram = "Xwayland";
-    maintainers = with maintainers; [ emantor ];
+    maintainers = with maintainers; [ emantor k900 ];
     platforms = platforms.linux;
   };
 }

pkgs/tools/admin/granted/default.nix

···
 
 buildGoModule rec {
   pname = "granted";
-  version = "0.25.0";
+  version = "0.26.0";
 
   src = fetchFromGitHub {
     owner = "common-fate";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-oXwBVtkHy0bIs/5iHUvxO2gxccgBC0/+7EV09LIsROo=";
+    sha256 = "sha256-Ny2HHNawUmjqo0rTlM5yulOkqQUM/x1ySbXIE6vbegQ=";
   };
 
-  vendorHash = "sha256-EtS0cSDFWrR2rkKtNihBCZGBZC0TXruEuP2fqw0ZuIQ=";
+  vendorHash = "sha256-f0vL9YD5PmoZFeOv2oeYtm2gYPYCJ6aYTan9AVr0/gc=";
 
   nativeBuildInputs = [ makeWrapper ];
 

pkgs/tools/misc/cf-terraforming/default.nix

···
 
 buildGoModule rec {
   pname = "cf-terraforming";
-  version = "0.19.0";
+  version = "0.20.0";
 
   src = fetchFromGitHub {
     owner = "cloudflare";
     repo = "cf-terraforming";
     rev = "v${version}";
-    sha256 = "sha256-eGfPk3qptNf6QfVKDT4MwJav7z+ri+eEiB7KHGRxzOE=";
+    sha256 = "sha256-r5iRXhbjmFNlzoOe9s6vheROl/XKbeIfGD+ACl0hmro=";
   };
 
-  vendorHash = "sha256-cWFCEC20D2nhVeW7P/w5YSt1tQbWTPDWF/eaxEvWoLo=";
+  vendorHash = "sha256-FinthjJeXwfjyNORdgmgArjRk+2zUlVV67P52V/lK+A=";
   ldflags = [ "-X github.com/cloudflare/cf-terraforming/internal/app/cf-terraforming/cmd.versionString=${version}" ];
 
   # The test suite insists on downloading a binary release of Terraform from

pkgs/tools/package-management/poetry/unwrapped.nix

···
 
 buildPythonPackage rec {
   pname = "poetry";
-  version = "1.8.2";
+  version = "1.8.3";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "python-poetry";
     repo = "poetry";
     rev = "refs/tags/${version}";
-    hash = "sha256-MBWVeS/UHpzeeNUeiHMoXnLA3enRO/6yGIbg4Vf2GxU=";
+    hash = "sha256-PPHt9GG5XJzrhnuAS8L+0Pa3El3RNCdEbXbLnHopDWg=";
   };
 
   nativeBuildInputs = [

pkgs/tools/wayland/wluma/Cargo.lock

···
 version = 3
 
 [[package]]
+name = "addr2line"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
 name = "aho-corasick"
-version = "0.7.20"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
 dependencies = [
- "memchr 2.5.0",
+ "memchr 2.7.2",
 ]
+
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
 
 [[package]]
 name = "android_system_properties"
···
 
 [[package]]
 name = "anyhow"
-version = "1.0.68"
+version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cb2f989d18dd141ab8ae82f64d1a8cdd37e0840f73a406896cf5e99502fab61"
+checksum = "0952808a6c2afd1aa8947271f3a60f1a6763c7b912d210184c5149b5cf147247"
 
 [[package]]
 name = "ash"
-version = "0.37.2+1.3.238"
+version = "0.37.3+1.3.251"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28bf19c1f0a470be5fbf7522a308a05df06610252c5bcf5143e1b23f629a9a03"
+checksum = "39e9c3835d686b0a6084ab4234fcd1b07dbf6e4767dce60874b12356a25ecd4a"
 
 [[package]]
 name = "atty"
···
 
 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"
+
+[[package]]
+name = "backtrace"
+version = "0.3.71"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
+dependencies = [
+ "addr2line",
+ "cc",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+]
 
 [[package]]
 name = "bindgen"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cfdf7b466f9a4903edc73f95d6d2bcd5baf8ae620638762244d3f60143643cc5"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "cexpr",
  "clang-sys",
  "lazy_static",
···
  "regex",
  "rustc-hash",
  "shlex",
- "syn 2.0.22",
+ "syn 2.0.57",
  "which",
 ]
 
···
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
+name = "bitflags"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+
+[[package]]
 name = "bumpalo"
-version = "3.11.1"
+version = "3.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"
+checksum = "7ff69b9dd49fd426c69a0db9fc04dd934cdb6645ff000864d98f7e2af8830eaa"
 
 [[package]]
 name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "cc"
-version = "1.0.78"
+version = "1.0.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a20104e2335ce8a659d6dd92a51a767a0c062599c73b343fd152cb401e828c3d"
+checksum = "8cd6604a82acf3039f1144f54b8eb34e91ffba622051189e71b781822d5ee1f5"
 
 [[package]]
 name = "cexpr"
···
 
 [[package]]
 name = "chrono"
-version = "0.4.23"
+version = "0.4.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16b0a3d9ed01224b22057780a37bb8c5dbfe1be8ba48678e7bf57ec4b385411f"
+checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
 dependencies = [
+ "android-tzdata",
  "iana-time-zone",
  "js-sys",
- "num-integer",
  "num-traits",
- "time",
  "wasm-bindgen",
- "winapi",
+ "windows-targets 0.52.4",
 ]
 
 [[package]]
 name = "clang-sys"
-version = "1.4.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa2e27ae6ab525c3d369ded447057bca5438d86dc3a68f6faafb8269ba82ebf3"
+checksum = "67523a3b4be3ce1989d607a828d036249522dd9c1c8de7f4dd2dae43a37369d1"
 dependencies = [
  "glob",
  "libc",
···
 ]
 
 [[package]]
-name = "codespan-reporting"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
-dependencies = [
- "termcolor",
- "unicode-width",
-]
-
-[[package]]
 name = "core-foundation"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
 dependencies = [
- "core-foundation-sys 0.8.3",
+ "core-foundation-sys",
  "libc",
 ]
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ca8a5221364ef15ce201e8ed2f609fc312682a8f4e0e3d4aa5879764e0fa3b"
-
-[[package]]
-name = "core-foundation-sys"
-version = "0.8.3"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
 
 [[package]]
 name = "core-graphics"
-version = "0.22.3"
+version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2581bbab3b8ffc6fcbd550bf46c355135d16e9ff2a6ea032ad6b9bf1d7efe4fb"
+checksum = "970a29baf4110c26fedbc7f82107d42c23f7e88e404c4577ed73fe99ff85a212"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "core-foundation",
  "core-graphics-types",
  "foreign-types",
···
 
 [[package]]
 name = "core-graphics-types"
-version = "0.1.1"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a68b68b3446082644c91ac778bf50cd4104bfb002b5a6a7c44cca5a2c70788b"
+checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "core-foundation",
- "foreign-types",
  "libc",
 ]
 
 [[package]]
-name = "cxx"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51d1075c37807dcf850c379432f0df05ba52cc30f279c5cfc43cc221ce7f8579"
-dependencies = [
- "cc",
- "cxxbridge-flags",
- "cxxbridge-macro",
- "link-cplusplus",
-]
-
-[[package]]
-name = "cxx-build"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5044281f61b27bc598f2f6647d480aed48d2bf52d6eb0b627d84c0361b17aa70"
-dependencies = [
- "cc",
- "codespan-reporting",
- "once_cell",
- "proc-macro2",
- "quote",
- "scratch",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "cxxbridge-flags"
-version = "1.0.86"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61b50bc93ba22c27b0d31128d2d130a0a6b3d267ae27ef7e4fae2167dfe8781c"
-
-[[package]]
-name = "cxxbridge-macro"
-version = "1.0.86"
+name = "dbus"
+version = "0.9.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39e61fda7e62115119469c7b3591fd913ecca96fb766cfd3f2e2502ab7bc87a5"
+checksum = "1bb21987b9fb1613058ba3843121dd18b163b254d8a6e797e144cbac14d96d1b"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
+ "libc",
+ "libdbus-sys",
+ "winapi",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "ddc-i2c"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66503057bd41fc21b532b3ebe33b2ec57e5d4971fcfc3844306ebcb499b6c8c2"
+checksum = "1ef18fac9fd5c11d0c7b85a80887b01f7361b49edb2b4627243928b90ce2691b"
 dependencies = [
  "ddc",
  "i2c",
···
 
 [[package]]
 name = "ddc-macos"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cbaf316c113cfc30da8856c8104dfb4168b73fdd78562d1542e358fe8299dea"
+checksum = "3d04c521a076cbd37159b4674492304407f3bbc9669b43a90d9ed054a6d2b3cb"
 dependencies = [
  "core-foundation",
- "core-foundation-sys 0.8.3",
+ "core-foundation-sys",
  "core-graphics",
  "ddc",
  "io-kit-sys",
- "mach 0.3.2",
+ "mach",
  "thiserror",
 ]
 
 [[package]]
 name = "ddc-winapi"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3238e71b65c870e236de529546a689202fca64a2eaeec43995d28f6920d7fc9e"
+checksum = "015df0d6d814ea948e012977760324da6d103ec8d67c971c75a6daa3b4fc943f"
 dependencies = [
  "ddc",
  "widestring",
···
 checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
-name = "dirs"
-version = "4.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
-dependencies = [
- "dirs-sys",
-]
-
-[[package]]
-name = "dirs-sys"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
-dependencies = [
- "libc",
- "redox_users",
- "winapi",
-]
-
-[[package]]
 name = "dlib"
-version = "0.5.0"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac1b7517328c04c2aa68422fc60a41b92208182142ed04a25879c26c8f878794"
+checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412"
 dependencies = [
  "libloading",
 ]
···
 
 [[package]]
 name = "either"
-version = "1.8.1"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
+checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
 
 [[package]]
 name = "env_logger"
···
 ]
 
 [[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
+[[package]]
+name = "errno"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
 name = "float-cmp"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "foreign-types"
-version = "0.3.2"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
 dependencies = [
+ "foreign-types-macros",
  "foreign-types-shared",
 ]
 
 [[package]]
+name = "foreign-types-macros"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.57",
+]
+
+[[package]]
 name = "foreign-types-shared"
-version = "0.1.1"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
 
 [[package]]
 name = "fragile"
···
 
 [[package]]
 name = "futures-core"
-version = "0.3.25"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04909a7a7e4633ae6c4a9ab280aeb86da1236243a77b694a49eacd659a4bd3ac"
+checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
 
 [[package]]
-name = "getrandom"
-version = "0.2.8"
+name = "gimli"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
-dependencies = [
- "cfg-if",
- "libc",
- "wasi 0.11.0+wasi-snapshot-preview1",
-]
+checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
 
 [[package]]
 name = "glob"
···
 
 [[package]]
 name = "hashbrown"
-version = "0.12.3"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
 
 [[package]]
 name = "hermit-abi"
···
 ]
 
 [[package]]
+name = "home"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
+[[package]]
 name = "humantime"
 version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60c7b7bdd7b3a985fdcf94a0d7d98e7a47fde8b7f22fb55ce1a91cc104a2ce9a"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0268a871aaa071221d6c2875ebedcf64710e59b0d87c68c8faf5e98b87dd2a4"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "i2c",
  "i2c-linux-sys",
  "resize-slice",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55cd060ed0016621d3da4ed3a23b0158084de90d1f3a8e59f3d391aacd3bbcf8"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "byteorder",
  "libc",
 ]
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.53"
+version = "0.1.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"
+checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
 dependencies = [
  "android_system_properties",
- "core-foundation-sys 0.8.3",
+ "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
  "wasm-bindgen",
- "winapi",
+ "windows-core",
 ]
 
 [[package]]
 name = "iana-time-zone-haiku"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
 dependencies = [
- "cxx",
- "cxx-build",
+ "cc",
 ]
 
 [[package]]
 name = "indexmap"
-version = "1.9.2"
+version = "2.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
- "autocfg",
+ "equivalent",
  "hashbrown",
 ]
 
 [[package]]
 name = "inotify"
-version = "0.10.0"
+version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abf888f9575c290197b2c948dc9e9ff10bd1a39ad1ea8585f734585fa6b9d3f9"
+checksum = "fdd168d97690d0b8c412d6b6c10360277f4d7ee495c5d0d5d5fe0854923255cc"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "futures-core",
  "inotify-sys",
  "libc",
···
 
 [[package]]
 name = "io-kit-sys"
-version = "0.1.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f21dcc74995dd4cd090b147e79789f8d65959cbfb5f0b118002db869ea3bd0a0"
+checksum = "617ee6cf8e3f66f3b4ea67a4058564628cde41901316e19f559e14c7c72c5e7b"
 dependencies = [
- "core-foundation-sys 0.6.2",
- "mach 0.2.3",
+ "core-foundation-sys",
+ "mach2",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "itoa"
-version = "1.0.5"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "js-sys"
-version = "0.3.60"
+version = "0.3.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49409df3e3bf0856b916e2ceaca09ee28e6871cf7d9ce97a692cacfdb2a25a47"
+checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
 dependencies = [
  "wasm-bindgen",
 ]
···
 
 [[package]]
 name = "libc"
-version = "0.2.141"
+version = "0.2.153"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+
+[[package]]
+name = "libdbus-sys"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3304a64d199bb964be99741b7a14d26972741915b3649639149b2479bb46f4b5"
+checksum = "06085512b750d640299b79be4bad3d2fa90a9c00b1fd9e1b46364f66f0485c72"
+dependencies = [
+ "pkg-config",
+]
 
 [[package]]
 name = "libloading"
-version = "0.7.4"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19"
 dependencies = [
  "cfg-if",
- "winapi",
+ "windows-targets 0.52.4",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
-name = "link-cplusplus"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecd207c9c713c34f95a097a5b029ac2ce6010530c7b49d7fea24d977dede04f5"
-dependencies = [
- "cc",
-]
-
-[[package]]
 name = "linked-hash-map"
 version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
 
 [[package]]
+name = "linux-raw-sys"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
+
+[[package]]
 name = "log"
-version = "0.4.17"
+version = "0.4.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
-dependencies = [
- "cfg-if",
-]
+checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
 
 [[package]]
 name = "mach"
-version = "0.2.3"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86dd2487cdfea56def77b88438a2c915fb45113c5319bfe7e14306ca4cd0b0e1"
+checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
 dependencies = [
  "libc",
 ]
 
 [[package]]
-name = "mach"
-version = "0.3.2"
+name = "mach2"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
+checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "mccs"
-version = "0.1.0"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74366c6da4179141e0d4551a46799a7e667a68eda60561690d5048bd8e0f8422"
+checksum = "6090d6b3ded42fed158b660a6b9cdaa1924f3eef6c6598e82a9ca9b70a1988cd"
 dependencies = [
  "void",
 ]
 
 [[package]]
 name = "mccs-caps"
-version = "0.1.0"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9766b1345aec53f3f1781797e31f7367a8c53871a0e30214d8372fe2ccbe3ce"
+checksum = "8eb961d01a3bb07969cfa276be2ab88c31d0fefa77a872696832732d6e9ec094"
 dependencies = [
  "mccs",
  "nom 3.2.1",
···
 
 [[package]]
 name = "mccs-db"
-version = "0.1.2"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99726fbbe1e11e2908c461e8fab6c9106a5cb13338cc4feb68a01cced38026d0"
+checksum = "3cdaa8fe19a1a1918becc1b8cbbbdc1058bc71411dff4de0a6ec6b5269f49d38"
 dependencies = [
  "mccs",
  "nom 3.2.1",
···
 
 [[package]]
 name = "memchr"
-version = "2.5.0"
+version = "2.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
 
 [[package]]
 name = "memoffset"
···
 checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
+name = "miniz_oxide"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
+dependencies = [
+ "adler",
+]
+
+[[package]]
 name = "mio"
-version = "0.8.5"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5d732bc30207a6423068df043e3d02e0735b155ad7ce1a6f76fe2baa5b158de"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
 dependencies = [
  "libc",
- "log",
- "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys",
+ "wasi",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "cfg-if",
  "libc",
  "memoffset",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
 dependencies = [
- "memchr 2.5.0",
+ "memchr 2.7.2",
  "minimal-lexical",
 ]
 
···
 checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
 
 [[package]]
-name = "num-integer"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
-dependencies = [
- "autocfg",
- "num-traits",
-]
-
-[[package]]
 name = "num-traits"
-version = "0.2.15"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
 dependencies = [
  "autocfg",
 ]
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b29e9a9393c69ee856bfcf5f76ed1ef32d2c0dd6f58558fd43334278fc1e7ea7"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "winapi",
 ]
 
 [[package]]
+name = "object"
+version = "0.32.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+dependencies = [
+ "memchr 2.7.2",
+]
+
+[[package]]
 name = "once_cell"
-version = "1.17.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "peeking_take_while"
···
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.9"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
 
 [[package]]
 name = "pkg-config"
-version = "0.3.26"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
 
 [[package]]
 name = "predicates"
···
 
 [[package]]
 name = "predicates-core"
-version = "1.0.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72f883590242d3c6fc5bf50299011695fa6590c2c70eac95ee1bdb9a733ad1a2"
+checksum = "b794032607612e7abeb4db69adb4e33590fa6cf1149e95fd7cb00e634b92f174"
 
 [[package]]
 name = "predicates-tree"
-version = "1.0.7"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54ff541861505aabf6ea722d2131ee980b8276e10a1297b94e896dd8b621850d"
+checksum = "368ba315fb8c5052ab692e68a0eefec6ec57b23a36959c14496f0b0df2c0cecf"
 dependencies = [
  "predicates-core",
  "termtree",
···
 
 [[package]]
 name = "prettyplease"
-version = "0.2.9"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9825a04601d60621feed79c4e6b56d65db77cdca55cef43b46b0de1096d1c282"
+checksum = "8d3928fb5db768cb86f891ff014f0144589297e3c6a1aba6ed7cecfdace270c7"
 dependencies = [
  "proc-macro2",
- "syn 2.0.22",
+ "syn 2.0.57",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.62"
+version = "1.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe8df9bd9fe9d1742a9e17f8129712801b428f6d4c6059d79bacea58f0b0142d"
+checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.28"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9ab9c7eadfd8df19006f1cf1a4aed13540ed5cbc047010ece5826e10825488"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
-name = "redox_syscall"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "redox_users"
-version = "0.4.3"
+name = "regex"
+version = "1.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
+checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
 dependencies = [
- "getrandom",
- "redox_syscall",
- "thiserror",
+ "aho-corasick",
+ "memchr 2.7.2",
+ "regex-automata",
+ "regex-syntax",
 ]
 
 [[package]]
-name = "regex"
-version = "1.7.3"
+name = "regex-automata"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b1f693b24f6ac912f4893ef08244d70b6067480d2f1a46e950c9691e6749d1d"
+checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
 dependencies = [
  "aho-corasick",
- "memchr 2.5.0",
+ "memchr 2.7.2",
  "regex-syntax",
 ]
 
 [[package]]
 name = "regex-syntax"
-version = "0.6.29"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"
 
 [[package]]
 name = "resize-slice"
···
 ]
 
 [[package]]
+name = "rustc-demangle"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
+
+[[package]]
 name = "rustc-hash"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
+name = "rustix"
+version = "0.38.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89"
+dependencies = [
+ "bitflags 2.5.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
 name = "ryu"
-version = "1.0.12"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b4b9743ed687d4b4bcedf9ff5eaa7398495ae14e61cba0a295704edbc7decde"
+checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
 
 [[package]]
 name = "scoped-tls"
···
 checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
 
 [[package]]
-name = "scratch"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddccb15bcce173023b3fedd9436f882a0739b8dfb45e4f6b6002bee5929f61b2"
-
-[[package]]
 name = "serde"
-version = "1.0.152"
+version = "1.0.197"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb"
+checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.152"
+version = "1.0.197"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
+checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.57",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1"
+dependencies = [
+ "serde",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "serde_yaml"
-version = "0.9.16"
+version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92b5b431e8907b50339b51223b97d102db8d987ced36f6e4d03621db9316c834"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
  "indexmap",
  "itoa",
···
 
 [[package]]
 name = "shlex"
-version = "1.1.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43b2853a4d09f215c24cc5489c992ce46052d359b5109343cbafbf26bc62f8a3"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "smallvec"
-version = "1.10.0"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "socket2"
-version = "0.4.7"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02e2d2db9033d13a1567121ddd7a095ee144db4e1ca1b1bda3419bc0da294ebd"
+checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871"
 dependencies = [
  "libc",
- "winapi",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "syn"
-version = "2.0.22"
+version = "2.0.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2efbeae7acf4eabd6bcdcbd11c92f45231ddda7539edc7806bd1a04a03b24616"
+checksum = "11a6ae1e52eb25aab8f3fb9fca13be982a373b8f1157ca14b897a825ba4a2d35"
 dependencies = [
  "proc-macro2",
  "quote",
···
 
 [[package]]
 name = "termcolor"
-version = "1.2.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
 dependencies = [
  "winapi-util",
 ]
 
 [[package]]
 name = "termtree"
-version = "0.4.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95059e91184749cb66be6dc994f67f182b6d897cb3df74a5bf66b5e709295fd8"
+checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
 
 [[package]]
 name = "thiserror"
-version = "1.0.38"
+version = "1.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a9cd18aa97d5c45c6603caea1da6628790b37f7a34b6ca89522331c5180fed0"
+checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.38"
+version = "1.0.58"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f"
+checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "time"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
-dependencies = [
- "libc",
- "wasi 0.10.0+wasi-snapshot-preview1",
- "winapi",
+ "syn 2.0.57",
 ]
 
 [[package]]
 name = "tokio"
-version = "1.24.1"
+version = "1.37.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d9f76183f91ecfb55e1d7d5602bd1d979e38a3a522fe900241cf195624d67ae"
+checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787"
 dependencies = [
- "autocfg",
+ "backtrace",
  "libc",
  "mio",
  "pin-project-lite",
  "socket2",
- "windows-sys",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "toml"
-version = "0.5.9"
-source = "git+https://github.com/HarveyHunt/toml?branch=dotted-table-parsing-toml#7db18be32494855199ed827ac389e161914bd20d"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd79e69d3b627db300ff956027cc6c3798cef26d22526befdfcd12feeb6d2257"
 dependencies = [
  "serde",
+ "serde_spanned",
  "toml_datetime",
+ "toml_edit",
 ]
 
 [[package]]
 name = "toml_datetime"
-version = "0.5.0"
-source = "git+https://github.com/HarveyHunt/toml?branch=dotted-table-parsing-toml#7db18be32494855199ed827ac389e161914bd20d"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.19.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
+ "indexmap",
  "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "winnow",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
-
-[[package]]
-name = "unicode-width"
-version = "0.1.10"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
 [[package]]
 name = "uninitialized"
···
 
 [[package]]
 name = "unsafe-libyaml"
-version = "0.2.5"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc7ed8ba44ca06be78ea1ad2c3682a43349126c8818054231ee6f4748012aed2"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
 
 [[package]]
 name = "v4l"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d8fbfea44a46799d62c55323f3c55d06df722fbe577851d848d328a1041c3403"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "libc",
  "v4l-sys",
 ]
···
 
 [[package]]
 name = "wasi"
-version = "0.10.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
-
-[[package]]
-name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.83"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaf9f5aceeec8be17c128b2e93e031fb8a4d469bb9c4ae2d7dc1888b26887268"
+checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
 dependencies = [
  "cfg-if",
  "wasm-bindgen-macro",
···
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.83"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"
+checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.57",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.83"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "052be0f94026e6cbc75cdefc9bae13fd6052cdcaf532fa6c45e7ae33a1e6c810"
+checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
···
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.83"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07bc0c051dc5f23e307b13285f9d75df86bfdf816c5721e573dec1f9b8aa193c"
+checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.57",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.83"
+version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c38c045535d93ec4f0b4defec448e4291638ee608530863b1e2ba115d4fff7f"
+checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
 
 [[package]]
 name = "wayland-client"
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f3b068c05a039c9f755f881dc50f01732214f5685e379829759088967c46715"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "downcast-rs",
  "libc",
  "nix",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b950621f9354b322ee817a23474e479b34be96c2e909c14f7bc0100e9a970bc6"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "wayland-client",
  "wayland-commons",
  "wayland-scanner",
···
 
 [[package]]
 name = "which"
-version = "4.4.0"
+version = "4.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2441c784c52b289a054b7201fc93253e288f094e2f4be9058343127c4226a269"
+checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7"
 dependencies = [
  "either",
- "libc",
+ "home",
  "once_cell",
+ "rustix",
 ]
 
 [[package]]
 name = "widestring"
-version = "0.3.0"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a212922ea58fbf5044f83663aa4fc6281ff890f1fd7546c0c3f52f5290831781"
+checksum = "653f141f39ec16bba3c5abe400a0c60da7468261cc2cbf36805022876bc721a8"
 
 [[package]]
 name = "winapi"
···
 
 [[package]]
 name = "winapi-util"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
 dependencies = [
  "winapi",
 ]
···
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.4",
+]
+
+[[package]]
 name = "windows-sys"
-version = "0.42.0"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.4",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.4",
+ "windows_aarch64_msvc 0.52.4",
+ "windows_i686_gnu 0.52.4",
+ "windows_i686_msvc 0.52.4",
+ "windows_x86_64_gnu 0.52.4",
+ "windows_x86_64_gnullvm 0.52.4",
+ "windows_x86_64_msvc 0.52.4",
 ]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.42.1"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c9864e83243fdec7fc9c5444389dcbbfd258f745e7853198f365e3c4968a608"
+checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.42.1"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8b1b673ffc16c47a9ff48570a9d85e25d265735c503681332589af6253c6c7"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.42.1"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3887528ad530ba7bdbb1faa8275ec7a1155a45ffa57c37993960277145d640"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.42.1"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf4d1122317eddd6ff351aa852118a2418ad4214e6613a50e0191f7004372605"
+checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.42.1"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1040f221285e17ebccbc2591ffdc2d44ee1f9186324dd3e84e99ac68d699c45"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.42.1"
+version = "0.52.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "628bfdf232daa22b0d64fdb62b09fcc36bb01f05a3939e20ab73aaf9470d0463"
+checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.42.1"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8"
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr 2.7.2",
+]
 
 [[package]]
 name = "wluma"
-version = "4.3.0"
+version = "4.4.0"
 dependencies = [
  "ash",
  "chrono",
+ "dbus",
  "ddc-hi",
  "env_logger",
  "inotify",
···
  "log",
  "mockall",
  "serde",
- "serde_yaml 0.9.16",
+ "serde_yaml 0.9.34+deprecated",
  "toml",
  "v4l",
  "wayland-client",
···
 
 [[package]]
 name = "xdg"
-version = "2.4.1"
+version = "2.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c4583db5cbd4c4c0303df2d15af80f0539db703fa1c68802d4cbbd2dd0f88f6"
-dependencies = [
- "dirs",
-]
+checksum = "213b7324336b53d2414b2db8537e56544d981803139155afa84f76eeebb7a546"
 
 [[package]]
 name = "xml-rs"
-version = "0.8.4"
+version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2d7d3948613f75c98fd9328cfdcc45acc4d360655289d0a7d4ec931392200a3"
+checksum = "0fcb9cbac069e033553e8bb871be2fbdffcab578eb25bd0f7c508cedc6dcd75a"
 
 [[package]]
 name = "yaml-rust"

pkgs/tools/wayland/wluma/default.nix

···
 , pkg-config
 , udev
 , v4l-utils
+, dbus
+, nix-update-script
 }:
 
 rustPlatform.buildRustPackage rec {
   pname = "wluma";
-  version = "4.3.0";
+  version = "4.4.0";
 
   src = fetchFromGitHub {
     owner = "maximbaz";
     repo = "wluma";
     rev = version;
-    sha256 = "sha256-FaX87k8LdBhrBX4qvokSHkcNaQZ0+oSbkn9d0dK6FGo=";
+    sha256 = "sha256-Ow3SjeulYiHY9foXrmTtLK3F+B3+DrtDjBUke3bJeDw=";
   };
 
   cargoLock = {
     lockFile = ./Cargo.lock;
-    outputHashes = {
-      "toml-0.5.9" = "sha256-WUQFF9Hfo3JK65AKAF7qNZex6l7F3N8HXmJlu8cJUEE=";
-    };
   };
 
   nativeBuildInputs = [
···
     udev
     v4l-utils
     vulkan-loader
+    dbus
   ];
 
   postInstall = ''
···
       --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ wayland ]}"
   '';
 
+  passthru.updateScript = nix-update-script { };
+
   meta = with lib; {
     description = "Automatic brightness adjustment based on screen contents and ALS";
     homepage = "https://github.com/maximbaz/wluma";
     changelog = "https://github.com/maximbaz/wluma/releases/tag/${version}";
     license = licenses.isc;
-    maintainers = with maintainers; [ yshym jmc-figueira ];
+    maintainers = with maintainers; [ yshym jmc-figueira atemu ];
     platforms = platforms.linux;
     mainProgram = "wluma";
   };

pkgs/top-level/all-packages.nix

···
 
   xlife = callPackage ../applications/graphics/xlife { };
 
-  xmobar = haskellPackages.xmobar;
+  xmobar = haskellPackages.xmobar.bin;
 
   xmonad-log = callPackage ../tools/misc/xmonad-log { };
 

pkgs/top-level/haskell-packages.nix

···
       llvmPackages = pkgs.llvmPackages_15;
     };
     ghc98 = compiler.ghc982;
+    ghc9101 = callPackage ../development/compilers/ghc/9.10.1.nix {
+      bootPkgs =
+        # For GHC 9.6 no armv7l bindists are available.
+        if stdenv.hostPlatform.isAarch32 then
+          packages.ghc963
+        else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then
+          packages.ghc963
+        else if stdenv.hostPlatform.isDarwin then
+          # it seems like the GHC 9.6.* bindists are built with a different
+          # toolchain than we are using (which I'm guessing from the fact
+          # that 9.6.4 bindists pass linker flags our ld doesn't support).
+          # With both 9.6.3 and 9.6.4 binary it is impossible to link against
+          # the clock package (probably a hsc2hs problem).
+          packages.ghc963
+        else
+          packages.ghc963Binary;
+      inherit (buildPackages.python3Packages) sphinx;
+      # Need to use apple's patched xattr until
+      # https://github.com/xattr/xattr/issues/44 and
+      # https://github.com/xattr/xattr/issues/55 are solved.
+      inherit (buildPackages.darwin) xattr autoSignDarwinBinariesHook;
+      # 2023-01-15: Support range >= 11 && < 16
+      buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_15;
+      llvmPackages = pkgs.llvmPackages_15;
+    };
+    ghc910 = compiler.ghc9101;
     ghcHEAD = callPackage ../development/compilers/ghc/head.nix {
       bootPkgs =
         # For GHC 9.6 no armv7l bindists are available.
···
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.8.x.nix { };
     };
     ghc98 = packages.ghc982;
+    ghc9101 = callPackage ../development/haskell-modules {
+      buildHaskellPackages = bh.packages.ghc9101;
+      ghc = bh.compiler.ghc9101;
+      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.10.x.nix { };
+    };
+    ghc910 = packages.ghc9101;
     ghcHEAD = callPackage ../development/haskell-modules {
       buildHaskellPackages = bh.packages.ghcHEAD;
       ghc = bh.compiler.ghcHEAD;

pkgs/top-level/python-packages.nix

···
 
   filecheck = callPackage ../development/python-modules/filecheck { };
 
+  filedate = callPackage ../development/python-modules/filedate { };
+
   filedepot = callPackage ../development/python-modules/filedepot { };
 
   filelock = callPackage ../development/python-modules/filelock { };

pkgs/top-level/release-haskell.nix

···
     ghc965
     ghc981
     ghc982
+    ghc9101
   ];
 
   # packagePlatforms applied to `haskell.packages.*`
···
       cabal-install = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       Cabal_3_10_3_0 = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       Cabal-syntax_3_10_3_0 = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       cabal2nix = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       cabal2nix-unstable = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       funcmp = released;
       haskell-language-server = lib.subtractLists [
···
         compilerNames.ghc8107
         # Support ceased as of 2.5.0.0
         compilerNames.ghc902
+        # No support yet (2024-05-12)
+        compilerNames.ghc9101
       ] released;
       hoogle = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       hlint = lib.subtractLists [
         compilerNames.ghc902
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       hpack = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       hsdns = released;
       jailbreak-cabal = released;
       language-nix = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       large-hashable = [
         compilerNames.ghc928
···
       titlecase = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       ghc-api-compat = [
         compilerNames.ghc8107
···
       ghc-lib = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       ghc-lib-parser = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       ghc-lib-parser-ex = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
       ghc-source-gen = [
         # Feel free to remove these as they break,
···
       hashable = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
-      primitive = released;
+      primitive = lib.subtractLists [
+        compilerNames.ghc9101
+      ] released;
       weeder = lib.subtractLists [
         compilerNames.ghc981
         compilerNames.ghc982
+        compilerNames.ghc9101
       ] released;
     })
     {