Merge staging-next into staging

doc/languages-frameworks/dotnet.section.md

···
 
 To package Dotnet applications, you can use `buildDotnetModule`. This has similar arguments to `stdenv.mkDerivation`, with the following additions:
 
-* `projectFile` is used for specifying the dotnet project file, relative to the source root. These usually have `.sln` or `.csproj` file extensions. This can be a list of multiple projects as well. Most of the time dotnet can figure this location out by itself, so this should only be set if necessary.
+* `projectFile` is used for specifying the dotnet project file, relative to the source root. These have `.sln` (entire solution) or `.csproj` (single project) file extensions. This can be a list of multiple projects as well. When omitted, will attempt to find and build the solution (`.sln`). If running into problems, make sure to set it to a file (or a list of files) with the `.csproj` extension - building applications as entire solutions is not fully supported by the .NET CLI.
 * `nugetDeps` takes either a path to a `deps.nix` file, or a derivation. The `deps.nix` file can be generated using the script attached to `passthru.fetch-deps`. This file can also be generated manually using `nuget-to-nix` tool, which is available in nixpkgs. If the argument is a derivation, it will be used directly and assume it has the same output as `mkNugetDeps`.
 * `packNupkg` is used to pack project as a `nupkg`, and installs it to `$out/share`. If set to `true`, the derivation can be used as a dependency for another dotnet project by adding it to `projectReferences`.
 * `projectReferences` can be used to resolve `ProjectReference` project items. Referenced projects can be packed with `buildDotnetModule` by setting the `packNupkg = true` attribute and passing a list of derivations to `projectReferences`. Since we are sharing referenced projects as NuGets they must be added to csproj/fsproj files as `PackageReference` as well.
···
 * `executables` is used to specify which executables get wrapped to `$out/bin`, relative to `$out/lib/$pname`. If this is unset, all executables generated will get installed. If you do not want to install any, set this to `[]`. This gets done in the `preFixup` phase.
 * `runtimeDeps` is used to wrap libraries into `LD_LIBRARY_PATH`. This is how dotnet usually handles runtime dependencies.
 * `buildType` is used to change the type of build. Possible values are `Release`, `Debug`, etc. By default, this is set to `Release`.
-* `selfContainedBuild` allows to enable the [self-contained](https://docs.microsoft.com/en-us/dotnet/core/deploying/#publish-self-contained) build flag. By default, it is set to false and generated applications have a dependency on the selected dotnet runtime. If enabled, the dotnet runtime is bundled into the executable and the built app has no dependency on Dotnet.
+* `selfContainedBuild` allows to enable the [self-contained](https://docs.microsoft.com/en-us/dotnet/core/deploying/#publish-self-contained) build flag. By default, it is set to false and generated applications have a dependency on the selected dotnet runtime. If enabled, the dotnet runtime is bundled into the executable and the built app has no dependency on .NET.
 * `useAppHost` will enable creation of a binary executable that runs the .NET application using the specified root. More info in [Microsoft docs](https://learn.microsoft.com/en-us/dotnet/core/deploying/#publish-framework-dependent). Enabled by default.
 * `useDotnetFromEnv` will change the binary wrapper so that it uses the .NET from the environment. The runtime specified by `dotnet-runtime` is given as a fallback in case no .NET is installed in the user's environment. This is most useful for .NET global tools and LSP servers, which often extend the .NET CLI and their runtime should match the users' .NET runtime.
 * `dotnet-sdk` is useful in cases where you need to change what dotnet SDK is being used. You can also set this to the result of `dotnetSdkPackages.combinePackages`, if the project uses multiple SDKs to build.
 * `dotnet-runtime` is useful in cases where you need to change what dotnet runtime is being used. This can be either a regular dotnet runtime, or an aspnetcore.
 * `dotnet-test-sdk` is useful in cases where unit tests expect a different dotnet SDK. By default, this is set to the `dotnet-sdk` attribute.
-* `testProjectFile` is useful in cases where the regular project file does not contain the unit tests. It gets restored and build, but not installed. You may need to regenerate your nuget lockfile after setting this.
+* `testProjectFile` is useful in cases where the regular project file does not contain the unit tests. It gets restored and build, but not installed. You may need to regenerate your nuget lockfile after setting this. Note that if set, only tests from this project are executed.
 * `disabledTests` is used to disable running specific unit tests. This gets passed as: `dotnet test --filter "FullyQualifiedName!={}"`, to ensure compatibility with all unit test frameworks.
 * `dotnetRestoreFlags` can be used to pass flags to `dotnet restore`.
 * `dotnetBuildFlags` can be used to pass flags to `dotnet build`.

maintainers/maintainer-list.nix

···
     githubId = 15312184;
     name = "Rebecca Turner";
   };
+  _999eagle = {
+    email = "[e-mail]";
+    matrix = "@sophie:catgirl.cloud";
+    github = "999eagle";
+    githubId = 1221984;
+    name = "Sophie Tauchert";
+    keys = [{
+      fingerprint = "7B59 F09E 0FE5 BC34 F032  1FB4 5270 1DE5 F5F5 1125";
+    }];
+  };
   a1russell = {
     email = "[e-mail]";
     github = "a1russell";

nixos/modules/system/boot/stage-1-init.sh

···
     done
 }
 
+# Create the mount point if required.
+makeMountPoint() {
+    local device="$1"
+    local mountPoint="$2"
+    local options="$3"
+
+    local IFS=,
+
+    # If we're bind mounting a file, the mount point should also be a file.
+    if ! [ -d "$device" ]; then
+        for opt in $options; do
+            if [ "$opt" = bind ] || [ "$opt" = rbind ]; then
+                mkdir -p "$(dirname "/mnt-root$mountPoint")"
+                touch "/mnt-root$mountPoint"
+                return
+            fi
+        done
+    fi
+
+    mkdir -m 0755 -p "/mnt-root$mountPoint"
+}
+
 # Mount special file systems.
 specialMount() {
   local device="$1"
···
 
     info "mounting $device on $mountPoint..."
 
-    mkdir -p "/mnt-root$mountPoint"
+    makeMountPoint "$device" "$mountPoint" "$optionsPrefixed"
 
     # For ZFS and CIFS mounts, retry a few times before giving up.
     # We do this for ZFS as a workaround for issue NixOS/nixpkgs#25383.

nixos/tests/non-default-filesystems.nix

···
 with import ../lib/testing-python.nix { inherit system pkgs; };
 with pkgs.lib;
 {
+  bind = makeTest {
+    name = "non-default-filesystem-bind";
+
+    nodes.machine = { ... }: {
+      virtualisation.writableStore = false;
+
+      virtualisation.fileSystems."/test-bind-dir/bind" = {
+        device = "/";
+        neededForBoot = true;
+        options = [ "bind" ];
+      };
+
+      virtualisation.fileSystems."/test-bind-file/bind" = {
+        depends = [ "/nix/store" ];
+        device = builtins.toFile "empty" "";
+        neededForBoot = true;
+        options = [ "bind" ];
+      };
+    };
+
+    testScript = ''
+      machine.wait_for_unit("multi-user.target")
+    '';
+  };
+
   btrfs = makeTest
     {
       name = "non-default-filesystems-btrfs";

nixos/tests/os-prober.nix

···
       ${parted}/bin/parted --script /dev/vda mklabel msdos
       ${parted}/sbin/parted --script /dev/vda -- mkpart primary ext2 1M -1s
       mkdir /mnt
-      ${e2fsprogs}/bin/mkfs.ext4 /dev/vda1
+      ${e2fsprogs}/bin/mkfs.ext4 -O '^metadata_csum_seed' /dev/vda1
       ${util-linux}/bin/mount -t ext4 /dev/vda1 /mnt
 
       if test -e /mnt/.debug; then
···
           docbook5
           docbook_xsl_ns
           grub2
+          kbd
+          kbd.dev
           kmod.dev
           libarchive
           libarchive.dev

pkgs/applications/audio/tone/default.nix

···
   projectFile = "tone/tone.csproj";
   executables = [ "tone" ];
   nugetDeps = ./nuget-deps.nix;
-  dotnetBuildFlags = [ "--no-self-contained" ];
+
   dotnetInstallFlags = [
     "-p:PublishSingleFile=false"
-    "-p:PublishTrimmed=false"
-    "-p:PublishReadyToRun=false"
   ];
 
   dotnet-sdk = dotnetCorePackages.sdk_6_0;
···
     description = "A cross platform utility to dump and modify audio metadata for a wide variety of formats";
     license = licenses.asl20;
     maintainers = [ maintainers.jvanbruegge ];
-    platforms = [ "x86_64-linux" ];
+    platforms = platforms.linux;
   };
 }

pkgs/applications/audio/tone/nuget-deps.nix

···
   (fetchNuGet { pname = "Microsoft.Extensions.Options.ConfigurationExtensions"; version = "7.0.0"; sha256 = "1liyprh0zha2vgmqh92n8kkjz61zwhr7g16f0gmr297z2rg1j5pj"; })
   (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "2.0.0"; sha256 = "1xppr5jbny04slyjgngxjdm0maxdh47vq481ps944d7jrfs0p3mb"; })
   (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "7.0.0"; sha256 = "1b4km9fszid9vp2zb3gya5ni9fn8bq62bzaas2ck2r7gs0sdys80"; })
-  (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "6.0.18"; sha256 = "12661jkck5wqwc6cr8vq71lqn7k0jm0q86qxw51a0vph24m77irj"; })
   (fetchNuGet { pname = "Newtonsoft.Json"; version = "13.0.2"; sha256 = "1p9splg1min274dpz7xdfgzrwkyfd3xlkygwpr1xgjvvyjvs6b0i"; })
   (fetchNuGet { pname = "Sandreas.AudioMetadata"; version = "0.1.1"; sha256 = "11ibv23h7qj5qshibmlsqmjca51dqbhib9p1gz66c5kqhk7ci38j"; })
   (fetchNuGet { pname = "Sandreas.Files"; version = "1.1.2"; sha256 = "08qk229q2y1dpdxdnp8xi9mgk8fgpjxrxm4z6ak8n09npp67nhn0"; })

pkgs/applications/finance/denaro/default.nix

···
 { lib
-, stdenvNoCC
 , buildDotnetModule
 , fetchFromGitHub
 , dotnetCorePackages
···
   projectFile = "NickvisionMoney.GNOME/NickvisionMoney.GNOME.csproj";
   nugetDeps = ./deps.nix;
   executables = "NickvisionMoney.GNOME";
-
-  # Prevent installing native libraries for all platforms
-  dotnetBuildFlags = [ "--runtime" (dotnetCorePackages.systemToDotnetRid stdenvNoCC.hostPlatform.system) ];
-  dotnetInstallFlags = [ "--runtime" (dotnetCorePackages.systemToDotnetRid stdenvNoCC.hostPlatform.system) ];
 
   nativeBuildInputs = [
     pkg-config

pkgs/applications/misc/xdgmenumaker/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "xdgmenumaker";
-  version = "2.0";
+  version = "2.1";
 
   src = fetchFromGitHub {
     owner = "gapan";
     repo = pname;
     rev = version;
-    sha256 = "CLFFsc/F6I8UOY/XbViWCAlnnu32E5gtEXg9+KSJqI0=";
+    sha256 = "K+IecWWRjnY/5TBJydTuEPqNRSg1OIE1t0u6HkLS9uI=";
   };
 
   format = "other";

pkgs/applications/networking/browsers/firefox/common.nix

···
 
 in
 
-buildStdenv.mkDerivation ({
+buildStdenv.mkDerivation {
   pname = "${pname}-unwrapped";
   inherit version;
 
···
       hash = "sha256-fLUYaJwhrC/wF24HkuWn2PHqz7LlAaIZ1HYjRDB2w9A=";
     })
   ]
-  ++ lib.optional (lib.versionOlder version "109") [
+  ++ lib.optionals (lib.versionOlder version "109") [
     # cherry-pick bindgen change to fix build with clang 16
     (fetchpatch {
       url = "https://git.alpinelinux.org/aports/plain/community/firefox-esr/bindgen.patch?id=4c4b0c01c808657fffc5b796c56108c57301b28f";
       hash = "sha256-lTvgT358M4M2vedZ+A6xSKsBYhSN+McdmEeR9t75MLU=";
     })
   ]
-  ++ lib.optional (lib.versionOlder version "111") [
+  ++ lib.optionals (lib.versionOlder version "111") [
     # cherry-pick mp4parse change fixing build with Rust 1.70+
     # original change: https://github.com/mozilla/mp4parse-rust/commit/8b5b652d38e007e736bb442ccd5aa5ed699db100
     # vendored to update checksums
···
   dontUpdateAutotoolsGnuConfigScripts = true;
 
   requiredSystemFeatures = [ "big-parallel" ];
-})
+}

pkgs/applications/terminal-emulators/rio/default.nix

···
     fontconfig
     libGL
     vulkan-loader
-  ] ++ lib.optional withX11 [
+  ] ++ lib.optionals withX11 [
     libX11
     libXcursor
     libXi
     libXrandr
     libxcb
-  ] ++ lib.optional withWayland [
+  ] ++ lib.optionals withWayland [
     wayland
   ];
 in

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

···
+{ lib
+, fetchFromGitHub
+, buildDotnetModule
+, dotnetCorePackages
+, libX11
+, libICE
+, libSM
+, fontconfig
+, libsecret
+, gnupg
+, pass
+, withGuiSupport ? true
+, withLibsecretSupport ? true
+, withGpgSupport ? true
+}:
+
+assert withLibsecretSupport -> withGuiSupport;
+buildDotnetModule rec {
+  pname = "git-credential-manager";
+  version = "2.1.2";
+
+  src = fetchFromGitHub {
+    owner = "git-ecosystem";
+    repo = "git-credential-manager";
+    rev = "v${version}";
+    hash = "sha256-PeQ9atSCgSvduAcqY2CnNJH3ucvoInduA5i8dPUJiHo=";
+  };
+
+  projectFile = "src/shared/Git-Credential-Manager/Git-Credential-Manager.csproj";
+  nugetDeps = ./deps.nix;
+  dotnet-sdk = dotnetCorePackages.sdk_6_0;
+  dotnet-runtime = dotnetCorePackages.runtime_6_0;
+  dotnetInstallFlags = [ "--framework" "net6.0" ];
+  executables = [ "git-credential-manager" ];
+
+  runtimeDeps = [ fontconfig ]
+    ++ lib.optionals withGuiSupport [ libX11 libICE libSM ]
+    ++ lib.optional withLibsecretSupport libsecret;
+  makeWrapperArgs = lib.optionals withGpgSupport [ "--prefix" "PATH" ":" (lib.makeBinPath [ gnupg pass ]) ];
+
+  passthru.updateScript = ./update.sh;
+
+  meta = with lib; {
+    description = "Secure, cross-platform Git credential storage with authentication to GitHub, Azure Repos, and other popular Git hosting services.";
+    homepage = "https://github.com/git-ecosystem/git-credential-manager";
+    license = with licenses; [ mit ];
+    platforms = platforms.unix;
+    maintainers = with maintainers; [ _999eagle ];
+  };
+}

pkgs/applications/version-management/git-credential-manager/deps.nix

···
+# This file was automatically generated by passthru.fetch-deps.
+# Please dont edit it manually, your changes might get overwritten!
+
+{ fetchNuGet }: [
+  (fetchNuGet { pname = "Avalonia"; version = "11.0.0-preview6"; sha256 = "14m7bg6ric8hpa2kmkhff6hpljfa73snbkj8fqida7hfd0nhggyl"; })
+  (fetchNuGet { pname = "Avalonia.Angle.Windows.Natives"; version = "2.1.0.2023020321"; sha256 = "1az4s1g22ipak9a3xfh55z2h3rm6lpqh7svbpw6ag4ysrgsjjsjd"; })
+  (fetchNuGet { pname = "Avalonia.Controls.ColorPicker"; version = "11.0.0-preview6"; sha256 = "12lps97bqgd65z0y4d73ql2rcxaaaylb2x8fqvkb2jbrd76n30wz"; })
+  (fetchNuGet { pname = "Avalonia.Controls.DataGrid"; version = "11.0.0-preview6"; sha256 = "1kk4ids80gzkf8llasmcairmmz6yfsi7mbld21gb3sdwdf0wf92y"; })
+  (fetchNuGet { pname = "Avalonia.Desktop"; version = "11.0.0-preview6"; sha256 = "18rabqzs5namzi0y6435blm6j54cnwsc8bkq2daj9bim5njy56pm"; })
+  (fetchNuGet { pname = "Avalonia.Diagnostics"; version = "11.0.0-preview6"; sha256 = "0l9c7zakk17xyag9cl9nxq4j6wzlr6kgzzwpl7zwj7f3vypxlp6v"; })
+  (fetchNuGet { pname = "Avalonia.FreeDesktop"; version = "11.0.0-preview6"; sha256 = "0ni3y5qkpsz2s5hflkipwmpmb21b2mfs6h06rrvrq95m4l0bil7i"; })
+  (fetchNuGet { pname = "Avalonia.Native"; version = "11.0.0-preview6"; sha256 = "0m1zbcbypj06xkmyjx56smh5smi02gdvn6xbqi92k185aiiwicj1"; })
+  (fetchNuGet { pname = "Avalonia.Remote.Protocol"; version = "11.0.0-preview6"; sha256 = "0wws5z8vmagzh7x47mlgf780579d5zqv0hyd649sycdxkaadcz5r"; })
+  (fetchNuGet { pname = "Avalonia.Skia"; version = "11.0.0-preview6"; sha256 = "15572ibkb7ihgdmcxzj3avb1g4lcqrjxdxgf66ifvfyjj49vfi8h"; })
+  (fetchNuGet { pname = "Avalonia.Themes.Fluent"; version = "11.0.0-preview6"; sha256 = "1hm8ax9bq7vj458f2lrcppv3ylc6zmmdwp6zkbf2s6fv7nhvpmgf"; })
+  (fetchNuGet { pname = "Avalonia.Themes.Simple"; version = "11.0.0-preview6"; sha256 = "1b1y2a3bkwz38a5nvwqhw23gp10a63046qiprapyxp589gbkf8cj"; })
+  (fetchNuGet { pname = "Avalonia.Win32"; version = "11.0.0-preview6"; sha256 = "0img9zmrppikzgw48j5a3svcrv9skbh13wzrdqnk0648n8fgj9k4"; })
+  (fetchNuGet { pname = "Avalonia.X11"; version = "11.0.0-preview6"; sha256 = "04923qvlpgszr1zlcg0pfxzsgqgdjcrpqgkqlrlp62ac6yv8dr9g"; })
+  (fetchNuGet { pname = "HarfBuzzSharp"; version = "2.8.2.3"; sha256 = "115aybicqs9ijjlcv6k6r5v0agkjm1bm1nkd0rj3jglv8s0xvmp2"; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Linux"; version = "2.8.2.3"; sha256 = "1f18ahwkaginrg0vwsi6s56lvnqvvxv7pzklfs5lnknasxy1a76z"; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.macOS"; version = "2.8.2.3"; sha256 = "052d8frpkj4ijs6fm6xp55xbv95b1s9biqwa0w8zp3rgm88m9236"; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.WebAssembly"; version = "2.8.2.3"; sha256 = "043hv36bg5240znbm8x5la7py17m4jfzy57q3ka32f6zjld83j36"; })
+  (fetchNuGet { pname = "HarfBuzzSharp.NativeAssets.Win32"; version = "2.8.2.3"; sha256 = "08khd2jqm8sw58ljz5srangzfm2sz3gd2q1jzc5fr80lj8rv6r74"; })
+  (fetchNuGet { pname = "MicroCom.Runtime"; version = "0.11.0"; sha256 = "0p9c3m0zk59x9dcqw077hzd2yk60myisbacvm36mnwpcjwzjkp2m"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Analyzers"; version = "3.0.0"; sha256 = "0bbl0jpqywqmzz2gagld1p2gvdfldjfjmm25hil9wj2nq1zc4di8"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Common"; version = "3.8.0"; sha256 = "12n7rvr39bzkf2maw7zplw8rwpxpxss4ich3bb2pw770rx4nyvyw"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp"; version = "3.8.0"; sha256 = "1kmry65csvfn72zzc16vj1nfbfwam28wcmlrk3m5rzb8ydbzgylb"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.CSharp.Scripting"; version = "3.8.0"; sha256 = "0w0yx0lpg54iw5jazqk46h48gx43ij32gwac8iywdj6kxfxm03vw"; })
+  (fetchNuGet { pname = "Microsoft.CodeAnalysis.Scripting.Common"; version = "3.8.0"; sha256 = "0hjgxcsj5zy27lqk0986m59n5dbplx2vjjla2lsvg4bwg8qa7bpk"; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.3.0"; sha256 = "0gw297dgkh0al1zxvgvncqs0j15lsna9l1wpqas4rflmys440xvb"; })
+  (fetchNuGet { pname = "Microsoft.CSharp"; version = "4.4.1"; sha256 = "0z6d1i6xcf0c00z6rs75rgw4ncs9q2m8amasf6mmbf40fm02ry7g"; })
+  (fetchNuGet { pname = "Microsoft.Identity.Client"; version = "4.52.0"; sha256 = "0g7bzzm04lrfar3l1rl1lsb0q1nm0ix5fc24bhm4faxvzdyd3vg7"; })
+  (fetchNuGet { pname = "Microsoft.Identity.Client.Extensions.Msal"; version = "2.28.0"; sha256 = "1z2irqbjqxawyxq2778bcjbj0x8m63dh3lj5m04knq48wl4wh40x"; })
+  (fetchNuGet { pname = "Microsoft.IdentityModel.Abstractions"; version = "6.22.0"; sha256 = "06495i2i9cabys4s0dkaz0rby8k47gy627v9ivp7aa3k6xmypviz"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.0"; sha256 = "08vh1r12g6ykjygq5d3vq09zylgb84l63k49jc4v8faw9g93iqqm"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "2.1.2"; sha256 = "1507hnpr9my3z4w1r6xk5n0s1j3y6a2c2cnynj76za7cphxi1141"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "5.0.0"; sha256 = "0mwpwdflidzgzfx2dlpkvvnkgkr2ayaf0s80737h4wa35gaj11rc"; })
+  (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.0"; sha256 = "193xwf33fbm0ni3idxzbr5fdq3i2dlfgihsac9jj7whj0gd902nh"; })
+  (fetchNuGet { pname = "Microsoft.Win32.SystemEvents"; version = "6.0.0"; sha256 = "0c6pcj088g1yd1vs529q3ybgsd2vjlk5y1ic6dkmbhvrp5jibl9p"; })
+  (fetchNuGet { pname = "Newtonsoft.Json"; version = "13.0.1"; sha256 = "0fijg0w6iwap8gvzyjnndds0q4b8anwxxvik7y8vgq97dram4srb"; })
+  (fetchNuGet { pname = "SkiaSharp"; version = "2.88.3"; sha256 = "1yq694myq2rhfp2hwwpyzcg1pzpxcp7j72wib8p9pw9dfj7008sv"; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.Linux"; version = "2.88.3"; sha256 = "0dajvr60nwvnv7s6kcqgw1w97zxdpz1c5lb7kcq7r0hi0l05ck3q"; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.macOS"; version = "2.88.3"; sha256 = "191ajgi6fnfqcvqvkayjsxasiz6l0bv3pps8vv9abbyc4b12qvph"; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.WebAssembly"; version = "2.88.3"; sha256 = "1w5njksq3amrrp7fqxw89nv6ar2kgc5yx092i4rxv7hrjbd1aagx"; })
+  (fetchNuGet { pname = "SkiaSharp.NativeAssets.Win32"; version = "2.88.3"; sha256 = "03wwfbarsxjnk70qhqyd1dw65098dncqk2m0vksx92j70i7lry6q"; })
+  (fetchNuGet { pname = "System.Collections"; version = "4.3.0"; sha256 = "19r4y64dqyrq6k4706dnyhhw7fs24kpp3awak7whzss39dakpxk9"; })
+  (fetchNuGet { pname = "System.Collections.Immutable"; version = "5.0.0"; sha256 = "1kvcllagxz2q92g81zkz81djkn2lid25ayjfgjalncyc68i15p0r"; })
+  (fetchNuGet { pname = "System.CommandLine"; version = "2.0.0-beta1.21216.1"; sha256 = "10p3i10sh9aarqfzac3bgmv9zabb8m5c2aylf3chwlh71kp9l63l"; })
+  (fetchNuGet { pname = "System.ComponentModel.Annotations"; version = "4.5.0"; sha256 = "1jj6f6g87k0iwsgmg3xmnn67a14mq88np0l1ys5zkxhkvbc8976p"; })
+  (fetchNuGet { pname = "System.Diagnostics.Debug"; version = "4.3.0"; sha256 = "00yjlf19wjydyr6cfviaph3vsjzg3d5nvnya26i2fvfg53sknh3y"; })
+  (fetchNuGet { pname = "System.Drawing.Common"; version = "6.0.0"; sha256 = "02n8rzm58dac2np8b3xw8ychbvylja4nh6938l5k2fhyn40imlgz"; })
+  (fetchNuGet { pname = "System.Dynamic.Runtime"; version = "4.3.0"; sha256 = "1d951hrvrpndk7insiag80qxjbf2y0y39y8h5hnq9612ws661glk"; })
+  (fetchNuGet { pname = "System.Globalization"; version = "4.3.0"; sha256 = "1cp68vv683n6ic2zqh2s1fn4c2sd87g5hpp6l4d4nj4536jz98ki"; })
+  (fetchNuGet { pname = "System.IO"; version = "4.3.0"; sha256 = "05l9qdrzhm4s5dixmx68kxwif4l99ll5gqmh7rqgw554fx0agv5f"; })
+  (fetchNuGet { pname = "System.IO.FileSystem.AccessControl"; version = "5.0.0"; sha256 = "0ixl68plva0fsj3byv76bai7vkin86s6wyzr8vcav3szl862blvk"; })
+  (fetchNuGet { pname = "System.IO.Pipelines"; version = "6.0.0"; sha256 = "08211lvckdsdbd67xz4f6cyk76cli565j0dby1grlc4k9bhwby65"; })
+  (fetchNuGet { pname = "System.Linq"; version = "4.3.0"; sha256 = "1w0gmba695rbr80l1k2h4mrwzbzsyfl2z4klmpbsvsg5pm4a56s7"; })
+  (fetchNuGet { pname = "System.Linq.Expressions"; version = "4.3.0"; sha256 = "0ky2nrcvh70rqq88m9a5yqabsl4fyd17bpr63iy2mbivjs2nyypv"; })
+  (fetchNuGet { pname = "System.Memory"; version = "4.5.4"; sha256 = "14gbbs22mcxwggn0fcfs1b062521azb9fbb7c113x0mq6dzq9h6y"; })
+  (fetchNuGet { pname = "System.Numerics.Vectors"; version = "4.5.0"; sha256 = "1kzrj37yzawf1b19jq0253rcs8hsq1l2q8g69d7ipnhzb0h97m59"; })
+  (fetchNuGet { pname = "System.ObjectModel"; version = "4.3.0"; sha256 = "191p63zy5rpqx7dnrb3h7prvgixmk168fhvvkkvhlazncf8r3nc2"; })
+  (fetchNuGet { pname = "System.Reflection"; version = "4.3.0"; sha256 = "0xl55k0mw8cd8ra6dxzh974nxif58s3k1rjv1vbd7gjbjr39j11m"; })
+  (fetchNuGet { pname = "System.Reflection.Emit"; version = "4.3.0"; sha256 = "11f8y3qfysfcrscjpjym9msk7lsfxkk4fmz9qq95kn3jd0769f74"; })
+  (fetchNuGet { pname = "System.Reflection.Emit.ILGeneration"; version = "4.3.0"; sha256 = "0w1n67glpv8241vnpz1kl14sy7zlnw414aqwj4hcx5nd86f6994q"; })
+  (fetchNuGet { pname = "System.Reflection.Emit.Lightweight"; version = "4.3.0"; sha256 = "0ql7lcakycrvzgi9kxz1b3lljd990az1x6c4jsiwcacrvimpib5c"; })
+  (fetchNuGet { pname = "System.Reflection.Extensions"; version = "4.3.0"; sha256 = "02bly8bdc98gs22lqsfx9xicblszr2yan7v2mmw3g7hy6miq5hwq"; })
+  (fetchNuGet { pname = "System.Reflection.Metadata"; version = "5.0.0"; sha256 = "17qsl5nanlqk9iz0l5wijdn6ka632fs1m1fvx18dfgswm258r3ss"; })
+  (fetchNuGet { pname = "System.Reflection.Primitives"; version = "4.3.0"; sha256 = "04xqa33bld78yv5r93a8n76shvc8wwcdgr1qvvjh959g3rc31276"; })
+  (fetchNuGet { pname = "System.Reflection.TypeExtensions"; version = "4.3.0"; sha256 = "0y2ssg08d817p0vdag98vn238gyrrynjdj4181hdg780sif3ykp1"; })
+  (fetchNuGet { pname = "System.Resources.ResourceManager"; version = "4.3.0"; sha256 = "0sjqlzsryb0mg4y4xzf35xi523s4is4hz9q4qgdvlvgivl7qxn49"; })
+  (fetchNuGet { pname = "System.Runtime"; version = "4.3.0"; sha256 = "066ixvgbf2c929kgknshcxqj6539ax7b9m570cp8n179cpfkapz7"; })
+  (fetchNuGet { pname = "System.Runtime.CompilerServices.Unsafe"; version = "4.7.1"; sha256 = "119br3pd85lq8zcgh4f60jzmv1g976q1kdgi3hvqdlhfbw6siz2j"; })
+  (fetchNuGet { pname = "System.Runtime.Extensions"; version = "4.3.0"; sha256 = "1ykp3dnhwvm48nap8q23893hagf665k0kn3cbgsqpwzbijdcgc60"; })
+  (fetchNuGet { pname = "System.Runtime.Handles"; version = "4.3.0"; sha256 = "0sw2gfj2xr7sw9qjn0j3l9yw07x73lcs97p8xfc9w1x9h5g5m7i8"; })
+  (fetchNuGet { pname = "System.Runtime.InteropServices"; version = "4.3.0"; sha256 = "00hywrn4g7hva1b2qri2s6rabzwgxnbpw9zfxmz28z09cpwwgh7j"; })
+  (fetchNuGet { pname = "System.Security.AccessControl"; version = "5.0.0"; sha256 = "17n3lrrl6vahkqmhlpn3w20afgz09n7i6rv0r3qypngwi7wqdr5r"; })
+  (fetchNuGet { pname = "System.Security.Cryptography.ProtectedData"; version = "4.5.0"; sha256 = "11qlc8q6b7xlspayv07718ibzvlj6ddqqxkvcbxv5b24d5kzbrb7"; })
+  (fetchNuGet { pname = "System.Security.Principal.Windows"; version = "5.0.0"; sha256 = "1mpk7xj76lxgz97a5yg93wi8lj0l8p157a5d50mmjy3gbz1904q8"; })
+  (fetchNuGet { pname = "System.Text.Encoding"; version = "4.3.0"; sha256 = "1f04lkir4iladpp51sdgmis9dj4y8v08cka0mbmsy0frc9a4gjqr"; })
+  (fetchNuGet { pname = "System.Text.Encoding.CodePages"; version = "4.5.1"; sha256 = "1z21qyfs6sg76rp68qdx0c9iy57naan89pg7p6i3qpj8kyzn921w"; })
+  (fetchNuGet { pname = "System.Threading"; version = "4.3.0"; sha256 = "0rw9wfamvhayp5zh3j7p1yfmx9b5khbf4q50d8k5rk993rskfd34"; })
+  (fetchNuGet { pname = "System.Threading.Tasks"; version = "4.3.0"; sha256 = "134z3v9abw3a6jsw17xl3f6hqjpak5l682k2vz39spj4kmydg6k7"; })
+  (fetchNuGet { pname = "System.Threading.Tasks.Extensions"; version = "4.5.4"; sha256 = "0y6ncasgfcgnjrhynaf0lwpkpkmv4a07sswwkwbwb5h7riisj153"; })
+  (fetchNuGet { pname = "Tmds.DBus.Protocol"; version = "0.14.0"; sha256 = "1j7ifcv621z5kjafs0c1qw4xcgv4kd4hwp0qamhcrllvshd2mabq"; })
+  (fetchNuGet { pname = "Tmds.DBus.SourceGenerator"; version = "0.0.4"; sha256 = "16qa3xi0ip2nvgnjjqj64ppjdrf4p4skrfqzfnb39rp0k7v8smfx"; })
+]

pkgs/applications/version-management/git-credential-manager/update.sh

···
+#!/usr/bin/env nix-shell
+#!nix-shell -i bash -p curl jq nix-prefetch nix coreutils gnused
+
+cd "$(dirname "$0")"
+
+set -euo pipefail
+
+latestVersion="$(curl -s "https://api.github.com/repos/git-ecosystem/git-credential-manager/releases?per_page=1" | jq -r ".[0].tag_name" | sed 's/^v//')"
+currentVersion="$(nix-instantiate --eval -E "with import ../../../.. {}; git-credential-manager.version" | tr -d '"')"
+
+if [[ "$latestVersion" == "$currentVersion" ]]; then
+    echo "up to date"
+    exit 0
+fi
+
+echo "updating $currentVersion -> $latestVersion"
+
+sed -i -e "s/version = \"${currentVersion}\"/version = \"${latestVersion}\"/" default.nix
+hash="$(nix-prefetch ./.)"
+sed -i -Ee "s/hash = \"sha256-[A-Za-z0-9=]{44}\"/hash = \"${hash}\"/" default.nix
+
+
+nugetDeps="$(realpath ./deps.nix)"
+$(nix-build ../../../.. -A git-credential-manager.fetch-deps --no-out-link) "$nugetDeps"

pkgs/build-support/dotnet/build-dotnet-module/hooks/default.nix

···
 , stdenv
 , which
 , coreutils
+, zlib
+, openssl
 , callPackage
 , makeSetupHook
 , makeWrapper
···
       propagatedBuildInputs = [ dotnet-sdk nuget-source ];
       substitutions = {
         nugetSource = nuget-source;
+        dynamicLinker = "${stdenv.cc}/nix-support/dynamic-linker";
+        libPath = lib.makeLibraryPath [
+          stdenv.cc.cc.lib
+          stdenv.cc.libc
+          dotnet-sdk.passthru.icu
+          zlib
+          openssl
+        ];
         inherit runtimeId;
       };
     } ./dotnet-configure-hook.sh) { };
···
       name = "dotnet-check-hook";
       propagatedBuildInputs = [ dotnet-test-sdk ];
       substitutions = {
-        inherit buildType libraryPath;
+        inherit buildType runtimeId libraryPath;
         disabledTests = lib.optionalString (disabledTests != [])
           (let
             escapedNames = lib.lists.map (n: lib.replaceStrings [","] ["%2C"] n) disabledTests;

pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-build-hook.sh

···
     fi
 
     if [ "${selfContainedBuild-}" ]; then
-        dotnetBuildFlags+=(--runtime "@runtimeId@" "-p:SelfContained=true")
+        dotnetBuildFlags+=("-p:SelfContained=true")
     else
         dotnetBuildFlags+=("-p:SelfContained=false")
     fi
···
 
     dotnetBuild() {
         local -r project="${1-}"
+
+        runtimeIdFlags=()
+        if [[ "$project" == *.csproj ]] || [ "${selfContainedBuild-}" ]; then
+            runtimeIdFlags+=("--runtime @runtimeId@")
+        fi
+
         env dotnet build ${project-} \
             -maxcpucount:$maxCpuFlag \
             -p:BuildInParallel=$parallelBuildFlag \
···
             --configuration "@buildType@" \
             --no-restore \
             ${versionFlag-} \
+            ${runtimeIdFlags[@]} \
             ${dotnetBuildFlags[@]}  \
             ${dotnetFlags[@]}
     }

pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-check-hook.sh

···
     fi
 
     for project in ${testProjectFile[@]-${projectFile[@]}}; do
+        runtimeIdFlags=()
+        if [[ "$project" == *.csproj ]]; then
+            runtimeIdFlags=("--runtime @runtimeId@")
+        fi
+
         env "LD_LIBRARY_PATH=@libraryPath@" \
             dotnet test "$project" \
               -maxcpucount:$maxCpuFlag \
···
               --no-build \
               --logger "console;verbosity=normal" \
               ${disabledTestsFlag-} \
+              ${runtimeIdFlags[@]} \
               "${dotnetTestFlags[@]}"  \
               "${dotnetFlags[@]}"
     done

pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-configure-hook.sh

···
         dotnetRestore "$project"
     done
 
+    echo "Fixing up native binaries..."
+    # Find all native binaries and nuget libraries, and fix them up,
+    # by setting the proper interpreter and rpath to some commonly used libraries
+    for binary in $(find "$HOME/.nuget/packages/" -type f -executable); do
+        if patchelf --print-interpreter "$binary" >/dev/null 2>/dev/null; then
+            echo "Found binary: $binary, fixing it up..."
+            patchelf --set-interpreter "$(cat "@dynamicLinker@")" "$binary"
+
+            # This makes sure that if the binary requires some specific runtime dependencies, it can find it.
+            # This fixes dotnet-built binaries like crossgen2
+            patchelf \
+                --add-needed libicui18n.so \
+                --add-needed libicuuc.so \
+                --add-needed libz.so \
+                --add-needed libssl.so \
+                "$binary"
+
+            patchelf --set-rpath "@libPath@" "$binary"
+        fi
+    done
+
     runHook postConfigure
 
     echo "Finished dotnetConfigureHook"

pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-install-hook.sh

···
     runHook preInstall
 
     if [ "${selfContainedBuild-}" ]; then
-        dotnetInstallFlags+=(--runtime "@runtimeId@" "--self-contained")
+        dotnetInstallFlags+=("--self-contained")
     else
         dotnetInstallFlags+=("--no-self-contained")
+        # https://learn.microsoft.com/en-us/dotnet/core/deploying/trimming/trim-self-contained
+        # Trimming is only available for self-contained build, so force disable it here
+        dotnetInstallFlags+=("-p:PublishTrimmed=false")
     fi
 
     if [ "${useAppHost-}" ]; then
···
 
     dotnetPublish() {
         local -r project="${1-}"
+
+        runtimeIdFlags=()
+        if [[ "$project" == *.csproj ]] || [ "${selfContainedBuild-}" ]; then
+            runtimeIdFlags+=("--runtime @runtimeId@")
+        fi
+
         env dotnet publish ${project-} \
             -p:ContinuousIntegrationBuild=true \
             -p:Deterministic=true \
             --output "$out/lib/${pname}" \
             --configuration "@buildType@" \
             --no-build \
+            ${runtimeIdFlags[@]} \
             ${dotnetInstallFlags[@]}  \
             ${dotnetFlags[@]}
     }
···
              --output "$out/share" \
              --configuration "@buildType@" \
              --no-build \
+            --runtime "@runtimeId@" \
              ${dotnetPackFlags[@]}  \
              ${dotnetFlags[@]}
     }

pkgs/build-support/vm/default.nix

···
         url = "https://snapshot.debian.org/archive/debian/20221126T084953Z/dists/buster/main/binary-i386/Packages.xz";
         hash = "sha256-n9JquhtZgxw3qr9BX0MQoY3ZTIHN0dit+iru3DC31UY=";
       };
-      urlPrefix = "mirror://debian";
+      urlPrefix = "https://snapshot.debian.org/archive/debian/20221126T084953Z";
       packages = commonDebianPackages;
     };
 
···
         url = "https://snapshot.debian.org/archive/debian/20221126T084953Z/dists/buster/main/binary-amd64/Packages.xz";
         hash = "sha256-YukIIB3u87jgp9oudwklsxyKVKjSL618wFgDSXiFmjU=";
       };
-      urlPrefix = "mirror://debian";
+      urlPrefix = "https://snapshot.debian.org/archive/debian/20221126T084953Z";
       packages = commonDebianPackages;
     };
 
···
         url = "https://snapshot.debian.org/archive/debian/20230131T034648Z/dists/bullseye/main/binary-i386/Packages.xz";
         hash = "sha256-z9eG7RlvelEnZAaeCfIO+XxTZVL3d+zTA7ShU43l/pw=";
       };
-      urlPrefix = "mirror://debian";
+      urlPrefix = "https://snapshot.debian.org/archive/debian/20230131T034648Z";
       packages = commonDebianPackages;
     };
 
···
         url = "https://snapshot.debian.org/archive/debian/20230131T034648Z/dists/bullseye/main/binary-amd64/Packages.xz";
         hash = "sha256-mz0eCWdn6uWt40OxsSPheHzEnMeLE52yR/vpb48/VF0=";
       };
-      urlPrefix = "mirror://debian";
+      urlPrefix = "https://snapshot.debian.org/archive/debian/20230131T034648Z";
       packages = commonDebianPackages;
     };
   };

pkgs/desktops/gnome/extensions/buildGnomeExtension.nix

···
         echo "${metadata}" | base64 --decode > $out/metadata.json
       '';
     };
-    nativeBuildInputs = with pkgs; [ glib ];
+    nativeBuildInputs = with pkgs; [ buildPackages.glib ];
     buildPhase = ''
       runHook preBuild
       if [ -d schemas ]; then

pkgs/development/compilers/dotnet/build-dotnet.nix

···
     export DOTNET_CLI_TELEMETRY_OPTOUT=1
   '';
 
-  passthru = rec {
+  passthru = {
     inherit icu;
     packages = packageDeps;
 

pkgs/development/compilers/dotnet/default.nix

···
 Hashes and urls are retrieved from:
 https://dotnet.microsoft.com/download/dotnet
 */
-{ callPackage,}:
+{ callPackage }:
 let
   buildDotnet = attrs: callPackage (import ./build-dotnet.nix attrs) {};
   buildAttrs = {
···
   # Convert a "stdenv.hostPlatform.system" to a dotnet RID
   systemToDotnetRid = system: runtimeIdentifierMap.${system} or (throw "unsupported platform ${system}");
 in
-rec {
+{
   inherit systemToDotnetRid;
 
   combinePackages = attrs: callPackage (import ./combine-packages.nix attrs) {};

pkgs/development/compilers/dotnet/update.sh

···
       "runtime.osx-arm64.Microsoft.NETCore.DotNetHost" \
       "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy" \
       "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver" \
+      "Microsoft.NETCore.App.Crossgen2.linux-musl-arm" \
+      "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64" \
+      "Microsoft.NETCore.App.Crossgen2.linux-musl-x64" \
+      "Microsoft.NETCore.App.Crossgen2.linux-arm" \
+      "Microsoft.NETCore.App.Crossgen2.linux-arm64" \
+      "Microsoft.NETCore.App.Crossgen2.linux-x64" \
+      "Microsoft.NETCore.App.Crossgen2.osx-x64" \
+      "Microsoft.NETCore.App.Crossgen2.osx-arm64"
     )
 
     # Packages that only apply to .NET 7 and up

pkgs/development/compilers/dotnet/versions/6.0.nix

···
       (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHost"; version = "6.0.18"; sha256 = "0c95g1kapwsrbz51myhzpd1wviwlhvknhyfl3q5jy03z1kymxscj"; })
       (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "6.0.18"; sha256 = "1iy2n5b3wwarsrkhm937f87rir7md45m5hm51qfzr5i3bx5vabcg"; })
       (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "6.0.18"; sha256 = "09f5dcdvnfs9ax5i4b6kqpj7frhw66madla71i2m3azayqd0kis1"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "6.0.18"; sha256 = "1wx2kpgprpzm95h314hxjwfx3qglsy1g3ssrk34n4znswxf68czd"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "6.0.18"; sha256 = "07yfp1mn4pk81ispcxz513vkgzjc0295wvlhb2lyfly70j5221vh"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "6.0.18"; sha256 = "0fw1i6zc9jzbsk5gkz3ns9qcsi58mjn6g8wq2y67amacc3m918aw"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "6.0.18"; sha256 = "1yfxlcxrrpmgn5m415wxnca4xd6gy9z0wqrlhk8v6n33gzhyr84y"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "6.0.18"; sha256 = "0yqwq66fnbylgwxvrin3qkmhza1ciq73x4sl54dgq7vj4sz7r0q3"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "6.0.18"; sha256 = "12661jkck5wqwc6cr8vq71lqn7k0jm0q86qxw51a0vph24m77irj"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "6.0.18"; sha256 = "16x0mlckhlaqq9lm8d50mg4fhb7290vc4kp6gdk6bxg9j1nl9pza"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "6.0.18"; sha256 = "0k30ck2gkv09g8jgalnrdiz39i6lpsq9ky1c9y35dvg0mclcixc3"; })
     ];
   };
 }

pkgs/development/compilers/dotnet/versions/7.0.nix

···
       (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHost"; version = "7.0.7"; sha256 = "1x0bd7b6yjm38k64df1l7jwl6fn1n0wgba8pxrb1dw97ijcq6pds"; })
       (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "7.0.7"; sha256 = "0cri9fbrsdah7xr4x9qy73n3pj0zmrwc8xc8a8zj299xmjx41srp"; })
       (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "7.0.7"; sha256 = "0dp8j9dc46v46zza9i4i7ywn3cz43fxyhzhiwls6nzc9z0y3xnjb"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "7.0.7"; sha256 = "1difx4s84s5s8yq66qc8j7ldzchlj8han4syalnfw4mx35syh3r9"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "7.0.7"; sha256 = "0dkzcanshijp0x836rdj1bydpzxnvwk13jjils9kl0503yk91ln5"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "7.0.7"; sha256 = "1a4m6dkl7plsxv3m0b64nkmdbh6jif0qxi2861qpdh8wd904nl51"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "7.0.7"; sha256 = "0yb7rycgcvd4rg3rqb56pqfyqrixyz8a0j0iacsb5773k1l2c0lr"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "7.0.7"; sha256 = "0myh03v7czlc1sm3b9gqn4m5qm94vc6qar483678mi3d6fmb0c7x"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "7.0.7"; sha256 = "1fq4zy6af3pidsjqi663kb6354cpayyrd30hd1zhfm14kz00cgg5"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "7.0.7"; sha256 = "1x15r1d66s0qn9s9lj5dad4g6qfx0pmphix7nbw88pb2fp2az0ia"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "7.0.7"; sha256 = "0dd67jl5hd0mq1vl51f4nn4s6pwhssldj7gn4y2adb2vlpwd5zq7"; })
       (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler"; version = "7.0.7"; sha256 = "12ayxmqacv8n38vvp79g23wd443zs2ws8k64p08pr8aymcpx22k6"; })
       (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler"; version = "7.0.7"; sha256 = "1bm9rzs5lr6a8qxavy7drjv5z1vwxyh1fcv9cag2d7g91q9ljhxn"; })
       (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler"; version = "7.0.7"; sha256 = "1hb8dd0hwmng2j6bk1s76lkl9ap1rw687cjccv5g79h30fadcf2s"; })

pkgs/development/compilers/dotnet/versions/8.0.nix

···
       (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.0-preview.5.23280.8"; sha256 = "13iavci8n0ahsl5k1xasribk93gmkxd3s67xgagasc1gzpkxm8q2"; })
       (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.0-preview.5.23280.8"; sha256 = "16aa6sgblm4l1fzsgllmxsxn57qnx430z12n6hm3m08qrlmcpyd9"; })
       (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.0-preview.5.23280.8"; sha256 = "05k0h0p6yc02np4m7jdhmc8c2105b22wdldbsklx4rl3jqy7m6p3"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "8.0.0-preview.5.23280.8"; sha256 = "1yvaiqblqmsrydbf9gr18rp6d9rqqpzahzxhc62hixfh59l55mi7"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "8.0.0-preview.5.23280.8"; sha256 = "06i72xhd0ji755wj8bczv8x8mynyf2kxhx7ysn70crrkk0b7921h"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "8.0.0-preview.5.23280.8"; sha256 = "02ks9j1mybb3f34mjky09nw22la6nhfmkjj5g5gczspqfcc6a2dw"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "8.0.0-preview.5.23280.8"; sha256 = "15plhhljfyaj0cdpsqyq3n0q747p90nvl5kwj6amccadkcy7ahnk"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "8.0.0-preview.5.23280.8"; sha256 = "09vvjm9a7nh6bd8ldf1f0vz1iafp4v77q5d78382hfqan8r505id"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "8.0.0-preview.5.23280.8"; sha256 = "1p21siacj11nbba5czcg4ppk7wny2p3rc2wxg30vs1jj45qvf82c"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "8.0.0-preview.5.23280.8"; sha256 = "1h6xrjvgn0bl615bwmr5l5gpw4qxhbzsqd7sb57m8597cjqc8m35"; })
+      (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "8.0.0-preview.5.23280.8"; sha256 = "0fymmvixx0wh1qa5hrazfr27n0hr3dj1gppipy3mslm325m1zdf4"; })
       (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.0-preview.5.23280.8"; sha256 = "0z6cny0jzbwd7skgc3lji00j1z061j4yacrjbhysnq5z5g563r75"; })
       (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.0-preview.5.23280.8"; sha256 = "0f72algnr7kknbvw1b17vlw6wvkghw8v4n9fji7ppwbrd8g8i8b0"; })
       (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.0-preview.5.23280.8"; sha256 = "1bcps96s8n5iwshxjqwbdvhhr5nkh1f1hn4k79gw1q8ic1c4giq9"; })

pkgs/development/libraries/libvirt/default.nix

···
   # NOTE: You must also bump:
   # <nixpkgs/pkgs/development/python-modules/libvirt/default.nix>
   # SysVirt in <nixpkgs/pkgs/top-level/perl-packages.nix>
-  version = "9.2.0";
+  version = "9.4.0";
 
   src = fetchFromGitLab {
     owner = pname;
     repo = pname;
     rev = "v${version}";
-    sha256 = "sha256-uASIfQVbY/5I/PELEB6EGzzHfcgY4jIolbyH05TgiLA=";
+    sha256 = "sha256-aYLXiZtbNXwJ8qmTHXv2OnyrYWK7KbwQWulTeuTbe0k=";
     fetchSubmodules = true;
   };
 

pkgs/development/libraries/symengine/default.nix

···
-{ lib, stdenv
+{ lib
+, stdenv
 , fetchFromGitHub
 , cmake
 , gmp
 , flint
 , mpfr
 , libmpc
-, catch
+, withShared ? true
 }:
 
 stdenv.mkDerivation rec {
   pname = "symengine";
-  version = "0.9.0";
+  version = "0.10.1";
 
   src = fetchFromGitHub {
     owner = "symengine";
     repo = "symengine";
     rev = "v${version}";
-    sha256 = "sha256-5KpxBusJCuwrfFWHbrRKlH6Ic7YivYqz2m+BCbNfZp0=";
+    hash = "sha256-qTu0vS9K6rrr/0SXKpGC9P1QSN/AN7hyO/4DrGvhxWM=";
   };
 
-  postPatch = ''
-    cp ${catch}/include/catch/catch.hpp symengine/utilities/catch/catch.hpp
-  '';
-
   nativeBuildInputs = [ cmake ];
 
   buildInputs = [ gmp flint mpfr libmpc ];
···
   ] ++ lib.optionals (stdenv.isDarwin && stdenv.isAarch64) [
     # error: unrecognized instruction mnemonic, did you mean: bit, cnt, hint, ins, not?
     "-DBUILD_TESTS=OFF"
+  ] ++ lib.optionals withShared [
+    "-DBUILD_SHARED_LIBS=ON"
   ];
 
   doCheck = true;
-
-  checkPhase = ''
-    ctest
-  '';
 
   meta = with lib; {
     description = "A fast symbolic manipulation library";

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

···
 
 buildPythonPackage rec {
   pname = "black";
-  version = "23.1.0";
+  version = "23.3.0";
   format = "pyproject";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-sL2XvqiQP1orpyGSV6ROPx+dAAc9bMGt1o8L7saWkqw=";
+    hash = "sha256-HHuNYG5yikHqHMvXJkZ35JTofPYw45kmLO2S1KjayUA=";
   };
 
   nativeBuildInputs = [

pkgs/development/python-modules/google-cloud-bigquery/default.nix

···
 
 buildPythonPackage rec {
   pname = "google-cloud-bigquery";
-  version = "3.11.1";
+  version = "3.11.2";
   format = "setuptools";
 
   disabled = pythonOlder "3.7";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-z+EVi8WBgna6dllZ2oonr9zaoR+j+p7tCX1WOSl9/nQ=";
+    hash = "sha256-oPDQSS//TJyRHKsnZA5pDdFLRC7agzMZsRGQBCsvdGk=";
   };
 
   propagatedBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "langchain";
-  version = "0.0.201";
+  version = "0.0.207";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
     owner = "hwchase17";
     repo = "langchain";
     rev = "refs/tags/v${version}";
-    hash = "sha256-+mS6rKypDrlKFg+c0GPAZ0YX7UYN+mlilnbX2hptLt0=";
+    hash = "sha256-/gPkgHcHHyFAhPF4hqEMkOaHV9Z1159ZdB2lwtsJEKE=";
   };
 
   postPatch = ''

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

···
 
 buildPythonPackage rec {
   pname = "langchainplus-sdk";
-  version = "0.0.10";
+  version = "0.0.16";
   format = "pyproject";
 
   disabled = pythonOlder "3.8";
···
   src = fetchPypi {
     inherit version;
     pname = "langchainplus_sdk";
-    hash = "sha256-T4ELON90qZ0B5XI+ZT2gLwXfPukilxzMq8Nl0Awz2/Y=";
+    hash = "sha256-L8Bn3QOO3PGAhtNC2ixpCYTE03+b+mhP/MrqNLQ+2yg=";
   };
 
   nativeBuildInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "libvirt";
-  version = "9.2.0";
+  version = "9.4.0";
 
   src = fetchFromGitLab {
     owner = "libvirt";
     repo = "libvirt-python";
     rev = "v${version}";
-    hash = "sha256-htJPNFiY0WuQlgfFkLh3RUmnx2X4aQ0+iUQgZ1+HDp0=";
+    hash = "sha256-P5IfH93qCEIJScDRkSOAnA5D82PV1T1eUlPCQYbK0d8=";
   };
 
   nativeBuildInputs = [ pkg-config ];

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

···
 { lib
 , buildPythonPackage
-, fetchPypi
+, fetchFromGitHub
+, setuptools
 , pathspec
 , pytestCheckHook
 , pythonOlder
···
 
 buildPythonPackage rec {
   pname = "yamllint";
-  version = "1.31.0";
-  format = "setuptools";
+  version = "1.32.0";
+  format = "pyproject";
 
   disabled = pythonOlder "3.7";
 
-  src = fetchPypi {
-    inherit pname version;
-    hash = "sha256-LYPx0S9zPhYqh+BrF2FJ17ucW65Knl/OHHcdf3A/emU=";
+  src = fetchFromGitHub {
+    owner = "adrienverge";
+    repo = pname;
+    rev = "refs/tags/v${version}";
+    hash = "sha256-DtIQ/gUBFQBm0OOJC2c/ONn2ZKsMAzdwMx7FbUo+uIU=";
   };
+
+  nativeBuildInputs = [
+    setuptools
+  ];
 
   propagatedBuildInputs = [
     pyyaml

pkgs/development/tools/language-servers/ansible-language-server/default.nix

···
 
 buildNpmPackage rec {
   pname = "ansible-language-server";
-  version = "1.0.5";
+  version = "1.1.0";
 
   src = fetchFromGitHub {
     owner = "ansible";
     repo = pname;
     rev = "refs/tags/v${version}";
-    hash = "sha256-OpYxG6rSPCu2jWyOU1+Dt4LM/3pZKaQyJE8emykh2K4=";
+    hash = "sha256-kyyYHA0+n8zo1GOzC5lW+QnAn2EtLq0bB1L11yONJbE=";
   };
 
-  npmDepsHash = "sha256-pK8Kn4w3QFcfjm0F1bEK9La36wTbmuGzkKMeBIc/9eo=";
+  npmDepsHash = "sha256-0mOj0HV6fbImuYDKr3S2SUO8nHN7R0FX9Ihi0GtoSR4=";
   npmBuildScript = "compile";
 
   # We remove/ignore the prepare and prepack scripts because they run the

pkgs/development/tools/misc/src-cli/default.nix

···
 { lib
 , buildGoModule
 , fetchFromGitHub
+, stdenv
+, xorg
+, darwin
 , testers
 , src-cli
 }:
 
 buildGoModule rec {
   pname = "src-cli";
-  version = "5.0.3";
+  version = "5.1.0";
 
   src = fetchFromGitHub {
     owner = "sourcegraph";
     repo = "src-cli";
     rev = version;
-    hash = "sha256-KqCH4f9QPfr/Hm4phR9qeCV925RkOawGnbCx8wz/QwE=";
+    hash = "sha256-sN6Ea1kJce8Jqy8YrkWzDrQDrmA8F+UYz7ZuqfdbnJ4=";
   };
 
-  vendorHash = "sha256-NMLrBYGscZexnR43I4Ku9aqzJr38z2QAnZo0RouHFrc=";
+  vendorHash = "sha256-A533f+FfEzU2TlNwHkD8gjeQYRATz85cCCmqLdl9290=";
 
   subPackages = [
     "cmd/src"
+  ];
+
+  buildInputs = lib.optionals stdenv.isLinux [
+    xorg.libX11
+  ] ++ lib.optionals stdenv.isDarwin [
+    darwin.apple_sdk.frameworks.Cocoa
   ];
 
   ldflags = [

pkgs/development/tools/rust/rust-analyzer/default.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "rust-analyzer-unwrapped";
-  version = "2023-06-05";
-  cargoSha256 = "sha256-2mQ9DoY5grywiRE3dxSuziaw7adIHe8mRgzcFXVnIEg=";
+  version = "2023-06-19";
+  cargoSha256 = "sha256-aQZkiIRD5r5MSENjrtD2qM/h3ByYfYgOxYx62RgLX7o=";
 
   src = fetchFromGitHub {
     owner = "rust-lang";
     repo = "rust-analyzer";
     rev = version;
-    sha256 = "sha256-IHfvZ8cbn/rgueO7ZvFUHWPPvXEM/rrK1YATwucHVbM=";
+    sha256 = "sha256-dzTROlAzRR8LIHEud2brANXDV8be1jsBV8aQynxj4UI=";
   };
 
   cargoBuildFlags = [ "--bin" "rust-analyzer" "--bin" "rust-analyzer-proc-macro-srv" ];

pkgs/servers/http/nginx/mainline.nix

···
 { callPackage, ... }@args:
 
 callPackage ./generic.nix args {
-  version = "1.25.0";
-  hash = "sha256-XtRNRZQycqTopbz0Q0I3IQ8t4xuQP8peOBwbvX7uHow=";
+  version = "1.25.1";
+  hash = "sha256-8JBxrEbg6jrcAAjvC6yiKfxrS+RTO675u7+6feKahgI=";
 }

pkgs/servers/klipper/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "klipper";
-  version = "unstable-2023-04-24";
+  version = "unstable-2023-06-21";
 
   src = fetchFromGitHub {
     owner = "KevinOConnor";
     repo = "klipper";
-    rev = "b17ae55f5bd3a079ab3626b1e6fd5c60416e6ba0";
-    sha256 = "sha256-e1luOJdTeSB/UNl/W91tBuuQ5f2fKfo1CSMQiE+A1T4=";
+    rev = "d32a83345518f4bb632bef9ca2de669b35f0e555";
+    sha256 = "sha256-XpAUv4NVERVGxV4lk6u15lIIce8ZrYf9uN3fdL5xolI=";
   };
 
   sourceRoot = "source/klippy";
···
     makeWrapper
   ];
 
-  buildInputs = [ (python3.withPackages (p: with p; [ cffi pyserial greenlet jinja2 markupsafe numpy ])) ];
+  buildInputs = [ (python3.withPackages (p: with p; [ can cffi pyserial greenlet jinja2 markupsafe numpy ])) ];
 
   # we need to run this to prebuild the chelper.
   postBuild = ''

pkgs/servers/nosql/eventstore/default.nix

···
     "EventStore.Projections.Core.Tests.Services.grpc_service.ServerFeaturesTests<LogFormat+V3,UInt32>.should_receive_expected_endpoints"
   ];
 
-  nugetBinariesToPatch = lib.optionals stdenv.isLinux [
-    "grpc.tools/2.49.1/tools/linux_x64/protoc"
-    "grpc.tools/2.49.1/tools/linux_x64/grpc_csharp_plugin"
-  ];
-
   postConfigure = ''
-    # Fixes execution of native protoc binaries during build
-    for binary in $nugetBinariesToPatch; do
-      path="$HOME/.nuget/packages/$binary"
-      patchelf --set-interpreter "$(cat $NIX_BINTOOLS/nix-support/dynamic-linker)" $path
-    done
-
     # Fixes git execution by GitInfo on mac os
     substituteInPlace "$HOME/.nuget/packages/gitinfo/2.0.26/build/GitInfo.targets" \
       --replace "<GitExe Condition=\"Exists('/usr/bin/git')\">/usr/bin/git</GitExe>" " " \

pkgs/tools/admin/awscli2/default.nix

···
 in
 with py.pkgs; buildPythonApplication rec {
   pname = "awscli2";
-  version = "2.12.0"; # N.B: if you change this, check if overrides are still up-to-date
+  version = "2.12.2"; # N.B: if you change this, check if overrides are still up-to-date
   format = "pyproject";
 
   src = fetchFromGitHub {
     owner = "aws";
     repo = "aws-cli";
     rev = version;
-    hash = "sha256-sT8GTw+HusR98NzdjNSvmAn5JoS5z3HaIljbswRLunk=";
+    hash = "sha256-BEg7Zlc1gmZ5PpbIY6xL9l69DVz0l2b6e5oiECRucLw=";
   };
 
   postPatch = ''

pkgs/tools/admin/lxd/default.nix

···
 
 buildGoModule rec {
   pname = "lxd";
-  version = "5.14";
+  version = "5.15";
 
   src = fetchurl {
     urls = [
       "https://linuxcontainers.org/downloads/lxd/lxd-${version}.tar.gz"
       "https://github.com/lxc/lxd/releases/download/lxd-${version}/lxd-${version}.tar.gz"
     ];
-    hash = "sha256-EtVZ0g9LD6dWA70/E1Ad/RWJjbvrAzU2hF3n6CdTMBE=";
+    hash = "sha256-ez/875yu0XYu5ORf4ak6RN1jWGxuGk0n9023zJkoluM=";
   };
 
   vendorHash = null;

pkgs/tools/misc/esphome/dashboard.nix

···
 
 buildPythonPackage rec {
   pname = "esphome-dashboard";
-  version = "20230516.0";
+  version = "20230621.0";
   format = "setuptools";
 
   src = fetchPypi {
     inherit pname version;
-    hash = "sha256-Mkh31ip7xzG8e4qgIVc+HFN310SnuTGRp4HYbFqKa/A=";
+    hash = "sha256-e5nAhtM5Yc2KNmH6a041o6i6SnVCbaONulBe1ZCF0+w=";
   };
 
   # no tests

pkgs/tools/misc/esphome/default.nix

···
 in
 python.pkgs.buildPythonApplication rec {
   pname = "esphome";
-  version = "2023.5.5";
+  version = "2023.6.1";
   format = "setuptools";
 
   src = fetchFromGitHub {
     owner = pname;
     repo = pname;
     rev = "refs/tags/${version}";
-    hash = "sha256-PV+uqJKXqnSMItWVg8iZVOQwxHrDHthezqyvciRq5+M=";
+    hash = "sha256-26oVqSNXuCyovybe0vi10rD89eSQHFYn+WHpGLMn2QA=";
   };
 
   postPatch = ''

pkgs/tools/misc/fedifetcher/default.nix

···
+{ lib, fetchFromGitHub, python3 }:
+
+python3.pkgs.buildPythonApplication rec {
+  pname = "fedifetcher";
+  version = "5.0.1";
+  format = "other";
+
+  src = fetchFromGitHub {
+    owner = "nanos";
+    repo = "FediFetcher";
+    rev = "v${version}";
+    hash = "sha256-O7YDxNQel1XFSjGrzdBI4PsejmzPVLvYLNF/vZgdh4w=";
+  };
+
+  propagatedBuildInputs = with python3.pkgs; [
+    python-dateutil
+    requests
+  ];
+
+  installPhase = ''
+    runHook preInstall
+
+    install -vD find_posts.py $out/bin/fedifetcher
+
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    description = "A tool for Mastodon that automatically fetches missing replies and posts from other fediverse instances";
+    longDescription = ''
+      FediFetcher is a tool for Mastodon that automatically fetches missing
+      replies and posts from other fediverse instances, and adds them to your
+      own Mastodon instance.
+    '';
+    homepage = "https://blog.thms.uk/fedifetcher";
+    license = licenses.mit;
+    maintainers = with maintainers; [ delroth ];
+  };
+}

pkgs/top-level/all-packages.nix

···
     inherit (darwin.apple_sdk.frameworks) DiskArbitration Foundation;
   };
 
+  git-credential-manager = callPackage ../applications/version-management/git-credential-manager { };
+
   git-credential-oauth = callPackage ../applications/version-management/git-credential-oauth { };
 
   git-crypt = callPackage ../applications/version-management/git-crypt { };
···
   fastmod = callPackage ../tools/text/fastmod {
     inherit (darwin.apple_sdk.frameworks) Security;
   };
+
+  fedifetcher = callPackage ../tools/misc/fedifetcher { };
 
   fitnesstrax = callPackage ../applications/misc/fitnesstrax { };
 

pkgs/top-level/perl-packages.nix

···
 
   SysVirt = buildPerlModule rec {
     pname = "Sys-Virt";
-    version = "9.0.0";
+    version = "9.4.0";
     src = fetchFromGitLab {
       owner = "libvirt";
       repo = "libvirt-perl";
       rev = "v${version}";
-      hash = "sha256-QiaB272kxs/Y3/l8KbFy8f9iyOCxhzfA/h2FnfGzmE4=";
+      hash = "sha256-3ER6kcUfNM5ULhN/MlOil4Rx3O84fLnIvH+Cb/oXTFM=";
     };
     nativeBuildInputs = [ pkgs.pkg-config ];
     buildInputs = [ pkgs.libvirt CPANChanges TestPod TestPodCoverage XMLXPath ];