Merge master into haskell-updates

flake.nix

···
               # We set it to null, to remove the "legacy" entrypoint's
               # non-hermetic default.
               system = null;
-            } // args
+
+              modules = args.modules ++ [
+                # This module is injected here since it exposes the nixpkgs self-path in as
+                # constrained of contexts as possible to avoid more things depending on it and
+                # introducing unnecessary potential fragility to changes in flakes itself.
+                #
+                # See: failed attempt to make pkgs.path not copy when using flakes:
+                # https://github.com/NixOS/nixpkgs/pull/153594#issuecomment-1023287913
+                ({ config, pkgs, lib, ... }: {
+                  config.nixpkgs.flake.source = self.outPath;
+                })
+              ];
+            } // builtins.removeAttrs args [ "modules" ]
           );
       });
 

maintainers/maintainer-list.nix

···
     githubId = 113123021;
     name = "Ashvith Shetty";
   };
+  asininemonkey = {
+    email = "[e-mail]";
+    github = "asininemonkey";
+    githubId = 65740649;
+    name = "Jose Cardoso";
+  };
   aske = {
     email = "[e-mail]";
     github = "aske";
···
     github = "asppsa";
     githubId = 453170;
     name = "Alastair Pharo";
+  };
+  aspulse = {
+    email = "[e-mail]";
+    github = "aspulse";
+    githubId = 84216737;
+    name = "AsPulse / あすぱる";
+    keys = [{
+      fingerprint = "C919 E69E A7C0 E147 9E0F  C26E 1EDA D0C6 70BD 062D";
+    }];
   };
   astavie = {
     email = "[e-mail]";
···
     github = "rardiol";
     githubId = 11351304;
     name = "Ricardo Ardissone";
+  };
+  raroh73 = {
+    email = "[e-mail]";
+    github = "Raroh73";
+    githubId = 96078496;
+    name = "Raroh73";
   };
   rasendubi = {
     email = "[e-mail]";

maintainers/team-list.nix

···
       imincik
       nh2
       nialov
-      r-burns
       sikmir
       willcohen
     ];

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

···
    - This can be disabled through the `environment.stub-ld.enable` option.
    - If you use `programs.nix-ld.enable`, no changes are needed. The stub will be disabled automatically.
 
+- On flake-based NixOS configurations using `nixpkgs.lib.nixosSystem`, NixOS will automatically set `NIX_PATH` and the system-wide flake registry (`/etc/nix/registry.json`) to point `<nixpkgs>` and the unqualified flake path `nixpkgs` to the version of nixpkgs used to build the system.
+
+  This makes `nix run nixpkgs#hello` and `nix-build '<nixpkgs>' -A hello` work out of the box with no added configuration, reusing dependencies already on the system.
+
+  This may be undesirable if nix commands are not going to be run on the built system since it adds nixpkgs to the system closure. For such closure-size-constrained non-interactive systems, this setting should be disabled.
+
+  To disable this, set [nixpkgs.flake.setNixPath](#opt-nixpkgs.flake.setNixPath) and [nixpkgs.flake.setFlakeRegistry](#opt-nixpkgs.flake.setFlakeRegistry) to false.
+
 - Julia environments can now be built with arbitrary packages from the ecosystem using the `.withPackages` function. For example: `julia.withPackages ["Plots"]`.
 
 - A new option `systemd.sysusers.enable` was added. If enabled, users and
···
 
 - `nitter` requires a `guest_accounts.jsonl` to be provided as a path or loaded into the default location at `/var/lib/nitter/guest_accounts.jsonl`. See [Guest Account Branch Deployment](https://github.com/zedeus/nitter/wiki/Guest-Account-Branch-Deployment) for details.
 
+- `boot.supportedFilesystems` and `boot.initrd.supportedFilesystems` are now attribute sets instead of lists. Assignment from lists as done previously is still supported, but checking whether a filesystem is enabled must now by done using `supportedFilesystems.fs or false` instead of using `lib.elem "fs" supportedFilesystems` as was done previously.
+
 - `services.aria2.rpcSecret` has been replaced with `services.aria2.rpcSecretFile`.
   This was done so that secrets aren't stored in the world-readable nix store.
   To migrate, you will have create a file with the same exact string, and change
···
 - The vendored third party libraries have been mostly removed from `cudaPackages.nsight_systems`, which we now only ship for `cudaPackages_11_8` and later due to outdated dependencies. Users comfortable with the vendored dependencies may use `overrideAttrs` to amend the `postPatch` phase and the `meta.broken` correspondingly. Alternatively, one could package the deprecated `boost170` locally, as required for `cudaPackages_11_4.nsight_systems`.
 
 - The `cudaPackages` package scope has been updated to `cudaPackages_12`.
+
+- Ada packages (libraries and tools) have been moved into the `gnatPackages` scope. `gnatPackages` uses the default GNAT compiler, `gnat12Packages` and `gnat13Packages` use the respective matching compiler version.
+
+- `spark2014` has been renamed to `gnatprove`. A version of `gnatprove` matching different GNAT versions is available from the different `gnatPackages` sets.
 
 - `services.resolved.fallbackDns` can now be used to disable the upstream fallback servers entirely by setting it to an empty list. To get the previous behaviour of the upstream defaults set it to null, the new default, instead.
 

nixos/modules/hardware/printers.nix

···
 with lib;
 let
   cfg = config.hardware.printers;
-  ppdOptionsString = options: optionalString (options != {})
-    (concatStringsSep " "
-      (mapAttrsToList (name: value: "-o '${name}'='${value}'") options)
-    );
-  ensurePrinter = p: ''
-    ${pkgs.cups}/bin/lpadmin -p '${p.name}' -E \
-      ${optionalString (p.location != null) "-L '${p.location}'"} \
-      ${optionalString (p.description != null) "-D '${p.description}'"} \
-      -v '${p.deviceUri}' \
-      -m '${p.model}' \
-      ${ppdOptionsString p.ppdOptions}
+
+  ensurePrinter = p: let
+    args = cli.toGNUCommandLineShell {} ({
+      p = p.name;
+      v = p.deviceUri;
+      m = p.model;
+    } // optionalAttrs (p.location != null) {
+      L = p.location;
+    } // optionalAttrs (p.description != null) {
+      D = p.description;
+    } // optionalAttrs (p.ppdOptions != {}) {
+      o = mapAttrsToList (name: value: "'${name}'='${value}'") p.ppdOptions;
+    });
+  in ''
+    ${pkgs.cups}/bin/lpadmin ${args} -E
   '';
+
   ensureDefaultPrinter = name: ''
     ${pkgs.cups}/bin/lpadmin -d '${name}'
   '';

nixos/modules/installer/cd-dvd/installation-cd-minimal-new-kernel-no-zfs.nix

···
-{ pkgs, ... }:
+{ lib, ... }:
 
 {
   imports = [ ./installation-cd-minimal-new-kernel.nix ];
 
-  # Makes `availableOn` fail for zfs, see <nixos/modules/profiles/base.nix>.
-  # This is a workaround since we cannot remove the `"zfs"` string from `supportedFilesystems`.
-  # The proper fix would be to make `supportedFilesystems` an attrset with true/false which we
-  # could then `lib.mkForce false`
-  nixpkgs.overlays = [(final: super: {
-    zfs = super.zfs.overrideAttrs(_: {
-      meta.platforms = [];
-    });
-  })];
+  boot.supportedFilesystems.zfs = lib.mkForce false;
 }

nixos/modules/installer/sd-card/sd-image-aarch64-new-kernel-no-zfs-installer.nix

···
-{ pkgs, ... }:
+{ lib, ... }:
 
 {
   imports = [ ./sd-image-aarch64-new-kernel-installer.nix ];
 
-  # Makes `availableOn` fail for zfs, see <nixos/modules/profiles/base.nix>.
-  # This is a workaround since we cannot remove the `"zfs"` string from `supportedFilesystems`.
-  # The proper fix would be to make `supportedFilesystems` an attrset with true/false which we
-  # could then `lib.mkForce false`
-  nixpkgs.overlays = [(final: super: {
-    zfs = super.zfs.overrideAttrs(_: {
-      meta.platforms = [];
-    });
-  })];
+  boot.supportedFilesystems.zfs = lib.mkForce false;
 }

nixos/modules/misc/nixpkgs-flake.nix

···
+{ config, options, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.nixpkgs.flake;
+in
+{
+  options.nixpkgs.flake = {
+    source = mkOption {
+      # In newer Nix versions, particularly with lazy trees, outPath of
+      # flakes becomes a Nix-language path object. We deliberately allow this
+      # to gracefully come through the interface in discussion with @roberth.
+      #
+      # See: https://github.com/NixOS/nixpkgs/pull/278522#discussion_r1460292639
+      type = types.nullOr (types.either types.str types.path);
+
+      default = null;
+      defaultText = "if (using nixpkgsFlake.lib.nixosSystem) then self.outPath else null";
+
+      example = ''builtins.fetchTarball { name = "source"; sha256 = "${lib.fakeHash}"; url = "https://github.com/nixos/nixpkgs/archive/somecommit.tar.gz"; }'';
+
+      description = mdDoc ''
+        The path to the nixpkgs sources used to build the system. This is automatically set up to be
+        the store path of the nixpkgs flake used to build the system if using
+        `nixpkgs.lib.nixosSystem`, and is otherwise null by default.
+
+        This can also be optionally set if the NixOS system is not built with a flake but still uses
+        pinned sources: set this to the store path for the nixpkgs sources used to build the system,
+        as may be obtained by `builtins.fetchTarball`, for example.
+
+        Note: the name of the store path must be "source" due to
+        <https://github.com/NixOS/nix/issues/7075>.
+      '';
+    };
+
+    setNixPath = mkOption {
+      type = types.bool;
+
+      default = cfg.source != null;
+      defaultText = "config.nixpkgs.flake.source != null";
+
+      description = mdDoc ''
+        Whether to set {env}`NIX_PATH` to include `nixpkgs=flake:nixpkgs` such that `<nixpkgs>`
+        lookups receive the version of nixpkgs that the system was built with, in concert with
+        {option}`nixpkgs.flake.setFlakeRegistry`.
+
+        This is on by default for NixOS configurations built with flakes.
+
+        This makes {command}`nix-build '<nixpkgs>' -A hello` work out of the box on flake systems.
+
+        Note that this option makes the NixOS closure depend on the nixpkgs sources, which may add
+        undesired closure size if the system will not have any nix commands run on it.
+      '';
+    };
+
+    setFlakeRegistry = mkOption {
+      type = types.bool;
+
+      default = cfg.source != null;
+      defaultText = "config.nixpkgs.flake.source != null";
+
+      description = mdDoc ''
+        Whether to pin nixpkgs in the system-wide flake registry (`/etc/nix/registry.json`) to the
+        store path of the sources of nixpkgs used to build the NixOS system.
+
+        This is on by default for NixOS configurations built with flakes.
+
+        This option makes {command}`nix run nixpkgs#hello` reuse dependencies from the system, avoid
+        refetching nixpkgs, and have a consistent result every time.
+
+        Note that this option makes the NixOS closure depend on the nixpkgs sources, which may add
+        undesired closure size if the system will not have any nix commands run on it.
+      '';
+    };
+  };
+
+  config = mkIf (cfg.source != null) (mkMerge [
+    {
+      assertions = [
+        {
+          assertion = cfg.setNixPath -> cfg.setFlakeRegistry;
+          message = ''
+            Setting `nixpkgs.flake.setNixPath` requires that `nixpkgs.flake.setFlakeRegistry` also
+            be set, since it is implemented in terms of indirection through the flake registry.
+          '';
+        }
+      ];
+    }
+    (mkIf cfg.setFlakeRegistry {
+      nix.registry.nixpkgs.to = mkDefault {
+        type = "path";
+        path = cfg.source;
+      };
+    })
+    (mkIf cfg.setNixPath {
+      # N.B. This does not include nixos-config in NIX_PATH unlike modules/config/nix-channel.nix
+      # because we would need some kind of evil shim taking the *calling* flake's self path,
+      # perhaps, to ever make that work (in order to know where the Nix expr for the system came
+      # from and how to call it).
+      nix.nixPath = mkDefault ([ "nixpkgs=flake:nixpkgs" ]
+        ++ optional config.nix.channel.enable "/nix/var/nix/profiles/per-user/root/channels");
+    })
+  ]);
+}

nixos/modules/module-list.nix

···
   ./misc/meta.nix
   ./misc/nixops-autoluks.nix
   ./misc/nixpkgs.nix
+  ./misc/nixpkgs-flake.nix
   ./misc/passthru.nix
   ./misc/version.nix
   ./misc/wordlist.nix

nixos/modules/system/boot/stage-1.nix

···
 # the modules necessary to mount the root file system, then calls the
 # init in the root file system to start the second boot stage.
 
-{ config, lib, utils, pkgs, ... }:
+{ config, options, lib, utils, pkgs, ... }:
 
 with lib;
 
···
       };
 
     boot.initrd.supportedFilesystems = mkOption {
-      default = [ ];
-      example = [ "btrfs" ];
-      type = types.listOf types.str;
-      description = lib.mdDoc "Names of supported filesystem types in the initial ramdisk.";
+      default = { };
+      inherit (options.boot.supportedFilesystems) example type description;
     };
 
     boot.initrd.verbose = mkOption {

nixos/modules/tasks/filesystems.nix

···
     };
 
     boot.supportedFilesystems = mkOption {
-      default = [ ];
-      example = [ "btrfs" ];
-      type = types.listOf types.str;
-      description = lib.mdDoc "Names of supported filesystem types.";
+      default = { };
+      example = lib.literalExpression ''
+        {
+          btrfs = true;
+          zfs = lib.mkForce false;
+        }
+      '';
+      type = types.coercedTo
+        (types.listOf types.str)
+        (enabled: lib.listToAttrs (map (fs: lib.nameValuePair fs true) enabled))
+        (types.attrsOf types.bool);
+      description = lib.mdDoc ''
+        Names of supported filesystem types, or an attribute set of file system types
+        and their state. The set form may be used together with `lib.mkForce` to
+        explicitly disable support for specific filesystems, e.g. to disable ZFS
+        with an unsupported kernel.
+      '';
     };
 
     boot.specialFileSystems = mkOption {

nixos/modules/tasks/filesystems/apfs.nix

···
 
 let
 
-  inInitrd = any (fs: fs == "apfs") config.boot.initrd.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.apfs or false;
 
 in
 
 {
-  config = mkIf (any (fs: fs == "apfs") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.apfs or false) {
 
     system.fsPackages = [ pkgs.apfsprogs ];
 

nixos/modules/tasks/filesystems/bcachefs.nix

···
 in
 
 {
-  config = lib.mkIf (lib.elem "bcachefs" config.boot.supportedFilesystems) (lib.mkMerge [
+  config = lib.mkIf (config.boot.supportedFilesystems.bcachefs or false) (lib.mkMerge [
     {
       inherit assertions;
       # needed for systemd-remount-fs
···
       };
     }
 
-    (lib.mkIf ((lib.elem "bcachefs" config.boot.initrd.supportedFilesystems) || (bootFs != {})) {
+    (lib.mkIf ((config.boot.initrd.supportedFilesystems.bcachefs or false) || (bootFs != {})) {
       inherit assertions;
       # chacha20 and poly1305 are required only for decryption attempts
       boot.initrd.availableKernelModules = [ "bcachefs" "sha256" "chacha20" "poly1305" ];

nixos/modules/tasks/filesystems/btrfs.nix

···
 
 let
 
-  inInitrd = any (fs: fs == "btrfs") config.boot.initrd.supportedFilesystems;
-  inSystem = any (fs: fs == "btrfs") config.boot.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.btrfs or false;
+  inSystem = config.boot.supportedFilesystems.btrfs or false;
 
   cfgScrub = config.services.btrfs.autoScrub;
 

nixos/modules/tasks/filesystems/cifs.nix

···
 
 let
 
-  inInitrd = any (fs: fs == "cifs") config.boot.initrd.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.cifs or false;
 
 in
 
 {
   config = {
 
-    system.fsPackages = mkIf (any (fs: fs == "cifs") config.boot.supportedFilesystems) [ pkgs.cifs-utils ];
+    system.fsPackages = mkIf (config.boot.supportedFilesystems.cifs or false) [ pkgs.cifs-utils ];
 
     boot.initrd.availableKernelModules = mkIf inInitrd
       [ "cifs" "nls_utf8" "hmac" "md4" "ecb" "des_generic" "sha256" ];

nixos/modules/tasks/filesystems/ecryptfs.nix

···
 with lib;
 
 {
-  config = mkIf (any (fs: fs == "ecryptfs") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.ecryptfs or false) {
     system.fsPackages = [ pkgs.ecryptfs ];
     security.wrappers = {
       "mount.ecryptfs_private" =

nixos/modules/tasks/filesystems/erofs.nix

···
 
 let
 
-  inInitrd = lib.any (fs: fs == "erofs") config.boot.initrd.supportedFilesystems;
-  inSystem = lib.any (fs: fs == "erofs") config.boot.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.erofs or false;
+  inSystem = config.boot.supportedFilesystems.erofs or false;
 
 in
 

nixos/modules/tasks/filesystems/exfat.nix

···
 with lib;
 
 {
-  config = mkIf (any (fs: fs == "exfat") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.exfat or false) {
     system.fsPackages = if config.boot.kernelPackages.kernelOlder "5.7" then [
       pkgs.exfat # FUSE
     ] else [

nixos/modules/tasks/filesystems/ext.nix

···
 
 let
 
-  inInitrd = lib.any (fs: fs == "ext2" || fs == "ext3" || fs == "ext4") config.boot.initrd.supportedFilesystems;
-  inSystem = lib.any (fs: fs == "ext2" || fs == "ext3" || fs == "ext4") config.boot.supportedFilesystems;
+  hasExtX = s: s.ext2 or s.ext3 or s.ext4 or false;
+
+  inInitrd = hasExtX config.boot.initrd.supportedFilesystems;
+  inSystem = hasExtX config.boot.supportedFilesystems;
 
 in
 

nixos/modules/tasks/filesystems/f2fs.nix

···
 with lib;
 
 let
-  inInitrd = any (fs: fs == "f2fs") config.boot.initrd.supportedFilesystems;
-  fileSystems = filter (x: x.fsType == "f2fs") config.system.build.fileSystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.f2fs or false;
 in
 {
-  config = mkIf (any (fs: fs == "f2fs") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.f2fs or false) {
 
     system.fsPackages = [ pkgs.f2fs-tools ];
 

nixos/modules/tasks/filesystems/glusterfs.nix

···
 with lib;
 
 {
-  config = mkIf (any (fs: fs == "glusterfs") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.glusterfs or false) {
 
     system.fsPackages = [ pkgs.glusterfs ];
 

nixos/modules/tasks/filesystems/jfs.nix

···
 with lib;
 
 let
-  inInitrd = any (fs: fs == "jfs") config.boot.initrd.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.jfs or false;
 in
 {
-  config = mkIf (any (fs: fs == "jfs") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.jfs or false) {
 
     system.fsPackages = [ pkgs.jfsutils ];
 

nixos/modules/tasks/filesystems/nfs.nix

···
 
 let
 
-  inInitrd = any (fs: fs == "nfs") config.boot.initrd.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.nfs or false;
 
   nfsStateDir = "/var/lib/nfs";
 
···
 
   ###### implementation
 
-  config = mkIf (any (fs: fs == "nfs" || fs == "nfs4") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.nfs or config.boot.supportedFilesystems.nfs4 or false) {
 
     services.rpcbind.enable = true;
 

nixos/modules/tasks/filesystems/ntfs.nix

···
 with lib;
 
 {
-  config = mkIf (any (fs: fs == "ntfs" || fs == "ntfs-3g") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.ntfs or config.boot.supportedFilesystems.ntfs-3g or false) {
 
     system.fsPackages = [ pkgs.ntfs3g ];
 

nixos/modules/tasks/filesystems/reiserfs.nix

···
 
 let
 
-  inInitrd = any (fs: fs == "reiserfs") config.boot.initrd.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.reiserfs or false;
 
 in
 
 {
-  config = mkIf (any (fs: fs == "reiserfs") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.reiserfs or false) {
 
     system.fsPackages = [ pkgs.reiserfsprogs ];
 

nixos/modules/tasks/filesystems/squashfs.nix

···
 
 let
 
-  inInitrd = lib.any (fs: fs == "squashfs") config.boot.initrd.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.squashfs or false;
 
 in
 

nixos/modules/tasks/filesystems/sshfs.nix

···
 { config, lib, pkgs, ... }:
 
 {
-  config = lib.mkIf (lib.any (fs: fs == "sshfs" || fs == "fuse.sshfs") config.boot.supportedFilesystems) {
-    system.fsPackages = [ pkgs.sshfs ];
-  };
+  config = lib.mkIf
+    (config.boot.supportedFilesystems.sshfs
+      or config.boot.supportedFilesystems."fuse.sshfs"
+      or false)
+    {
+      system.fsPackages = [ pkgs.sshfs ];
+    };
 }

nixos/modules/tasks/filesystems/unionfs-fuse.nix

···
 {
   config = lib.mkMerge [
 
-    (lib.mkIf (lib.any (fs: fs == "unionfs-fuse") config.boot.initrd.supportedFilesystems) {
+    (lib.mkIf (config.boot.initrd.supportedFilesystems.unionfs-fuse or false) {
       boot.initrd.kernelModules = [ "fuse" ];
 
       boot.initrd.extraUtilsCommands = lib.mkIf (!config.boot.initrd.systemd.enable) ''
···
       };
     })
 
-    (lib.mkIf (lib.any (fs: fs == "unionfs-fuse") config.boot.supportedFilesystems) {
+    (lib.mkIf (config.boot.supportedFilesystems.unionfs-fuse or false) {
       system.fsPackages = [ pkgs.unionfs-fuse ];
     })
 

nixos/modules/tasks/filesystems/vboxsf.nix

···
 
 let
 
-  inInitrd = any (fs: fs == "vboxsf") config.boot.initrd.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.vboxsf or false;
 
   package = pkgs.runCommand "mount.vboxsf" { preferLocalBuild = true; } ''
     mkdir -p $out/bin
···
 in
 
 {
-  config = mkIf (any (fs: fs == "vboxsf") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.vboxsf or false) {
 
     system.fsPackages = [ package ];
 

nixos/modules/tasks/filesystems/vfat.nix

···
 
 let
 
-  inInitrd = any (fs: fs == "vfat") config.boot.initrd.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.vfat or false;
 
 in
 
 {
-  config = mkIf (any (fs: fs == "vfat") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.vfat or false) {
 
     system.fsPackages = [ pkgs.dosfstools pkgs.mtools ];
 

nixos/modules/tasks/filesystems/xfs.nix

···
 
 let
 
-  inInitrd = any (fs: fs == "xfs") config.boot.initrd.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.xfs or false;
 
 in
 
 {
-  config = mkIf (any (fs: fs == "xfs") config.boot.supportedFilesystems) {
+  config = mkIf (config.boot.supportedFilesystems.xfs or false) {
 
     system.fsPackages = [ pkgs.xfsprogs.bin ];
 

nixos/modules/tasks/filesystems/zfs.nix

···
   clevisDatasets = map (e: e.device) (filter (e: e.device != null && (hasAttr e.device config.boot.initrd.clevis.devices) && e.fsType == "zfs" && (fsNeededForBoot e)) config.system.build.fileSystems);
 
 
-  inInitrd = any (fs: fs == "zfs") config.boot.initrd.supportedFilesystems;
-  inSystem = any (fs: fs == "zfs") config.boot.supportedFilesystems;
+  inInitrd = config.boot.initrd.supportedFilesystems.zfs or false;
+  inSystem = config.boot.supportedFilesystems.zfs or false;
 
   autosnapPkg = pkgs.zfstools.override {
     zfs = cfgZfs.package;

nixos/modules/virtualisation/cri-o.nix

···
 
   crioPackage = pkgs.cri-o.override {
     extraPackages = cfg.extraPackages
-      ++ lib.optional (builtins.elem "zfs" config.boot.supportedFilesystems) config.boot.zfs.package;
+      ++ lib.optional (config.boot.supportedFilesystems.zfs or false) config.boot.zfs.package;
   };
 
   format = pkgs.formats.toml { };

nixos/modules/virtualisation/hyperv-image.nix

···
     boot.growPartition = true;
 
     boot.loader.grub = {
-      version = 2;
       device = "nodev";
       efiSupport = true;
       efiInstallAsRemovable = true;

nixos/modules/virtualisation/linode-config.nix

···
 
       grub = {
         enable = true;
-        version = 2;
         forceInstall = true;
         device = "nodev";
 

nixos/modules/virtualisation/oci-containers.nix

···
       text = ''
         ${cfg.backend} rm -f ${name} || true
         ${optionalString (isValidLogin container.login) ''
+          # try logging in, if it fails, check if image exists locally
           ${cfg.backend} login \
           ${container.login.registry} \
           --username ${container.login.username} \
-          --password-stdin < ${container.login.passwordFile}
+          --password-stdin < ${container.login.passwordFile} \
+          || ${cfg.backend} image inspect ${container.image} >/dev/null \
+          || { echo "image doesn't exist locally and login failed" >&2 ; exit 1; }
         ''}
         ${optionalString (container.imageFile != null) ''
           ${cfg.backend} load -i ${container.imageFile}

nixos/modules/virtualisation/podman/default.nix

···
     extraPackages = cfg.extraPackages
       # setuid shadow
       ++ [ "/run/wrappers" ]
-      ++ lib.optional (builtins.elem "zfs" config.boot.supportedFilesystems) config.boot.zfs.package;
+      ++ lib.optional (config.boot.supportedFilesystems.zfs or false) config.boot.zfs.package;
   });
 
   # Provides a fake "docker" binary mapping to podman

nixos/modules/virtualisation/vmware-image.nix

···
     boot.growPartition = true;
 
     boot.loader.grub = {
-      version = 2;
       device = "nodev";
       efiSupport = true;
       efiInstallAsRemovable = true;

nixos/tests/installer.nix

···
             curl
           ]
           ++ optionals (bootLoader == "grub") (let
-            zfsSupport = lib.any (x: x == "zfs")
-              (extraInstallerConfig.boot.supportedFilesystems or []);
+            zfsSupport = extraInstallerConfig.boot.supportedFilesystems.zfs or false;
           in [
             (pkgs.grub2.override { inherit zfsSupport; })
             (pkgs.grub2_efi.override { inherit zfsSupport; })

pkgs/applications/audio/go-musicfox/default.nix

···
 
 buildGoModule rec {
   pname = "go-musicfox";
-  version = "4.3.0";
+  version = "4.3.1";
 
   src = fetchFromGitHub {
     owner = "go-musicfox";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-JDR3D3tILT0q9jqcZmbfQC3yn7cmaSL/GEpCguqCFXI=";
+    hash = "sha256-QZHuQAOnthSm7Kb82i3NUWTnKk+9OMHV5vzOU72inX0=";
   };
 
   deleteVendor = true;
 
-  vendorHash = "sha256-ILO4v4ii1l9JokXG7R3vuN7i5hDi/hLHTFiClA2vdf0=";
+  vendorHash = "sha256-6DeoxpjVfykBI3fJAJpMZwJ4VTooIbxGpk5+SW198hU=";
 
   subPackages = [ "cmd/musicfox.go" ];
 

pkgs/applications/audio/kid3/default.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "kid3";
-  version = "3.9.4";
+  version = "3.9.5";
 
   src = fetchurl {
     url = "mirror://kde/stable/kid3/${finalAttrs.version}/kid3-${finalAttrs.version}.tar.xz";
-    hash = "sha256-xBCWDpYiXeChxIiMPqHG3CyiRau2kUdDJtzcPtvWpSA=";
+    hash = "sha256-pCT+3eNcF247RDNEIqrUOEhBh3LaAgdR0A0IdOXOgUU=";
   };
 
   nativeBuildInputs = [

pkgs/applications/audio/snapcast/default.nix

···
 { stdenv, lib, fetchFromGitHub, fetchpatch, cmake, pkg-config
-, alsa-lib, asio, avahi, boost179, flac, libogg, libvorbis, soxr
+, alsa-lib, asio, avahi, boost179, flac, libogg, libvorbis, libopus, soxr
 , IOKit, AudioToolbox
 , aixlog, popl
 , pulseaudioSupport ? false, libpulseaudio
···
   # not needed
   buildInputs = [
     boost179
-    asio avahi flac libogg libvorbis
+    asio avahi flac libogg libvorbis libopus
     aixlog popl soxr
   ] ++ lib.optional pulseaudioSupport libpulseaudio
   ++ lib.optional stdenv.isLinux alsa-lib

pkgs/applications/blockchains/ton/default.nix

···
 , pkg-config
 , gperf
 , libmicrohttpd
+, libsodium
 , openssl
 , readline
+, secp256k1
 , zlib
 , nix-update-script
 }:
 
 stdenv.mkDerivation rec {
   pname = "ton";
-  version = "2023.10";
+  version = "2024.01";
 
   src = fetchFromGitHub {
     owner = "ton-blockchain";
     repo = "ton";
     rev = "v${version}";
-    sha256 = "sha256-K1RhhW7EvwYV7/ng3NPjSGdHEQvJZ7K97YXd7s5wghc=";
+    hash = "sha256-nZ7yel+lTNO5zFzN711tLwAvqpf5qaYOxERwApnMVOs=";
     fetchSubmodules = true;
   };
 
···
   buildInputs = [
     gperf
     libmicrohttpd
+    libsodium
     openssl
     readline
+    secp256k1
     zlib
   ];
 
   passthru.updateScript = nix-update-script { };
 
   meta = with lib; {
+    # The build fails on darwin as:
+    #   error: aligned allocation function of type 'void *(std::size_t, std::align_val_t)' is only available on macOS 10.13 or newer
+    broken = stdenv.isDarwin;
     description = "A fully decentralized layer-1 blockchain designed by Telegram";
     homepage = "https://ton.org/";
     changelog = "https://github.com/ton-blockchain/ton/blob/v${version}/Changelog.md";

pkgs/applications/editors/emacs/elisp-packages/elpa-packages.nix

···
         ];
 
         buildInputs = [
-          pkgs.gnatcoll-xref
+          pkgs.gnatPackages.gnatcoll-xref
         ];
 
         buildPhase = ''

pkgs/applications/editors/neovim/build-neovim-plugin.nix

···
           nativeBuildInputs = oa.nativeBuildInputs or [] ++ [
             lua.pkgs.luarocksMoveDataFolder
           ];
+          version = "${originalLuaDrv.version}-unstable-${oa.version}";
         }));
     in
       finalDrv

pkgs/applications/editors/notepad-next/default.nix

···
 
 mkDerivation rec {
   pname = "notepad-next";
-  version = "0.6.4";
+  version = "0.7";
 
   src = fetchFromGitHub {
     owner = "dail8859";
     repo = "NotepadNext";
     rev = "v${version}";
-    sha256 = "sha256-m8+kM9uz3gJ3kvpgZdoonSvYlh/f1WiGZlB8JKMTXh4=";
+    sha256 = "sha256-I2bS8oT/TGf6fuXpTwOKo2MaUo0jLFIU/DfW9h1toOk=";
     # External dependencies - https://github.com/dail8859/NotepadNext/issues/135
     fetchSubmodules = true;
   };

pkgs/applications/editors/vscode/extensions/default.nix

···
 
       contextmapper.context-mapper-vscode-extension = callPackage ./contextmapper.context-mapper-vscode-extension { };
 
+      continue.continue = buildVscodeMarketplaceExtension {
+        mktplcRef =
+          let
+            sources = {
+              "x86_64-linux" = {
+                arch = "linux-x64";
+                sha256 = "05kh6sf3jv3510q33chf8s5n1kfp9wcm7650va7mcrdkfr9g8ysq";
+              };
+              "x86_64-darwin" = {
+                arch = "darwin-x64";
+                sha256 = "0242h9kq47qvs1xynr5x8dzxkc5pwgb6km0iqpyy9kydg8ng1vp3";
+              };
+              "aarch64-linux" = {
+                arch = "linux-arm64";
+                sha256 = "1qm3f2lh8mi3hnyp2bmx7j2lir6fmbbxkzh6b8zf579khhbapnaz";
+              };
+              "aarch64-darwin" = {
+                arch = "darwin-arm64";
+                sha256 = "18w22z1c5qgkpw2zlwmi9gs9dx1pcm51f0r8my7ynnvgl6mp12sg";
+              };
+            };
+          in
+          {
+            name = "continue";
+            publisher = "Continue";
+            version = "0.8.12";
+          } // sources.${stdenv.system};
+        nativeBuildInputs = [
+          autoPatchelfHook
+        ];
+        buildInputs = [
+          stdenv.cc.cc.lib
+        ];
+        postInstall = ''
+          cd "$out/$installPrefix"
+          substituteInPlace "out/extension.js" \
+            --replace-fail 'await showTutorial();' '//await showTutorial();'
+        '';
+        meta = {
+          description = "Open-source autopilot for software development - bring the power of ChatGPT to your IDE";
+          downloadPage = "https://marketplace.visualstudio.com/items?itemName=Continue.continue";
+          homepage = "https://github.com/continuedev/continue";
+          license = lib.licenses.asl20;
+          maintainers = [ lib.maintainers.raroh73 ];
+          platforms = [ "x86_64-linux" "x86_64-darwin" "aarch64-darwin" "aarch64-linux" ];
+        };
+      };
+
       coolbear.systemd-unit-file = buildVscodeMarketplaceExtension {
         mktplcRef = {
           publisher = "coolbear";

pkgs/applications/emulators/bsnes/ares/default.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "ares";
-  version = "135";
+  version = "136";
 
   src = fetchFromGitHub {
     owner = "ares-emulator";
     repo = "ares";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-SZhsMKjNxmT2eHsXAZcyMGoMhwWGgvXpDeZGGVn58Sc=";
+    hash = "sha256-Hks/MWusPiBVdb5L+53qtR6VmXG/P4rDzsvHxLeA8Do=";
   };
 
   patches = [

pkgs/applications/graphics/upscayl/default.nix

···
   lib,
 }: let
   pname = "upscayl";
-  version = "2.9.8";
+  version = "2.9.9";
 
   src = fetchurl {
     url = "https://github.com/upscayl/upscayl/releases/download/v${version}/upscayl-${version}-linux.AppImage";
-    hash = "sha256-hLK9AX87WbJdKTV/rzEzNeaUWeDz1+bvp/R2LkjHp+w=";
+    hash = "sha256-33jJRMvRQxL7rPJ6VigEKcDhge46CAA0jJUOhzEyWzA=";
   };
 
   appimageContents = appimageTools.extractType2 {

pkgs/applications/kde/kcachegrind.nix

···
   mkDerivation, lib,
   extra-cmake-modules, kdoctools,
   karchive, ki18n, kio, perl, python3, php, qttools,
-  kdbusaddons
+  kdbusaddons, makeBinaryWrapper, graphviz
 }:
 
 mkDerivation {
···
     license = with lib.licenses; [ gpl2 ];
     maintainers = with lib.maintainers; [ orivej ];
   };
-  nativeBuildInputs = [ extra-cmake-modules kdoctools ];
+  nativeBuildInputs = [ extra-cmake-modules kdoctools makeBinaryWrapper ];
   buildInputs = [ karchive ki18n kio perl python3 php qttools kdbusaddons ];
+  postInstall = ''
+    wrapProgram $out/bin/kcachegrind \
+      --suffix PATH : "${lib.makeBinPath [ graphviz ]}"
+  '';
 }

pkgs/applications/misc/blender/default.nix

···
-{ config, stdenv, lib, fetchurl, fetchzip, boost, cmake, ffmpeg, gettext, glew
+{ config, stdenv, lib, fetchurl, fetchzip, fetchpatch, boost, cmake, ffmpeg, gettext, glew
 , libepoxy, libXi, libX11, libXext, libXrender
 , libjpeg, libpng, libsamplerate, libsndfile
 , libtiff, libwebp, libGLU, libGL, openal, opencolorio, openexr, openimagedenoise, openimageio, openjpeg, python310Packages
···
 
   patches = [
     ./draco.patch
+    (fetchpatch {
+      url = "https://projects.blender.org/blender/blender/commit/cf4365e555a759d5b3225bce77858374cb07faad.diff";
+      hash = "sha256-Nypd04yFSHYa7RBa8kNmoApqJrU4qpaOle3tkj44d4g=";
+    })
   ] ++ lib.optional stdenv.isDarwin ./darwin.patch;
 
   nativeBuildInputs =

pkgs/applications/misc/gimoji/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "gimoji";
-  version = "0.7.3";
+  version = "0.7.6";
 
   src = fetchFromGitHub {
     owner = "zeenix";
     repo = "gimoji";
     rev = version;
-    hash = "sha256-xQ02jmPuu1IHkQCCJn2FVPcJRbwN+k8FhsZyDX0oHaw=";
+    hash = "sha256-ipsEFZGC3JYOeNVI4AUb2c/9tt+TTIbeXuJ15ShEH6U=";
   };
 
-  cargoHash = "sha256-DSLIH6swVQXHrqKBxlrhNTG5maRmUi6Ndmuuv0Vo3Ak=";
+  cargoHash = "sha256-786OPEaIHQtgUHlkjLprKfJ7VoeSW+IzHto3XXZ6Fu8=";
 
   buildInputs = lib.optionals stdenv.isDarwin [
     darwin.apple_sdk.frameworks.AppKit

pkgs/applications/misc/yubioath-flutter/default.nix

···
 
 flutter.buildFlutterApplication rec {
   pname = "yubioath-flutter";
-  version = "6.3.1";
+  version = "6.4.0";
 
   src = fetchFromGitHub {
     owner = "Yubico";
     repo = "yubioath-flutter";
     rev = version;
-    hash = "sha256-XgRIX2Iv5niJw2NSBPwM0K4uF5sPj9c+Xj4oHtAQSbU=";
+    hash = "sha256-aXUnmKEUCi0rsVr3HVhEk6xa1z9HMsH+0AIY531hqiU=";
   };
 
   passthru.helper = python3.pkgs.callPackage ./helper.nix { inherit src version meta; };
 
   pubspecLock = lib.importJSON ./pubspec.lock.json;
+  gitHashes = {
+    window_manager = "sha256-mLX51nbWFccsAfcqLQIYDjYz69y9wAz4U1RZ8TIYSj0=";
+  };
 
   postPatch = ''
     rm -f pubspec.lock
 
     substituteInPlace linux/CMakeLists.txt \
-      --replace "../build/linux/helper" "${passthru.helper}/libexec/helper"
+      --replace-fail "../build/linux/helper" "${passthru.helper}/libexec/helper"
   '';
 
   preInstall = ''

pkgs/applications/misc/yubioath-flutter/pubspec.lock.json

···
       "dependency": "transitive",
       "description": {
         "name": "build_runner_core",
-        "sha256": "c9e32d21dd6626b5c163d48b037ce906bbe428bc23ab77bcd77bb21e593b6185",
+        "sha256": "4ae8ffe5ac758da294ecf1802f2aff01558d8b1b00616aa7538ea9a8a5d50799",
         "url": "https://pub.dev"
       },
       "source": "hosted",
-      "version": "7.2.11"
+      "version": "7.3.0"
     },
     "built_collection": {
       "dependency": "transitive",
···
       "dependency": "transitive",
       "description": {
         "name": "built_value",
-        "sha256": "c9aabae0718ec394e5bc3c7272e6bb0dc0b32201a08fe185ec1d8401d3e39309",
+        "sha256": "a3ec2e0f967bc47f69f95009bb93db936288d61d5343b9436e378b28a2f830c6",
         "url": "https://pub.dev"
       },
       "source": "hosted",
-      "version": "8.8.1"
+      "version": "8.9.0"
     },
     "characters": {
       "dependency": "transitive",
···
       "dependency": "direct dev",
       "description": {
         "name": "custom_lint",
-        "sha256": "dfb893ff17c83cf08676c6b64df11d3e53d80590978d7c1fb242afff3ba6dedb",
+        "sha256": "f89ff83efdba7c8996e86bb3bad0b759d58f9b19ae4d0e277a386ddd8b481217",
         "url": "https://pub.dev"
       },
       "source": "hosted",
-      "version": "0.5.8"
+      "version": "0.6.0"
     },
     "custom_lint_builder": {
       "dependency": "direct dev",
       "description": {
         "name": "custom_lint_builder",
-        "sha256": "8df6634b38a36a6c6cb74a9c0eb02e9ba0b0ab89b29e38e6daa86e8ed2c6288d",
+        "sha256": "9cdd9987feaa6925ec5f98d64de4fbbb5d94248ff77bbf2489366efad6c4baef",
         "url": "https://pub.dev"
       },
       "source": "hosted",
-      "version": "0.5.8"
+      "version": "0.6.0"
     },
     "custom_lint_core": {
       "dependency": "transitive",
       "description": {
         "name": "custom_lint_core",
-        "sha256": "2b235be098d157e244f18ea905a15a18c16a205e30553888fac6544bbf52f03f",
+        "sha256": "9003a91409c9f1db6e2e50b4870d1d5e802e5923b25f7261bf3cb3e11ea9d4fb",
         "url": "https://pub.dev"
       },
       "source": "hosted",
-      "version": "0.5.8"
+      "version": "0.6.0"
     },
     "dart_style": {
       "dependency": "transitive",
···
       "dependency": "direct main",
       "description": {
         "name": "flutter_riverpod",
-        "sha256": "da9591d1f8d5881628ccd5c25c40e74fc3eef50ba45e40c3905a06e1712412d5",
+        "sha256": "4bce556b7ecbfea26109638d5237684538d4abc509d253e6c5c4c5733b360098",
         "url": "https://pub.dev"
       },
       "source": "hosted",
-      "version": "2.4.9"
+      "version": "2.4.10"
     },
     "flutter_test": {
       "dependency": "direct dev",
···
       "dependency": "direct dev",
       "description": {
         "name": "freezed",
-        "sha256": "6c5031daae12c7072b3a87eff98983076434b4889ef2a44384d0cae3f82372ba",
+        "sha256": "57247f692f35f068cae297549a46a9a097100685c6780fe67177503eea5ed4e5",
         "url": "https://pub.dev"
       },
       "source": "hosted",
-      "version": "2.4.6"
+      "version": "2.4.7"
     },
     "freezed_annotation": {
       "dependency": "direct main",
···
       "dependency": "transitive",
       "description": {
         "name": "mime",
-        "sha256": "e4ff8e8564c03f255408decd16e7899da1733852a9110a58fe6d1b817684a63e",
+        "sha256": "2e123074287cc9fd6c09de8336dae606d1ddb88d9ac47358826db698c176a1f2",
         "url": "https://pub.dev"
       },
       "source": "hosted",
-      "version": "1.0.4"
+      "version": "1.0.5"
     },
     "package_config": {
       "dependency": "transitive",
···
       "dependency": "transitive",
       "description": {
         "name": "riverpod",
-        "sha256": "942999ee48b899f8a46a860f1e13cee36f2f77609eb54c5b7a669bb20d550b11",
+        "sha256": "548e2192eb7aeb826eb89387f814edb76594f3363e2c0bb99dd733d795ba3589",
         "url": "https://pub.dev"
       },
       "source": "hosted",
-      "version": "2.4.9"
+      "version": "2.5.0"
     },
     "rxdart": {
       "dependency": "transitive",
···
       "dependency": "direct main",
       "description": {
         "name": "url_launcher",
-        "sha256": "d25bb0ca00432a5e1ee40e69c36c85863addf7cc45e433769d61bed3fe81fd96",
+        "sha256": "c512655380d241a337521703af62d2c122bf7b77a46ff7dd750092aa9433499c",
         "url": "https://pub.dev"
       },
       "source": "hosted",
-      "version": "6.2.3"
+      "version": "6.2.4"
     },
     "url_launcher_android": {
       "dependency": "transitive",
···
     "window_manager": {
       "dependency": "direct main",
       "description": {
-        "name": "window_manager",
-        "sha256": "dcc865277f26a7dad263a47d0e405d77e21f12cb71f30333a52710a408690bd7",
-        "url": "https://pub.dev"
+        "path": ".",
+        "ref": "2272d45bcf46d7e2b452a038906fbc85df3ce83d",
+        "resolved-ref": "2272d45bcf46d7e2b452a038906fbc85df3ce83d",
+        "url": "https://github.com/fdennis/window_manager.git"
       },
-      "source": "hosted",
-      "version": "0.3.7"
+      "source": "git",
+      "version": "0.3.8"
     },
     "xdg_directories": {
       "dependency": "transitive",

pkgs/applications/networking/asn/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "asn";
-  version = "0.75.3";
+  version = "0.76.0";
 
   src = fetchFromGitHub {
     owner = "nitefood";
     repo = "asn";
     rev = "refs/tags/v${version}";
-    hash = "sha256-KOwXOGw6gv8YFTrFFkD6BNKChTIbD2Soy3gvvSzNQgM=";
+    hash = "sha256-pdtRf9VKEdNg1UeYSaLNLm9O057dT+n5g3Dd0bcP4EI=";
   };
 
   nativeBuildInputs = [

pkgs/applications/networking/cloudflared/default.nix

···
 
 buildGoModule rec {
   pname = "cloudflared";
-  version = "2024.2.0";
+  version = "2024.2.1";
 
   src = fetchFromGitHub {
     owner = "cloudflare";
     repo = "cloudflared";
     rev = "refs/tags/${version}";
-    hash = "sha256-jcIHpRHcAgzzSKvZH9SLfu5Ake3zCgsSw1iv64yXW2E=";
+    hash = "sha256-aSAwDz7QSYbHfDA+/usGh7xCxSq+kBTB3eqMBf5XEa8=";
   };
 
   vendorHash = null;

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

···
 
 buildGoModule rec {
   pname = "arkade";
-  version = "0.11.1";
+  version = "0.11.2";
 
   src = fetchFromGitHub {
     owner = "alexellis";
     repo = "arkade";
     rev = version;
-    hash = "sha256-DsKc+AT+0vIaJftBFLqVXx/CJRNNgE/vzSxlHkCSJaI=";
+    hash = "sha256-G8zWPz5pTDjfZJ8DtY1DQRGYMOsGhNXWZEgFYKM/y6I=";
   };
 
   CGO_ENABLED = 0;

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

···
 
 stdenv.mkDerivation rec {
   pname = "kubetail";
-  version = "1.6.18";
+  version = "1.6.19";
 
   src = fetchFromGitHub {
     owner = "johanhaleby";
     repo = "kubetail";
     rev = version;
-    sha256 = "sha256-Gde5thEpMX3h0e1eoC8SeDdkZfa02CmQf3ELLMeEWGU=";
+    sha256 = "sha256-s+rz30VWG4RijeJuRYEhCmgFDjaxJ+4twgXrGkNc5c8=";
   };
 
   nativeBuildInputs = [ installShellFiles makeWrapper ];

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

···
 
 buildGoModule rec {
   pname = "vcluster";
-  version = "0.18.1";
+  version = "0.19.1";
 
   src = fetchFromGitHub {
     owner = "loft-sh";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-TJjMB7x8MOlr3GexsnOZBFPJovVkf4ByRn1aGprvZFQ=";
+    hash = "sha256-W9BSLGUrW8Us+yYQLIz3oY8JKJSo43cL+oWQQf3xWJE=";
   };
 
   vendorHash = null;

pkgs/applications/networking/instant-messengers/discord/default.nix

···
     if stdenv.isLinux then {
       stable = "0.0.43";
       ptb = "0.0.71";
-      canary = "0.0.278";
+      canary = "0.0.282";
       development = "0.0.13";
     } else {
       stable = "0.0.294";
···
       };
       canary = fetchurl {
         url = "https://dl-canary.discordapp.net/apps/linux/${version}/discord-canary-${version}.tar.gz";
-        hash = "sha256-ypnw/CDY02jD8xLpJvS4Y7GjahgvUhcmV7zSDaVkNpk=";
+        hash = "sha256-+Ijl/yPa7DVzVKOWTxCu6FxIsschIqYa+tYBnnKdCBA=";
       };
       development = fetchurl {
         url = "https://dl-development.discordapp.net/apps/linux/${version}/discord-development-${version}.tar.gz";

pkgs/applications/networking/instant-messengers/mattermost-desktop/default.nix

···
 { lib
 , stdenv
 , fetchurl
-, electron_26
+, electron_27
 , makeWrapper
 }:
 
 let
 
   pname = "mattermost-desktop";
-  version = "5.5.1";
+  version = "5.6.0";
 
   srcs = {
     "x86_64-linux" = {
       url = "https://releases.mattermost.com/desktop/${version}/${pname}-${version}-linux-x64.tar.gz";
-      hash = "sha256-bRiO5gYM7nrnkbHBP3B9zAK2YV5POkc3stEsbZJ48VA=";
+      hash = "sha256-KUF/zH18X+RS8AICBv53JTBpcaokzo92psyoQNmLF/Q=";
     };
 
     "aarch64-linux" = {
       url = "https://releases.mattermost.com/desktop/${version}/${pname}-${version}-linux-arm64.tar.gz";
-      hash = "sha256-Z4U6Jbwasra69QPHJ9/7WwMSxh0O9r4QIe/xC3WRf4w=";
+      hash = "sha256-Zl5PalAles39qSMtt1cytfu4Mheud4+8TTkt7Ohdf/o=";
     };
   };
 
···
     substituteInPlace $out/share/applications/Mattermost.desktop \
       --replace /share/mattermost-desktop/mattermost-desktop /bin/mattermost-desktop
 
-    makeWrapper ${electron_26}/bin/electron $out/bin/${pname} \
+    makeWrapper '${lib.getExe electron_27}' $out/bin/${pname} \
       --add-flags $out/share/${pname}/app.asar
 
     runHook postInstall

pkgs/applications/networking/pyload-ng/default.nix

···
   postPatch = ''
     # relax version bounds
     sed -i 's/\([A-z0-9]*\)~=.*$/\1/' setup.cfg
-    # not sure what Flask-Session2 is but flask-session works just fine
-    sed -i '/Flask-Session2/d' setup.cfg
   '';
 
   propagatedBuildInputs = with python3.pkgs; [

pkgs/applications/networking/sync/storj-uplink/default.nix

···
 
 buildGoModule rec {
   pname = "storj-uplink";
-  version = "1.96.2";
+  version = "1.98.2";
 
   src = fetchFromGitHub {
     owner = "storj";
     repo = "storj";
     rev = "v${version}";
-    hash = "sha256-mQIrXDEfMMrubQyn90eu0k3isvnpaF237Tpd84HhUfU=";
+    hash = "sha256-XnTrQIDUHdW9HwnYRigGFMGmcSCBhdoTXT4xlMCMeCw=";
   };
 
   subPackages = [ "cmd/uplink" ];
 
-  vendorHash = "sha256-cUhdl0jqgkA89NeOdFSifR5LsTjeYifOXqBu3qCAovk=";
+  vendorHash = "sha256-n7exLjiDyvnoKAKnJXo1Ag+jh1Ccb2eA3Yv5fg7gkDk=";
 
   ldflags = [ "-s" "-w" ];
 

pkgs/applications/networking/sync/wdt/default.nix

···
 
 stdenv.mkDerivation {
   pname = "wdt";
-  version = "unstable-2023-12-01";
+  version = "unstable-2024-02-05";
 
   src = fetchFromGitHub {
     owner = "facebook";
     repo = "wdt";
-    rev = "66f17af009ef6eaf2707bb8bb511ba6bcf3d9bbe";
-    sha256 = "sha256-ucnFcpH9Duru35kRT769zMX2BMqufZJopd2srKPJkrU=";
+    rev = "d94b2d5df6f1c803f9f3b8ed9247b752fa853865";
+    sha256 = "sha256-9TeJbZZq9uQ6KaEBFGDyIGcXgxi2y1aj55vxv5dAIzw=";
   };
 
   nativeBuildInputs = [ cmake ];

pkgs/applications/office/paperless-ngx/default.nix

···
 }:
 
 let
-  version = "2.5.2";
+  version = "2.5.3";
 
   src = fetchFromGitHub {
     owner = "paperless-ngx";
     repo = "paperless-ngx";
     rev = "refs/tags/v${version}";
-    hash = "sha256-v6k9clKNBNb2MQp0BTrUL9zfY6SUKfzaaOycmV8RKyk=";
+    hash = "sha256-fZ5grVZjCVkCH6doeqBLHPh9mPvHkiz+QXi/OyoJhR4=";
   };
 
   python = python3;
···
   ];
 
   propagatedBuildInputs = with python.pkgs; [
-    amqp
-    anyio
-    asgiref
-    async-timeout
-    attrs
-    autobahn
-    automat
-    billiard
     bleach
-    celery
-    certifi
-    cffi
+    channels
     channels-redis
-    channels
-    charset-normalizer
-    click
-    click-didyoumean
-    click-plugins
-    click-repl
-    coloredlogs
     concurrent-log-handler
-    constantly
-    cryptography
     dateparser
+    django
     django-allauth
     django-auditlog
     django-celery-results
···
     django-filter
     django-guardian
     django-multiselectfield
-    django
-    djangorestframework-guardian2
     djangorestframework
+    djangorestframework-guardian2
     drf-writable-nested
     filelock
     flower
     gotenberg-client
     gunicorn
-    h11
-    h2
-    hiredis
-    httptools
-    httpx
-    humanfriendly
-    humanize
-    hyperlink
-    idna
     imap-tools
-    img2pdf
-    incremental
-    inotify-simple
     inotifyrecursive
-    joblib
     langdetect
-    lxml
-    msgpack
     mysqlclient
     nltk
     ocrmypdf
-    packaging
     pathvalidate
     pdf2image
-    pikepdf
-    pillow
-    pluggy
-    portalocker
-    prompt-toolkit
     psycopg2
-    pyasn1-modules
-    pyasn1
-    pycparser
-    pyopenssl
     python-dateutil
     python-dotenv
+    python-gnupg
     python-ipware
     python-magic
-    python-gnupg
-    pytz
-    pyyaml
     pyzbar
     rapidfuzz
     redis
-    regex
-    reportlab
-    requests
     scikit-learn
-    scipy
     setproctitle
-    service-identity
-    sniffio
-    sqlparse
-    threadpoolctl
     tika-client
-    tornado
     tqdm
-    twisted
-    txaio
-    tzdata
-    tzlocal
-    urllib3
     uvicorn
-    uvloop
-    vine
     watchdog
-    watchfiles
-    wcwidth
-    webencodings
-    websockets
     whitenoise
     whoosh
-    zipp
-    zope-interface
     zxing-cpp
   ]
   ++ redis.optional-dependencies.hiredis
-  ++ twisted.optional-dependencies.tls
   ++ uvicorn.optional-dependencies.standard;
 
   postBuild = ''
···
     pytest-rerunfailures
     pytest-xdist
     pytestCheckHook
-    reportlab
   ];
 
   pytestFlagsArray = [
···
 
     # Disable unneeded code coverage test
     substituteInPlace src/setup.cfg \
-      --replace "--cov --cov-report=html --cov-report=xml" ""
+      --replace-fail "--cov --cov-report=html --cov-report=xml" ""
   '';
 
   disabledTests = [

pkgs/applications/radio/srsran/default.nix

···
     zeromq
   ];
 
+  cmakeFlags = [ "-DENABLE_WERROR=OFF" ];
+
   meta = with lib; {
     homepage = "https://www.srslte.com/";
     description = "Open-source 4G and 5G software radio suite.";

pkgs/applications/science/biology/sortmerna/default.nix

···
     substituteInPlace src/sortmerna/CMakeLists.txt \
       --replace "target_link_libraries(sortmerna" \
         "target_link_libraries(sortmerna Threads::Threads"
+
+    # Fix gcc-13 build by adding missing <cstdint> includes:
+    #   https://github.com/sortmerna/sortmerna/issues/412
+    sed -e '1i #include <cstdint>' -i include/kseq_load.hpp
   '';
 
   meta = with lib; {

pkgs/applications/science/machine-learning/starspace/default.nix

···
   '';
 
   meta = with lib; {
+    # Does not build against gcc-13. No development activity upstream
+    # for past few years.
+    broken = true;
     description = "General-purpose neural model for efficient learning of entity embeddings";
     homepage = "https://ai.facebook.com/tools/starspace/";
     license = licenses.mit;

pkgs/applications/version-management/git-cliff/default.nix

···
 , fetchFromGitHub
 , rustPlatform
 , Security
+, SystemConfiguration
 }:
 
 rustPlatform.buildRustPackage rec {
   pname = "git-cliff";
-  version = "1.4.0";
+  version = "2.0.4";
 
   src = fetchFromGitHub {
     owner = "orhun";
     repo = "git-cliff";
     rev = "v${version}";
-    hash = "sha256-OK2eoWlqlpf/X8EGMnWTv9Gs5FkYvW5rmQDB/Mkbp60=";
+    hash = "sha256-0ReMn37sYpS5uX9Nem7M9LthAvGNdJaAob+tEnjIrMw=";
   };
 
-  cargoHash = "sha256-gtkpZKOaG5p79uJ9cbbGdiOX57bDFTf2/Bd8+WToJrw=";
+  cargoHash = "sha256-xDIXXHoykEtRzWm5NDE1rcFgC4iFxhUPgwlvaoHmV6Y=";
 
   # attempts to run the program on .git in src which is not deterministic
   doCheck = false;
 
   buildInputs = lib.optionals stdenv.isDarwin [
-    Security
+    Security SystemConfiguration
   ];
 
   meta = with lib; {

pkgs/applications/version-management/git-credential-oauth/default.nix

···
 
 buildGoModule rec {
   pname = "git-credential-oauth";
-  version = "0.11.0";
+  version = "0.11.1";
 
   src = fetchFromGitHub {
     owner = "hickford";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-Zxdd4JhSoaAFx8neZqdOZSZEOTtupZHnX+5ziYxbw6s=";
+    hash = "sha256-bqyoAAqli0L6Kf+W1sTh2vmmfaIj2OdpQyvQZnYOWWA=";
   };
 
   ldflags = [

pkgs/applications/version-management/git-ignore/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "git-ignore";
-  version = "1.3.1";
+  version = "1.3.3";
 
   src = fetchFromGitHub {
     owner = "sondr3";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-kfc4LIFjLMltCn3BPaEfxc/yOZxFjYioyobTQZN/RmY=";
+    hash = "sha256-OVKRNj3tRi/PGY1m4rdpmH87laYzTkCiwoBc3txVJ3U=";
   };
 
-  cargoHash = "sha256-HoW10XzWIjxsqoKVKQkMf5in7pOODGnUM0cRZP1OJpg=";
+  cargoHash = "sha256-dAQKL+sMThpTqBoN5MZvm8tQUJhaSH7lT8DwbjzFq40=";
 
   nativeBuildInputs = [
     installShellFiles

pkgs/applications/video/kodi/addons/youtube/default.nix

···
 buildKodiAddon rec {
   pname = "youtube";
   namespace = "plugin.video.youtube";
-  version = "7.0.2.2";
+  version = "7.0.3";
 
   src = fetchFromGitHub {
     owner = "anxdpanic";
     repo = "plugin.video.youtube";
     rev = "v${version}";
-    hash = "sha256-BUeE/8oQYBiq4XgIp4nv0hjEQz3nnkDWCnAf4kpptwk=";
+    hash = "sha256-dD9jl/W8RDfYHv13TBniOeRyc4cocj8160BHWz3MKlE=";
   };
 
   propagatedBuildInputs = [

pkgs/applications/video/vokoscreen-ng/default.nix

···
-{ lib
-, mkDerivation
-, fetchFromGitHub
-, pkg-config
-, qmake
-, qttools
-, gstreamer
-, libX11
-, pulseaudio
-, qtbase
-, qtmultimedia
-, qtx11extras
-
+{ fetchFromGitHub
+, gst_all_1
+, gst-plugins-bad
 , gst-plugins-base
 , gst-plugins-good
-, gst-plugins-bad
 , gst-plugins-ugly
-, wayland
+, gstreamer
+, lib
+, libX11
 , pipewire
-, wrapQtAppsHook
+, pkg-config
+, pulseaudio
+, qt6
+, stdenv
+, wayland
 }:
 
-mkDerivation rec {
+stdenv.mkDerivation rec {
   pname = "vokoscreen-ng";
-  version = "3.8.0";
+  version = "4.0.0";
 
   src = fetchFromGitHub {
     owner = "vkohaupt";
     repo = "vokoscreenNG";
     rev = version;
-    sha256 = "sha256-4tQ/fLaAbjfc3mt2qJsW9scku/CGUs74SehDaZgLPj4=";
+    hash = "sha256-Y6+R18Gf3ShqhsmZ4Okx02fSOOyilS6iKU5FW9wpxvY=";
   };
 
   qmakeFlags = [ "src/vokoscreenNG.pro" ];
 
-  nativeBuildInputs = [ qttools pkg-config qmake wrapQtAppsHook ];
+  nativeBuildInputs = [ qt6.qttools pkg-config qt6.qmake qt6.wrapQtAppsHook ];
   buildInputs = [
-    gstreamer
+    gst_all_1.gstreamer
     libX11
     pulseaudio
-    qtbase
-    qtmultimedia
-    qtx11extras
+    qt6.qtbase
+    qt6.qtmultimedia
     wayland
     pipewire
-    gst-plugins-base
-    gst-plugins-good
-    gst-plugins-bad
-    gst-plugins-ugly
+    gst_all_1.gst-plugins-base
+    gst_all_1.gst-plugins-good
+    gst_all_1.gst-plugins-bad
+    gst_all_1.gst-plugins-ugly
   ];
 
   postPatch = ''
···
     description = "User friendly Open Source screencaster for Linux and Windows";
     license = licenses.gpl2Plus;
     homepage = "https://github.com/vkohaupt/vokoscreenNG";
-    maintainers = with maintainers; [ shamilton ];
+    maintainers = with maintainers; [ shamilton dietmarw ];
     platforms = platforms.linux;
     mainProgram = "vokoscreenNG";
   };

pkgs/build-support/cc-wrapper/default.nix

···
 
       # this symlink points to the unwrapped gnat's output "out". It is used by
       # our custom gprconfig compiler description to find GNAT's ada runtime. See
-      # ../../development/tools/build-managers/gprbuild/{boot.nix, nixpkgs-gnat.xml}
+      # ../../development/ada-modules/gprbuild/{boot.nix, nixpkgs-gnat.xml}
       ln -sf ${cc} $out/nix-support/gprconfig-gnat-unwrapped
     ''
 

pkgs/by-name/ar/arcticons-sans/package.nix

···
+{ lib
+, stdenvNoCC
+, fetchzip
+}:
+
+stdenvNoCC.mkDerivation (finalAttrs: {
+  pname = "arcticons-sans";
+  version = "0.580";
+
+  src = fetchzip {
+    hash = "sha256-BRyYHOuz7zxD1zD4L4DmI9dFhGePmGFDqYmS0DIbvi8=";
+    url = "https://github.com/arcticons-team/arcticons-font/archive/refs/tags/${finalAttrs.version}.zip";
+  };
+
+  installPhase = ''
+    runHook preInstall
+
+    install -D -m444 -t $out/share/fonts/opentype $src/*.otf
+
+    runHook postInstall
+  '';
+
+  meta = {
+    description = "Arcticons Sans";
+    homepage = "https://github.com/arcticons-team/arcticons-font";
+    license = lib.licenses.ofl;
+    maintainers = with lib.maintainers; [ asininemonkey ];
+  };
+})

pkgs/by-name/bo/bonsai/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "bonsai";
-  version = "1.0.2";
+  version = "1.1.0";
 
   src = fetchFromSourcehut {
     owner = "~stacyharper";
     repo = "bonsai";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-Yosf07KUOQv4O5111tLGgI270g0KVGwzdTPtPOsTcP8=";
+    hash = "sha256-Wsr76OQOIqRPCx/8GK9NovxxPZ3dEP8pSo8wgMK1Hfo=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/gh/gh-poi/package.nix

···
+{ lib
+, fetchFromGitHub
+, buildGoModule
+}:
+
+buildGoModule rec {
+  pname = "gh-poi";
+  version = "0.9.8";
+
+  src = fetchFromGitHub {
+    owner = "seachicken";
+    repo = "gh-poi";
+    rev = "v${version}";
+    hash = "sha256-QpUZxho9hzmgbCFgNxwwKi6hhfyqc4b/JYKH3rP4Eb8=";
+  };
+
+  ldflags = [ "-s" "-w" ];
+
+  vendorHash = "sha256-D/YZLwwGJWCekq9mpfCECzJyJ/xSlg7fC6leJh+e8i0=";
+
+  # Skip checks because some of test suites require fixture.
+  # See: https://github.com/seachicken/gh-poi/blob/v0.9.8/.github/workflows/contract-test.yml#L28-L29
+  doCheck = false;
+
+  meta = with lib; {
+    changelog = "https://github.com/seachicken/gh-poi/releases/tag/${src.rev}";
+    description = "GitHub CLI extension to safely clean up your local branches";
+    homepage = "https://github.com/seachicken/gh-poi";
+    license = licenses.mit;
+    maintainers = with maintainers; [ aspulse ];
+    mainProgram = "gh-poi";
+  };
+}

pkgs/by-name/he/helix-gpt/pin.json

···
 {
-  "version": "0.27",
-  "srcHash": "sha256-sGkK3SaQmzprgTiABgKfRZ3pUNFZNrt/8aNANH1RES8=",
+  "version": "0.28",
+  "srcHash": "sha256-vOXY8B5CRCEQX/NnBVNwmyRKSeDSliurClRPiJIAD3Y=",
   "x86_64-linux": "sha256-h6wGkOfSbB8Rwm7eFvcowDdH1RdS6eFaxgf+SdYvYt8=",
-  "x86_64-darwin": "sha256-A8T1FNPS1CguSmRyGl+i0o/DGy+LyTnKYKdNc8kTKS8=",
-  "aarch64-darwin": "sha256-A8T1FNPS1CguSmRyGl+i0o/DGy+LyTnKYKdNc8kTKS8="
+  "x86_64-darwin": "sha256-lkURZs6nQpsZ7SGX+eLoBEXa9VdTQP795iHAGYyRaVs=",
+  "aarch64-darwin": "sha256-lkURZs6nQpsZ7SGX+eLoBEXa9VdTQP795iHAGYyRaVs="
 }

pkgs/by-name/lu/lubelogger/package.nix

···
 
 buildDotnetModule rec {
   pname = "lubelogger";
-  version = "1.2.1";
+  version = "1.2.2";
 
   src = fetchFromGitHub {
     owner = "hargata";
     repo = "lubelog";
     rev = "v${version}";
-    hash = "sha256-YxP8XmjYqxuTA2fIV1q7GBsrWPtLr02KkFl4UUNJ2p8=";
+    hash = "sha256-eH8BWTUTzmVTOnn5svSfk8hqf8CjIpQdxoknlkgjVDY=";
   };
 
   projectFile = "CarCareTracker.sln";

pkgs/by-name/oe/oelint-adv/package.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "oelint-adv";
-  version = "4.3.1";
+  version = "4.4.0";
   format = "setuptools";
 
   src = fetchPypi {
     inherit version;
     pname = "oelint_adv";
-    hash = "sha256-N8QNX6JuHVDKBLwGNwBROH8f+tcLrc1Mk21CiiOVHkI=";
+    hash = "sha256-Sg7qn/yZUJEJdMmaGm27kyL+fKkUsZo25eExZPOem40=";
   };
 
   propagatedBuildInputs = with python3.pkgs; [

pkgs/by-name/ou/outfox/package.nix

···
+{ lib
+, stdenv
+, fetchurl
+, autoPatchelfHook
+, alsa-lib
+, freetype
+, libjack2
+, libglvnd
+, libpulseaudio
+, makeDesktopItem
+, makeWrapper
+}:
+
+stdenv.mkDerivation rec {
+  pname = "outfox";
+  version = "0.5.0-pre042";
+
+  src = {
+    i686-linux = fetchurl {
+      url =  "https://github.com/TeamRizu/OutFox/releases/download/OF5.0.0-042/OutFox-alpha-0.5.0-pre042-Linux-14.04-32bit-i386-i386-legacy-date-20231227.tar.gz";
+      sha256 = "sha256-NFjNoqJ7Fq4A7Y0k6oQcWjykV+/b/MiRtJ1p6qlZdjs=";
+    };
+    x86_64-linux = fetchurl {
+      url = "https://github.com/TeamRizu/OutFox/releases/download/OF5.0.0-042/OutFox-alpha-0.5.0-pre042-Linux-22.04-amd64-current-date-20231224.tar.gz";
+      hash = "sha256-dW+g/JYav3rUuI+nHDi6rXu/O5KYiEdk/HH82jgOUnI=";
+    };
+    aarch64-linux = fetchurl {
+      url = "https://github.com/TeamRizu/OutFox/releases/download/OF5.0.0-042/OutFox-alpha-0.5.0-pre042-Raspberry-Pi-Linux-18.04-arm64-arm64v8-modern-date-20231225.tar.gz";
+      hash = "sha256-7Qrq6t8KmUSIK4Rskkxw5l4UZ2vsb9/orzPegHySaJ4=";
+    };
+    armv7l-linux = fetchurl {
+      url = "https://github.com/TeamRizu/OutFox/releases/download/OF5.0.0-042/OutFox-alpha-0.5.0-pre042-Raspberry-Pi-Linux-14.04-arm32-arm32v7-legacy-date-20231227.tar.gz";
+      hash = "sha256-PRp7kuqFBRy7nextTCB+/poc+A9AX2EiQphx6aUfT8E=";
+    };
+  }.${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}");
+
+  nativeBuildInputs = [
+    autoPatchelfHook
+    makeWrapper
+  ];
+
+  buildInputs = [
+    alsa-lib
+    freetype
+    libjack2
+    libglvnd
+    libpulseaudio
+  ];
+
+  desktop = makeDesktopItem {
+    name = "project-outfox";
+    desktopName = "Project OutFox";
+    genericName = "Rhythm game engine";
+    exec = "OutFox";
+    tryExec = "OutFox";
+    categories = [ "Game" ];
+  };
+
+  patchPhase = ''
+    find ./Appearance -type f -executable -exec chmod -x {} \;
+  '';
+
+  installPhase = ''
+    mkdir -p $out/bin $out/share/OutFox $out/share/applications
+    cp -r ./. $out/share/OutFox
+    ln -s ${desktop}/share/applications/project-outfox.desktop $out/share/applications/project-outfox.desktop
+    makeWrapper $out/share/OutFox/OutFox $out/bin/OutFox --argv0
+  '';
+
+  meta = with lib; {
+    description = "A rhythm game engine forked from StepMania";
+    homepage = "https://projectoutfox.com";
+    sourceProvenance = with sourceTypes; [ binaryNativeCode ];
+    license = licenses.unfree;
+    platforms = [ "x86_64-linux" "i686-linux" "aarch64-linux" "armv7l-linux" ];
+    maintainers = with maintainers; [ maxwell-lt ];
+    mainProgram = "OutFox";
+  };
+}

pkgs/by-name/re/renode-dts2repl/package.nix

···
 
 python3.pkgs.buildPythonApplication {
   pname = "renode-dts2repl";
-  version = "unstable-2024-02-19";
+  version = "unstable-2024-02-23";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "antmicro";
     repo = "dts2repl";
-    rev = "d0bf509a04327bfe5a8542fdbcc71cf368bb9ac7";
-    hash = "sha256-era8iyKOk5JzemSWk20ojjtoRsjSA43uzQC1ZFXUkZc=";
+    rev = "ae616f4f6a70a2f497c2a9ce8c9c64b34238e553";
+    hash = "sha256-2Q7hfXf9nCrmHxJ0S8njF5zIgcGXaRPPVogtsPgLLsI=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/sr/srm-cuarzo/package.nix

···
 }:
 stdenv.mkDerivation (self: {
   pname = "srm-cuarzo";
-  version = "0.5.2-1";
+  version = "0.5.3-1";
   rev = "v${self.version}";
-  hash = "sha256-FMd1v0K+H7DlSD0osmWrnuSKqQZxw3RUZq8JwZFm/f4=";
+  hash = "sha256-KRp+rTpiUbOmUPE9vASwTF+c8TDveFnAEqptcGO5luc=";
 
   src = fetchFromGitHub {
     inherit (self) rev hash;

pkgs/by-name/ty/typos-lsp/package.nix

···
 }:
 rustPlatform.buildRustPackage rec {
   pname = "typos-lsp";
-  version = "0.1.12";
+  version = "0.1.13";
 
   src = fetchFromGitHub {
     owner = "tekumara";
     repo = "typos-lsp";
     rev = "refs/tags/v${version}";
-    hash = "sha256-LzemgHVCuLkLaJyyrJhIsOOn+OnYuiJsMSxITNz6R8g=";
+    hash = "sha256-2nNOUeuDDBi7Ak7ATKYyRqmGwebk0JqIdHN6GV+v+aA=";
   };
 
-  cargoHash = "sha256-LFRg/Y/nudrdPw/o3WUH6aM+ThE8N/HII5J0Ikid8GI=";
+  cargoHash = "sha256-hQoxaavR4cefmpr+znXOs1OFJJ83mGk4TidFf13l7Ho=";
 
   # fix for compilation on aarch64
   # see https://github.com/NixOS/nixpkgs/issues/145726

pkgs/by-name/vi/vinegar/package.nix

···
 , xorg
 , wayland
 , vulkan-headers
-, wineWowPackages
+, wine64Packages
 , fetchpatch
 }:
 let
   # wine-staging doesn't support overrideAttrs for now
-  wine = wineWowPackages.stagingFull.overrideDerivation (oldAttrs: {
+  wine = wine64Packages.staging.overrideDerivation (oldAttrs: {
     patches =
-      (oldAttrs.patches or [ ])
+      (oldAttrs.patches or [])
       ++ [
         # upstream issue: https://bugs.winehq.org/show_bug.cgi?id=55604
         # Here are the currently applied patches for Roblox to run under WINE:
         (fetchpatch {
-          name = "vinegar-wine-segrevert.patch";
-          url = "https://raw.githubusercontent.com/flathub/org.vinegarhq.Vinegar/8fc153c492542a522d6cc2dff7d1af0e030a529a/patches/wine/temp.patch";
-          hash = "sha256-AnEBBhB8leKP0xCSr6UsQK7CN0NDbwqhe326tJ9dDjc=";
+          name = "vinegar-wine-segregrevert.patch";
+          url = "https://raw.githubusercontent.com/flathub/org.vinegarhq.Vinegar/e24cb9dfa996bcfeaa46504c0375660fe271148d/patches/wine/segregrevert.patch";
+          hash = "sha256-+3Nld81nG3GufI4jAF6yrWfkJmsSCOku39rx0Hov29c=";
+        })
+        (fetchpatch {
+          name = "vinegar-wine-mouselock.patch";
+          url = "https://raw.githubusercontent.com/flathub/org.vinegarhq.Vinegar/e24cb9dfa996bcfeaa46504c0375660fe271148d/patches/wine/mouselock.patch";
+          hash = "sha256-0AGA4AQbxTL5BGVbm072moav7xVA3zpotYqM8pcEDa4=";
         })
       ];
   });
 in
 buildGoModule rec {
   pname = "vinegar";
-  version = "1.6.1";
+  version = "1.7.3";
 
   src = fetchFromGitHub {
     owner = "vinegarhq";
     repo = "vinegar";
     rev = "v${version}";
-    hash = "sha256-uRdWE5NwRVSuUZyU5B5u5DfJOxu/gUqwM682eORTDOs=";
+    hash = "sha256-aKL+4jw/uMbbvLRCBHstCTrcQ1PTYSCwMNgXTvSvMeY=";
   };
 
-  vendorHash = "sha256-Ex6PRd3rD2jbLXlY36koNvZF3P+gAZTE9hExIfOw9CE=";
+  vendorHash = "sha256-OaMfWecOPQh6quXjYkZLyBDHZ9TINSA7Ue/Y0sz5ZYY=";
 
   nativeBuildInputs = [ pkg-config makeBinaryWrapper ];
   buildInputs = [ libGL libxkbcommon xorg.libX11 xorg.libXcursor xorg.libXfixes wayland vulkan-headers wine ];

pkgs/development/ada-modules/gnatprove/default.nix

···
+{ stdenv
+, lib
+, fetchFromGitHub
+, gnat
+, gnatcoll-core
+, gprbuild
+, python3
+, ocamlPackages
+, makeWrapper
+}:
+let
+  gnat_version = lib.versions.major gnat.version;
+
+  fetchSpark2014 = { rev, sha256 } : fetchFromGitHub {
+    owner = "AdaCore";
+    repo = "spark2014";
+    fetchSubmodules = true;
+    inherit rev sha256;
+  };
+
+  spark2014 = {
+    "12" = {
+      src = fetchSpark2014 {
+        rev = "ab34e07080a769b63beacc141707b5885c49d375"; # branch fsf-12
+        sha256 = "sha256-7pe3eWitpxmqzjW6qEIEuN0qr2IR+kJ7Ssc9pTBcCD8=";
+      };
+      commit_date = "2022-05-25";
+    };
+    "13" = {
+      src = fetchSpark2014 {
+        rev = "12db22e854defa9d1c993ef904af1e72330a68ca"; # branch fsf-13
+        sha256 = "sha256-mZWP9yF1O4knCiXx8CqolnS+93bM+hTQy40cd0HZmwI=";
+      };
+      commit_date = "2023-01-05";
+    };
+  };
+
+  thisSpark = spark2014.${gnat_version} or
+    (builtins.throw "GNATprove depend on a specific GNAT version and can't be built using GNAT ${gnat_version}.");
+
+in
+stdenv.mkDerivation rec {
+  pname = "gnatprove";
+  version = "fsf-${gnat_version}_${thisSpark.commit_date}";
+
+  src = thisSpark.src;
+
+  nativeBuildInputs = [
+    gnat
+    gprbuild
+    python3
+    ocamlPackages.ocaml
+    makeWrapper
+  ];
+
+  buildInputs = [
+    gnatcoll-core
+    ocamlPackages.camlzip
+    ocamlPackages.findlib
+    ocamlPackages.menhir
+    ocamlPackages.menhirLib
+    ocamlPackages.num
+    ocamlPackages.yojson
+    ocamlPackages.zarith
+  ];
+
+  propagatedBuildInputs = [
+    gprbuild
+  ];
+
+  postPatch = ''
+    # gnat2why/gnat_src points to the GNAT sources
+    tar xf ${gnat.cc.src} gcc-${gnat.cc.version}/gcc/ada
+    mv gcc-${gnat.cc.version}/gcc/ada gnat2why/gnat_src
+  '';
+
+  configurePhase = ''
+    make setup
+  '';
+
+  installPhase = ''
+    make install-all
+    cp -a ./install/. $out
+    mkdir $out/share/gpr
+    ln -s $out/lib/gnat/* $out/share/gpr/
+  '';
+
+  meta = with lib; {
+    description = "a software development technology specifically designed for engineering high-reliability applications";
+    homepage = "https://github.com/AdaCore/spark2014";
+    maintainers = [ maintainers.jiegec ];
+    license = licenses.gpl3;
+    platforms = platforms.all;
+  };
+}
+

pkgs/development/compilers/chez/default.nix

···
 { lib, stdenv, fetchurl
 , coreutils, cctools
-, ncurses, libiconv, libX11, libuuid
+, ncurses, libiconv, libX11, libuuid, testers
 }:
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "chez-scheme";
-  version = "9.6.4";
+  version = "10.0.0";
 
   src = fetchurl {
     url = "https://github.com/cisco/ChezScheme/releases/download/v${finalAttrs.version}/csv${finalAttrs.version}.tar.gz";
-    hash = "sha256-9YJ2gvolnEeXX/4Hh4X7Vh5KXFT3ZDMe9mwyEyhDaF0=";
+    hash = "sha256-03GZASte0ZhcQGnWqH/xjl4fWi3yfkApkfr0XcTyIyw=";
   };
 
   nativeBuildInputs = lib.optional stdenv.isDarwin cctools;
···
   ** NixOS or in any chroot build.
   */
   patchPhase = ''
-    substituteInPlace ./configure \
-      --replace "git submodule init && git submodule update || exit 1" "true"
-
-    substituteInPlace ./workarea \
-      --replace "/bin/ln" ln \
-      --replace "/bin/cp" cp
-
     substituteInPlace ./makefiles/installsh \
-      --replace "/usr/bin/true" "${coreutils}/bin/true"
+      --replace-warn "/usr/bin/true" "${coreutils}/bin/true"
 
     substituteInPlace zlib/configure \
-      --replace "/usr/bin/libtool" libtool
+      --replace-warn "/usr/bin/libtool" libtool
   '';
 
   /*
···
   ** for.
   */
   configurePhase = ''
-    ./configure --threads --installprefix=$out --installman=$out/share/man
+    ./configure --as-is --threads --installprefix=$out --installman=$out/share/man
   '';
 
   /*
···
 
   setupHook = ./setup-hook.sh;
 
+  passthru.tests = {
+    version = testers.testVersion {
+      package = finalAttrs.finalPackage;
+    };
+  };
+
   meta = {
     description  = "A powerful and incredibly fast R6RS Scheme compiler";
     homepage     = "https://cisco.github.io/ChezScheme/";
     license      = lib.licenses.asl20;
     maintainers  = with lib.maintainers; [ thoughtpolice ];
     platforms    = lib.platforms.unix;
-    badPlatforms = [ "aarch64-linux" "aarch64-darwin" ];
+    mainProgram  = "scheme";
   };
 })

pkgs/development/compilers/ecl/default.nix

···
 
   hardeningDisable = [ "format" ];
 
+  # ECL’s ‘make check’ only works after install, making it a de-facto
+  # installCheck.
+  doInstallCheck = true;
+  installCheckTarget = "check";
+
   postInstall = ''
     sed -e 's/@[-a-zA-Z_]*@//g' -i $out/bin/ecl-config
     wrapProgram "$out/bin/ecl" --prefix PATH ':' "${

pkgs/development/compilers/sbcl/bootstrap.nix

···
   postFixup = lib.optionalString (!stdenv.isAarch32 && stdenv.isLinux) ''
     patchelf --set-interpreter $(cat $NIX_CC/nix-support/dynamic-linker) $out/share/sbcl/sbcl
   '';
+
+  meta.sourceProvenance = [ lib.sourceTypes.binaryNativeCode ];
 }

pkgs/development/compilers/sbcl/default.nix

···
-{ lib, stdenv, callPackage, clisp, fetchurl, fetchpatch, writeText, zstd
+{ lib, stdenv, callPackage, clisp, coreutils, fetchurl, strace, texinfo, which, writeText, zstd
 , threadSupport ? (stdenv.hostPlatform.isx86 || "aarch64-linux" == stdenv.hostPlatform.system || "aarch64-darwin" == stdenv.hostPlatform.system)
 , linkableRuntime ? stdenv.hostPlatform.isx86
 , disableImmobileSpace ? false
···
 , purgeNixReferences ? false
 , coreCompression ? lib.versionAtLeast version "2.2.6"
 , markRegionGC ? lib.versionAtLeast version "2.4.0"
-, texinfo
 , version
+  # Set this to a lisp binary to use a custom bootstrap lisp compiler for
+  # SBCL. Leave as null to use the default. This is useful for local development
+  # of SBCL, because you can use your existing stock SBCL as a boostrap. On Hydra
+  # of course we can’t do that because SBCL hasn’t been built yet, so we use
+  # CLISP, but that’s much slower.
+, bootstrapLisp ? null
 }:
 
 let
···
   sbclBootstrap = callPackage ./bootstrap.nix {
     cfg = bootstrapBinaries.${stdenv.hostPlatform.system};
   };
-  bootstrapLisp =
-    if (builtins.hasAttr stdenv.hostPlatform.system bootstrapBinaries)
+  bootstrapLisp' =
+    if bootstrapLisp != null
+    then bootstrapLisp
+    else if (builtins.hasAttr stdenv.hostPlatform.system bootstrapBinaries)
     then "${sbclBootstrap}/bin/sbcl --disable-debugger --no-userinit --no-sysinit"
     else "${clisp}/bin/clisp -E UTF-8 --silent -norc";
 
 in
 
-stdenv.mkDerivation rec {
+stdenv.mkDerivation (self: rec {
   pname = "sbcl";
   inherit version;
 
···
     inherit (versionMap.${version}) sha256;
   };
 
-  nativeBuildInputs = [ texinfo ];
+  nativeBuildInputs = [
+    texinfo
+  ] ++ lib.optionals self.doCheck (
+    [
+      which
+    ] ++ lib.optionals (builtins.elem stdenv.system strace.meta.platforms) [
+      strace
+    ]
+  );
   buildInputs = lib.optionals coreCompression [ zstd ];
 
-  patches = lib.optionals (version == "2.4.0") [
+  patches = [
+    ./search-for-binaries-in-PATH.patch
+  ] ++ lib.optionals (version == "2.4.0") [
     ./fix-2.4.0-aarch64-darwin.patch
   ];
 
-  postPatch = ''
-    echo '"${version}.nixos"' > version.lisp-expr
-
-    # SBCL checks whether files are up-to-date in many places..
-    # Unfortunately, same timestamp is not good enough
-    sed -e 's@> x y@>= x y@' -i contrib/sb-aclrepl/repl.lisp
-    #sed -e '/(date)/i((= date 2208988801) 2208988800)' -i contrib/asdf/asdf.lisp
-    sed -i src/cold/slam.lisp -e \
-      '/file-write-date input/a)'
-    sed -i src/cold/slam.lisp -e \
-      '/file-write-date output/i(or (and (= 2208988801 (file-write-date output)) (= 2208988801 (file-write-date input)))'
-    sed -i src/code/target-load.lisp -e \
-      '/date defaulted-fasl/a)'
-    sed -i src/code/target-load.lisp -e \
-      '/date defaulted-source/i(or (and (= 2208988801 (file-write-date defaulted-source-truename)) (= 2208988801 (file-write-date defaulted-fasl-truename)))'
-
-    # Fix the tests
-    sed -e '5,$d' -i contrib/sb-bsd-sockets/tests.lisp
-    sed -e '5,$d' -i contrib/sb-simple-streams/*test*.lisp
+  # I don’t know why these are failing (on ofBorg), and I’d rather just disable
+  # them and move forward with the succeeding tests than block testing
+  # altogether. One by one hopefully we can fix these (on ofBorg,
+  # upstream--somehow some way) in due time.
+  disabledTestFiles = lib.optionals (builtins.elem stdenv.hostPlatform.system [
+    "x86_64-linux"
+    "aarch64-linux"
+  ]) [
+    "foreign-stack-alignment.impure.lisp"
+    # Floating point tests are fragile
+    # https://sourceforge.net/p/sbcl/mailman/message/58728554/
+    "compiler.pure.lisp"
+    "float.pure.lisp"
+  ] ++ lib.optionals (stdenv.hostPlatform.system == "aarch64-linux") [
+    # This is failing on aarch64-linux on ofBorg. Not on my local machine nor on
+    # a VM on my laptop. Not sure what’s wrong.
+    "traceroot.impure.lisp"
+  ];
+  postPatch = lib.optionalString (self.disabledTestFiles != [ ]) ''
+    (cd tests ; rm -f ${lib.concatStringsSep " " self.disabledTestFiles})
   ''
-  + (if purgeNixReferences
-    then
-      # This is the default location to look for the core; by default in $out/lib/sbcl
-      ''
-        sed 's@^\(#define SBCL_HOME\) .*$@\1 "/no-such-path"@' \
-          -i src/runtime/runtime.c
-      ''
-    else
-      # Fix software version retrieval
-      ''
-        sed -e "s@/bin/uname@$(command -v uname)@g" -i src/code/*-os.lisp \
-          src/code/run-program.lisp
-      ''
-    );
-
+  + lib.optionalString purgeNixReferences ''
+    # This is the default location to look for the core; by default in $out/lib/sbcl
+    sed 's@^\(#define SBCL_HOME\) .*$@\1 "/no-such-path"@' \
+        -i src/runtime/runtime.c
+  ''
+  + ''
+    (
+      shopt -s nullglob
+      # Tests need patching regardless of purging of paths from the final
+      # binary. There are some tricky files in nested directories which should
+      # definitely NOT be patched this way, hence just a single * (and no
+      # globstar).
+      substituteInPlace ${if purgeNixReferences then "tests" else "{tests,src/code}"}/*.{lisp,sh} \
+        --replace-quiet /usr/bin/env "${coreutils}/bin/env" \
+        --replace-quiet /bin/uname "${coreutils}/bin/uname" \
+        --replace-quiet /bin/sh "${stdenv.shell}"
+    )
+  '';
 
   preBuild = ''
     export INSTALL_ROOT=$out
···
     optional (!threadSupport) "sb-thread" ++
     optionals disableImmobileSpace [ "immobile-space" "immobile-code" "compact-instance-header" ];
 
-  env.NIX_CFLAGS_COMPILE = toString (lib.optionals (lib.versionOlder version "2.1.10") [
+  buildArgs = [
+    "--prefix=$out"
+    "--xc-host=${lib.escapeShellArg bootstrapLisp'}"
+  ] ++ builtins.map (x: "--with-${x}") self.enableFeatures
+  ++ builtins.map (x: "--without-${x}") self.disableFeatures
+  ++ lib.optionals (stdenv.hostPlatform.system == "aarch64-darwin") [
+    "--arch=arm64"
+  ];
+
+  env.NIX_CFLAGS_COMPILE = toString (lib.optionals (lib.versionOlder self.version "2.1.10") [
     # Workaround build failure on -fno-common toolchains like upstream
     # clang-13. Without the change build fails as:
     #   duplicate symbol '_static_code_space_free_pointer' in: alloc.o traceroot.o
···
   buildPhase = ''
     runHook preBuild
 
-    sh make.sh --prefix=$out --xc-host="${bootstrapLisp}" ${
-                  lib.concatStringsSep " "
-                    (builtins.map (x: "--with-${x}") enableFeatures ++
-                     builtins.map (x: "--without-${x}") disableFeatures)
-                } ${lib.optionalString (stdenv.hostPlatform.system == "aarch64-darwin") "--arch=arm64"}
+    sh make.sh ${lib.concatStringsSep " " self.buildArgs}
     (cd doc/manual ; make info)
 
     runHook postBuild
   '';
 
+  # Tests on ofBorg’s x86_64-darwin platforms are so unstable that a random one
+  # will fail every other run. There’s a deeper problem here; we might as well
+  # disable them entirely so at least the other platforms get to benefit from
+  # testing.
+  doCheck = stdenv.hostPlatform.system != "x86_64-darwin";
+
+  # From the INSTALL docs
+  checkPhase = ''
+    runHook preCheck
+
+    (cd tests && sh run-tests.sh)
+
+    runHook postCheck
+  '';
+
   installPhase = ''
     runHook preInstall
 
     INSTALL_ROOT=$out sh install.sh
 
-    runHook postInstall
   ''
   + lib.optionalString (!purgeNixReferences) ''
     cp -r src $out/lib/sbcl
···
        '(("SYS:SRC;**;*.*.*" #P"$out/lib/sbcl/src/**/*.*")
          ("SYS:CONTRIB;**;*.*.*" #P"$out/lib/sbcl/contrib/**/*.*")))
     EOF
+  '' + ''
+    runHook postInstall
   '';
 
   setupHook = lib.optional purgeNixReferences (writeText "setupHook.sh" ''
···
   '');
 
   meta = with lib; {
-    description = "Lisp compiler";
+    description = "Common Lisp compiler";
     homepage = "https://sbcl.org";
     license = licenses.publicDomain; # and FreeBSD
     maintainers = lib.teams.lisp.members;
···
       "aarch64-linux"
     ];
   };
-}
+})

pkgs/development/compilers/sbcl/search-for-binaries-in-PATH.patch

···
+From 35856b09e3606361b17f21225c759632be1cdf34 Mon Sep 17 00:00:00 2001
+From: Hraban Luyat <[e-mail]>
+Date: Wed, 24 Jan 2024 14:58:53 -0500
+Subject: [PATCH] Search for binaries in tests in PATH, not /usr/bin
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Same as 8ed662fbfeb5dde35eb265f390b55b01f79f70c1 but for tests, and for more
+than just ‘cat’. For the same reasons as that diff.
+---
+ tests/run-program.impure.lisp | 18 ++++++++++--------
+ tests/run-program.test.sh     |  9 ++++-----
+ 2 files changed, 14 insertions(+), 13 deletions(-)
+
+diff --git a/tests/run-program.impure.lisp b/tests/run-program.impure.lisp
+index 0eab8884c..b07d1e4fb 100644
+--- a/tests/run-program.impure.lisp
++++ b/tests/run-program.impure.lisp
+@@ -15,7 +15,7 @@
+ 
+ (defun bin-pwd-ignoring-result ()
+   (let ((initially-open-fds (directory "/proc/self/fd/*" :resolve-symlinks nil)))
+-    (sb-ext:run-program "/usr/bin/pwd" nil :input :stream :output :stream :wait nil)
++    (sb-ext:run-program "pwd" nil :search t :input :stream :output :stream :wait nil)
+     (length initially-open-fds)))
+ 
+ (with-test (:name (run-program :autoclose-streams)
+@@ -49,7 +49,7 @@
+ (with-test (:name (run-program :cat 2)
+                   :skipped-on (or (not :sb-thread) :win32))
+   ;; Tests that reading from a FIFO is interruptible.
+-  (let* ((process (run-program "/bin/cat" '()
++  (let* ((process (run-program "cat" '() :search t
+                                :wait nil :output :stream :input :stream))
+          (in (process-input process))
+          (out (process-output process))
+@@ -167,7 +167,7 @@
+   (defparameter *cat-out* (make-synonym-stream '*cat-out-pipe*)))
+ 
+ (with-test (:name (run-program :cat 5) :fails-on :win32)
+-  (let ((cat (run-program "/bin/cat" nil :input *cat-in* :output *cat-out*
++  (let ((cat (run-program "cat" nil :search t :input *cat-in* :output *cat-out*
+                           :wait nil)))
+     (dolist (test '("This is a test!"
+                     "This is another test!"
+@@ -310,14 +310,16 @@
+   (let ((had-error-p nil))
+     (flet ((barf (&optional (format :default))
+              (with-output-to-string (stream)
+-               (run-program #-netbsd "/usr/bin/perl" #+netbsd "/usr/pkg/bin/perl"
++               (run-program #-netbsd "perl" #+netbsd "/usr/pkg/bin/perl"
+                             '("-e" "print \"\\x20\\xfe\\xff\\x0a\"")
++                            :search #-netbsd t #+netbsd nil
+                             :output stream
+                             :external-format format)))
+            (no-barf ()
+              (with-output-to-string (stream)
+-               (run-program "/bin/echo"
++               (run-program "echo"
+                             '("This is a test")
++                            :search t
+                             :output stream))))
+       (handler-case
+           (barf :utf-8)
+@@ -353,9 +355,9 @@
+                ;; If the permitted inputs are :ANY then leave it be
+                (listp (symbol-value 'run-tests::*allowed-inputs*)))
+       (push (namestring file) (symbol-value 'run-tests::*allowed-inputs*)))
+-    (assert (null (run-program "/bin/cat" '() :input file)))
+-    (assert (null (run-program "/bin/cat" '() :output #.(or *compile-file-truename*
+-                                                            *load-truename*)
++    (assert (null (run-program "cat" '() :search t :input file)))
++    (assert (null (run-program "cat" '() :search t :output #.(or *compile-file-truename*
++                                                                 *load-truename*)
+                                       :if-output-exists nil)))))
+ 
+ 
+diff --git a/tests/run-program.test.sh b/tests/run-program.test.sh
+index 48eaef889..c926e5a05 100755
+--- a/tests/run-program.test.sh
++++ b/tests/run-program.test.sh
+@@ -39,9 +39,8 @@ run_sbcl --eval "(defvar *exit-ok* $EXIT_LISP_WIN)" <<'EOF'
+   (assert (not (zerop (sb-ext:process-exit-code
+                        (sb-ext:run-program "false" () :search t :wait t)))))
+   (let ((string (with-output-to-string (stream)
+-                  (our-run-program    "/bin/echo"
+-                                      '("foo" "bar")
+-                                      :output stream))))
++                  (run-program  "echo" '("foo" "bar")
++                                :search t :output stream))))
+     (assert (string= string "foo bar
+ ")))
+   (format t ";;; Smoke tests: PASS~%")
+@@ -103,8 +102,8 @@ run_sbcl --eval "(defvar *exit-ok* $EXIT_LISP_WIN)" <<'EOF'
+   ;; make sure that a stream input argument is basically reasonable.
+   (let ((string (let ((i (make-string-input-stream "abcdef")))
+                   (with-output-to-string (stream)
+-                    (our-run-program "/bin/cat" ()
+-                                        :input i :output stream)))))
++                    (run-program "cat" ()
++                                 :search t :input i :output stream)))))
+     (assert (= (length string) 6))
+     (assert (string= string "abcdef")))
+ 
+-- 
+2.43.0
+

pkgs/development/embedded/platformio/core.nix

···
     })
   ];
 
+  postPatch = ''
+    # Disable update checks at runtime
+    substituteInPlace platformio/maintenance.py --replace-fail '    check_platformio_upgrade()' ""
+  '';
+
   nativeBuildInputs = [
     installShellFiles
     pythonRelaxDepsHook

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

···
 
   # Manually maintained
   cachix-api = overrideCabal (drv: {
-    version = "1.7";
+    version = "1.7.1";
     src = pkgs.fetchFromGitHub {
       owner = "cachix";
       repo = "cachix";
-      rev = "v1.7";
-      sha256 = "sha256-d9BohugsKajvjNgt+VyXHuDdLOFKr9mhwpdUNkpIP3s=";
+      rev = "v1.7.1";
+      sha256 = "sha256-neN8zGZuGXnLVdQw468z67o96mn8o1p4WGqPINl+NjU=";
     };
     postUnpack = "sourceRoot=$sourceRoot/cachix-api";
   }) super.cachix-api;
   cachix = (overrideCabal (drv: {
-    version = "1.7";
+    version = "1.7.1";
     src = pkgs.fetchFromGitHub {
       owner = "cachix";
       repo = "cachix";
-      rev = "v1.7";
-      sha256 = "sha256-d9BohugsKajvjNgt+VyXHuDdLOFKr9mhwpdUNkpIP3s=";
+      rev = "v1.7.1";
+      sha256 = "sha256-neN8zGZuGXnLVdQw468z67o96mn8o1p4WGqPINl+NjU=";
     };
     postUnpack = "sourceRoot=$sourceRoot/cachix";
   }) (lib.pipe

pkgs/development/libraries/ada/spark2014/default.nix

···
-{ stdenv
-, lib
-, fetchFromGitHub
-, gnat12
-, gnatcoll-core
-, gprbuild
-, python3
-, ocamlPackages
-, makeWrapper
-}:
-
-stdenv.mkDerivation rec {
-  pname = "spark2014";
-  version = "unstable-2022-05-25";
-
-  src = fetchFromGitHub {
-    owner = "AdaCore";
-    repo = "spark2014";
-    # commit on fsf-12 branch
-    rev = "ab34e07080a769b63beacc141707b5885c49d375";
-    sha256 = "sha256-7pe3eWitpxmqzjW6qEIEuN0qr2IR+kJ7Ssc9pTBcCD8=";
-    fetchSubmodules = true;
-  };
-
-  nativeBuildInputs = [
-    gnat12
-    gprbuild
-    python3
-    ocamlPackages.ocaml
-    makeWrapper
-  ];
-
-  buildInputs = [
-    gnatcoll-core
-    ocamlPackages.camlzip
-    ocamlPackages.findlib
-    ocamlPackages.menhir
-    ocamlPackages.menhirLib
-    ocamlPackages.num
-    ocamlPackages.yojson
-    ocamlPackages.zarith
-  ];
-
-  postPatch = ''
-    # gnat2why/gnat_src points to the GNAT sources
-    tar xf ${gnat12.cc.src} gcc-${gnat12.cc.version}/gcc/ada
-    mv gcc-${gnat12.cc.version}/gcc/ada gnat2why/gnat_src
-  '';
-
-  configurePhase = ''
-    make setup
-  '';
-
-  installPhase = ''
-    make install-all
-    cp -a ./install/. $out
-  '';
-
-  meta = with lib; {
-    description = "a software development technology specifically designed for engineering high-reliability applications";
-    homepage = "https://github.com/AdaCore/spark2014";
-    maintainers = [ maintainers.jiegec ];
-    license = licenses.gpl3;
-    platforms = platforms.all;
-  };
-}
-

pkgs/development/libraries/icu/default.nix

···
 
 let
   make-icu = (import ./make-icu.nix) {
-    inherit stdenv lib fetchurl fixDarwinDylibNames testers;
+    inherit stdenv lib buildPackages fetchurl fixDarwinDylibNames testers;
   };
 in
 {
   icu74 = make-icu {
     version = "74.2";
     hash = "sha256-aNsIIhKpbW9T411g9H04uWLp+dIHp0z6x4Apro/14Iw=";
-    nativeBuildRoot = buildPackages.icu74.override { buildRootOnly = true; };
   };
   icu73 = make-icu {
     version = "73.2";
     hash = "sha256-gYqAcS7TyqzZtlIwXgGvx/oWfm8ulJltpEuQwqtgTOE=";
-    nativeBuildRoot = buildPackages.icu73.override { buildRootOnly = true; };
   };
   icu72 = make-icu {
     version = "72.1";
     hash = "sha256-otLTghcJKn7VZjXjRGf5L5drNw4gGCrTJe3qZoGnHWg=";
-    nativeBuildRoot = buildPackages.icu72.override { buildRootOnly = true; };
   };
   icu71 = make-icu {
     version = "71.1";
     hash = "sha256-Z6fm5R9h+vEwa2k1Mz4TssSKvY2m0vRs5q3KJLHiHr8=";
-    nativeBuildRoot = buildPackages.icu71.override { buildRootOnly = true; };
   };
   icu70 = make-icu {
     version = "70.1";
     hash = "sha256-jSBUKMF78Tu1NTAGae0oszihV7HAGuZtMdDT4tR8P9U=";
-    nativeBuildRoot = buildPackages.icu70.override { buildRootOnly = true; };
   };
   icu69 = make-icu {
     version = "69.1";
     hash = "sha256-TLp7es0dPELES7DBS+ZjcJjH+vKzMM6Ha8XzuRXQl0U=";
-    nativeBuildRoot = buildPackages.icu69.override { buildRootOnly = true; };
   };
   icu68 = make-icu {
     version = "68.2";
     hash = "sha256-x5GT3uOQeiGZuClqk7UsXLdDMsJvPRZyaUh2gNR51iU=";
-    nativeBuildRoot = buildPackages.icu68.override { buildRootOnly = true; };
   };
   icu67 = make-icu {
     version = "67.1";
     hash = "sha256-lKgM1vJRpTvSqZf28bWsZlP+eR36tm4esCJ3QPuG1dw=";
-    nativeBuildRoot = buildPackages.icu67.override { buildRootOnly = true; };
   };
   icu66 = make-icu {
     version = "66.1";
     hash = "sha256-UqPyIJq5VVnBzwoU8kM4AB84lhW/AOJYXvPbxD7PCi4=";
-    nativeBuildRoot = buildPackages.icu66.override { buildRootOnly = true; };
   };
   icu64 = make-icu {
     version = "64.2";
     hash = "sha256-Yn1dhHjm2W/IyQ/tSFEjkHmlYaaoueSLCJLyToLTHWw=";
-    nativeBuildRoot = buildPackages.icu64.override { buildRootOnly = true; };
   };
   icu63 = make-icu {
     version = "63.1";
     hash = "sha256-BcSQtpRU/OWGC36OKCEjFnSvChHX7y/r6poyUSmYy50=";
-    nativeBuildRoot = buildPackages.icu63.override { buildRootOnly = true; };
     patches = [
       # https://bugzilla.mozilla.org/show_bug.cgi?id=1499398
       (fetchpatch {
···
   icu60 = make-icu {
     version = "60.2";
     hash = "sha256-8HPqjzW5JtcLsz5ld1CKpkKosxaoA/Eb4grzhIEdtBg=";
-    nativeBuildRoot = buildPackages.icu60.override { buildRootOnly = true; };
   };
   icu58 = make-icu {
     version = "58.2";
     hash = "sha256-KwpEEBU6myDeDiDH2LZgSacq7yRLU2g9DXUhNxaD2gw=";
-    nativeBuildRoot = buildPackages.icu58.override { buildRootOnly = true; };
     patches = [
       (fetchurl {
         url = "http://bugs.icu-project.org/trac/changeset/39484?format=diff";
···
     ];
     patchFlags = [ "-p4" ];
   };
- }
+}

pkgs/development/libraries/icu/make-icu.nix

···
-{ stdenv, lib, fetchurl, fixDarwinDylibNames, testers }:
+{ stdenv, lib, buildPackages, fetchurl, fixDarwinDylibNames, testers }:
 
-{ version, hash, patches ? [], patchFlags ? []
-# Cross-compiled icu4c requires a build-root of a native compile
-, buildRootOnly ? false, nativeBuildRoot
-}:
+{ version, hash, patches ? [], patchFlags ? [] }:
 
 let
+  # Cross-compiled icu4c requires a build-root of a native compile
+  nativeBuildRoot = buildPackages."icu${lib.versions.major version}".buildRootOnly;
+
   pname = "icu4c";
 
   baseAttrs = {
···
     '';
   };
 
-  attrs = if buildRootOnly
-            then buildRootOnlyAttrs
-          else realAttrs;
+  mkWithAttrs = attrs: stdenv.mkDerivation (finalAttrs: attrs // {
+    passthru.tests.pkg-config = testers.testMetaPkgConfig finalAttrs.finalPackage;
+    passthru.buildRootOnly = mkWithAttrs buildRootOnlyAttrs;
+  });
 in
-stdenv.mkDerivation (finalAttrs: attrs // {
-  passthru.tests.pkg-config = testers.testMetaPkgConfig finalAttrs.finalPackage;
-})
+  mkWithAttrs realAttrs

pkgs/development/libraries/leatherman/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "leatherman";
-  version = "1.12.11";
+  version = "1.12.12";
 
   src = fetchFromGitHub {
-    sha256 = "sha256-XB5qIXPe1Tu+cfxuL+HAfR9QQNiUY/noO51CVEz9hsU=";
+    sha256 = "sha256-V/AMdJ3ldlgBaO8gS0FOqb5tTdRGGW/+3LZq/TKkdog=";
     rev = version;
     repo = "leatherman";
     owner = "puppetlabs";

pkgs/development/libraries/opencv/4.x.nix

···
 , stdenv
 , fetchurl
 , fetchFromGitHub
-, fetchpatch
 , cmake
 , pkg-config
 , unzip
 , zlib
-, pcre
+, pcre2
 , hdf5
 , boost
+, glib
 , gflags
 , protobuf_21
 , config
···
 , eigen
 , enableBlas ? true
 , blas
+, enableVA ? !stdenv.isDarwin
+, libva
 , enableContrib ? true
 
 , enableCuda ? config.cudaSupport
···
 , enableFfmpeg ? true
 , ffmpeg
 , enableGStreamer ? true
+, elfutils
 , gst_all_1
+, orc
+, libunwind
+, zstd
 , enableTesseract ? false
 , tesseract
 , leptonica
···
 }@inputs:
 
 let
-  version = "4.7.0";
+  version = "4.9.0";
 
   # It's necessary to consistently use backendStdenv when building with CUDA
   # support, otherwise we get libstdc++ errors downstream
···
     owner = "opencv";
     repo = "opencv";
     rev = version;
-    sha256 = "sha256-jUeGsu8+jzzCnIFbVMCW8DcUeGv/t1yCY/WXyW+uGDI=";
+    hash = "sha256-3qqu4xlRyMbPKHHTIT+iRRGtpFlcv0NU8GNZpgjdi6k=";
   };
 
   contribSrc = fetchFromGitHub {
     owner = "opencv";
     repo = "opencv_contrib";
     rev = version;
-    sha256 = "sha256-meya0J3RdOIeMM46e/6IOVwrKn3t/c0rhwP2WQaybkE=";
+    hash = "sha256-K74Ghk4uDqj4OWEzDxT2R3ERi+jkAWZszzezRenfuZ8=";
   };
 
   testDataSrc = fetchFromGitHub {
     owner = "opencv";
     repo = "opencv_extra";
     rev = version;
-    sha256 = "sha256-6hAdJdaUgtRGQanQKuY/q6fcXWXFZ3K/oLbGxvksry0=";
+    hash = "sha256-pActKi7aN5EOZq2Fpf5mALnZq71c037/R3Q6wJ4uCfQ=";
   };
 
   # Contrib must be built in order to enable Tesseract support:
···
     src = fetchFromGitHub {
       owner = "opencv";
       repo = "opencv_3rdparty";
-      rev = "a56b6ac6f030c312b2dce17430eef13aed9af274";
-      sha256 = "1msbkc3zixx61rcg6a04i1bcfhw1phgsrh93glq1n80hgsk3nbjq";
+      rev = "0cc4aa06bf2bef4b05d237c69a5a96b9cd0cb85a";
+      hash = "sha256-/kHivOgCkY9YdcRRaVgytXal3ChE9xFfGAB0CfFO5ec=";
     } + "/ippicv";
-    files = let name = platform: "ippicv_2019_${platform}_general_20180723.tgz"; in
+    files = let name = platform: "ippicv_2021.10.0_${platform}_20230919_general.tgz"; in
       if effectiveStdenv.hostPlatform.system == "x86_64-linux" then
-        { ${name "lnx_intel64"} = "c0bd78adb4156bbf552c1dfe90599607"; }
+        { ${name "lnx_intel64"} = "606a19b207ebedfe42d59fd916cc4850"; }
       else if effectiveStdenv.hostPlatform.system == "i686-linux" then
-        { ${name "lnx_ia32"} = "4f38432c30bfd6423164b7a24bbc98a0"; }
+        { ${name "lnx_ia32"} = "ea08487b810baad2f68aca87b74a2db9"; }
       else if effectiveStdenv.hostPlatform.system == "x86_64-darwin" then
-        { ${name "mac_intel64"} = "fe6b2bb75ae0e3f19ad3ae1a31dfa4a2"; }
+        { ${name "mac_intel64"} = "14f01c5a4780bfae9dde9b0aaf5e56fc"; }
       else
         throw "ICV is not available for this platform (or not yet supported by this package)";
     dst = ".cache/ippicv";
···
       owner = "opencv";
       repo = "opencv_3rdparty";
       rev = "fccf7cd6a4b12079f73bbfb21745f9babcd4eb1d";
-      sha256 = "0r9fam8dplyqqsd3qgpnnfgf9l7lj44di19rxwbm8mxiw0rlcdvy";
+      hash = "sha256-fjdGM+CxV1QX7zmF2AiR9NDknrP2PjyaxtjT21BVLmU=";
     };
     files = {
       "vgg_generated_48.i" = "e8d0dcd54d1bcfdc29203d011a797179";
···
       owner = "opencv";
       repo = "opencv_3rdparty";
       rev = "8afa57abc8229d611c4937165d20e2a2d9fc5a12";
-      sha256 = "061lsvqdidq9xa2hwrcvwi9ixflr2c2lfpc8drr159g68zi8bp4v";
+      hash = "sha256-m9yF4kfmpRJybohdRwUTmboeU+SbZQ6F6gm32PDWNBg=";
     };
     files = {
       "face_landmark_model.dat" = "7505c44ca4eb54b4ab1e4777cb96ac05";
···
   ade = rec {
     src = fetchurl {
       url = "https://github.com/opencv/ade/archive/${name}";
-      sha256 = "sha256-TjLRbFbC7MDY9PxIy560ryviBI58cbQwqgc7A7uOHkg=";
+      hash = "sha256-WG/GudVpkO10kOJhoKXFMj672kggvyRYCIpezal3wcE=";
     };
-    name = "v0.1.2a.zip";
-    md5 = "fa4b3e25167319cb0fa9432ef8281945";
+    name = "v0.1.2d.zip";
+    md5 = "dbb095a8bf3008e91edbbf45d8d34885";
     dst = ".cache/ade";
   };
 
···
       owner = "opencv";
       repo = "opencv_3rdparty";
       rev = "a8b69ccc738421293254aec5ddb38bd523503252";
-      sha256 = "sha256-/n6zHwf0Rdc4v9o4rmETzow/HTv+81DnHP+nL56XiTY=";
+      hash = "sha256-/n6zHwf0Rdc4v9o4rmETzow/HTv+81DnHP+nL56XiTY=";
     };
     files = {
       "detect.caffemodel" = "238e2b2d6f3c18d6c3a30de0c31e23cf";
···
   patches = [
     ./cmake-don-t-use-OpenCVFindOpenEXR.patch
   ] ++ lib.optionals enableContrib [
-    (fetchpatch {
-      name = "CVE-2023-2617.patch";
-      url = "https://github.com/opencv/opencv_contrib/commit/ccc277247ac1a7aef0a90353edcdec35fbc5903c.patch";
-      stripLen = 2;
-      extraPrefix = [ "opencv_contrib/" ];
-      sha256 = "sha256-drZ+DVn+Pk4zAZJ+LgX5u3Tz7MU0AEI/73EVvxDP3AU=";
-    })
-    (fetchpatch {
-      name = "CVE-2023-2618.patch";
-      url = "https://github.com/opencv/opencv_contrib/commit/ec406fa4748fb4b0630c1b986469e7918d5e8953.patch";
-      stripLen = 2;
-      extraPrefix = [ "opencv_contrib/" ];
-      sha256 = "sha256-cB5Tsh2fDOsc0BNtSzd6U/QoCjkd9yMW1QutUU69JJ0=";
-    })
   ] ++ lib.optional enableCuda ./cuda_opt_flow.patch;
 
   # This prevents cmake from using libraries in impure paths (which
···
     echo '"(build info elided)"' > modules/core/version_string.inc
   '';
 
-  buildInputs = [ zlib pcre boost gflags protobuf_21 ]
-    ++ lib.optional enablePython pythonPackages.python
-    ++ lib.optional (effectiveStdenv.buildPlatform == effectiveStdenv.hostPlatform) hdf5
-    ++ lib.optional enableGtk2 gtk2
-    ++ lib.optional enableGtk3 gtk3
-    ++ lib.optional enableVtk vtk
-    ++ lib.optional enableJPEG libjpeg
-    ++ lib.optional enablePNG libpng
-    ++ lib.optional enableTIFF libtiff
-    ++ lib.optional enableWebP libwebp
-    ++ lib.optionals enableEXR [ openexr ilmbase ]
-    ++ lib.optional enableJPEG2000 openjpeg
-    ++ lib.optional enableFfmpeg ffmpeg
-    ++ lib.optionals (enableFfmpeg && effectiveStdenv.isDarwin)
-      [ VideoDecodeAcceleration bzip2 ]
-    ++ lib.optionals enableGStreamer (with gst_all_1; [ gstreamer gst-plugins-base gst-plugins-good ])
-    ++ lib.optional enableOvis ogre
-    ++ lib.optional enableGPhoto2 libgphoto2
-    ++ lib.optional enableDC1394 libdc1394
-    ++ lib.optional enableEigen eigen
-    ++ lib.optional enableBlas blas.provider
+  buildInputs = [
+    boost
+    gflags
+    glib
+    pcre2
+    protobuf_21
+    zlib
+  ] ++ lib.optionals enablePython [
+    pythonPackages.python
+  ] ++ lib.optionals (effectiveStdenv.buildPlatform == effectiveStdenv.hostPlatform) [
+    hdf5
+  ] ++ lib.optionals enableGtk2 [
+    gtk2
+  ] ++ lib.optionals enableGtk3 [
+    gtk3
+  ] ++ lib.optionals enableVtk [
+    vtk
+  ] ++ lib.optionals enableJPEG [
+    libjpeg
+  ] ++ lib.optionals enablePNG [
+    libpng
+  ] ++ lib.optionals enableTIFF [
+    libtiff
+  ] ++ lib.optionals enableWebP [
+    libwebp
+  ] ++ lib.optionals enableEXR [
+    openexr
+    ilmbase
+  ] ++ lib.optionals enableJPEG2000 [
+    openjpeg
+  ] ++ lib.optionals enableFfmpeg [
+    ffmpeg
+  ] ++ lib.optionals (enableFfmpeg && effectiveStdenv.isDarwin) [
+    bzip2
+    VideoDecodeAcceleration
+  ] ++ lib.optionals (enableGStreamer && effectiveStdenv.isLinux) (with gst_all_1; [
+    elfutils
+    gst-plugins-base
+    gst-plugins-good
+    gstreamer
+    libunwind
+    orc
+    zstd
+  ]) ++ lib.optionals enableOvis [
+    ogre
+  ] ++ lib.optionals enableGPhoto2 [
+    libgphoto2
+  ] ++ lib.optionals enableDC1394 [
+    libdc1394
+  ] ++ lib.optionals enableEigen [
+    eigen
+  ] ++ lib.optionals enableVA [
+    libva
+  ] ++ lib.optionals enableBlas [
+    blas.provider
+  ] ++ lib.optionals enableTesseract [
     # There is seemingly no compile-time flag for Tesseract.  It's
     # simply enabled automatically if contrib is built, and it detects
     # tesseract & leptonica.
-    ++ lib.optionals enableTesseract [ tesseract leptonica ]
-    ++ lib.optional enableTbb tbb
-    ++ lib.optionals effectiveStdenv.isDarwin [
-      bzip2 AVFoundation Cocoa VideoDecodeAcceleration CoreMedia MediaToolbox Accelerate
-    ]
-    ++ lib.optionals enableDocs [ doxygen graphviz-nox ]
-    ++ lib.optionals enableCuda (with cudaPackages; [
-      cuda_cudart.lib
-      cuda_cudart.dev
-      cuda_cccl.dev # <thrust/*>
-      libnpp.dev # npp.h
-      libnpp.lib
-      libnpp.static
-      nvidia-optical-flow-sdk
-    ] ++ lib.optionals enableCublas [
-      # May start using the default $out instead once
-      # https://github.com/NixOS/nixpkgs/issues/271792
-      # has been addressed
-      libcublas.static
-      libcublas.lib
-      libcublas.dev # cublas_v2.h
-    ] ++ lib.optionals enableCudnn [
-      cudnn.dev # cudnn.h
-      cudnn.lib
-      cudnn.static
-    ] ++ lib.optionals enableCufft [
-      libcufft.dev # cufft.h
-      libcufft.lib
-      libcufft.static
-    ]);
+    tesseract
+    leptonica
+  ] ++ lib.optionals enableTbb [
+    tbb
+  ] ++ lib.optionals effectiveStdenv.isDarwin [
+    bzip2
+    AVFoundation
+    Cocoa
+    VideoDecodeAcceleration
+    CoreMedia
+    MediaToolbox
+    Accelerate
+  ] ++ lib.optionals enableDocs [
+    doxygen
+    graphviz-nox
+  ] ++ lib.optionals enableCuda (with cudaPackages; [
+    cuda_cudart.lib
+    cuda_cudart.dev
+    cuda_cccl.dev # <thrust/*>
+    libnpp.dev # npp.h
+    libnpp.lib
+    libnpp.static
+    nvidia-optical-flow-sdk
+  ] ++ lib.optionals enableCublas [
+    # May start using the default $out instead once
+    # https://github.com/NixOS/nixpkgs/issues/271792
+    # has been addressed
+    libcublas.static
+    libcublas.lib
+    libcublas.dev # cublas_v2.h
+  ] ++ lib.optionals enableCudnn [
+    cudnn.dev # cudnn.h
+    cudnn.lib
+    cudnn.static
+  ] ++ lib.optionals enableCufft [
+    libcufft.dev # cufft.h
+    libcufft.lib
+    libcufft.static
+  ]);
 
   propagatedBuildInputs = lib.optionals enablePython [ pythonPackages.numpy ];
 

pkgs/development/libraries/physics/rivet/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "rivet";
-  version = "3.1.9";
+  version = "3.1.10";
 
   src = fetchurl {
     url = "https://www.hepforge.org/archive/rivet/Rivet-${version}.tar.bz2";
-    hash = "sha256-9lMgRdph7rKtwgqavEFmtLLUGrLByltQDNYWuxuS57E=";
+    hash = "sha256-RYuODfHec46ZctJLJg6qCH3xLJnU/p3uU3fUfqakmRk=";
   };
 
   latex = texliveBasic.withPackages (ps: with ps; [

pkgs/development/libraries/yajl/cmake-shared-static-fix.patch

···
-From 768be8b9f98e30a8bd2d51576be9dfcf2cb838ea Mon Sep 17 00:00:00 2001
-From: Kiskae <[e-mail]>
-Date: Tue, 26 Sep 2023 20:53:00 +0200
-Subject: [PATCH] simplify compilation of static/shared with cmake
-
-Signed-off-by: Kiskae <[e-mail]>
----
- CMakeLists.txt              | 2 ++
- example/CMakeLists.txt      | 2 +-
- perf/CMakeLists.txt         | 2 +-
- src/CMakeLists.txt          | 7 ++-----
- test/parsing/CMakeLists.txt | 2 +-
- 5 files changed, 7 insertions(+), 8 deletions(-)
-
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 471eee13..9af25203 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -16,6 +16,8 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
- 
- PROJECT(YetAnotherJSONParser C)
- 
-+option(BUILD_SHARED_LIBS "Build using shared libraries" ON)
-+
- SET (YAJL_MAJOR 2)
- SET (YAJL_MINOR 1)
- SET (YAJL_MICRO 1)
-diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
-index 0a7f6220..62ddf14c 100644
---- a/example/CMakeLists.txt
-+++ b/example/CMakeLists.txt
-@@ -20,4 +20,4 @@ LINK_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/../${YAJL_DIST_NAME}/lib)
- 
- ADD_EXECUTABLE(parse_config ${SRCS})
- 
--TARGET_LINK_LIBRARIES(parse_config yajl_s)
-+TARGET_LINK_LIBRARIES(parse_config yajl)
-diff --git a/perf/CMakeLists.txt b/perf/CMakeLists.txt
-index b438d7a1..924a2681 100644
---- a/perf/CMakeLists.txt
-+++ b/perf/CMakeLists.txt
-@@ -20,4 +20,4 @@ LINK_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/../${YAJL_DIST_NAME}/lib)
- 
- ADD_EXECUTABLE(perftest ${SRCS})
- 
--TARGET_LINK_LIBRARIES(perftest yajl_s)
-+TARGET_LINK_LIBRARIES(perftest yajl)
-diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
-index 789ddf99..78875032 100644
---- a/src/CMakeLists.txt
-+++ b/src/CMakeLists.txt
-@@ -35,9 +35,7 @@ SET (pkgconfigDir ${CMAKE_CURRENT_BINARY_DIR}/../${YAJL_DIST_NAME}/lib/pkgconfig
- # set the output path for libraries
- SET(LIBRARY_OUTPUT_PATH ${libDir})
- 
--ADD_LIBRARY(yajl_s STATIC ${SRCS} ${HDRS} ${PUB_HDRS})
--
--ADD_LIBRARY(yajl SHARED ${SRCS} ${HDRS} ${PUB_HDRS})
-+ADD_LIBRARY(yajl ${SRCS} ${HDRS} ${PUB_HDRS})
- 
- #### setup shared library version number
- SET_TARGET_PROPERTIES(yajl PROPERTIES
-@@ -69,7 +67,7 @@ FOREACH (header ${PUB_HDRS})
- 
-   EXEC_PROGRAM(${CMAKE_COMMAND} ARGS -E copy_if_different ${header} ${incDir})
- 
--  ADD_CUSTOM_COMMAND(TARGET yajl_s POST_BUILD
-+  ADD_CUSTOM_COMMAND(TARGET yajl POST_BUILD
-       COMMAND ${CMAKE_COMMAND} -E copy_if_different ${header} ${incDir})
- ENDFOREACH (header ${PUB_HDRS})
- 
-@@ -81,7 +79,6 @@ INSTALL(TARGETS yajl
-         RUNTIME DESTINATION lib${LIB_SUFFIX}
-         LIBRARY DESTINATION lib${LIB_SUFFIX}
-         ARCHIVE DESTINATION lib${LIB_SUFFIX})
--INSTALL(TARGETS yajl_s ARCHIVE DESTINATION lib${LIB_SUFFIX})
- INSTALL(FILES ${PUB_HDRS} DESTINATION include/yajl)
- INSTALL(FILES ${incDir}/yajl_version.h DESTINATION include/yajl)
- INSTALL(FILES ${pkgconfigDir}/yajl.pc DESTINATION lib${LIB_SUFFIX}/pkgconfig)
-diff --git a/test/parsing/CMakeLists.txt b/test/parsing/CMakeLists.txt
-index c22a3887..f445920d 100644
---- a/test/parsing/CMakeLists.txt
-+++ b/test/parsing/CMakeLists.txt
-@@ -20,4 +20,4 @@ LINK_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR}/../../${YAJL_DIST_NAME}/lib)
- 
- ADD_EXECUTABLE(yajl_test ${SRCS})
- 
--TARGET_LINK_LIBRARIES(yajl_test yajl_s)
-+TARGET_LINK_LIBRARIES(yajl_test yajl)

pkgs/development/libraries/yajl/default.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "yajl";
-  version = "unstable-2022-04-20";
+  version = "2.1.0-unstable-2024-02-01";
 
   src = fetchFromGitHub {
     owner = "containers";
     repo = "yajl";
-    rev = "49923ccb2143e36850bcdeb781e2bcdf5ce22f15";
-    hash = "sha256-9bMPA5FpyBp8fvG/kkT/MnhYtdqg3QzOnmDFXKwJVW0=";
+    rev = "6bc5219389fd2752631682b0a8368e6d8218a8c5";
+    hash = "sha256-vY0tqCkz6PN00Qbip5ViO64L3C06fJ4JjFuIk0TWgCo=";
   };
-
-  patches = [
-    # https://github.com/containers/yajl/pull/1
-    ./cmake-shared-static-fix.patch
-  ];
 
   nativeBuildInputs = [ cmake ];
 

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

···
 
 buildPythonPackage rec {
   pname = "aioautomower";
-  version = "2024.2.7";
+  version = "2024.2.8";
   pyproject = true;
 
   disabled = pythonOlder "3.11";
···
     owner = "Thomas55555";
     repo = "aioautomower";
     rev = "refs/tags/${version}";
-    hash = "sha256-ij/Webe/YqpAyjCXFpKq0eyvTegiTDJYiMASuUJKc7Q=";
+    hash = "sha256-YdC6459lEvHDnX4L26n28oGzDSsa7/8UGHjnONhn9Yo=";
   };
 
   postPatch = ''

pkgs/development/python-modules/appthreat-vulnerability-db/default.nix

···
 
 buildPythonPackage rec {
   pname = "appthreat-vulnerability-db";
-  version = "5.6.2";
+  version = "5.6.3";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "AppThreat";
     repo = "vulnerability-db";
     rev = "refs/tags/v${version}";
-    hash = "sha256-/Un5Jh/3UjhJApL0eQzj545F9q+55xwFsIa5M+U93w0=";
+    hash = "sha256-aOHnuZdjXiIqd/SeQdVB1qB7v8DfnEFH0zHctA74MPw=";
   };
 
   postPatch = ''

pkgs/development/python-modules/clarifai-grpc/default.nix

···
 
 buildPythonPackage rec {
   pname = "clarifai-grpc";
-  version = "10.1.4";
+  version = "10.1.6";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "Clarifai";
     repo = "clarifai-python-grpc";
     rev = "refs/tags/${version}";
-    hash = "sha256-cYYAEen/RY5TG2jLxUS38Acehg/X8pni6T1zxhJAi1Y=";
+    hash = "sha256-VRI4mAYWJUP9kxf+xOlcys07Jsa7Zy9bP8BDKDEYli4=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/dask-awkward/default.nix

···
 , awkward
 , buildPythonPackage
 , dask
+, dask-histogram
+, distributed
 , fetchFromGitHub
 , hatch-vcs
 , hatchling
+, hist
+, pandas
 , pyarrow
 , pytestCheckHook
 , pythonOlder
 , pythonRelaxDepsHook
+, typing-extensions
+, uproot
 }:
 
 buildPythonPackage rec {
···
   propagatedBuildInputs = [
     awkward
     dask
+    typing-extensions
   ];
 
+  passthru.optional-dependencies = {
+    io = [
+      pyarrow
+    ];
+  };
+
   checkInputs = [
+    dask-histogram
+    distributed
+    hist
+    pandas
     pytestCheckHook
-    pyarrow
-  ];
+    uproot
+  ] ++ lib.flatten (builtins.attrValues passthru.optional-dependencies);
 
   pythonImportsCheck = [
     "dask_awkward"
···
     "test_remote_double"
     "test_remote_single"
     "test_from_text"
+    # ValueError: not a ROOT file: first four bytes...
+    "test_basic_root_works"
   ];
 
   meta = with lib; {

pkgs/development/python-modules/http-message-signatures/default.nix

···
 
 buildPythonPackage rec {
   pname = "http-message-signatures";
-  version = "0.4.4";
+  version = "0.5.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "pyauth";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-acTziJM5H5Td+eG/LNrlNwgpVvFDyl/tf6//YuE1XZk=";
+    hash = "sha256-Jsivw4lNA/2oqsOGGx8D4gUPftzuys877A9RXyapnSQ=";
   };
 
   nativeBuildInputs = [

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

···
 { lib
-, aiohttp
 , platformdirs
 , buildPythonPackage
 , docutils
 , fetchFromGitHub
 , flaky
 , installShellFiles
-, packaging
 , pycurl
 , pytest-asyncio
 , pytest-httpbin
···
 
 buildPythonPackage rec {
   pname = "nvchecker";
-  version = "2.12";
-  format = "pyproject";
+  version = "2.13.1";
+  pyproject = true;
 
-  disabled = pythonOlder "3.7";
+  disabled = pythonOlder "3.8";
 
   src = fetchFromGitHub {
     owner = "lilydjwg";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-6mhVDC2jpIIOZeoKz4AxxU7jj8dqPVBKRWupbuY/T7E=";
+    hash = "sha256-q+az9oaxxIOv/vLFpkT3cF5GDJsa0Cid4oPWEKg5s7M=";
   };
 
   nativeBuildInputs = [
+    setuptools
     docutils
     installShellFiles
   ];
 
   propagatedBuildInputs = [
-    aiohttp
+    structlog
     platformdirs
-    packaging
+    tornado
     pycurl
-    setuptools
-    structlog
-    tornado
   ] ++ lib.optionals (pythonOlder "3.11") [
     tomli
   ];

pkgs/development/python-modules/odp-amsterdam/default.nix

···
 
 buildPythonPackage rec {
   pname = "odp-amsterdam";
-  version = "6.0.0";
+  version = "6.0.1";
   pyproject = true;
 
   disabled = pythonOlder "3.11";
···
     owner = "klaasnicolaas";
     repo = "python-odp-amsterdam";
     rev = "refs/tags/v${version}";
-    hash = "sha256-dAyKypc8bMWkXhYa7BlGGAGqPaPJHFHwXd/UK80BGoE=";
+    hash = "sha256-teLjiclkbjlG226gMUgqc2IUEWqKcSm6xIekw+AQPU4=";
   };
 
   postPatch = ''

pkgs/development/python-modules/orbax-checkpoint/default.nix

···
+{ lib
+, absl-py
+, buildPythonPackage
+, cached-property
+, etils
+, fetchPypi
+, flit-core
+, importlib-resources
+, jax
+, jaxlib
+, msgpack
+, nest-asyncio
+, numpy
+, protobuf
+, pytest-xdist
+, pytestCheckHook
+, pythonOlder
+, pyyaml
+, tensorstore
+, typing-extensions
+}:
+
+buildPythonPackage rec {
+  pname = "orbax-checkpoint";
+  version = "0.5.3";
+  pyproject = true;
+
+  disabled = pythonOlder "3.9";
+
+  src = fetchPypi {
+    pname = "orbax_checkpoint";
+    inherit version;
+    hash = "sha256-FXKQTLv+hROSfg2A+AtzDg7y9oAzLTwoENhENTKTi0U=";
+  };
+
+  nativeBuildInputs = [
+    flit-core
+  ];
+
+  propagatedBuildInputs = [
+    absl-py
+    cached-property
+    etils
+    importlib-resources
+    jax
+    jaxlib
+    msgpack
+    nest-asyncio
+    numpy
+    protobuf
+    pyyaml
+    tensorstore
+    typing-extensions
+  ];
+
+  nativeCheckInputs = [
+    pytest-xdist
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [
+    "orbax"
+  ];
+
+  disabledTestPaths = [
+    # Circular dependency flax
+    "orbax/checkpoint/transform_utils_test.py"
+    "orbax/checkpoint/utils_test.py"
+  ];
+
+  meta = with lib; {
+    description = "Orbax provides common utility libraries for JAX users";
+    homepage = "https://github.com/google/orbax/tree/main/checkpoint";
+    changelog = "https://github.com/google/orbax/blob/${version}/CHANGELOG.md";
+    license = licenses.asl20;
+    maintainers = with maintainers; [fab ];
+  };
+}

pkgs/development/python-modules/oslo-context/default.nix

···
 
 buildPythonPackage rec {
   pname = "oslo.context";
-  version = "5.3.0";
+  version = "5.4.0";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-xRBxQcYotq5W1P62MiucSnAJL9ahgekfq+relKCeTjg=";
+    hash = "sha256-6WSRu91rUecqOoxUahKbhNI56OngtSEMi6fAoKVimRk=";
   };
 
   postPatch = ''

pkgs/development/python-modules/pillow-heif/default.nix

···
     x265
   ];
 
+  # clang-16: error: argument unused during compilation: '-fno-strict-overflow' [-Werror,-Wunused-command-line-argument]
+  env.NIX_CFLAGS_COMPILE = lib.optionalString stdenv.cc.isClang "-Wno-unused-command-line-argument";
+
   propagatedBuildInputs = [
     pillow
   ];

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

···
 
 buildPythonPackage rec {
   pname = "puremagic";
-  version = "1.20";
+  version = "1.21";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
···
     owner = "cdgriffith";
     repo = pname;
     rev = "refs/tags/${version}";
-    hash = "sha256-Iyf/Vf1uqdtHlaP9Petpp88aIGCGmHu//cH6bindL6c=";
+    hash = "sha256-ObJp3+gk1tf1+9wBpvzs0wwP7ptDlfGwX9b4wlCb1RI=";
   };
 
   nativeCheckInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "pydrawise";
-  version = "2024.1.1";
+  version = "2024.2.0";
   format = "pyproject";
 
   disabled = pythonOlder "3.10";
···
     owner = "dknowles2";
     repo = "pydrawise";
     rev = "refs/tags/${version}";
-    hash = "sha256-fMwWGE6WfgENti4H+WSfd8ZSHqxHyBVATUhng/o8qeY=";
+    hash = "sha256-eFjfO2lpRPgyTtzIutHqGIKC0SLKPBA4Pq0vhl9iCvs=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "pynuki";
-  version = "1.6.2";
-  format = "pyproject";
+  version = "1.6.3";
+  pyproject = true;
 
   disabled = pythonOlder "3.8";
 
   src = fetchFromGitHub {
     owner = "pschmitt";
-    repo = pname;
+    repo = "pynuki";
     rev = "refs/tags/${version}";
-    hash = "sha256-I0eAhgThSBEmJF6mYw+0Bh1kCUqEMFnCx+4n7l3Hf14=";
+    hash = "sha256-PF5FmAuPcJXq8gQ8HyzdtL2HiiUjueT+LAS1lYRvrwM=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/pytedee-async/default.nix

···
 
 buildPythonPackage rec {
   pname = "pytedee-async";
-  version = "0.2.13";
+  version = "0.2.14";
   pyproject = true;
 
   disabled = pythonOlder "3.9";
···
     owner = "zweckj";
     repo = "pytedee_async";
     rev = "refs/tags/v${version}";
-    hash = "sha256-3W+eqkniDMoDKeute5w1QyklOc/aren/Q8txBEI/4ys=";
+    hash = "sha256-BtBHiDOYe8BkrqJEGG4eGKFMnCspCQK4fvcj2vvGmFM=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/python-homewizard-energy/default.nix

···
 
 buildPythonPackage rec {
   pname = "python-homewizard-energy";
-  version = "4.3.0";
+  version = "4.3.1";
   pyproject = true;
 
   disabled = pythonOlder "3.9";
···
     owner = "DCSBL";
     repo = "python-homewizard-energy";
     rev = "refs/tags/v${version}";
-    hash = "sha256-5e2PzH+kDOopH4LYOq49SlHsfBbZZk60U1BSN8OnrKI=";
+    hash = "sha256-LpxXTzUb+N15lGno3pAhRSEJCb4NmwBcGQ/PshI9gYA=";
   };
 
   postPatch = ''

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

···
 
 buildPythonPackage rec {
   pname = "pyunifiprotect";
-  version = "4.23.3";
+  version = "4.23.4";
   pyproject = true;
 
   disabled = pythonOlder "3.9";
···
     owner = "briis";
     repo = "pyunifiprotect";
     rev = "refs/tags/v${version}";
-    hash = "sha256-QWIiBuKDhSNYVyEm45QV4a2UxADDrBdiCBeJI+a6v7c=";
+    hash = "sha256-sBdu4XJkEtHf6dlHgJKFQvONp1x89NiS2EgxMiJFX7A=";
   };
 
   env.SETUPTOOLS_SCM_PRETEND_VERSION = version;

pkgs/development/python-modules/snakemake-interface-common/default.nix

···
 
 buildPythonPackage rec {
   pname = "snakemake-interface-common";
-  version = "1.17.0";
+  version = "1.17.1";
   format = "pyproject";
 
   src = fetchFromGitHub {
     owner = "snakemake";
     repo = pname;
     rev = "refs/tags/v${version}";
-    hash = "sha256-1dvanwYCQE5usgXPhYCZfUpj4MyaLImQ5RskQvS6nJs=";
+    hash = "sha256-23PGKSBX7KMt0Q7sWiLIPfCkxr2HtBas7flYeNHABWM=";
   };
 
   nativeBuildInputs = [

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

···
 , pythonOlder
 , simplejson
 , twisted
-, typing-extensions
 }:
 
 buildPythonPackage rec {
   pname = "structlog";
-  version = "23.2.0";
-  format = "pyproject";
+  version = "24.1.0";
+  pyproject = true;
 
   disabled = pythonOlder "3.8";
 
···
     owner = "hynek";
     repo = "structlog";
     rev = "refs/tags/${version}";
-    hash = "sha256-KSHKgkv+kObKCdWZDg5o6QYe0AMND9VLdEuseY/GyDY=";
+    hash = "sha256-0Yc28UEeozK2+IqILFTqHoTiM5L2SA4t6jld4qTBSzQ=";
   };
 
   nativeBuildInputs = [
···
     hatchling
   ];
 
-  propagatedBuildInputs = lib.optionals (pythonOlder "3.8") [
-    typing-extensions
-  ];
-
   nativeCheckInputs = [
     freezegun
     pretend
···
     twisted
   ];
 
-  disabledTests = [
-    # _pickle.PicklingError: Only BytesLoggers to sys.stdout and sys.stderr can be pickled.
-    "test_pickle"
-  ];
-
   pythonImportsCheck = [
     "structlog"
   ];
···
     homepage = "https://github.com/hynek/structlog";
     changelog = "https://github.com/hynek/structlog/blob/${version}/CHANGELOG.md";
     license = licenses.asl20;
-    maintainers = with maintainers; [ ];
+    maintainers = with maintainers; [ dotlambda ];
   };
 }

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

···
+{ lib
+, buildPythonPackage
+, pythonOlder
+, fetchFromGitHub
+, setuptools
+, aiohttp
+, incremental
+, systembridgemodels
+}:
+
+buildPythonPackage rec {
+  pname = "systembridgeconnector";
+  version = "4.0.1";
+  pyproject = true;
+
+  disabled = pythonOlder "3.11";
+
+  src = fetchFromGitHub {
+    owner = "timmo001";
+    repo = "system-bridge-connector";
+    rev = "refs/tags/${version}";
+    hash = "sha256-dMOhw7e2sCmGItsgGcGxYVCIJM2FBm6IyxIQXPtY+Pg=";
+  };
+
+  nativeBuildInputs = [
+    setuptools
+  ];
+
+  propagatedBuildInputs = [
+    aiohttp
+    incremental
+    systembridgemodels
+  ];
+
+  pythonImportsCheck = [ "systembridgeconnector" ];
+
+  # upstream has no tests
+  doCheck = false;
+
+  meta = {
+    changelog = "https://github.com/timmo001/system-bridge-connector/releases/tag/${version}";
+    description = "This is the connector package for the System Bridge project";
+    homepage = "https://github.com/timmo001/system-bridge-connector";
+    license = lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ dotlambda ];
+  };
+}

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

···
+{ lib
+, buildPythonPackage
+, pythonOlder
+, fetchFromGitHub
+, fetchpatch2
+, setuptools
+, incremental
+}:
+
+buildPythonPackage rec {
+  pname = "systembridgemodels";
+  version = "4.0.0";
+  pyproject = true;
+
+  disabled = pythonOlder "3.11";
+
+  src = fetchFromGitHub {
+    owner = "timmo001";
+    repo = "system-bridge-models";
+    rev = "refs/tags/${version}";
+    hash = "sha256-4nbTsVRqtoX4UhTrQS4HwoLtx0RO1VA8UewSAWOSsik=";
+  };
+
+  patches = [
+    (fetchpatch2 {
+      url = "https://github.com/timmo001/system-bridge-models/commit/7cd506760fd47c0f3717b6fcfe127b673e3198f8.patch";
+      hash = "sha256-i+GCcoyX07ii9Kj46dtAlT85jUKfF0KHEH9++UTjiik=";
+    })
+  ];
+
+  nativeBuildInputs = [
+    setuptools
+  ];
+
+  propagatedBuildInputs = [
+    incremental
+  ];
+
+  pythonImportsCheck = [ "systembridgemodels" ];
+
+  # upstream has no tests
+  doCheck = false;
+
+  meta = {
+    changelog = "https://github.com/timmo001/system-bridge-models/releases/tag/${version}";
+    description = "This is the models package used by the System Bridge project";
+    homepage = "https://github.com/timmo001/system-bridge-models";
+    license = lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ dotlambda ];
+  };
+}

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

···
 
 buildPythonPackage rec {
   pname = "teslajsonpy";
-  version = "3.9.11";
+  version = "3.10.0";
   format = "pyproject";
 
   disabled = pythonOlder "3.7";
···
     owner = "zabuldon";
     repo = pname;
     rev = "refs/tags/v${version}";
-    hash = "sha256-oGYXhSMwG566xdGCDMz9ajJ4HJXXcYBAJQf035iJQvE=";
+    hash = "sha256-7pT3LXBbE4/QRfmTWAJG6yarU787r2tjXRiv7ySvuSs=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "ytmusicapi";
-  version = "1.5.2";
+  version = "1.5.3";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "sigma67";
     repo = "ytmusicapi";
     rev = "refs/tags/${version}";
-    hash = "sha256-3dJ9Mu1cblBJh3BVEyxdfO+RD8kSxpdvnvox7ljMWT4=";
+    hash = "sha256-X4bfGYFttuEMwDyjqzDe3RJGkAvVUs91hEL0JfXrdIM=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "zamg";
-  version = "0.3.5";
+  version = "0.3.6";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "killer0071234";
     repo = "python-zamg";
     rev = "refs/tags/v${version}";
-    hash = "sha256-lT345G0apo4ncM4FMs69+ql+QxvTlsEtG2KRX4oYvlo=";
+    hash = "sha256-j864+3c0GDDftdLqLDD0hizT54c0IgTjT77jOneXlq0=";
   };
 
   postPatch = ''

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

···
   ovirt-engine-sdk = attrs: {
     buildInputs = [ curl libxml2 ];
     dontBuild = false;
-    patches = [
-      # fix ruby 3.1 https://github.com/oVirt/ovirt-engine-sdk-ruby/pull/3
-      (fetchpatch {
-        url = "https://github.com/oVirt/ovirt-engine-sdk-ruby/pull/3/commits/b596b919bc7857fdc0fc1c61a8cb7eab32cfc2db.patch";
-        hash = "sha256-AzGTQaD/e6X4LOMuXhy/WhbayhWKYCGHXPFlzLRWyPM=";
-        stripLen = 1;
-      })
-    ];
   };
 
   pango = attrs: {

pkgs/development/tools/analysis/flow/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "flow";
-  version = "0.229.1";
+  version = "0.229.2";
 
   src = fetchFromGitHub {
     owner = "facebook";
     repo = "flow";
     rev = "v${version}";
-    hash = "sha256-zovtSY37f7WKwE0Mjl9Vc+RcYjqMRhPHafN50XAj5cE=";
+    hash = "sha256-PoEtXk8EqlFgy33akd6na50P/tT6uWtEq+kfbayDo5s=";
   };
 
   postPatch = ''

pkgs/development/tools/aws-sam-cli/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "aws-sam-cli";
-  version = "1.103.0";
-  format = "pyproject";
+  version = "1.110.0";
+  pyproject = true;
 
   disabled = python3.pythonOlder "3.8";
 
···
     owner = "aws";
     repo = "aws-sam-cli";
     rev = "refs/tags/v${version}";
-    hash = "sha256-oy0+dAA6x8Jl1nZ1wjsR9xvpR9biemTtqL9B1awz4BM=";
+    hash = "sha256-FJHHEsdi2uGP9/GxrANsVEuxZiS4M4BPBGoARQBQpkA=";
   };
 
   nativeBuildInputs = with python3.pkgs; [
···
   ];
 
   pythonRelaxDeps = [
+    "aws-lambda-builders"
     "aws-sam-translator"
     "boto3-stubs"
-    "tzlocal"
+    "cfn-lint"
     "cookiecutter"
     "docker"
-    "aws-lambda-builders"
+    "jsonschema"
+    "pyopenssl"
+    "rich"
+    "ruamel-yaml"
     "tomlkit"
-    "rich"
-    "jsonschema"
+    "tzlocal"
   ];
 
   propagatedBuildInputs = with python3.pkgs; [
···
       --prefix PATH : $out/bin:${lib.makeBinPath [ git ]}
   '';
 
-  doCheck = true;
-
   nativeCheckInputs = with python3.pkgs; [
     filelock
     flaky
     parameterized
     psutil
+    pytest-timeout
     pytest-xdist
     pytestCheckHook
   ];
···
 
   pytestFlagsArray = [
     "tests"
+    # Disable warnings
+    "-W"
+    "ignore::DeprecationWarning"
+  ];
 
+  disabledTestPaths = [
     # Disable tests that requires networking or complex setup
-    "--ignore=tests/end_to_end"
-    "--ignore=tests/integration"
-    "--ignore=tests/regression"
-    "--ignore=tests/smoke"
-    "--ignore=tests/unit/lib/telemetry"
-
+    "tests/end_to_end"
+    "tests/integration"
+    "tests/regression"
+    "tests/smoke"
+    "tests/unit/lib/telemetry"
     # Disable flaky tests
-    "--ignore=tests/unit/lib/samconfig/test_samconfig.py"
-    "--deselect=tests/unit/lib/sync/flows/test_rest_api_sync_flow.py::TestRestApiSyncFlow::test_update_stage"
-    "--deselect=tests/unit/lib/sync/flows/test_rest_api_sync_flow.py::TestRestApiSyncFlow::test_delete_deployment"
-    "--deselect=tests/unit/local/lambda_service/test_local_lambda_invoke_service.py::TestValidateRequestHandling::test_request_with_no_data"
+    "tests/unit/lib/samconfig/test_samconfig.py"
+  ];
 
-    # Disable warnings
-    "-W ignore::DeprecationWarning"
+  disabledTests = [
+    # Disable flaky tests
+    "test_update_stage"
+    "test_delete_deployment"
+    "test_request_with_no_data"
   ];
 
   pythonImportsCheck = [

pkgs/development/tools/build-managers/gprbuild/default.nix pkgs/development/ada-modules/gprbuild/default.nix

···
   # link gprconfig_kb db from gprbuild-boot into build dir,
   # the install process copies its contents to $out
   preInstall = ''
-    ln -sf ${gprbuild-boot}/share/gprconfig share/gprconfig
+    # Use PATH to discover spliced gprbuild-boot from buildPackages,
+    # since path interpolation would give us gprbuild-boot from pkgsHostTarget
+    gprbuild_boot="$(dirname "$(type -p gprbuild)")/.."
+    ln -sf "$gprbuild_boot/share/gprconfig" share/gprconfig
   '';
 
   # no need for the install script

pkgs/development/tools/continuous-integration/drone-runner-docker/default.nix

···
   vendorHash = "sha256-KcNp3VdJ201oxzF0bLXY4xWHqHNz54ZrVSI96cfhU+k=";
 
   meta = with lib; {
-    maintainers = with maintainers; [ endocrimes emilylange ];
+    maintainers = with maintainers; [ endocrimes ];
     license = licenses.unfreeRedistributable;
     homepage = "https://github.com/drone-runners/drone-runner-docker";
     description = "Drone pipeline runner that executes builds inside Docker containers";

pkgs/development/tools/electron/binary/generic.nix

···
 , mesa
 , libxkbcommon
 , libxshmfence
-, libglvnd
+, libGL
 , alsa-lib
 , cairo
 , cups
···
     ++ lib.optionals (lib.versionOlder version "10.0.0") [ libXScrnSaver ]
     ++ lib.optionals (lib.versionAtLeast version "11.0.0") [ libxkbcommon ]
     ++ lib.optionals (lib.versionAtLeast version "12.0.0") [ libxshmfence ]
-    ++ lib.optionals (lib.versionAtLeast version "17.0.0") [ libglvnd ]
+    ++ lib.optionals (lib.versionAtLeast version "17.0.0") [ libGL ]
   );
 
   linux = {
···
         --set-rpath "${electronLibPath}:$out/libexec/electron" \
         $out/libexec/electron/.electron-wrapped \
         ${lib.optionalString (lib.versionAtLeast version "15.0.0") "$out/libexec/electron/.chrome_crashpad_handler-wrapped" }
+
+      # patch libANGLE
+      patchelf \
+        --set-rpath "${lib.makeLibraryPath [ libGL pciutils ]}" \
+        $out/libexec/electron/lib*GL*
     '';
   };
 

pkgs/development/tools/misc/kool/default.nix

···
 
 buildGoModule rec {
   pname = "kool";
-  version = "3.0.0";
+  version = "3.1.0";
 
   src = fetchFromGitHub {
     owner = "kool-dev";
     repo = "kool";
     rev = version;
-    hash = "sha256-+vdizU2/q2nrEanpRPy1scgfTYh/I7feW4jz8efelWY=";
+    hash = "sha256-apecHILrtvzD1bAOuyhSokDqBB2UgCavQXOw4dQSPwc=";
   };
 
   vendorHash = "sha256-PmS96KVhe9TDmtYBx2hROLCbGMQ0OY3MN405dUmxPzk=";

pkgs/development/tools/rojo/default.nix

···
 in
 rustPlatform.buildRustPackage rec {
   pname = "rojo";
-  version = "7.4.0";
+  version = "7.4.1";
 
   src = fetchFromGitHub {
     owner = "rojo-rbx";
     repo = "rojo";
     rev = "v${version}";
-    sha256 = "sha256-Eh1G0jX9KXVlMZLl8whxULywadblWml232qvcq4JLJ4=";
+    hash = "sha256-7fnzNYAbsZW/48C4dwpMXXQy2ZgxbYFSs85wNKGcu/4=";
     fetchSubmodules = true;
   };
 
-  cargoSha256 = "sha256-aKfgylY9aspL1JpdYa6hOy/6lQoqO54OhZWqSlMPZ8o=";
+  cargoHash = "sha256-9kmSNWsZY0OcqaYOCblMwkXTdGXhj7f/2pUDx/L/o2o=";
 
   nativeBuildInputs = [
     pkg-config

pkgs/development/tools/rust/ravedude/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "ravedude";
-  version = "0.1.6";
+  version = "0.1.7";
 
   src = fetchCrate {
     inherit pname version;
-    hash = "sha256-LhPRz3DUMDoe50Hq3yO+2BHpyh5fQ4sMNGLttjkdSZw=";
+    hash = "sha256-p5pbxnoUBhdDf7acpLStgBvoWZyFYNHxTwzDhGSApRM=";
   };
 
-  cargoHash = "sha256-Uo8wlTAHBkn/WeGPhPP+BU80wjSyNHsWQj8QvA7mHrk=";
+  cargoHash = "sha256-L7eXSji+irjwuOZ5uxqWK9SesRZrqEeoenJgMzqpszo=";
 
   nativeBuildInputs = [ pkg-config ];
 

pkgs/games/libremines/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libremines";
-  version = "1.10.0";
+  version = "2.0.0";
 
   src = fetchFromGitHub {
     owner = "Bollos00";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-aqWzTvvRoke+Rakb6dNpDoD7haKHEKW3XARGLrH2WiY=";
+    hash = "sha256-LejDXjli+AEVGp23y+ez/NyJY/8w7uHcOij6RsDwIH4=";
   };
 
   nativeBuildInputs = [ cmake wrapQtAppsHook ];

pkgs/games/papermc/default.nix

···
 }:
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "papermc";
-  version = "1.20.2.234";
+  version = "1.20.4.435";
 
   src =
     let
···
     in
     fetchurl {
       url = "https://papermc.io/api/v2/projects/paper/versions/${mcVersion}/builds/${buildNum}/downloads/paper-${mcVersion}-${buildNum}.jar";
-      hash = "sha256-fR7Dq09iFGVXodQjrS7Hg4NcrKPJbNg0hexU520JC6c=";
+      hash = "sha256-NrIsYLoAAWORw/S26NDFjYBVwpNITJxuWGZow3696wM=";
     };
 
   installPhase = ''

pkgs/misc/cups/drivers/foomatic-db/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "foomatic-db";
-  version = "unstable-2023-09-02";
+  version = "unstable-2024-02-09";
 
   src = fetchFromGitHub {
     # there is also a daily snapshot at the `downloadPage`,
     # but it gets deleted quickly and would provoke 404 errors
     owner = "OpenPrinting";
     repo = "foomatic-db";
-    rev = "4e6ab90da63afddee33d80115acb44149d2d292b";
-    hash = "sha256-wtDGJUyViiCenCY4zvr0Ia4ecZpoDsDSWwlYYs3YMT8=";
+    rev = "f8b43644771612f854fecda969440511de784bf0";
+    hash = "sha256-8Pui83Z7g5aHBJk46AYeKil/0++I6zcc5S/BWRuy1WM=";
   };
 
   buildInputs = [ cups cups-filters ghostscript gnused perl ];

pkgs/misc/drivers/epkowa/default.nix

···
     };
     meta = common_meta // { description = "Plugin to support " + passthru.hw + " scanner in sane"; };
   };
+  v550 = stdenv.mkDerivation rec {
+    pname = "iscan-perfection-v550-bundle";
+    version = "2.30.4";
+
+    nativeBuildInputs = [ autoPatchelfHook rpm ];
+    src = fetchurl {
+      urls = [
+        "https://download2.ebz.epson.net/iscan/plugin/perfection-v550/rpm/x64/iscan-perfection-v550-bundle-${version}.x64.rpm.tar.gz"
+        "https://web.archive.org/web/https://download2.ebz.epson.net/iscan/plugin/perfection-v550/rpm/x64/iscan-perfection-v550-bundle-${version}.x64.rpm.tar.gz"
+      ];
+      sha256 = "f8b3abf21354fc5b9bc87753cef950b6c0f07bf322a94aaff2c163bafcf50cd9";
+    };
+    installPhase = ''
+      cd plugins
+      ${rpm}/bin/rpm2cpio iscan-plugin-perfection-v550-*.x86_64.rpm | ${cpio}/bin/cpio -idmv
+      mkdir $out
+      cp -r usr/share $out
+      cp -r usr/lib64 $out/lib
+      mv $out/share/iscan $out/share/esci
+      mv $out/lib/iscan $out/lib/esci
+    '';
+    passthru = {
+      registrationCommand = ''
+        $registry --add interpreter usb 0x04b8 0x013b "$plugin/lib/esci/libiscan-plugin-perfection-v550 $plugin/share/esci/esfweb.bin"
+      '';
+      hw = "Perfection V550 Photo";
+    };
+    meta = common_meta // { description = "Plugin to support " + passthru.hw + " scanner in sane"; };
+  };
   v600 = stdenv.mkDerivation rec {
     pname = "iscan-gt-x820-bundle";
     version = "2.30.4";

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

···
 
 stdenv.mkDerivation rec {
   name = "facetimehd-${version}-${kernel.version}";
-  version = "0.5.18";
+  version = "0.6.8";
 
   # Note: When updating this revision:
   # 1. Also update pkgs/os-specific/linux/firmware/facetimehd-firmware/
···
     owner = "patjak";
     repo = "facetimehd";
     rev = version;
-    sha256 = "sha256-UO8t2zrfdJlu4uzhhyWOuHIjJNVezIq3nUPGZeW/KJU=";
+    sha256 = "sha256-Tze85Hx1YmStAKenmF/S1JuMDq5eVjBcs3LSWXjyE7w=";
   };
 
   preConfigure = ''

pkgs/os-specific/linux/nvidia-x11/default.nix

···
 
   # Last one supporting Kepler architecture
   legacy_470 = generic {
-    version = "470.223.02";
-    sha256_64bit = "sha256-s2hi1TNsw+br6Ow6tPiFsYPaJY8d+x4FrkBrP2xNRPg=";
-    sha256_aarch64 = "sha256-CFkg2ARlGWqlFQKm8SlbwMH6eLidHKA/q5QGVOpPGuU=";
-    settingsSha256 = "sha256-r6DuIH/rnsCm/y51iRgPNi5/kz+EFMVABREdTjBneZ0=";
-    persistencedSha256 = "sha256-e71fpPBBv8S/aoeXxBXkzKy5bsMMbv8y024cSLc8DYc=";
-
-    patches = [ rcu_patch ];
+    version = "470.239.06";
+    sha256_64bit = "sha256-fXTKrBQKBDLXnr6OQzDceW85un3UCz/NYd92AYG/nMw=";
+    sha256_aarch64 = "sha256-NZj8OLQ0N7y3V7UBamLyJE8AbI3alZJD1weNjnssuNs=";
+    settingsSha256 = "sha256-2YTk6DaoB8Qvob9/ohtHXuDhxGO9O/SUwlXXbLSgJP0=";
+    persistencedSha256 = "sha256-wLrkfD8MQ8sMODE+yEnWg/1ETxYVWOqNsIj1dY+5yjc=";
   };
 
   # Last one supporting x86

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

···
 
 stdenv.mkDerivation rec {
   name = "virtio_vmmci";
-  version = "0.5.0";
+  version = "0.6.0";
 
   src = fetchFromGitHub {
     owner = "voutilad";
     repo = "virtio_vmmci";
     rev = version;
-    hash = "sha256-ZHslYYZFjM3wp0W5J3/WwCtQ2wDzT1jNc26Z/giTC8g=";
+    hash = "sha256-dMh6bqlhsp/cWKqiJ9xjVI9yJj2w1ap7agKSnRjadXA=";
   };
 
   hardeningDisable = [ "pic" "format" ];

pkgs/servers/home-assistant/component-packages.nix

···
       ifaddr
       psutil-home-assistant
       sqlalchemy
+      systembridgeconnector
       zeroconf
-    ]; # missing inputs: systembridgeconnector
+    ];
     "system_health" = ps: with ps; [
       aiohttp-cors
       aiohttp-fast-url-dispatcher
···
     "syncthing"
     "syncthru"
     "synology_dsm"
+    "system_bridge"
     "system_health"
     "system_log"
     "systemmonitor"

pkgs/servers/home-assistant/custom-lovelace-modules/multiple-entity-row/default.nix

···
 
 mkYarnPackage rec {
   pname = "multiple-entity-row";
-  version = "4.5.0";
+  version = "4.5.1";
 
   src = fetchFromGitHub {
     owner = "benct";
     repo = "lovelace-multiple-entity-row";
     rev = "v${version}";
-    hash = "sha256-3CkBzxB3bX4jwk71PaRMX1MkAb6UVOBqZCYpTN7VORY=";
+    hash = "sha256-CXRgXyH1NUg7ssQhenqP0tXr1m2qOkHna3Rf30K3SjI=";
   };
 
   packageJSON = ./package.json;

pkgs/servers/home-assistant/custom-lovelace-modules/multiple-entity-row/package.json

···
 {
   "name": "multiple-entity-row",
-  "version": "4.5.0",
+  "version": "4.5.1",
   "description": "Show multiple entity states, attributes and icons on entity rows in Home Assistant's Lovelace UI",
   "keywords": [
     "home-assistant",

pkgs/servers/homepage-dashboard/default.nix

···
 , fetchpatch
 , makeBinaryWrapper
 , nixosTests
+, enableLocalIcons ? false
 }:
+let
+  dashboardIcons = fetchFromGitHub {
+    owner = "walkxcode";
+    repo = "dashboard-icons";
+    rev = "a02a5999fe56948671721da8b0830cdd5b609ed7"; # Until 2024-02-25
+    hash = "sha256-s0Doh4j6CH66fZoQKMt4yc7aLStNFGMVoDp5dvs7+pk=";
+  };
 
+  installLocalIcons = ''
+    mkdir -p $out/share/homepage/public/icons
+    cp ${dashboardIcons}/png/* $out/share/homepage/public/icons
+    cp ${dashboardIcons}/svg/* $out/share/homepage/public/icons
+    cp ${dashboardIcons}/LICENSE $out/share/homepage/public/icons/
+  '';
+in
 buildNpmPackage rec {
   pname = "homepage-dashboard";
   version = "0.8.8";
···
   installPhase = ''
     runHook preInstall
 
-    mkdir -p $out
-    cp -r .next/standalone $out/bin
-    cp -r public $out/bin/public
+    mkdir -p $out/{share,bin}
 
-    mkdir -p $out/bin/.next
-    cp -r .next/static $out/bin/.next/static
+    cp -r .next/standalone $out/share/homepage/
+    cp -r public $out/share/homepage/public
 
-    mv $out/bin/server.js $out/bin/homepage
-    chmod +x $out/bin/homepage
+    mkdir -p $out/share/homepage/.next
+    cp -r .next/static $out/share/homepage/.next/static
+
+    chmod +x $out/share/homepage/server.js
 
-    wrapProgram $out/bin/homepage \
+    makeWrapper $out/share/homepage/server.js $out/bin/homepage \
       --set-default PORT 3000 \
       --set-default HOMEPAGE_CONFIG_DIR /var/lib/homepage-dashboard
+
+    ${if enableLocalIcons then installLocalIcons else ""}
 
     runHook postInstall
   '';

pkgs/servers/mail/rspamd/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "rspamd";
-  version = "3.8.2";
+  version = "3.8.3";
 
   src = fetchFromGitHub {
     owner = "rspamd";
     repo = "rspamd";
     rev = version;
-    hash = "sha256-02Ykj4qo821iJa4AqS3XfSBm1nqBxRKC2IgTgbdiRss=";
+    hash = "sha256-LX37HE4xr3tJqAXBDbi2O8N9tt8DazslIfmqG9hNiKw=";
   };
 
   hardeningEnable = [ "pie" ];

pkgs/servers/monitoring/prometheus/statsd-exporter.nix

···
     hash = "sha256-C7+4v40T667KJHEQ3ebLDg2wJNrxD/nossfT6rMlER8=";
   };
 
+  ldflags =
+    let
+      t = "github.com/prometheus/common/version";
+    in
+    [ "-s" "-w"
+      "-X ${t}.Version=${version}"
+      "-X ${t}.Revision=unknown"
+      "-X ${t}.Branch=unknown"
+      "-X ${t}.BuildUser=nix@nixpkgs"
+      "-X ${t}.BuildDate=unknown"
+    ];
+
   vendorHash = "sha256-scBpRZeECgAtpu9lnkIk1I2c8UmAkEL8LYNPUeUNYto=";
 
   meta = with lib; {

pkgs/servers/monitoring/zabbix/agent.nix

···
 { lib, stdenv, fetchurl, pkg-config, libiconv, openssl, pcre }:
 
-import ./versions.nix ({ version, sha256, ... }:
+import ./versions.nix ({ version, hash, ... }:
   stdenv.mkDerivation {
     pname = "zabbix-agent";
     inherit version;
 
     src = fetchurl {
       url = "https://cdn.zabbix.com/zabbix/sources/stable/${lib.versions.majorMinor version}/zabbix-${version}.tar.gz";
-      inherit sha256;
+      inherit hash;
     };
 
     nativeBuildInputs = [ pkg-config ];

pkgs/servers/monitoring/zabbix/agent2.nix

···
 { lib, buildGoModule, fetchurl, autoreconfHook, pkg-config, libiconv, openssl, pcre, zlib }:
 
-import ./versions.nix ({ version, sha256, vendorHash ? throw "unsupported version ${version} for zabbix-agent2", ... }:
+import ./versions.nix ({ version, hash, vendorHash ? throw "unsupported version ${version} for zabbix-agent2", ... }:
   buildGoModule {
     pname = "zabbix-agent2";
     inherit version;
 
     src = fetchurl {
       url = "https://cdn.zabbix.com/zabbix/sources/stable/${lib.versions.majorMinor version}/zabbix-${version}.tar.gz";
-      inherit sha256;
+      inherit hash;
     };
 
     modRoot = "src/go";

pkgs/servers/monitoring/zabbix/proxy.nix

···
 let
   inherit (lib) optional optionalString;
 in
-  import ./versions.nix ({ version, sha256, ... }:
+  import ./versions.nix ({ version, hash, ... }:
     stdenv.mkDerivation {
       pname = "zabbix-proxy";
       inherit version;
 
       src = fetchurl {
         url = "https://cdn.zabbix.com/zabbix/sources/stable/${lib.versions.majorMinor version}/zabbix-${version}.tar.gz";
-        inherit sha256;
+        inherit hash;
       };
 
       nativeBuildInputs = [ pkg-config ];

pkgs/servers/monitoring/zabbix/server.nix

···
 let
   inherit (lib) optional optionalString;
 in
-  import ./versions.nix ({ version, sha256, ... }:
+  import ./versions.nix ({ version, hash, ... }:
     stdenv.mkDerivation {
       pname = "zabbix-server";
       inherit version;
 
       src = fetchurl {
         url = "https://cdn.zabbix.com/zabbix/sources/stable/${lib.versions.majorMinor version}/zabbix-${version}.tar.gz";
-        inherit sha256;
+        inherit hash;
       };
 
       nativeBuildInputs = [ autoreconfHook pkg-config ];

pkgs/servers/monitoring/zabbix/versions.nix

···
 generic: {
   v60 = generic {
-    version = "6.0.21";
-    sha256 = "sha256-hdKPI5UEQvF/URH2eLWW32az3LMEse3UXIELOsfvwzk=";
+    version = "6.0.26";
+    hash = "sha256-MIOKe5hqfDecB1oWZKzbFmJCsQLuAGtp21l2WxxVG+g=";
     vendorHash = null;
   };
 
   v50 = generic {
-    version = "5.0.37";
-    sha256 = "sha256-+C5fI+eMJKsynVnVJIYj27x1iFQwaG9Fnho0BXgENQI=";
-    vendorHash = "sha256-oSZBzIUL1yHXk7PnkSAlhI0i89aGMFrFHmbMN9rDAJ0=";
+    version = "5.0.41";
+    hash = "sha256-pPvw0lPoK1IpsXc5c8Qu9zFhx2oHJz2bwiX80vrYa58=";
+    vendorHash = "sha256-qLDoNnEFiSrWXbLtYlmQaqY8Rv6JaG8WbMYBlry5Evc=";
   };
 }

pkgs/servers/monitoring/zabbix/web.nix

···
 { lib, stdenv, fetchurl, writeText }:
 
-import ./versions.nix ({ version, sha256, ... }:
+import ./versions.nix ({ version, hash, ... }:
   stdenv.mkDerivation rec {
     pname = "zabbix-web";
     inherit version;
 
     src = fetchurl {
       url = "https://cdn.zabbix.com/zabbix/sources/stable/${lib.versions.majorMinor version}/zabbix-${version}.tar.gz";
-      inherit sha256;
+      inherit hash;
     };
 
     phpConfig = writeText "zabbix.conf.php" ''

pkgs/servers/sql/postgresql/ext/pg_net.nix

···
 
 stdenv.mkDerivation rec {
   pname = "pg_net";
-  version = "0.7.3";
+  version = "0.8.0";
 
   buildInputs = [ curl postgresql ];
 
···
     owner  = "supabase";
     repo   = pname;
     rev    = "refs/tags/v${version}";
-    hash   = "sha256-j5qLgn/i4ljysuwgT46579N+9VpGr483vQEX/3lUYFA=";
+    hash   = "sha256-ZPsRPWV1G3lMM2mT+H139Wvgoy8QnmeUbzEnGeDJmZA=";
   };
+
+  env.NIX_CFLAGS_COMPILE = "-Wno-error";
 
   installPhase = ''
     mkdir -p $out/{lib,share/postgresql/extension}

pkgs/servers/tang/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "tang";
-  version = "14";
+  version = "15";
 
   src = fetchFromGitHub {
     owner = "latchset";
     repo = "tang";
     rev = "refs/tags/v${version}";
-    hash = "sha256-QKURKb2g71pZvuZlJk3Rc26H3oU0WSkjgQtJQLrYGbw=";
+    hash = "sha256-nlC2hdNzQZrfirjS2gX4oFp2OD1OdxmLsN03hfxD3ug=";
   };
 
   nativeBuildInputs = [

pkgs/servers/web-apps/changedetection-io/default.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "changedetection-io";
-  version = "0.45.9";
+  version = "0.45.14";
   format = "setuptools";
 
   src = fetchFromGitHub {
     owner = "dgtlmoon";
     repo = "changedetection.io";
     rev = version;
-    hash = "sha256-xiKXp9DBaiSteqZwQLZ4zLwT5MeETJx01rKRrWGYioc=";
+    hash = "sha256-O+kWivVc/FZmIDjOE/fsUccrOyHrQ8GakjulEnm4w88=";
   };
 
   postPatch = ''
     substituteInPlace requirements.txt \
-      --replace "apprise~=1.6.0" "apprise" \
+      --replace "apprise~=1.7.1" "apprise" \
       --replace "cryptography~=3.4" "cryptography" \
       --replace "dnspython~=2.4" "dnspython" \
       --replace "pytest ~=7.2" "" \
···
     jinja2-time
     jsonpath-ng
     jq
+    loguru
     lxml
     paho-mqtt
     pillow
···
     changelog = "https://github.com/dgtlmoon/changedetection.io/releases/tag/${version}";
     license = licenses.asl20;
     maintainers = with maintainers; [ mikaelfangel ];
+    mainProgram = "changedetection.io";
   };
 }

pkgs/tools/audio/audiowaveform/default.nix

···
     sha256 = "sha256-FcQq0xWs3jH2MfhFQ5r5Vaz8B3akBHBSg8Z/k9An/Wg=";
   };
 
+  cmakeFlags = [
+    # gtest no longer supports C++11.
+    "-DCMAKE_CXX_STANDARD=14"
+  ];
+
   nativeBuildInputs = [ cmake gtest ];
 
   buildInputs = [ boost gd libsndfile libmad libid3tag ];

pkgs/tools/audio/whisper-ctranslate2/default.nix

···
 }:
 let
   pname = "whisper-ctranslate2";
-  version = "0.3.9";
+  version = "0.4.1";
 in
 python3.pkgs.buildPythonApplication {
   inherit pname version;
···
     owner = "Softcatala";
     repo = "whisper-ctranslate2";
     rev = version;
-    hash = "sha256-dm8LPcAVxEvhFDEkZcFXFZLfEZTtKzTqBqWKfXbXn5Q=";
+    hash = "sha256-kFln/AqKjnEK5L9hOqGpyoRjNG+dagBIGrmq2C+OZOY=";
   };
 
   propagatedBuildInputs = with python3.pkgs; [

pkgs/tools/backup/borgmatic/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "borgmatic";
-  version = "1.8.1";
+  version = "1.8.8";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "sha256-XbihTQJtoiRRfwjMCP+XEPmbt7//zFPx1fIWOvn92Nc=";
+    sha256 = "sha256-dPWp8SH4//HJlCrF6YRaMb32idox1E0/Gd8qc/GmP4c=";
   };
 
-  nativeCheckInputs = with python3Packages; [ flexmock pytestCheckHook pytest-cov ];
+  nativeCheckInputs = with python3Packages; [ flexmock pytestCheckHook pytest-cov ] ++ passthru.optional-dependencies.apprise;
 
   # - test_borgmatic_version_matches_news_version
   # The file NEWS not available on the pypi source, and this test is useless
···
     requests
     setuptools
   ];
+
+  passthru.optional-dependencies = {
+    apprise = with python3Packages; [ apprise ];
+  };
 
   postInstall = ''
     installShellCompletion --cmd borgmatic \

pkgs/tools/misc/esphome/default.nix

···
     colorama
     cryptography
     esphome-dashboard
+    icmplib
     kconfiglib
-    icmplib
+    packaging
     paho-mqtt
     pillow
     platformio

pkgs/tools/misc/faketty/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "faketty";
-  version = "1.0.14";
+  version = "1.0.15";
 
   src = fetchCrate {
     inherit pname version;
-    hash = "sha256-oma8Vmp1AMmEGyZG8i/ztiyYH0RrLZ/l/vXgPJs+5o0=";
+    hash = "sha256-f32Y9Aj4Z9y6Da9rbRgwi9BGPl4FsI790BH52cIIoPA=";
   };
 
-  cargoHash = "sha256-+gojthIR5WMSjN1gCUyN0cKHWYBKBezsckVZJD7JncM=";
+  cargoHash = "sha256-+M1oq2CHUK6CIDFiUNLjO1UmHI19D5zdHVl8dvmQ1G8=";
 
   postPatch = ''
     patchShebangs tests/test.sh

pkgs/tools/misc/fend/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "fend";
-  version = "1.4.0";
+  version = "1.4.3";
 
   src = fetchFromGitHub {
     owner = "printfn";
-    repo = pname;
+    repo = "fend";
     rev = "v${version}";
-    sha256 = "sha256-s6b15FhVfEwsHtVt4bhd6LDxl/WW1PXlUrH2XFOTT5E=";
+    hash = "sha256-X96r5wN5eq1PZD/JGqnG/0kg6PYEdnj5h9zc+GXQjQM=";
   };
 
-  cargoHash = "sha256-Ilsv0mo7/4eEdRH3jWZXdF4LSYYdWr6gCvnMMAZn5j0=";
+  cargoHash = "sha256-UIZs45OQ1j57VEb6g4P0AwjmEsjMt0am5FUXXDODaWI=";
 
   nativeBuildInputs = [ pandoc installShellFiles copyDesktopItems ];
   buildInputs = lib.optionals stdenv.isDarwin [ darwin.apple_sdk.frameworks.Security ];
···
   '';
 
   postInstall = ''
-    install -D -m 444 $src/icon/fend-icon-256.png $out/share/icons/hicolor/256x256/apps/fend.png
+    install -D -m 444 $src/icon/icon.svg $out/share/icons/hicolor/scalable/apps/fend.svg
   '';
 
   desktopItems = [

pkgs/tools/misc/tagref/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "tagref";
-  version = "1.9.0";
+  version = "1.9.1";
 
   src = fetchFromGitHub {
     owner = "stepchowfun";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-SPmpQR4RMimU6RnljmqV9z0WvDRZkc+Y+C32BnNmK/E=";
+    sha256 = "sha256-4F9u1wzeBgYP3L6h08xMvgq62ix/SOaFaLl7uEf1j1c=";
   };
 
-  cargoHash = "sha256-VufTLK1LDQlIiNNsV9q24sHTmcT1Y7bCnhIXPRvuRAU=";
+  cargoHash = "sha256-AO6BGevCoLCH4vpyrXrgF3FrjUa3lHA7ynXfk4KKigM=";
 
   meta = with lib; {
     description = "Manage cross-references in your code";

pkgs/tools/misc/xq/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "xq";
-  version = "0.3.0";
+  version = "0.3.1";
 
   src = fetchCrate {
     inherit pname version;
-    sha256 = "sha256-mgvs3/gseLnFtAciW5txtYqo+8DyyQC7y/tN1kDqcb4=";
+    sha256 = "sha256-KR5gjRJH392s7Ue0F26slj4sRosFAAAahf6up+yOQno=";
   };
 
-  cargoHash = "sha256-lSyJqGWlk3ldgAkyebuyUDLp8mJdwnw8ee6ZHQXU2Y4=";
+  cargoHash = "sha256-eL7VFLRfRVF2seWgHLWGudsTt5u+JcnNrJiD7K47EPA=";
 
   meta = with lib; {
     description = "Pure rust implementation of jq";

pkgs/tools/networking/ddns-go/default.nix

···
 
 buildGoModule rec {
   pname = "ddns-go";
-  version = "6.0.3";
+  version = "6.1.2";
 
   src = fetchFromGitHub {
     owner = "jeessy2";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-hfL4heW2p1JdNEAQqsRMmvXSeBkw/zWfXk0YPXyqLXk=";
+    hash = "sha256-OKQRcYG3t7sU/HSmnkViWWm1is0fhrb6nyh8ahl/l6U=";
   };
 
-  vendorHash = "sha256-UsMeYI/YogTbwyaJjVZbGMbxa434BDRBF+5VoSk6G9k=";
+  vendorHash = "sha256-VCp+seFaYXElQmktYlWm+nW4gNwNocOVm7T+M6+AdNg=";
 
   ldflags = [
     "-X main.version=${version}"

pkgs/tools/security/metasploit/Gemfile

···
 # frozen_string_literal: true
 source "https://rubygems.org"
 
-gem "metasploit-framework", git: "https://github.com/rapid7/metasploit-framework", ref: "refs/tags/6.3.56"
+gem "metasploit-framework", git: "https://github.com/rapid7/metasploit-framework", ref: "refs/tags/6.3.57"

pkgs/tools/security/metasploit/Gemfile.lock

···
 GIT
   remote: https://github.com/rapid7/metasploit-framework
-  revision: ff8298ede09a5e825d5d53775f36d60cd4110f17
-  ref: refs/tags/6.3.56
+  revision: e01334b3bd267539df650f14627231fb8e4bc21d
+  ref: refs/tags/6.3.57
   specs:
-    metasploit-framework (6.3.56)
+    metasploit-framework (6.3.57)
       actionpack (~> 7.0.0)
       activerecord (~> 7.0.0)
       activesupport (~> 7.0.0)
···
       metasploit-concern
       metasploit-credential
       metasploit-model
-      metasploit-payloads (= 2.0.165)
+      metasploit-payloads (= 2.0.166)
       metasploit_data_models
       metasploit_payloads-mettle (= 1.0.26)
       mqtt
···
       activemodel (~> 7.0)
       activesupport (~> 7.0)
       railties (~> 7.0)
-    metasploit-payloads (2.0.165)
+    metasploit-payloads (2.0.166)
     metasploit_data_models (6.0.3)
       activerecord (~> 7.0)
       activesupport (~> 7.0)

pkgs/tools/security/metasploit/default.nix

···
   };
 in stdenv.mkDerivation rec {
   pname = "metasploit-framework";
-  version = "6.3.56";
+  version = "6.3.57";
 
   src = fetchFromGitHub {
     owner = "rapid7";
     repo = "metasploit-framework";
     rev = "refs/tags/${version}";
-    hash = "sha256-BF/8+Quu8heS+VKn5ciHfZLTAmoliO25O4BccQBj4bE=";
+    hash = "sha256-MToWengiF4dacD6E0byZENNMh408d3YJ18sn93nEksI=";
   };
 
   nativeBuildInputs = [

pkgs/tools/security/metasploit/gemset.nix

···
     platforms = [];
     source = {
       fetchSubmodules = false;
-      rev = "ff8298ede09a5e825d5d53775f36d60cd4110f17";
-      sha256 = "1cg1cc072p407fwyv215d81d74kxhz4fb9sjz691gwmf1gwzqpq4";
+      rev = "e01334b3bd267539df650f14627231fb8e4bc21d";
+      sha256 = "1hljqiwzf9ybsw4pcxrwin3lrlqhk6yd311yf1d8f5r2g1x1cfii";
       type = "git";
       url = "https://github.com/rapid7/metasploit-framework";
     };
-    version = "6.3.56";
+    version = "6.3.57";
   };
   metasploit-model = {
     groups = ["default"];
···
     platforms = [];
     source = {
       remotes = ["https://rubygems.org"];
-      sha256 = "0v9vr3iklxm53vfkyiqja8a942n8r0a49w9rmvk9ql4h3r5xcgpw";
+      sha256 = "0f8grdgqn9y8wc61k111zlap5vqjika56k4vabkwglljs5bv44nk";
       type = "gem";
     };
-    version = "2.0.165";
+    version = "2.0.166";
   };
   metasploit_data_models = {
     groups = ["default"];

pkgs/tools/security/trufflehog/default.nix

···
 
 buildGoModule rec {
   pname = "trufflehog";
-  version = "3.68.1";
+  version = "3.68.2";
 
   src = fetchFromGitHub {
     owner = "trufflesecurity";
     repo = "trufflehog";
     rev = "refs/tags/v${version}";
-    hash = "sha256-KHMQnAI0t532YGOh7jtuuLCfRrXkzPuWOBEWaJ45HCs=";
+    hash = "sha256-6gQoyVlLE+cXYwh8lTkL2giDhd3ETgETjT3XuEOwOU8=";
   };
 
   vendorHash = "sha256-D58WqqDwQo7fRubkGNRhD6g9ooKS9peb2qJJDRXgLtk=";

pkgs/tools/text/csview/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "csview";
-  version = "1.2.2";
+  version = "1.2.3";
 
   src = fetchFromGitHub {
     owner = "wfxr";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-pv0zCtVHTjzkXK5EZhu6jviMJF0p9dvAuYcA6khiIos=";
+    sha256 = "sha256-O6IJGfJwGdtxLyUTFNHp9rGy05gVLlQTS8bTRsSYIuY=";
   };
 
-  cargoSha256 = "sha256-uMBwEbxI8hjoFMlH+oquHvKdyLUC9bnO5uMFHkyZjgY=";
+  cargoHash = "sha256-jwkoyvelxl2lJoOHznZDmd39GJMye/+vi7PjrzjlLk4=";
 
   meta = with lib; {
     description = "A high performance csv viewer with cjk/emoji support";

pkgs/top-level/ada-packages.nix

···
+{ lib
+, pkgs
+, makeScopeWithSplicing'
+, generateSplicesForMkScope
+, gnat
+}:
+let
+  gnat_version = lib.versions.major gnat.version;
+in
+makeScopeWithSplicing' {
+  otherSplices = generateSplicesForMkScope ("gnat" + gnat_version + "Packages");
+  f = (self: {
+    inherit gnat;
+
+    gprbuild-boot = self.callPackage ../development/ada-modules/gprbuild/boot.nix { };
+    gprbuild      = self.callPackage ../development/ada-modules/gprbuild { };
+
+    xmlada = self.callPackage ../development/ada-modules/xmlada { };
+
+    gnatprove = self.callPackage ../development/ada-modules/gnatprove {
+      ocamlPackages = pkgs.ocaml-ng.ocamlPackages_4_14;
+    };
+
+    gnatcoll-core     = self.callPackage ../development/ada-modules/gnatcoll/core.nix { };
+
+    # gnatcoll-bindings repository
+    gnatcoll-gmp      = self.callPackage ../development/ada-modules/gnatcoll/bindings.nix { component = "gmp"; };
+    gnatcoll-iconv    = self.callPackage ../development/ada-modules/gnatcoll/bindings.nix { component = "iconv"; };
+    gnatcoll-lzma     = self.callPackage ../development/ada-modules/gnatcoll/bindings.nix { component = "lzma"; };
+    gnatcoll-omp      = self.callPackage ../development/ada-modules/gnatcoll/bindings.nix { component = "omp"; };
+    gnatcoll-python3  = self.callPackage ../development/ada-modules/gnatcoll/bindings.nix { component = "python3"; python3 = pkgs.python39; };
+    gnatcoll-readline = self.callPackage ../development/ada-modules/gnatcoll/bindings.nix { component = "readline"; };
+    gnatcoll-syslog   = self.callPackage ../development/ada-modules/gnatcoll/bindings.nix { component = "syslog"; };
+    gnatcoll-zlib     = self.callPackage ../development/ada-modules/gnatcoll/bindings.nix { component = "zlib"; };
+
+    # gnatcoll-db repository
+    gnatcoll-postgres = self.callPackage ../development/ada-modules/gnatcoll/db.nix { component = "postgres"; };
+    gnatcoll-sql      = self.callPackage ../development/ada-modules/gnatcoll/db.nix { component = "sql"; };
+    gnatcoll-sqlite   = self.callPackage ../development/ada-modules/gnatcoll/db.nix { component = "sqlite"; };
+    gnatcoll-xref     = self.callPackage ../development/ada-modules/gnatcoll/db.nix { component = "xref"; };
+    gnatcoll-db2ada   = self.callPackage ../development/ada-modules/gnatcoll/db.nix { component = "gnatcoll_db2ada"; };
+    gnatinspect       = self.callPackage ../development/ada-modules/gnatcoll/db.nix { component = "gnatinspect"; };
+  });
+}
+

pkgs/top-level/aliases.nix

···
   gnatboot11 = gnat-bootstrap11;
   gnatboot12 = gnat-bootstrap12;
   gnatboot = gnat-bootstrap;
+  gnatcoll-core     = gnatPackages.gnatcoll-core; # Added 2024-02-25
+  gnatcoll-gmp      = gnatPackages.gnatcoll-gmp; # Added 2024-02-25
+  gnatcoll-iconv    = gnatPackages.gnatcoll-iconv; # Added 2024-02-25
+  gnatcoll-lzma     = gnatPackages.gnatcoll-lzma; # Added 2024-02-25
+  gnatcoll-omp      = gnatPackages.gnatcoll-omp; # Added 2024-02-25
+  gnatcoll-python3  = gnatPackages.gnatcoll-python3; # Added 2024-02-25
+  gnatcoll-readline = gnatPackages.gnatcoll-readline; # Added 2024-02-25
+  gnatcoll-syslog   = gnatPackages.gnatcoll-syslog; # Added 2024-02-25
+  gnatcoll-zlib     = gnatPackages.gnatcoll-zlib; # Added 2024-02-25
+  gnatcoll-postgres = gnatPackages.gnatcoll-postgres; # Added 2024-02-25
+  gnatcoll-sql      = gnatPackages.gnatcoll-sql; # Added 2024-02-25
+  gnatcoll-sqlite   = gnatPackages.gnatcoll-sqlite; # Added 2024-02-25
+  gnatcoll-xref     = gnatPackages.gnatcoll-xref; # Added 2024-02-25
+  gnatcoll-db2ada   = gnatPackages.gnatcoll-db2ada; # Added 2024-02-25
+  gnatinspect = gnatPackages.gnatinspect; # Added 2024-02-25
   gnome-firmware-updater = gnome-firmware; # added 2022-04-14
   gnome-passwordsafe = gnome-secrets; # added 2022-01-30
   gnome-mpv = throw "'gnome-mpv' has been renamed to/replaced by 'celluloid'"; # Converted to throw 2023-09-10
···
   gocode = throw "'gocode' has been removed as the upstream project was archived. 'gopls' is suggested as replacement"; # Added 2023-12-26
   govendor = throw "'govendor' has been removed as it is no longer maintained upstream, please use Go modules instead"; # Added 2023-12-26
   gometer = throw "gometer has been removed from nixpkgs because goLance stopped offering Linux support"; # Added 2023-02-10
-
+  gprbuild-boot = gnatPackages.gprbuild-boot; # Added 2024-02-25;
   graalvm11-ce = throw "graalvm11-ce has been removed because upstream dropped support to different JDK versions for each GraalVM release. Please use graalvm-ce instead"; # Added 2023-09-26
   graalvm17-ce = throw "graalvm17-ce has been removed because upstream dropped support to different JDK versions for each GraalVM release. Please use graalvm-ce instead"; # Added 2023-09-26
   graalvm19-ce = throw "graalvm19-ce has been removed because upstream dropped support to different JDK versions for each GraalVM release. Please use graalvm-ce instead"; # Added 2023-09-26
···
   spark2 = throw "'spark2' is no longer supported nixpkgs, please use 'spark'"; # Added 2023-05-08
   spark_2_4 = throw "'spark_2_4' is no longer supported nixpkgs, please use 'spark'"; # Added 2023-05-08
   spark_3_1 = throw "'spark_3_1' is no longer supported nixpkgs, please use 'spark'"; # Added 2023-05-08
+  spark2014 = gnatprove; # Added 2024-02-25
 
   # Added 2020-02-10
   sourceHanSansPackages = {
···
   xdg_utils = xdg-utils; # Added 2021-02-01
   xineLib = xine-lib; # Added 2021-04-27
   xineUI = xine-ui; # Added 2021-04-27
+  xmlada = gnatPackages.xmlada; # Added 2024-02-25
   xonsh-unwrapped = throw "'xonsh-unwrapped' was incorporated into xonsh code; call xonsh directly instead."; # Added 2024-01-20
   xtrt = throw "xtrt has been removed due to being abandoned"; # Added 2023-05-25
   xulrunner = firefox-unwrapped; # Added 2023-11-03

pkgs/top-level/all-packages.nix

···
   };
 
   git-cliff = callPackage ../applications/version-management/git-cliff {
-    inherit (darwin.apple_sdk.frameworks) Security;
+    inherit (darwin.apple_sdk.frameworks) Security SystemConfiguration;
   };
 
   git-codeowners = callPackage ../applications/version-management/git-codeowners { };
···
     inherit (gnome2) libart_lgpl;
   });
 
-  gnat = gnat12;
+  gnat = gnat12; # When changing this, update also gnatPackages
 
   gnat11 = wrapCC (gcc11.cc.override {
     name = "gnat";
···
   } // lib.optionalAttrs (stdenv.hostPlatform.isDarwin) {
     bintools = bintoolsDualAs;
   });
+
+  gnat12Packages = recurseIntoAttrs (callPackage ./ada-packages.nix { gnat = buildPackages.gnat12; });
+  gnat13Packages = recurseIntoAttrs (callPackage ./ada-packages.nix { gnat = buildPackages.gnat13; });
+  gnatPackages   = gnat12Packages;
+
+  inherit (gnatPackages)
+    gprbuild
+    gnatprove;
 
   gnu-smalltalk = callPackage ../development/compilers/gnu-smalltalk { };
 
···
 
   sparkleshare = callPackage ../applications/version-management/sparkleshare { };
 
-  spark2014 = callPackage ../development/libraries/ada/spark2014 {
-    ocamlPackages = ocaml-ng.ocamlPackages_4_14;
-  };
-
   spidermonkey_78 = callPackage ../development/interpreters/spidermonkey/78.nix {
     inherit (darwin) libobjc;
   };
···
 
   global = callPackage ../development/tools/misc/global { };
 
-  gnatcoll-db2ada = callPackage ../development/libraries/ada/gnatcoll/db.nix {
-    component = "gnatcoll_db2ada";
-  };
-
-  gnatinspect = callPackage ../development/libraries/ada/gnatcoll/db.nix {
-    component = "gnatinspect";
-  };
-
   gnome-doc-utils = callPackage ../development/tools/documentation/gnome-doc-utils { };
 
   gnome-desktop-testing = callPackage ../development/tools/gnome-desktop-testing { };
···
 
   gotty = callPackage ../servers/gotty { };
 
-  gprbuild-boot = callPackage ../development/tools/build-managers/gprbuild/boot.nix { };
-
-  gprbuild = callPackage ../development/tools/build-managers/gprbuild { };
-
   gputils = callPackage ../development/embedded/gputils { };
 
   gpuvis = callPackage ../development/tools/misc/gpuvis { };
···
   mpir = callPackage ../development/libraries/mpir { };
 
   gl3w = callPackage ../development/libraries/gl3w { };
-
-  gnatcoll-core = callPackage ../development/libraries/ada/gnatcoll/core.nix { };
-
-  # gnatcoll-bindings repository
-  gnatcoll-gmp = callPackage ../development/libraries/ada/gnatcoll/bindings.nix { component = "gmp"; };
-  gnatcoll-iconv = callPackage ../development/libraries/ada/gnatcoll/bindings.nix { component = "iconv"; };
-  gnatcoll-lzma = callPackage ../development/libraries/ada/gnatcoll/bindings.nix { component = "lzma"; };
-  gnatcoll-omp = callPackage ../development/libraries/ada/gnatcoll/bindings.nix { component = "omp"; };
-  gnatcoll-python3 = callPackage ../development/libraries/ada/gnatcoll/bindings.nix {
-    component = "python3";
-    python3 = python39;
-  };
-  gnatcoll-readline = callPackage ../development/libraries/ada/gnatcoll/bindings.nix { component = "readline"; };
-  gnatcoll-syslog = callPackage ../development/libraries/ada/gnatcoll/bindings.nix { component = "syslog"; };
-  gnatcoll-zlib = callPackage ../development/libraries/ada/gnatcoll/bindings.nix { component = "zlib"; };
-
-  # gnatcoll-db repository
-  gnatcoll-postgres = callPackage ../development/libraries/ada/gnatcoll/db.nix { component = "postgres"; };
-  gnatcoll-sql = callPackage ../development/libraries/ada/gnatcoll/db.nix { component = "sql"; };
-  gnatcoll-sqlite = callPackage ../development/libraries/ada/gnatcoll/db.nix { component = "sqlite"; };
-  gnatcoll-xref = callPackage ../development/libraries/ada/gnatcoll/db.nix { component = "xref"; };
 
   gns3Packages = dontRecurseIntoAttrs (callPackage ../applications/networking/gns3 { });
   gns3-gui = gns3Packages.guiStable;
···
   xgeometry-select = callPackage ../tools/X11/xgeometry-select { };
 
   xmake-core-sv = callPackage ../development/libraries/xmake-core-sv { };
-
-  xmlada = callPackage ../development/libraries/ada/xmlada { };
 
   xmlrpc_c = callPackage ../development/libraries/xmlrpc-c { };
 

pkgs/top-level/python-packages.nix

···
 
   oras = callPackage ../development/python-modules/oras { };
 
+  orbax-checkpoint = callPackage ../development/python-modules/orbax-checkpoint { };
+
   orderedmultidict = callPackage ../development/python-modules/orderedmultidict { };
 
   ordered-set = callPackage ../development/python-modules/ordered-set { };
···
   syslog-rfc5424-formatter = callPackage ../development/python-modules/syslog-rfc5424-formatter { };
 
   systembridge = callPackage ../development/python-modules/systembridge { };
+
+  systembridgeconnector = callPackage ../development/python-modules/systembridgeconnector { };
+
+  systembridgemodels = callPackage ../development/python-modules/systembridgemodels { };
 
   systemd = callPackage ../development/python-modules/systemd {
     inherit (pkgs) systemd;