Merge staging-next into staging

.github/workflows/pr.yml

···
 on:
   pull_request:
     paths:
+      - .github/actions/get-merge-commit/action.yml
       - .github/workflows/build.yml
       - .github/workflows/check.yml
       - .github/workflows/eval.yml

doc/packages/linux.section.md

···
   ignoreConfigErrors = true;
   autoModules = false;
   kernelPreferBuiltin = true;
-  extraStructuredConfig = with lib.kernel; {
+  structuredExtraConfig = with lib.kernel; {
     DEBUG_KERNEL = yes;
     FRAME_POINTER = yes;
     KGDB = yes;

lib/attrsets.nix

···
 
     : Predicate taking an attribute name and an attribute value, which returns `true` to include the attribute, or `false` to exclude the attribute.
 
+      <!-- TIP -->
+      If possible, decide on `name` first and on `value` only if necessary.
+      This avoids evaluating the value if the name is already enough, making it possible, potentially, to have the argument reference the return value.
+      (Depending on context, that could still be considered a self reference by users; a common pattern in Nix.)
+
+      <!-- TIP -->
+      `filterAttrs` is occasionally the cause of infinite recursion in configuration systems that allow self-references.
+      To support the widest range of user-provided logic, perform the `filterAttrs` call as late as possible.
+      Typically that's right before using it in a derivation, as opposed to an implicit conversion whose result is accessible to the user's expressions.
+
     `set`
 
     : The attribute set to filter

maintainers/maintainer-list.nix

···
     githubId = 57819359;
     name = "Binh Nguyen";
   };
-  tuynia = {
-    github = "mivorasu";
-    githubId = 221005165;
-    name = "Qylia Vorlaque";
-  };
   tv = {
     email = "[e-mail]";
     github = "4z3";

nixos/modules/config/debug-info.nix

···
-{ config, lib, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 {
 
   options = {
···
       '';
     };
 
+    environment.debuginfodServers = lib.mkOption {
+      type = lib.types.listOf lib.types.str;
+      default = [ ];
+      description = ''
+        List of urls of debuginfod servers for tools like {command}`gdb` and {command}`valgrind` to use.
+
+        Unrelated to {option}`environment.enableDebugInfo`.
+      '';
+    };
+
   };
 
-  config = lib.mkIf config.environment.enableDebugInfo {
+  config = lib.mkMerge [
+    (lib.mkIf config.environment.enableDebugInfo {
+
+      # FIXME: currently disabled because /lib is already in
+      # environment.pathsToLink, and we can't have both.
+      #environment.pathsToLink = [ "/lib/debug/.build-id" ];
 
-    # FIXME: currently disabled because /lib is already in
-    # environment.pathsToLink, and we can't have both.
-    #environment.pathsToLink = [ "/lib/debug/.build-id" ];
+      environment.extraOutputsToInstall = [ "debug" ];
+
+      environment.variables.NIX_DEBUG_INFO_DIRS = [ "/run/current-system/sw/lib/debug" ];
 
-    environment.extraOutputsToInstall = [ "debug" ];
+    })
+    (lib.mkIf (config.environment.debuginfodServers != [ ]) {
+      environment.variables.DEBUGINFOD_URLS = lib.strings.concatStringsSep " " config.environment.debuginfodServers;
 
-    environment.variables.NIX_DEBUG_INFO_DIRS = [ "/run/current-system/sw/lib/debug" ];
+      environment.systemPackages = [
+        # valgrind support requires debuginfod-find on PATH
+        (lib.getBin pkgs.elfutils)
+      ];
 
-  };
+      environment.etc."gdb/gdbinit.d/nixseparatedebuginfod2.gdb".text = "set debuginfod enabled on";
+    })
+  ];
 
 }

nixos/modules/config/system-path.nix

···
 }:
 let
 
-  requiredPackages =
-    map (pkg: lib.setPrio ((pkg.meta.priority or lib.meta.defaultPriority) + 3) pkg)
-      [
-        pkgs.acl
-        pkgs.attr
-        pkgs.bashInteractive # bash with ncurses support
-        pkgs.bzip2
-        pkgs.coreutils-full
-        pkgs.cpio
-        pkgs.curl
-        pkgs.diffutils
-        pkgs.findutils
-        pkgs.gawk
-        pkgs.stdenv.cc.libc
-        pkgs.getent
-        pkgs.getconf
-        pkgs.gnugrep
-        pkgs.gnupatch
-        pkgs.gnused
-        pkgs.gnutar
-        pkgs.gzip
-        pkgs.xz
-        pkgs.less
-        pkgs.libcap
-        pkgs.ncurses
-        pkgs.netcat
-        config.programs.ssh.package
-        pkgs.mkpasswd
-        pkgs.procps
-        pkgs.su
-        pkgs.time
-        pkgs.util-linux
-        pkgs.which
-        pkgs.zstd
-      ];
+  corePackageNames = [
+    "acl"
+    "attr"
+    "bashInteractive" # bash with ncurses support
+    "bzip2"
+    "coreutils-full"
+    "cpio"
+    "curl"
+    "diffutils"
+    "findutils"
+    "gawk"
+    "getent"
+    "getconf"
+    "gnugrep"
+    "gnupatch"
+    "gnused"
+    "gnutar"
+    "gzip"
+    "xz"
+    "less"
+    "libcap"
+    "ncurses"
+    "netcat"
+    "mkpasswd"
+    "procps"
+    "su"
+    "time"
+    "util-linux"
+    "which"
+    "zstd"
+  ];
+  corePackages =
+    (map (
+      n:
+      let
+        pkg = pkgs.${n};
+      in
+      lib.setPrio ((pkg.meta.priority or lib.meta.defaultPriority) + 3) pkg
+    ) corePackageNames)
+    ++ [ pkgs.stdenv.cc.libc ];
+  corePackagesText = "[ ${lib.concatMapStringsSep " " (n: "pkgs.${n}") corePackageNames} ]";
 
   defaultPackageNames = [
     "perl"
···
           configuration.  (The latter is the main difference with
           installing them in the default profile,
           {file}`/nix/var/nix/profiles/default`.
+        '';
+      };
+
+      corePackages = lib.mkOption {
+        type = lib.types.listOf lib.types.package;
+        default = corePackages;
+        defaultText = lib.literalMD ''
+          these packages, with their `meta.priority` numerically increased
+          (thus lowering their installation priority):
+
+              ${corePackagesText}
+        '';
+        example = [ ];
+        description = ''
+          Set of core packages for a normal interactive system.
+
+          Only change this if you know what you're doing!
+
+          Like with systemPackages, packages are installed to
+          {file}`/run/current-system/sw`. They are
+          automatically available to all users, and are
+          automatically updated every time you rebuild the system
+          configuration.
         '';
       };
 
···
 
   config = {
 
-    environment.systemPackages = requiredPackages ++ config.environment.defaultPackages;
+    environment.systemPackages = config.environment.corePackages ++ config.environment.defaultPackages;
 
     environment.pathsToLink = [
       "/bin"

nixos/modules/module-list.nix

···
   ./services/development/jupyterhub/default.nix
   ./services/development/livebook.nix
   ./services/development/lorri.nix
+  ./services/development/nixseparatedebuginfod2.nix
   ./services/development/nixseparatedebuginfod.nix
   ./services/development/rstudio-server/default.nix
   ./services/development/vsmartcard-vpcd.nix

nixos/modules/programs/bash/bash.nix

···
 in
 
 {
-  imports = [
-    (lib.mkRemovedOptionModule [ "programs" "bash" "enable" ] "")
-  ];
 
   options = {
 
     programs.bash = {
 
-      /*
-        enable = lib.mkOption {
-          default = true;
-          description = ''
-            Whenever to configure Bash as an interactive shell.
-            Note that this tries to make Bash the default
-            {option}`users.defaultUserShell`,
-            which in turn means that you might need to explicitly
-            set this variable if you have another shell configured
-            with NixOS.
-          '';
-          type = lib.types.bool;
-        };
-      */
+      enable = lib.mkOption {
+        default = true;
+        description = ''
+          Whenever to configure Bash as an interactive shell.
+          Note that this tries to make Bash the default
+          {option}`users.defaultUserShell`,
+          which in turn means that you might need to explicitly
+          set this variable if you have another shell configured
+          with NixOS.
+        '';
+        type = lib.types.bool;
+      };
 
       shellAliases = lib.mkOption {
         default = { };
···
 
   };
 
-  config = # lib.mkIf cfg.enable
-    {
+  config = lib.mkIf cfg.enable {
 
-      programs.bash = {
+    programs.bash = {
 
-        shellAliases = builtins.mapAttrs (name: lib.mkDefault) cfge.shellAliases;
+      shellAliases = builtins.mapAttrs (name: lib.mkDefault) cfge.shellAliases;
 
-        shellInit = ''
-          if [ -z "$__NIXOS_SET_ENVIRONMENT_DONE" ]; then
-              . ${config.system.build.setEnvironment}
-          fi
+      shellInit = ''
+        if [ -z "$__NIXOS_SET_ENVIRONMENT_DONE" ]; then
+            . ${config.system.build.setEnvironment}
+        fi
 
-          ${cfge.shellInit}
-        '';
+        ${cfge.shellInit}
+      '';
 
-        loginShellInit = cfge.loginShellInit;
+      loginShellInit = cfge.loginShellInit;
 
-        interactiveShellInit = ''
-          # Check the window size after every command.
-          shopt -s checkwinsize
+      interactiveShellInit = ''
+        # Check the window size after every command.
+        shopt -s checkwinsize
 
-          # Disable hashing (i.e. caching) of command lookups.
-          set +h
+        # Disable hashing (i.e. caching) of command lookups.
+        set +h
 
-          ${cfg.promptInit}
-          ${cfg.promptPluginInit}
-          ${bashAliases}
+        ${cfg.promptInit}
+        ${cfg.promptPluginInit}
+        ${bashAliases}
 
-          ${cfge.interactiveShellInit}
-        '';
+        ${cfge.interactiveShellInit}
+      '';
 
-      };
+    };
 
-      environment.etc.profile.text = ''
-        # /etc/profile: DO NOT EDIT -- this file has been generated automatically.
-        # This file is read for login shells.
+    environment.etc.profile.text = ''
+      # /etc/profile: DO NOT EDIT -- this file has been generated automatically.
+      # This file is read for login shells.
 
-        # Only execute this file once per shell.
-        if [ -n "$__ETC_PROFILE_SOURCED" ]; then return; fi
-        __ETC_PROFILE_SOURCED=1
+      # Only execute this file once per shell.
+      if [ -n "$__ETC_PROFILE_SOURCED" ]; then return; fi
+      __ETC_PROFILE_SOURCED=1
 
-        # Prevent this file from being sourced by interactive non-login child shells.
-        export __ETC_PROFILE_DONE=1
+      # Prevent this file from being sourced by interactive non-login child shells.
+      export __ETC_PROFILE_DONE=1
 
-        ${cfg.shellInit}
-        ${cfg.loginShellInit}
+      ${cfg.shellInit}
+      ${cfg.loginShellInit}
 
-        # Read system-wide modifications.
-        if test -f /etc/profile.local; then
-            . /etc/profile.local
-        fi
+      # Read system-wide modifications.
+      if test -f /etc/profile.local; then
+          . /etc/profile.local
+      fi
 
-        if [ -n "''${BASH_VERSION:-}" ]; then
-            . /etc/bashrc
-        fi
-      '';
+      if [ -n "''${BASH_VERSION:-}" ]; then
+          . /etc/bashrc
+      fi
+    '';
 
-      environment.etc.bashrc.text = ''
-        # /etc/bashrc: DO NOT EDIT -- this file has been generated automatically.
+    environment.etc.bashrc.text = ''
+      # /etc/bashrc: DO NOT EDIT -- this file has been generated automatically.
 
-        # Only execute this file once per shell.
-        if [ -n "$__ETC_BASHRC_SOURCED" ] || [ -n "$NOSYSBASHRC" ]; then return; fi
-        __ETC_BASHRC_SOURCED=1
+      # Only execute this file once per shell.
+      if [ -n "$__ETC_BASHRC_SOURCED" ] || [ -n "$NOSYSBASHRC" ]; then return; fi
+      __ETC_BASHRC_SOURCED=1
 
-        # If the profile was not loaded in a parent process, source
-        # it.  But otherwise don't do it because we don't want to
-        # clobber overridden values of $PATH, etc.
-        if [ -z "$__ETC_PROFILE_DONE" ]; then
-            . /etc/profile
-        fi
+      # If the profile was not loaded in a parent process, source
+      # it.  But otherwise don't do it because we don't want to
+      # clobber overridden values of $PATH, etc.
+      if [ -z "$__ETC_PROFILE_DONE" ]; then
+          . /etc/profile
+      fi
 
-        # We are not always an interactive shell.
-        if [ -n "$PS1" ]; then
-            ${cfg.interactiveShellInit}
-        fi
+      # We are not always an interactive shell.
+      if [ -n "$PS1" ]; then
+          ${cfg.interactiveShellInit}
+      fi
 
-        # Read system-wide modifications.
-        if test -f /etc/bashrc.local; then
-            . /etc/bashrc.local
-        fi
-      '';
+      # Read system-wide modifications.
+      if test -f /etc/bashrc.local; then
+          . /etc/bashrc.local
+      fi
+    '';
 
-      environment.etc.bash_logout.text = ''
-        # /etc/bash_logout: DO NOT EDIT -- this file has been generated automatically.
+    environment.etc.bash_logout.text = ''
+      # /etc/bash_logout: DO NOT EDIT -- this file has been generated automatically.
 
-        # Only execute this file once per shell.
-        if [ -n "$__ETC_BASHLOGOUT_SOURCED" ] || [ -n "$NOSYSBASHLOGOUT" ]; then return; fi
-        __ETC_BASHLOGOUT_SOURCED=1
+      # Only execute this file once per shell.
+      if [ -n "$__ETC_BASHLOGOUT_SOURCED" ] || [ -n "$NOSYSBASHLOGOUT" ]; then return; fi
+      __ETC_BASHLOGOUT_SOURCED=1
 
-        ${cfg.logout}
+      ${cfg.logout}
 
-        # Read system-wide modifications.
-        if test -f /etc/bash_logout.local; then
-            . /etc/bash_logout.local
-        fi
-      '';
+      # Read system-wide modifications.
+      if test -f /etc/bash_logout.local; then
+          . /etc/bash_logout.local
+      fi
+    '';
 
-      # Configuration for readline in bash. We use "option default"
-      # priority to allow user override using both .text and .source.
-      environment.etc.inputrc.source = lib.mkOptionDefault ./inputrc;
+    # Configuration for readline in bash. We use "option default"
+    # priority to allow user override using both .text and .source.
+    environment.etc.inputrc.source = lib.mkOptionDefault ./inputrc;
 
-      users.defaultUserShell = lib.mkDefault pkgs.bashInteractive;
+    users.defaultUserShell = lib.mkDefault pkgs.bashInteractive;
 
-      environment.pathsToLink = lib.optionals cfg.completion.enable [
-        "/etc/bash_completion.d"
-        "/share/bash-completion"
-      ];
+    environment.pathsToLink = lib.optionals cfg.completion.enable [
+      "/etc/bash_completion.d"
+      "/share/bash-completion"
+    ];
 
-      environment.shells = [
-        "/run/current-system/sw/bin/bash"
-        "/run/current-system/sw/bin/sh"
-        "${pkgs.bashInteractive}/bin/bash"
-        "${pkgs.bashInteractive}/bin/sh"
-      ];
+    environment.shells = [
+      "/run/current-system/sw/bin/bash"
+      "/run/current-system/sw/bin/sh"
+      "${pkgs.bashInteractive}/bin/bash"
+      "${pkgs.bashInteractive}/bin/sh"
+    ];
 
-    };
+  };
 
 }

nixos/modules/programs/fuse.nix

···
-{ config, lib, ... }:
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 
 let
   cfg = config.programs.fuse;
···
   meta.maintainers = with lib.maintainers; [ ];
 
   options.programs.fuse = {
+    enable = lib.mkEnableOption "fuse" // {
+      default = true;
+    };
+
     mountMax = lib.mkOption {
       # In the C code it's an "int" (i.e. signed and at least 16 bit), but
       # negative numbers obviously make no sense:
···
     };
   };
 
-  config = {
+  config = lib.mkIf cfg.enable {
+    environment.systemPackages = [
+      pkgs.fuse
+      pkgs.fuse3
+    ];
+
+    security.wrappers =
+      let
+        mkSetuidRoot = source: {
+          setuid = true;
+          owner = "root";
+          group = "root";
+          inherit source;
+        };
+      in
+      {
+        fusermount = mkSetuidRoot "${lib.getBin pkgs.fuse}/bin/fusermount";
+        fusermount3 = mkSetuidRoot "${lib.getBin pkgs.fuse3}/bin/fusermount3";
+      };
+
     environment.etc."fuse.conf".text = ''
       ${lib.optionalString (!cfg.userAllowOther) "#"}user_allow_other
       mount_max = ${builtins.toString cfg.mountMax}
     '';
+
   };
 }

nixos/modules/programs/ssh.nix

···
       }
     );
 
+    environment.corePackages = [ cfg.package ];
+
     # SSH configuration. Slight duplication of the sshd_config
     # generation in the sshd service.
     environment.etc."ssh/ssh_config".text = ''

nixos/modules/security/wrappers/default.nix

···
       in
       {
         # These are mount related wrappers that require the +s permission.
-        fusermount = mkSetuidRoot "${lib.getBin pkgs.fuse}/bin/fusermount";
-        fusermount3 = mkSetuidRoot "${lib.getBin pkgs.fuse3}/bin/fusermount3";
         mount = mkSetuidRoot "${lib.getBin pkgs.util-linux}/bin/mount";
         umount = mkSetuidRoot "${lib.getBin pkgs.util-linux}/bin/umount";
       };

nixos/modules/services/development/nixseparatedebuginfod.nix

···
       extra-allowed-users = [ "nixseparatedebuginfod" ];
     };
 
-    environment.variables.DEBUGINFOD_URLS = "http://${url}";
-
-    environment.systemPackages = [
-      # valgrind support requires debuginfod-find on PATH
-      (lib.getBin pkgs.elfutils)
-    ];
-
-    environment.etc."gdb/gdbinit.d/nixseparatedebuginfod.gdb".text = "set debuginfod enabled on";
-
+    environment.debuginfodServers = [ "http://${url}" ];
   };
 }

nixos/modules/services/development/nixseparatedebuginfod2.nix

···
+{
+  pkgs,
+  lib,
+  config,
+  utils,
+  ...
+}:
+let
+  cfg = config.services.nixseparatedebuginfod2;
+  url = "127.0.0.1:${toString cfg.port}";
+in
+{
+  options = {
+    services.nixseparatedebuginfod2 = {
+      enable = lib.mkEnableOption "nixseparatedebuginfod2, a debuginfod server providing source and debuginfo for nix packages";
+      port = lib.mkOption {
+        description = "port to listen";
+        default = 1950;
+        type = lib.types.port;
+      };
+      package = lib.mkPackageOption pkgs "nixseparatedebuginfod2" { };
+      substituter = lib.mkOption {
+        description = "nix substituter to fetch debuginfo from. Either http/https substituters, or `local:` to use debuginfo present in the local store.";
+        default = "https://cache.nixos.org";
+        example = "local:";
+        type = lib.types.str;
+      };
+      cacheExpirationDelay = lib.mkOption {
+        description = "keep unused cache entries for this long. A number followed by a unit";
+        default = "1d";
+        type = lib.types.str;
+      };
+    };
+  };
+  config = lib.mkIf cfg.enable {
+    systemd.services.nixseparatedebuginfod2 = {
+      wantedBy = [ "multi-user.target" ];
+      path = [ config.nix.package ];
+      serviceConfig = {
+        ExecStart = [
+          (utils.escapeSystemdExecArgs [
+            (lib.getExe cfg.package)
+            "--listen-address"
+            url
+            "--substituter"
+            cfg.substituter
+            "--expiration"
+            cfg.cacheExpirationDelay
+          ])
+        ];
+        Restart = "on-failure";
+        CacheDirectory = "nixseparatedebuginfod2";
+        DynamicUser = true;
+
+        # hardening
+        # Filesystem stuff
+        ProtectSystem = "strict"; # Prevent writing to most of /
+        ProtectHome = true; # Prevent accessing /home and /root
+        PrivateTmp = true; # Give an own directory under /tmp
+        PrivateDevices = true; # Deny access to most of /dev
+        ProtectKernelTunables = true; # Protect some parts of /sys
+        ProtectControlGroups = true; # Remount cgroups read-only
+        RestrictSUIDSGID = true; # Prevent creating SETUID/SETGID files
+        PrivateMounts = true; # Give an own mount namespace
+        RemoveIPC = true;
+        UMask = "0077";
+
+        # Capabilities
+        CapabilityBoundingSet = ""; # Allow no capabilities at all
+        NoNewPrivileges = true; # Disallow getting more capabilities. This is also implied by other options.
+
+        # Kernel stuff
+        ProtectKernelModules = true; # Prevent loading of kernel modules
+        SystemCallArchitectures = "native"; # Usually no need to disable this
+        SystemCallFilter = "@system-service";
+        ProtectKernelLogs = true; # Prevent access to kernel logs
+        ProtectClock = true; # Prevent setting the RTC
+        ProtectProc = "noaccess";
+        ProcSubset = "pid";
+
+        # Networking
+        RestrictAddressFamilies = "AF_UNIX AF_INET AF_INET6";
+
+        # Misc
+        LockPersonality = true; # Prevent change of the personality
+        ProtectHostname = true; # Give an own UTS namespace
+        RestrictRealtime = true; # Prevent switching to RT scheduling
+        MemoryDenyWriteExecute = true; # Maybe disable this for interpreters like python
+        RestrictNamespaces = true;
+
+      };
+    };
+
+    environment.debuginfodServers = [ "http://${url}" ];
+
+  };
+}

nixos/modules/services/networking/netbird.nix

···
                         mkdir -p "$out/share/applications"
                         substitute ${cfg.ui.package}/share/applications/netbird.desktop \
                             "$out/share/applications/${mkBin "netbird"}.desktop" \
-                          --replace-fail 'Name=NetBird' "Name=NetBird @ ${client.service.name}" \
+                          --replace-fail 'Name=Netbird' "Name=NetBird @ ${client.service.name}" \
                           --replace-fail '${lib.getExe cfg.ui.package}' "$out/bin/${mkBin "netbird-ui"}"
                       '')
                     ];

nixos/modules/services/networking/prosody.nix

···
 
       ${lib.concatMapStrings (muc: ''
         Component ${toLua muc.domain} "muc"
-            modules_enabled = {${optionalString cfg.modules.mam ''" muc_mam",''}${optionalString muc.allowners_muc ''" muc_allowners",''} }
+            modules_enabled = {${optionalString cfg.modules.mam ''"muc_mam",''}${optionalString muc.allowners_muc ''"muc_allowners",''} }
             name = ${toLua muc.name}
             restrict_room_creation = ${toLua muc.restrictRoomCreation}
             max_history_messages = ${toLua muc.maxHistoryMessages}
···
             ${muc.extraConfig}
       '') cfg.muc}
 
-      ${
-        lib.optionalString (cfg.httpFileShare != null) ''
-          Component ${toLua cfg.httpFileShare.domain} "http_file_share"
-            modules_disabled = { "s2s" }
-        ''
-        + lib.optionalString (cfg.httpFileShare.http_host != null) ''
+      ${lib.optionalString (cfg.httpFileShare != null) ''
+        Component ${toLua cfg.httpFileShare.domain} "http_file_share"
+          modules_disabled = { "s2s" }
+        ${lib.optionalString (cfg.httpFileShare.http_host != null) ''
           http_host = "${cfg.httpFileShare.http_host}"
-        ''
-        + ''
-          ${settingsToLua "  http_file_share_" (cfg.httpFileShare // { domain = null; })}
-        ''
-      }
+        ''}
+        ${settingsToLua "  http_file_share_" (cfg.httpFileShare // { domain = null; })}
+      ''}
 
       ${lib.concatStringsSep "\n" (
         lib.mapAttrsToList (n: v: ''

nixos/modules/services/networking/tayga.nix

···
     data-dir ${cfg.dataDir}
 
     ${concatStringsSep "\n" (mapAttrsToList (ipv4: ipv6: "map " + ipv4 + " " + ipv6) cfg.mappings)}
+
+    ${optionalString ((builtins.length cfg.log) > 0) ''
+      log ${concatStringsSep " " cfg.log}
+    ''}
+
+    wkpf-strict ${if cfg.wkpfStrict then "yes" else "no"}
   '';
 
   addrOpts =
···
           }
         '';
       };
+
+      log = mkOption {
+        type = types.listOf types.str;
+        default = [ ];
+        description = "Packet errors to log (drop, reject, icmp, self)";
+        example = literalExpression ''
+          [ "drop" "reject" "icmp" "self" ]
+        '';
+      };
+
+      wkpfStrict = mkOption {
+        type = types.bool;
+        default = true;
+        description = "Enable restrictions on the use of the well-known prefix (64:ff9b::/96) - prevents translation of non-global IPv4 ranges when using the well-known prefix. Must be enabled for RFC 6052 compatibility.";
+      };
     };
   };
 
···
       };
     };
 
+    environment.etc."tayga.conf".source = configFile;
+
     systemd.services.tayga = {
       description = "Stateless NAT64 implementation";
       wantedBy = [ "multi-user.target" ];
       after = [ "network.target" ];
 
+      reloadTriggers = [ configFile ];
       serviceConfig = {
-        ExecStart = "${cfg.package}/bin/tayga -d --nodetach --config ${configFile}";
+        ExecStart = "${cfg.package}/bin/tayga -d --nodetach --config /etc/tayga.conf";
         ExecReload = "${pkgs.coreutils}/bin/kill -SIGHUP $MAINPID";
         Restart = "always";
 

nixos/modules/services/video/frigate.nix

···
     elem
     filterAttrsRecursive
     hasPrefix
+    literalExpression
     makeLibraryPath
     mkDefault
     mkEnableOption
···
   format = pkgs.formats.yaml { };
 
   filteredConfig = converge (filterAttrsRecursive (_: v: !elem v [ null ])) cfg.settings;
+
+  configFileUnchecked = format.generate "frigate.yaml" filteredConfig;
+  configFileChecked =
+    pkgs.runCommand "frigate-config"
+      {
+        preferLocalBuilds = true;
+      }
+      ''
+        function error() {
+          cat << 'HEREDOC'
+
+        Note that not all configurations can be reliably checked in the
+        build sandbox.
+
+        This check can be disabled using `services.frigate.checkConfig`.
+        HEREDOC
+
+          exit 1
+        }
+
+        cp ${configFileUnchecked} $out
+        export CONFIG_FILE=$out
+        export PYTHONPATH=${cfg.package.pythonPath}
+        ${cfg.package.python.interpreter} -m frigate --validate-config || error
+      '';
+  configFile = if cfg.checkConfig then configFileChecked else configFileUnchecked;
 
   cameraFormat =
     with types;
···
 
         - https://docs.frigate.video/configuration/hardware_acceleration
         - https://docs.frigate.video/configuration/ffmpeg_presets#hwaccel-presets
+      '';
+    };
+
+    checkConfig = mkOption {
+      type = bool;
+      default = pkgs.stdenv.buildPlatform.canExecute pkgs.stdenv.hostPlatform;
+      defaultText = literalExpression ''
+        pkgs.stdenv.buildPlatform.canExecute pkgs.stdenv.hostPlatform
+      '';
+      description = ''
+        Whether to check the configuration at build time.
       '';
     };
 
···
             rm --recursive --force /var/cache/frigate/!(model_cache)
           '')
           (pkgs.writeShellScript "frigate-create-writable-config" ''
-            cp --no-preserve=mode "${format.generate "frigate.yml" filteredConfig}" /run/frigate/frigate.yml
+            cp --no-preserve=mode ${configFile} /run/frigate/frigate.yml
           '')
         ];
         ExecStart = "${cfg.package.python.interpreter} -m frigate";

nixos/modules/services/web-apps/jitsi-meet.nix

···
 
       # required for muc_breakout_rooms
       package = lib.mkDefault (
-        config.services.prosody.package.override {
+        pkgs.prosody.override {
           withExtraLuaPackages = p: with p; [ cjson ];
         }
       );

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

···
           tr -dc A-Za-z0-9 </dev/urandom 2>/dev/null | head -c 64 > ${stateDir}/secret.key
         fi
 
-        echo "exit( wfGetDB( DB_PRIMARY )->tableExists( 'user' ) ? 1 : 0 );" | \
-        ${php}/bin/php ${pkg}/share/mediawiki/maintenance/eval.php --conf ${mediawikiConfig} && \
+        echo "exit( \$this->getPrimaryDB()->tableExists( 'user' ) ? 1 : 0 );" | \
+        ${php}/bin/php ${pkg}/share/mediawiki/maintenance/run.php eval --conf ${mediawikiConfig} && \
         ${php}/bin/php ${pkg}/share/mediawiki/maintenance/install.php \
           --confpath /tmp \
           --scriptpath / \

nixos/modules/system/activation/activation-script.nix

···
       source ${config.system.build.earlyMountScript}
     '';
 
-    systemd.user = {
+    systemd.user = lib.mkIf config.system.activatable {
       services.nixos-activation = {
         description = "Run user-specific NixOS activation";
         script = config.system.userActivationScripts.script;

nixos/modules/system/boot/kernel.nix

···
           {
             name = "foo";
             patch = ./foo.patch;
-            extraStructuredConfig.FOO = lib.kernel.yes;
+            structuredExtraConfig.FOO = lib.kernel.yes;
             features.foo = true;
           }
           {
···
                                         # (required, but can be null if only config changes
                                         # are needed)
 
-          extraStructuredConfig = {     # attrset of extra configuration parameters without the CONFIG_ prefix
+          structuredExtraConfig = {     # attrset of extra configuration parameters without the CONFIG_ prefix
             FOO = lib.kernel.yes;       # (optional)
           };                            # values should generally be lib.kernel.yes,
                                         # lib.kernel.no or lib.kernel.module
···
 
           extraConfig = "FOO y";        # extra configuration options in string form without the CONFIG_ prefix
                                         # (optional, multiple lines allowed to specify multiple options)
-                                        # (deprecated, use extraStructuredConfig instead)
+                                        # (deprecated, use structuredExtraConfig instead)
         }
         ```
 
···
 
           ln -s ${initrdPath} $out/initrd
 
-          ln -s ${config.system.build.initialRamdiskSecretAppender}/bin/append-initrd-secrets $out
+          ${optionalString (config.boot.initrd.secrets != { }) ''
+            ln -s ${config.system.build.initialRamdiskSecretAppender}/bin/append-initrd-secrets $out
+          ''}
 
           ln -s ${config.hardware.firmware}/lib/firmware $out/firmware
         '';

nixos/modules/system/boot/kexec.nix

···
-{ pkgs, lib, ... }:
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}:
 
+let
+  cfg = config.boot.kexec;
+in
 {
-  config = lib.mkIf (lib.meta.availableOn pkgs.stdenv.hostPlatform pkgs.kexec-tools) {
+  options.boot.kexec = {
+    enable = lib.mkEnableOption "kexec" // {
+      default = lib.meta.availableOn pkgs.stdenv.hostPlatform pkgs.kexec-tools;
+      defaultText = lib.literalExpression ''lib.meta.availableOn pkgs.stdenv.hostPlatform pkgs.kexec-tools'';
+    };
+  };
+
+  config = lib.mkIf cfg.enable {
     environment.systemPackages = [ pkgs.kexec-tools ];
 
     systemd.services.prepare-kexec = {

nixos/modules/tasks/filesystems.nix

···
     # Add the mount helpers to the system path so that `mount' can find them.
     system.fsPackages = [ pkgs.dosfstools ];
 
-    environment.systemPackages =
-      with pkgs;
-      [
-        fuse3
-        fuse
-      ]
-      ++ config.system.fsPackages;
+    environment.systemPackages = config.system.fsPackages;
 
     environment.etc.fstab.text =
       let

nixos/modules/tasks/network-interfaces.nix

···
       text = cfg.hostName + "\n";
     };
 
-    environment.systemPackages = [
-      pkgs.host
-      pkgs.hostname-debian
-      pkgs.iproute2
-      pkgs.iputils
-    ]
-    ++ optionals config.networking.wireless.enable [
-      pkgs.wirelesstools # FIXME: obsolete?
-      pkgs.iw
-    ]
-    ++ bridgeStp;
+    environment.corePackages = lib.mkOptionDefault (
+      [
+        pkgs.host
+        pkgs.hostname-debian
+        pkgs.iproute2
+        pkgs.iputils
+      ]
+      ++ optionals config.networking.wireless.enable [
+        pkgs.wirelesstools # FIXME: obsolete?
+        pkgs.iw
+      ]
+      ++ bridgeStp
+    );
 
     # Wake-on-LAN configuration is shared by the scripted and networkd backends.
     systemd.network.links = pipe interfaces [

nixos/tests/all-tests.nix

···
   };
   nixpkgs = pkgs.callPackage ../modules/misc/nixpkgs/test.nix { inherit evalMinimalConfig; };
   nixseparatedebuginfod = runTest ./nixseparatedebuginfod.nix;
+  nixseparatedebuginfod2 = runTest ./nixseparatedebuginfod2.nix;
   node-red = runTest ./node-red.nix;
   nomad = runTest ./nomad.nix;
   nominatim = runTest ./nominatim.nix;

nixos/tests/nixseparatedebuginfod.nix

···
 in
 {
   name = "nixseparatedebuginfod";
-  # A binary cache with debug info and source for nix
+  # A binary cache with debug info and source for gnumake
   nodes.cache =
     { pkgs, ... }:
     {
···
         openFirewall = true;
       };
       system.extraDependencies = [
-        pkgs.nix.debug
-        pkgs.nix.src
+        pkgs.gnumake.debug
+        pkgs.gnumake.src
         pkgs.sl
       ];
     };
···
     environment.systemPackages = [
       pkgs.valgrind
       pkgs.gdb
+      pkgs.gnumake
       (pkgs.writeShellScriptBin "wait_for_indexation" ''
         set -x
-        while debuginfod-find debuginfo /run/current-system/sw/bin/nix |& grep 'File too large'; do
+        while debuginfod-find debuginfo /run/current-system/sw/bin/make |& grep 'File too large'; do
           sleep 1;
         done
       '')
···
 
     # nixseparatedebuginfod needs .drv to associate executable -> source
     # on regular systems this would be provided by nixos-rebuild
-    machine.succeed("nix-instantiate '<nixpkgs>' -A nix")
+    machine.succeed("nix-instantiate '<nixpkgs>' -A gnumake")
 
     machine.succeed("timeout 600 wait_for_indexation")
 
     # test debuginfod-find
-    machine.succeed("debuginfod-find debuginfo /run/current-system/sw/bin/nix")
+    machine.succeed("debuginfod-find debuginfo /run/current-system/sw/bin/make")
 
     # test that gdb can fetch source
-    out = machine.succeed("gdb /run/current-system/sw/bin/nix --batch -x ${builtins.toFile "commands" ''
+    out = machine.succeed("gdb /run/current-system/sw/bin/make --batch -x ${builtins.toFile "commands" ''
       start
       l
     ''}")
     print(out)
-    assert 'int main(' in out
+    assert 'main (int argc, char **argv, char **envp)' in out
 
     # test that valgrind can display location information
-    # this relies on the fact that valgrind complains about nix
-    # libgc helps in this regard, and we also ask valgrind to show leak kinds
+    # this relies on the fact that valgrind complains about gnumake
+    # because we also ask valgrind to show leak kinds
     # which are usually false positives.
-    out = machine.succeed("valgrind --leak-check=full --show-leak-kinds=all nix-env --version 2>&1")
+    out = machine.succeed("valgrind --leak-check=full --show-leak-kinds=all make --version 2>&1")
     print(out)
-    assert 'main.cc' in out
+    assert 'main.c' in out
   '';
 }

nixos/tests/nixseparatedebuginfod2.nix

···
+{ pkgs, lib, ... }:
+{
+  name = "nixseparatedebuginfod2";
+  # A binary cache with debug info and source for gnumake
+  nodes.cache =
+    { pkgs, ... }:
+    {
+      services.nginx = {
+        enable = true;
+        virtualHosts.default = {
+          default = true;
+          addSSL = false;
+          root = "/var/lib/thebinarycache";
+        };
+      };
+      networking.firewall.allowedTCPPorts = [ 80 ];
+      systemd.services.buildthebinarycache = {
+        before = [ "nginx.service" ];
+        wantedBy = [ "nginx.service" ];
+        script = ''
+          ${pkgs.nix}/bin/nix --extra-experimental-features nix-command copy --to file:///var/lib/thebinarycache?index-debug-info=true ${pkgs.gnumake.debug} ${pkgs.gnumake} ${pkgs.gnumake.src} ${pkgs.sl}
+        '';
+        serviceConfig = {
+          User = "nginx";
+          Group = "nginx";
+          StateDirectory = "thebinarycache";
+          Type = "oneshot";
+        };
+      };
+    };
+  # the machine where we need the debuginfo
+  nodes.machine = {
+    services.nixseparatedebuginfod2 = {
+      enable = true;
+      substituter = "http://cache";
+    };
+    environment.systemPackages = [
+      pkgs.valgrind
+      pkgs.gdb
+      pkgs.gnumake
+    ];
+  };
+  testScript = ''
+    start_all()
+    cache.wait_for_unit("nginx.service")
+    cache.wait_for_open_port(80)
+    machine.wait_for_unit("nixseparatedebuginfod2.service")
+    machine.wait_for_open_port(1950)
+
+    with subtest("check that the binary cache works"):
+      machine.succeed("nix-store --extra-substituters http://cache --option require-sigs false -r ${pkgs.sl}")
+
+    # test debuginfod-find
+    machine.succeed("debuginfod-find debuginfo /run/current-system/sw/bin/make")
+
+    # test that gdb can fetch source
+    out = machine.succeed("gdb /run/current-system/sw/bin/make --batch -x ${builtins.toFile "commands" ''
+      start
+      l
+    ''}")
+    print(out)
+    assert 'main (int argc, char **argv, char **envp)' in out
+
+    # test that valgrind can display location information
+    # this relies on the fact that valgrind complains about gnumake
+    # because we also ask valgrind to show leak kinds
+    # which are usually false positives.
+    out = machine.succeed("valgrind --leak-check=full --show-leak-kinds=all make --version 2>&1")
+    print(out)
+    assert 'main.c' in out
+  '';
+}

nixos/tests/tayga.nix

···
   };
 
   nodes = {
-    # The server is configured with static IPv4 addresses. RFC 6052 Section 3.1
-    # disallows the mapping of non-global IPv4 addresses like RFC 1918 into the
-    # Well-Known Prefix 64:ff9b::/96. TAYGA also does not allow the mapping of
-    # documentation space (RFC 5737). To circumvent this, 100.64.0.2/24 from
-    # RFC 6589 (Carrier Grade NAT) is used here.
+    # The server is configured with static IPv4 addresses. We have to disable the
+    # well-known prefix restrictions (as required by RFC 6052 Section 3.1) because
+    # we're using private space (TAYGA also considers documentation space non-global,
+    # unfortunately).
     # To reach the IPv4 address pool of the NAT64 gateway, there is a static
     # route configured. In normal cases, where the router would also source NAT
     # the pool addresses to one IPv4 addresses, this would not be needed.
···
         };
       };
       programs.mtr.enable = true;
+      environment.systemPackages = [ pkgs.tcpdump ];
     };
 
     # The router is configured with static IPv4 addresses towards the server
···
       ];
 
       networking = {
+        hostName = "router-systemd";
         useDHCP = false;
         useNetworkd = true;
         firewall.enable = false;
···
         mappings = {
           "192.0.2.42" = "2001:db8::2";
         };
+        log = [
+          "drop"
+          "reject"
+          "icmp"
+          "self"
+        ];
+        wkpfStrict = false;
       };
+      environment.systemPackages = [ pkgs.tcpdump ];
     };
 
     router_nixos = {
···
       ];
 
       networking = {
+        hostName = "router-nixos";
         useDHCP = false;
         firewall.enable = false;
         interfaces.eth1 = lib.mkForce {
···
         mappings = {
           "192.0.2.42" = "2001:db8::2";
         };
+        log = [
+          "drop"
+          "reject"
+          "icmp"
+          "self"
+        ];
+        wkpfStrict = false;
       };
+      environment.systemPackages = [ pkgs.tcpdump ];
     };
 
     # The client is configured with static IPv6 addresses. It has also a static
···
         };
       };
       programs.mtr.enable = true;
+      environment.systemPackages = [ pkgs.tcpdump ];
     };
   };
 

nixos/tests/velocity.nix

···
           (mkVelocityService "velocity-with-native" (pkgs.velocity.override { withVelocityNative = true; }))
         ];
 
-      environment.systemPackages = [ pkgs.mcstatus ];
+      environment.systemPackages = [ (pkgs.python3.withPackages (p: [ p.mcstatus ])) ];
     };
 
   testScript = ''
···
       server.wait_until_succeeds(f"journalctl -b -u {name} | grep -q -E '{connections_startup_query}'")
       server.wait_until_succeeds(f"journalctl -b -u {name} | grep -q 'Done ([0-9]*.[0-9]*s)!'");
 
-      _, status_result = server.execute("mcstatus localhost:25565 status")
+      _, status_result = server.execute("python -m mcstatus localhost:25565 status")
       assert "A Velocity Server" in status_result
 
       server.execute(f"echo stop > /run/{name}.stdin")

pkgs/applications/editors/vim/plugins/generated.nix

···
     meta.hydraPlatforms = [ ];
   };
 
+  workspaces-nvim = buildVimPlugin {
+    pname = "workspaces.nvim";
+    version = "2024-10-08";
+    src = fetchFromGitHub {
+      owner = "natecraddock";
+      repo = "workspaces.nvim";
+      rev = "55a1eb6f5b72e07ee8333898254e113e927180ca";
+      sha256 = "143xzg60yiw1aam7sc5rva9bzzmshfzpm2sacimwr8188qsz8xvb";
+    };
+    meta.homepage = "https://github.com/natecraddock/workspaces.nvim/";
+    meta.hydraPlatforms = [ ];
+  };
+
   wrapping-nvim = buildVimPlugin {
     pname = "wrapping.nvim";
     version = "2025-01-16";

pkgs/applications/editors/vim/plugins/vim-plugin-names

···
 https://github.com/wannesm/wmgraphviz.vim/,,
 https://github.com/vim-scripts/wombat256.vim/,,
 https://github.com/lukaszkorecki/workflowish/,,
+https://github.com/natecraddock/workspaces.nvim/,HEAD,
 https://github.com/andrewferrier/wrapping.nvim/,HEAD,
 https://github.com/tweekmonster/wstrip.vim/,,
 https://github.com/piersolenski/wtf.nvim/,HEAD,

pkgs/applications/editors/vscode/extensions/WakaTime.vscode-wakatime/default.nix

···
   mktplcRef = {
     name = "vscode-wakatime";
     publisher = "WakaTime";
-    version = "25.2.2";
-    hash = "sha256-9Ldb45tCgLaTdntmQlcIPe13ZTeIVGKrHYXLRgLlB0w=";
+    version = "25.3.0";
+    hash = "sha256-cw3wcMr8QKG75VofIsAmlD2RqN/0fGdqhugen/vmJlo=";
   };
 
   meta = {

pkgs/applications/editors/vscode/extensions/dbaeumer.vscode-eslint/default.nix

···
   mktplcRef = {
     name = "vscode-eslint";
     publisher = "dbaeumer";
-    version = "3.0.15";
-    hash = "sha256-oeudNCBrHO3yvw3FrFA4EZk1yODcRRfF/y3U5tdEz4I=";
+    version = "3.0.16";
+    hash = "sha256-UxD07bouMK8nuysh5TAV7ZVhkLiOV6R1qfvVZcXB2Hc=";
   };
 
   meta = {

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

···
         mktplcRef = {
           publisher = "ban";
           name = "spellright";
-          version = "3.0.144";
-          hash = "sha256-+JNvChnAi2p04X3VVWgBZQAsF5UpAQpG7fROYtjaHRo=";
+          version = "3.0.146";
+          hash = "sha256-gvj5vWA8VAy5Ohtkn9vsx7MswgVAcxYOLm+ifKhjLz0=";
         };
         meta = {
           description = "Visual Studio Code extension for Spellchecker";
···
         mktplcRef = {
           publisher = "banacorn";
           name = "agda-mode";
-          version = "0.6.2";
-          hash = "sha256-OQHNbzlTnpv2V5ICNTfAC1QM3bDnRgtJvgJKONxvU5M=";
+          version = "0.6.3";
+          hash = "sha256-ZyFY3pzNUUpdAB3lqys/z0NOUrQA/qmPquRPNFw/JAI=";
         };
         meta = {
           changelog = "https://marketplace.visualstudio.com/items/banacorn.agda-mode/changelog";
···
         mktplcRef = {
           name = "vscode-tailwindcss";
           publisher = "bradlc";
-          version = "0.14.25";
-          hash = "sha256-NXA7UDSo6G0Did6tzwgIYnjR+ymoY7V5aUtaFzqlVik=";
+          version = "0.14.26";
+          hash = "sha256-agntfMsLAYASviH7Wuw/W8JwfHRi6qAfuMkqmFWT0bg=";
         };
         meta = {
           changelog = "https://marketplace.visualstudio.com/items/bradlc.vscode-tailwindcss/changelog";
···
         mktplcRef = {
           publisher = "DanielSanMedium";
           name = "dscodegpt";
-          version = "3.13.40";
-          hash = "sha256-2O96Bey2VKj2FdK1nJSYSKE9fltciNbqD/UI7rKlFgY=";
+          version = "3.14.3";
+          hash = "sha256-B0FYMM7usSkQgq7jZfo3uEvERRQ6PrinO36KJGke/Yo=";
         };
         meta = {
           changelog = "https://marketplace.visualstudio.com/items/DanielSanMedium.dscodegpt/changelog";
···
         mktplcRef = {
           name = "compare-folders";
           publisher = "moshfeu";
-          version = "0.25.1";
-          hash = "sha256-axNTdnSkMkFs7LSZCc7VinjbrDncsRHlRtDG9+eh2qQ=";
+          version = "0.25.3";
+          hash = "sha256-QrSh8/AycC5nKbZ1+E3V/lJu/7Skket8b05yPnZg68s=";
         };
 
         meta = {
···
         mktplcRef = {
           name = "volar";
           publisher = "Vue";
-          version = "3.0.4";
-          hash = "sha256-Eqg4+jX1dARryfb9Ueb2qng5xwhyaU6cDG089nlLNgc=";
+          version = "3.0.5";
+          hash = "sha256-Ja0zWCHHxd1XE2f2ZQvchqzCKv0pbcAU3uEh2f6+X3c=";
         };
         meta = {
           changelog = "https://github.com/vuejs/language-tools/blob/master/CHANGELOG.md";

pkgs/applications/editors/vscode/extensions/fstarlang.fstar-vscode-assistant/default.nix

···
   mktplcRef = {
     name = "fstar-vscode-assistant";
     publisher = "FStarLang";
-    version = "0.18.1";
-    hash = "sha256-uiw3EJbYoDG5r93NIxloiF7Co3gxcZT9+hlLZFnxkBE=";
+    version = "0.19.1";
+    hash = "sha256-bC9Kzhp4H9wykuitEKQUthYVhmVI/m8H0PloBqoFbvU=";
   };
   meta = {
     description = "Interactive editing mode VS Code extension for F*";

pkgs/applications/editors/vscode/extensions/ndonfris.fish-lsp/default.nix

···
     downloadPage = "https://marketplace.visualstudio.com/items?itemName=ndonfris.fish-lsp";
     homepage = "https://github.com/ndonfris/fish-lsp";
     license = lib.licenses.mit;
-    maintainers = with lib.maintainers; [ tuynia ];
   };
 }

pkgs/applications/editors/vscode/extensions/oliver-ni.scheme-fmt/default.nix

···
     downloadPage = "https://marketplace.visualstudio.com/items?itemName=oliver-ni.scheme-fmt";
     homepage = "https://github.com/oliver-ni/scheme-fmt";
     license = lib.licenses.cc0;
-    maintainers = with lib.maintainers; [ tuynia ];
   };
 }

pkgs/applications/editors/vscode/extensions/release-candidate.vscode-scheme-repl/default.nix

···
     downloadPage = "https://marketplace.visualstudio.com/items?itemName=release-candidate.vscode-scheme-repl";
     homepage = "https://github.com/Release-Candidate/vscode-scheme-repl";
     license = lib.licenses.mit;
-    maintainers = with lib.maintainers; [ tuynia ];
   };
 }

pkgs/applications/editors/vscode/extensions/rooveterinaryinc.roo-cline/default.nix

···
   mktplcRef = {
     publisher = "RooVeterinaryInc";
     name = "roo-cline";
-    version = "3.25.4";
-    hash = "sha256-uyI/VdBpkCxzlm1Ei2v/UjsenhyanDuVXLXk3Pkiw1s=";
+    version = "3.25.10";
+    hash = "sha256-j9ydB6hR+Qx4HvBDMrYGev2K/vsG6ASeOQHhhYheEuw=";
   };
 
   passthru.updateScript = vscode-extension-update-script { };

pkgs/applications/editors/vscode/extensions/tsyesika.guile-scheme-enhanced/default.nix

···
     downloadPage = "https://marketplace.visualstudio.com/items?itemName=tsyesika.guile-scheme-enhanced";
     homepage = "https://codeberg.org/tsyesika/vscode-guile-scheme-enhanced";
     license = lib.licenses.asl20;
-    maintainers = with lib.maintainers; [ tuynia ];
   };
 }

pkgs/applications/editors/vscode/extensions/ufo5260987423.magic-scheme/default.nix

···
     downloadPage = "https://marketplace.visualstudio.com/items?itemName=ufo5260987423.magic-scheme";
     homepage = "https://github.com/ufo5260987423/magic-scheme";
     license = lib.licenses.mit;
-    maintainers = with lib.maintainers; [ tuynia ];
   };
 }

pkgs/applications/emulators/libretro/cores/dolphin.nix

···
 }:
 mkLibretroCore {
   core = "dolphin";
-  version = "0-unstable-2025-05-17";
+  version = "0-unstable-2025-08-05";
 
   src = fetchFromGitHub {
     owner = "libretro";
     repo = "dolphin";
-    rev = "a09f78f735f0d2184f64ba5b134abe98ee99c65f";
-    hash = "sha256-NUnWNj47FmH8perfRwFFnaXeU58shUXqKFOzHf4ce5c=";
+    rev = "83438f9b1a2c832319876a1fda130a5e33d4ef87";
+    hash = "sha256-q4y+3uJ1tQ2OvlEvi/JNyIO/RfuWNIEKfVZ6xEWKFCg=";
   };
 
   extraNativeBuildInputs = [

pkgs/applications/emulators/libretro/cores/nestopia.nix

···
 }:
 mkLibretroCore {
   core = "nestopia";
-  version = "0-unstable-2025-07-20";
+  version = "0-unstable-2025-08-09";
 
   src = fetchFromGitHub {
     owner = "libretro";
     repo = "nestopia";
-    rev = "0e82a1642d4acafab4da9ce937954b85d846952b";
-    hash = "sha256-/r1EUb3Z6RaEycGnkU4RtYr0JjohgQmru99DG45OWKo=";
+    rev = "d33852f5efe89c87a06f8ce7d12b8b5451e9ae71";
+    hash = "sha256-v/jXoXgVEIXpxBgHZ/6oL+YGPDv9jefwdetiqLFBN9I=";
   };
 
   makefile = "Makefile";

pkgs/applications/networking/browsers/chromium/default.nix

···
         pulseSupport
         ungoogled
         ;
-      gnChromium = buildPackages.gn.overrideAttrs (oldAttrs: {
-        version = if (upstream-info.deps.gn ? "version") then upstream-info.deps.gn.version else "0";
-        src = fetchgit {
-          url = "https://gn.googlesource.com/gn";
-          inherit (upstream-info.deps.gn) rev hash;
-        };
-      });
+      gnChromium = buildPackages.gn.override upstream-info.deps.gn;
     });
 
     browser = callPackage ./browser.nix {

pkgs/applications/networking/browsers/chromium/info.json

···
         "hash": "sha256-UouvzNFStYScnyfIJcz1Om7cDhC7EyShZQ/Icu73BPo="
       },
       "gn": {
+        "version": "0-unstable-2025-06-19",
         "rev": "97b68a0bb62b7528bc3491c7949d6804223c2b82",
-        "hash": "sha256-m+z10s40Q/iYcoMw3o/+tmhIdqHMsYJjdGabHrK/aqo="
+        "hash": "sha256-gwptzuirIdPAV9XCaAT09aM/fY7d6xgBU7oSu9C4tmE="
       },
       "npmHash": "sha256-R2gOpfPOUAmnsnUTIvzDPHuHNzL/b2fwlyyfTrywEcI="
     },
···
         "hash": "sha256-UouvzNFStYScnyfIJcz1Om7cDhC7EyShZQ/Icu73BPo="
       },
       "gn": {
+        "version": "0-unstable-2025-06-19",
         "rev": "97b68a0bb62b7528bc3491c7949d6804223c2b82",
-        "hash": "sha256-m+z10s40Q/iYcoMw3o/+tmhIdqHMsYJjdGabHrK/aqo="
+        "hash": "sha256-gwptzuirIdPAV9XCaAT09aM/fY7d6xgBU7oSu9C4tmE="
       },
       "ungoogled-patches": {
         "rev": "139.0.7258.66-1",

pkgs/applications/networking/browsers/chromium/update.mjs

···
       chromedriver: !ungoogled ? await fetch_chromedriver_binaries(await get_latest_chromium_release('mac')) : undefined,
       deps: {
         depot_tools: {},
-        gn: {},
+        gn: await fetch_gn(chromium_rev, lockfile_initial[attr_path].deps.gn),
         'ungoogled-patches': !ungoogled ? undefined : {
           rev: ungoogled_patches.rev,
           hash: ungoogled_patches.hash,
···
     lockfile[attr_path].deps.depot_tools = {
       rev: depot_tools.rev,
       hash: depot_tools.hash,
-    }
-
-    const gn = await fetch_gn(chromium_rev, lockfile_initial[attr_path].deps.gn)
-    lockfile[attr_path].deps.gn = {
-      rev: gn.rev,
-      hash: gn.hash,
     }
 
     // DEPS update loop
···
 
 async function fetch_gn(chromium_rev, gn_previous) {
   const DEPS_file = await get_gitiles_file('https://chromium.googlesource.com/chromium/src', chromium_rev, 'DEPS')
-  const gn_rev = /^\s+'gn_version': 'git_revision:(?<rev>.+)',$/m.exec(DEPS_file).groups.rev
-  const hash = gn_rev === gn_previous.rev ? gn_previous.hash : ''
+  const { rev } = /^\s+'gn_version': 'git_revision:(?<rev>.+)',$/m.exec(DEPS_file).groups
+
+  const cache_hit = rev === gn_previous.rev;
+  if (cache_hit) {
+    return gn_previous
+  }
+
+  const commit_date = await get_gitiles_commit_date('https://gn.googlesource.com/gn', rev)
+  const version = `0-unstable-${commit_date}`
+
+  const expr = [`(import ./. {}).gn.override { version = "${version}"; rev = "${rev}"; hash = ""; }`]
+  const derivation = await $nixpkgs`nix-instantiate --expr ${expr}`
 
-  return await prefetch_gitiles('https://gn.googlesource.com/gn', gn_rev, hash)
+  return {
+    version,
+    rev,
+    hash: await prefetch_FOD(derivation),
+  }
+}
+
+
+async function get_gitiles_commit_date(base_url, rev) {
+  const url = `${base_url}/+/${rev}?format=json`
+  const response = await (await fetch(url)).text()
+  const json = JSON.parse(response.replace(`)]}'\n`, ''))
+
+  const date = new Date(json.commiter.time)
+  return date.toISOString().split("T")[0]
 }
 
 
···
 
   return hash
 }
-

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

···
 
 buildGoModule rec {
   pname = "helmfile";
-  version = "1.1.3";
+  version = "1.1.4";
 
   src = fetchFromGitHub {
     owner = "helmfile";
     repo = "helmfile";
     rev = "v${version}";
-    hash = "sha256-Nsfqd54QNRkeqUxUA05+0gtcoopz090/wW+zdFsEii8=";
+    hash = "sha256-q0PIvTsl5wbzSNyrJbN6y8nB7yJB3NO2RAvWKr8hmNU=";
   };
 
-  vendorHash = "sha256-fiwxmF91UCTNi3jgrJnWgPswWXQFLg70d+h3frnu7kU=";
+  vendorHash = "sha256-frwwqVmkiWtA6eg4rcd/KbG5CiEoF+rRO66/6WMxawI=";
 
   proxyVendor = true; # darwin/linux hash mismatch
 

pkgs/applications/networking/cluster/terraform-providers/providers.json

···
     "vendorHash": "sha256-ZCMSmOCPEMxCSpl3DjIUGPj1W/KNJgyjtHpmQ19JquA="
   },
   "datadog": {
-    "hash": "sha256-2BoazJ97yPtp627a5HpAVg9iD2OMIeXSmv5kkdxuTes=",
+    "hash": "sha256-Fi1Ip/Uy89s8XeX5yT55LKjMw/Bk/B/Vwvc0qXTaYbw=",
     "homepage": "https://registry.terraform.io/providers/DataDog/datadog",
     "owner": "DataDog",
     "repo": "terraform-provider-datadog",
-    "rev": "v3.69.0",
+    "rev": "v3.70.0",
     "spdx": "MPL-2.0",
-    "vendorHash": "sha256-AQ+/+NCBBj4ptBGHJmibH6QZo4560dRRbs55SqY9buE="
+    "vendorHash": "sha256-IW7v9w3/X+v+AF8eRE4n1KI7MnLWlxkXzTvAJtsQ4Ik="
   },
   "deno": {
     "hash": "sha256-7IvJrhXMeAmf8e21QBdYNSJyVMEzLpat4Tm4zHWglW8=",
···
     "vendorHash": "sha256-SsEWNIBkgcdTlSrB4hIvRmhMv2eJ2qQaPUmiN09A+NM="
   },
   "huaweicloud": {
-    "hash": "sha256-BzWYtn6KVVMq+wjqj3CMPKSzo9DzePIIdnRjJ53nJBI=",
+    "hash": "sha256-LLQFgUy3Hv3HlcL4gnZPdIEcR95fqroKIH4cLyb21Sk=",
     "homepage": "https://registry.terraform.io/providers/huaweicloud/huaweicloud",
     "owner": "huaweicloud",
     "repo": "terraform-provider-huaweicloud",
-    "rev": "v1.77.1",
+    "rev": "v1.77.3",
     "spdx": "MPL-2.0",
     "vendorHash": null
   },
···
     "vendorHash": "sha256-QxbZv6YMa5/I4bTeQBNdmG3EKtLEmstnH7HMiZzFJrI="
   },
   "migadu": {
-    "hash": "sha256-3q9vhHt4VDqcIYHEZjJY0whvGPQWMDHkGsAQEES8EkE=",
+    "hash": "sha256-k7W/oaZeBY5/Wi1vRCD641DKc0KQbBa834WDmtBp5wY=",
     "homepage": "https://registry.terraform.io/providers/metio/migadu",
     "owner": "metio",
     "repo": "terraform-provider-migadu",
-    "rev": "2025.7.17",
+    "rev": "2025.8.7",
     "spdx": "0BSD",
-    "vendorHash": "sha256-oipY2hwgRrntCxxHPyH06e8p+0fKfAQwhh2iBI4RGHQ="
+    "vendorHash": "sha256-CokSZ4CgWBCb/MnGK410Lt9rwBq3luceoFAPLLrwT5U="
   },
   "minio": {
     "hash": "sha256-TLWbbWYTjnvxT1LaV3FsL31xHHov8LpDYhA/nchMyMo=",
···
     "vendorHash": "sha256-MIO0VHofPtKPtynbvjvEukMNr5NXHgk7BqwIhbc9+u0="
   },
   "signalfx": {
-    "hash": "sha256-EoehHn7j3nnXzpHEjX4FQSO1na9xSmVpnTiPnTqUrpE=",
+    "hash": "sha256-hNMZbrihV+xlfamXRaGszQRqO8Tn2829rd4+pH83lrU=",
     "homepage": "https://registry.terraform.io/providers/splunk-terraform/signalfx",
     "owner": "splunk-terraform",
     "repo": "terraform-provider-signalfx",
-    "rev": "v9.17.0",
+    "rev": "v9.19.1",
     "spdx": "MPL-2.0",
-    "vendorHash": "sha256-404/DlCtz0yAaM8zJ3ngJ2/DwoUJImjIqKYwdigHl4U="
+    "vendorHash": "sha256-wpm7J8kfkm4vDZhZ0koQsgpW5JwWY7DngSYXfaWh3FQ="
   },
   "skytap": {
     "hash": "sha256-JII4czazo6Di2sad1uFHMKDO2gWgZlQE8l/+IRYHQHU=",

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

···
     license = licenses.unfree;
     sourceProvenance = with sourceTypes; [ binaryNativeCode ];
     maintainers = with maintainers; [
-      herberteuler
       rafaelrc
     ];
     platforms = [ "x86_64-linux" ];

pkgs/applications/video/mpv/scripts/skipsilence.nix

···
 
 buildLua {
   pname = "mpv-skipsilence";
-  version = "0-unstable-2024-05-06";
+  version = "0-unstable-2025-08-03";
 
   src = fetchFromGitHub {
     owner = "ferreum";
     repo = "mpv-skipsilence";
-    rev = "5ae7c3b6f927e728c22fc13007265682d1ecf98c";
-    hash = "sha256-fg8vfeb68nr0bTBIvr0FnRnoB48/kV957pn22tWcz1g=";
+    rev = "42e511c52c68c1aa9678e18caea41e43eee9149b";
+    hash = "sha256-+sOMWFFumJUk5gFE1iCTvWub3PWzYOkulXJLCGS4fYA=";
   };
 
   passthru.updateScript = unstableGitUpdater { };

pkgs/by-name/al/all-the-package-names/package.nix

···
 
 buildNpmPackage rec {
   pname = "all-the-package-names";
-  version = "2.0.2159";
+  version = "2.0.2168";
 
   src = fetchFromGitHub {
     owner = "nice-registry";
     repo = "all-the-package-names";
     tag = "v${version}";
-    hash = "sha256-7c4cxGSBc60WTLjRptb8VbTf279BxDgVOiVaP4C7pKk=";
+    hash = "sha256-iHwmvrDIiBMoH1LBrAbYvI/qPebTJIlvaOl6KxXJ+O8=";
   };
 
-  npmDepsHash = "sha256-fDQnEjPefRBbpCX21vZrJ3Y8y7d3PgM54IfPJbb44ao=";
+  npmDepsHash = "sha256-WxgcuQx/raixX4Y2diyDM5cAhsfFCUrNt+z02VC3Ng4=";
 
   passthru.updateScript = nix-update-script { };
 

pkgs/by-name/am/amp-cli/package-lock.json

···
   "packages": {
     "": {
       "dependencies": {
-        "@sourcegraph/amp": "^0.0.1754036264-ga0aa13"
+        "@sourcegraph/amp": "^0.0.1754827277-g1b1a5d"
       }
     },
     "node_modules/@colors/colors": {
···
         "kuler": "^2.0.0"
       }
     },
-    "node_modules/@luxass/strip-json-comments": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/@luxass/strip-json-comments/-/strip-json-comments-1.4.0.tgz",
-      "integrity": "sha512-Zl343to4u/t8jz1q7R/1UY6hLX+344cwPLEXsIYthVwdU5zyjuVBGcpf2E24+QZkwFfRfmnHTcscreQzWn3hiA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=18"
-      }
-    },
     "node_modules/@sourcegraph/amp": {
-      "version": "0.0.1754036264-ga0aa13",
-      "resolved": "https://registry.npmjs.org/@sourcegraph/amp/-/amp-0.0.1754036264-ga0aa13.tgz",
-      "integrity": "sha512-76U1LuEOPUuJcVyMvRkblfvQChJutVZcgCJ4DB/rwke2yxXp2rhdqAOd1bHc2qWrH/nlWX+2BBZY1wTZgAVxRg==",
+      "version": "0.0.1754827277-g1b1a5d",
+      "resolved": "https://registry.npmjs.org/@sourcegraph/amp/-/amp-0.0.1754827277-g1b1a5d.tgz",
+      "integrity": "sha512-P7PAvlEuRFz0dfpgErRe9brm00+1/I0xK2ym8QWt+hY6ITXtAFMbxJKELcsVpJwgSTJeFs3LUyj9glrJHdNMmw==",
       "dependencies": {
         "ansi-regex": "^6.1.0",
         "commander": "^11.1.0",
         "fuse.js": "^7.0.0",
-        "jsonc-parse": "^1.5.5",
+        "jsonc-parser": "^3.3.1",
         "open": "^10.1.2",
         "open-simplex-noise": "^2.5.0",
         "runes": "^0.4.3",
         "string-width": "^6.1.0",
         "winston": "^3.17.0",
+        "wrap-ansi": "^9.0.0",
         "xdg-basedir": "^5.1.0"
       },
       "bin": {
···
         "url": "https://github.com/chalk/ansi-regex?sponsor=1"
       }
     },
+    "node_modules/ansi-styles": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz",
+      "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
     "node_modules/async": {
       "version": "3.2.6",
       "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
···
         "node": ">=10"
       }
     },
+    "node_modules/get-east-asian-width": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.3.0.tgz",
+      "integrity": "sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/inherits": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
···
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/jsonc-parse": {
-      "version": "1.5.5",
-      "resolved": "https://registry.npmjs.org/jsonc-parse/-/jsonc-parse-1.5.5.tgz",
-      "integrity": "sha512-6xSVqUb+VBwXSJoyDPzgK1toG+JoOcfjWrmZNBL5ZmKnokV9dLshqyLU8NkcLavKbT5tKEr+3T0d4/7d+wVdVw==",
-      "license": "MIT",
-      "dependencies": {
-        "@luxass/strip-json-comments": "^1.3.2"
-      },
-      "engines": {
-        "node": ">=18"
-      }
+    "node_modules/jsonc-parser": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.3.1.tgz",
+      "integrity": "sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ==",
+      "license": "MIT"
     },
     "node_modules/kuler": {
       "version": "2.0.0",
···
       },
       "engines": {
         "node": ">= 12.0.0"
+      }
+    },
+    "node_modules/wrap-ansi": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.0.tgz",
+      "integrity": "sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^6.2.1",
+        "string-width": "^7.0.0",
+        "strip-ansi": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrap-ansi/node_modules/string-width": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz",
+      "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^10.3.0",
+        "get-east-asian-width": "^1.0.0",
+        "strip-ansi": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/xdg-basedir": {

pkgs/by-name/am/amp-cli/package.nix

···
 
 buildNpmPackage (finalAttrs: {
   pname = "amp-cli";
-  version = "0.0.1754036264-ga0aa13";
+  version = "0.0.1754827277-g1b1a5d";
 
   src = fetchzip {
     url = "https://registry.npmjs.org/@sourcegraph/amp/-/amp-${finalAttrs.version}.tgz";
-    hash = "sha256-+pvxRLoluRk6/XfPr5luW2oIAjWTCYMJo53wHzQh598=";
+    hash = "sha256-7LOp4/jpdxkeKi++vZGogobNiQpMqd5zMeCQywgc/wg=";
   };
 
   postPatch = ''
···
     chmod +x bin/amp-wrapper.js
   '';
 
-  npmDepsHash = "sha256-Xm/uZAf9bDasHGIhcS2G8JUo3GyTdnErjzU7clkFQW0=";
+  npmDepsHash = "sha256-6n+1fzet/JwLzaL9Z0ALIFY7Z0yaCwRCrv+73DxNkiY=";
 
   propagatedBuildInputs = [
     ripgrep

pkgs/by-name/au/automatic-timezoned/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "automatic-timezoned";
-  version = "2.0.84";
+  version = "2.0.85";
 
   src = fetchFromGitHub {
     owner = "maxbrunet";
     repo = "automatic-timezoned";
     rev = "v${version}";
-    sha256 = "sha256-Ul9bzMC8MfbfE4PDi3O8mhsImbspOcBDqTZOoVVeP/0=";
+    sha256 = "sha256-1Fsc33ZIZsXCPe0WuhFEO6HjSqrvzYoR6QD/MMPxVjA=";
   };
 
-  cargoHash = "sha256-GroKztTpPWTw/tyrPWfld1ix0BnkjphwHM3J/17byqM=";
+  cargoHash = "sha256-Gbb5+4RXZGebqGDcwVSXAipaQ3fA0Tu7jhQXnSyW9O0=";
 
   meta = {
     description = "Automatically update system timezone based on location";

pkgs/by-name/ba/balena-cli/package.nix

···
 in
 buildNpmPackage' rec {
   pname = "balena-cli";
-  version = "22.1.5";
+  version = "22.2.4";
 
   src = fetchFromGitHub {
     owner = "balena-io";
     repo = "balena-cli";
     rev = "v${version}";
-    hash = "sha256-5ltVQHye4miXA7W201n4XakP1eVyfFWzzaP+I7iKwOg=";
+    hash = "sha256-d0buLOiCHBpGhzduOCfJk+hraqS/njz1PTOD8QZSt8k=";
   };
 
-  npmDepsHash = "sha256-oYwysy/gBJZ3akTjkdZEaX3KfdBmoaXEPbdXZNs8Ds8=";
+  npmDepsHash = "sha256-7qecvPiJeV1rOLnI76WNwRGmx6PVCPHH5M/+OH+8l3I=";
 
   postPatch = ''
     ln -s npm-shrinkwrap.json package-lock.json

pkgs/by-name/ba/bazel-watcher/package.nix

···
 
 buildGoModule rec {
   pname = "bazel-watcher";
-  version = "0.26.8";
+  version = "0.26.10";
 
   src = fetchFromGitHub {
     owner = "bazelbuild";
     repo = "bazel-watcher";
     rev = "v${version}";
-    hash = "sha256-lAIIu6DWFQOwY6KFDaNVZg/H1pn2/eFmoqjtSGqBhMk=";
+    hash = "sha256-OrOJ24XdYASOgO8170M0huVGYubH8MJ0tbp0hvqmN/w=";
   };
 
-  vendorHash = "sha256-wbQY493O2d/fa46/qvCzBpv9OY1YPQjTEqHtT0A9EV0=";
+  vendorHash = "sha256-JkEJyrBY70+XO9qjw/t2qCayhVQzRkTEp/NXFTr+pXY=";
 
   # The dependency github.com/fsnotify/fsevents requires CGO
   env.CGO_ENABLED = if stdenv.hostPlatform.isDarwin then "1" else "0";

pkgs/by-name/br/brutespray/package.nix

···
 
 buildGoModule (finalAttrs: {
   pname = "brutespray";
-  version = "2.3.1";
+  version = "2.4.0";
 
   src = fetchFromGitHub {
     owner = "x90skysn3k";
     repo = "brutespray";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-oH7Gun/nKScv2buLwM6faiz9/3sl9l4JzkKbdTnGz0Q=";
+    hash = "sha256-tws3BvVQSlGcBgiJ8Ho7V/KJjzoq3TEOiChqTzrMbiU=";
   };
 
-  vendorHash = "sha256-TBLjCXb1W5FHBrzxBI0/3NMuM9eCizLiz489jyZsEso=";
+  vendorHash = "sha256-Fe3W5rlKygw4z5bF+6xy5mv86wKcBuCf3nhtdtFWJPM=";
 
   nativeBuildInputs = [ makeBinaryWrapper ];
 

pkgs/by-name/ch/cht-sh/package.nix

···
 
 stdenv.mkDerivation {
   pname = "cht.sh";
-  version = "0-unstable-2025-07-29";
+  version = "0-unstable-2025-08-08";
 
   nativeBuildInputs = [ makeWrapper ];
 
   src = fetchFromGitHub {
     owner = "chubin";
     repo = "cheat.sh";
-    rev = "bae856b96329e205967c74b3803023cb2b655df9";
-    sha256 = "7k/9DLSO1D+1BvTlRZBHOvz++LMw1DcpOL5LIb7VUXw=";
+    rev = "b714a5f0d56427924a7871f083fd05e7ede6b0e4";
+    sha256 = "JkqHxHgs7gUk511CSJ/sLEBWCAYig1lqfslhABDNMGI=";
   };
 
   # Fix ".cht.sh-wrapped" in the help message

pkgs/by-name/cl/clickhouse-backup/package.nix

···
 
 buildGoModule rec {
   pname = "clickhouse-backup";
-  version = "2.6.30";
+  version = "2.6.33";
 
   src = fetchFromGitHub {
     owner = "Altinity";
     repo = "clickhouse-backup";
     rev = "v${version}";
-    hash = "sha256-9CxmMCtrQlHO9Q7gGMN0mIKVERjdef9IB6YUXXuJxeg=";
+    hash = "sha256-H8LwinH9/J2QawzVggt9vA7/oqaTXy02xqqlGPNtZvc=";
   };
 
-  vendorHash = "sha256-tv5UaHoZTEAjo0jgbHRZHN6xiCNaexED+NG7cBDtiWA=";
+  vendorHash = "sha256-LTljOVQI1fRXvo0cfsiT6SU4Q9t5dyaCuHBq/BiVe/w=";
 
   ldflags = [
     "-X main.version=${version}"

pkgs/by-name/co/codex/package.nix

···
 }:
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "codex";
-  version = "0.19.0";
+  version = "0.20.0";
 
   src = fetchFromGitHub {
     owner = "openai";
     repo = "codex";
     tag = "rust-v${finalAttrs.version}";
-    hash = "sha256-s7gN1fsk/PRiVVzlrtmAUd2Vu8hhKtlCesLOVrzJ/58=";
+    hash = "sha256-v5PEj3T/eirAMpHHMR6LE9X8qDNhvCJP40Nleal3oOw=";
   };
 
   sourceRoot = "${finalAttrs.src.name}/codex-rs";

pkgs/by-name/co/copybara/package.nix

···
 }:
 stdenv.mkDerivation (finalAttrs: {
   pname = "copybara";
-  version = "20250728";
+  version = "20250804";
 
   src = fetchurl {
     url = "https://github.com/google/copybara/releases/download/v${finalAttrs.version}/copybara_deploy.jar";
-    hash = "sha256-/ulX5Q+P6ViiDcdwRpd9zhJAQiFULzU2fSXvfOk36xo=";
+    hash = "sha256-lus3WEwpd9TIGy7IO11d8eZ3S6J/jHzWRFQ76gRiVXg=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/cu/cubeb/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "cubeb";
-  version = "0-unstable-2025-07-10";
+  version = "0-unstable-2025-08-05";
 
   src = fetchFromGitHub {
     owner = "mozilla";
     repo = "cubeb";
-    rev = "fa021607121360af7c171d881dc5bc8af7bb56eb";
-    hash = "sha256-6PUHUPybe3g5nexunAHsHLThFdvpnv+avks+C0oYih0=";
+    rev = "d78a19ba4a892abfdfd7eeeb19fa7ffe3d80938c";
+    hash = "sha256-sjv5XKZu9uX2y2HN+BFttOsb6bECEpl0oRneYxNOZgU=";
   };
 
   outputs = [

pkgs/by-name/da/databricks-cli/package.nix

···
 
 buildGoModule (finalAttrs: {
   pname = "databricks-cli";
-  version = "0.262.0";
+  version = "0.263.0";
 
   src = fetchFromGitHub {
     owner = "databricks";
     repo = "cli";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-grA7HI9gJFgeqNxmd6SboAn9z2QKLok7BayGj2RMYog=";
+    hash = "sha256-bRHZGoO7+k7HoXcyJMusqDnn3XoAesgZ280j8jNgQYY=";
   };
 
   # Otherwise these tests fail asserting that the version is 0.0.0-dev

pkgs/by-name/eg/eggnog-mapper/package.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "eggnog-mapper";
-  version = "2.1.12";
+  version = "2.1.13";
   format = "setuptools";
 
   src = fetchFromGitHub {
     owner = "eggnogdb";
     repo = "eggnog-mapper";
     tag = version;
-    hash = "sha256-+luxXQmtGufYrA/9Ak3yKzbotOj2HM3vhIoOxE+Ty1U=";
+    hash = "sha256-Gu4D8DBvgCPlO+2MjeNZy6+lNqsIlksegWmmYvEZmUU=";
   };
 
   postPatch = ''

pkgs/by-name/er/ergo/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ergo";
-  version = "6.0.0";
+  version = "6.0.1";
 
   src = fetchurl {
     url = "https://github.com/ergoplatform/ergo/releases/download/v${version}/ergo-${version}.jar";
-    sha256 = "sha256-gHDXMirYSXMpBISMDW+Wh3o7BZuWnBG8CXV/thMh/Ww=";
+    sha256 = "sha256-ByvHXgXFdoHbc+lWEK82I/I50Q1aoe3SSI2JeaTjEC4=";
   };
 
   nativeBuildInputs = [ makeWrapper ];

pkgs/by-name/ev/evcc/package.nix

···
 }:
 
 let
-  version = "0.207.0";
+  version = "0.207.2";
 
   src = fetchFromGitHub {
     owner = "evcc-io";
     repo = "evcc";
     tag = version;
-    hash = "sha256-gaTY+9MB3nPRD2bOnWYS+vALRR9eHkFNCrEEMspE5ck=";
+    hash = "sha256-bBW2HU2TijUC6pn3gH23JTTGy5BWSm+V6BBsiYqi6U0=";
   };
 
-  vendorHash = "sha256-cn7zqhBJblDPl7H8BJtWZ2+ckTKVlqBIwwuXNGwrXdk=";
+  vendorHash = "sha256-VITdJ23xrO346EOlNe5uoOKcsQ76x+Yb7Vhl0/H+WTI=";
 
   commonMeta = with lib; {
     license = licenses.mit;
···
 
   npmDeps = fetchNpmDeps {
     inherit src;
-    hash = "sha256-yQ+MnXjixNQfWSVnRzmxRtQAvLecdLMDQSXyuIdzGnU=";
+    hash = "sha256-GB57pXfWo1lduVDPPw7TBM8qgCmTxPDxKQyD4ZZJnjE=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/fc/fcitx5-pinyin-moegirl/package.nix

···
 }:
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "fcitx5-pinyin-moegirl";
-  version = "20250711";
+  version = "20250810";
 
   src = fetchurl {
     url = "https://github.com/outloudvi/mw2fcitx/releases/download/${finalAttrs.version}/moegirl.dict";
-    hash = "sha256-kjdgsq5n+7rjPBrXOjrb13+JLPLeXNQFv9uhl4NSszM=";
+    hash = "sha256-PuuW43+uu9Vasy33KW1IKb2uK2mh8M/V9fVCVp1QZl0=";
   };
 
   dontUnpack = true;

pkgs/by-name/fc/fcitx5-pinyin-zhwiki/package.nix

···
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "fcitx5-pinyin-zhwiki";
   version = "0.2.5";
-  date = "20250415";
+  date = "20250731";
 
   src = fetchurl {
     url = "https://github.com/felixonmars/fcitx5-pinyin-zhwiki/releases/download/${finalAttrs.version}/zhwiki-${finalAttrs.date}.dict";
-    hash = "sha256-8dFBoP3UcYCl6EYojn14Bp7aYe/Z9cf4drSmeheHbLw=";
+    hash = "sha256-pS2fVLfihJGgKA1XsW1x0VanfhjHgDGtsqedpmvdUnE=";
   };
 
   dontUnpack = true;

pkgs/by-name/fi/fire/package.nix

···
 {
   stdenv,
   lib,
+  fetchurl,
   fetchFromGitHub,
+  runCommand,
   unstableGitUpdater,
   catch2_3,
   cmake,
+  fontconfig,
   pkg-config,
   libX11,
   libXrandr,
···
   libXcursor,
   freetype,
   alsa-lib,
+
+  # Only able to test this myself in Linux
+  withStandalone ? stdenv.hostPlatform.isLinux,
 }:
 
+let
+  # Required version, base URL and expected location specified in cmake/CPM.cmake
+  cpmDownloadVersion = "0.40.2";
+  cpmSrc = fetchurl {
+    url = "https://github.com/cpm-cmake/CPM.cmake/releases/download/v${cpmDownloadVersion}/CPM.cmake";
+    hash = "sha256-yM3DLAOBZTjOInge1ylk3IZLKjSjENO3EEgSpcotg10=";
+  };
+  cpmSourceCache = runCommand "cpm-source-cache" { } ''
+    mkdir -p $out/cpm
+    ln -s ${cpmSrc} $out/cpm/CPM_${cpmDownloadVersion}.cmake
+  '';
+
+  pathMappings = [
+    {
+      from = "LV2";
+      to = "${placeholder "out"}/${
+        if stdenv.hostPlatform.isDarwin then "Library/Audio/Plug-Ins/LV2" else "lib/lv2"
+      }";
+    }
+    {
+      from = "VST3";
+      to = "${placeholder "out"}/${
+        if stdenv.hostPlatform.isDarwin then "Library/Audio/Plug-Ins/VST3" else "lib/vst3"
+      }";
+    }
+    # this one's a guess, don't know where ppl have agreed to put them yet
+    {
+      from = "CLAP";
+      to = "${placeholder "out"}/${
+        if stdenv.hostPlatform.isDarwin then "Library/Audio/Plug-Ins/CLAP" else "lib/clap"
+      }";
+    }
+  ]
+  ++ lib.optionals withStandalone [
+    {
+      from = "Standalone";
+      to = "${placeholder "out"}/bin";
+    }
+  ]
+  ++ lib.optionals stdenv.hostPlatform.isDarwin [
+    # Audio Unit is a macOS-specific thing
+    {
+      from = "AU";
+      to = "${placeholder "out"}/Library/Audio/Plug-Ins/Components";
+    }
+  ];
+
+  x11Libs = [
+    libX11
+    libXrandr
+    libXinerama
+    libXext
+    libXcursor
+  ];
+in
 stdenv.mkDerivation (finalAttrs: {
   pname = "fire";
-  version = "1.0.1-unstable-2025-03-12";
+  version = "1.0.2-unstable-2025-07-05";
 
   src = fetchFromGitHub {
     owner = "jerryuhoo";
     repo = "Fire";
-    rev = "b7ded116ce7ab78a57bb9b6b61796cb2cf3a6e8b";
+    rev = "a0553c6fcced4919871771da3add390e931e29de";
     fetchSubmodules = true;
-    hash = "sha256-d8w+b4OpU2/kQdcAimR4ihDEgVTM1V7J0hj7saDrQpY=";
+    hash = "sha256-bHqWP3EZQg42OBi44Z1RvkIB2Ou0dDxgBLcidgxaMU8=";
   };
 
-  postPatch = ''
-    # Disable automatic copying of built plugins during buildPhase, it defaults
-    # into user home and we want to have building & installing separated.
-    substituteInPlace CMakeLists.txt \
-      --replace-fail 'COPY_PLUGIN_AFTER_BUILD TRUE' 'COPY_PLUGIN_AFTER_BUILD FALSE'
-  ''
-  + lib.optionalString stdenv.hostPlatform.isLinux ''
-    # Remove hardcoded LTO flags: needs extra setup on Linux
-    substituteInPlace CMakeLists.txt \
-      --replace-fail 'juce::juce_recommended_lto_flags' '# Not forcing LTO'
-  ''
-  + lib.optionalString (!finalAttrs.finalPackage.doCheck) ''
-    substituteInPlace CMakeLists.txt \
-      --replace-fail 'include(Tests)' '# Not building tests' \
-      --replace-fail 'include(Benchmarks)' '# Not building benchmark test'
-  '';
+  postPatch =
+    let
+      formatsListing = lib.strings.concatMapStringsSep " " (entry: entry.from) pathMappings;
+    in
+    ''
+      # Allow all the formats we can handle
+      # Set LV2URI again for LV2 build
+      # Disable automatic copying of built plugins during buildPhase, it defaults
+      # into user home and we want to have building & installing separated.
+      substituteInPlace CMakeLists.txt \
+        --replace-fail 'set(FORMATS' 'set(FORMATS ${formatsListing}) #' \
+        --replace-fail 'BUNDLE_ID "''${BUNDLE_ID}"' 'BUNDLE_ID "''${BUNDLE_ID}" LV2URI "https://www.bluewingsmusic.com/Fire/"' \
+        --replace-fail 'COPY_PLUGIN_AFTER_BUILD TRUE' 'COPY_PLUGIN_AFTER_BUILD FALSE'
+    ''
+    + lib.optionalString stdenv.hostPlatform.isLinux ''
+      # Remove hardcoded LTO flags: needs extra setup on Linux
+      substituteInPlace CMakeLists.txt \
+        --replace-fail 'juce::juce_recommended_lto_flags' '# Not forcing LTO'
+    ''
+    + lib.optionalString (!finalAttrs.finalPackage.doCheck) ''
+      substituteInPlace CMakeLists.txt \
+        --replace-fail 'include(Tests)' '# Not building tests' \
+        --replace-fail 'include(Benchmarks)' '# Not building benchmark test'
+    '';
 
   strictDeps = true;
 
···
     pkg-config
   ];
 
-  buildInputs = lib.optionals stdenv.hostPlatform.isLinux [
-    libX11
-    libXrandr
-    libXinerama
-    libXext
-    libXcursor
-    freetype
-    alsa-lib
-  ];
+  buildInputs = [
+    catch2_3
+    fontconfig
+  ]
+  ++ lib.optionals stdenv.hostPlatform.isLinux (
+    x11Libs
+    ++ [
+      freetype
+      alsa-lib
+    ]
+  );
 
   cmakeFlags = [
-    (lib.cmakeBool "FETCHCONTENT_FULLY_DISCONNECTED" true)
-    (lib.cmakeFeature "FETCHCONTENT_SOURCE_DIR_CATCH2" "${catch2_3.src}")
+    (lib.cmakeFeature "CPM_SOURCE_CACHE" "${cpmSourceCache}")
+    (lib.cmakeBool "CPM_LOCAL_PACKAGES_ONLY" true)
+    (lib.cmakeFeature "Catch2_SOURCE_DIR" "${catch2_3.src}")
   ];
 
-  installPhase =
-    let
-      pathMappings = [
-        {
-          from = "LV2";
-          to = "${placeholder "out"}/${
-            if stdenv.hostPlatform.isDarwin then "Library/Audio/Plug-Ins/LV2" else "lib/lv2"
-          }";
-        }
-        {
-          from = "VST3";
-          to = "${placeholder "out"}/${
-            if stdenv.hostPlatform.isDarwin then "Library/Audio/Plug-Ins/VST3" else "lib/vst3"
-          }";
-        }
-        # this one's a guess, don't know where ppl have agreed to put them yet
-        {
-          from = "CLAP";
-          to = "${placeholder "out"}/${
-            if stdenv.hostPlatform.isDarwin then "Library/Audio/Plug-Ins/CLAP" else "lib/clap"
-          }";
-        }
-      ]
-      ++ lib.optionals stdenv.hostPlatform.isDarwin [
-        {
-          from = "AU";
-          to = "${placeholder "out"}/Library/Audio/Plug-Ins/Components";
-        }
-      ];
-    in
-    ''
-      runHook preInstall
+  installPhase = ''
+    runHook preInstall
 
-    ''
-    + lib.strings.concatMapStringsSep "\n" (entry: ''
-      mkdir -p ${entry.to}
-      # Exact path of the build artefact depends on used CMAKE_BUILD_TYPE
-      cp -r Fire_artefacts/*/${entry.from}/* ${entry.to}/
-    '') pathMappings
-    + ''
+  ''
+  + lib.strings.concatMapStringsSep "\n" (entry: ''
+    mkdir -p ${entry.to}
+    # Exact path of the build artefact depends on used CMAKE_BUILD_TYPE
+    cp -r -t ${entry.to} Fire_artefacts/${finalAttrs.cmakeBuildType or "Release"}/${entry.from}/*
+  '') pathMappings
+  + ''
 
-      runHook postInstall
-    '';
+    runHook postInstall
+  '';
 
   doCheck = stdenv.buildPlatform.canExecute stdenv.hostPlatform;
 
+  # Standalone dlopen's X11 libraries
+  postFixup = lib.strings.optionalString (withStandalone && stdenv.hostPlatform.isLinux) ''
+    patchelf --add-rpath ${lib.makeLibraryPath x11Libs} $out/bin/Fire
+  '';
+
   passthru.updateScript = unstableGitUpdater { tagPrefix = "v"; };
 
   meta = {
     description = "Multi-band distortion plugin by Wings";
-    homepage = "https://github.com/jerryuhoo/Fire";
+    homepage = "https://www.bluewingsmusic.com/Fire";
     license = lib.licenses.agpl3Only; # Not clarified if Only or Plus
     platforms = lib.platforms.unix;
     maintainers = with lib.maintainers; [ OPNA2608 ];
+  }
+  // lib.optionalAttrs withStandalone {
+    mainProgram = "Fire";
   };
 })

pkgs/by-name/fo/foxglove-cli/package.nix

···
 }:
 buildGoModule (finalAttrs: {
   pname = "foxglove-cli";
-  version = "1.0.24";
+  version = "1.0.25";
 
   src = fetchFromGitHub {
     owner = "foxglove";
     repo = "foxglove-cli";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-JYaBVXSKn4zgWHq+s/tMgHCpQ2z5ZYh/+e+ex4MaUmo=";
+    hash = "sha256-zmX3eCh5NYCbYlbx6bIxwF6Qktj+kwV4KpVsTI9ofZ8=";
   };
 
   vendorHash = "sha256-fL/eOGx81pdIPWHt14cf4VoIqmfUmbkKa8/y0QQKYko=";

pkgs/by-name/fx/fx/package.nix

···
 
 buildGoModule (finalAttrs: {
   pname = "fx";
-  version = "38.0.0";
+  version = "39.0.1";
 
   src = fetchFromGitHub {
     owner = "antonmedv";
     repo = "fx";
     tag = finalAttrs.version;
-    hash = "sha256-9g9xtnmM3ANsvfxqE8pMTxiiUj+uQadhBooRQYKQpTg=";
+    hash = "sha256-KVnPESE0Fp1liOZtpDgNpAggROnGHYdefAAECkbgZDE=";
   };
 
-  vendorHash = "sha256-yVAoswClpf5+1nwLyrLKLYFt9Noh2HRemif1e1nWm7M=";
+  vendorHash = "sha256-7x0nbgMzEJznDH6Wf5iaTYXLh/2IGUSeSVvb0UKKTOQ=";
 
   ldflags = [ "-s" ];
 

pkgs/by-name/gi/git-repo/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "git-repo";
-  version = "2.57.2";
+  version = "2.57.3";
 
   src = fetchFromGitHub {
     owner = "android";
     repo = "tools_repo";
     rev = "v${version}";
-    hash = "sha256-B8Z5qkjUrydjWTeAanDHMn7C2qVIIqb90zJ6WrI6fgI=";
+    hash = "sha256-QJr1srOHcCnIQZNz56+zBlKs5ZA0/yDfhILek7pBx1Q=";
   };
 
   # Fix 'NameError: name 'ssl' is not defined'

pkgs/by-name/gi/git-statuses/package.nix

···
   lib,
   fetchFromGitHub,
   rustPlatform,
+  installShellFiles,
   pkg-config,
   openssl,
+  git,
   versionCheckHook,
+  stdenv,
   nix-update-script,
 }:
 
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "git-statuses";
-  version = "0.4.0";
+  version = "0.5.1";
 
   src = fetchFromGitHub {
     owner = "bircni";
     repo = "git-statuses";
     tag = finalAttrs.version;
-    hash = "sha256-e4g4tiewhN5acrkGN9Y5+WO+ihogiJXmT4PlhLtyWcs=";
+    hash = "sha256-nuWtW1NEECBqQ5uZKRqnvbjMUeYBg04j51zrHi/SDm0=";
   };
 
-  cargoHash = "sha256-IqlVwh80yTzVHWi5L+EQzt5SksK7SlBowZy46HnA+FI=";
+  cargoHash = "sha256-WAr5AkT4C14HupJHHZi209jtE8a9IUwOCw76cYu8Yjc=";
 
   # Needed to get openssl-sys to use pkg-config.
   env.OPENSSL_NO_VENDOR = 1;
 
   nativeBuildInputs = [
+    installShellFiles
     pkg-config
   ];
   buildInputs = [
     openssl
   ];
   nativeInstallCheckInputs = [
+    git
     versionCheckHook
   ];
   doInstallCheck = true;
+
+  postInstall = lib.optionalString (stdenv.buildPlatform.canExecute stdenv.hostPlatform) ''
+    installShellCompletion --cmd git-statuses \
+      --bash <($out/bin/git-statuses --completions bash) \
+      --fish <($out/bin/git-statuses --completions fish) \
+      --zsh <($out/bin/git-statuses --completions zsh)
+  '';
 
   passthru.updateScript = nix-update-script { };
 

pkgs/by-name/gi/github-backup/package.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "github-backup";
-  version = "0.50.2";
+  version = "0.50.3";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "josegonzalez";
     repo = "python-github-backup";
     tag = version;
-    hash = "sha256-MUPQa1L3HmAMn1pZSzQk8VKpcz2nDGuWZB8pVi7CyYs=";
+    hash = "sha256-MBKBY86qIM/rgvGMvE7K9x9n+zDVtoimkVGLBxCWRmI=";
   };
 
   build-system = with python3Packages; [

pkgs/by-name/gn/gn/generic.nix

···
-{
-  stdenv,
-  lib,
-  fetchgit,
-  fetchpatch,
-  cctools,
-  writeText,
-  ninja,
-  python3,
-  ...
-}:
-
-{
-  rev,
-  revNum,
-  version,
-  sha256,
-}:
-
-let
-  revShort = builtins.substring 0 7 rev;
-  lastCommitPosition = writeText "last_commit_position.h" ''
-    #ifndef OUT_LAST_COMMIT_POSITION_H_
-    #define OUT_LAST_COMMIT_POSITION_H_
-
-    #define LAST_COMMIT_POSITION_NUM ${revNum}
-    #define LAST_COMMIT_POSITION "${revNum} (${revShort})"
-
-    #endif  // OUT_LAST_COMMIT_POSITION_H_
-  '';
-
-in
-stdenv.mkDerivation {
-  pname = "gn-unstable";
-  inherit version;
-
-  src = fetchgit {
-    # Note: The TAR-Archives (+archive/${rev}.tar.gz) are not deterministic!
-    url = "https://gn.googlesource.com/gn";
-    inherit rev sha256;
-  };
-
-  nativeBuildInputs = [
-    ninja
-    python3
-  ];
-  buildInputs = lib.optionals stdenv.hostPlatform.isDarwin [
-    cctools
-  ];
-
-  env.NIX_CFLAGS_COMPILE = "-Wno-error";
-  # Relax hardening as otherwise gn unstable 2024-06-06 and later fail with:
-  # cc1plus: error: '-Wformat-security' ignored without '-Wformat' [-Werror=format-security]
-  hardeningDisable = [ "format" ];
-
-  buildPhase = ''
-    python build/gen.py --no-last-commit-position
-    ln -s ${lastCommitPosition} out/last_commit_position.h
-    ninja -j $NIX_BUILD_CORES -C out gn
-  '';
-
-  installPhase = ''
-    install -vD out/gn "$out/bin/gn"
-  '';
-
-  setupHook = ./setup-hook.sh;
-
-  meta = with lib; {
-    description = "Meta-build system that generates build files for Ninja";
-    mainProgram = "gn";
-    homepage = "https://gn.googlesource.com/gn";
-    license = licenses.bsd3;
-    platforms = platforms.unix;
-    maintainers = with maintainers; [
-      stesie
-      matthewbauer
-    ];
-  };
-}

pkgs/by-name/gn/gn/package.nix

···
-{ callPackage, ... }@args:
+{
+  stdenv,
+  lib,
+  fetchgit,
+  cctools,
+  ninja,
+  python3,
 
-callPackage ./generic.nix args {
   # Note: Please use the recommended version for Chromium stable, i.e. from
   # <nixpkgs>/pkgs/applications/networking/browsers/chromium/info.json
-  rev = "85cc21e94af590a267c1c7a47020d9b420f8a033";
-  revNum = "2233"; # git describe $rev --match initial-commit | cut -d- -f3
-  version = "2025-04-28";
-  sha256 = "sha256-+nKP2hBUKIqdNfDz1vGggXSdCuttOt0GwyGUQ3Z1ZHI=";
+  version ?
+    # This is a workaround for update-source-version to be able to update this
+    let
+      _version = "0-unstable-2025-06-19";
+    in
+    _version,
+  rev ? "97b68a0bb62b7528bc3491c7949d6804223c2b82",
+  hash ? "sha256-gwptzuirIdPAV9XCaAT09aM/fY7d6xgBU7oSu9C4tmE=",
+}:
+
+stdenv.mkDerivation {
+  pname = "gn";
+  inherit version;
+
+  src = fetchgit {
+    url = "https://gn.googlesource.com/gn";
+    inherit rev hash;
+    leaveDotGit = true;
+    deepClone = true;
+    postFetch = ''
+      cd "$out"
+      mkdir .nix-files
+      git rev-parse --short=12 HEAD > .nix-files/REV_SHORT
+      git describe --match initial-commit | cut -d- -f3 > .nix-files/REV_NUM
+      find "$out" -name .git -print0 | xargs -0 rm -rf
+    '';
+  };
+
+  nativeBuildInputs = [
+    ninja
+    python3
+  ];
+  buildInputs = lib.optionals stdenv.hostPlatform.isDarwin [
+    cctools
+  ];
+
+  env.NIX_CFLAGS_COMPILE = "-Wno-error";
+  # Relax hardening as otherwise gn unstable 2024-06-06 and later fail with:
+  # cc1plus: error: '-Wformat-security' ignored without '-Wformat' [-Werror=format-security]
+  hardeningDisable = [ "format" ];
+
+  configurePhase = ''
+    runHook preConfigure
+
+    python build/gen.py --no-last-commit-position
+    cat > out/last_commit_position.h << EOF
+    #ifndef OUT_LAST_COMMIT_POSITION_H_
+    #define OUT_LAST_COMMIT_POSITION_H_
+
+    #define LAST_COMMIT_POSITION_NUM $(<.nix-files/REV_NUM)
+    #define LAST_COMMIT_POSITION "$(<.nix-files/REV_NUM) ($(<.nix-files/REV_SHORT))"
+
+    #endif  // OUT_LAST_COMMIT_POSITION_H_
+    EOF
+
+    runHook postConfigure
+  '';
+
+  buildPhase = ''
+    runHook preBuild
+
+    ninja -v -j $NIX_BUILD_CORES -C out gn
+
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    install -vD out/gn "$out/bin/gn"
+
+    runHook postInstall
+  '';
+
+  setupHook = ./setup-hook.sh;
+
+  passthru.updateScript = ./update.sh;
+
+  meta = {
+    description = "Meta-build system that generates build files for Ninja";
+    mainProgram = "gn";
+    homepage = "https://gn.googlesource.com/gn";
+    license = lib.licenses.bsd3;
+    platforms = lib.platforms.unix;
+    maintainers = with lib.maintainers; [
+      stesie
+      matthewbauer
+      marcin-serwin
+      emilylange
+    ];
+  };
 }

pkgs/by-name/gn/gn/update.sh

···
+#!/usr/bin/env nix-shell
+#!nix-shell -i bash -p jq curl common-updater-scripts
+
+set -ex
+
+rev=$(
+  curl --location "https://raw.githubusercontent.com/NixOS/nixpkgs/refs/heads/master/pkgs/applications/networking/browsers/chromium/info.json" \
+  | jq -r ".chromium.deps.gn.rev"
+)
+
+commit_time=$(
+  curl "https://gn.googlesource.com/gn/+/$rev?format=json" \
+  | sed "s/)]}'//" \
+  | jq -r ".committer.time" \
+  | awk '{print $2, $3, $5, $4 $6}'
+)
+
+commit_date=$(TZ= date --date "$commit_time" --iso-8601)
+version="0-unstable-$commit_date"
+
+update-source-version --rev="$rev" --version-key="_version" "gn" "$version"

pkgs/by-name/go/google-chrome/package.nix

···
 
   linux = stdenvNoCC.mkDerivation (finalAttrs: {
     inherit pname meta passthru;
-    version = "138.0.7204.183";
+    version = "139.0.7258.66";
 
     src = fetchurl {
       url = "https://dl.google.com/linux/chrome/deb/pool/main/g/google-chrome-stable/google-chrome-stable_${finalAttrs.version}-1_amd64.deb";
-      hash = "sha256-GxdfHU6pskOL0i/rmN7kwGsuLYTotL1mEw6RV7qfl50=";
+      hash = "sha256-DY1hFlYKVSWRYuK1DGaqxr4x+kEmXnr/GsKBC39rCxk=";
     };
 
     # With strictDeps on, some shebangs were not being patched correctly
···
 
   darwin = stdenvNoCC.mkDerivation (finalAttrs: {
     inherit pname meta passthru;
-    version = "138.0.7204.184";
+    version = "139.0.7258.67";
 
     src = fetchurl {
-      url = "http://dl.google.com/release2/chrome/acvbvqaeyyrjo6kygs27pc5y27ea_138.0.7204.184/GoogleChrome-138.0.7204.184.dmg";
-      hash = "sha256-KM9fK5zaXNCdVfCRN9b0RxIvH7VxCln4Eo9YgOEd8PY=";
+      url = "http://dl.google.com/release2/chrome/l4kjdkw5j5zarcsucmoo3n4idi_139.0.7258.67/GoogleChrome-139.0.7258.67.dmg";
+      hash = "sha256-IfJlHRpMZy1DFmOC6yZ5dphchdOSvUYf7s3+ngQ7pL4=";
     };
 
     dontPatch = true;

pkgs/by-name/go/gose/package.nix

···
   lib,
 }:
 let
-  version = "0.11.1";
+  version = "0.11.2";
 
   src = fetchFromGitHub {
     repo = "gose";
     owner = "stv0g";
     tag = "v${version}";
-    hash = "sha256-Wz3gcx9/wrSfiHkOGnjAoUFfN0tiA1C+31GlnHqL3M0=";
+    hash = "sha256-AeGrnRnKThv29wFopx91BSep22WFkkKkUsTa7qFQOzs=";
   };
 
   frontend = buildNpmPackage {
···
   inherit version;
   inherit src;
 
-  vendorHash = "sha256-HsYF4v7RUzGDJvZEoq0qTo9iPGJoqK4YqTsXSv8SwKQ=";
+  vendorHash = "sha256-9qQXk8XyvVsussu5YfoSrjEul0E1301W019vTVSgnkk=";
 
   env.CGO_ENABLED = 0;
 

pkgs/by-name/ha/halo/package.nix

···
 }:
 stdenv.mkDerivation rec {
   pname = "halo";
-  version = "2.21.4";
+  version = "2.21.6";
   src = fetchurl {
     url = "https://github.com/halo-dev/halo/releases/download/v${version}/halo-${version}.jar";
-    hash = "sha256-RoisTthVRq6UGTE5jRdo6tL/3UVaOu1/3XPpwyLQV4g=";
+    hash = "sha256-kMz97dsWUbP4taRjxS84I+NWPyefVlP/WaY6pk7K6Q0=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/ho/holo-cli/package.nix

···
 
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "holo-cli";
-  version = "0.5.0-unstable-2025-07-01";
+  version = "0.5.0-unstable-2025-08-07";
 
   src = fetchFromGitHub {
     owner = "holo-routing";
     repo = "holo-cli";
-    rev = "f04c1d0dcd6d800e079f33b8431b17fa00afeeb1";
-    hash = "sha256-ZJeXGT5oajynk44550W4qz+OZEx7y52Wwy+DYzrHZig=";
+    rev = "e786bb16e5e6b78989dc3b4e3299b283432dfa26";
+    hash = "sha256-uqRgitI4D2H9igVdnwuNnc3frRiEZ85/DILp6FzGQ+0=";
   };
 
   cargoHash = "sha256-bsoxWjOMzRRtFGEaaqK0/adhGpDcejCIY0Pzw1HjQ5U=";

pkgs/by-name/ho/home-manager/package.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "home-manager";
-  version = "0-unstable-2025-07-28";
+  version = "0-unstable-2025-08-06";
 
   src = fetchFromGitHub {
     name = "home-manager-source";
     owner = "nix-community";
     repo = "home-manager";
-    rev = "f49e872f55e36e67ebcb906ff65f86c7a1538f7c";
-    hash = "sha256-vojVM0SgFP8crFh1LDDXkzaI9/er/1cuRfbNPhfBHyc=";
+    rev = "13461dec40bf03d9196ff79d1abe48408268cc35";
+    hash = "sha256-V0iiDcYvNeMOP2FyfgC4H8Esx+JodXEl80lD4hFD4SI=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/ii/iio-sensor-proxy/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "iio-sensor-proxy";
-  version = "3.7";
+  version = "3.8";
 
   src = fetchFromGitLab {
     domain = "gitlab.freedesktop.org";
     owner = "hadess";
     repo = "iio-sensor-proxy";
     rev = version;
-    hash = "sha256-MAfh6bgh39J5J3rlyPjyCkk5KcfWHMZLytZcBRPHaJE=";
+    hash = "sha256-ZVaV4Aj4alr5eP3uz6SunpeRsMOo8YcZMqCcB0DUYGY=";
   };
-
-  # Fix devices with cros-ec-accel, like Chromebooks and Framework Laptop 12
-  # https://gitlab.freedesktop.org/hadess/iio-sensor-proxy/-/merge_requests/400
-  patches = [
-    (fetchpatch2 {
-      name = "mr400_1.patch";
-      url = "https://gitlab.freedesktop.org/hadess/iio-sensor-proxy/-/commit/f35d293e65841a3b9c0de778300c7fa58b181fd0.patch";
-      hash = "sha256-Gk8Wpy+KFhHAsR3XklcsL3Eo4fHjQuFT6PCN5hz9KHk=";
-    })
-    (fetchpatch2 {
-      name = "mr400_2.patch";
-      url = "https://gitlab.freedesktop.org/hadess/iio-sensor-proxy/-/commit/7416edf4da98d8e3b75f9eddb7e5c488ac4a4c54.patch";
-      hash = "sha256-5UnYam6P+paBHAI0qKXDAvrFM8JYhRVTUFePRTHCp+U=";
-    })
-    (fetchpatch2 {
-      name = "mr400_3.patch";
-      url = "https://gitlab.freedesktop.org/hadess/iio-sensor-proxy/-/commit/d00109194422a4fe3e9a7bc1235ffc492459c61a.patch";
-      hash = "sha256-58KrXbdpR1eWbPmsr8b0ke67hX5J0o0gtqzrz3dc+ck=";
-    })
-  ];
 
   postPatch = ''
     # upstream meson.build currently doesn't have an option to change the default polkit dir

pkgs/by-name/jd/jd-diff-patch/package.nix

···
 
 buildGoModule (finalAttrs: {
   pname = "jd-diff-patch";
-  version = "2.2.3";
+  version = "2.2.5";
 
   src = fetchFromGitHub {
     owner = "josephburnett";
     repo = "jd";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-ucSJfzkcOpLfI2IcsnKvjpR/hwHNne+liE1b/L/H96g=";
+    hash = "sha256-E11Hd2uvF5LrgrWpR8OzXqEjoUrBkBHDDuuCujznfbE=";
   };
 
   sourceRoot = "${finalAttrs.src.name}/v2";

pkgs/by-name/je/jellyfin-tui/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "jellyfin-tui";
-  version = "1.2.3";
+  version = "1.2.4";
 
   src = fetchFromGitHub {
     owner = "dhonus";
     repo = "jellyfin-tui";
     tag = "v${version}";
-    hash = "sha256-gT6Zs32BhSfwH+JjwJcY9wK7WrqGuaWP+q/2rF8gp4M=";
+    hash = "sha256-fRlnfCHjUZWvp+pYxLUXFxW/nR7Glhhfm4YQKLR2XaY=";
   };
 
-  cargoHash = "sha256-U298pYDYzaRdU5w3FWHMkgaCT15aUTZITroVcEJ1Q0w=";
+  cargoHash = "sha256-VUg96qyTF7XkZsl4wl70u5S9NqgRCGJ4od8Cj4dSoI8=";
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [

pkgs/by-name/kn/knowsmore/package.nix

···
 
 python3.pkgs.buildPythonApplication rec {
   pname = "knowsmore";
-  version = "0.1.45";
+  version = "0.1.46";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "helviojunior";
     repo = "knowsmore";
     tag = "v${version}";
-    hash = "sha256-Z0N98P1vh9nhqOzlkL/BgqQrybeig5TrHsg1K4jqGxw=";
+    hash = "sha256-yY3BLouIUvSBeNlq4XcEHKLi00BWeGUXNOP2p5NIFXc=";
   };
 
   pythonRelaxDeps = [

pkgs/by-name/lo/local-content-share/package.nix

···
 
 buildGoModule (finalAttrs: {
   pname = "local-content-share";
-  version = "31";
+  version = "32";
 
   src = fetchFromGitHub {
     owner = "Tanq16";
     repo = "local-content-share";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-BVO804Ndjbg4uEE1bufZcGZxEVdraV29LJ6yBWXTakA=";
+    hash = "sha256-2TgamuHDASwSKshPkNLAnwnnCU23SvdXWv6sU++yBII=";
   };
 
   vendorHash = null;

pkgs/by-name/ma/matrix-alertmanager-receiver/package.nix

···
 
 buildGoModule (finalAttrs: {
   pname = "matrix-alertmanager-receiver";
-  version = "2025.7.30";
+  version = "2025.8.6";
 
   src = fetchFromGitHub {
     owner = "metio";
     repo = "matrix-alertmanager-receiver";
     tag = finalAttrs.version;
-    hash = "sha256-2zTkRXXXMMphNyw/OeiIAmc4KP0LqN6M0vtpX/7fhoI=";
+    hash = "sha256-rnGKpJppR7NoOAx/jGt7vxr1EVok3tMzkr9ry/k57L8=";
   };
 
-  vendorHash = "sha256-zOaAvPCAEQkJMogJ6ly0jkHfj+SAlFqk5m+eQdsaxK4=";
+  vendorHash = "sha256-JMjfrSdaN2zXgACkPddQ9h7SLV6jhpUvFTk56UfPWJg=";
 
   env.CGO_ENABLED = "0";
 

pkgs/by-name/me/melange/package.nix

···
 
 buildGoModule rec {
   pname = "melange";
-  version = "0.30.1";
+  version = "0.30.5";
 
   src = fetchFromGitHub {
     owner = "chainguard-dev";
     repo = "melange";
     rev = "v${version}";
-    hash = "sha256-BHeWrT0naxHLgd91xLTDHdDCt7piItPJMyjrRWQb2cA=";
+    hash = "sha256-df8CHUVHvSK1nFpJIuVHmwbHsigwZLL5UwA0/V6NkxE=";
     # populate values that require us to use git. By doing this in postFetch we
     # can delete .git afterwards and maintain better reproducibility of the src.
     leaveDotGit = true;
···
     '';
   };
 
-  vendorHash = "sha256-K2i9cQIcRkLbGIcGtEMo/PHO6pV2UXo/JgKdndWI7KM=";
+  vendorHash = "sha256-hyE/5P2EabICjueTln2zBmdIK73OqteWwmT5mSf7vXE=";
 
   subPackages = [ "." ];
 

pkgs/by-name/ni/nixseparatedebuginfod2/package.nix

···
+{
+  lib,
+  fetchFromGitHub,
+  rustPlatform,
+  libarchive,
+  openssl,
+  pkg-config,
+  bubblewrap,
+  elfutils,
+  nix,
+  nixosTests,
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "nixseparatedebuginfod2";
+  version = "0.1.0";
+
+  src = fetchFromGitHub {
+    owner = "symphorien";
+    repo = "nixseparatedebuginfod2";
+    tag = "v${version}";
+    hash = "sha256-bk+l/oWAPuWV6mnh9Pr/mru3BZjos08IfzEGUEFSW1E=";
+  };
+
+  cargoHash = "sha256-HmtFso6uF2GsjIA0FPVL4S3S+lwQUrg7N576UaekXpU=";
+
+  buildInputs = [
+    libarchive
+    openssl
+  ];
+
+  nativeBuildInputs = [ pkg-config ];
+
+  nativeCheckInputs = [
+    bubblewrap
+    elfutils
+    nix
+  ];
+
+  env.OPENSSL_NO_VENDOR = "1";
+
+  passthru.tests = { inherit (nixosTests) nixseparatedebuginfod2; };
+
+  meta = {
+    description = "Downloads and provides debug symbols and source code for nix derivations to gdb and other debuginfod-capable debuggers as needed";
+    homepage = "https://github.com/symphorien/nixseparatedebuginfod2";
+    license = lib.licenses.gpl3Only;
+    maintainers = [ lib.maintainers.symphorien ];
+    platforms = lib.platforms.linux;
+    mainProgram = "nixseparatedebuginfod2";
+  };
+}

pkgs/by-name/oh/oh-my-zsh/package.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  version = "2025-07-28";
+  version = "2025-08-08";
   pname = "oh-my-zsh";
 
   src = fetchFromGitHub {
     owner = "ohmyzsh";
     repo = "ohmyzsh";
-    rev = "5c804257ceb5b3062b876afae290adf72c474aad";
-    sha256 = "sha256-LSyabJIVuLdocx2fy5mVGFVX45gDxzm4hGDyF8yihZ4=";
+    rev = "9d8d4cf41482a95127ca41faecc0a7ee0781ca2e";
+    sha256 = "sha256-u98vvBhGYfvfYmo/J8hBc6bDui5HVlgM3hY32LwJGio=";
   };
 
   strictDeps = true;

pkgs/by-name/ol/olivetin/package.nix

···
       '';
 
       outputHashMode = "recursive";
-      outputHash = "sha256-4mmpiI2GhjMBp662/+DiM7SjEd1cPhF/A4YpyU04/Fs=";
+      outputHash = "sha256-o+Zt3rmTK7NmBQ9hDlbxZySUlCx6Ks7yQTtdm9+pJac=";
     };
 
     webui = buildNpmPackage {

pkgs/by-name/ol/ollama/package.nix

···
   cudaPackages,
   cudaArches ? cudaPackages.flags.realArches or [ ],
   autoAddDriverRunpath,
+  apple-sdk_15,
 
   # passthru
   nixosTests,
···
   ];
 
   buildInputs =
-    lib.optionals enableRocm (rocmLibs ++ [ libdrm ]) ++ lib.optionals enableCuda cudaLibs;
+    lib.optionals enableRocm (rocmLibs ++ [ libdrm ])
+    ++ lib.optionals enableCuda cudaLibs
+    ++ lib.optionals stdenv.hostPlatform.isDarwin [ apple-sdk_15 ];
 
   # replace inaccurate version number with actual release version
   postPatch = ''
···
     changelog = "https://github.com/ollama/ollama/releases/tag/v${finalAttrs.version}";
     license = licenses.mit;
     platforms = if (rocmRequested || cudaRequested) then platforms.linux else platforms.unix;
-    broken = stdenv.hostPlatform.isDarwin; # TODO: Remove after upstream issue is fixed, see issue #431464 and comments.
     mainProgram = "ollama";
     maintainers = with maintainers; [
       abysssol

pkgs/by-name/om/omnisharp-roslyn/deps.json

···
   },
   {
     "pname": "ICSharpCode.Decompiler",
-    "version": "8.2.0.7535",
-    "hash": "sha256-4BWs04Va9pc/SLeMA/vKoBydhw+Bu6s9MDtoo/Ucft8="
+    "version": "9.1.0.7988",
+    "hash": "sha256-zPLgLNO4cCrtN9BR9x6X+W0MNkQ71nADIopOC1VBhAQ="
   },
   {
     "pname": "McMaster.Extensions.CommandLineUtils",
···
     "pname": "Microsoft.Bcl.AsyncInterfaces",
     "version": "8.0.0",
     "hash": "sha256-9aWmiwMJKrKr9ohD1KSuol37y+jdDxPGJct3m2/Bknw="
+  },
+  {
+    "pname": "Microsoft.Bcl.AsyncInterfaces",
+    "version": "9.0.0",
+    "hash": "sha256-BsXNOWEgfFq3Yz7VTtK6m/ov4/erRqyBzieWSIpmc1U="
   },
   {
     "pname": "Microsoft.Build",
···
   },
   {
     "pname": "Microsoft.CodeAnalysis.Common",
-    "version": "4.13.0-3.24620.4",
-    "hash": "sha256-VSPRpTzEXnTNQAxXDOOi6YVS2C6/S2zTKgQR4aNkxME=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.common/4.13.0-3.24620.4/microsoft.codeanalysis.common.4.13.0-3.24620.4.nupkg"
+    "version": "4.14.0-3.25168.13",
+    "hash": "sha256-iQUNxmc2oGFqADDfNXj8A1O1nea6nxobBcYwBgqq8oY=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.common/4.14.0-3.25168.13/microsoft.codeanalysis.common.4.14.0-3.25168.13.nupkg"
   },
   {
     "pname": "Microsoft.CodeAnalysis.CSharp",
-    "version": "4.13.0-3.24620.4",
-    "hash": "sha256-YGxCN8J3BjSZ9hXYQF0nCL3Welv3UVASeSTkwwFPchc=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.csharp/4.13.0-3.24620.4/microsoft.codeanalysis.csharp.4.13.0-3.24620.4.nupkg"
+    "version": "4.14.0-3.25168.13",
+    "hash": "sha256-XicPFcDtJis8WS3nkMsxbmE+A20K9x6qE3EWeJEBjh8=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.csharp/4.14.0-3.25168.13/microsoft.codeanalysis.csharp.4.14.0-3.25168.13.nupkg"
   },
   {
     "pname": "Microsoft.CodeAnalysis.CSharp.Features",
-    "version": "4.13.0-3.24620.4",
-    "hash": "sha256-qpNsw5OtTAQFnN6g6tIh6+nsr+zc+/Na+oETR/GWxeM=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.csharp.features/4.13.0-3.24620.4/microsoft.codeanalysis.csharp.features.4.13.0-3.24620.4.nupkg"
+    "version": "4.14.0-3.25168.13",
+    "hash": "sha256-vI0G7XR92aVD6r5rYIEF+pZ+bpyznnfHVhQvWF3Eu4Q=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.csharp.features/4.14.0-3.25168.13/microsoft.codeanalysis.csharp.features.4.14.0-3.25168.13.nupkg"
   },
   {
     "pname": "Microsoft.CodeAnalysis.CSharp.Scripting",
-    "version": "4.13.0-3.24620.4",
-    "hash": "sha256-1D+TjiljZQQJEYIzhdLAbLq8DIvW30vgSDYnDlPoGoU=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.csharp.scripting/4.13.0-3.24620.4/microsoft.codeanalysis.csharp.scripting.4.13.0-3.24620.4.nupkg"
+    "version": "4.14.0-3.25168.13",
+    "hash": "sha256-zy8otm38p285W08GGy0M//1ZTOxiCxrC3tBcWKIg4Ps=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.csharp.scripting/4.14.0-3.25168.13/microsoft.codeanalysis.csharp.scripting.4.14.0-3.25168.13.nupkg"
   },
   {
     "pname": "Microsoft.CodeAnalysis.CSharp.Workspaces",
-    "version": "4.13.0-3.24620.4",
-    "hash": "sha256-NT7yDEq4fW8c71xHC3YPsP5vl8AZ9PdKASzxROwhccs=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.csharp.workspaces/4.13.0-3.24620.4/microsoft.codeanalysis.csharp.workspaces.4.13.0-3.24620.4.nupkg"
+    "version": "4.14.0-3.25168.13",
+    "hash": "sha256-wuttOafOufLuc1DFlp2r8zdfkOrD5eFRRN2/pt/MWtE=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.csharp.workspaces/4.14.0-3.25168.13/microsoft.codeanalysis.csharp.workspaces.4.14.0-3.25168.13.nupkg"
   },
   {
     "pname": "Microsoft.CodeAnalysis.Elfie",
···
   },
   {
     "pname": "Microsoft.CodeAnalysis.ExternalAccess.AspNetCore",
-    "version": "4.13.0-3.24620.4",
-    "hash": "sha256-91ZFqiu4MlteCir6p7YrOtbUMuRNIpNr6jX5qLdmZgM=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.externalaccess.aspnetcore/4.13.0-3.24620.4/microsoft.codeanalysis.externalaccess.aspnetcore.4.13.0-3.24620.4.nupkg"
+    "version": "4.14.0-3.25168.13",
+    "hash": "sha256-zhvnYOrXZvm0+YoVu1mG/X6IK9eIv+Fik9Y4cSBStdc=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.externalaccess.aspnetcore/4.14.0-3.25168.13/microsoft.codeanalysis.externalaccess.aspnetcore.4.14.0-3.25168.13.nupkg"
   },
   {
     "pname": "Microsoft.CodeAnalysis.ExternalAccess.OmniSharp",
-    "version": "4.13.0-3.24620.4",
-    "hash": "sha256-o2+DeY/p5AxMkMnYIiNMyMtrAnazzgfC6cVY8lImz4E=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.externalaccess.omnisharp/4.13.0-3.24620.4/microsoft.codeanalysis.externalaccess.omnisharp.4.13.0-3.24620.4.nupkg"
+    "version": "4.14.0-3.25168.13",
+    "hash": "sha256-MbPehGBs4q3zJ0gZf6Ab85IUBSyjRPO3nXfXxHus4v4=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.externalaccess.omnisharp/4.14.0-3.25168.13/microsoft.codeanalysis.externalaccess.omnisharp.4.14.0-3.25168.13.nupkg"
   },
   {
     "pname": "Microsoft.CodeAnalysis.ExternalAccess.OmniSharp.CSharp",
-    "version": "4.13.0-3.24620.4",
-    "hash": "sha256-LfIgqc7lDoyxbOsGmF4Ji488iXaT1f2ecjZz1662WlM=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.externalaccess.omnisharp.csharp/4.13.0-3.24620.4/microsoft.codeanalysis.externalaccess.omnisharp.csharp.4.13.0-3.24620.4.nupkg"
+    "version": "4.14.0-3.25168.13",
+    "hash": "sha256-Hpomx3SEqAFilwaA7yJV60iLXGpWSJAC+7XANxjIpng=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.externalaccess.omnisharp.csharp/4.14.0-3.25168.13/microsoft.codeanalysis.externalaccess.omnisharp.csharp.4.14.0-3.25168.13.nupkg"
   },
   {
     "pname": "Microsoft.CodeAnalysis.Features",
-    "version": "4.13.0-3.24620.4",
-    "hash": "sha256-ITkMz+1b9Q9I5UZk4N5+qKD7FPTBMohLDOqx3e2hShI=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.features/4.13.0-3.24620.4/microsoft.codeanalysis.features.4.13.0-3.24620.4.nupkg"
+    "version": "4.14.0-3.25168.13",
+    "hash": "sha256-GDrT8bMIzWy6O1MSTXcBIooKNnKDrR4Q5RJnyikRGRI=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.features/4.14.0-3.25168.13/microsoft.codeanalysis.features.4.14.0-3.25168.13.nupkg"
   },
   {
     "pname": "Microsoft.CodeAnalysis.Scripting.Common",
-    "version": "4.13.0-3.24620.4",
-    "hash": "sha256-9Pch1BIrhsEwoI3ahgQM4BQBhw1wH9d8X9WB6deM3Sk=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.scripting.common/4.13.0-3.24620.4/microsoft.codeanalysis.scripting.common.4.13.0-3.24620.4.nupkg"
+    "version": "4.14.0-3.25168.13",
+    "hash": "sha256-k2M3MfdbTG30PtcNHLHzVimaU8nKsv80XYt0DE6jZAI=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.scripting.common/4.14.0-3.25168.13/microsoft.codeanalysis.scripting.common.4.14.0-3.25168.13.nupkg"
   },
   {
     "pname": "Microsoft.CodeAnalysis.Workspaces.Common",
-    "version": "4.13.0-3.24620.4",
-    "hash": "sha256-Ex39ayopBTApxMCjevqn1qVFgjEvbst9sf7twW6+osI=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.workspaces.common/4.13.0-3.24620.4/microsoft.codeanalysis.workspaces.common.4.13.0-3.24620.4.nupkg"
+    "version": "4.14.0-3.25168.13",
+    "hash": "sha256-eKk8/Ezlnm+d2XFyfgY8HkyVxASvGisJoppswwqtew8=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/microsoft.codeanalysis.workspaces.common/4.14.0-3.25168.13/microsoft.codeanalysis.workspaces.common.4.14.0-3.25168.13.nupkg"
   },
   {
     "pname": "Microsoft.CSharp",
···
   },
   {
     "pname": "Microsoft.Extensions.Caching.Abstractions",
-    "version": "8.0.0",
-    "hash": "sha256-xGpKrywQvU1Wm/WolYIxgHYEFfgkNGeJ+GGc5DT3phI="
+    "version": "9.0.0",
+    "hash": "sha256-hDau5OMVGIg4sc5+ofe14ROqwt63T0NSbzm/Cv0pDrY="
   },
   {
     "pname": "Microsoft.Extensions.Caching.Memory",
-    "version": "8.0.1",
-    "hash": "sha256-5Q0vzHo3ZvGs4nPBc/XlBF4wAwYO8pxq6EGdYjjXZps="
+    "version": "9.0.0",
+    "hash": "sha256-OZVOVGZOyv9uk5XGJrz6irBkPNjxnBxjfSyW30MnU0s="
   },
   {
     "pname": "Microsoft.Extensions.Configuration",
-    "version": "8.0.0",
-    "hash": "sha256-9BPsASlxrV8ilmMCjdb3TiUcm5vFZxkBnAI/fNBSEyA="
+    "version": "9.0.0",
+    "hash": "sha256-uBLeb4z60y8z7NelHs9uT3cLD6wODkdwyfJm6/YZLDM="
   },
   {
     "pname": "Microsoft.Extensions.Configuration.Abstractions",
-    "version": "8.0.0",
-    "hash": "sha256-4eBpDkf7MJozTZnOwQvwcfgRKQGcNXe0K/kF+h5Rl8o="
+    "version": "9.0.0",
+    "hash": "sha256-xtG2USC9Qm0f2Nn6jkcklpyEDT3hcEZOxOwTc0ep7uc="
   },
   {
     "pname": "Microsoft.Extensions.Configuration.Binder",
-    "version": "8.0.0",
-    "hash": "sha256-GanfInGzzoN2bKeNwON8/Hnamr6l7RTpYLA49CNXD9Q="
+    "version": "9.0.0",
+    "hash": "sha256-6ajYWcNOQX2WqftgnoUmVtyvC1kkPOtTCif4AiKEffU="
   },
   {
     "pname": "Microsoft.Extensions.Configuration.CommandLine",
-    "version": "8.0.0",
-    "hash": "sha256-fmPC/o8S+weTtQJWykpnGHm6AKVU21xYE/CaHYU7zgg="
+    "version": "9.0.0",
+    "hash": "sha256-RE6DotU1FM1sy5p3hukT+WOFsDYJRsKX6jx5vhlPceM="
   },
   {
     "pname": "Microsoft.Extensions.Configuration.EnvironmentVariables",
-    "version": "8.0.0",
-    "hash": "sha256-+bjFZvqCsMf2FRM2olqx/fub+QwfM1kBhjGVOT5HC48="
+    "version": "9.0.0",
+    "hash": "sha256-tDJx2prYZpr0RKSwmJfsK9FlUGwaDmyuSz2kqQxsWoI="
   },
   {
     "pname": "Microsoft.Extensions.Configuration.FileExtensions",
-    "version": "8.0.0",
-    "hash": "sha256-BCxcjVP+kvrDDB0nzsFCJfU74UK4VBvct2JA4r+jNcs="
+    "version": "9.0.0",
+    "hash": "sha256-PsLo6mrLGYfbi96rfCG8YS1APXkUXBG4hLstpT60I4s="
   },
   {
     "pname": "Microsoft.Extensions.Configuration.Json",
-    "version": "8.0.0",
-    "hash": "sha256-Fi/ijcG5l0BOu7i96xHu96aN5/g7zO6SWQbTsI3Qetg="
+    "version": "9.0.0",
+    "hash": "sha256-qQn7Ol0CvPYuyecYWYBkPpTMdocO7I6n+jXQI2udzLI="
   },
   {
     "pname": "Microsoft.Extensions.DependencyInjection",
-    "version": "8.0.0",
-    "hash": "sha256-+qIDR8hRzreCHNEDtUcPfVHQdurzWPo/mqviCH78+EQ="
+    "version": "9.0.0",
+    "hash": "sha256-dAH52PPlTLn7X+1aI/7npdrDzMEFPMXRv4isV1a+14k="
   },
   {
     "pname": "Microsoft.Extensions.DependencyInjection.Abstractions",
···
   },
   {
     "pname": "Microsoft.Extensions.DependencyInjection.Abstractions",
-    "version": "8.0.2",
-    "hash": "sha256-UfLfEQAkXxDaVPC7foE/J3FVEXd31Pu6uQIhTic3JgY="
+    "version": "9.0.0",
+    "hash": "sha256-CncVwkKZ5CsIG2O0+OM9qXuYXh3p6UGyueTHSLDVL+c="
   },
   {
     "pname": "Microsoft.Extensions.DependencyModel",
-    "version": "8.0.0",
-    "hash": "sha256-qkCdwemqdZY/yIW5Xmh7Exv74XuE39T8aHGHCofoVgo="
+    "version": "9.0.0",
+    "hash": "sha256-xirwlMWM0hBqgTneQOGkZ8l45mHT08XuSSRIbprgq94="
   },
   {
     "pname": "Microsoft.Extensions.FileProviders.Abstractions",
-    "version": "8.0.0",
-    "hash": "sha256-uQSXmt47X2HGoVniavjLICbPtD2ReQOYQMgy3l0xuMU="
+    "version": "9.0.0",
+    "hash": "sha256-mVfLjZ8VrnOQR/uQjv74P2uEG+rgW72jfiGdSZhIfDc="
   },
   {
     "pname": "Microsoft.Extensions.FileProviders.Physical",
-    "version": "8.0.0",
-    "hash": "sha256-29y5ZRQ1ZgzVOxHktYxyiH40kVgm5un2yTGdvuSWnRc="
+    "version": "9.0.0",
+    "hash": "sha256-IzFpjKHmF1L3eVbFLUZa2N5aH3oJkJ7KE1duGIS7DP8="
   },
   {
     "pname": "Microsoft.Extensions.FileSystemGlobbing",
-    "version": "8.0.0",
-    "hash": "sha256-+Oz41JR5jdcJlCJOSpQIL5OMBNi+1Hl2d0JUHfES7sU="
+    "version": "9.0.0",
+    "hash": "sha256-eBLa8pW/y/hRj+JbEr340zbHRABIeFlcdqE0jf5/Uhc="
   },
   {
     "pname": "Microsoft.Extensions.Logging",
-    "version": "8.0.0",
-    "hash": "sha256-Meh0Z0X7KyOEG4l0RWBcuHHihcABcvCyfUXgasmQ91o="
+    "version": "9.0.0",
+    "hash": "sha256-kR16c+N8nQrWeYLajqnXPg7RiXjZMSFLnKLEs4VfjcM="
   },
   {
     "pname": "Microsoft.Extensions.Logging.Abstractions",
···
   },
   {
     "pname": "Microsoft.Extensions.Logging.Abstractions",
-    "version": "8.0.2",
-    "hash": "sha256-cHpe8X2BgYa5DzulZfq24rg8O2K5Lmq2OiLhoyAVgJc="
+    "version": "9.0.0",
+    "hash": "sha256-iBTs9twjWXFeERt4CErkIIcoJZU1jrd1RWCI8V5j7KU="
   },
   {
     "pname": "Microsoft.Extensions.Logging.Configuration",
-    "version": "8.0.0",
-    "hash": "sha256-mzmstNsVjKT0EtQcdAukGRifD30T82BMGYlSu8k4K7U="
+    "version": "9.0.0",
+    "hash": "sha256-ysPjBq64p6JM4EmeVndryXnhLWHYYszzlVpPxRWkUkw="
   },
   {
     "pname": "Microsoft.Extensions.Logging.Console",
-    "version": "8.0.0",
-    "hash": "sha256-bdb9YWWVn//AeySp7se87/tCN2E7e8Gx2GPMw28cd9c="
+    "version": "9.0.0",
+    "hash": "sha256-N2t9EUdlS6ippD4Z04qUUyBuQ4tKSR/8TpmKScb5zRw="
   },
   {
     "pname": "Microsoft.Extensions.Options",
-    "version": "8.0.2",
-    "hash": "sha256-AjcldddddtN/9aH9pg7ClEZycWtFHLi9IPe1GGhNQys="
+    "version": "9.0.0",
+    "hash": "sha256-DT5euAQY/ItB5LPI8WIp6Dnd0lSvBRP35vFkOXC68ck="
   },
   {
     "pname": "Microsoft.Extensions.Options.ConfigurationExtensions",
-    "version": "8.0.0",
-    "hash": "sha256-A5Bbzw1kiNkgirk5x8kyxwg9lLTcSngojeD+ocpG1RI="
+    "version": "9.0.0",
+    "hash": "sha256-r1Z3sEVSIjeH2UKj+KMj86har68g/zybSqoSjESBcoA="
   },
   {
     "pname": "Microsoft.Extensions.Primitives",
-    "version": "8.0.0",
-    "hash": "sha256-FU8qj3DR8bDdc1c+WeGZx/PCZeqqndweZM9epcpXjSo="
+    "version": "9.0.0",
+    "hash": "sha256-ZNLusK1CRuq5BZYZMDqaz04PIKScE2Z7sS2tehU7EJs="
   },
   {
     "pname": "Microsoft.IO.Redist",
···
   },
   {
     "pname": "NuGet.Common",
-    "version": "6.13.0-rc.95",
-    "hash": "sha256-SeN5m2Wuwux9kO+S5qX6bvvYUA22BOZDz6rg2Gk0vQc=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.common/6.13.0-rc.95/nuget.common.6.13.0-rc.95.nupkg"
+    "version": "6.14.0-rc.116",
+    "hash": "sha256-9iueLk2eBzA1Qph0zz2eM9hSfKtwdlApcEXkcImYHow=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.common/6.14.0-rc.116/nuget.common.6.14.0-rc.116.nupkg"
   },
   {
     "pname": "NuGet.Configuration",
-    "version": "6.13.0-rc.95",
-    "hash": "sha256-vrqUvp0Nse6zITKySrVgnPpkl2+ic8f0d/veYrUeRzM=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.configuration/6.13.0-rc.95/nuget.configuration.6.13.0-rc.95.nupkg"
+    "version": "6.14.0-rc.116",
+    "hash": "sha256-aZcINPKC6x773h/JW007YDPkj/jXZIBs/Y2gVp2jHKI=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.configuration/6.14.0-rc.116/nuget.configuration.6.14.0-rc.116.nupkg"
   },
   {
     "pname": "NuGet.DependencyResolver.Core",
-    "version": "6.13.0-rc.95",
-    "hash": "sha256-ttllWdeTVn3JJECrqfCy9lVZKX7DQbgxjKMIBZH3GoI=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.dependencyresolver.core/6.13.0-rc.95/nuget.dependencyresolver.core.6.13.0-rc.95.nupkg"
+    "version": "6.14.0-rc.116",
+    "hash": "sha256-xn3ftpNI3xMblSwqQcgYzhZ1fDj/urbnnCLZrTLuNNk=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.dependencyresolver.core/6.14.0-rc.116/nuget.dependencyresolver.core.6.14.0-rc.116.nupkg"
   },
   {
     "pname": "NuGet.Frameworks",
-    "version": "6.13.0-rc.95",
-    "hash": "sha256-Dq1YxucNDbrO8L2l8uV1SEOKuL4oVhUjlDeRLrg82Wo=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.frameworks/6.13.0-rc.95/nuget.frameworks.6.13.0-rc.95.nupkg"
+    "version": "6.14.0-rc.116",
+    "hash": "sha256-d9pZxwUrPcl/pizjC6j+Tns30muXUk2OVOAvkQ40TWk=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.frameworks/6.14.0-rc.116/nuget.frameworks.6.14.0-rc.116.nupkg"
   },
   {
     "pname": "NuGet.LibraryModel",
-    "version": "6.13.0-rc.95",
-    "hash": "sha256-zuiuiT6NprcW/UEhndi6vO4J3ONeIGkmRMjkDqdf4QQ=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.librarymodel/6.13.0-rc.95/nuget.librarymodel.6.13.0-rc.95.nupkg"
+    "version": "6.14.0-rc.116",
+    "hash": "sha256-8MzoYPA6p9pd0NkVW3oImhy1t3szqjk/dqHbRb2UM9I=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.librarymodel/6.14.0-rc.116/nuget.librarymodel.6.14.0-rc.116.nupkg"
   },
   {
     "pname": "NuGet.Packaging",
-    "version": "6.13.0-rc.95",
-    "hash": "sha256-gK0UtXawa2HtdYyug/vTihrj4ZLqCJ8w516kj9Gmq40=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.packaging/6.13.0-rc.95/nuget.packaging.6.13.0-rc.95.nupkg"
+    "version": "6.14.0-rc.116",
+    "hash": "sha256-0ck3KroeV+MSYBESHrqtZ7I4h10Wx5qfEYgikVk9lLE=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.packaging/6.14.0-rc.116/nuget.packaging.6.14.0-rc.116.nupkg"
   },
   {
     "pname": "NuGet.ProjectModel",
-    "version": "6.13.0-rc.95",
-    "hash": "sha256-Y+3CNqRfoCTzVYgVpJ8Q2kIQcZIbdfit6uVOuqFaMy0=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.projectmodel/6.13.0-rc.95/nuget.projectmodel.6.13.0-rc.95.nupkg"
+    "version": "6.14.0-rc.116",
+    "hash": "sha256-w8xv1eWnCgTEMd7UoZkoxcQ2fiOhPTf6AgkcY6XFiXs=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.projectmodel/6.14.0-rc.116/nuget.projectmodel.6.14.0-rc.116.nupkg"
   },
   {
     "pname": "NuGet.Protocol",
-    "version": "6.13.0-rc.95",
-    "hash": "sha256-HyzaY1PmpPGG6J8g+BYdS1ETYZMwahEu7OiyWyjXzu4=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.protocol/6.13.0-rc.95/nuget.protocol.6.13.0-rc.95.nupkg"
+    "version": "6.14.0-rc.116",
+    "hash": "sha256-vJH2Lp7eBq44+w6iDkgUItcy81qYG52E7NE5q10TJqc=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.protocol/6.14.0-rc.116/nuget.protocol.6.14.0-rc.116.nupkg"
   },
   {
     "pname": "NuGet.Versioning",
-    "version": "6.13.0-rc.95",
-    "hash": "sha256-2em8SYwrFR7wDjBpoSDs3Gfdz7w90IUs8vnGCnxcgF8=",
-    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.versioning/6.13.0-rc.95/nuget.versioning.6.13.0-rc.95.nupkg"
+    "version": "6.14.0-rc.116",
+    "hash": "sha256-qSpNg8NdQDTxS+xXkz5j/LJNqhF8jUn/bAQyJWFP9vA=",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/d1622942-d16f-48e5-bc83-96f4539e7601/nuget/v3/flat2/nuget.versioning/6.14.0-rc.116/nuget.versioning.6.14.0-rc.116.nupkg"
   },
   {
     "pname": "OmniSharp.Extensions.JsonRpc",
···
   },
   {
     "pname": "System.Collections.Immutable",
-    "version": "8.0.0",
-    "hash": "sha256-F7OVjKNwpqbUh8lTidbqJWYi476nsq9n+6k0+QVRo3w="
+    "version": "9.0.0",
+    "hash": "sha256-+6q5VMeoc5bm4WFsoV6nBXA9dV5pa/O4yW+gOdi8yac="
   },
   {
     "pname": "System.ComponentModel.Annotations",
···
   },
   {
     "pname": "System.ComponentModel.Composition",
-    "version": "8.0.0",
-    "hash": "sha256-MnKdjE/qIvAmEeRc3gOn5uJhT0TI3UnUJPjj3TLHFQo="
+    "version": "9.0.0",
+    "hash": "sha256-CsWwo/NLEAt36kE52cT4wud8uUjJ31vpHlAY6RkUbog="
   },
   {
     "pname": "System.Composition",
-    "version": "8.0.0",
-    "hash": "sha256-rA118MFj6soKN++BvD3y9gXAJf0lZJAtGARuznG5+Xg="
+    "version": "9.0.0",
+    "hash": "sha256-FehOkQ2u1p8mQ0/wn3cZ+24HjhTLdck8VZYWA1CcgbM="
   },
   {
     "pname": "System.Composition.AttributedModel",
-    "version": "8.0.0",
-    "hash": "sha256-n3aXiBAFIlQicSRLiNtLh++URSUxRBLggsjJ8OMNRpo="
+    "version": "9.0.0",
+    "hash": "sha256-a7y7H6zj+kmYkllNHA402DoVfY9IaqC3Ooys8Vzl24M="
   },
   {
     "pname": "System.Composition.Convention",
-    "version": "8.0.0",
-    "hash": "sha256-Z9HOAnH1lt1qc38P3Y0qCf5gwBwiLXQD994okcy53IE="
+    "version": "9.0.0",
+    "hash": "sha256-tw4vE5JRQ60ubTZBbxoMPhtjOQCC3XoDFUH7NHO7o8U="
   },
   {
     "pname": "System.Composition.Hosting",
-    "version": "8.0.0",
-    "hash": "sha256-axKJC71oKiNWKy66TVF/c3yoC81k03XHAWab3mGNbr0="
+    "version": "9.0.0",
+    "hash": "sha256-oOxU+DPEEfMCuNLgW6wSkZp0JY5gYt44FJNnWt+967s="
   },
   {
     "pname": "System.Composition.Runtime",
-    "version": "8.0.0",
-    "hash": "sha256-AxwZ29+GY0E35Pa255q8AcMnJU52Txr5pBy86t6V1Go="
+    "version": "9.0.0",
+    "hash": "sha256-AyIe+di1TqwUBbSJ/sJ8Q8tzsnTN+VBdJw4K8xZz43s="
   },
   {
     "pname": "System.Composition.TypedParts",
-    "version": "8.0.0",
-    "hash": "sha256-+ZJawThmiYEUNJ+cB9uJK+u/sCAVZarGd5ShZoSifGo="
+    "version": "9.0.0",
+    "hash": "sha256-F5fpTUs3Rr7yP/NyIzr+Xn5NdTXXp8rrjBnF9UBBUog="
   },
   {
     "pname": "System.Configuration.ConfigurationManager",
-    "version": "8.0.0",
-    "hash": "sha256-xhljqSkNQk8DMkEOBSYnn9lzCSEDDq4yO910itptqiE="
+    "version": "9.0.0",
+    "hash": "sha256-+pLnTC0YDP6Kjw5DVBiFrV/Q3x5is/+6N6vAtjvhVWk="
   },
   {
     "pname": "System.Data.DataSetExtensions",
···
   },
   {
     "pname": "System.Diagnostics.DiagnosticSource",
-    "version": "8.0.0",
-    "hash": "sha256-+aODaDEQMqla5RYZeq0Lh66j+xkPYxykrVvSCmJQ+Vs="
-  },
-  {
-    "pname": "System.Diagnostics.DiagnosticSource",
-    "version": "8.0.1",
-    "hash": "sha256-zmwHjcJgKcbkkwepH038QhcnsWMJcHys+PEbFGC0Jgo="
+    "version": "9.0.0",
+    "hash": "sha256-1VzO9i8Uq2KlTw1wnCCrEdABPZuB2JBD5gBsMTFTSvE="
   },
   {
     "pname": "System.Diagnostics.EventLog",
-    "version": "8.0.0",
-    "hash": "sha256-rt8xc3kddpQY4HEdghlBeOK4gdw5yIj4mcZhAVtk2/Y="
+    "version": "9.0.0",
+    "hash": "sha256-tPvt6yoAp56sK/fe+/ei8M65eavY2UUhRnbrREj/Ems="
   },
   {
     "pname": "System.Drawing.Common",
···
   },
   {
     "pname": "System.IO.Pipelines",
-    "version": "8.0.0",
-    "hash": "sha256-LdpB1s4vQzsOODaxiKstLks57X9DTD5D6cPx8DE1wwE="
+    "version": "9.0.0",
+    "hash": "sha256-vb0NrPjfEao3kfZ0tavp2J/29XnsQTJgXv3/qaAwwz0="
   },
   {
     "pname": "System.Memory",
···
   },
   {
     "pname": "System.Reflection.Metadata",
-    "version": "8.0.0",
-    "hash": "sha256-dQGC30JauIDWNWXMrSNOJncVa1umR1sijazYwUDdSIE="
+    "version": "9.0.0",
+    "hash": "sha256-avEWbcCh7XgpsSesnR3/SgxWi/6C5OxjR89Jf/SfRjQ="
   },
   {
     "pname": "System.Reflection.MetadataLoadContext",
···
   },
   {
     "pname": "System.Security.Cryptography.ProtectedData",
-    "version": "8.0.0",
-    "hash": "sha256-fb0pa9sQxN+mr0vnXg1Igbx49CaOqS+GDkTfWNboUvs="
+    "version": "9.0.0",
+    "hash": "sha256-gPgPU7k/InTqmXoRzQfUMEKL3QuTnOKowFqmXTnWaBQ="
   },
   {
     "pname": "System.Security.Cryptography.Xml",
···
   },
   {
     "pname": "System.Text.Encodings.Web",
-    "version": "8.0.0",
-    "hash": "sha256-IUQkQkV9po1LC0QsqrilqwNzPvnc+4eVvq+hCvq8fvE="
+    "version": "9.0.0",
+    "hash": "sha256-WGaUklQEJywoGR2jtCEs5bxdvYu5SHaQchd6s4RE5x0="
   },
   {
     "pname": "System.Text.Json",
-    "version": "8.0.5",
-    "hash": "sha256-yKxo54w5odWT6nPruUVsaX53oPRe+gKzGvLnnxtwP68="
+    "version": "9.0.0",
+    "hash": "sha256-aM5Dh4okLnDv940zmoFAzRmqZre83uQBtGOImJpoIqk="
   },
   {
     "pname": "System.Threading.Channels",
···
   },
   {
     "pname": "System.Threading.Tasks.Dataflow",
-    "version": "8.0.0",
-    "hash": "sha256-Q6fPtMPNW4+SDKCabJzNS+dw4B04Oxd9sHH505bFtQo="
+    "version": "9.0.0",
+    "hash": "sha256-nRzcFvLBpcOfyIJdCCZq5vDKZN0xHVuB8yCXoMrwZJA="
   },
   {
     "pname": "System.Threading.Tasks.Extensions",

pkgs/by-name/om/omnisharp-roslyn/package.nix

···
 let
   finalPackage = buildDotnetModule rec {
     pname = "omnisharp-roslyn";
-    version = "1.39.13";
+    version = "1.39.14";
 
     src = fetchFromGitHub {
       owner = "OmniSharp";
       repo = "omnisharp-roslyn";
       tag = "v${version}";
-      hash = "sha256-/U7zpx0jAnvZl7tshGV7wORD/wQUKYgX1kADpyCXHM4=";
+      hash = "sha256-yWrb+Ov1syKjeer7CxmGzkf9qUJxQ0IoIRfyIiO8eI8=";
     };
 
     projectFile = "src/OmniSharp.Stdio.Driver/OmniSharp.Stdio.Driver.csproj";

pkgs/by-name/op/openhue-cli/package.nix

···
 
 buildGoModule (finalAttrs: {
   pname = "openhue-cli";
-  version = "0.18";
+  version = "0.20";
 
   src = fetchFromGitHub {
     owner = "openhue";
     repo = "openhue-cli";
     tag = finalAttrs.version;
-    hash = "sha256-LSaHE3gdjpNea6o+D/JGvHtwvG13LbHv2pDcZhlIoEE=";
+    hash = "sha256-vUmJjuBcOjIhhtWrzq+y0fDlh+wQhgBwxnfuod27CBA=";
     leaveDotGit = true;
     postFetch = ''
       cd "$out"
···
     '';
   };
 
-  vendorHash = "sha256-lqIzmtFtkfrJSrpic79Is0yGpnLUysPQLn2lp/Mh+u4=";
+  vendorHash = "sha256-DhTe0fSWoAwzoGr8rZMsbSE92jJFr4T7aVx/ULMfVFo=";
 
   env.CGO_ENABLED = 0;
 

pkgs/by-name/op/openxr-loader/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "openxr-loader";
-  version = "1.1.49";
+  version = "1.1.50";
 
   src = fetchFromGitHub {
     owner = "KhronosGroup";
     repo = "OpenXR-SDK-Source";
     tag = "release-${version}";
-    hash = "sha256-fQmS8oJZ7Oy/miKCtOQGSvZFDIEMFOcUyz2D6P8hNZY=";
+    hash = "sha256-/5zw9tj7F0cxhzyIRf8njoYB9moJFYLEjDeqe0OBr34=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/pa/particle-cli/package.nix

···
 
 buildNpmPackage (finalAttrs: {
   pname = "particle-cli";
-  version = "3.40.0";
+  version = "3.40.1";
 
   src = fetchFromGitHub {
     owner = "particle-iot";
     repo = "particle-cli";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-qfwj0hs+4p00pALrIMAjHCM7Cdoj6+sxV/nMyI2rYNg=";
+    hash = "sha256-rbCk54bTDwvbpRMUR9bUNLTuIHw3HnKoJE7euXMujxg=";
   };
 
-  npmDepsHash = "sha256-o8G6+xYOg80vgjJ6Skm7ydysuH71uN9erj7Nd4QOB2I=";
+  npmDepsHash = "sha256-gvnjrFTx1N/dIYSWHjj+PGxiVyiP3pdcDjPIix48cAI=";
 
   buildInputs = [
     udev

pkgs/by-name/pa/payme/package.nix

···
 
 buildGoModule rec {
   pname = "payme";
-  version = "1.2.3";
+  version = "1.2.4";
 
   src = fetchFromGitHub {
     owner = "jovandeginste";
     repo = "payme";
     rev = "v${version}";
-    hash = "sha256-jkJGR6i68kNzA60T5ZOu2u+fPvZht4ssEtr8aYocGUk=";
+    hash = "sha256-GXJjjCruDjL5+ag3aUJAHPLOvbwux9FBnyqXJ52WifE=";
     leaveDotGit = true;
     postFetch = ''
       cd "$out"

pkgs/by-name/pe/petsc/package.nix

···
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "petsc";
-  version = "3.23.4";
+  version = "3.23.5";
 
   src = fetchzip {
     url = "https://web.cels.anl.gov/projects/petsc/download/release-snapshots/petsc-${finalAttrs.version}.tar.gz";
-    hash = "sha256-7UugWo3SzRap3Ed6NySRZOJgD+Wkb9J+QEGRUfLbOPI=";
+    hash = "sha256-pfGb/9GlKsZJpdEU6lOr61a8AE5NR9MlZ0mHJ/j+eDs=";
   };
 
   strictDeps = true;

pkgs/by-name/pi/pistol/package.nix

···
 
 buildGoModule rec {
   pname = "pistol";
-  version = "0.5.2";
+  version = "0.5.3";
 
   src = fetchFromGitHub {
     owner = "doronbehar";
     repo = "pistol";
     rev = "v${version}";
-    sha256 = "sha256-/w2BenBIzhD0KHtELlFy7YGv0lykHrjrROZeW75gHis=";
+    sha256 = "sha256-cL9hHehajqMIpdD10KYIbNkBt2fiRQkx81m9H3Yd1UY=";
   };
 
-  vendorHash = "sha256-+Q72DUKLqahgbLCaXOTAYZaMvNfv3XF+SpyqHyB065g=";
+  vendorHash = "sha256-+moQ3qZnWmmGpOXUxyBS3hIETK/ZtRwmvD2tXFf0A3o=";
 
   doCheck = false;
 

pkgs/by-name/po/pocketbase/package.nix

···
 
 buildGoModule rec {
   pname = "pocketbase";
-  version = "0.29.0";
+  version = "0.29.2";
 
   src = fetchFromGitHub {
     owner = "pocketbase";
     repo = "pocketbase";
     rev = "v${version}";
-    hash = "sha256-yNz/bwjOPcj4N4yXi1pckz/rGNSJeCs8xeZHj+W/+2E=";
+    hash = "sha256-TWizSLWsQEK2BGaYVkqc/rrjiv/MZF0kKZAYGQAItJ4=";
   };
 
-  vendorHash = "sha256-XfHU2E2VEcQEQtcGmZqEPjdy7wxvOEdcysSYYD5oLNM=";
+  vendorHash = "sha256-MWCx8v1/A0xjm8M9zgPXkMYsQlpAqDaASoqFTr7FG18=";
 
   # This is the released subpackage from upstream repo
   subPackages = [ "examples/base" ];

pkgs/by-name/po/powerstation/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "powerstation";
-  version = "0.6.1";
+  version = "0.7.0";
 
   src = fetchFromGitHub {
     owner = "ShadowBlip";
     repo = "PowerStation";
     tag = "v${version}";
-    hash = "sha256-UB0NmP2UaQEYGrFR0f0nBLuGTjjTIhvz0bwx3eC2JE4=";
+    hash = "sha256-wm/O36AdBxfLVCM3NtzSVVHBM+GfH4ARZ/2ekJX5qsE=";
   };
 
-  cargoHash = "sha256-32tz1cJ2G3GXB9j0lFyjsAOn/iQGxzrdfcqkA/Yh4UY=";
+  cargoHash = "sha256-P4NTzKKY/yB8ODPlsGWfihXTQD8MiOnp+tKCWFKtKxI=";
 
   nativeBuildInputs = [
     cmake

pkgs/by-name/qw/qwen-code/package.nix

···
+{
+  lib,
+  buildNpmPackage,
+  fetchFromGitHub,
+  fetchNpmDeps,
+  nix-update-script,
+}:
+
+buildNpmPackage (finalAttrs: {
+  pname = "qwen-code";
+  version = "0.0.5";
+
+  src = fetchFromGitHub {
+    owner = "QwenLM";
+    repo = "qwen-code";
+    tag = "v${finalAttrs.version}";
+    hash = "sha256-/PuykGiXpjk2Fp1Sif59hvOIepZ7KcJRvL/9RMatQJA=";
+  };
+
+  npmDeps = fetchNpmDeps {
+    inherit (finalAttrs) src;
+    hash = "sha256-HzrN549MfI+TN7BKssisIsga7udGKvextruzuoLq8M4=";
+  };
+
+  buildPhase = ''
+    runHook preBuild
+
+    npm run generate
+    npm run bundle
+
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p $out/bin
+    cp -r bundle/* $out/
+    patchShebangs $out
+    ln -s $out/gemini.js $out/bin/qwen
+
+    runHook postInstall
+  '';
+
+  passthru.updateScript = nix-update-script { };
+
+  meta = {
+    description = "Coding agent that lives in digital world";
+    homepage = "https://github.com/QwenLM/qwen-code";
+    mainProgram = "qwen";
+    license = lib.licenses.asl20;
+    platforms = lib.platforms.all;
+    maintainers = with lib.maintainers; [ lonerOrz ];
+  };
+})

pkgs/by-name/ri/rime-moegirl/package.nix

···
 }:
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "rime-moegirl";
-  version = "20250711";
+  version = "20250810";
   src = fetchurl {
     url = "https://github.com/outloudvi/mw2fcitx/releases/download/${finalAttrs.version}/moegirl.dict.yaml";
-    hash = "sha256-gs/JhdSeLFkBKvBdVRxk3RhqlkOhly18w4Pz63GG814=";
+    hash = "sha256-/Yv/2kigtpNvnWlHYTJBMUlMV5i5toteaLiDJ0kDoZg=";
   };
 
   dontUnpack = true;

pkgs/by-name/ru/rustical/package.nix

···
 
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "rustical";
-  version = "0.8.1";
+  version = "0.8.4";
 
   src = fetchFromGitHub {
     owner = "lennart-k";
     repo = "rustical";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-TkgkgPQEj0SA9MjfWtOUu6rHKYCIs5jVieYL1N+XLk8=";
+    hash = "sha256-y4t63lb14WdUjzhjv/mx90ThaTfE7KFyRkg+CG+66TE=";
   };
 
-  cargoHash = "sha256-X+8G2H3wszKJmn7p8n0b6z3xZ/ylGzwc99oUnIGKpTA=";
+  cargoHash = "sha256-DK3es0GjKurCwGmr/6gAk+ccJc1dUP64kK+UzvS+Mi0=";
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ openssl ];

pkgs/by-name/sd/sdl_gamecontrollerdb/package.nix

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "sdl_gamecontrollerdb";
-  version = "0-unstable-2025-07-28";
+  version = "0-unstable-2025-08-05";
 
   src = fetchFromGitHub {
     owner = "mdqinc";
     repo = "SDL_GameControllerDB";
-    rev = "34765aa1de21323a873ab107a2a25e269e86b2e8";
-    hash = "sha256-K3XeSs6psR8RnDiYAKrVbx3KWQuJcD3RyZpOl+dn5Qw=";
+    rev = "7543fc8af09232396f7d57e19c2342965c53e94f";
+    hash = "sha256-y5QyrgT/ipal36jTJurvXMac6uRMt3XOg3Sm6SLe0sk=";
   };
 
   dontBuild = true;

pkgs/by-name/sh/shadowenv/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "shadowenv";
-  version = "3.3.1";
+  version = "3.4.0";
 
   src = fetchFromGitHub {
     owner = "Shopify";
     repo = "shadowenv";
     rev = version;
-    hash = "sha256-s70tNeF0FnWYZ0xLGIL1lTM0LwJdhPPIHrNgrY1YNBs=";
+    hash = "sha256-WsUeqkuT4NhoaCJG1hqz+uWyvWQBfxtDheEkWkYmSWU=";
   };
 
-  cargoHash = "sha256-Cg01yM3FbrYpZrv2dhGJnezugNhcuwDcXIU47/AWrC4=";
+  cargoHash = "sha256-vAMap35rpmEKSHJ9yW/PzPbEWtLw30DawDmI+QfcOsw=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/by-name/sn/snyk/package.nix

···
 }:
 
 let
-  version = "1.1298.1";
+  version = "1.1298.2";
 in
 buildNpmPackage {
   pname = "snyk";
···
     owner = "snyk";
     repo = "cli";
     tag = "v${version}";
-    hash = "sha256-oLkzEm7OMBNqT+EDrwujqQek4LWwKgYFUoMRWhpqY4o=";
+    hash = "sha256-8VnbXxvz5mWWMq6sjffshMbHBf2H6s/xmPbQZsZC/4A=";
   };
 
   npmDepsHash = "sha256-7fHehEKjNNRdRk9+kARzn75G0r1pse7ULn/Oz6mQRKM=";

pkgs/by-name/st/st/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "st";
-  version = "0.9.2";
+  version = "0.9.3";
 
   src = fetchzip {
     url = "https://dl.suckless.org/st/st-${finalAttrs.version}.tar.gz";
-    hash = "sha256-pFyK4XvV5Z4gBja8J996zF6wkdgQCNVccqUJ5+ejB/w=";
+    hash = "sha256-Xr1JtaOMVgn+zsD39LFjP/0dkYkvaAXbEcYb3ptgYLA=";
   };
 
   outputs = [

pkgs/by-name/st/stackit-cli/package.nix

···
 
 buildGoModule rec {
   pname = "stackit-cli";
-  version = "0.37.3";
+  version = "0.38.0";
 
   src = fetchFromGitHub {
     owner = "stackitcloud";
     repo = "stackit-cli";
     rev = "v${version}";
-    hash = "sha256-nyNASYpZvao194rlKSyxNa74Ezo5CwiESNj54uBgUL4=";
+    hash = "sha256-i6UOgD3C0nq6Z3Gdki8YOZotU1CbC14Jx8d9B1LV7Hk=";
   };
 
-  vendorHash = "sha256-iWGRFjCvXm03GRnmQlscP5Y5di9W4lW3jotyhDcE/x4=";
+  vendorHash = "sha256-qzNd1wn3N+EPjXO1gFYKtVNdGwd2D/jf6oJFvloR7HY=";
 
   subPackages = [ "." ];
 

pkgs/by-name/st/step-kms-plugin/package.nix

···
 
 buildGoModule rec {
   pname = "step-kms-plugin";
-  version = "0.14.0";
+  version = "0.14.2";
 
   src = fetchFromGitHub {
     owner = "smallstep";
     repo = "step-kms-plugin";
     rev = "v${version}";
-    hash = "sha256-GP4ztKTkHIxBCK9Wx9oT8jehIFYCj3lnAt+RGgTMpHo=";
+    hash = "sha256-0RIAwZbk6DNlJHTmxUd/td94OlrjwcQ86ao7wt7PSdg=";
   };
 
-  vendorHash = "sha256-beRLkYLAe3wx0CmCXcn5flWeg+qOK1JPYjAD/bhPkTc=";
+  vendorHash = "sha256-YvK3icanE8FoTeACfReVXmV143lcRTyXv8L6+hoFIaM=";
 
   proxyVendor = true;
 

pkgs/by-name/sy/syft/package.nix

···
 
 buildGoModule rec {
   pname = "syft";
-  version = "1.29.1";
+  version = "1.30.0";
 
   src = fetchFromGitHub {
     owner = "anchore";
     repo = "syft";
     tag = "v${version}";
-    hash = "sha256-X+7X71M7nJKEAvAm0L9hh/zamJTGb+OyYNFWfiYlyew=";
+    hash = "sha256-7YnjkevF4Nmu8YDhpd/WqXzLM8cdVPDt5ss9bg8udow=";
     # populate values that require us to use git. By doing this in postFetch we
     # can delete .git afterwards and maintain better reproducibility of the src.
     leaveDotGit = true;
···
   # hash mismatch with darwin
   proxyVendor = true;
 
-  vendorHash = "sha256-xgjnPTeSB+AWFLfXYLW3bveJowVje81lVvO30ZiCLxI=";
+  vendorHash = "sha256-ydXEquE12om67jouEHN5/MPI9+i69OALIQcPHRBD/YA=";
 
   nativeBuildInputs = [ installShellFiles ];
 

pkgs/by-name/ta/tauno-monitor/package.nix

···
 }:
 python3Packages.buildPythonApplication rec {
   pname = "tauno-monitor";
-  version = "0.2.11";
+  version = "0.2.14";
   pyproject = false;
 
   src = fetchFromGitHub {
     owner = "taunoe";
     repo = "tauno-monitor";
     tag = "v${version}";
-    hash = "sha256-FoNn+A0zqFf/Nl0MrK9/X5mwaq8mJBRH0uGnemDC0is=";
+    hash = "sha256-1jXQZc2+Yufjo75KwHbAFPsGxdpxkdUP8LXyY2fj3Kw=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/ta/tayga/package.nix

···
 {
   lib,
   stdenv,
-  fetchurl,
+  fetchFromGitHub,
   nixosTests,
 }:
 
 stdenv.mkDerivation (finalAttrs: {
-  version = "0.9.2";
+  version = "0.9.5";
   pname = "tayga";
 
-  src = fetchurl {
-    url = "http://www.litech.org/tayga/tayga-${finalAttrs.version}.tar.bz2";
-    hash = "sha256-Kx95J6nS3P+Qla/zwnGSSwUsz9L6ypWIsndDGkTwAJw=";
+  src = fetchFromGitHub {
+    owner = "apalrd";
+    repo = "tayga";
+    tag = finalAttrs.version;
+    hash = "sha256-xOm4fetFq2UGuhOojrT8WOcX78c6MLTMVbDv+O62x2E=";
   };
 
-  env.NIX_CFLAGS_COMPILE = toString [
-    "-Wno-address-of-packed-member"
-    "-Wno-implicit-function-declaration"
-  ];
+  preBuild = ''
+    echo "#define TAYGA_VERSION \"${finalAttrs.version}\"" > version.h
+  '';
+
+  installPhase = ''
+    install -Dm755 tayga $out/bin/tayga
+    install -D tayga.conf.5 $out/share/man/man5/tayga.conf.5
+    install -D tayga.8 $out/share/man/man8/tayga.8
+    cp -R docs $out/share/
+    cp tayga.conf.example $out/share/docs/
+  '';
 
   passthru.tests.tayga = nixosTests.tayga;
 
···
       It is intended to provide production-quality NAT64 service
       for networks where dedicated NAT64 hardware would be overkill.
     '';
-    homepage = "http://www.litech.org/tayga";
+    homepage = "https://github.com/apalrd/tayga";
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ _0x4A6F ];
     platforms = platforms.linux;

pkgs/by-name/tf/tfupdate/package.nix

···
 
 buildGoModule rec {
   pname = "tfupdate";
-  version = "0.9.1";
+  version = "0.9.2";
 
   src = fetchFromGitHub {
     owner = "minamijoyo";
     repo = "tfupdate";
     rev = "v${version}";
-    sha256 = "sha256-hxg/hAfUjygBgkfql2ZpiskKPqwVmo2MZ4n9eod5Kn4=";
+    sha256 = "sha256-izxvvR/wVNQlDWxJhUSAq2q0U0Y7fcFflEZRS2sfEIY=";
   };
 
-  vendorHash = "sha256-dWp9onewCiemk3AUTgiaVwnLuVVMMTk/6hCWDS5NS88=";
+  vendorHash = "sha256-gmIh1xlOXLASzY9E5phS48Bdj1agH5LdUUW0p/g4I5w=";
 
   # Tests start http servers which need to bind to local addresses:
   # panic: httptest: failed to listen on a port: listen tcp6 [::1]:0: bind: operation not permitted

pkgs/by-name/va/vacuum-go/package.nix

···
 
 buildGoModule (finalAttrs: {
   pname = "vacuum-go";
-  version = "0.17.7";
+  version = "0.17.8";
 
   src = fetchFromGitHub {
     owner = "daveshanley";
     repo = "vacuum";
     # using refs/tags because simple version gives: 'the given path has multiple possibilities' error
     tag = "v${finalAttrs.version}";
-    hash = "sha256-RkJOBiannG98bqc3GdBzRGvDATjX0gtgn8PCdIIBdBc=";
+    hash = "sha256-Vrvb4xLY7vxTaAlaPScBKmLfOgOzxGHpt4GJu8DnwUg=";
   };
 
-  vendorHash = "sha256-6tBKlJa7fec0jc7/s1A6h86SwlZR7HzGes7hPEuwNmo=";
+  vendorHash = "sha256-IOlJHVzmBR4Re3VxAwLjpws3DTJSzG8JBya6L3WTeoQ=";
 
   env.CGO_ENABLED = 0;
   ldflags = [

pkgs/by-name/va/valkey/package.nix

···
     sed -i '/^proc wait_load_handlers_disconnected/{n ; s/wait_for_condition 50 100/wait_for_condition 50 500/; }' \
       tests/support/util.tcl
 
+    CLIENTS="$NIX_BUILD_CORES"
+    if (( $CLIENTS > 4)); then
+      CLIENTS=4
+    fi
+
     # Skip some more flaky tests.
     # Skip test requiring custom jemalloc (unit/memefficiency).
     ./runtest \
       --no-latency \
       --timeout 2000 \
-      --clients $NIX_BUILD_CORES \
+      --clients "$CLIENTS" \
       --tags -leaks \
       --skipunit unit/memefficiency \
       --skipunit integration/failover \

pkgs/by-name/ve/velocity/deps.json

···
    "module": "sha256-eYp7cGdyE27iijLt2GOx6fgWE6NJhAXXS+ilyb6/9U8=",
    "pom": "sha256-20U7urXn2opDE5sNzTuuZykzIfKcTZH1p5XZ/2xS3d8="
   },
+  "io/papermc#fill-gradle/1.0.3": {
+   "jar": "sha256-i0s+vAeA1bKfvpdqqwSx7RfW8nUt+91hgOLaTAkPHok=",
+   "module": "sha256-RyHV6clYb0y/g1pDAdYF8p+v1ycn6pPhcHueG2vEjJ4=",
+   "pom": "sha256-iQridlDWW/I2j8S0pp2rQKSqLsX6mtRKh+8enBJd5JA="
+  },
+  "io/papermc/fill/gradle#io.papermc.fill.gradle.gradle.plugin/1.0.3": {
+   "pom": "sha256-mY28yKdtdiKCQgolhRc+El30dd3ROKN1PSNk70wA/BM="
+  },
+  "net/kyori#indra-git/3.1.3": {
+   "jar": "sha256-Yj3GYLWoSQJgP1Ww4EnCX9w8Z3SckQWKEGOWPcYFae0=",
+   "module": "sha256-V9JC+gioSOG2JGEvV/+6qY9p9d8DA9LBj3vbGpAyikU=",
+   "pom": "sha256-Zp9TPudkCyfovE9RPkohPaBBz1wcJhVTx/GD1Qu21Jc="
+  },
   "org/apache#apache/29": {
    "pom": "sha256-PkkDcXSCC70N9jQgqXclWIY5iVTCoGKR+mH3J6w1s3c="
   },
···
   "com/fasterxml#oss-parent/50": {
    "pom": "sha256-9dpV3XuI+xcMRoAdF3dKZS+y9FgftbHQpfyGqhgrhXc="
   },
-  "com/fasterxml#oss-parent/56": {
-   "pom": "sha256-/UkfeIV0JBBtLj1gW815m1PTGlZc3IaEY8p+h120WlA="
-  },
   "com/fasterxml#oss-parent/58": {
    "pom": "sha256-VnDmrBxN3MnUE8+HmXpdou+qTSq+Q5Njr57xAqCgnkA="
   },
-  "com/fasterxml/jackson#jackson-bom/2.16.0": {
-   "pom": "sha256-Wqooh0QFvwT7qOLFcVkieCRGG6b31VKr246NOgum+L8="
+  "com/fasterxml#oss-parent/61": {
+   "pom": "sha256-NklRPPWX6RhtoIVZhqjFQ+Er29gF7e75wSTbVt0DZUQ="
+  },
+  "com/fasterxml/jackson#jackson-base/2.18.1": {
+   "pom": "sha256-m612py37mq3jx6MzQ3dUk4bbqlTCFeRYOiUEyIp81K8="
   },
   "com/fasterxml/jackson#jackson-bom/2.17.2": {
    "pom": "sha256-H0crC8IATVz0IaxIhxQX+EGJ5481wElxg4f9i0T7nzI="
   },
-  "com/fasterxml/jackson#jackson-parent/2.16": {
-   "pom": "sha256-i/YUKBIUiiq/aFCycvCvTD2P8RIe1gTEAvPzjJ5lRqs="
+  "com/fasterxml/jackson#jackson-bom/2.18.1": {
+   "pom": "sha256-84SrzK8Mb712GDdi9yVv1nkBLtgdt/KiZofouWWgFKc="
   },
   "com/fasterxml/jackson#jackson-parent/2.17": {
    "pom": "sha256-rubeSpcoOwQOQ/Ta1XXnt0eWzZhNiSdvfsdWc4DIop0="
   },
+  "com/fasterxml/jackson#jackson-parent/2.18.1": {
+   "pom": "sha256-0IIvrBoCJoRLitRFySDEmk9hkWnQmxAQp9/u0ZkQmYw="
+  },
+  "com/fasterxml/jackson/core#jackson-annotations/2.18.1": {
+   "jar": "sha256-t/nfXayahfR/2ydpRV7oupzy/pt8TPY24K7INHnXiC8=",
+   "module": "sha256-DFBMd03V5mzpWoFiUnsAvNGR0e6S2kKPFhL5n3NMqYw=",
+   "pom": "sha256-dRNr4/Jizrf75rkHuPJujGKMM+G1SSINS36CvdHQ5EY="
+  },
+  "com/fasterxml/jackson/core#jackson-core/2.18.1": {
+   "jar": "sha256-6+GVlq0Z96BRTIu497Cs+FI5pO/1rgMinpdg0mjSnCI=",
+   "module": "sha256-VHp3eJ1Ej1IoV37sUTwj2+eAhg98E4mecnrOCXDz3jE=",
+   "pom": "sha256-36WWVD+Z1b7cE4aq4rr73v9mpnK7IXF4/CSMjT1Xf+0="
+  },
+  "com/fasterxml/jackson/core#jackson-databind/2.18.1": {
+   "jar": "sha256-cRvDv4bTHQKWi5J577B6atYK38C6oOn+ZtcaCsJVYjQ=",
+   "module": "sha256-xlQvXTA+kaQo5pElXhDIGcSyGvnsQ+a+Vnq8MSRNIWc=",
+   "pom": "sha256-09m5HHTeS7LD9bNRhqq1FHFtqh1yEny2DQ0+Uk8xHyI="
+  },
+  "com/fasterxml/jackson/datatype#jackson-datatype-jsr310/2.18.1": {
+   "jar": "sha256-b3nIdhO9ALH/3rx40jXLnz3Ndhl3+/h8G3cBeCiuiV8=",
+   "module": "sha256-kOszPmMBRzhd8WMcq4L+YtkqVQB4b4Mskl6jbOgv2SM=",
+   "pom": "sha256-m9eWNx4di6787izrlhPIF8k8t/xw3DVSIzmRcBvn46c="
+  },
+  "com/fasterxml/jackson/module#jackson-modules-java8/2.18.1": {
+   "pom": "sha256-Pt9S8cWuqdNlMYMp6SUVLFJppU88C+7Enn0bBT+JA/4="
+  },
   "com/fasterxml/woodstox#woodstox-core/6.5.1": {
    "jar": "sha256-ySjWBmXGQV+xw5d1z5XPxE9/RYDPWrAbHDgOv/12iH8=",
    "pom": "sha256-SDllThaxcU509Rq8s3jYNWgUq49NUnPR3S8c6KOQrdw="
···
    "jar": "sha256-0fPGaqkaxSVJ4Arjsgi6S5r31y1o8jBkNVO+s45hGKw=",
    "pom": "sha256-9ZiID+766p1nTcQdsTqzcAS/A3drW7IcBN7ejpIMHxI="
   },
+  "com/google/errorprone#error_prone_annotations/2.36.0": {
+   "jar": "sha256-d0QOJwsLyaJJkDxaB2w2pyLEiGyk9CZ18pA6HFPtYaU=",
+   "pom": "sha256-15z9N8hfdta3VMdQHuHchEe3smQsI4LXeCUhZr0zHpw="
+  },
   "com/google/errorprone#error_prone_annotations/2.6.0": {
    "pom": "sha256-d1CXiHMcDoMurQIJFPYFi5MxYBb8ZdfLKscDspNKmvY="
   },
···
   "com/google/errorprone#error_prone_parent/2.21.1": {
    "pom": "sha256-MrsLX/JB/Wuh/upEiuu5zt7xaZvnPLbzGTZTh7gr+Sw="
   },
+  "com/google/errorprone#error_prone_parent/2.36.0": {
+   "pom": "sha256-Okz8imvtYetI6Wl5b8MeoNJwtj5nBZmUamGIOttwlNw="
+  },
   "com/google/errorprone#error_prone_parent/2.6.0": {
    "pom": "sha256-+7tgNV14gZvGGYK0y1sBbGVyjMMNJb/qQckKYcZETzQ="
   },
···
    "jar": "sha256-oXHuTHNN0tqDfksWvp30Zhr6typBra8x64Tf2vk2yiY=",
    "pom": "sha256-6WBCznj+y6DaK+lkUilHyHtAopG1/TzWcqQ0kkEDxLk="
   },
+  "com/google/guava#failureaccess/1.0.3": {
+   "jar": "sha256-y/w5BrGbj1XdfP1t/gqkUy6DQlDX8IC9jSEaPiRrWcs=",
+   "pom": "sha256-xUvv839tQtQ+FHItVKUiya1R75f8W3knfmKj6/iC87s="
+  },
   "com/google/guava#guava-parent/21.0": {
    "pom": "sha256-rNxtbwezRsrrF0kyeIvMxjwDXMXCsQCVjCH/4PbhmYg="
   },
···
   "com/google/guava#guava-parent/31.1-jre": {
    "pom": "sha256-RDliZ4O0StJe8F/wdiHdS7eWzE608pZqSkYf6kEw4Pw="
   },
+  "com/google/guava#guava-parent/33.4.0-android": {
+   "pom": "sha256-ciDt5hAmWW+8cg7kuTJG+i0U8ygFhTK1nvBT3jl8fYM="
+  },
+  "com/google/guava#guava-parent/33.4.6-jre": {
+   "pom": "sha256-Co0mEQgdOkd8L5S9lVY/6BDMdaZzUmqeSv2xGJEly0Q="
+  },
   "com/google/guava#guava/21.0": {
    "jar": "sha256-lyE5cYq8ikiT+njLqM97LJA/Ncl6r0T6MDGwZplItIA=",
    "pom": "sha256-wLAWqFx4TgHKUenWS/j+gM5AKyBv6ol7AyWNXm0P+A0="
···
    "jar": "sha256-pC7cnKt5Ljn+ObuU8/ymVe0Vf/h6iveOHWulsHxKAKs=",
    "pom": "sha256-kZPQe/T2YBCNc1jliyfSG0TjToDWc06Y4hkWN28nDeI="
   },
+  "com/google/guava#guava/33.4.6-jre": {
+   "jar": "sha256-lYoDW3T/bH0M3/nDhFJLZF62GPcRe2Dh7pFfnP/Q5xY=",
+   "module": "sha256-7+mDiJ/pKGiR0+ego5RsG2+l7AvG7qirnp4FOCYd1qc=",
+   "pom": "sha256-nokisU/7NNGuKxzTOQZFWkPoc6Tum8sx+jYD529uQfI="
+  },
   "com/google/guava#listenablefuture/9999.0-empty-to-avoid-conflict-with-guava": {
    "jar": "sha256-s3KgN9QjCqV/vv/e8w/WEj+cDC24XQrO0AyRuXTzP5k=",
    "pom": "sha256-GNSx2yYVPU5VB5zh92ux/gXNuGLvmVSojLzE/zi4Z5s="
···
    "jar": "sha256-Ia8wySJnvWEiwOC00gzMtmQaN+r5VsZUDsRx1YTmSns=",
    "pom": "sha256-X6yoJLoRW+5FhzAzff2y/OpGui/XdNQwTtvzD6aj8FU="
   },
+  "com/google/j2objc#j2objc-annotations/3.0.0": {
+   "jar": "sha256-iCQVc0Z93KRP/U10qgTCu/0Rv3wX4MNCyUyd56cKfGQ=",
+   "pom": "sha256-I7PQOeForYndEUaY5t1744P0osV3uId9gsc6ZRXnShc="
+  },
   "com/googlecode/concurrent-trees#concurrent-trees/2.6.1": {
    "jar": "sha256-BONySYTipcv1VgbPo3KlvT08XSohUzpwBOPN5Tl2H6U=",
    "pom": "sha256-Q8K5sULnBV0fKlgn8QlEkl0idH2XVrMlDAeqtHU4qXE="
   },
+  "com/googlecode/javaewah#JavaEWAH/1.1.12": {
+   "jar": "sha256-sZIEMxrG4gS++vUIpo9S7GtGONnZus3b69Q1+cTVAPI=",
+   "pom": "sha256-BhhOmwWeCAkRgnE2r17Hj1fuTDvBn2MutWGw34+HiM4="
+  },
   "com/googlecode/javaewah#JavaEWAH/1.2.3": {
    "jar": "sha256-1lImlJcTxMYaeE9BxRFn57Axb5N2Q5jrup5DNrPZVMI=",
    "pom": "sha256-5O1sZpYgNm+ZOSBln+CsfLyD11PbwNwOseUplzr5byM="
   },
+  "com/gradleup/shadow#com.gradleup.shadow.gradle.plugin/8.3.6": {
+   "pom": "sha256-NidtUGriR/nwGsf4gtmR/Om7klqlTGD8Cwt5QDINnFw="
+  },
+  "com/gradleup/shadow#shadow-gradle-plugin/8.3.6": {
+   "jar": "sha256-fOIOvwHuKe7FJFY70UK6wpHXUTXtedDZUamP0skmXDs=",
+   "module": "sha256-+8pm1Bwrz9HiUE9uzIIf4BqbAIx27qnJQM+Ay1aaI/8=",
+   "pom": "sha256-lRJfSJrSuJ5gJXMmnK9h9tSF26gvHcuNCYDODfK2stA="
+  },
   "com/lmax#disruptor/4.0.0": {
    "jar": "sha256-wrqAhBVBJyvIFbytq5ENLXFqpWPsoVdiRQq0yIlEBQU=",
    "module": "sha256-/ccJZrzS41x5Tc4sF7mZwuZpUOFYUx6Z3BUfsOvCllM=",
···
    "jar": "sha256-7urpF5FxRKaKdB1MDf9mqlxcX9hVk/8he87T/Iyng7g=",
    "pom": "sha256-1dgfzCiMDYxxHDAgB8raSqmiJu0aES1LqmTLHWMiFws="
   },
-  "commons-io#commons-io/2.15.1": {
-   "jar": "sha256-pYrxLuG2jP0uuwwnyu8WTwhDgaAOyBpIzCdf1+pU4VQ=",
-   "pom": "sha256-Fxoa+CtnWetXQLO4gJrKgBE96vEVMDby9ERZAd/T+R0="
+  "commons-io#commons-io/2.17.0": {
+   "jar": "sha256-SqTKSPPf0wt4Igt4gdjLk+rECT7JQ2G2vvqUh5mKVQs=",
+   "pom": "sha256-SEqTn/9TELjLXGuQKcLc8VXT+TuLjWKF8/VrsroJ/Ek="
   },
   "dev/equo/ide#solstice/1.7.5": {
    "jar": "sha256-BuFLxDrMMx2ra16iAfxnNk7RI/mCyF+lEx8IF+1lrk8=",
···
    "jar": "sha256-DnGR++Mk+5340tIHwHtma43CW7vib1OkxS4v7OYkqXY=",
    "pom": "sha256-+pvmlFd2A+LUy1X0UjctP2wPk+XzjuXNf7Yos3k8qbw="
   },
-  "io/fabric8#kubernetes-client-bom/5.12.4": {
-   "pom": "sha256-0jI5KonD79yFqymcWpToud01vALzQM6ERv9lmqFZE6A="
-  },
-  "io/github/goooler/shadow#io.github.goooler.shadow.gradle.plugin/8.1.5": {
-   "pom": "sha256-jzpPZuyZj2+w/T3lacYy607vycDvmIh0/pq2sF6OZAI="
-  },
-  "io/github/goooler/shadow#shadow-gradle-plugin/8.1.5": {
-   "jar": "sha256-p7085GPChFndkIaPyJjNX+wyDD3/U0fw9oiFp72eQtU=",
-   "module": "sha256-d07ZeQXwUHxpfxeKhAFy/bQ+pJz8L55Je4DAlfN6rtU=",
-   "pom": "sha256-7Z4JpOOV2pTl7BNx1XynWglhZtS65b9W85cKD+3ttQc="
-  },
   "io/leangen/geantyref#geantyref/1.3.11": {
    "jar": "sha256-wmJ0R0s4RLzbfYPPc6eFNm+EtFO8F6GRz6T4/D4CIjQ=",
    "pom": "sha256-3Etrgt7DQXBSvBc7lC+5asogUIpLmkfp8b2yQAXkPuc="
   },
-  "io/netty#netty-bom/4.1.104.Final": {
-   "pom": "sha256-WmXgahWdINO0gAYkpXDGRtvucQsrU5s0SaJoVYwonpw="
+  "io/netty#netty-buffer/4.2.1.Final": {
+   "jar": "sha256-Ls6NhBPVqjWh0eD+lPafnp7dj3q7U/bFV6Rzyf0L/I4=",
+   "pom": "sha256-kI8SXPGXUNqRcRIhTOuon6Rt0iZU3tvAQbmaGN516gg="
   },
-  "io/netty#netty-buffer/4.2.0.Final": {
-   "jar": "sha256-wBkmAXvg2WcRhFhSomRt5L8AqSVCsC7ZFfW+5Ugi/g0=",
-   "pom": "sha256-bBjzQVX17TipgvzKvnFjpPtKyIJT+mXMUO2UW5wqihA="
+  "io/netty#netty-codec-base/4.2.1.Final": {
+   "jar": "sha256-wqGnr5kWlCcvdLt9qwEFkEl5DBS0U3YACYJ+EFUw07c=",
+   "pom": "sha256-HhZaZI/68L/DUEepXastE8xH9MhaO60bpeX/GR9RTfw="
   },
-  "io/netty#netty-codec-base/4.2.0.Final": {
-   "jar": "sha256-RrVqvXE66yfG9H1zo+SF6iHZbFUFQWJq0PYsoMrhGPQ=",
-   "pom": "sha256-NiGpDs4IdW0xajveLg3IBxhIc/j/CC92+klZeguCNbU="
-  },
-  "io/netty#netty-codec-compression/4.2.0.Final": {
-   "jar": "sha256-tl3evCEZwECx5W+bZkfs3vjc29zSAOkdY63atOsauRw=",
-   "pom": "sha256-cuWm+0uQbKqiQxZebFNiyuAU4OAIE+11Hb5Y0B3p+eA="
+  "io/netty#netty-codec-compression/4.2.1.Final": {
+   "jar": "sha256-x9UaT2nEv78EP5LRlvYabfQq0pxb0NBT0QcRciClykY=",
+   "pom": "sha256-PUu9bTVQI2qrQ9FQxrKPBvV0QFpg0K7k7Z43G2nPF8U="
   },
-  "io/netty#netty-codec-haproxy/4.2.0.Final": {
-   "jar": "sha256-Cyah1KJ7DmzZGp6w21n71bBBmukrZdaSBGbIynWzSFo=",
-   "pom": "sha256-xlckSFjKcaOrz5xXjNN5eIl23x82aemjlo3U+TCggOg="
+  "io/netty#netty-codec-haproxy/4.2.1.Final": {
+   "jar": "sha256-9tKNDNRcyZhLpihrVZdg9/q9Xc8K0XhwHvDq5SmfRlc=",
+   "pom": "sha256-1/zgS3ordcAx0e/Fg7kZ7WT8OATQ+fe/cNtN83TIyrQ="
   },
-  "io/netty#netty-codec-http/4.2.0.Final": {
-   "jar": "sha256-iG0GBiC164CipVNL5wpH/FFsYKvQVVcPDvNMr28dYeI=",
-   "pom": "sha256-rI0zA731xoXJfFQQEzLGEqbrIc2KYI3mhtjfz1TFoJs="
+  "io/netty#netty-codec-http/4.2.1.Final": {
+   "jar": "sha256-EOgxhiv32rzsz0/YKYnDHdo5qJ7Wac9+lt7glykHdUE=",
+   "pom": "sha256-IgFVyOpvA50KfkncC8wJEDVCK63RJqtdTHJCcQKlzFo="
   },
-  "io/netty#netty-codec-marshalling/4.2.0.Final": {
-   "jar": "sha256-vdBfpYoNkN4YJfHLFtUYuYNXGS3TA/f2u1QUFdCSi60=",
-   "pom": "sha256-7q2vroWVahx6stgVkzy22BudMpyo6O9u1ANne3Dt7hY="
+  "io/netty#netty-codec-marshalling/4.2.1.Final": {
+   "jar": "sha256-SFSZicclpwJXkTKathKhpMvksQ5T9KaxPkTJwMVCh2o=",
+   "pom": "sha256-Jbo/nNzuOZQJYUr0NYs1SQKnVXqxLSgFTCE2WRom088="
   },
-  "io/netty#netty-codec-protobuf/4.2.0.Final": {
-   "jar": "sha256-1hkWVKT52MRAv4VqAQxb1RhuwQAMEB03dUNSAESHjmU=",
-   "pom": "sha256-KUWxLJErMIvF3X7Sdeaol/hsaMuDoi9adJ2HN04NKlo="
+  "io/netty#netty-codec-protobuf/4.2.1.Final": {
+   "jar": "sha256-yQ/7MaBKMoAonacuY6r3oj+XwWmOLMm5a/pkad+C9Zg=",
+   "pom": "sha256-1THFYFdSdgq6pFwwbPwyv9DdhrUjeVyYCv7qASifEDg="
   },
-  "io/netty#netty-codec/4.2.0.Final": {
-   "jar": "sha256-fbLwyPRKH7ZoZPPvqG0DqZigfNOB1s0Oh0YR9GSKkM0=",
-   "pom": "sha256-WhGKGtrJLpPpS63SMdxvMS0k2RkWEOo5O3X+1FDaYd8="
+  "io/netty#netty-codec/4.2.1.Final": {
+   "jar": "sha256-7vbxj3GsXjLcJ6jVJUeRRsWf7DAJnUMaQGYq/329RvE=",
+   "pom": "sha256-50zpmZRDPP4uWb0c5YR5fpCK1ddv47TZfp5xpzChvGQ="
   },
-  "io/netty#netty-common/4.2.0.Final": {
-   "jar": "sha256-UjcLbBMfU2tgybHmQ+mptuf/7PeH1dNFOxaJr72JSIY=",
-   "pom": "sha256-PPsQLAvAFyLCB/prp3iMnGkxbssK7NpZneT/rEw1nnM="
+  "io/netty#netty-common/4.2.1.Final": {
+   "jar": "sha256-fupKlvYazgYzeQY3QVDLc8lPJIiX/aPahltcOKcQvf0=",
+   "pom": "sha256-LuOladJw8oHrQ6uo6Mb9sgQXtV3D+wffbVPEwM39/Cs="
   },
-  "io/netty#netty-handler/4.2.0.Final": {
-   "jar": "sha256-ZBJAh4MnA68MxjSeCj442TkkrQj9X6RzB+r5qug5YdA=",
-   "pom": "sha256-VX4ITPkgVg6ZtVUKb8Vcy74jpTmtCURFdhVsAHmtSa8="
+  "io/netty#netty-handler/4.2.1.Final": {
+   "jar": "sha256-uX0Fet//+4JM5rXZh2v+Hwv86yRQS2ONP2xik8//XcU=",
+   "pom": "sha256-2eLP4nuNM9r9fSmHXLIaYV17+TD29tRfRP2wVQNn11Q="
   },
-  "io/netty#netty-parent/4.2.0.Final": {
-   "pom": "sha256-r7Or46M80QKlWTbO40FwE4txcozZWEY78FDKE375qxw="
+  "io/netty#netty-parent/4.2.1.Final": {
+   "pom": "sha256-w5aMzUh1X2OcSI0V9sFBOc76FWGZbEdiBcK+IdZngLQ="
   },
-  "io/netty#netty-resolver/4.2.0.Final": {
-   "jar": "sha256-ySpDpbHanOEWv3PvuyNkT+acHNM9037ZDcxXnvWt0Sg=",
-   "pom": "sha256-cGaHuj0B5olAF0hwSJ1Nt6R0Rj6UAv7p6QqySgnccK0="
+  "io/netty#netty-resolver/4.2.1.Final": {
+   "jar": "sha256-+xxanxIwzFWJRKxjPltk0+TsmB2ODVcn1fWBIgCLIY4=",
+   "pom": "sha256-yHpisHkPKXcurI6z3uY9Dm4ZQY2H57sbTZhK+E7LdQ4="
   },
-  "io/netty#netty-transport-classes-epoll/4.2.0.Final": {
-   "jar": "sha256-tyKjARA3ByL1AljVtKIZcMKvHO+zgQCAwe+zFhJ8ZCg=",
-   "pom": "sha256-TiF2aSsdI1maf2xsSAf7tBpHbGClxldxccW9WLxvftk="
+  "io/netty#netty-transport-classes-epoll/4.2.1.Final": {
+   "jar": "sha256-zC+Xr6VoTxmVpfEAazbJuksjPB5oA4xQ5bd7FKuk7qQ=",
+   "pom": "sha256-xDnVSdFm5hjdHluGEj62ZJmzf9Mo+UleCJh8TsduvS0="
   },
-  "io/netty#netty-transport-classes-io_uring/4.2.0.Final": {
-   "jar": "sha256-Y1RIRQCPj9/wW4JcUOoiCWJQNMLPZfiFl/dvPKvH2O0=",
-   "pom": "sha256-tjAC7xoEeJ9zHMIF7voNJM5z4bZ9kX34wxvbSj4xkkM="
+  "io/netty#netty-transport-classes-io_uring/4.2.1.Final": {
+   "jar": "sha256-xt64sgz3ajfiz26QX9Pu5Ph+7WR41O11x3CfQOABkVY=",
+   "pom": "sha256-pW283sTP9EwK3z21jILuXXTjtwxw+bgvstQljd1+mkk="
   },
-  "io/netty#netty-transport-classes-kqueue/4.2.0.Final": {
-   "jar": "sha256-4PX/BxGBO+ynWQ9ST9J3oe8WXy7pxRlrq41y10LdbCE=",
-   "pom": "sha256-KpL37GnxRY82aAnD1M99dRR23CxIuAZxdH0JWPk4sG0="
+  "io/netty#netty-transport-classes-kqueue/4.2.1.Final": {
+   "jar": "sha256-jx1LTHuS7dMdGcF2q2DF4+ceeESBzJXH/FDHRRHTLVY=",
+   "pom": "sha256-FZfud6TwQxu61IMSkFPYCpJxI9QEZKiMbK8mFfSJ0X0="
   },
-  "io/netty#netty-transport-native-epoll/4.2.0.Final": {
-   "jar": "sha256-VHWlUTe9NaqZ8iA6nzjqX2N08BS4jfcp7bmZ9KgYo80=",
-   "pom": "sha256-I0HScHWe5FI3f+gvtxRoHet1Wta4XdPnTrPSMi+HfB0="
+  "io/netty#netty-transport-native-epoll/4.2.1.Final": {
+   "jar": "sha256-r7pS5ooybM9V+fDL5DKL3HdfTQfkmp/bBU7e4zKk1iY=",
+   "pom": "sha256-jU8ZMnkjUd2dh18wKBgtGO380ot2HRmh/v28vTA53ho="
   },
-  "io/netty#netty-transport-native-epoll/4.2.0.Final/linux-aarch_64": {
-   "jar": "sha256-o9xKVsE5jbEifUQcr0Ii2xaKXT9449X7tGu6lkmkOLU="
+  "io/netty#netty-transport-native-epoll/4.2.1.Final/linux-aarch_64": {
+   "jar": "sha256-qKVqGCRta5N39nhh3ZnVRJd7eCKPvueD/pK291kebwo="
   },
-  "io/netty#netty-transport-native-epoll/4.2.0.Final/linux-x86_64": {
-   "jar": "sha256-EQc20zqQ7V3p/HSEpDuopaJ+YRz57Bzl83f6Fu3wk6I="
+  "io/netty#netty-transport-native-epoll/4.2.1.Final/linux-x86_64": {
+   "jar": "sha256-06vTRm3/oo01EC+Ig0a6TO9ZvBVm0AhLX6xf6yrasf0="
   },
-  "io/netty#netty-transport-native-io_uring/4.2.0.Final": {
-   "jar": "sha256-oTzFZIYRhC4iEavTzG7QwHNqlF2OxgHE3Pa9kkPboGw=",
-   "pom": "sha256-f45+F28dIA4O6ojEIu8fOPIbh1kmSsTNLsY2oLVCHDk="
+  "io/netty#netty-transport-native-io_uring/4.2.1.Final": {
+   "jar": "sha256-cA85zEIqvjT0pypNb4vXrIN+IPkKaw19bqBioJPaRfQ=",
+   "pom": "sha256-sIrz9A+m3YDNS7IHuKbDC056QnyqJQXplvELqKmsOcY="
   },
-  "io/netty#netty-transport-native-io_uring/4.2.0.Final/linux-aarch_64": {
-   "jar": "sha256-YavxiRa4SKO7bAO0UnUyRxVeVb4YNWtdcTtaE0TInvs="
+  "io/netty#netty-transport-native-io_uring/4.2.1.Final/linux-aarch_64": {
+   "jar": "sha256-Sz4XmKmexoj1p0KO0XdT7mi1ODY3RYVQ7KVycgFa27U="
   },
-  "io/netty#netty-transport-native-io_uring/4.2.0.Final/linux-x86_64": {
-   "jar": "sha256-VjWAqkvFfpxORqWG90gz8LNKLL9M8z6CCIMgqodqtxY="
+  "io/netty#netty-transport-native-io_uring/4.2.1.Final/linux-x86_64": {
+   "jar": "sha256-iWlfPXfnC3GSwonzezLC077qlQRhh0/mrZZTP8m5jXE="
   },
-  "io/netty#netty-transport-native-kqueue/4.2.0.Final": {
-   "jar": "sha256-izT+uqOG2dFXVzP28oJDgaJcslyFhpUY98VvriN1AJg=",
-   "pom": "sha256-sVEZGtkMTI/ScxJcB/2Z2nkYxIsW1TJ4EbeXhYd9Fr4="
+  "io/netty#netty-transport-native-kqueue/4.2.1.Final": {
+   "jar": "sha256-yBOQD8hQKKmxDapY57E/gAdIByXWj5LSmIk6IX4TASo=",
+   "pom": "sha256-2sqgyfd13F0mqip8Paewi5nMw++c/it0XEMJtJZRj00="
   },
-  "io/netty#netty-transport-native-kqueue/4.2.0.Final/osx-aarch_64": {
-   "jar": "sha256-B7vau9N0Ngx7tGDqF4iaNlvC9q+yKUO6u6/fdv+nSA8="
+  "io/netty#netty-transport-native-kqueue/4.2.1.Final/osx-aarch_64": {
+   "jar": "sha256-M1afocec8CjdrrAwZ2PiyUJx1shUTFkX0Pmc3pLjxKE="
   },
-  "io/netty#netty-transport-native-kqueue/4.2.0.Final/osx-x86_64": {
-   "jar": "sha256-sCYa4U6hX5dz4ayf8uu3oNlyF9HauW0HWVnFYEVMQw4="
+  "io/netty#netty-transport-native-kqueue/4.2.1.Final/osx-x86_64": {
+   "jar": "sha256-2Kh+nBDNnLxRsiJXq43HmfCywb87V4/gH4phdaxf2g4="
   },
-  "io/netty#netty-transport-native-unix-common/4.2.0.Final": {
-   "jar": "sha256-7qfwGHxAlNWTQbFQ1K0fxEyWOuZHcn1fM6hkR00g9VI=",
-   "pom": "sha256-kT7odeA5R97x91lJLS+ZNgKWAfE+6EET/zlCSd4NiSk="
+  "io/netty#netty-transport-native-unix-common/4.2.1.Final": {
+   "jar": "sha256-fyp3RpUMyyJ5CK/j7iG5vPaczFhDe7F8FXmo1XL7OKk=",
+   "pom": "sha256-XZQGqeIfeIg7nliBQp3VOFQ0bxEEXbs4H49By/LbdYE="
   },
-  "io/netty#netty-transport/4.2.0.Final": {
-   "jar": "sha256-LAurKGrjmt+MKikn2C5v2WTcGbPtH729TG9OIg8FKP8=",
-   "pom": "sha256-YNXY8UcYoSxfjYkUPjo2/7tWE72VAJLHyaol4sy+Urc="
+  "io/netty#netty-transport/4.2.1.Final": {
+   "jar": "sha256-up/UVZj6BWBdKlAU1vRxEuQ5K6K5Es0eN4bkhRs5fPc=",
+   "pom": "sha256-g8ryhVEg1V430/dDgX23gUOezAxMfra7Zv80sEDNjO8="
   },
   "it/unimi/dsi#fastutil/8.5.15": {
    "jar": "sha256-z/62ZzvfHm5Dd9aE3y9VrDWc9c9t9hPgXmLe7qUAk2o=",
···
    "jar": "sha256-Yq4oGH7SsGKBPaap1We/7nM8NBWCaZti3ZgCMHKaAxM=",
    "pom": "sha256-NYRJ1sc1OFhFCN2K5s/eVrr0o0t2e3HZzEZE8PH0IRo="
   },
-  "net/kyori#adventure-api/4.21.0": {
-   "jar": "sha256-ZKdldgQB541DOofb1M2lcBazA4U8b9Hclwh7WjqmgTM=",
-   "module": "sha256-+lKIKqUdj68bqml6drFHBnQUmNTKOkGg2MSrkTr6mV8=",
-   "pom": "sha256-dRFiV0Q3x90YtMgLxL5lBOtRCVVTL6YGhO8xU5LhQCc="
+  "net/kyori#adventure-api/4.23.0": {
+   "jar": "sha256-Ubn89img4yWTTyoyHpdL1tqCMzMmb/CZtK2GJC7cXvQ=",
+   "module": "sha256-ssVpI4V4Sh8OZm+ETRp3aMFkoIqFDC+SjNxBW/lSLJ0=",
+   "pom": "sha256-rXHK/j8ZankUdWLS1zFs2Xy4IEzWT1u7tDbaxsd69sk="
   },
-  "net/kyori#adventure-bom/4.21.0": {
-   "module": "sha256-6oUg3iIrlad0iW1bqJtFbKHQs7+RZbPsyOwvLXZhKPM=",
-   "pom": "sha256-fpuPxF10yGMnby42w0azTt+R2UJGxGgjRxv4w1hlenQ="
+  "net/kyori#adventure-bom/4.23.0": {
+   "module": "sha256-c9ge6qJeY3eAOKKVCMQKFLwJ6bZWEjaIoUJHc5HDOeo=",
+   "pom": "sha256-FGu/m1sl8kwUwlpmW76XgKXsCUmgPGttk7c/PfaQ9fM="
   },
-  "net/kyori#adventure-key/4.21.0": {
-   "jar": "sha256-apOYydQCCJ+doGCla0XK59WMvxmTcabY7Bom2PlMxrs=",
-   "module": "sha256-aepciDIN/bFf/lUqRKf0G8gBQqu6Kuds6nG3g4uF4Ho=",
-   "pom": "sha256-BERAvYv/A9TmYDNK3F5V8/bPlLf/ddBzS4DEHjqCgJc="
+  "net/kyori#adventure-key/4.23.0": {
+   "jar": "sha256-gDd4WEpb+PpfF7q5s7YkUO4TEP2SjyAPFoOSmkMMJmQ=",
+   "module": "sha256-o4U17pVdUtrTEco9rneVLJRybh55ytyr98WMYusqn0U=",
+   "pom": "sha256-iaYmnO5F3YJsKqD5mSQebjvq79mtSfkyxSZNvNcxewk="
   },
-  "net/kyori#adventure-nbt/4.21.0": {
-   "jar": "sha256-r27AXxaClKLmiLs8UhGxI70NTXh5HiS7fxE5rZi16zU=",
-   "module": "sha256-AGs77o7gGbcDYQ2MfBgzRW5OQ7nhEJO5yFF6Ck0M+B0=",
-   "pom": "sha256-0DAw5LnLm+QZSU42YB/opYAbt0nfH4pY8Xhn4SBwRzE="
+  "net/kyori#adventure-nbt/4.23.0": {
+   "jar": "sha256-2HqbMvVCeqeGOjG7+8q6t36WIExdKKYvf4DWalJtcEY=",
+   "module": "sha256-cdaqmcJYMWM5RELtBF4FrGyY3KvHEtMi5KBpBbdKOTY=",
+   "pom": "sha256-lKa0XCvcLlfTGwOL2sLeaV8qRp4TlpDLskiFuG4vOM4="
   },
   "net/kyori#adventure-platform-api/4.3.4": {
    "jar": "sha256-7GBGKMK3wWXqdMH8s6LQ8DNZwsd6FJYOOgvC43lnCsI=",
···
    "module": "sha256-VYXzbUzK6MaYbW4tmAjZs5ywl28CLK8sANPP5v1HTQQ=",
    "pom": "sha256-wP6w6syf5B8iL5iXsS4lrDw0Ub3VYWwUhclppgBO2eE="
   },
-  "net/kyori#adventure-text-logger-slf4j/4.21.0": {
-   "jar": "sha256-RyStz+/740AsjoMhhGkGArN0uxZuvRfm7ACMRFxTeTU=",
-   "module": "sha256-5WCx5qig2rD9wE+mseKirWZ3EkMJiyolz7A76DFNxtU=",
-   "pom": "sha256-7V/qFBbC6VjJcntV4fEaRoDmyM52WLE8FVt7UrEKPso="
+  "net/kyori#adventure-text-logger-slf4j/4.23.0": {
+   "jar": "sha256-e41RpiLFfZgt64llKz4tbukSj2V82lSRKtkmaL2r42Q=",
+   "module": "sha256-/xZGn2LzFSLEpmN50bXR0/vJfGKBNd1fpVG3Nkck8Eo=",
+   "pom": "sha256-zSk39q2IjiVO5SB9RWW2jmd2XErDNHAezauWoWQjC2s="
   },
-  "net/kyori#adventure-text-minimessage/4.21.0": {
-   "jar": "sha256-UctIeIUbcmM76h0bWyTo3jRhS8koroodupa2OOmk6MQ=",
-   "module": "sha256-c/i/PZOmL76h8kLHmSq0qLNhuml92HWZCku22tY3qCs=",
-   "pom": "sha256-zwtZrXXi99pqoHZ0wlrwAKD4UNXmceXSs8aKgtTeVxA="
+  "net/kyori#adventure-text-minimessage/4.23.0": {
+   "jar": "sha256-Vu0nZroiOLQBuuqWDTquRftY/aFhTalo/iuR/bnDgTw=",
+   "module": "sha256-H19hklBkEB3mY1LP0Qq43fWu/2RyVZt7KL1wERxaf2c=",
+   "pom": "sha256-fxTmmBxHbcYjPE5oGCZWIP4vV0uxfdj3UzKd8J8Cd2Q="
   },
-  "net/kyori#adventure-text-serializer-ansi/4.21.0": {
-   "jar": "sha256-LwrIh56+RgbvZhviUgAzqVEo6TDK0wr1vAxpy1kSmcU=",
-   "module": "sha256-V+Qm8xoIWTqA1aZvxnr/Y1y9Cqh8x8RWicmTpqoGwU0=",
-   "pom": "sha256-+cXbfm4x6DLrME+ZtgqP8AbTZ39XZOSqH1muT0KgDUU="
+  "net/kyori#adventure-text-serializer-ansi/4.23.0": {
+   "jar": "sha256-rF6iq0xE0wLnlkag9NRfSsmESi6sBpDoCnPc/SOy5Vw=",
+   "module": "sha256-/65qUt91zjFf3gi4HVKZ9JfEyfxcbGw3cCcfOMR2NQA=",
+   "pom": "sha256-9zq7B/otQpS9CaSm9Gpbu/WzbcUNpx/zPOPFuBlesKU="
   },
-  "net/kyori#adventure-text-serializer-commons/4.21.0": {
-   "jar": "sha256-LusmYFxyOlfltj0kwt1kGCFToUhsqOnzC8ukLSB/LCo=",
-   "module": "sha256-2SyvdO7dl496C1Q9dH4bNGD2+incUK9KAJEXKyyYJqM=",
-   "pom": "sha256-iSySW39EOPgDnk93KciCbI84LICMDDTIhoOtNqEN3PI="
+  "net/kyori#adventure-text-serializer-commons/4.23.0": {
+   "jar": "sha256-7ol3hRw6RFAN4rCOuqvVOX7Anzs2foblMInROHty+p0=",
+   "module": "sha256-YjLHYBQobnByp5HHWVWahxFizy18z81tDqGE3juXwgY=",
+   "pom": "sha256-ZyydJyIj/+Q6qskmSMNidr3yFBPKIG1Z0dOfAAjGEg0="
   },
-  "net/kyori#adventure-text-serializer-gson/4.21.0": {
-   "jar": "sha256-ObUc+poE324dL0MdJqaX7WGWI2ls3rHAChr9NHxc4IQ=",
-   "module": "sha256-xSvs+73VcbpmWXy7iHfbGxeBYfCNA44zYIv9P54aD28=",
-   "pom": "sha256-aEx9Da6SK8h5u+4lweWm/L6vCdnbDhijb9IuUZlqWsM="
+  "net/kyori#adventure-text-serializer-gson/4.23.0": {
+   "jar": "sha256-PiaD2i0UAwMjzJZFu6TNhtfLq/zkK9Fi7C2lDF59Yig=",
+   "module": "sha256-bX0ip7YdYnZqtPATdojSzM3ensdkP6OTzOlswwyX9vw=",
+   "pom": "sha256-bD3I0ry/SXG30bxzV8i+Xg5w4EqKhEt8RPQdada4XWo="
   },
-  "net/kyori#adventure-text-serializer-json-legacy-impl/4.21.0": {
-   "jar": "sha256-zMCsXIBSo1C/yrpnyk03xyFL5aH42Syq44wcrWz4v1U=",
-   "module": "sha256-b4OuzShhdN3x79WpDiGuHB2uI3dxU71gx5C0BM8mgAQ=",
-   "pom": "sha256-ix6svUQKhS+N0V5SekEvDIU+uAaJc72krT+6K+Eq/QQ="
+  "net/kyori#adventure-text-serializer-json-legacy-impl/4.23.0": {
+   "jar": "sha256-ovBQ7uMdiedww3bnPZoxt/b8QaORU0QTyUvksIF4vuQ=",
+   "module": "sha256-5Zqpg2TubngVdr3o0r6KLAd9quhvOqXKmUjAbW8s+XM=",
+   "pom": "sha256-iPCayPZoGa4ib7nDqSt2ZzrG4m9VMH+adhOVhraDO40="
   },
-  "net/kyori#adventure-text-serializer-json/4.21.0": {
-   "jar": "sha256-kocXstx2RathZhfAvVXoCpwDWHYrWQoNPAu+MCsuVIE=",
-   "module": "sha256-wTimiDaAyLv+TCvGCGU/AKxhu/QGqbXYHSityPXo3Q0=",
-   "pom": "sha256-XAMhaDcf2h9er2XKH0YsCV/ci8qGlyxL15T9CsaVLtg="
+  "net/kyori#adventure-text-serializer-json/4.23.0": {
+   "jar": "sha256-/CvHvwb8Cv5wbWJ493GDcqRoTSGhblLk1iJldxUomE8=",
+   "module": "sha256-KNC8Tk4rwY5zi1eBI+hXFug0GOlabO+KMeCPiVvw1MQ=",
+   "pom": "sha256-9b8uVtQSdYvaYyQEpwh2LILTQDI8zz1AEkHGdz1oeqw="
   },
-  "net/kyori#adventure-text-serializer-legacy/4.21.0": {
-   "jar": "sha256-msG5n4KEWOGQCPZ1eBoOjIUXzfoiofxbuHp79pVUw1w=",
-   "module": "sha256-mJvCjUI2jqtsZERpc3oocvgf+BTCp+wWGwUqHRgkQQg=",
-   "pom": "sha256-KpOkDYdQEqmRPf4z6W5LXIUlRwDqVDSndkjHNLDFAhk="
+  "net/kyori#adventure-text-serializer-legacy/4.23.0": {
+   "jar": "sha256-1SgOt1vypertB5eXGmzJAtxrjLtv6sJwEcyGJGEIIJ0=",
+   "module": "sha256-ci7v3AmzXyiOb6kKZ/CviLiS+ySDGUNqbg0QAxo4ADU=",
+   "pom": "sha256-9jjCmc72C3tNLOpg7vXYMntHW5d2HxxNq5VOHUWXUik="
   },
-  "net/kyori#adventure-text-serializer-plain/4.21.0": {
-   "jar": "sha256-Ep1piIu5P+lvUS8eWBodNvAog2G4Xo7IBP1u7LzvMS4=",
-   "module": "sha256-qtwvfOI85wiFn3c/Bti6y6r1fWsGfG1vtSwx40gCrt4=",
-   "pom": "sha256-kqv+DaajY+E0gwjXNMuwTfyZkzjKq5zqVV4/JN9WLD0="
+  "net/kyori#adventure-text-serializer-plain/4.23.0": {
+   "jar": "sha256-wuHYBMob54Q09K1r29U8yXoROtkpXLTJNs87nZAsWR4=",
+   "module": "sha256-OwEWAKJgf8zpq1+u7fWcvNQkgUmlMlXXfHZJJmO+IxM=",
+   "pom": "sha256-qVKWXEA9cuZKvM5m+BgxxE7dgimWU/sqlhbwzWfgAQI="
   },
   "net/kyori#ansi/1.1.1": {
    "jar": "sha256-tsVp4aCSW57rNJ4S2zXiI3VWEH4zNmV+Cy694mHYr9c=",
···
    "jar": "sha256-fQH8JaS7OvDhZiaFRV9FQfv0YmIW6lhG5FXBSR4Va4w=",
    "module": "sha256-qfpHivwqQ0b4pb4JH14UZmhgGS3YZbHj2FkilmRsdP4=",
    "pom": "sha256-XuAEEIIvNukBnZR2LOAbzWA5VpdlNRvvBmCUXNT5pW4="
+  },
+  "net/kyori#mammoth/1.4.0": {
+   "jar": "sha256-sEq7lrZm92PS10Z7AwjyP+jYt1P4rYkUOBTLXqmQHrM=",
+   "module": "sha256-wgR2ao8Uzk4aEkpTAqmDkQH82hGN4qumt2zGKGUmSq4=",
+   "pom": "sha256-uKJc0TFMWmsbn7lUg/132CUjKF/vpwW9dL+Ta65yRCE="
   },
   "net/kyori#option/1.1.0": {
    "jar": "sha256-l7abSxff4CIXyRMa00JWTLya69BMdetoljm194/UsRw=",
···
   "org/apache#apache/33": {
    "pom": "sha256-14vYUkxfg4ChkKZSVoZimpXf5RLfIRETg6bYwJI6RBU="
   },
-  "org/apache/ant#ant-launcher/1.10.14": {
-   "jar": "sha256-8JCXJaeiTjk4iPP7tVg0er9QbOL368WB/yYzG5TZUaU=",
-   "pom": "sha256-nJ2qQSPp63BzVnk2UsOIo1UQqqWm0UW0T4VdCN1LK7w="
+  "org/apache/ant#ant-launcher/1.10.15": {
+   "jar": "sha256-XIVRmQMHoDIzbZjdrtVJo5ponwfU1Ma5UGAb8is9ahs=",
+   "pom": "sha256-ea+EKil53F/gAivAc8SYgQ7q2DvGKD7t803E3+MNrJU="
   },
-  "org/apache/ant#ant-parent/1.10.14": {
-   "pom": "sha256-CBYQamBniMJw767yFWLPy9j0uvfafBG85RSetWYbMx8="
+  "org/apache/ant#ant-parent/1.10.15": {
+   "pom": "sha256-SYhPGHPFEHzCN/QoXER3R5uwgEvwc3OUgBsI114rvrA="
   },
-  "org/apache/ant#ant/1.10.14": {
-   "jar": "sha256-TLvZJD3kwQQtYdmhXbTEPJD/k7FteLOUgdoclWyOlnE=",
-   "pom": "sha256-L6QmnmscRXI6iojmnZhKdm27IEzQ/pgUlMzfP+469lw="
+  "org/apache/ant#ant/1.10.15": {
+   "jar": "sha256-djrNpKaViMnqiBepUoUf8ML8S/+h0IHCVl3EB/KdV5Q=",
+   "pom": "sha256-R4DmHoeBbu4fIdGE7Jl7Zfk9tfS5BCwXitsp4j50JdY="
   },
   "org/apache/commons#commons-parent/39": {
    "pom": "sha256-h80n4aAqXD622FBZzphpa7G0TCuLZQ8FZ8ht9g+mHac="
···
   "org/apache/commons#commons-parent/58": {
    "pom": "sha256-LUsS4YiZBjq9fHUni1+pejcp2Ah4zuy2pA2UbpwNVZA="
   },
-  "org/apache/commons#commons-parent/65": {
-   "pom": "sha256-bPNJX8LmrJE6K38uA/tZCPs/Ip+wbTNY3EVnjVrz424="
+  "org/apache/commons#commons-parent/74": {
+   "pom": "sha256-gOthsMh/3YJqBpMTsotnLaPxiFgy2kR7Uebophl+fss="
   },
   "org/apache/groovy#groovy-bom/4.0.22": {
    "module": "sha256-Ul0/SGvArfFvN+YAL9RlqygCpb2l9MZWf778copo5mY=",
···
    "jar": "sha256-8r8vLHdyFpyeMGmXGWZ60w+bRsTp14QZB96y0S2ZI/4=",
    "pom": "sha256-f8K4BFgJ8/J6ydTZ6ZudNGIbY3HPk8cxPs2Epa8Om64="
   },
-  "org/apache/logging#logging-parent/10.5.0": {
-   "pom": "sha256-ngk5zAKXfp/1KOdmBj4PMiTTbok7pMkh8JINtI86xqk="
-  },
   "org/apache/logging#logging-parent/11.3.0": {
    "pom": "sha256-pcmFtW/hxYQzOTtQkabznlufeFGN2PySE0aQWZtk19A="
   },
-  "org/apache/logging/log4j#log4j-api/2.22.1": {
-   "jar": "sha256-XXvq5/8V2FFtZRcSHX8Sp5pqwYDfZLX87FXVviEFblM=",
-   "pom": "sha256-bVdUd3E5Sz7hj57T7/ohWXGeLzY0Ynhj0FAjup/Y4Ys="
-  },
   "org/apache/logging/log4j#log4j-api/2.24.1": {
    "jar": "sha256-bne7Ip/I3K8JA4vutekDCyLp4BtRtFiwGDzmaevMku8=",
    "pom": "sha256-IzAaISnUEAiZJfSvQa7LUlhKPcxFJoI+EyNOyst+c+M="
   },
-  "org/apache/logging/log4j#log4j-bom/2.22.1": {
-   "pom": "sha256-nxUjceNriy6m6yyb0YgnYAafNhgKbygXfmpIwoFMDyM="
+  "org/apache/logging/log4j#log4j-api/2.24.3": {
+   "jar": "sha256-W0oKDNDnUd7UMcFiRCvb3VMyjR+Lsrrl/Bu+7g9m2A8=",
+   "pom": "sha256-vAXeM1M6Elmtusv8yCbNZjdqLZxO5T+4NgCfRKRbgjk="
   },
   "org/apache/logging/log4j#log4j-bom/2.24.1": {
    "pom": "sha256-vGPPsrS5bbS9cwyWLoJPtpKMuEkCwUFuR3q1y3KwsNM="
   },
-  "org/apache/logging/log4j#log4j-core/2.22.1": {
-   "jar": "sha256-RtzOysVWYj2OLOhkhJaCSoKVHROQYqTmEUiv8aJe0Y0=",
-   "pom": "sha256-HPf2SP7UPwv6wzKNk/yCPHSZB4/XkE4YtlSbsQeKnFI="
+  "org/apache/logging/log4j#log4j-bom/2.24.3": {
+   "pom": "sha256-sXq38yj0WGt+cfjJT8NaXaK86AcFpdYwBAIsGSiDNVg="
   },
   "org/apache/logging/log4j#log4j-core/2.24.1": {
    "jar": "sha256-ALzziEcsqApocBQYF2O2bXdxd/Isu/F5/WDhsaybybA=",
    "pom": "sha256-JyQstBek3xl47t/GlYtFyJgg+WzH9NFtH0gr/CN24M0="
   },
-  "org/apache/logging/log4j#log4j-iostreams/2.24.1": {
-   "jar": "sha256-oPXv2zMWaqrvEs1U+bXKlA1/oXV113BVD4KPMnAu+H4=",
-   "pom": "sha256-trWodrJTUpAmlQNSQxFnfefgkum9GfwgKWsKOYHD918="
+  "org/apache/logging/log4j#log4j-core/2.24.3": {
+   "jar": "sha256-frQIRZauJb08YWmOSOjQq2WpJgdYiE7Vy7nG5VxEpWo=",
+   "pom": "sha256-v9XAxKrGECQsy2H/ABCK1zeA2iCi9ym+Bjg2qXZXf1c="
   },
-  "org/apache/logging/log4j#log4j-jul/2.24.1": {
-   "jar": "sha256-7Rj4dHi+aaLXYKKJVmdkX/LAvry2xJQGeaSfRYi44FE=",
-   "pom": "sha256-mwbQSbyXT+bSXCcutp94QhoQeW6A6PnDl8lxtjFXjRw="
+  "org/apache/logging/log4j#log4j-iostreams/2.24.3": {
+   "jar": "sha256-Vv6AD/RhVeY2DfFxUOhpud49NUltsu/2QRWp0NvDGG8=",
+   "pom": "sha256-EcMCVtRz/apOYTuUqYoeVsLGAhYY2TK/Iqujeb4w4Co="
   },
-  "org/apache/logging/log4j#log4j-slf4j2-impl/2.24.1": {
-   "jar": "sha256-ZEtuPwxA5WmeoMoBOESxOK9EBWHSciZnLoC3qh/fwVY=",
-   "pom": "sha256-dip5v73nPP9Pmc6Gy2ar3w4S9c+K/5eefTe2XVVzb8Q="
+  "org/apache/logging/log4j#log4j-jul/2.24.3": {
+   "jar": "sha256-52uSXNbnCoI2SoBZ4G2zAxK3Ron/RlAQSnVbr/k3ENU=",
+   "pom": "sha256-c2tbLEv0UUuqrO+h27sGUF+gigliEHMv7roDMvY8sic="
   },
-  "org/apache/logging/log4j#log4j/2.22.1": {
-   "pom": "sha256-7Zibb7CaJW69TP3MIZaIuhw9beS087UUVC0WVj3CkJc="
+  "org/apache/logging/log4j#log4j-slf4j2-impl/2.24.3": {
+   "jar": "sha256-zarCLkDsMMQJbh6+jEVMiCbA0cN419tdezrRZjVLC9M=",
+   "pom": "sha256-fMloVddd24RWLjUHM0kF0NNTDECttyCAGTmIHgk3OKM="
   },
   "org/apache/logging/log4j#log4j/2.24.1": {
    "pom": "sha256-+NcAm1Rl2KhT0QuEG8Bve3JnXwza71OoDprNFDMkfto="
+  },
+  "org/apache/logging/log4j#log4j/2.24.3": {
+   "pom": "sha256-wUG0hj/AzqtYOJShPh+eUsAfwtdYcn1nR/a5nVBA87E="
   },
   "org/apache/maven#maven-api-meta/4.0.0-alpha-9": {
    "jar": "sha256-MsT1yturaAw0lS+ctXBFehODzOxMmlewOSYH1xkcaUk=",
···
   "org/codehaus#codehaus-parent/4": {
    "pom": "sha256-a4cjfejC4XQM+AYnx/POPhXeGTC7JQxVoeypT6PgFN8="
   },
-  "org/codehaus/groovy#groovy-bom/3.0.19": {
-   "pom": "sha256-E+POc+1L+fxu4rVA2FVWh/astwf4SSOUFMgnfUMd7KE="
-  },
   "org/codehaus/mojo#animal-sniffer-annotations/1.14": {
    "jar": "sha256-IGgyC9a610TDZzqwSPZ+ML749RiZb6OAAzVWYAZpkF0=",
    "pom": "sha256-GHnxmgWZHj7ZWRC5ZokzM5awxGeiFdxNH5ABhAS3KiY="
···
   "org/codehaus/mojo#mojo-parent/40": {
    "pom": "sha256-/GSNzcQE+L9m4Fg5FOz5gBdmGCASJ76hFProUEPLdV4="
   },
-  "org/codehaus/plexus#plexus-utils/4.0.0": {
-   "jar": "sha256-JwzXA7SMblyMaR8YdfItYtIs/gcsc64vWBTYPWjB2gs=",
-   "pom": "sha256-pExUeUJt6g57//0uw630nGhRUBl4iWXE0jH8PwTaQSk="
+  "org/codehaus/plexus#plexus-utils/4.0.2": {
+   "jar": "sha256-iVcnTnX+LCeLFCjdFqDa7uHdOBUstu/4Fhd6wo/Mtpc=",
+   "pom": "sha256-UVHBO918w6VWlYOn9CZzkvAT/9MRXquNtfht5CCjZq8="
   },
-  "org/codehaus/plexus#plexus-xml/4.0.3": {
-   "jar": "sha256-eqWeb9aTuGF8hydq7KnnoUmhC9qWB4iJO5TYpUcDc/c=",
-   "pom": "sha256-JzxQW2WJJwZxENYbbo/hL8tzcPVZgMk7r+lc4Lgt0FY="
-  },
-  "org/codehaus/plexus#plexus/13": {
-   "pom": "sha256-V1lF3AiWbGbrA9W66RNb0iyjkgoYZbuZ0+zZO+9Vq9M="
+  "org/codehaus/plexus#plexus-xml/4.0.4": {
+   "jar": "sha256-Bp54tTcQjcYSSmcHP8mYJkeR9rZJnpVaOOcrs+T+Gt8=",
+   "pom": "sha256-Ohb3yn7CRzFFtGHgpylREI1H4SThjIRMCFsaY3jGEVE="
   },
-  "org/codehaus/plexus#plexus/16": {
-   "pom": "sha256-aNTu1lo9u8NC7YDdE4++nGfLf7TCq8T1IBzbW59kWGg="
+  "org/codehaus/plexus#plexus/18": {
+   "pom": "sha256-tD7onIiQueW8SNB5/LTETwgrUTklM1bcRVgGozw92P0="
   },
   "org/codehaus/woodstox#stax2-api/4.2.1": {
    "jar": "sha256-Z4Vn5ItRpCxlxpnyZlOa09Z21LGlsK19iezoudV3JXk=",
···
   "org/eclipse/ee4j#project/1.0.7": {
    "pom": "sha256-IFwDmkLLrjVW776wSkg+s6PPlVC9db+EJg3I8oIY8QU="
   },
-  "org/eclipse/jetty#jetty-bom/9.4.53.v20231009": {
-   "pom": "sha256-+vlzoZh0JmzQhlsCmeup8WfLsHB13U/tvj1hVjV+ndU="
+  "org/eclipse/jgit#org.eclipse.jgit-parent/5.13.0.202109080827-r": {
+   "pom": "sha256-oY/X0MQf2o2PHEoktQAKhmRWFHokdG7mzEcx54ihje4="
   },
   "org/eclipse/jgit#org.eclipse.jgit-parent/6.7.0.202309050840-r": {
    "pom": "sha256-u56FQW2Y0HMfx2f41w6EaAQWAdZnKuItsqx5n3qjkR8="
   },
+  "org/eclipse/jgit#org.eclipse.jgit/5.13.0.202109080827-r": {
+   "jar": "sha256-2r+DafDN+M8Xt/faS9qTIMVwu3VMiOC+t7hSgSz1zSU=",
+   "pom": "sha256-qEF3Rc+i2V1qlxHpQT/KmE/FZmt2J7rRVAzyfUYq6BM="
+  },
   "org/eclipse/jgit#org.eclipse.jgit/6.7.0.202309050840-r": {
    "jar": "sha256-tWRHfQkiQaqrUMhKxd0aw3XAGCBE1+VlnTpgqQ4ugBo=",
    "pom": "sha256-BNB83b8ZjfpuRIuan7lA94HAEq2T2eqCBv4KTTplwZI="
···
   "org/fusesource#fusesource-pom/1.12": {
    "pom": "sha256-xA2WDarc73sBwbHGZXr7rE//teUxaPj8sLKLhOb9zKE="
   },
-  "org/fusesource/jansi#jansi/2.4.1": {
-   "jar": "sha256-Ll53Wp3Fj/prvWqm8JnWL4ti3N60w8O7vlzyMBvC3ME=",
-   "pom": "sha256-P5jZeaTTVZ+HefuwBLNK51Fq+t9RDhHffMPNBz6xuzs="
+  "org/fusesource/jansi#jansi/2.4.2": {
+   "jar": "sha256-C3uLADqQ6kkVebYvURiCjkURKRTGVYmwD6pJ1ux4WDk=",
+   "pom": "sha256-Lory+B0MmVUIvWfJid4ewhbrakdgk/WY9CFOz2ESjfA="
   },
   "org/javassist#javassist/3.28.0-GA": {
    "jar": "sha256-V9Cp6ShvgvTqqFESUYaZf4Eb784OIGD/ChWnf1qd2ac=",
···
    "module": "sha256-DZTIpBSD58Jwfr1pPhsTV6hBUpmM6FVQ67xUykMho6c=",
    "pom": "sha256-Cdlg+FkikDwuUuEmsX6fpQILQlxGnsYZRLPAGDVUciQ="
   },
-  "org/jline#jline-native/3.27.1": {
-   "jar": "sha256-Y2ZG2kBBPnSWOz9LQMnF3PtC89Ds8bk9bd9ciV7/5CI=",
-   "pom": "sha256-n/4orsyfVG7JaV8tUh9nRZtLNpFxSMCNFvRVazg9Mo8="
+  "org/jline#jline-native/3.30.2": {
+   "jar": "sha256-b6b1DhFWEJNMs/1CO0Mab9+QAGUunHg0+0gTMSnkUTM=",
+   "pom": "sha256-Nf+jS0HVcYVpXIW6KxEjx/+tOCf4HVNSlq2oolecl0E="
   },
   "org/jline#jline-parent/3.20.0": {
    "pom": "sha256-cXjGACAsS8Jux6S2IlXu829wVsrSpeYjnFdL7qXCEMo="
   },
-  "org/jline#jline-parent/3.27.1": {
-   "pom": "sha256-6WT9B2wgziTdtI3XN6CNYFA0cAXj5u7IL/XrBD1WFYE="
-  },
   "org/jline#jline-reader/3.20.0": {
    "jar": "sha256-rNHJTR4iiqe3li9psh7Tqf2CjrOmPkuvkIaVTmJq8fA=",
    "pom": "sha256-2fF+3XIcAqExcgN21sB4eHgutrb6/rX/QkBKtXFD4TY="
   },
-  "org/jline#jline-terminal-jansi/3.27.1": {
-   "jar": "sha256-mWvM6OpUHXH3Du3/+dEHpIJ39lVzReIdHzDGDmZIRnQ=",
-   "pom": "sha256-XWrgbTzxQG2C+kk2K8yZxImpu4l3c9baUiJnTT+K/+g="
+  "org/jline#jline-terminal-jansi/3.30.2": {
+   "jar": "sha256-AXOC7/q4HAn4O0Ecic4gPzLQWR2t4KjYygUTmqThtDI=",
+   "pom": "sha256-cb0W3CMPlL82lQ4md+JKSF0kv59UoWCyfx/SkqqeaB4="
   },
   "org/jline#jline-terminal/3.20.0": {
    "jar": "sha256-EhJRcOeVUZum3IAQwHC1PHaq6StIXB43Uw5Uq13QjUM=",
    "pom": "sha256-EMo7z1F48YUH8hCmOtljeJaFM0OtHBKRoBmhFvIWpUg="
   },
-  "org/jline#jline-terminal/3.27.1": {
-   "jar": "sha256-Qre3VlBrypi1BZOEJqNcmQgveBnDM+0lvUEUv7DjtfI=",
-   "pom": "sha256-hHjnmqIupq95eWRD+O0w//pdxkfrPS0YYLrC4j800pc="
+  "org/jline#jline-terminal/3.30.2": {
+   "jar": "sha256-HqoUwqI6kVMxzNTqp11iTCN/sMoNI6UHgQt/kYFhCgw=",
+   "pom": "sha256-RGzvv38zbLWZGzML8w9v5NP6g0OGLGp8MjCl33sePvc="
   },
   "org/jspecify#jspecify/0.3.0": {
    "module": "sha256-M7jCLyQkwpAyQaf+olj8QasMTWiJd2V2xRkEdWLuQ6U=",
···
    "module": "sha256-qnlAydaDEuOdiaZShaqa9F8U2PQ02FDujZPbalbRZ7s=",
    "pom": "sha256-EJN9RMQlmEy4c5Il00cS4aMUVkHKk6w/fvGG+iX2urw="
   },
+  "org/junit#junit-bom/5.11.0": {
+   "module": "sha256-9+2+Z/IgQnCMQQq8VHQI5cR29An1ViNqEXkiEnSi7S0=",
+   "pom": "sha256-5nRZ1IgkJKxjdPQNscj0ouiJRrNAugcsgL6TKivkZE0="
+  },
   "org/junit#junit-bom/5.9.1": {
    "module": "sha256-kCbBZWaQ+hRa117Og2dCEaoSrYkwqRsQfC9c3s4vGxw=",
    "pom": "sha256-sWPBz8j8H9WLRXoA1YbATEbphtdZBOnKVMA6l9ZbSWw="
···
    "module": "sha256-4dG63P7cJyRFQeC+XV6EtyoicNevYWhrJvEc/Edw2kI=",
    "pom": "sha256-EqqGyhwNZIoiXU58aWBUwfx26IeCxcOft983muI7728="
   },
+  "org/junit/platform#junit-platform-launcher/1.10.2": {
+   "jar": "sha256-rtT0L7kK2ps0fCMfE2VvwJEhuiDattxkamvZ1Nox5Ko=",
+   "module": "sha256-/1YhIQJQJSv9rbYiu+LqZuzsMahnc2zqSz1K3yGcp/8=",
+   "pom": "sha256-WjEXCOeQa7l0YpwayHC8EWV0ZbmJ2koHfkVBa9mHJeQ="
+  },
   "org/lanternpowered#lmbda/2.0.0": {
    "jar": "sha256-v7mL90YQgkvVbhDYJSM6Zg66M7qRXPlHJGJX9QPadfM=",
    "pom": "sha256-KRybm3znFPdLpG0zsmSEpYS+NPXHXGyTDsIF8iGbVfg="
···
   "org/ow2#ow2/1.5.1": {
    "pom": "sha256-Mh3bt+5v5PU96mtM1tt0FU1r+kI5HB92OzYbn0hazwU="
   },
-  "org/ow2/asm#asm-commons/9.6": {
-   "jar": "sha256-eu/Q1cCQFwHGn3UT/tp2X7a+M68s56oXxXgfyHZXxRE=",
-   "pom": "sha256-qYrkiVM0uvj/hr1mUWIQ29mgPxpuFeR92oKvz2tT13w="
+  "org/ow2/asm#asm-commons/9.7.1": {
+   "jar": "sha256-mlebVNKSrZvhcdQxP9RznGNVksK1rDpFm70QSc3exqA=",
+   "pom": "sha256-C/HTHaDJ+djtwvJ9u/279z8acVtyzS+ijz8ZWZTXStE="
   },
-  "org/ow2/asm#asm-tree/9.6": {
-   "jar": "sha256-xD7PF7U5x3fhXae1uGVTs3fi05poPeYoVWfVKDiI5+8=",
-   "pom": "sha256-G8tIHX/Ba5VbtgygfIz6JCS87ni9xAW7oxx9b13C0RM="
-  },
-  "org/ow2/asm#asm/9.6": {
-   "jar": "sha256-PG+sJCTbPUqFO2afTj0dnDxVIjXhmjGWc/iHCDwjA6E=",
-   "pom": "sha256-ku7iS8PIQ+SIHUbB3WUFRx7jFC+s+0ZrQoz+paVsa2A="
+  "org/ow2/asm#asm-tree/9.7.1": {
+   "jar": "sha256-mSmIH1nra4QOhtVFcMd7Wc5yHRBObf16QJeJkcLTtB8=",
+   "pom": "sha256-E7kF9l5/1DynZ09Azao3Z5ukhYxsnZ+48Xp6/ZuqvJ4="
   },
   "org/ow2/asm#asm/9.7.1": {
    "jar": "sha256-jK3UOsXrbQneBfrsyji5F6BAu5E5x+3rTMgcdAtxMoE=",
    "pom": "sha256-cimwOzCnPukQCActnkVppR2FR/roxQ9SeEGu9MGwuqg="
   },
+  "org/ow2/asm#asm/9.8": {
+   "jar": "sha256-h26raoPa7K1cpn65/KuwY8l7WuuM8fynqYns3hdSIFE=",
+   "pom": "sha256-wTZ8O7OD12Gef3l+ON91E4hfLu8ErntZCPaCImV7W6o="
+  },
   "org/reflections#reflections/0.10.2": {
    "jar": "sha256-k4otCP5UBQ12ELlE2N3DoJNVcQ2ea+CqyDjbwE6aKCU=",
    "pom": "sha256-tsqj6301vXVu1usKKoGGi408D29CJE/q5BdgrGYwbYc="
   },
+  "org/slf4j#slf4j-api/1.7.30": {
+   "jar": "sha256-zboHlk0btAoHYUhcax6ML4/Z6x0ZxTkorA1/lRAQXFc=",
+   "pom": "sha256-fgdHdR6bZ+Gdy1IG8E6iLMA9JQxCJCZALq3QNRPywxQ="
+  },
   "org/slf4j#slf4j-api/1.7.36": {
    "jar": "sha256-0+9XXj5JeWeNwBvx3M5RAhSTtNEft/G+itmCh3wWocA=",
    "pom": "sha256-+wRqnCKUN5KLsRwtJ8i113PriiXmDL0lPZhSEN7cJoQ="
   },
-  "org/slf4j#slf4j-api/2.0.12": {
-   "jar": "sha256-p5UCuKvfvXIoRqJ2kSJqQIhoLW01ZU+bgOKpzKz37Uc=",
-   "pom": "sha256-Udh5pZmPWCJ0Dc9VIsDtaXGtXEpeowtw9bVGCT5rQmM="
-  },
   "org/slf4j#slf4j-api/2.0.16": {
    "jar": "sha256-oSV43eG6AL2bgW04iguHmSjQC6s8g8JA9wE79BlsV5o=",
    "pom": "sha256-saAPWxxNvmK4BdZdI5Eab3cGOInXyx6G/oOJ1hkEc/c="
   },
-  "org/slf4j#slf4j-bom/2.0.12": {
-   "pom": "sha256-SH70mE1wFY9Yw3zodmkxukx+VzdYZYhLdWORv9bQDDk="
+  "org/slf4j#slf4j-api/2.0.17": {
+   "jar": "sha256-e3UdlSBhlU1av+1xgcH2RdM2CRtnmJFZHWMynGIuuDI=",
+   "pom": "sha256-FQxAKH987NwhuTgMqsmOkoxPM8Aj22s0jfHFrJdwJr8="
   },
   "org/slf4j#slf4j-bom/2.0.16": {
    "pom": "sha256-BWYEjsglzfKHWGIK9k2eFK44qc2HSN1vr6bfSkGUwnk="
+  },
+  "org/slf4j#slf4j-bom/2.0.17": {
+   "pom": "sha256-940ntkK0uIbrg5/BArXNn+fzDzdZn/5oGFvk4WCQMek="
+  },
+  "org/slf4j#slf4j-parent/1.7.30": {
+   "pom": "sha256-EWR5VuSKDFv7OsM/bafoPzQQAraFfv0zWlBbaHvjS3U="
   },
   "org/slf4j#slf4j-parent/1.7.36": {
    "pom": "sha256-uziNN/vN083mTDzt4hg4aTIY3EUfBAQMXfNgp47X6BI="
   },
-  "org/slf4j#slf4j-parent/2.0.12": {
-   "pom": "sha256-fGvEdX5NSZJN3w/sX1zkAvg6bGzz4QUtGVsSgqeFVd4="
-  },
   "org/slf4j#slf4j-parent/2.0.16": {
    "pom": "sha256-CaC0zIFNcnRhbJsW1MD9mq8ezIEzNN5RMeVHJxsZguU="
+  },
+  "org/slf4j#slf4j-parent/2.0.17": {
+   "pom": "sha256-lc1x6FLf2ykSbli3uTnVfsKy5gJDkYUuC1Rd7ggrvzs="
   },
   "org/sonatype/oss#oss-parent/5": {
    "pom": "sha256-FnjUEgpYXYpjATGu7ExSTZKDmFg7fqthbufVqH9SDT0="
···
    "jar": "sha256-IRswbPxE+Plt86Cj3a91uoxSie7XfWDXL4ibuFX1NeU=",
    "pom": "sha256-CTvhsDMxvOKTLWglw36YJy12Ieap6fuTKJoAJRi43Vo="
   },
-  "org/vafer#jdependency/2.10": {
-   "jar": "sha256-Hc2DVauevO1odxW/ElLrKu5dDnRJeiAU/TOHz86N+F8=",
-   "pom": "sha256-q1PyWatfZIPT27AjVGngeNSiLP2JB3GrBPh9s6W0YGc="
+  "org/vafer#jdependency/2.12": {
+   "jar": "sha256-xuxNA/nwT7ZEjTavQ6HMBpoh7LXocBM90Y/tT02x3mg=",
+   "pom": "sha256-LY6Zq9RS9eZCxtK74xACuSh5naw6CeA+PknyE3ozt+s="
   },
   "org/xmlresolver#xmlresolver/5.1.1": {
    "jar": "sha256-MSL4rkDERq27MDzVUldoA/2/bq77hL985D0TNlsnymg=",

pkgs/by-name/ve/velocity/fix-version.patch

···
 --- a/build-logic/src/main/kotlin/velocity-init-manifest.gradle.kts
 +++ b/build-logic/src/main/kotlin/velocity-init-manifest.gradle.kts
-@@ -2,28 +2,9 @@ import org.gradle.jvm.tasks.Jar
- import org.gradle.kotlin.dsl.withType
- import java.io.ByteArrayOutputStream
+@@ -8,29 +8,10 @@ interface Injected {
+     val execOps: ExecOperations
+ }
  
 -val currentShortRevision = ByteArrayOutputStream().use {
--    exec {
+-    val execOps = objects.newInstance<Injected>().execOps
+-    execOps.exec {
 -        executable = "git"
 -        args = listOf("rev-parse", "HEAD")
 -        standardOutput = it
···
 -
  tasks.withType<Jar> {
      manifest {
--        val buildNumber = System.getenv("BUILD_NUMBER")
+         val buildNumber = System.getenv("BUILD_NUMBER")
 -        val velocityHumanVersion: String =
 -            if (project.version.toString().endsWith("-SNAPSHOT")) {
 -                if (buildNumber == null) {
···
 -            } else {
 -                archiveVersion.get()
 -            }
-+        val velocityHumanVersion = System.getenv("BUILD_VERSION")
++        val velocityHumanVersion = System.getenv("BUILD_VERSION");
          attributes["Implementation-Version"] = velocityHumanVersion
      }
  }

pkgs/by-name/ve/velocity/package.nix

···
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "velocity";
-  version = "3.4.0-unstable-2025-06-11";
+  version = "3.4.0-unstable-2025-08-02";
 
   src = fetchFromGitHub {
     owner = "PaperMC";
     repo = "Velocity";
-    rev = "669fda298c670c55686f34d868383052b192518d";
-    hash = "sha256-UI6SqVAaM4NANf9cGvsIgYO1jSkWDOk5ysyufrPWTgg=";
+    rev = "d47848cb93a5f94a95059c2794c0197df6360f29";
+    hash = "sha256-bCvUXWv4rdoZEU1GpVSlXROC9kBtSGisvmCgRPKVZ4o=";
   };
 
   nativeBuildInputs = [

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

···
 
 python3Packages.buildPythonApplication rec {
   pname = "virtnbdbackup";
-  version = "2.32";
+  version = "2.34";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "abbbi";
     repo = "virtnbdbackup";
     tag = "v${version}";
-    hash = "sha256-SCt+RvtY17wTGeCcMbmK7q7cLz17upTEgoKZM4pDh7s=";
+    hash = "sha256-3qB1y9iFt8GKDRzc6mvq8d4M6BczlmlAaColH4MssdI=";
   };
 
   build-system = with python3Packages; [

pkgs/by-name/wi/wiliwili/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: {
   pname = "wiliwili";
-  version = "1.5.1";
+  version = "1.5.2";
 
   src = fetchFromGitHub {
     owner = "xfangfang";
     repo = "wiliwili";
     tag = "v${finalAttrs.version}";
     fetchSubmodules = true;
-    hash = "sha256-37DQafP+PFjrfNXJt88oK0ghqQEVQjDdVbYsf1tHAN4=";
+    hash = "sha256-lcHKbEYlOznu9WhWX7ZoOCnxr6h/AJCLbjLmc2ZZTbg=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/wo/workout-tracker/package.nix

···
 }:
 let
   pname = "workout-tracker";
-  version = "2.4.0";
+  version = "2.4.1";
 
   src = fetchFromGitHub {
     owner = "jovandeginste";
     repo = "workout-tracker";
     tag = "v${version}";
-    hash = "sha256-CJiUSN0QmZD5B/KPlHY2SySQC3D/+aVdydS4mYTabz0=";
+    hash = "sha256-MS4+dbJUh+oHWcQKe84VWW2e3hbZM4dgDWl6ZkFQkDo=";
   };
 
   assets = buildNpmPackage {

pkgs/by-name/zo/zoom-us/package.nix

···
   versions.x86_64-darwin = "6.5.7.60598";
 
   # This is the fallback version so that evaluation can produce a meaningful result.
-  versions.x86_64-linux = "6.5.7.3298";
+  versions.x86_64-linux = "6.5.8.3527";
 
   srcs = {
     aarch64-darwin = fetchurl {
···
     };
     x86_64-linux = fetchurl {
       url = "https://zoom.us/client/${versions.x86_64-linux}/zoom_x86_64.pkg.tar.xz";
-      hash = "sha256-6gzgJmB+/cwcEToQpniVVZyQZcqzblQG/num0X+xUIE=";
+      hash = "sha256-qTehkDMyc28XHtta7taNYn8gPCYS/Qdr2VMUIDDC/68=";
     };
   };
 

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

···
+{
+  lib,
+  buildPythonPackage,
+  fetchFromGitHub,
+  pythonOlder,
+  setuptools,
+  aiohttp,
+  mashumaro,
+  aiofiles,
+  aioresponses,
+  pytest-asyncio,
+  pytestCheckHook,
+}:
+
+buildPythonPackage rec {
+  pname = "airos";
+  version = "0.2.4";
+  pyproject = true;
+
+  disabled = pythonOlder "3.13";
+
+  src = fetchFromGitHub {
+    owner = "CoMPaTech";
+    repo = "python-airos";
+    tag = "v${version}";
+    hash = "sha256-zY0XPucCXiJDo9C4GiDqs/lxQDTphs/mBXBqSYPvkoI=";
+  };
+
+  build-system = [ setuptools ];
+
+  dependencies = [
+    aiohttp
+    mashumaro
+  ];
+
+  nativeCheckInputs = [
+    aiofiles
+    aioresponses
+    pytest-asyncio
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [ "airos" ];
+
+  meta = {
+    description = "Ubiquity airOS module(s) for Python 3";
+    homepage = "https://github.com/CoMPaTech/python-airos";
+    changelog = "https://github.com/CoMPaTech/python-airos/releases/tag/v${version}";
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.jamiemagee ];
+  };
+}

pkgs/development/python-modules/django-stubs-ext/default.nix

···
     "tests/typecheck"
   ];
 
+  # Tests are not shipped with PyPI
+
   pythonImportsCheck = [ "django_stubs_ext" ];
 
   meta = with lib; {

pkgs/development/python-modules/django-stubs/default.nix

···
 {
   lib,
   buildPythonPackage,
-  django,
   django-stubs-ext,
+  django,
   fetchFromGitHub,
+  hatchling,
+  redis,
   mypy,
   pytest-mypy-plugins,
+  oracledb,
   pytestCheckHook,
   pythonOlder,
-  hatchling,
   tomli,
   types-pytz,
   types-pyyaml,
+  types-redis,
   typing-extensions,
 }:
 
···
 
   optional-dependencies = {
     compatible-mypy = [ mypy ];
+    oracle = [ oracledb ];
+    redis = [
+      redis
+      types-redis
+    ];
   };
 
   nativeCheckInputs = [
···
   ];
 
   disabledTestPaths = [
-    "tests/typecheck"
+    # Skip type checking
+    "tests/typecheck/"
   ];
 
   pythonImportsCheck = [ "django-stubs" ];

pkgs/development/python-modules/djangorestframework-stubs/default.nix

···
   version = "3.16.1";
   pyproject = true;
 
-  disabled = pythonOlder "3.9";
+  disabled = pythonOlder "3.10";
 
   src = fetchFromGitHub {
     owner = "typeddjango";
···
     hash = "sha256-TTv6v7G3LODrUDSYSNNa4+dujih7QElmvK3mMQg9EuQ=";
   };
 
-  nativeBuildInputs = [ setuptools ];
+  postPatch = ''
+    substituteInPlace pyproject.toml \
+      --replace-fail "<79.0.0" ""
+  '';
+
+  build-system = [ setuptools ];
 
-  propagatedBuildInputs = [
+  dependencies = [
     django-stubs
     requests
     types-pyyaml
···
   ]
   ++ lib.flatten (builtins.attrValues optional-dependencies);
 
-  # Upstream recommends mypy > 1.7 which we don't have yet, thus all testsare failing with 3.14.5 and below
+  # Upstream recommends mypy > 1.7 which we don't have yet, thus all tests are failing with 3.14.5 and below
   doCheck = false;
 
   pythonImportsCheck = [ "rest_framework-stubs" ];

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

···
 
 buildPythonPackage rec {
   pname = "fastai";
-  version = "2.8.2";
+  version = "2.8.3";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-ix3Sp/IKj7BLmuuGd/763LB0llSUYAbMWJD8fvWe/u8=";
+    hash = "sha256-lgUBxf8vef9HnAWh2eNxtFRMeHxDjucJrZEcONq9DK8=";
   };
 
   propagatedBuildInputs = [

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

···
   prePatch = ''
     # patch fails to apply because of line endings
     dos2unix ldap3/utils/asn1.py
+    substituteInPlace _version.json \
+      --replace-fail '"version": "2.9",' '"version": "${version}",'
   '';
 
   patches = [
···
   meta = with lib; {
     homepage = "https://github.com/cannatag/ldap3";
     description = "Strictly RFC 4510 conforming LDAP V3 pure Python client library";
-    license = licenses.lgpl3;
+    license = licenses.lgpl3Plus;
     maintainers = [ ];
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "publicsuffixlist";
-  version = "1.0.2.20250802";
+  version = "1.0.2.20250809";
   pyproject = true;
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-/Liz65F7Rk/TJr5xICfRsK10Flzgojw2m4otnh4+y5A=";
+    hash = "sha256-eTvYGTwuSjT7ban7B9xS+8HzJfiMHnEIZSXimjMykJE=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/pybind11-stubgen/default.nix

···
 
 buildPythonPackage rec {
   pname = "pybind11-stubgen";
-  version = "2.5.4";
+  version = "2.5.5";
   pyproject = true;
 
   build-system = [ setuptools ];
···
     owner = "sizmailov";
     repo = "pybind11-stubgen";
     tag = "v${version}";
-    hash = "sha256-xOvh5H2n7KOOvsRecwWlaWgFIHUPYxTEOTvM9RIpTTQ=";
+    hash = "sha256-J2LydgkiNQp+2/agwBCSTtr+Ci4zONLkHmnMLFBww24=";
   };
 
   # For testing purposes, the upstream source uses a shell script to build the pybind11

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

···
+{
+  lib,
+  buildPythonPackage,
+  fetchPypi,
+  setuptools,
+}:
+
+buildPythonPackage rec {
+  pname = "pyitachip2ir";
+  version = "0.0.7";
+  pyproject = true;
+
+  src = fetchPypi {
+    inherit pname version;
+    hash = "sha256-T/Q3tZTTwqlaHDR2l2nRLISC4LLrOPZZv14sRxYyqDQ=";
+  };
+
+  build-system = [ setuptools ];
+
+  # Package has no tests
+  doCheck = false;
+
+  pythonImportsCheck = [ "pyitachip2ir" ];
+
+  meta = {
+    description = "Library for sending IR commands to an ITach IP2IR gateway";
+    homepage = "https://github.com/alanfischer/itachip2ir";
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.jamiemagee ];
+  };
+}

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

···
 {
   lib,
   buildPythonPackage,
+  cython,
+  fastcrc,
   fetchPypi,
-  future,
   lxml,
+  setuptools,
 }:
 
 buildPythonPackage rec {
   pname = "pymavlink";
   version = "2.4.49";
-  format = "setuptools";
+  pyproject = true;
 
   src = fetchPypi {
     inherit pname version;
     hash = "sha256-188Q1VktA4oYqpcnERd+u4i+IUPvzCWN9jCwUT6dosI=";
   };
 
-  propagatedBuildInputs = [
-    future
+  build-system = [
+    cython
+    setuptools
+  ];
+
+  dependencies = [
+    fastcrc
     lxml
   ];
 
···
   meta = with lib; {
     description = "Python MAVLink interface and utilities";
     homepage = "https://github.com/ArduPilot/pymavlink";
+    changelog = "https://github.com/ArduPilot/pymavlink/releases/tag/${version}";
     license = with licenses; [
       lgpl3Plus
       mit

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

···
 
 buildPythonPackage rec {
   pname = "pymiele";
-  version = "0.5.2";
+  version = "0.5.3";
   pyproject = true;
 
   disabled = pythonOlder "3.13";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-pU1PC1DXoXjZVkml3OFPhKgLVqhB9LbPPE1NzphyOSk=";
+    hash = "sha256-sz8yNyh8cmgmnElEhjw7yUUUiG6bpdB4LXze6ZWFjMo=";
   };
 
   build-system = [ setuptools ];

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

···
+{
+  lib,
+  buildPythonPackage,
+  fetchFromGitHub,
+  setuptools,
+  pythonRelaxDepsHook,
+  pydub,
+  pysocks,
+  requests,
+  selenium,
+  speechrecognition,
+}:
+
+buildPythonPackage rec {
+  pname = "pypasser";
+  version = "0.0.5";
+  pyproject = true;
+
+  src = fetchFromGitHub {
+    owner = "xHossein";
+    repo = "PyPasser";
+    tag = version;
+    hash = "sha256-vqa+Xap9dYvjJMiGNGNmegh7rmAqwf3//MH47xwr/T0=";
+  };
+
+  build-system = [ setuptools ];
+
+  nativeBuildInputs = [
+    pythonRelaxDepsHook
+  ];
+
+  pythonRelaxDeps = [
+    "speechrecognition"
+  ];
+
+  dependencies = [
+    pydub
+    pysocks
+    requests
+    selenium
+    speechrecognition
+  ];
+
+  pythonImportsCheck = [
+    "pypasser"
+    "pypasser.reCaptchaV2"
+    "pypasser.reCaptchaV3"
+  ];
+
+  # Package has no tests
+  doCheck = false;
+
+  meta = {
+    description = "Bypassing reCaptcha V3 by sending HTTP requests & solving reCaptcha V2 using speech to text";
+    homepage = "https://github.com/xHossein/PyPasser";
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.jamiemagee ];
+  };
+}

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

···
+{
+  lib,
+  buildPythonPackage,
+  fetchFromGitHub,
+  appdirs,
+  pytestCheckHook,
+  setuptools,
+}:
+
+buildPythonPackage rec {
+  pname = "pypjlink2";
+  version = "1.2.1";
+  pyproject = true;
+
+  src = fetchFromGitHub {
+    owner = "benoitlouy";
+    repo = "pypjlink";
+    tag = "v${version}";
+    hash = "sha256-0RVI9DX5JaVWntSu5du5SU45NC70TZJyVrvMuVR7grA=";
+  };
+
+  build-system = [
+    setuptools
+  ];
+
+  dependencies = [
+    appdirs
+  ];
+
+  nativeCheckInputs = [
+    pytestCheckHook
+  ];
+
+  pythonImportsCheck = [
+    "pypjlink"
+  ];
+
+  meta = {
+    description = "Python implementation of the PJLink protocol for controlling digital projectors";
+    homepage = "https://github.com/benoitlouy/pypjlink";
+    changelog = "https://github.com/benoitlouy/pypjlink/releases/tag/v${version}";
+    license = lib.licenses.asl20;
+    maintainers = [ lib.maintainers.jamiemagee ];
+  };
+}

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

···
 
 buildPythonPackage rec {
   pname = "pytenable";
-  version = "1.8.2";
+  version = "1.8.3";
   pyproject = true;
 
   disabled = pythonOlder "3.10";
···
     owner = "tenable";
     repo = "pyTenable";
     tag = version;
-    hash = "sha256-21vKR9W2Bpi+9YfmMQ+vgQIGchb7cYA2Sx493/XuYU0=";
+    hash = "sha256-91V2R29M/+kiosfkl5t6Y8qT/E041Wl1jhXCw3eQ7us=";
   };
 
   pythonRelaxDeps = [

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

···
 
 buildPythonPackage rec {
   pname = "python-roborock";
-  version = "2.27.0";
+  version = "2.29.1";
   pyproject = true;
 
   disabled = pythonOlder "3.11";
···
     owner = "humbertogontijo";
     repo = "python-roborock";
     tag = "v${version}";
-    hash = "sha256-3iNqeRCdkkL77hYlh+LRo8ZKExcpk075eBbnp8oJQ8w=";
+    hash = "sha256-6Y/nqgGZQgmgaMjdAcYEidhr2h913deWtBoWnQz966o=";
   };
 
   postPatch = ''

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

···
+{
+  lib,
+  buildPythonPackage,
+  fetchFromGitHub,
+  hatchling,
+  hatch-vcs,
+  aiohttp,
+}:
+
+buildPythonPackage rec {
+  pname = "pywmspro";
+  version = "0.3.2";
+  pyproject = true;
+
+  src = fetchFromGitHub {
+    owner = "mback2k";
+    repo = "pywmspro";
+    tag = version;
+    hash = "sha256-o/+WjdU9+Vh1CnZYF2IsNpK5cubAFvsqANZ4GxrKFHI=";
+  };
+
+  build-system = [
+    hatchling
+    hatch-vcs
+  ];
+
+  dependencies = [ aiohttp ];
+
+  # Package has no tests
+  doCheck = false;
+
+  pythonImportsCheck = [ "wmspro" ];
+
+  meta = {
+    description = "Python library for WMS WebControl pro API";
+    homepage = "https://github.com/mback2k/pywmspro";
+    license = lib.licenses.asl20;
+    maintainers = [ lib.maintainers.jamiemagee ];
+  };
+}

pkgs/development/python-modules/sagemaker-core/default.nix

···
 
 buildPythonPackage rec {
   pname = "sagemaker-core";
-  version = "1.0.47";
+  version = "1.0.49";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "aws";
     repo = "sagemaker-core";
     tag = "v${version}";
-    hash = "sha256-PfAv4w+egB0fIkL6nexjtoqcXyvnx52RTQu6QwKjpNU=";
+    hash = "sha256-xDtBtsrromqfciVOxGTTWhTZG08qUjk9EJ9yMvYS7+Y=";
   };
 
   build-system = [

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

···
 
 buildPythonPackage rec {
   pname = "storage3";
-  version = "0.12.0";
+  version = "0.12.1";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "supabase";
     repo = "storage-py";
-    rev = "v${version}";
-    hash = "sha256-3Z+j9n/seL1ZuB1djOVpA6Qci/Ygi9g8g2lLQGKRUHM=";
+    tag = "v${version}";
+    hash = "sha256-Ef309CTnzbaqKAVMdvroUYAy9RImWZZqhsnwRdpGVkk=";
   };
 
   dependencies = [

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

···
+{
+  lib,
+  buildPythonPackage,
+  fetchFromGitHub,
+  setuptools,
+  pyjwt,
+  pypasser,
+  requests,
+  pythonOlder,
+}:
+
+buildPythonPackage rec {
+  pname = "tami4edgeapi";
+  version = "3.0";
+  pyproject = true;
+
+  disabled = pythonOlder "3.7";
+
+  src = fetchFromGitHub {
+    owner = "Guy293";
+    repo = "Tami4EdgeAPI";
+    tag = "v${version}";
+    hash = "sha256-rhJ8L6qLDnO50Xp2eqquRinDTQjMxWVSjNL5GQI1gvM=";
+  };
+
+  build-system = [ setuptools ];
+
+  dependencies = [
+    pyjwt
+    pypasser
+    requests
+  ];
+
+  # Package has no tests
+  doCheck = false;
+
+  pythonImportsCheck = [ "Tami4EdgeAPI" ];
+
+  meta = {
+    description = "Python API client for Tami4 Edge / Edge+ devices";
+    homepage = "https://github.com/Guy293/Tami4EdgeAPI";
+    changelog = "https://github.com/Guy293/Tami4EdgeAPI/releases/tag/v${version}";
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.jamiemagee ];
+  };
+}

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

···
+{
+  lib,
+  buildPythonPackage,
+  docopt,
+  fetchFromGitHub,
+  poetry-core,
+  pytest-vcr,
+  pytestCheckHook,
+  requests,
+  setuptools,
+  vcrpy,
+}:
+
+buildPythonPackage rec {
+  pname = "thingspeak";
+  version = "1.0.0";
+  pyproject = true;
+
+  src = fetchFromGitHub {
+    owner = "mchwalisz";
+    repo = "thingspeak";
+    tag = "v${version}";
+    hash = "sha256-9YvudzksWp130hkG8WxiX9WHegAVH2TT1vwMbLJ13qE=";
+  };
+
+  postPatch = ''
+    substituteInPlace pyproject.toml \
+      --replace-fail "poetry.masonry.api" "poetry.core.masonry.api" \
+      --replace-fail 'requires = ["poetry>=0.12"]' 'requires = ["poetry-core"]'
+  '';
+
+  build-system = [
+    poetry-core
+  ];
+
+  dependencies = [
+    docopt
+    requests
+    setuptools
+  ];
+
+  nativeCheckInputs = [
+    pytest-vcr
+    pytestCheckHook
+    vcrpy
+  ];
+
+  disabledTests = [
+    # VCR cassette conflicts with different API keys
+    "test_get_with_key"
+  ];
+
+  pythonImportsCheck = [
+    "thingspeak"
+  ];
+
+  meta = {
+    description = "Client library for the thingspeak.com API";
+    homepage = "https://github.com/mchwalisz/thingspeak";
+    changelog = "https://github.com/mchwalisz/thingspeak/releases/tag/v${version}";
+    license = lib.licenses.lgpl3Only;
+    maintainers = [ lib.maintainers.jamiemagee ];
+  };
+}

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

···
+{
+  lib,
+  buildPythonPackage,
+  fetchFromGitHub,
+  pythonOlder,
+  aiohttp,
+  yarl,
+  hatchling,
+}:
+
+buildPythonPackage rec {
+  pname = "volvocarsapi";
+  version = "0.4.1";
+  pyproject = true;
+
+  disabled = pythonOlder "3.12";
+
+  src = fetchFromGitHub {
+    owner = "thomasddn";
+    repo = "volvo-cars-api";
+    tag = "v${version}";
+    hash = "sha256-YMrhVxDm8Cp8vbMVtdq6yoaAu8nUB7L2YG+LSkvMdZs=";
+  };
+
+  build-system = [
+    hatchling
+  ];
+
+  dependencies = [
+    aiohttp
+    yarl
+  ];
+
+  # Package has no tests
+  doCheck = false;
+
+  pythonImportsCheck = [
+    "volvocarsapi"
+  ];
+
+  meta = {
+    description = "Python client for the Volvo Cars API";
+    homepage = "https://github.com/thomasddn/volvo-cars-api";
+    changelog = "https://github.com/thomasddn/volvo-cars-api/releases/tag/v${version}";
+    license = lib.licenses.gpl3Only;
+    maintainers = [ lib.maintainers.jamiemagee ];
+  };
+}

pkgs/development/tools/electron/info.json

···
         "chromium": {
             "deps": {
                 "gn": {
-                    "hash": "sha256-EqbwCLkseND1v3UqM+49N7GuoXJ3PlJjWOes4OijQ3U=",
+                    "hash": "sha256-U0f/Q134UJrSke+/o9Hs4+mQa/vSM2hdkRXhLfhnqME=",
                     "rev": "ed1abc107815210dc66ec439542bee2f6cbabc00",
-                    "url": "https://gn.googlesource.com/gn",
-                    "version": "2025-01-13"
+                    "version": "0-unstable-2025-01-13"
                 }
             },
             "version": "134.0.6998.205"
···
         "chromium": {
             "deps": {
                 "gn": {
-                    "hash": "sha256-vDKMt23RMDI+KX6CmjfeOhRv2haf/mDOuHpWKnlODcg=",
+                    "hash": "sha256-MnGl+D9ahQibUHCtyOUf1snvmeupUn4D2yrDj55JTe4=",
                     "rev": "6e8e0d6d4a151ab2ed9b4a35366e630c55888444",
-                    "url": "https://gn.googlesource.com/gn",
-                    "version": "2025-03-24"
+                    "version": "0-unstable-2025-03-24"
                 }
             },
             "version": "136.0.7103.177"
···
         "chromium": {
             "deps": {
                 "gn": {
-                    "hash": "sha256-UB9a7Fr1W0yYld6WbXyRR8dFqWsj/zx4KumDZ5JQKSM=",
+                    "hash": "sha256-BplU8qNKObVrKMLKTyqivPF1L6bbJulFC+Zop9UpmZY=",
                     "rev": "ebc8f16ca7b0d36a3e532ee90896f9eb48e5423b",
-                    "url": "https://gn.googlesource.com/gn",
-                    "version": "2025-05-21"
+                    "version": "0-unstable-2025-05-21"
                 }
             },
             "version": "138.0.7204.185"

pkgs/development/tools/electron/update.py

···
 #! /usr/bin/env nix-shell
-#! nix-shell -i python -p python3.pkgs.joblib python3.pkgs.click python3.pkgs.click-log nix nix-prefetch-git prefetch-yarn-deps prefetch-npm-deps gclient2nix
+#! nix-shell -i python -p python3.pkgs.joblib python3.pkgs.click python3.pkgs.click-log nix nurl prefetch-yarn-deps prefetch-npm-deps gclient2nix
 """
 electron updater
 
···
 import click
 import click_log
 
-from datetime import datetime
+from datetime import datetime, UTC
 from typing import Iterable, Tuple
 from urllib.request import urlopen
 from joblib import Parallel, delayed, Memory
···
 
 os.chdir(os.path.dirname(__file__))
 
+# Absolute path of nixpkgs top-level directory
+NIXPKGS_PATH = subprocess.check_output(["git", "rev-parse", "--show-toplevel"]).decode("utf-8").strip()
+
 memory: Memory = Memory("cache", verbose=0)
 
 logger = logging.getLogger(__name__)
···
 
 
 @memory.cache
+def get_gn_hash(gn_version, gn_commit):
+    print("gn.override", file=sys.stderr)
+    expr = f'(import {NIXPKGS_PATH} {{}}).gn.override {{ version = "{gn_version}"; rev = "{gn_commit}"; hash = ""; }}'
+    out = subprocess.check_output(["nurl", "--hash", "--expr", expr])
+    return out.decode("utf-8").strip()
+
[e-mail]
 def get_chromium_gn_source(chromium_tag: str) -> dict:
     gn_pattern = r"'gn_version': 'git_revision:([0-9a-f]{40})'"
     gn_commit = re.search(gn_pattern, get_chromium_file(chromium_tag, "DEPS")).group(1)
-    gn_prefetch: bytes = subprocess.check_output(
-        [
-            "nix-prefetch-git",
-            "--quiet",
-            "https://gn.googlesource.com/gn",
-            "--rev",
-            gn_commit,
-        ]
+
+    gn_commit_info = json.loads(
+        urlopen(f"https://gn.googlesource.com/gn/+/{gn_commit}?format=json")
+        .read()
+        .decode("utf-8")
+        .split(")]}'\n")[1]
     )
-    gn: dict = json.loads(gn_prefetch)
+
+    gn_commit_date = datetime.strptime(gn_commit_info["commiter"]["time"], "%a %b %d %H:%M:%S %Y %z")
+    gn_date = gn_commit_date.astimezone(UTC).date().isoformat()
+    gn_version = f"0-unstable-{gn_date}"
+
     return {
         "gn": {
-            "version": datetime.fromisoformat(gn["date"]).date().isoformat(),
-            "url": gn["url"],
-            "rev": gn["rev"],
-            "hash": gn["hash"],
+            "version": gn_version,
+            "rev": gn_commit,
+            "hash": get_gn_hash(gn_version, gn_commit),
         }
     }
 

pkgs/os-specific/linux/kernel/generic.nix

···
         {
           structuredExtraConfig ? { },
           ...
-        }:
-        {
-          settings = structuredExtraConfig;
-        }
+        }@args:
+        if args ? extraStructuredConfig then
+          throw ''
+            Passing `extraStructuredConfig` to the Linux kernel (e.g.
+            via `boot.kernelPatches` in NixOS) is not supported anymore. Use
+            `structuredExtraConfig` instead.
+          ''
+        else
+          {
+            settings = structuredExtraConfig;
+          }
       ) kernelPatches;
 
       # appends kernel patches extraConfig

pkgs/os-specific/linux/kernel/zen-kernels.nix

···
   variants = {
     # ./update-zen.py zen
     zen = {
-      version = "6.15.8"; # zen
+      version = "6.16"; # zen
       suffix = "zen1"; # zen
-      sha256 = "010k50c9anjbcrwh9cgc6wn91hh3xa1x3mpxbaa2x1v8f5773vd4"; # zen
+      sha256 = "1ckysnshlrhfycz0yppna6jrnvgc9k49wr5srvl15wj1hck84p7d"; # zen
       isLqx = false;
     };
     # ./update-zen.py lqx

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

···
     ./0019-meson-Don-t-link-ssh-dropins.patch
 
     ./0020-install-unit_file_exists_full-follow-symlinks.patch
-
-    # add nspawn build option flag
-    # required to disable nspawn for systemdLibs to avoid dependency on getent
-    # https://github.com/systemd/systemd/pull/36876, remove for systemd 258
-    (fetchpatch {
-      # required for the actual patch to apply
-      url = "https://github.com/systemd/systemd/commit/b1fb2d971c810e0bdf9ff0ae567a1c6c230e4e5d.patch";
-      hash = "sha256-JBheazg1OFkx8vUl2l8+34BoEPVURBQJHxqntOBYB60=";
-      includes = [ "src/nspawn/meson.build" ];
-    })
-    (fetchpatch {
-      url = "https://github.com/systemd/systemd/commit/d95818f5221d9b9b19648cffa0cb2407f023b27e.patch";
-      hash = "sha256-FTpWGec5ivlkyEEDMCPaLE+BH91e7JI0kH8pS88bBDY=";
-      excludes = [ "test/fuzz/meson.build" ];
-    })
   ]
   ++ lib.optionals (stdenv.hostPlatform.isLinux && stdenv.hostPlatform.isGnu) [
     ./0021-timesyncd-disable-NSCD-when-DNSSEC-validation-is-dis.patch
···
     (lib.mesonEnable "gnutls" false)
     (lib.mesonEnable "xkbcommon" false)
     (lib.mesonEnable "man" true)
-    (lib.mesonEnable "nspawn" withNspawn)
+    # (lib.mesonEnable "nspawn" withNspawn) # nspawn build can be turned off on systemd 258, on 257.x it will just not be installed in systemdLibs but the build is unconditional
 
     (lib.mesonBool "analyze" withAnalyze)
     (lib.mesonBool "logind" withLogind)
···
       ]
       ++ lib.optionals withNspawn [
         {
+          # we only need to patch getent when nspawn will actually be built/installed
+          # as of systemd 257.x, nspawn will not be installed on systemdLibs, so we don't need to patch it
+          # patching getent unconditionally here introduces infinite recursion on musl
           search = "/usr/bin/getent";
           replacement = "${getent}/bin/getent";
           where = [ "src/nspawn/nspawn-setuid.c" ];

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

···
       ];
     "airos" =
       ps: with ps; [
-      ]; # missing inputs: airos
+        airos
+      ];
     "airq" =
       ps: with ps; [
         aioairq
···
       ];
     "itach" =
       ps: with ps; [
-      ]; # missing inputs: pyitachip2ir
+        pyitachip2ir
+      ];
     "itunes" =
       ps: with ps; [
       ];
···
       ];
     "pjlink" =
       ps: with ps; [
-      ]; # missing inputs: pypjlink2
+        pypjlink2
+      ];
     "plaato" =
       ps: with ps; [
         aiohasupervisor
···
       ];
     "tami4" =
       ps: with ps; [
-      ]; # missing inputs: Tami4EdgeAPI
+        tami4edgeapi
+      ];
     "tank_utility" =
       ps: with ps; [
         tank-utility
···
       ];
     "thingspeak" =
       ps: with ps; [
-      ]; # missing inputs: thingspeak
+        thingspeak
+      ];
     "thinkingcleaner" =
       ps: with ps; [
       ]; # missing inputs: pythinkingcleaner
···
       ];
     "volvo" =
       ps: with ps; [
-      ]; # missing inputs: volvocarsapi
+        volvocarsapi
+      ];
     "volvooncall" =
       ps: with ps; [
         volvooncall
···
       ];
     "wmspro" =
       ps: with ps; [
-      ]; # missing inputs: pywmspro
+        pywmspro
+      ];
     "wolflink" =
       ps: with ps; [
         wolf-comm
···
     "airgradient"
     "airly"
     "airnow"
+    "airos"
     "airq"
     "airthings"
     "airthings_ble"
···
     "pi_hole"
     "picnic"
     "ping"
+    "pjlink"
     "plaato"
     "plant"
     "playstation_network"
···
     "tag"
     "tailscale"
     "tailwind"
+    "tami4"
     "tankerkoenig"
     "tasmota"
     "tautulli"
···
     "voicerss"
     "voip"
     "volumio"
+    "volvo"
     "volvooncall"
     "vulcan"
     "vultr"
···
     "withings"
     "wiz"
     "wled"
+    "wmspro"
     "wolflink"
     "workday"
     "worldclock"

pkgs/servers/home-assistant/custom-components/fellow/package.nix

···
 buildHomeAssistantComponent {
   owner = "NewsGuyTor";
   domain = "fellow";
-  version = "0.3.2";
+  version = "0-unstable-2025-08-06";
 
   src = fetchFromGitHub {
     owner = "NewsGuyTor";
     repo = "FellowAiden-HomeAssistant";
-    rev = "2268880c7727b1d2e488dcebbdc5b2675d664ddf";
-    hash = "sha256-Wg6EFUQNhlK2GQjC90c5lA3b/y40LhXdInba/iTtUWc=";
+    rev = "bb0f3042e974a149a3597d06312e6be9b8d265ff";
+    hash = "sha256-cplIiFt0CkeOXjypvG0MR/t7PWzeaa2G6uScWSLbEpo=";
   };
 
   passthru.updateScript = unstableGitUpdater { };

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

···
 
 buildGoModule rec {
   pname = "redis_exporter";
-  version = "1.74.0";
+  version = "1.75.0";
 
   src = fetchFromGitHub {
     owner = "oliver006";
     repo = "redis_exporter";
     rev = "v${version}";
-    sha256 = "sha256-TPMbRyz476ylo6OEYYtLQCNL01dLShnJu0ncVgzL5kY=";
+    sha256 = "sha256-Z74AB3loT6KJgJBXGh3q1v49ro0gXPvIwd3URRikUa0=";
   };
 
-  vendorHash = "sha256-q/RMdGFwZuFnjE0txb7ShhHlxLpLNF5S6KmmAKKYnaE=";
+  vendorHash = "sha256-y1j7s8R8pd3sp9yOlG2aopQ+GNO2Z7OCO1a9i9L6KM4=";
 
   ldflags = [
     "-X main.BuildVersion=${version}"

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

···
 
 postgresqlBuildExtension (finalAttrs: {
   pname = "pg_net";
-  version = "0.19.4";
+  version = "0.19.5";
 
   src = fetchFromGitHub {
     owner = "supabase";
     repo = "pg_net";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-uHsfRQ5RKhTvqokF94s/RzTQ23BRTBV+yyIW41Djjgo=";
+    hash = "sha256-Cpi2iASi1QJoED0Qs1dANqg/BNZTsz5S+pw8iYyW03Y=";
   };
 
   buildInputs = [ curl ];

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

···
 
 postgresqlBuildExtension (finalAttrs: {
   pname = "timescaledb${lib.optionalString (!enableUnfree) "-apache"}";
-  version = "2.21.1";
+  version = "2.21.2";
 
   src = fetchFromGitHub {
     owner = "timescale";
     repo = "timescaledb";
     tag = finalAttrs.version;
-    hash = "sha256-oZaEUz6g/8oVdVyPCkAE0quzYBxO911MZcgd8rFFA3c=";
+    hash = "sha256-pNF75Wh8WMXqxjU19KBiH/jYzT/4uBYuUMH1vRilU94=";
   };
 
   nativeBuildInputs = [ cmake ];
···
       ||
         # PostgreSQL 18 support issue upstream: https://github.com/timescale/timescaledb/issues/8233
         # Check after next package update.
-        lib.warnIf (finalAttrs.version != "2.21.1") "Is postgresql18Packages.timescaledb still broken?" (
+        lib.warnIf (finalAttrs.version != "2.21.2") "Is postgresql18Packages.timescaledb still broken?" (
           lib.versionAtLeast postgresql.version "18"
         );
   };

pkgs/tools/security/pinentry/default.nix

···
     in
     stdenv.mkDerivation rec {
       pname = "pinentry-${pinentryExtraPname}";
-      version = "1.3.1";
+      version = "1.3.2";
 
       src = fetchurl {
         url = "mirror://gnupg/pinentry/pinentry-${version}.tar.bz2";
-        hash = "sha256-vHLuJ8cjkAerGJbDwvrlOwduLJvSSD3CdpoWkCvOjAQ=";
+        hash = "sha256-jphu2IVhtNpunv4MVPpMqJIwNcmSZN8LBGRJfF+5Tp4=";
       };
 
       nativeBuildInputs = [

pkgs/top-level/python-packages.nix

···
 
   airly = callPackage ../development/python-modules/airly { };
 
+  airos = callPackage ../development/python-modules/airos { };
+
   airportsdata = callPackage ../development/python-modules/airportsdata { };
 
   airthings-ble = callPackage ../development/python-modules/airthings-ble { };
···
 
   pyisy = callPackage ../development/python-modules/pyisy { };
 
+  pyitachip2ir = callPackage ../development/python-modules/pyitachip2ir { };
+
   pyituran = callPackage ../development/python-modules/pyituran { };
 
   pyixapi = callPackage ../development/python-modules/pyixapi { };
···
 
   pypass = callPackage ../development/python-modules/pypass { };
 
+  pypasser = callPackage ../development/python-modules/pypasser { };
+
   pypblib = callPackage ../development/python-modules/pypblib { };
 
   pypca = callPackage ../development/python-modules/pypca { };
···
   pypiserver = callPackage ../development/python-modules/pypiserver { };
 
   pypitoken = callPackage ../development/python-modules/pypitoken { };
+
+  pypjlink2 = callPackage ../development/python-modules/pypjlink2 { };
 
   pyplaato = callPackage ../development/python-modules/pyplaato { };
 
···
 
   pywlroots = callPackage ../development/python-modules/pywlroots { wlroots = pkgs.wlroots_0_17; };
 
+  pywmspro = callPackage ../development/python-modules/pywmspro { };
+
   pyworld = callPackage ../development/python-modules/pyworld { };
 
   pyws66i = callPackage ../development/python-modules/pyws66i { };
···
 
   takethetime = callPackage ../development/python-modules/takethetime { };
 
+  tami4edgeapi = callPackage ../development/python-modules/tami4edgeapi { };
+
   tank-utility = callPackage ../development/python-modules/tank-utility { };
 
   tappy = callPackage ../development/python-modules/tappy { };
···
   thespian = callPackage ../development/python-modules/thespian { };
 
   thinc = callPackage ../development/python-modules/thinc { };
+
+  thingspeak = callPackage ../development/python-modules/thingspeak { };
 
   thinqconnect = callPackage ../development/python-modules/thinqconnect { };
 
···
   voluptuous-serialize = callPackage ../development/python-modules/voluptuous-serialize { };
 
   voluptuous-stubs = callPackage ../development/python-modules/voluptuous-stubs { };
+
+  volvocarsapi = callPackage ../development/python-modules/volvocarsapi { };
 
   volvooncall = callPackage ../development/python-modules/volvooncall { };