Merge staging-next into staging

nixos/modules/programs/neovim.nix

···
             };
 
             source = mkOption {
-              type = types.path;
+              default = null;
+              type = types.nullOr types.path;
               description = lib.mdDoc "Path of the source file.";
             };
 
···
     environment.etc = listToAttrs (attrValues (mapAttrs
       (name: value: {
         name = "xdg/nvim/${name}";
-        value = value // {
-          target = "xdg/nvim/${value.target}";
-        };
+        value = removeAttrs
+          (value // {
+            target = "xdg/nvim/${value.target}";
+          })
+          (optionals (isNull value.source) [ "source" ]);
       })
       cfg.runtime));
 

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

···
     meta.homepage = "https://github.com/chikamichi/mediawiki.vim/";
   };
 
+  melange-nvim = buildVimPluginFrom2Nix {
+    pname = "melange-nvim";
+    version = "2023-04-06";
+    src = fetchFromGitHub {
+      owner = "savq";
+      repo = "melange-nvim";
+      rev = "f15922543dd70b360335effb61411c05c710b99c";
+      sha256 = "19swmv0xzlxp7bcmgdm2qfam28wi9igqvfn5q7wq8qshb2wqzph1";
+    };
+    meta.homepage = "https://github.com/savq/melange-nvim/";
+  };
+
   mini-nvim = buildVimPluginFrom2Nix {
     pname = "mini.nvim";
     version = "2023-05-07";

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

···
 https://github.com/kaicataldo/material.vim/,HEAD,
 https://github.com/vim-scripts/mayansmoke/,,
 https://github.com/chikamichi/mediawiki.vim/,HEAD,
+https://github.com/savq/melange-nvim/,,
 https://github.com/echasnovski/mini.nvim/,,
 https://github.com/wfxr/minimap.vim/,,
 https://github.com/jose-elias-alvarez/minsnip.nvim/,,

pkgs/applications/graphics/shotwell/default.nix

···
 , libsecret
 , libportal-gtk3
 , gsettings-desktop-schemas
-, python3
 }:
 
 # for dependencies see https://wiki.gnome.org/Apps/Shotwell/BuildingAndInstalling
 
 stdenv.mkDerivation rec {
   pname = "shotwell";
-  version = "0.32.0";
+  version = "0.32.1";
 
   src = fetchurl {
     url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
-    sha256 = "sha256-F3Ky+h56VHnVKAKLyaMD8oVeHZWaWzyReSLmOpipCxk=";
+    sha256 = "sha256-SsRRdBatiqI7ROdcNL1uFrq3Nj+iCZG7CbrN+rP3Y84=";
   };
 
   nativeBuildInputs = [
···
     itstool
     gettext
     desktop-file-utils
-    python3
     wrapGAppsHook
     gobject-introspection
   ];
···
     libsecret
     libportal-gtk3
   ];
-
-  postPatch = ''
-    chmod +x build-aux/meson/postinstall.py # patchShebangs requires executable file
-    patchShebangs build-aux/meson/postinstall.py
-  '';
 
   passthru = {
     updateScript = gnome.updateScript {

pkgs/applications/misc/neo4j-desktop/default.nix

···
 { appimageTools, lib, fetchurl }:
 let
   pname = "neo4j-desktop";
-  version = "1.5.7";
+  version = "1.5.8";
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "https://s3-eu-west-1.amazonaws.com/dist.neo4j.org/${pname}/linux-offline/${name}-x86_64.AppImage";
-    hash = "sha256-5sIlLPfcoX5I4TBGKR8+WAo/xC6b9RP6ljhyTil1xJM=";
+    hash = "sha256-RqzR4TuvDasbkj/wKvOOS7r46sXDxvw3B5ydFGZeHX8=";
   };
 
   appimageContents = appimageTools.extract { inherit name src; };

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

···
 in
 stdenv.mkDerivation rec {
   pname = "opera";
-  version = "98.0.4759.15";
+  version = "98.0.4759.39";
 
   src = fetchurl {
     url = "${mirror}/${version}/linux/${pname}-stable_${version}_amd64.deb";
-    hash = "sha256-nv6/RXsF8rvYoCfsUC1xR79ssroAkfBqzADi02AfYH8=";
+    hash = "sha256-3HVgEOscds+VBn9ajmkRnPdqNi9lLItJrb3uRH6L96Q=";
   };
 
   unpackPhase = "dpkg-deb -x $src .";

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

···
 
 buildGoModule rec {
   pname = "pachyderm";
-  version = "2.5.5";
+  version = "2.6.0";
 
   src = fetchFromGitHub {
     owner = "pachyderm";
     repo = "pachyderm";
     rev = "v${version}";
-    hash = "sha256-RaMOn5Cb98wKI9w0+kVUCMiySKGuudXHsi+EXFIm3Zc=";
+    hash = "sha256-QWlNDnhcFXfCtX4J0V/hq6nFN0RjzYv29mI2zE2fyFo=";
   };
 
-  vendorHash = "sha256-XmIPifozTYd1rV2wm0dU0GPvg/+HFoSLGHB6DDrkzVc=";
+  vendorHash = "sha256-3EG9d4ERaWuHaKFt0KFCOKIgTdrL7HZTO+GSi2RROKY=";
 
   subPackages = [ "src/server/cmd/pachctl" ];
 

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

···
 
 buildGoModule rec {
   pname = "waypoint";
-  version = "0.11.0";
+  version = "0.11.1";
 
   src = fetchFromGitHub {
     owner = "hashicorp";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-FI6QXQ0n/vvzUJTBbPDh9nMyAdcfTzpX79RxQEbFDUs=";
+    sha256 = "sha256-8fMhwJWINazLQou/i6/BZiPtsBJLmEEX9J1EZ0rsTh8=";
   };
 
-  vendorHash = "sha256-t8PzimNW7JWvWU3lZHo+b5K3R6he35HhBQPu1hxK51U=";
+  vendorHash = "sha256-er1Qvnda8pTpWuvkiFhugZ6li82ljg9mk/HrtH22laA=";
 
   nativeBuildInputs = [ go-bindata installShellFiles ];
 

pkgs/applications/office/wpsoffice/default.nix

···
 , cups
 , udev
 , xorg
+, pango
 , makeWrapper
 , useChineseVersion ? false
 }:
···
     udev
   ];
 
-  runtimeDependencies = [
-    cups.lib
+  runtimeDependencies = map lib.getLib [
+    cups
+    pango
   ];
 
   installPhase = ''

pkgs/applications/virtualization/docker-slim/default.nix

···
 
 buildGoModule rec {
   pname = "docker-slim";
-  version = "1.40.1";
+  version = "1.40.2";
 
   src = fetchFromGitHub {
     owner = "slimtoolkit";
     repo = "slim";
     rev = version;
-    hash = "sha256-ec5Qedt6NrcWZilcN9dhosAN59orgS2xxjXWO9XDxVE=";
+    hash = "sha256-pRIfIgEM0olUi0LL8maB7vczcq4p67eDuWssoeOT4Tk=";
   };
 
   vendorHash = null;

pkgs/data/fonts/julia-mono/default.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "JuliaMono-ttf";
-  version = "0.048";
+  version = "0.049";
 
   src = fetchzip {
     url = "https://github.com/cormullion/juliamono/releases/download/v${version}/${pname}.tar.gz";
     stripRoot = false;
-    hash = "sha256-KSyJMlQclEj2CR+5uSYLmPtseWiDIUuahaPDx7Tn/bw=";
+    hash = "sha256-UTiuWbRUJVGEuqNj2EU6VBb8Y4FO08TA2Nk7cjsjmuM=";
   };
 
   installPhase = ''

pkgs/development/compilers/gcc/13/Added-mcf-thread-model-support-from-mcfgthread.patch

···
+From 86f2f767ddffd9f7c6f1470b987ae7b0d251b988 Mon Sep 17 00:00:00 2001
+From: Liu Hao <[e-mail]>
+Date: Wed, 25 Apr 2018 21:54:19 +0800
+Subject: [PATCH] Added 'mcf' thread model support from mcfgthread.
+
+Signed-off-by: Liu Hao <[e-mail]>
+---
+ config/gthr.m4                          |  1 +
+ gcc/config.gcc                          |  3 +++
+ gcc/config/i386/mingw-mcfgthread.h      |  1 +
+ gcc/config/i386/mingw-w64.h             |  2 +-
+ gcc/config/i386/mingw32.h               | 11 ++++++++++-
+ gcc/configure                           |  2 +-
+ gcc/configure.ac                        |  2 +-
+ libatomic/configure.tgt                 |  2 +-
+ libgcc/config.host                      |  6 ++++++
+ libgcc/config/i386/gthr-mcf.h           |  1 +
+ libgcc/config/i386/t-mingw-mcfgthread   |  2 ++
+ libgcc/configure                        |  1 +
+ libstdc++-v3/configure                  |  1 +
+ libstdc++-v3/libsupc++/atexit_thread.cc | 18 ++++++++++++++++++
+ libstdc++-v3/libsupc++/guard.cc         | 23 +++++++++++++++++++++++
+ libstdc++-v3/src/c++11/thread.cc        |  9 +++++++++
+ 16 files changed, 80 insertions(+), 5 deletions(-)
+ create mode 100644 gcc/config/i386/mingw-mcfgthread.h
+ create mode 100644 libgcc/config/i386/gthr-mcf.h
+ create mode 100644 libgcc/config/i386/t-mingw-mcfgthread
+
+diff --git a/config/gthr.m4 b/config/gthr.m4
+index 7b29f1f3327..82e21fe1709 100644
+--- a/config/gthr.m4
++++ b/config/gthr.m4
+@@ -21,6 +21,7 @@ case $1 in
+     tpf)	thread_header=config/s390/gthr-tpf.h ;;
+     vxworks)	thread_header=config/gthr-vxworks.h ;;
+     win32)	thread_header=config/i386/gthr-win32.h ;;
++    mcf)	thread_header=config/i386/gthr-mcf.h ;;
+ esac
+ AC_SUBST(thread_header)
+ ])
+diff --git a/gcc/config.gcc b/gcc/config.gcc
+index 46a9029acec..112c24e95a3 100644
+--- a/gcc/config.gcc
++++ b/gcc/config.gcc
+@@ -1758,6 +1758,9 @@ i[34567]86-*-mingw* | x86_64-*-mingw*)
+ 	if test x$enable_threads = xposix ; then
+ 		tm_file="${tm_file} i386/mingw-pthread.h"
+ 	fi
++	if test x$enable_threads = xmcf ; then
++		tm_file="${tm_file} i386/mingw-mcfgthread.h"
++	fi
+ 	tm_file="${tm_file} i386/mingw32.h"
+ 	# This makes the logic if mingw's or the w64 feature set has to be used
+ 	case ${target} in
+diff --git a/gcc/config/i386/mingw-mcfgthread.h b/gcc/config/i386/mingw-mcfgthread.h
+new file mode 100644
+index 00000000000..ec381a7798f
+--- /dev/null
++++ b/gcc/config/i386/mingw-mcfgthread.h
+@@ -0,0 +1 @@
++#define TARGET_USE_MCFGTHREAD 1
+diff --git a/gcc/config/i386/mingw-w64.h b/gcc/config/i386/mingw-w64.h
+index 484dc7a9e9f..a15bbeea500 100644
+--- a/gcc/config/i386/mingw-w64.h
++++ b/gcc/config/i386/mingw-w64.h
+@@ -48,7 +48,7 @@ along with GCC; see the file COPYING3.  If not see
+ 		 "%{mwindows:-lgdi32 -lcomdlg32} " \
+      "%{fvtable-verify=preinit:-lvtv -lpsapi; \
+         fvtable-verify=std:-lvtv -lpsapi} " \
+-		 "-ladvapi32 -lshell32 -luser32 -lkernel32"
++		 LIB_MCFGTHREAD "-ladvapi32 -lshell32 -luser32 -lkernel32"
+ 
+ #undef SPEC_32
+ #undef SPEC_64
+diff --git a/gcc/config/i386/mingw32.h b/gcc/config/i386/mingw32.h
+index 0612b87199a..76cea94f3b7 100644
+--- a/gcc/config/i386/mingw32.h
++++ b/gcc/config/i386/mingw32.h
+@@ -32,6 +32,14 @@ along with GCC; see the file COPYING3.  If not see
+ 	 | MASK_STACK_PROBE | MASK_ALIGN_DOUBLE \
+ 	 | MASK_MS_BITFIELD_LAYOUT)
+ 
++#ifndef TARGET_USE_MCFGTHREAD
++#define CPP_MCFGTHREAD()  ((void)0)
++#define LIB_MCFGTHREAD     ""
++#else
++#define CPP_MCFGTHREAD()  (builtin_define("__USING_MCFGTHREAD__"))
++#define LIB_MCFGTHREAD     " -lmcfgthread "
++#endif
++
+ /* See i386/crtdll.h for an alternative definition. _INTEGRAL_MAX_BITS
+    is for compatibility with native compiler.  */
+ #define EXTRA_OS_CPP_BUILTINS()					\
+@@ -50,6 +58,7 @@ along with GCC; see the file COPYING3.  If not see
+ 	  builtin_define_std ("WIN64");				\
+ 	  builtin_define ("_WIN64");				\
+ 	}							\
++	CPP_MCFGTHREAD();	\
+     }								\
+   while (0)
+ 
+@@ -93,7 +102,7 @@ along with GCC; see the file COPYING3.  If not see
+ 		 "%{mwindows:-lgdi32 -lcomdlg32} " \
+      "%{fvtable-verify=preinit:-lvtv -lpsapi; \
+         fvtable-verify=std:-lvtv -lpsapi} " \
+-                 "-ladvapi32 -lshell32 -luser32 -lkernel32"
++                 LIB_MCFGTHREAD "-ladvapi32 -lshell32 -luser32 -lkernel32"
+ 
+ /* Weak symbols do not get resolved if using a Windows dll import lib.
+    Make the unwind registration references strong undefs.  */
+diff --git a/gcc/configure b/gcc/configure
+index 6121e163259..52f0e00efe6 100755
+--- a/gcc/configure
++++ b/gcc/configure
+@@ -11693,7 +11693,7 @@ case ${enable_threads} in
+     target_thread_file='single'
+     ;;
+   aix | dce | lynx | mipssde | posix | rtems | \
+-  single | tpf | vxworks | win32)
++  single | tpf | vxworks | win32 | mcf)
+     target_thread_file=${enable_threads}
+     ;;
+   *)
+diff --git a/gcc/configure.ac b/gcc/configure.ac
+index b066cc609e1..4ecdba88de7 100644
+--- a/gcc/configure.ac
++++ b/gcc/configure.ac
+@@ -1612,7 +1612,7 @@ case ${enable_threads} in
+     target_thread_file='single'
+     ;;
+   aix | dce | lynx | mipssde | posix | rtems | \
+-  single | tpf | vxworks | win32)
++  single | tpf | vxworks | win32 | mcf)
+     target_thread_file=${enable_threads}
+     ;;
+   *)
+diff --git a/libatomic/configure.tgt b/libatomic/configure.tgt
+index ea8c34f8c71..23134ad7363 100644
+--- a/libatomic/configure.tgt
++++ b/libatomic/configure.tgt
+@@ -145,7 +145,7 @@ case "${target}" in
+   *-*-mingw*)
+ 	# OS support for atomic primitives.
+         case ${target_thread_file} in
+-          win32)
++          win32 | mcf)
+             config_path="${config_path} mingw"
+             ;;
+           posix)
+diff --git a/libgcc/config.host b/libgcc/config.host
+index 11b4acaff55..9fbd38650bd 100644
+--- a/libgcc/config.host
++++ b/libgcc/config.host
+@@ -737,6 +737,9 @@ i[34567]86-*-mingw*)
+ 	  posix)
+ 	    tmake_file="i386/t-mingw-pthread $tmake_file"
+ 	    ;;
++	  mcf)
++	    tmake_file="i386/t-mingw-mcfgthread $tmake_file"
++	    ;;
+ 	esac
+ 	# This has to match the logic for DWARF2_UNWIND_INFO in gcc/config/i386/cygming.h
+ 	if test x$ac_cv_sjlj_exceptions = xyes; then
+@@ -761,6 +764,9 @@ x86_64-*-mingw*)
+ 	  posix)
+ 	    tmake_file="i386/t-mingw-pthread $tmake_file"
+ 	    ;;
++	  mcf)
++	    tmake_file="i386/t-mingw-mcfgthread $tmake_file"
++	    ;;
+ 	esac
+ 	# This has to match the logic for DWARF2_UNWIND_INFO in gcc/config/i386/cygming.h
+ 	if test x$ac_cv_sjlj_exceptions = xyes; then
+diff --git a/libgcc/config/i386/gthr-mcf.h b/libgcc/config/i386/gthr-mcf.h
+new file mode 100644
+index 00000000000..5ea2908361f
+--- /dev/null
++++ b/libgcc/config/i386/gthr-mcf.h
+@@ -0,0 +1 @@
++#include <mcfgthread/gthread.h>
+diff --git a/libgcc/config/i386/t-mingw-mcfgthread b/libgcc/config/i386/t-mingw-mcfgthread
+new file mode 100644
+index 00000000000..4b9b10e32d6
+--- /dev/null
++++ b/libgcc/config/i386/t-mingw-mcfgthread
+@@ -0,0 +1,2 @@
++SHLIB_PTHREAD_CFLAG =
++SHLIB_PTHREAD_LDFLAG = -lmcfgthread
+diff --git a/libgcc/configure b/libgcc/configure
+index b2f3f870844..eff889dc3b3 100644
+--- a/libgcc/configure
++++ b/libgcc/configure
+@@ -5451,6 +5451,7 @@ case $target_thread_file in
+     tpf)	thread_header=config/s390/gthr-tpf.h ;;
+     vxworks)	thread_header=config/gthr-vxworks.h ;;
+     win32)	thread_header=config/i386/gthr-win32.h ;;
++    mcf)	thread_header=config/i386/gthr-mcf.h ;;
+ esac
+ 
+ 
+diff --git a/libstdc++-v3/configure b/libstdc++-v3/configure
+index ba094be6f15..979a5ab9ace 100755
+--- a/libstdc++-v3/configure
++++ b/libstdc++-v3/configure
+@@ -15187,6 +15187,7 @@ case $target_thread_file in
+     tpf)	thread_header=config/s390/gthr-tpf.h ;;
+     vxworks)	thread_header=config/gthr-vxworks.h ;;
+     win32)	thread_header=config/i386/gthr-win32.h ;;
++    mcf)	thread_header=config/i386/gthr-mcf.h ;;
+ esac
+ 
+ 
+diff --git a/libstdc++-v3/libsupc++/atexit_thread.cc b/libstdc++-v3/libsupc++/atexit_thread.cc
+index de920d714c6..665fb74bd6b 100644
+--- a/libstdc++-v3/libsupc++/atexit_thread.cc
++++ b/libstdc++-v3/libsupc++/atexit_thread.cc
+@@ -25,6 +25,22 @@
+ #include <cstdlib>
+ #include <new>
+ #include "bits/gthr.h"
++
++#ifdef __USING_MCFGTHREAD__
++
++#include <mcfgthread/gthread.h>
++namespace __cxxabiv1 {
++extern "C" int
++__cxa_thread_atexit (void (_GLIBCXX_CDTOR_CALLABI *dtor)(void *),
++				 void *obj, void *dso_handle)
++  _GLIBCXX_NOTHROW
++{
++  return ::_MCFCRT_AtThreadExit((void (*)(_MCFCRT_STD intptr_t))dtor, (_MCFCRT_STD intptr_t)obj) ? 0 : -1;
++  (void)dso_handle;
++}
++}
++#else // __USING_MCFGTHREAD__
++
+ #ifdef _GLIBCXX_THREAD_ATEXIT_WIN32
+ #define WIN32_LEAN_AND_MEAN
+ #include <windows.h>
+@@ -167,3 +183,5 @@ __cxxabiv1::__cxa_thread_atexit (void (*dtor)(void *), void *obj, void */*dso_ha
+ }
+ 
+ #endif /* _GLIBCXX_HAVE___CXA_THREAD_ATEXIT_IMPL */
++
++#endif // __USING_MCFGTHREAD__
+diff --git a/libstdc++-v3/libsupc++/guard.cc b/libstdc++-v3/libsupc++/guard.cc
+index 3a2ec3ad0d6..8b4cc96199b 100644
+--- a/libstdc++-v3/libsupc++/guard.cc
++++ b/libstdc++-v3/libsupc++/guard.cc
+@@ -28,6 +28,27 @@
+ #include <cxxabi.h>
+ #include <exception>
+ #include <new>
++
++#ifdef __USING_MCFGTHREAD__
++
++#include <mcfgthread/gthread.h>
++
++namespace __cxxabiv1 {
++
++extern "C" int __cxa_guard_acquire(__guard *g){
++	return ::_MCFCRT_WaitForOnceFlagForever((::_MCFCRT_OnceFlag *)g) == ::_MCFCRT_kOnceResultInitial;
++}
++extern "C" void __cxa_guard_abort(__guard *g) throw() {
++	::_MCFCRT_SignalOnceFlagAsAborted((::_MCFCRT_OnceFlag *)g);
++}
++extern "C" void __cxa_guard_release(__guard *g) throw() {
++	::_MCFCRT_SignalOnceFlagAsFinished((::_MCFCRT_OnceFlag *)g);
++}
++
++}
++
++#else // __USING_MCFGTHREAD__
++
+ #include <ext/atomicity.h>
+ #include <ext/concurrence.h>
+ #include <bits/atomic_lockfree_defines.h>
+@@ -425,3 +446,5 @@ namespace __cxxabiv1
+ #endif
+   }
+ }
++
++#endif
+diff --git a/libstdc++-v3/src/c++11/thread.cc b/libstdc++-v3/src/c++11/thread.cc
+index 8238817c2e9..0c6a1f85f6f 100644
+--- a/libstdc++-v3/src/c++11/thread.cc
++++ b/libstdc++-v3/src/c++11/thread.cc
+@@ -55,6 +55,15 @@ static inline int get_nprocs()
+ #elif defined(_GLIBCXX_USE_SC_NPROC_ONLN)
+ # include <unistd.h>
+ # define _GLIBCXX_NPROCS sysconf(_SC_NPROC_ONLN)
++#elif defined(_WIN32)
++# include <windows.h>
++static inline int get_nprocs()
++{
++  SYSTEM_INFO sysinfo;
++  GetSystemInfo(&sysinfo);
++  return (int)sysinfo.dwNumberOfProcessors;
++}
++# define _GLIBCXX_NPROCS get_nprocs()
+ #else
+ # define _GLIBCXX_NPROCS 0
+ #endif
+-- 
+2.17.0
+

pkgs/development/compilers/gcc/13/default.nix

···
+{ lib, stdenv, targetPackages, fetchurl, fetchpatch, noSysDirs
+, langC ? true, langCC ? true, langFortran ? false
+, langAda ? false
+, langObjC ? stdenv.targetPlatform.isDarwin
+, langObjCpp ? stdenv.targetPlatform.isDarwin
+, langD ? false
+, langGo ? false
+, reproducibleBuild ? true
+, profiledCompiler ? false
+, langJit ? false
+, staticCompiler ? false
+, enableShared ? !stdenv.targetPlatform.isStatic
+, enableLTO ? !stdenv.hostPlatform.isStatic
+, texinfo ? null
+, perl ? null # optional, for texi2pod (then pod2man)
+, gmp, mpfr, libmpc, gettext, which, patchelf, binutils
+, isl ? null # optional, for the Graphite optimization framework.
+, zlib ? null
+, libucontext ? null
+, gnat-bootstrap ? null
+, enableMultilib ? false
+, enablePlugin ? stdenv.hostPlatform == stdenv.buildPlatform # Whether to support user-supplied plug-ins
+, name ? "gcc"
+, libcCross ? null
+, threadsCross ? null # for MinGW
+, crossStageStatic ? false
+, gnused ? null
+, cloog # unused; just for compat with gcc4, as we override the parameter on some places
+, buildPackages
+, libxcrypt
+, disableGdbPlugin ? !enablePlugin
+, nukeReferences
+, callPackage
+}:
+
+# Make sure we get GNU sed.
+assert stdenv.buildPlatform.isDarwin -> gnused != null;
+
+# The go frontend is written in c++
+assert langGo -> langCC;
+assert langAda -> gnat-bootstrap != null;
+
+# TODO: fixup D bootstapping, probably by using gdc11 (and maybe other changes).
+#   error: GDC is required to build d
+assert !langD;
+
+# threadsCross is just for MinGW
+assert threadsCross != {} -> stdenv.targetPlatform.isWindows;
+
+# profiledCompiler builds inject non-determinism in one of the compilation stages.
+# If turned on, we can't provide reproducible builds anymore
+assert reproducibleBuild -> profiledCompiler == false;
+
+with lib;
+with builtins;
+
+let majorVersion = "13";
+    version = "${majorVersion}.1.0";
+    disableBootstrap = !stdenv.hostPlatform.isDarwin && !profiledCompiler;
+
+    inherit (stdenv) buildPlatform hostPlatform targetPlatform;
+
+    patches =
+         optional (targetPlatform != hostPlatform) ../libstdc++-target.patch
+      ++ optional noSysDirs ../gcc-12-no-sys-dirs.patch
+      ++ optional noSysDirs ../no-sys-dirs-riscv.patch
+      ++ [
+        ../gnat-cflags-11.patch
+        ../gcc-12-gfortran-driving.patch
+        ../ppc-musl.patch
+      ]
+      # We only apply this patch when building a native toolchain for aarch64-darwin, as it breaks building
+      # a foreign one: https://github.com/iains/gcc-12-branch/issues/18
+      ++ optional (stdenv.isDarwin && stdenv.isAarch64 && buildPlatform == hostPlatform && hostPlatform == targetPlatform) (fetchpatch {
+        name = "gcc-13-darwin-aarch64-support.patch";
+        url = "https://github.com/Homebrew/formula-patches/raw/5c206c47e2a08d522ec9795bb314346fff5fc4c5/gcc/gcc-13.1.0.diff";
+        sha256 = "sha256-sMgA7nwE2ULa54t5g6VE6eJQYa69XvQrefi9U9f2t4g=";
+      })
+      ++ optional langD ../libphobos.patch
+
+      # backport fixes to build gccgo with musl libc
+      ++ optionals (langGo && stdenv.hostPlatform.isMusl) [
+        (fetchpatch {
+          excludes = [ "gcc/go/gofrontend/MERGE" ];
+          url = "https://github.com/gcc-mirror/gcc/commit/cf79b1117bd177d3d4c6ed24b6fa243c3628ac2d.diff";
+          hash = "sha256-mS5ZiYi5D8CpGXrWg3tXlbhp4o86ew1imCTwaHLfl+I=";
+        })
+        (fetchpatch {
+          excludes = [ "gcc/go/gofrontend/MERGE" ];
+          url = "https://github.com/gcc-mirror/gcc/commit/7f195a2270910a6ed08bd76e3a16b0a6503f9faf.diff";
+          hash = "sha256-Ze/cFM0dQofKH00PWPDoklXUlwWhwA1nyTuiDAZ6FKo=";
+        })
+        (fetchpatch {
+          excludes = [ "gcc/go/gofrontend/MERGE" ];
+          url = "https://github.com/gcc-mirror/gcc/commit/762fd5e5547e464e25b4bee435db6df4eda0de90.diff";
+          hash = "sha256-o28upwTcHAnHG2Iq0OewzwSBEhHs+XpBGdIfZdT81pk=";
+        })
+        (fetchpatch {
+          excludes = [ "gcc/go/gofrontend/MERGE" ];
+          url = "https://github.com/gcc-mirror/gcc/commit/e73d9fcafbd07bc3714fbaf8a82db71d50015c92.diff";
+          hash = "sha256-1SjYCVHLEUihdON2TOC3Z2ufM+jf2vH0LvYtZL+c1Fo=";
+        })
+        (fetchpatch {
+          excludes = [ "gcc/go/gofrontend/MERGE" ];
+          url = "https://github.com/gcc-mirror/gcc/commit/b6c6a3d64f2e4e9347733290aca3c75898c44b2e.diff";
+          hash = "sha256-RycJ3YCHd3MXtYFjxP0zY2Wuw7/C4bWoBAQtTKJZPOQ=";
+        })
+        (fetchpatch {
+          excludes = [ "gcc/go/gofrontend/MERGE" ];
+          url = "https://github.com/gcc-mirror/gcc/commit/2b1a604a9b28fbf4f382060bebd04adb83acc2f9.diff";
+          hash = "sha256-WiBQG0Xbk75rHk+AMDvsbrm+dc7lDH0EONJXSdEeMGE=";
+        })
+        (fetchpatch {
+          url = "https://github.com/gcc-mirror/gcc/commit/c86b726c048eddc1be320c0bf64a897658bee13d.diff";
+          hash = "sha256-QSIlqDB6JRQhbj/c3ejlmbfWz9l9FurdSWxpwDebnlI=";
+        })
+      ]
+
+      # Fix detection of bootstrap compiler Ada support (cctools as) on Nix Darwin
+      ++ optional (stdenv.isDarwin && langAda) ../ada-cctools-as-detection-configure.patch
+
+      # Use absolute path in GNAT dylib install names on Darwin
+      ++ optional (stdenv.isDarwin && langAda) ../gnat-darwin-dylib-install-name.patch
+
+      # Obtain latest patch with ../update-mcfgthread-patches.sh
+      ++ optional (!crossStageStatic && targetPlatform.isMinGW && threadsCross.model == "mcf") ./Added-mcf-thread-model-support-from-mcfgthread.patch;
+
+    /* Cross-gcc settings (build == host != target) */
+    crossMingw = targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt";
+    stageNameAddon = if crossStageStatic then "stage-static" else "stage-final";
+    crossNameAddon = optionalString (targetPlatform != hostPlatform) "${targetPlatform.config}-${stageNameAddon}-";
+
+    callFile = lib.callPackageWith {
+      # lets
+      inherit
+        majorVersion
+        version
+        buildPlatform
+        hostPlatform
+        targetPlatform
+        patches
+        crossMingw
+        stageNameAddon
+        crossNameAddon
+      ;
+      # inherit generated with 'nix eval --json --impure --expr "with import ./. {}; lib.attrNames (lib.functionArgs gcc13.cc.override)" | jq '.[]' --raw-output'
+      inherit
+        binutils
+        buildPackages
+        cloog
+        crossStageStatic
+        disableBootstrap
+        disableGdbPlugin
+        enableLTO
+        enableMultilib
+        enablePlugin
+        enableShared
+        fetchpatch
+        fetchurl
+        gettext
+        gmp
+        gnat-bootstrap
+        gnused
+        isl
+        langAda
+        langC
+        langCC
+        langD
+        langFortran
+        langGo
+        langJit
+        langObjC
+        langObjCpp
+        lib
+        libcCross
+        libmpc
+        libucontext
+        libxcrypt
+        mpfr
+        name
+        noSysDirs
+        nukeReferences
+        patchelf
+        perl
+        profiledCompiler
+        reproducibleBuild
+        staticCompiler
+        stdenv
+        targetPackages
+        texinfo
+        threadsCross
+        which
+        zip
+        zlib
+      ;
+    };
+
+in
+
+lib.pipe (stdenv.mkDerivation ({
+  pname = "${crossNameAddon}${name}";
+  inherit version;
+
+  builder = ../builder.sh;
+
+  src = fetchurl {
+    url = "mirror://gcc/releases/gcc-${version}/gcc-${version}.tar.xz";
+    sha256 = "sha256-YdaE8Kpedqxlha2ImKJCeq3ol57V5/hUkihsTfwT7oY=";
+  };
+
+  inherit patches;
+
+  outputs = [ "out" "man" "info" ] ++ lib.optional (!langJit) "lib";
+  setOutputFlags = false;
+  NIX_NO_SELF_RPATH = true;
+
+  libc_dev = stdenv.cc.libc_dev;
+
+  hardeningDisable = [ "format" "pie" ];
+
+  postPatch = ''
+    configureScripts=$(find . -name configure)
+    for configureScript in $configureScripts; do
+      patchShebangs $configureScript
+    done
+  ''
+  # This should kill all the stdinc frameworks that gcc and friends like to
+  # insert into default search paths.
+  + lib.optionalString hostPlatform.isDarwin ''
+    substituteInPlace gcc/config/darwin-c.cc \
+      --replace 'if (stdinc)' 'if (0)'
+
+    substituteInPlace libgcc/config/t-slibgcc-darwin \
+      --replace "-install_name @shlib_slibdir@/\$(SHLIB_INSTALL_NAME)" "-install_name ''${!outputLib}/lib/\$(SHLIB_INSTALL_NAME)"
+
+    substituteInPlace libgfortran/configure \
+      --replace "-install_name \\\$rpath/\\\$soname" "-install_name ''${!outputLib}/lib/\\\$soname"
+  ''
+  + (
+    lib.optionalString (targetPlatform != hostPlatform || stdenv.cc.libc != null)
+      # On NixOS, use the right path to the dynamic linker instead of
+      # `/lib/ld*.so'.
+      (let
+        libc = if libcCross != null then libcCross else stdenv.cc.libc;
+      in
+        (
+        '' echo "fixing the \`GLIBC_DYNAMIC_LINKER', \`UCLIBC_DYNAMIC_LINKER', and \`MUSL_DYNAMIC_LINKER' macros..."
+           for header in "gcc/config/"*-gnu.h "gcc/config/"*"/"*.h
+           do
+             grep -q _DYNAMIC_LINKER "$header" || continue
+             echo "  fixing \`$header'..."
+             sed -i "$header" \
+                 -e 's|define[[:blank:]]*\([UCG]\+\)LIBC_DYNAMIC_LINKER\([0-9]*\)[[:blank:]]"\([^\"]\+\)"$|define \1LIBC_DYNAMIC_LINKER\2 "${libc.out}\3"|g' \
+                 -e 's|define[[:blank:]]*MUSL_DYNAMIC_LINKER\([0-9]*\)[[:blank:]]"\([^\"]\+\)"$|define MUSL_DYNAMIC_LINKER\1 "${libc.out}\2"|g'
+           done
+        ''
+        + lib.optionalString (targetPlatform.libc == "musl")
+        ''
+            sed -i gcc/config/linux.h -e '1i#undef LOCAL_INCLUDE_DIR'
+        ''
+        )
+    ))
+      + lib.optionalString targetPlatform.isAvr ''
+            makeFlagsArray+=(
+               '-s' # workaround for hitting hydra log limit
+               'LIMITS_H_TEST=false'
+            )
+          '';
+
+  inherit noSysDirs staticCompiler crossStageStatic
+    libcCross crossMingw;
+
+  inherit (callFile ../common/dependencies.nix { }) depsBuildBuild nativeBuildInputs depsBuildTarget buildInputs depsTargetTarget;
+
+  NIX_LDFLAGS = lib.optionalString  hostPlatform.isSunOS "-lm";
+
+
+  preConfigure = (callFile ../common/pre-configure.nix { }) + ''
+    ln -sf ${libxcrypt}/include/crypt.h libsanitizer/sanitizer_common/crypt.h
+  '';
+
+  dontDisableStatic = true;
+
+  configurePlatforms = [ "build" "host" "target" ];
+
+  configureFlags = callFile ../common/configure-flags.nix { };
+
+  targetConfig = if targetPlatform != hostPlatform then targetPlatform.config else null;
+
+  buildFlags =
+    # we do not yet have Nix-driven profiling
+    assert profiledCompiler -> !disableBootstrap;
+    let target =
+          lib.optionalString (profiledCompiler) "profiled" +
+          lib.optionalString (targetPlatform == hostPlatform && hostPlatform == buildPlatform && !disableBootstrap) "bootstrap";
+    in lib.optional (target != "") target;
+
+  inherit (callFile ../common/strip-attributes.nix { })
+    stripDebugList
+    stripDebugListTarget
+    preFixup;
+
+  # https://gcc.gnu.org/install/specific.html#x86-64-x-solaris210
+  ${if hostPlatform.system == "x86_64-solaris" then "CC" else null} = "gcc -m64";
+
+  # Setting $CPATH and $LIBRARY_PATH to make sure both `gcc' and `xgcc' find the
+  # library headers and binaries, regarless of the language being compiled.
+  #
+  # Likewise, the LTO code doesn't find zlib.
+  #
+  # Cross-compiling, we need gcc not to read ./specs in order to build the g++
+  # compiler (after the specs for the cross-gcc are created). Having
+  # LIBRARY_PATH= makes gcc read the specs from ., and the build breaks.
+
+  CPATH = optionals (targetPlatform == hostPlatform) (makeSearchPathOutput "dev" "include" ([]
+    ++ optional (zlib != null) zlib
+  ));
+
+  LIBRARY_PATH = optionals (targetPlatform == hostPlatform) (makeLibraryPath (optional (zlib != null) zlib));
+
+  inherit (callFile ../common/extra-target-flags.nix { })
+    EXTRA_FLAGS_FOR_TARGET
+    EXTRA_LDFLAGS_FOR_TARGET
+    ;
+
+  passthru = {
+    inherit langC langCC langObjC langObjCpp langAda langFortran langGo langD version;
+    isGNU = true;
+  };
+
+  enableParallelBuilding = true;
+  inherit enableShared enableMultilib;
+
+  meta = {
+    inherit (callFile ../common/meta.nix { })
+      homepage
+      license
+      description
+      longDescription
+      platforms
+      maintainers
+    ;
+  };
+}
+
+// optionalAttrs (targetPlatform != hostPlatform && targetPlatform.libc == "msvcrt" && crossStageStatic) {
+  makeFlags = [ "all-gcc" "all-target-libgcc" ];
+  installTargets = "install-gcc install-target-libgcc";
+}
+
+// optionalAttrs (enableMultilib) { dontMoveLib64 = true; }
+))
+[
+  (callPackage ../common/libgcc.nix   { inherit langC langCC langJit; })
+  (callPackage ../common/checksum.nix { inherit langC langCC; })
+]
+

pkgs/development/interpreters/php/8.1.nix

···
 
 let
   base = callPackage ./generic.nix (_args // {
-    version = "8.1.18";
-    hash = "sha256-0qww1rV0/KWU/gzAHAaT4jWFsnRD40KwqrBydM3kQW4=";
+    version = "8.1.19";
+    hash = "sha256-ZCByB/2jC+kmou8fZv8ma/H9x+AzObyZ+7oKEkXkJ5s=";
   });
 
 in

pkgs/development/interpreters/php/8.2.nix

···
 
 let
   base = callPackage ./generic.nix (_args // {
-    version = "8.2.5";
-    hash = "sha256-5agGY8yk9gRK2GpIl5gUfHrwN+ypb2zTV6s20oy2N1c=";
+    version = "8.2.6";
+    hash = "sha256-RKcMUvU3ZiwQ2R7tv1H9dlyZYb5rolCO1jv3omzdMQA=";
   });
 
 in

pkgs/development/libraries/gcc/libgcc/default.nix

···
-{ lib, stdenvNoLibs, buildPackages
-, gcc, glibc
-, libiberty
-}:
-
-stdenvNoLibs.mkDerivation rec {
-  pname = "libgcc";
-  inherit (gcc.cc) src version;
-
-  outputs = [ "out" "dev" ];
-
-  strictDeps = true;
-  depsBuildBuild = [ buildPackages.stdenv.cc ];
-  nativeBuildInputs = [ libiberty ];
-
-  postUnpack = ''
-    mkdir -p ./build
-    buildRoot=$(readlink -e "./build")
-  '';
-
-  postPatch = ''
-    sourceRoot=$(readlink -e "./libgcc")
-  '';
-
-  hardeningDisable = [ "pie" ];
-
-  preConfigure = ''
-    cd "$buildRoot"
-  ''
-
-  # Drop in libiberty, as external builds are not expected
-  + ''
-    (
-      mkdir -p build-${stdenvNoLibs.buildPlatform.config}/libiberty/
-      cd build-${stdenvNoLibs.buildPlatform.config}/libiberty/
-      ln -s ${buildPackages.libiberty}/lib/libiberty.a ./
-    )
-  ''
-  # A few misc bits of gcc need to be built.
-  #
-  #  - We "shift" the tools over to fake platforms perspective from the previous
-  #    stage.
-  #
-  #  - We define GENERATOR_FILE so nothing bothers looking for GNU GMP.
-  #
-  #  - We remove the `libgcc.mvar` deps so that the bootstrap xgcc isn't built.
-  + ''
-    mkdir -p "$buildRoot/gcc"
-    cd "$buildRoot/gcc"
-    (
-      export AS_FOR_BUILD=${buildPackages.stdenv.cc}/bin/$AS_FOR_BUILD
-      export CC_FOR_BUILD=${buildPackages.stdenv.cc}/bin/$CC_FOR_BUILD
-      export CPP_FOR_BUILD=${buildPackages.stdenv.cc}/bin/$CPP_FOR_BUILD
-      export CXX_FOR_BUILD=${buildPackages.stdenv.cc}/bin/$CXX_FOR_BUILD
-      export LD_FOR_BUILD=${buildPackages.stdenv.cc.bintools}/bin/$LD_FOR_BUILD
-
-      export AS=$AS_FOR_BUILD
-      export CC=$CC_FOR_BUILD
-      export CPP=$CPP_FOR_BUILD
-      export CXX=$CXX_FOR_BUILD
-      export LD=$LD_FOR_BUILD
-
-      export AS_FOR_TARGET=${stdenvNoLibs.cc}/bin/$AS
-      export CC_FOR_TARGET=${stdenvNoLibs.cc}/bin/$CC
-      export CPP_FOR_TARGET=${stdenvNoLibs.cc}/bin/$CPP
-      export LD_FOR_TARGET=${stdenvNoLibs.cc.bintools}/bin/$LD
-
-      export NIX_CFLAGS_COMPILE_FOR_BUILD+=' -DGENERATOR_FILE=1'
-
-      "$sourceRoot/../gcc/configure" $gccConfigureFlags
-
-      sed -e 's,libgcc.mvars:.*$,libgcc.mvars:,' -i Makefile
-
-      make \
-        config.h \
-        libgcc.mvars \
-        tconfig.h \
-        tm.h \
-        options.h \
-        insn-constants.h \
-        insn-modes.h
-    )
-    mkdir -p "$buildRoot/gcc/include"
-  ''
-  # Preparing to configure + build libgcc itself
-  + ''
-    mkdir -p "$buildRoot/gcc/${stdenvNoLibs.hostPlatform.config}/libgcc"
-    cd "$buildRoot/gcc/${stdenvNoLibs.hostPlatform.config}/libgcc"
-    configureScript=$sourceRoot/configure
-    chmod +x "$configureScript"
-
-    export AS_FOR_BUILD=${buildPackages.stdenv.cc}/bin/$AS_FOR_BUILD
-    export CC_FOR_BUILD=${buildPackages.stdenv.cc}/bin/$CC_FOR_BUILD
-    export CPP_FOR_BUILD=${buildPackages.stdenv.cc}/bin/$CPP_FOR_BUILD
-    export CXX_FOR_BUILD=${buildPackages.stdenv.cc}/bin/$CXX_FOR_BUILD
-    export LD_FOR_BUILD=${buildPackages.stdenv.cc.bintools}/bin/$LD_FOR_BUILD
-
-    export AS=${stdenvNoLibs.cc}/bin/$AS
-    export CC=${stdenvNoLibs.cc}/bin/$CC
-    export CPP=${stdenvNoLibs.cc}/bin/$CPP
-    export CXX=${stdenvNoLibs.cc}/bin/$CXX
-    export LD=${stdenvNoLibs.cc.bintools}/bin/$LD
-
-    export AS_FOR_TARGET=${stdenvNoLibs.cc}/bin/$AS_FOR_TARGET
-    export CC_FOR_TARGET=${stdenvNoLibs.cc}/bin/$CC_FOR_TARGET
-    export CPP_FOR_TARGET=${stdenvNoLibs.cc}/bin/$CPP_FOR_TARGET
-    export LD_FOR_TARGET=${stdenvNoLibs.cc.bintools}/bin/$LD_FOR_TARGET
-  '';
-
-  gccConfigureFlags = [
-    "--build=${stdenvNoLibs.buildPlatform.config}"
-    "--host=${stdenvNoLibs.buildPlatform.config}"
-    "--target=${stdenvNoLibs.hostPlatform.config}"
-
-    "--disable-bootstrap"
-    "--disable-multilib" "--with-multilib-list="
-    "--enable-languages=c"
-
-    "--disable-fixincludes"
-    "--disable-intl"
-    "--disable-lto"
-    "--disable-libatomic"
-    "--disable-libbacktrace"
-    "--disable-libcpp"
-    "--disable-libssp"
-    "--disable-libquadmath"
-    "--disable-libgomp"
-    "--disable-libvtv"
-    "--disable-vtable-verify"
-
-    "--with-system-zlib"
-  ] ++ lib.optional (stdenvNoLibs.hostPlatform.libc == "glibc")
-       "--with-glibc-version=${glibc.version}";
-
-  configurePlatforms = [ "build" "host" ];
-  configureFlags = [
-    "--disable-dependency-tracking"
-    # $CC cannot link binaries, let alone run then
-    "cross_compiling=true"
-    # Do not have dynamic linker without libc
-    "--enable-static"
-    "--disable-shared"
-
-    # Avoid dependency on gcc.
-    "--disable-gcov"
-  ];
-
-  makeFlags = [ "MULTIBUILDTOP:=../" ];
-
-  postInstall = ''
-    moveToOutput "lib/gcc/${stdenvNoLibs.hostPlatform.config}/${version}/include" "$dev"
-    mkdir -p "$out/lib" "$dev/include"
-    ln -s "$out/lib/gcc/${stdenvNoLibs.hostPlatform.config}/${version}"/* "$out/lib"
-    ln -s "$dev/lib/gcc/${stdenvNoLibs.hostPlatform.config}/${version}/include"/* "$dev/include/"
-  '';
-}

pkgs/development/libraries/getdns/default.nix

···
     outputs = [ "out" "man" "stubbyExampleJson" ];
 
     inherit (getdns) src;
-    sourceRoot = "${getdns.name}/stubby";
+    sourceRoot = "${getdns.pname}-${getdns.version}/stubby";
 
     nativeBuildInputs = [ cmake doxygen yq ];
 

pkgs/development/libraries/libmodulemd/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libmodulemd";
-  version = "2.14.0";
+  version = "2.15.0";
 
   outputs = [ "bin" "out" "dev" "devdoc" "man" "py" ];
 
···
     owner = "fedora-modularity";
     repo = pname;
     rev = "${pname}-${version}";
-    sha256 = "sha256-ccLk8O0UJwy7WZYr5Bq2XqaSFNe4i7HQehmVoB5C2Yg=";
+    sha256 = "sha256-mIyrdksyEk1AKV+vw4g8LUwlQRzwwMkPDuCbw2IiNcA=";
   };
 
   patches = [

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

···
-{ stdenv, lib, fetchurl, buildDunePackage, ounit }:
+{ stdenv, lib, fetchurl, buildDunePackage, ocaml, ounit2 }:
 
 buildDunePackage rec {
   pname = "dtoa";
-  version = "0.3.2";
-
-  useDune2 = true;
-
-  minimumOCamlVersion = "4.02";
+  version = "0.3.3";
 
   src = fetchurl {
-    url = "https://github.com/flowtype/ocaml-${pname}/releases/download/v${version}/${pname}-v${version}.tbz";
-    sha256 = "0zkhn0rdq82g6gamsv6nkx6i44s8104nh6jg5xydazl9jl1704xn";
+    url = "https://github.com/flowtype/ocaml-${pname}/releases/download/v${version}/${pname}-${version}.tbz";
+    hash = "sha256-2PRgjJ6Ssp4l6jHzv1/MqzlomQlJkKLVnRXG6KPJ7j4=";
   };
 
-  checkInputs = [ ounit ];
+  checkInputs = [ ounit2 ];
 
-  doCheck = true;
+  doCheck = lib.versionAtLeast ocaml.version "4.08";
 
   hardeningDisable = lib.optional stdenv.cc.isClang "strictoverflow";
 

pkgs/development/python-modules/azure-eventhub/default.nix

···
 
 buildPythonPackage rec {
   pname = "azure-eventhub";
-  version = "5.11.1";
+  version = "5.11.2";
   format = "setuptools";
 
   disabled = pythonOlder "3.6";
···
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    hash = "sha256-Z1tekAHjO2kVe5g/MpB1U9m38pBQ8J03+pDZdJgzcgE=";
+    hash = "sha256-/QVHPlElUNT7whLdMe1k8wYXePg+tQRBmXmZJM1w6fU=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/azure-identity/default.nix

···
 
 buildPythonPackage rec {
   pname = "azure-identity";
-  version = "1.12.0";
+  version = "1.13.0";
   format = "setuptools";
 
   disabled = pythonOlder "3.6";
···
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    hash = "sha256-f5sa59l+p68/ON0JMF4Zq4Gh4Wq2bqGGtledhcHKI0c=";
+    hash = "sha256-yTHCcwH/qGsHtNz1dOKdpz4966mrXR/k9EW7ajEX4mA=";
   };
 
   propagatedBuildInputs = [

pkgs/development/python-modules/azure-mgmt-keyvault/default.nix

···
 
 buildPythonPackage rec {
   pname = "azure-mgmt-keyvault";
-  version = "10.1.0";
+  version = "10.2.1";
   format = "setuptools";
 
   disabled = pythonOlder "3.6";
···
   src = fetchPypi {
     inherit pname version;
     extension = "zip";
-    hash = "sha256-DpO+6FvsNwjjcz2ImhHpColHVNpPUMgCtEMrfUzfAaA=";
+    hash = "sha256-lozs6Jy6V5cJigM7NUn8eyP/EVf/TKk+pZ9vABgAqK0=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "deezer-python";
-  version = "5.9.0";
+  version = "5.12.0";
   format = "pyproject";
 
   disabled = pythonOlder "3.7";
···
     owner = "browniebroke";
     repo = pname;
     rev = "refs/tags/v${version}";
-    hash = "sha256-S2OC2OvXoc7LDTX0ZkVtaLHflio+3u1Ic/i9TtQN4Ac=";
+    hash = "sha256-fJRGtes5EdGHiTJ5SDOyZT9NEnghbu+7I9OD2h4JOjw=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/dogpile-cache/default.nix

···
 
 buildPythonPackage rec {
   pname = "dogpile-cache";
-  version = "1.1.8";
+  version = "1.2.0";
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     pname = "dogpile.cache";
     inherit version;
-    hash = "sha256-2ETou2OMxPVEpMiag039Nv6TVAC3GhbL10Tr37cg/U4=";
+    hash = "sha256-R1VMhgzrSE3Vrvn/H4j+yz1K72u5IRlFD1vLqgJrv7E=";
   };
 
   preCheck = ''

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

···
 
 buildPythonPackage rec {
   pname = "fakeredis";
-  version = "2.12.0";
+  version = "2.12.1";
   format = "pyproject";
 
   disabled = pythonOlder "3.7";
···
     owner = "dsoftwareinc";
     repo = "fakeredis-py";
     rev = "refs/tags/v${version}";
-    hash = "sha256-D38EORmhPPN+iTggIF9JIRDR4+zCwE6JP8X+IVfdE7o=";
+    hash = "sha256-WF3dITWCrTQDORfaGWPpJBQFkPrUN6faHohjvBuOW7I=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/glean-sdk/default.nix

···
 
 buildPythonPackage rec {
   pname = "glean-sdk";
-  version = "52.6.0";
+  version = "52.7.0";
 
   disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-TTV6oydUP2znEOm7KZElugNDfROnlPmyC19Ig1H8/wM=";
+    hash = "sha256-sLjdGHiS7Co/oA9gQyAFkD14tAYjmwjWcPr4CRrzw/0=";
   };
 
   cargoDeps = rustPlatform.fetchCargoTarball {
     inherit src;
     name = "${pname}-${version}";
-    hash = "sha256-Np2TfgKP3yfJqA4WZyyedGp9XtKJjDikUov5pvB/opk=";
+    hash = "sha256-5TlgWcLmjklxhtDbB0aRF71iIRTJwetFj1Jii1DGdvU=";
   };
 
   nativeBuildInputs = [
···
   disabledTests = [
     # RuntimeError: No ping received.
     "test_client_activity_api"
+    "test_flipping_upload_enabled_respects_order_of_events"
   ];
 
   pythonImportsCheck = [

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

···
 , isodate
 , nest-asyncio
 , pytestCheckHook
+, pythonOlder
 , mock
 , pyhamcrest
 , radish-bdd
···
 
 buildPythonPackage rec {
   pname = "gremlinpython";
-  version = "3.6.1";
+  version = "3.6.3";
+  format = "setuptools";
 
-  # pypi tarball doesn't include tests
+  disabled = pythonOlder "3.7";
+
   src = fetchFromGitHub {
     owner = "apache";
     repo = "tinkerpop";
-    rev = version;
-    hash = "sha256-FMA9hJdq7gYkDtQO04Bwpjq2Q7nXGuN9wrBD4b9GgwY=";
+    rev = "refs/tags/${version}";
+    hash = "sha256-CmVWaRebJaZHJGzhaBdYXPF3BZ8+Cvc5P/KOpsG+dX4=";
   };
 
   sourceRoot = "source/gremlin-python/src/main/python";
···
     sed -i '/pytest-runner/d' setup.py
 
     substituteInPlace setup.py \
-      --replace 'aiohttp>=3.8.0,<=3.8.1' 'aiohttp' \
       --replace 'importlib-metadata<5.0.0' 'importlib-metadata' \
       --replace "os.getenv('VERSION', '?').replace('-SNAPSHOT', '.dev-%d' % timestamp)" '"${version}"'
   '';

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

···
 
 buildPythonPackage rec {
   pname = "sgp4";
-  version = "2.21";
+  version = "2.22";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-YXm4dQRId+lBYzwgr3ci/SMaiNiomvAb8wvWTzPN7O8=";
+    hash = "sha256-F/Ci6q0tygZbbeJcHOqpQP98+ozGcSDLQRGgDxd7hvk=";
   };
 
   nativeCheckInputs = [ numpy ];

pkgs/development/tools/build-managers/sbt/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "sbt";
-  version = "1.8.2";
+  version = "1.8.3";
 
   src = fetchurl {
     url = "https://github.com/sbt/sbt/releases/download/v${version}/sbt-${version}.tgz";
-    sha256 = "sha256-H2U0TaB029Zt/vqTwO/40xnXcuXK1H/L62rheLvfRoY=";
+    sha256 = "sha256-IfQhB4b9aP0V3KP0yO6crg2yScVOGw726Cnp+kk2Qjo=";
   };
 
   postPatch = ''

pkgs/development/tools/continuous-integration/dagger/default.nix

···
 
 buildGoModule rec {
   pname = "dagger";
-  version = "0.5.1";
+  version = "0.5.2";
 
   src = fetchFromGitHub {
     owner = "dagger";
     repo = "dagger";
     rev = "v${version}";
-    hash = "sha256-8RYfLuIFF/J7BSan+C135ntg1/CYuvUhcueKiccMPIo=";
+    hash = "sha256-vFKq7sa41KSfV4+vgsZLEfiF2iwd4O6BwXkVXQPJ7n0=";
   };
 
-  vendorHash = "sha256-w8eWWyKEedEopQyliKKDNOn00KDlcrZHXK/8LMFvx7o=";
+  vendorHash = "sha256-/S72x0KqEKIRiRP66InZcQaTvRY1kQRTvs+Ceo0bMCA=";
   proxyVendor = true;
 
   subPackages = [
     "cmd/dagger"
   ];
 
-  ldflags = [ "-s" "-w" "-X github.com/dagger/dagger/internal/engine.Version=${version}" ];
+  ldflags = [ "-s" "-w" "-X=github.com/dagger/dagger/internal/engine.Version=${version}" ];
 
   passthru.tests.version = testers.testVersion {
     package = dagger;
     command = "dagger version";
+    version = "v${version}";
   };
 
   meta = with lib; {

pkgs/development/tools/minizinc/default.nix

···
 { lib, stdenv, fetchFromGitHub, cmake, flex, bison }:
 stdenv.mkDerivation rec {
   pname = "minizinc";
-  version = "2.7.3";
+  version = "2.7.4";
 
   nativeBuildInputs = [ cmake flex bison ];
 
···
     owner = "MiniZinc";
     repo = "libminizinc";
     rev = version;
-    sha256 = "sha256-qDAFXyWEwdei1jBHb5ONgivlp2ftMNfBbq8a/Ibh2BM=";
+    sha256 = "sha256-Zq5gAwe9IQmknSDilFyHhSk5ZCQ8EfBOiM6Oef2WxYg=";
   };
 
   meta = with lib; {

pkgs/games/cdogs-sdl/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "cdogs-sdl";
-  version = "1.4.1";
+  version = "1.4.2";
 
   src = fetchFromGitHub {
     repo = pname;
     owner = "cxong";
     rev = version;
-    sha256 = "sha256-CH0P8OrRUXtuqAHxDKv4ziKYdwGTccLPwpzh4xo7lQc=";
+    sha256 = "sha256-KRHwcDUAQ6GzJ20pCINq8t+P4G4cWjbIayDsYM4VBaY=";
   };
 
   postPatch = ''

pkgs/games/steam/fhsenv.nix

···
     libidn2
     libpsl
     nghttp2.lib
-    openssl_1_1
     rtmpdump
   ] ++ steamPackages.steam-runtime-wrapped.overridePkgs
   ++ extraLibraries pkgs;

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

···
 
     extraMeta = {
       branch = lib.versions.majorMinor version + "/master";
-      maintainers = with lib.maintainers; [ pedrohlc ];
+      maintainers = with lib.maintainers; [ ];
       description = "Built using the best configuration and kernel sources for desktop, multimedia, and gaming workloads." +
         lib.optionalString isLqx " (Same as linux_zen but less aggressive release schedule)";
     };

pkgs/os-specific/linux/minimal-bootstrap/default.nix

···
     tinycc-bootstrappable = callPackage ./tinycc/bootstrappable.nix { };
     tinycc-mes = callPackage ./tinycc/mes.nix { };
 
-    inherit (callPackage ./utils.nix { }) fetchurl derivationWithMeta writeTextFile writeText runCommand;
+    inherit (callPackage ./utils.nix { }) fetchurl derivationWithMeta writeTextFile writeText;
 
   })

pkgs/os-specific/linux/minimal-bootstrap/gnumake/default.nix

···
 { lib
-, runCommand
 , fetchurl
+, kaem
 , tinycc
 , gnupatch
 }:
···
 
   objects = map (x: lib.replaceStrings [".c"] [".o"] (builtins.baseNameOf x)) sources;
 in
-runCommand "${pname}-${version}" {
+kaem.runCommand "${pname}-${version}" {
   inherit pname version;
 
   nativeBuildInputs = [ tinycc gnupatch ];

pkgs/os-specific/linux/minimal-bootstrap/gnupatch/default.nix

···
 { lib
-, runCommand
 , fetchurl
+, kaem
 , tinycc
 }:
 let
···
 
   objects = map (x: lib.replaceStrings [".c"] [".o"] (builtins.baseNameOf x)) sources;
 in
-runCommand "${pname}-${version}" {
+kaem.runCommand "${pname}-${version}" {
   inherit pname version;
 
   nativeBuildInputs = [ tinycc ];

pkgs/os-specific/linux/minimal-bootstrap/ln-boot/default.nix

···
 { lib
-, runCommand
+, kaem
 , mes
 }:
 let
···
 
   src = ./ln.c;
 in
-runCommand "${pname}-${version}" {
+kaem.runCommand "${pname}-${version}" {
   inherit pname version;
 
   meta = with lib; {

pkgs/os-specific/linux/minimal-bootstrap/mes/default.nix

···
 { lib
-, runCommand
 , fetchurl
 , writeText
 , callPackage
+, kaem
 , m2libc
 , mescc-tools
 }:
···
   sourceArchive = out: sources:
     "catm ${out} ${lib.concatMapStringsSep " " (replaceExt ".s") sources}";
 in
-runCommand "${pname}-${version}" {
+kaem.runCommand "${pname}-${version}" {
   inherit pname version;
 
   passthru = { inherit src nyacc; };

pkgs/os-specific/linux/minimal-bootstrap/mes/libc.nix

···
 { lib
-, runCommand
+, kaem
 , ln-boot
 , mes
 , mes-libc
···
   # the operation in two
   firstLibc = lib.take 100 libc_gnu_SOURCES;
   lastLibc = lib.drop 100 libc_gnu_SOURCES;
-in runCommand "${pname}-${version}" {
+in
+kaem.runCommand "${pname}-${version}" {
   inherit pname version;
 
   nativeBuildInputs = [ ln-boot ];

pkgs/os-specific/linux/minimal-bootstrap/mes/nyacc.nix

···
 { lib
-, runCommand
 , fetchurl
+, kaem
 , nyacc
 }:
 let
···
     sha256 = "065ksalfllbdrzl12dz9d9dcxrv97wqxblslngsc6kajvnvlyvpk";
   };
 in
-runCommand "${pname}-${version}" {
+kaem.runCommand "${pname}-${version}" {
   inherit pname version;
 
   passthru.guilePath = "${nyacc}/share/${pname}-${version}/module";

pkgs/os-specific/linux/minimal-bootstrap/stage0-posix/kaem/default.nix

···
 { lib
 , derivationWithMeta
+, writeText
+, kaem
 , kaem-unwrapped
+, mescc-tools
 , mescc-tools-extra
 , version
 }:
···
     '')
   ];
   PATH = lib.makeBinPath [ mescc-tools-extra ];
+
+  passthru.runCommand = name: env: buildCommand:
+    derivationWithMeta ({
+      inherit name;
+
+      builder = "${kaem}/bin/kaem";
+      args = [
+        "--verbose"
+        "--strict"
+        "--file"
+        (writeText "${name}-builder" buildCommand)
+      ];
+
+      PATH = lib.makeBinPath ((env.nativeBuildInputs or []) ++ [ kaem mescc-tools mescc-tools-extra ]);
+    } // (builtins.removeAttrs env [ "nativeBuildInputs" ]));
 
   meta = with lib; {
     description = "Minimal build tool for running scripts on systems that lack any shell";

pkgs/os-specific/linux/minimal-bootstrap/tinycc/bootstrappable.nix

···
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 { lib
-, runCommand
 , callPackage
 , fetchurl
+, kaem
 , mes
 , mes-libc
 }:
···
     url = "https://gitlab.com/janneke/tinycc/-/archive/${rev}/tinycc-${rev}.tar.gz";
     sha256 = "1a0cw9a62qc76qqn5sjmp3xrbbvsz2dxrw21lrnx9q0s74mwaxbq";
   };
-  src = (runCommand "tinycc-bootstrappable-${version}-source" {} ''
+  src = (kaem.runCommand "tinycc-bootstrappable-${version}-source" {} ''
     ungz --file ${tarball} --output tinycc.tar
     mkdir -p ''${out}
     cd ''${out}
···
     platforms = [ "i686-linux" ];
   };
 
-  tinycc-boot-mes = runCommand "tinycc-boot-mes-${version}" {} ''
+  tinycc-boot-mes = kaem.runCommand "tinycc-boot-mes-${version}" {} ''
     catm config.h
     ${mes}/bin/mes --no-auto-compile -e main ${mes}/bin/mescc.scm -- \
       -S \

pkgs/os-specific/linux/minimal-bootstrap/tinycc/common.nix

···
 { lib
-, runCommand
+, kaem
 , mes-libc
 , ln-boot
 }:
···
       options = lib.strings.concatStringsSep " " buildOptions;
       libtccOptions = lib.strings.concatStringsSep " " libtccBuildOptions;
     in
-    runCommand "${pname}-${version}" {
+    kaem.runCommand "${pname}-${version}" {
       inherit pname version meta;
       nativeBuildInputs = [ ln-boot ];
     } ''

pkgs/os-specific/linux/minimal-bootstrap/tinycc/mes.nix

···
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 { lib
-, runCommand
 , fetchurl
 , callPackage
+, kaem
 , tinycc-bootstrappable
 }:
 let
···
     url = "https://repo.or.cz/tinycc.git/snapshot/${rev}.tar.gz";
     sha256 = "11idrvbwfgj1d03crv994mpbbbyg63j1k64lw1gjy7mkiifw2xap";
   };
-  src = (runCommand "tinycc-${version}-source" {} ''
+  src = (kaem.runCommand "tinycc-${version}-source" {} ''
     ungz --file ${tarball} --output tinycc.tar
     mkdir -p ''${out}
     cd ''${out}
···
     platforms = [ "i686-linux" ];
   };
 
-  tccdefs = runCommand "tccdefs-${version}" {} ''
+  tccdefs = kaem.runCommand "tccdefs-${version}" {} ''
     mkdir ''${out}
     ${tinycc-bootstrappable}/bin/tcc -static -DC2STR -o c2str ${src}/conftest.c
     ./c2str ${src}/include/tccdefs.h ''${out}/tccdefs_.h

pkgs/os-specific/linux/minimal-bootstrap/utils.nix

···
 , buildPlatform
 , callPackage
 , kaem
-, mescc-tools
 , mescc-tools-extra
 }:
 
···
     };
 
   writeText = name: text: writeTextFile {inherit name text;};
-
-  runCommand = name: env: buildCommand:
-    derivationWithMeta ({
-      inherit name;
-
-      builder = "${kaem}/bin/kaem";
-      args = [
-        "--verbose"
-        "--strict"
-        "--file"
-        (writeText "${name}-builder" buildCommand)
-      ];
-
-      PATH = lib.makeBinPath ((env.nativeBuildInputs or []) ++ [ kaem mescc-tools mescc-tools-extra ]);
-    } // (builtins.removeAttrs env [ "nativeBuildInputs" ]));
 
 }

pkgs/servers/imgproxy/default.nix

···
 
 buildGoModule rec {
   pname = "imgproxy";
-  version = "3.16.1";
+  version = "3.17.0";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
-    sha256 = "sha256-l5THMK6YUfScTeralhEl5SDBDoeV3Olt1xzdzeJ8BEQ=";
+    sha256 = "sha256-7kNBXMjkOs8fLDUBdQJHOjwJhYYAbGPZZDA0NLFirH8=";
     rev = "v${version}";
   };
 
-  vendorHash = "sha256-EtNFSAx8YcRhzgV3IdrZaCM6fOd284iuTperCFECsL8=";
+  vendorHash = "sha256-5o1i88v+1UGYXP2SzyM6seyidrj1Z3Q64w/gi07xf4w=";
 
   nativeBuildInputs = [ pkg-config ];
 

pkgs/servers/search/opensearch/default.nix

···
 
 stdenvNoCC.mkDerivation rec {
   pname = "opensearch";
-  version = "2.6.0";
+  version = "2.7.0";
 
   src = fetchurl {
     url = "https://artifacts.opensearch.org/releases/bundle/opensearch/${version}/opensearch-${version}-linux-x64.tar.gz";
-    hash = "sha256-qJrgWF8JCR4jmnF239gaiRr4Y7Tin0TyYjzxd1Q4Wko";
+    hash = "sha256-qghqFcwfGDtKVyJW3Hb9Ad8UPh2dfhzxwyCZOp7mGmM=";
   };
 
   nativeBuildInputs = [ makeWrapper ];
   buildInputs = [ jre_headless util-linux ];
-  patches = [./opensearch-home-fix.patch ];
 
   installPhase = ''
     runHook preInstall
···
   meta = {
     description = "Open Source, Distributed, RESTful Search Engine";
     homepage = "https://github.com/opensearch-project/OpenSearch";
+    sourceProvenance = with lib.sourceTypes; [
+      binaryBytecode
+      binaryNativeCode
+    ];
     license = lib.licenses.asl20;
     platforms = lib.platforms.unix;
     maintainers = with lib.maintainers; [ shyim ];

pkgs/servers/search/opensearch/opensearch-home-fix.patch

···
-diff -Naur a/bin/opensearch-env b/bin/opensearch-env
---- a/bin/opensearch-env	2017-12-12 13:31:51.000000000 +0100
-+++ b/bin/opensearch-env	2017-12-18 19:51:12.282809695 +0100
-@@ -19,18 +19,10 @@
-   fi
- done
- 
--# determine OpenSearch home; to do this, we strip from the path until we find
--# bin, and then strip bin (there is an assumption here that there is no nested
--# directory under bin also named bin)
--OPENSEARCH_HOME=`dirname "$SCRIPT"`
--
--# now make OPENSEARCH_HOME absolute
--OPENSEARCH_HOME=`cd "$OPENSEARCH_HOME"; pwd`
--
--while [ "`basename "$OPENSEARCH_HOME"`" != "bin" ]; do
--  OPENSEARCH_HOME=`dirname "$OPENSEARCH_HOME"`
--done
--OPENSEARCH_HOME=`dirname "$OPENSEARCH_HOME"`
-+if [ -z "$OPENSEARCH_HOME" ]; then
-+    echo "You must set the OPENSEARCH_HOME var" >&2
-+    exit 1
-+fi
- 
- # now set the classpath
- OPENSEARCH_CLASSPATH="$OPENSEARCH_HOME/lib/*"

pkgs/servers/spicedb/default.nix

···
 
 buildGoModule rec {
   pname = "spicedb";
-  version = "1.20.0";
+  version = "1.21.0";
 
   src = fetchFromGitHub {
     owner = "authzed";
     repo = "spicedb";
     rev = "v${version}";
-    hash = "sha256-gTQ6AiFcx9ckygZt8l5BWHfk8wv0Z7xCirPzCPkloKA=";
+    hash = "sha256-d/py2tOvcada7hHmllVtxZ2af6GFioW95+eRTepXG7w=";
   };
 
-  vendorHash = "sha256-sL2i9kpMuJIdkDXOXJVMzYBiIsU7duu/tRfDaLPjbwo=";
+  vendorHash = "sha256-/0EOmnQyD3kOrRmItIgzyK+O7ZOYpUedXdgQjS894uQ=";
 
   subPackages = [ "cmd/spicedb" ];
 

pkgs/tools/admin/kics/default.nix

···
 
 buildGoModule rec {
   pname = "kics";
-  version = "1.7.0";
+  version = "1.7.1";
 
   src = fetchFromGitHub {
     owner = "Checkmarx";
     repo = "kics";
     rev = "v${version}";
-    sha256 = "sha256-T9dO8OGlbEvjM+9P7cbCCgXkJXXtkR+5zrXRoGZg08c=";
+    sha256 = "sha256-9Pr8h6q/Au5fDgtAhKpOXNj3ldsLTwqGnduTAiUYdvE=";
   };
 
   vendorHash = "sha256-Sg8f6fqe7DAsNsEGU1Ml42qgSuE5CrD+YrFqZKpNKtU=";

pkgs/tools/misc/chezmoi/default.nix

···
 
 buildGoModule rec {
   pname = "chezmoi";
-  version = "2.33.4";
+  version = "2.33.5";
 
   src = fetchFromGitHub {
     owner = "twpayne";
     repo = "chezmoi";
     rev = "v${version}";
-    hash = "sha256-EV1/T+VQGUI18KnX1y7CvwbOS9EabBmHUOoID8QUzmM=";
+    hash = "sha256-/Dh410wloqwo6dC9YP4Ufr6E56dnHoi48QSiYMSqml0=";
   };
 
-  vendorHash = "sha256-NfKpXphv8BF5wWs6c5VlI+riWtMXD8NSx3l9zwp7b/M=";
+  vendorHash = "sha256-P6PbriempswIH2h1RBTuhtxcmPI5T5lKS9nXRotARa8=";
 
   doCheck = false;
 

pkgs/tools/misc/clipboard-jh/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "clipboard-jh";
-  version = "0.7.0";
+  version = "0.7.1";
 
   src = fetchFromGitHub {
     owner = "Slackadays";
     repo = "clipboard";
     rev = version;
-    hash = "sha256-+1GgIa0kIOliI0ACiU9zQe24R6488xWEZ7n9nuxv3dY";
+    hash = "sha256-RLb7R4BXnP7J5gX8hsE9yi6N3kezsutP1HqkmjR3yRs=";
   };
 
   postPatch = ''

pkgs/tools/networking/kapp/default.nix

···
 
 buildGoModule rec {
   pname = "kapp";
-  version = "0.55.0";
+  version = "0.55.1";
 
   src = fetchFromGitHub {
     owner = "vmware-tanzu";
     repo = "carvel-kapp";
     rev = "v${version}";
-    sha256 = "sha256-Y/2Jsb4S07Sp4RbCp9E0/VHfYejFN3cmBLaTqUSK/6Q=";
+    sha256 = "sha256-g65hW/qyuwwZDfX0dDbgjlRCikBT3PpWP53MzkUlNqY=";
   };
 
   vendorHash = null;

pkgs/tools/networking/openapi-generator-cli/default.nix

···
 { callPackage, lib, stdenv, fetchurl, jre, makeWrapper }:
 
 let this = stdenv.mkDerivation rec {
-  version = "6.5.0";
+  version = "6.6.0";
   pname = "openapi-generator-cli";
 
   jarfilename = "${pname}-${version}.jar";
···
 
   src = fetchurl {
     url = "mirror://maven/org/openapitools/${pname}/${version}/${jarfilename}";
-    sha256 = "sha256-8Y13HpjyxbsWnR0ZYd5PlIZtKQGrweFhd91+kpmDRyE=";
+    sha256 = "sha256-lxj/eETolGLHXc2bIKNRNvbbJXv+G4dNseMALpneRgk=";
   };
 
   dontUnpack = true;
···
   meta = with lib; {
     description = "Allows generation of API client libraries (SDK generation), server stubs and documentation automatically given an OpenAPI Spec";
     homepage = "https://github.com/OpenAPITools/openapi-generator";
+    changelog = "https://github.com/OpenAPITools/openapi-generator/releases/tag/v${version}";
     sourceProvenance = with sourceTypes; [ binaryBytecode ];
     license = licenses.asl20;
-    maintainers = [ maintainers.shou ];
+    maintainers = with maintainers; [ shou ];
   };
 
   passthru.tests.example = callPackage ./example.nix {

pkgs/tools/text/diffsitter/default.nix

···
 in
 rustPlatform.buildRustPackage rec {
   pname = "diffsitter";
-  version = "0.7.3";
+  version = "0.8.0";
 
   src = fetchFromGitHub {
     owner = "afnanenayet";
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-AJjgn+qFfy6/gjb8tQOJDmevZy1ZfpF0nTxAgunSabE=";
+    sha256 = "sha256-KrmK0RJdNJcZGM/7IxDP5IbJMTY3v6MkHA1SQW+U3hw=";
     fetchSubmodules = false;
   };
 
-  cargoSha256 = "sha256-U/XvllkzEVt4TpDPA5gSRKpIIQagATGdHh7YPFOo4CY=";
+  cargoHash = "sha256-3HALOoa3QDl9KE2UHxszzDw/VuDLLmjccXQvBBrfrHA=";
 
   buildNoDefaultFeatures = true;
   buildFeatures = [
···
   ];
 
   postInstall = ''
+    # completions are not yet implemented
+    # so we can safely remove this without installing the completions
+    rm $out/bin/diffsitter_completions
+
     wrapProgram "$out/bin/diffsitter" \
       --prefix LD_LIBRARY_PATH : "${libPath}"
   '';

pkgs/tools/text/vale/default.nix

···
 
 buildGoModule rec {
   pname = "vale";
-  version = "2.25.2";
+  version = "2.26.0";
 
   subPackages = [ "cmd/vale" ];
   outputs = [ "out" "data" ];
···
     owner = "errata-ai";
     repo = "vale";
     rev = "v${version}";
-    hash = "sha256-2v/ibr50rEuo5/KCBTlqv1iaPLYmAEnV0Nol2nqawA0=";
+    hash = "sha256-giGiA1W7mKOsP3yj8FhbXr0hL2YV7dRmkyUCkqsngWM=";
   };
 
   vendorHash = "sha256-KB1mRWDYejc38tUv316MiGfmq2riNnpEMIUpjgfSasU=";

pkgs/tools/typesetting/tex/pplatex/default.nix

···
 
 stdenv.mkDerivation {
   pname = "pplatex";
-  version = "unstable-2015-09-14";
+  version = "unstable-2023-04-18";
 
   src = fetchFromGitHub {
     owner = "stefanhepp";
     repo = "pplatex";
-    rev = "5cec891ad6aec0115081cdd114ae1cc4f1ed7c06";
-    sha256 = "0wrkkbz6b6x91650nm8gccz7xghlp7b1i31fxwalz9xw3py9xygb";
+    rev = "8487b00b25127d9a4883e878000f4be6f89d56d5";
+    sha256 = "sha256-wPPJBn/UfmTWsD5JOg6po83Qn4qlpwgsPUV3iJzw5KU=";
   };
 
   nativeBuildInputs = [ cmake pkg-config ];
···
       "A tool to reformat the output of latex and friends into readable messages";
     homepage = "https://github.com/stefanhepp/pplatex";
     license = licenses.gpl3Plus;
-    maintainers = [ maintainers.srgom ];
+    maintainers = [ maintainers.srgom maintainers.doronbehar ];
     platforms = platforms.unix;
   };
 }

pkgs/tools/video/swfmill/default.nix

···
   # Fixes build with GCC 6
   env.NIX_CFLAGS_COMPILE = "-std=c++03";
 
+  # Remove once updated past 0.3.5
+  env.NIX_LDFLAGS = "-lz";
+
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ libxslt freetype libpng libxml2 ];
 

pkgs/top-level/aliases.nix

···
   liberation_ttf_v1_from_source = throw "'liberation_ttf_v1_from_source' has been renamed to/replaced by 'liberation_ttf_v1'"; # Converted to throw 2022-02-22
   liberation_ttf_v2_from_source = throw "'liberation_ttf_v2_from_source' has been renamed to/replaced by 'liberation_ttf_v2'"; # Converted to throw 2022-02-22
   liberationsansnarrow = throw "'liberationsansnarrow' has been renamed to/replaced by 'liberation-sans-narrow'"; # Converted to throw 2022-02-22
+  libgcc = throw "libgcc was removed, use gcc.cc.libgcc if needed"; # added 2023-05-13
   libgksu = throw "libgksu has been removed"; # Added 2022-01-16
   libgme = game-music-emu; # Added 2022-07-20
   libgnome_keyring = throw "'libgnome_keyring' has been renamed to/replaced by 'libgnome-keyring'"; # Converted to throw 2022-02-22

pkgs/top-level/all-packages.nix

···
   gcc10Stdenv = overrideCC gccStdenv buildPackages.gcc10;
   gcc11Stdenv = overrideCC gccStdenv buildPackages.gcc11;
   gcc12Stdenv = overrideCC gccStdenv buildPackages.gcc12;
+  gcc13Stdenv = overrideCC gccStdenv buildPackages.gcc13;
 
   # Meant for packages that fail with newer than gcc10.
   gcc10StdenvCompat = if stdenv.cc.isGNU && lib.versionAtLeast stdenv.cc.version "11" then gcc10Stdenv else stdenv;
···
     isl = if !stdenv.isDarwin then isl_0_20 else null;
   }));
 
-  gcc_latest = gcc12;
+  gcc13 = lowPrio (wrapCC (callPackage ../development/compilers/gcc/13 {
+    inherit noSysDirs;
+
+    reproducibleBuild = true;
+    profiledCompiler = false;
+
+    libcCross = if stdenv.targetPlatform != stdenv.buildPlatform then libcCross else null;
+    threadsCross = if stdenv.targetPlatform != stdenv.buildPlatform then threadsCross else { };
+
+    isl = if !stdenv.isDarwin then isl_0_20 else null;
+  }));
+
+  gcc_latest = gcc13;
 
   # Use the same GCC version as the one from stdenv by default
   gfortran = wrapCC (gcc.cc.override {
···
     profiledCompiler = false;
   });
 
+  gfortran13 = wrapCC (gcc13.cc.override {
+    name = "gfortran";
+    langFortran = true;
+    langCC = false;
+    langC = false;
+    profiledCompiler = false;
+  });
+
   libgccjit = gcc.cc.override {
     name = "libgccjit";
     langFortran = false;
···
       else stdenv;
   });
 
+  gnat13 = wrapCC (gcc13.cc.override {
+    name = "gnat";
+    langC = true;
+    langCC = false;
+    langAda = true;
+    profiledCompiler = false;
+    # As per upstream instructions building a cross compiler
+    # should be done with a (native) compiler of the same version.
+    # If we are cross-compiling GNAT, we may as well do the same.
+    gnat-bootstrap =
+      if stdenv.hostPlatform == stdenv.targetPlatform
+         && stdenv.buildPlatform == stdenv.hostPlatform
+      then buildPackages.gnat-bootstrap12
+      else buildPackages.gnat13;
+    stdenv =
+      if stdenv.hostPlatform == stdenv.targetPlatform
+         && stdenv.buildPlatform == stdenv.hostPlatform
+         && stdenv.buildPlatform.isDarwin
+         && stdenv.buildPlatform.isx86_64
+      then overrideCC stdenv gnat-bootstrap12
+      else stdenv;
+  });
+
   gnat-bootstrap = gnat-bootstrap12;
   gnat-bootstrap11 = wrapCC (callPackage ../development/compilers/gnat-bootstrap { majorVersion = "11"; });
   gnat-bootstrap12 = wrapCCWith ({
···
   });
 
   gccgo12 = wrapCC (gcc12.cc.override {
+    name = "gccgo";
+    langCC = true; #required for go.
+    langC = true;
+    langGo = true;
+    langJit = true;
+    profiledCompiler = false;
+  } // {
+    # not supported on darwin: https://github.com/golang/go/issues/463
+    meta.broken = stdenv.hostPlatform.isDarwin;
+  });
+
+  gccgo13 = wrapCC (gcc13.cc.override {
     name = "gccgo";
     langCC = true; #required for go.
     langC = true;
···
   libcxxabi = llvmPackages.libcxxabi;
 
   librarian-puppet-go = callPackage ../development/tools/librarian-puppet-go { };
-
-  libgcc = callPackage ../development/libraries/gcc/libgcc {
-    stdenvNoLibs = gccStdenvNoLibs; # cannot be built with clang it seems
-  };
 
   # This is for e.g. LLVM libraries on linux.
   gccForLibs =