Merge remote-tracking branch 'origin/staging-next' into staging

doc/doc-support/package.nix

···
   writeShellScriptBin,
   nixpkgs ? { },
   markdown-code-runner,
+  roboto,
 }:
 
 stdenvNoCC.mkDerivation (
···
       mkdir -p "$(dirname "$dest")"
       mv out "$dest"
       mv "$dest/index.html" "$dest/manual.html"
+
+      cp ${roboto.src}/web/Roboto\[ital\,wdth\,wght\].ttf "$dest/Roboto.ttf"
 
       cp ${epub} "$dest/nixpkgs-manual.epub"
 

doc/release-notes/rl-2505.section.md

···
 
 - `pnpm` was updated to version 10. If your project is incompatible, you can install the previous version from the package attribute `pnpm_9`.
 
+- `dwarf-fortress-packages` now only contains one minor version for each major version since version 0.44. Saves should still be compatible, but you may have to change which minor version you were using if it was one other than the newest.
+
 - `zig_0_9` and `zig_0_10` have been removed, you should upgrade to `zig_0_13` (also available as just `zig`), `zig_0_12` or `zig_0_11` instead.
 
 - `webpack-cli` was updated to major version 6, which has breaking changes from the previous version 5.1.4. See the [upstream release notes](https://github.com/webpack/webpack-cli/releases/tag/webpack-cli%406.0.0) for details on these changes.
···
   - All versions specified in composeAndroidPackages now track the latest. Android packages are automatically updated on unstable, and run the androidenv test suite on every update.
   - Many androidenv packages are now searchable on [search.nixos.org](https://search.nixos.org).
   - We now use the latest Google repositories, which should improve aarch64-darwin compatibility. The SDK now additionally evaluates on aarch64-linux, though not all packages are functional.
+
+- `dwarf-fortress` audio now works again. Additionally, the `dfhack` and `dwarf-fortress-full` packages are now exposed at toplevel, making it easier to install and play Dwarf Fortress. Note that `dwarf-fortress-full` is the Nixpkgs equivalent of the Dwarf Fortress Lazy Pack.
 
 - `gerbera` now has wavpack support.
 

doc/style.css

···
     margin: 0;
 }
 
-.book {
+.book,
+.appendix {
     margin: auto;
     width: 100%;
 }
 
 @media screen and (min-width: 768px) {
-    .book {
+    .book,
+    .appendix {
         max-width: 46rem;
     }
 }
 
 @media screen and (min-width: 992px) {
-    .book {
+    .book,
+    .appendix {
         max-width: 60rem;
     }
 }
 
 @media screen and (min-width: 1200px) {
-    .book {
+    .book,
+    .appendix {
         max-width: 73rem;
     }
 }
···
 
 body {
     font-size: 1rem;
-    font-family: 'Roboto', sans-serif;
+    font-family: "Roboto", sans-serif;
     font-weight: 300;
-    color: #000000;
-    background-color: #ffffff;
+    color: var(--main-text-color);
+    background-color: var(--background);
     min-height: 100vh;
     display: flex;
     flex-direction: column;
···
 a {
     text-decoration: none;
     border-bottom: 1px solid;
-    color: #405d99;
+    color: var(--link-color);
 }
 
 ul {
···
     line-height: 110%;
     font-size: 200%;
     margin-bottom: 1rem;
-    color: #6586c8;
+    color: var(--heading-color);
 }
 
 h2 {
···
     line-height: 110%;
     font-size: 170%;
     margin-bottom: 0.625rem;
-    color: #6586c8;
+    color: var(--heading-color);
 }
 
 h2:not(:first-child) {
···
     line-height: 110%;
     margin-bottom: 1rem;
     font-size: 150%;
-    color: #6586c8;
+    color: var(--heading-color);
 }
 
 .note h3,
···
     line-height: 110%;
     margin-bottom: 1rem;
     font-size: 140%;
-    color: #6586c8;
+    color: var(--heading-color);
 }
 
 h5 {
···
     line-height: 110%;
     margin-bottom: 1rem;
     font-size: 130%;
-    color: #6a6a6a;
+    color: var(--small-heading-color);
 }
 
 h6 {
     font-weight: 800;
     line-height: 110%;
     margin-bottom: 1rem;
-    font-size: 120%
+    font-size: 120%;
 }
 
 strong {
···
     margin-bottom: 1rem;
 }
 
-dt>*:first-child,
-dd>*:first-child {
+dt > *:first-child,
+dd > *:first-child {
     margin-top: 0;
 }
 
-dt>*:last-child,
-dd>*:last-child {
+dt > *:last-child,
+dd > *:last-child {
     margin-bottom: 0;
 }
 
···
     border-radius: 0.5rem;
     padding: 1rem;
     overflow: auto;
-    background: #f2f8fd;
-    color: #000000;
+    background: var(--codeblock-background);
+    color: var(--codeblock-text-color);
 }
 
 div.book .note,
···
     background: #f4f4f4;
 }
 
-div.book .note>.title,
-div.book .tip>.title,
-div.book .warning>.title,
-div.book .caution>.title,
-div.book .important>.title,
-div.appendix .note>.title,
-div.appendix .tip>.title,
-div.appendix .warning>.title,
-div.appendix .caution>.title,
-div.appendix .important>.title {
+div.book .note > .title,
+div.book .tip > .title,
+div.book .warning > .title,
+div.book .caution > .title,
+div.book .important > .title,
+div.appendix .note > .title,
+div.appendix .tip > .title,
+div.appendix .warning > .title,
+div.appendix .caution > .title,
+div.appendix .important > .title {
     font-weight: 800;
-    /* font-family: 'Overpass', serif; */
     line-height: 110%;
     margin-bottom: 1rem;
     color: inherit;
     margin-bottom: 0;
 }
 
-div.book .note> :first-child,
-div.book .tip> :first-child,
-div.book .warning> :first-child,
-div.book .caution> :first-child,
-div.book .important> :first-child,
-div.appendix .note> :first-child,
-div.appendix .tip> :first-child,
-div.appendix .warning> :first-child,
-div.appendix .caution> :first-child,
-div.appendix .important> :first-child {
+div.book .note > :first-child,
+div.book .tip > :first-child,
+div.book .warning > :first-child,
+div.book .caution > :first-child,
+div.book .important > :first-child,
+div.appendix .note > :first-child,
+div.appendix .tip > :first-child,
+div.appendix .warning > :first-child,
+div.appendix .caution > :first-child,
+div.appendix .important > :first-child {
     margin-top: 0;
 }
 
-div.book .note> :last-child,
-div.book .tip> :last-child,
-div.book .warning> :last-child,
-div.book .caution> :last-child,
-div.book .important> :last-child,
-div.appendix .note> :last-child,
-div.appendix .tip> :last-child,
-div.appendix .warning> :last-child,
-div.appendix .caution> :last-child,
-div.appendix .important> :last-child {
+div.book .note > :last-child,
+div.book .tip > :last-child,
+div.book .warning > :last-child,
+div.book .caution > :last-child,
+div.book .important > :last-child,
+div.appendix .note > :last-child,
+div.appendix .tip > :last-child,
+div.appendix .warning > :last-child,
+div.appendix .caution > :last-child,
+div.appendix .important > :last-child {
     margin-bottom: 0;
 }
 
···
 div.book .tip,
 div.appendix .note,
 div.appendix .tip {
-    color: #5277c3;
-    background: #f2f8fd;
+    color: var(--note-text-color);
+    background: var(--note-background);
 }
 
 div.book .warning,
 div.book .caution,
 div.appendix .warning,
 div.appendix .caution {
-    color: #cc3900;
-    background-color: #fff5e1;
+    color: var(--warning-text-color);
+    background-color: var(--warning-background);
 }
 
 div.book .section,
···
     border-radius: 4px;
 }
 
-div.book div.example details>summary,
-div.appendix div.example details>summary {
+div.book div.example details > summary,
+div.appendix div.example details > summary {
     cursor: pointer;
 }
 
···
     display: none;
 }
 
-div.book div.footnotes>hr,
-div.appendix div.footnotes>hr {
+div.book div.footnotes > hr,
+div.appendix div.footnotes > hr {
     border-color: #d8d8d8;
 }
 
-div.book div.footnotes>br,
-div.appendix div.footnotes>br {
+div.book div.footnotes > br,
+div.appendix div.footnotes > br {
     display: none;
 }
 
···
     user-select: none;
     -webkit-user-select: none;
 }
+
+:root {
+    --background: #fff;
+    --main-text-color: #000;
+    --link-color: #405d99;
+    --heading-color: #6586c8;
+    --small-heading-color: #6a6a6a;
+    --note-text-color: #5277c3;
+    --note-background: #f2f8fd;
+    --warning-text-color: #cc3900;
+    --warning-background: #fff5e1;
+    --codeblock-background: #f2f8fd;
+    --codeblock-text-color: #000;
+}
+
+@media (prefers-color-scheme: dark) {
+    :root {
+        --background: #242424;
+        --main-text-color: #fff;
+        --link-color: #6586c8;
+        --small-heading-color: #fff;
+        --note-background: none;
+        --warning-background: none;
+        --codeblock-background: #393939;
+        --codeblock-text-color: #fff;
+    }
+
+    div.book .note,
+    div.book .tip,
+    div.appendix .note,
+    div.appendix .tip,
+    div.book .warning,
+    div.book .caution,
+    div.appendix .warning,
+    div.appendix .caution {
+        border: 2px solid;
+        font-weight: 400;
+    }
+}
+
+@font-face {
+    font-family: Roboto;
+    src: url(Roboto.ttf);
+}

lib/options.nix

···
   inherit (lib.attrsets)
     attrByPath
     optionalAttrs
+    showAttrPath
     ;
   inherit (lib.strings)
     concatMapStrings
···
     ;
   inherit (lib.lists)
     last
+    toList
     ;
   prioritySuggestion = ''
     Use `lib.mkForce value` or `lib.mkDefault value` to change the priority on any of these definitions.
···
     }:
     let
       name' = if isList name then last name else name;
-      default' = if isList default then default else [ default ];
-      defaultText = concatStringsSep "." default';
+      default' = toList default;
+      defaultText = showAttrPath default';
       defaultValue = attrByPath default' (throw "${defaultText} cannot be found in ${pkgsText}") pkgs;
       defaults =
         if default != null then
           {
             default = defaultValue;
-            defaultText = literalExpression ("${pkgsText}." + defaultText);
+            defaultText = literalExpression "${pkgsText}.${defaultText}";
           }
         else
           optionalAttrs nullable {
···
       }
       // optionalAttrs (example != null) {
         example = literalExpression (
-          if isList example then "${pkgsText}." + concatStringsSep "." example else example
+          if isList example then "${pkgsText}.${showAttrPath example}" else example
         );
       }
     );

lib/path/default.nix

···
     # This is a workaround for https://github.com/NixOS/nix/issues/12361 which
     # was needed during the experimental phase of ca-derivations and should be
     # removed once the issue has been resolved.
-    || match "[0-9a-z]{52}" (head components) != null;
+    || components != [ ] && match "[0-9a-z]{52}" (head components) != null;
 
 in
 # No rec! Add dependencies on this file at the top.

lib/path/tests/unit.nix

···
       expected = false;
     };
 
+    # Root path (empty path components list)
+    testHasStorePathPrefixRoot = {
+      expr = hasStorePathPrefix /.;
+      expected = false;
+    };
+
     testHasStorePathPrefixExample1 = {
       expr = hasStorePathPrefix (storeDirPath + "/nvl9ic0pj1fpyln3zaqrf4cclbqdfn1j-foo/bar/baz");
       expected = true;

lib/strings.nix

···
 
     :::
   */
-  escapeC = list: replaceStrings list (map (c: "\\x${toLower (lib.toHexString (charToInt c))}") list);
+  escapeC =
+    list:
+    replaceStrings list (
+      map (c: "\\x${fixedWidthString 2 "0" (toLower (lib.toHexString (charToInt c)))}") list
+    );
 
   /**
     Escape the `string` so it can be safely placed inside a URL

lib/tests/misc.nix

···
   };
 
   testEscapeC = {
-    expr = strings.escapeC [ " " ] "Hello World";
-    expected = "Hello\\x20World";
+    expr = strings.escapeC [ "\n" " " ] "Hello World\n";
+    expected = "Hello\\x20World\\x0a";
   };
 
   testEscapeURL = testAllTrue [

lib/tests/modules.sh

···
 checkConfigOutput '^"hello"$' config.package.pname ./declare-mkPackageOption.nix
 checkConfigOutput '^"hello"$' config.namedPackage.pname ./declare-mkPackageOption.nix
 checkConfigOutput '^".*Hello.*"$' options.namedPackage.description ./declare-mkPackageOption.nix
+checkConfigOutput '^"literalExpression"$' options.namedPackage.defaultText._type ./declare-mkPackageOption.nix
+checkConfigOutput '^"pkgs\.hello"$' options.namedPackage.defaultText.text ./declare-mkPackageOption.nix
+checkConfigOutput '^"hello"$' config.namedPackageSingletonDefault.pname ./declare-mkPackageOption.nix
+checkConfigOutput '^".*Hello.*"$' options.namedPackageSingletonDefault.description ./declare-mkPackageOption.nix
+checkConfigOutput '^"pkgs\.hello"$' options.namedPackageSingletonDefault.defaultText.text ./declare-mkPackageOption.nix
 checkConfigOutput '^"hello"$' config.pathPackage.pname ./declare-mkPackageOption.nix
+checkConfigOutput '^"literalExpression"$' options.packageWithExample.example._type ./declare-mkPackageOption.nix
 checkConfigOutput '^"pkgs\.hello\.override \{ stdenv = pkgs\.clangStdenv; \}"$' options.packageWithExample.example.text ./declare-mkPackageOption.nix
+checkConfigOutput '^"literalExpression"$' options.packageWithPathExample.example._type ./declare-mkPackageOption.nix
+checkConfigOutput '^"pkgs\.hello"$' options.packageWithPathExample.example.text ./declare-mkPackageOption.nix
 checkConfigOutput '^".*Example extra description\..*"$' options.packageWithExtraDescription.description ./declare-mkPackageOption.nix
 checkConfigError 'The option .undefinedPackage. was accessed but has no value defined. Try setting the option.' config.undefinedPackage ./declare-mkPackageOption.nix
 checkConfigOutput '^null$' config.nullablePackage ./declare-mkPackageOption.nix
-checkConfigOutput '^"null or package"$' options.nullablePackageWithDefault.type.description ./declare-mkPackageOption.nix
+checkConfigOutput '^"null or package"$' options.nullablePackage.type.description ./declare-mkPackageOption.nix
+checkConfigOutput '^"hello"$' config.nullablePackageWithDefault.pname ./declare-mkPackageOption.nix
 checkConfigOutput '^"myPkgs\.hello"$' options.packageWithPkgsText.defaultText.text ./declare-mkPackageOption.nix
 checkConfigOutput '^"hello-other"$' options.packageFromOtherSet.default.pname ./declare-mkPackageOption.nix
+checkConfigOutput '^"hello"$' config.packageInvalidIdentifier.pname ./declare-mkPackageOption.nix
+checkConfigOutput '^"pkgs\.\\"123\\"\.\\"with\\\\\\"quote\\"\.hello"$' options.packageInvalidIdentifier.defaultText.text ./declare-mkPackageOption.nix
+checkConfigOutput '^"pkgs\.\\"123\\"\.\\"with\\\\\\"quote\\"\.hello"$' options.packageInvalidIdentifierExample.example.text ./declare-mkPackageOption.nix
 
 # submoduleWith
 

lib/tests/modules/declare-mkPackageOption.nix

···
         };
       in
       lib.mkPackageOption myPkgs "hello" { };
+
+    packageInvalidIdentifier =
+      let
+        myPkgs."123"."with\"quote" = { inherit (pkgs) hello; };
+      in
+      lib.mkPackageOption myPkgs [ "123" "with\"quote" "hello" ] { };
+
+    packageInvalidIdentifierExample = lib.mkPackageOption pkgs "hello" {
+      example = [
+        "123"
+        "with\"quote"
+        "hello"
+      ];
+    };
   };
 }

lib/tests/modules/pathWith.nix

···
   pathInStore.ok1 = "${storeDir}/0lz9p8xhf89kb1c1kk6jxrzskaiygnlh-bash-5.2-p15.drv";
   pathInStore.ok2 = "${storeDir}/0fb3ykw9r5hpayd05sr0cizwadzq1d8q-bash-5.2-p15";
   pathInStore.ok3 = "${storeDir}/0fb3ykw9r5hpayd05sr0cizwadzq1d8q-bash-5.2-p15/bin/bash";
+  pathInStore.ok4 = "/1121rp0gvr1qya7hvy925g5kjwg66acz6sn1ra1hca09f1z5dsab"; # CA derivation
+  pathInStore.ok5 = "/1121rp0gvr1qya7hvy925g5kjwg66acz6sn1ra1hca09f1z5dsab/bin/bash"; # CA derivation
+  pathInStore.ok6 = /1121rp0gvr1qya7hvy925g5kjwg66acz6sn1ra1hca09f1z5dsab; # CA derivation, path type
   pathInStore.bad1 = "";
   pathInStore.bad2 = "${storeDir}";
   pathInStore.bad3 = "${storeDir}/";

lib/types.nix

···
             check =
               x:
               let
-                isInStore = builtins.match "${builtins.storeDir}/[^.].*" (toString x) != null;
+                isInStore = lib.path.hasStorePathPrefix (
+                  if builtins.isPath x then
+                    x
+                  # Discarding string context is necessary to convert the value to
+                  # a path and safe as the result is never used in any derivation.
+                  else
+                    /. + builtins.unsafeDiscardStringContext x
+                );
                 isAbsolute = builtins.substring 0 1 (toString x) == "/";
                 isExpectedType = (
                   if inStore == null || inStore then isStringLike x else isString x # Do not allow a true path, which could be copied to the store later on.

maintainers/maintainer-list.nix

···
     github = "keenanweaver";
     githubId = 37268985;
   };
-  kekschen = {
-    email = "[e-mail]";
-    github = "kek5chen";
-    githubId = 52585984;
-    name = "Kek5chen";
-  };
   keksgesicht = {
     name = "Jan Braun";
     email = "[e-mail]";
···
     github = "sinanmohd";
     githubId = 69694713;
   };
+  sinics = {
+    name = "Zhifan";
+    email = "[e-mail]";
+    matrix = "@c3n21:matrix.org";
+    githubId = 37077738;
+  };
   sioodmy = {
     name = "Antoni Sokołowski";
     github = "sioodmy";
···
     github = "WilliButz";
     githubId = 20464732;
     name = "Willi Butz";
+  };
+  willow = {
+    email = "[e-mail]";
+    github = "kek5chen";
+    githubId = 52585984;
+    name = "Willow";
   };
   willow_ch = {
     email = "[e-mail]";

maintainers/team-list.nix

···
       pandapip1
       qyliss
       thefossguy
+      michaelBelsanti
     ];
     githubTeams = [ "cosmic" ];
     shortName = "cosmic";

nixos/doc/manual/default.nix

···
           ./manual.md \
           $dst/${common.indexPath}
 
+        cp ${pkgs.roboto.src}/web/Roboto\[ital\,wdth\,wght\].ttf "$dst/Roboto.ttf"
+
         mkdir -p $out/nix-support
         echo "nix-build out $out" >> $out/nix-support/hydra-build-products
         echo "doc manual $dst" >> $out/nix-support/hydra-build-products

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

···
 
 - [Netbird](https://netbird.io), an open-source VPN management platform, now has a self-hosted management server. Available as [services.netbird.server](#opt-services.netbird.server.enable).
 
-- [nh](https://github.com/viperML/nh), yet another Nix CLI helper. Available as [programs.nh](#opt-programs.nh.enable).
+- [nh](https://github.com/nix-community/nh), yet another Nix CLI helper. Available as [programs.nh](#opt-programs.nh.enable).
 
 - [oink](https://github.com/rlado/oink), a dynamic DNS client for Porkbun. Available as [services.oink](#opt-services.oink.enable).
 

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

···
 
 - [GoDNS](https://github.com/TimothyYe/godns), a dynamic DNS client written in Go, which supports multiple DNS providers. Available as [services.godns](option.html#opt-services.godns.enable).
 
+- [CookCLI](https://cooklang.org/cli/) Server, a web UI for cooklang recipes.
+
 <!-- To avoid merge conflicts, consider adding your item at an arbitrary place in the list instead. -->
 
 ## Backward Incompatibilities {#sec-release-25.05-incompatibilities}
···
 
 
 - `programs.clash-verge.tunMode` was deprecated and removed because now service mode is necessary to start program. Without `programs.clash-verge.enable`, clash-verge-rev will refuse to start.
+- `services.discourse` now requires PostgreSQL 15 per default. Please update before upgrading.
 
 - `services.homepage-dashboard` now requires the `allowedHosts` option to be set in accordance with the [documentation](https://gethomepage.dev/installation/#homepage_allowed_hosts).
 

nixos/modules/services/misc/gitlab.nix

···
         ConditionPathExists = "!${cfg.registry.certFile}";
       };
       serviceConfig = {
+        Type = "oneshot";
         Slice = "system-gitlab.slice";
       };
     };

nixos/modules/services/security/paretosecurity.nix

···
   pkgs,
   ...
 }:
+let
+  cfg = config.services.paretosecurity;
+in
 {
 
   options.services.paretosecurity = {
···
     trayIcon = lib.mkEnableOption "tray icon for ParetoSecurity";
   };
 
-  config = lib.mkIf config.services.paretosecurity.enable {
-    environment.systemPackages = [ config.services.paretosecurity.package ];
-    systemd.packages = [ config.services.paretosecurity.package ];
+  config = lib.mkIf cfg.enable {
+    environment.systemPackages = [ cfg.package ];
+    systemd.packages = [ cfg.package ];
 
     # In traditional Linux distributions, systemd would read the [Install] section from
     # unit files and automatically create the appropriate symlinks to enable services.
···
     ];
 
     # Enable the tray icon and timer services if the trayIcon option is enabled
-    systemd.user = lib.mkIf config.services.paretosecurity.trayIcon {
-      services.paretosecurity-trayicon = {
-        wantedBy = [ "graphical-session.target" ];
+    systemd.user = lib.mkIf cfg.trayIcon {
+      services = {
+        paretosecurity-trayicon.wantedBy = [ "graphical-session.target" ];
+        paretosecurity-user = {
+          wantedBy = [ "graphical-session.target" ];
+          serviceConfig.Environment = [
+            "PATH=${config.system.path}/bin:${config.system.path}/sbin"
+          ];
+        };
       };
-      services.paretosecurity-user = {
-        wantedBy = [ "graphical-session.target" ];
-        serviceConfig.Environment = [
-          "PATH=${config.system.path}/bin:${config.system.path}/sbin"
-        ];
-      };
-      timers.paretosecurity-user = {
-        wantedBy = [ "timers.target" ];
-      };
+      timers.paretosecurity-user.wantedBy = [ "timers.target" ];
     };
   };
 }

nixos/modules/services/web-apps/cook-cli.nix

···
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}:
+
+let
+  cfg = config.services.cook-cli;
+  inherit (lib)
+    mkIf
+    mkEnableOption
+    mkPackageOption
+    mkOption
+    getExe
+    types
+    ;
+in
+{
+  options = {
+    services.cook-cli = {
+      enable = lib.mkEnableOption "cook-cli";
+
+      package = lib.mkPackageOption pkgs "cook-cli" { };
+
+      autoStart = lib.mkOption {
+        type = lib.types.bool;
+        default = true;
+        description = ''
+          Whether to start cook-cli server automatically.
+        '';
+      };
+
+      port = lib.mkOption {
+        type = lib.types.port;
+        default = 9080;
+        description = ''
+          Which port cook-cli server will use.
+        '';
+      };
+
+      basePath = lib.mkOption {
+        type = lib.types.str;
+        default = "/var/lib/cook-cli";
+        description = ''
+          Path to the directory cook-cli will look for recipes.
+        '';
+      };
+
+      openFirewall = lib.mkOption {
+        type = lib.types.bool;
+        default = false;
+        description = ''
+          Whether to open the cook-cli server port in the firewall.
+        '';
+      };
+    };
+  };
+
+  config = lib.mkIf cfg.enable {
+    environment.systemPackages = [ cfg.package ];
+
+    systemd.tmpfiles.rules = [
+      "d ${cfg.basePath} 0770 cook-cli users"
+    ];
+
+    users.users.cook-cli = {
+      home = "${cfg.basePath}";
+      group = "cook-cli";
+      isSystemUser = true;
+    };
+    users.groups.cook-cli.members = [
+      "cook-cli"
+    ];
+
+    systemd.services.cook-cli = {
+      description = "cook-cli server";
+      serviceConfig = {
+        ExecStart = "${getExe cfg.package} server --host --port ${toString cfg.port} ${cfg.basePath}";
+        WorkingDirectory = cfg.basePath;
+        User = "cook-cli";
+        Group = "cook-cli";
+        # Hardening options
+        CapabilityBoundingSet = [ "CAP_SYS_NICE" ];
+        AmbientCapabilities = [ "CAP_SYS_NICE" ];
+        LockPersonality = true;
+        NoNewPrivileges = true;
+        PrivateTmp = true;
+        ProtectControlGroups = true;
+        ProtectKernelLogs = true;
+        ProtectKernelModules = true;
+        ProtectKernelTunables = true;
+        ProtectSystem = "strict";
+        ReadWritePaths = cfg.basePath;
+        RestrictNamespaces = true;
+        RestrictSUIDSGID = true;
+        Restart = "on-failure";
+        RestartSec = 5;
+      };
+      wantedBy = mkIf cfg.autoStart [ "multi-user.target" ];
+      wants = [ "network.target" ];
+    };
+
+    networking.firewall = lib.mkIf cfg.openFirewall {
+      allowedTCPPorts = [ cfg.port ];
+    };
+  };
+
+  meta.maintainers = [
+    lib.maintainers.luNeder
+    lib.maintainers.emilioziniades
+  ];
+}

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

···
   cfg = config.services.discourse;
   opt = options.services.discourse;
 
-  # Keep in sync with https://github.com/discourse/discourse_docker/blob/main/image/base/slim.Dockerfile#L5
-  upstreamPostgresqlVersion = lib.getVersion pkgs.postgresql_13;
+  # Keep in sync with https://github.com/discourse/discourse_docker/blob/main/image/base/Dockerfile PG_MAJOR
+  upstreamPostgresqlVersion = lib.getVersion pkgs.postgresql_15;
 
   postgresqlPackage =
     if config.services.postgresql.enable then config.services.postgresql.package else pkgs.postgresql;
···
       dns_query_timeout_secs = null;
       regex_timeout_seconds = 2;
       allow_impersonation = true;
+      log_line_max_chars = 160000;
+      yjit_enabled = false;
     };
 
     services.redis.servers.discourse =
···
                   extraConfig
                   + ''
                     proxy_set_header X-Request-Start "t=''${msec}";
+                    proxy_set_header X-Sendfile-Type "";
+                    proxy_set_header X-Accel-Mapping "";
+                    proxy_set_header Client-Ip "";
                   '';
               };
             cache = time: ''

nixos/modules/services/x11/desktop-managers/budgie.nix

···
       monospace = mkDefault [ "Hack" ];
     };
 
-    # Qt application style.
-    qt = {
-      enable = mkDefault true;
-      style = mkDefault "gtk2";
-      platformTheme = mkDefault "gtk2";
-    };
-
     environment.pathsToLink = [
       "/share" # TODO: https://github.com/NixOS/nixpkgs/issues/47173
     ];

nixos/tests/discourse.nix

···
 
         environment.systemPackages = [ pkgs.jq ];
 
-        services.postgresql.package = pkgs.postgresql_13;
+        services.postgresql.package = pkgs.postgresql_15;
 
         services.discourse = {
           enable = true;
···
         services.dovecot2 = {
           enable = true;
           protocols = [ "imap" ];
-          modules = [ pkgs.dovecot_pigeonhole ];
         };
 
         services.postfix = {

nixos/tests/gitlab.nix

···
 
         environment.systemPackages = with pkgs; [ git ];
 
+        networking.hosts."127.0.0.1" = [
+          "registry.localhost"
+          "pages.localhost"
+        ];
         virtualisation.memorySize = 6144;
         virtualisation.cores = 4;
         virtualisation.useNixStoreImage = true;
···
           virtualHosts = {
             localhost = {
               locations."/".proxyPass = "http://unix:/run/gitlab/gitlab-workhorse.socket";
+            };
+            "pages.localhost" = {
+              locations."/".proxyPass = "http://localhost:8090";
+            };
+            "registry.localhost" = {
+              locations."/".proxyPass = "http://localhost:4567";
             };
           };
         };
···
           smtp.enable = true;
           pages = {
             enable = true;
-            settings.pages-domain = "localhost";
+            settings.pages-domain = "pages.localhost";
           };
           extraConfig = {
             incoming_email = {
···
             otpFile = pkgs.writeText "otpsecret" "Riew9mue";
             dbFile = pkgs.writeText "dbsecret" "we2quaeZ";
             jwsFile = pkgs.runCommand "oidcKeyBase" { } "${pkgs.openssl}/bin/openssl genrsa 2048 > $out";
+          };
+
+          registry = {
+            enable = true;
+            certFile = "/var/lib/gitlab/registry_auth_cert";
+            keyFile = "/var/lib/gitlab/registry_auth_key";
+            externalAddress = "registry.localhost";
+            externalPort = 443;
           };
 
           # reduce memory usage
···
         gitlab.wait_for_unit("gitlab-sidekiq.service")
         gitlab.wait_for_file("${nodes.gitlab.services.gitlab.statePath}/tmp/sockets/gitlab.socket")
         gitlab.wait_until_succeeds("curl -sSf http://gitlab/users/sign_in")
+        gitlab.wait_for_unit("docker-registry.service")
       '';
 
       # The actual test of GitLab. Only push data to GitLab if
···
                   """
               )
               gitlab.succeed("test -s /tmp/archive.tar.bz2")
+        ''
+        + ''
+          with subtest("Test docker registry http is available"):
+              gitlab.succeed("curl -sSf http://registry.localhost")
         '';
 
     in

nixos/tests/paretosecurity.nix

···
   meta.maintainers = [ lib.maintainers.zupo ];
 
   nodes.terminal =
-    {
-      config,
-      pkgs,
-      lib,
-      ...
-    }:
-    let
-      # Create a patched version of the package that points to the local dashboard
-      # for easier testing
-      patchedPareto = pkgs.paretosecurity.overrideAttrs (oldAttrs: {
-        postPatch = ''
-          substituteInPlace team/report.go \
-            --replace-warn 'const reportURL = "https://dash.paretosecurity.com"' \
-                           'const reportURL = "http://dashboard"'
-        '';
-      });
-    in
+    { pkgs, ... }:
     {
       imports = [ ./common/user-account.nix ];
 
+      networking.firewall.enable = true;
       services.paretosecurity = {
         enable = true;
-        package = patchedPareto;
+
+        # Create a patched version of the package that points to the local dashboard
+        # for easier testing
+        package = pkgs.paretosecurity.overrideAttrs (oldAttrs: {
+          postPatch =
+            oldAttrs.postPatch or ""
+            + ''
+              substituteInPlace team/report.go \
+                --replace-warn 'const reportURL = "https://dash.paretosecurity.com"' \
+                               'const reportURL = "http://dashboard"'
+            '';
+        });
       };
-
-      networking.firewall.enable = true;
 
     };
 
-  nodes.dashboard =
-    { config, pkgs, ... }:
-    {
-      networking.firewall.allowedTCPPorts = [ 80 ];
+  nodes.dashboard = {
+    networking.firewall.allowedTCPPorts = [ 80 ];
 
-      services.nginx = {
-        enable = true;
-        virtualHosts."dashboard" = {
-          locations."/api/v1/team/".extraConfig = ''
-            add_header Content-Type application/json;
-            return 200 '{"message": "Linked device."}';
-          '';
-        };
+    services.nginx = {
+      enable = true;
+      virtualHosts."dashboard" = {
+        locations."/api/v1/team/".extraConfig = ''
+          add_header Content-Type application/json;
+          return 200 '{"message": "Linked device."}';
+        '';
       };
     };
+  };
 
   nodes.xfce =
-    { config, pkgs, ... }:
+    { pkgs, ... }:
     {
       imports = [ ./common/user-account.nix ];
 
···
 
       environment.systemPackages = [ pkgs.xdotool ];
       environment.variables.XAUTHORITY = "/home/alice/.Xauthority";
-
     };
 
   enableOCR = true;

pkgs/applications/editors/textadept/default.nix

···
-{
-  lib,
-  stdenv,
-  fetchFromGitHub,
-  fetchurl,
-  cmake,
-  withQt ? true,
-  qtbase,
-  wrapQtAppsHook,
-  withCurses ? false,
-  ncurses,
-}:
-stdenv.mkDerivation rec {
-  version = "12.4";
-  pname = "textadept";
-
-  src = fetchFromGitHub {
-    name = "textadept11";
-    owner = "orbitalquark";
-    repo = "textadept";
-    rev = "textadept_${version}";
-    sha256 = "sha256-nPgpQeBq5Stv2o0Ke4W2Ltnx6qLe5TIC5a8HSYVkmfI=";
-  };
-
-  nativeBuildInputs = [ cmake ] ++ lib.optionals withQt [ wrapQtAppsHook ];
-
-  buildInputs = lib.optionals withQt [ qtbase ] ++ lib.optionals withCurses ncurses;
-
-  cmakeFlags =
-    lib.optional withQt [ "-DQT=ON" ]
-    ++ lib.optional withCurses [
-      "-DCURSES=ON"
-      "-DQT=OFF"
-    ];
-
-  preConfigure =
-    ''
-      mkdir -p $PWD/build/_deps
-
-    ''
-    + lib.concatStringsSep "\n" (
-      lib.mapAttrsToList (
-        name: params: "ln -s ${fetchurl params} $PWD/build/_deps/${name}"
-      ) (import ./deps.nix)
-    );
-
-  meta = with lib; {
-    description = "Extensible text editor based on Scintilla with Lua scripting";
-    homepage = "http://foicica.com/textadept";
-    license = licenses.mit;
-    maintainers = with maintainers; [
-      raskin
-      mirrexagon
-      arcuru
-    ];
-    platforms = platforms.linux;
-    mainProgram = "textadept";
-  };
-}

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

···
 
   CopilotChat-nvim = buildVimPlugin {
     pname = "CopilotChat.nvim";
-    version = "2025-04-09";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "CopilotC-Nvim";
       repo = "CopilotChat.nvim";
-      rev = "a89f5f1162b04a0962e5f4c3cdf248a81e7e53cb";
-      sha256 = "0bp3zwfhp80581jw367kwxy104yr5rd6vvjlnsylb3nh9c6y7jjw";
+      rev = "634aa58117a9b70b3f08a0b150f11afd64f1c0eb";
+      sha256 = "11pc0m44yzwd8p7zd4nqjk7w4h0hxlk13p78107xp983m8v4jrzw";
     };
     meta.homepage = "https://github.com/CopilotC-Nvim/CopilotChat.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   SchemaStore-nvim = buildVimPlugin {
     pname = "SchemaStore.nvim";
-    version = "2025-04-10";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "b0o";
       repo = "SchemaStore.nvim";
-      rev = "992285058ce208825eb1b9ac82fa6be7d76ffcc1";
-      sha256 = "07n4wmai2bf4nxq05mra9qmqi35bfbm30vpl6n03d2f6kjmc6vj1";
+      rev = "e623e30df4053cacc67fb7eb04e1bd0fadba52b4";
+      sha256 = "0ragdcqr872v689sn8przq0yi4a1birrsma7f64a9g38chkiadx8";
     };
     meta.homepage = "https://github.com/b0o/SchemaStore.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   aerial-nvim = buildVimPlugin {
     pname = "aerial.nvim";
-    version = "2025-04-01";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "stevearc";
       repo = "aerial.nvim";
-      rev = "44684bf429dc40e97a6d00ffa09043ac3f692186";
-      sha256 = "02zd23np2pn7hivi8sl63lcdn85cfbvsapkyghkwh9prxg8a81zn";
+      rev = "2e00d1d4248f08dddfceacb8d2996e51e13e00f6";
+      sha256 = "18rhmpqs8440hn4g5786znj37fzb01wa3zws33rlq9vm6sfb0grw";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/stevearc/aerial.nvim/";
···
 
   aider-nvim = buildVimPlugin {
     pname = "aider.nvim";
-    version = "2025-01-07";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "joshuavial";
       repo = "aider.nvim";
-      rev = "a34a03635a130f16a56e6a50b211bb72cc1aff96";
-      sha256 = "00zfkqcldrqmlmj30gany0yqmyrc1i88hv7655bc78i0rihkv7di";
+      rev = "1e5fc680a764d2b93f342005d7e4415fec469088";
+      sha256 = "0f4gn4mwcghpcy5whah230y22wqaa1hxh8aczysh09fwdnigb4r4";
     };
     meta.homepage = "https://github.com/joshuavial/aider.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   ale = buildVimPlugin {
     pname = "ale";
-    version = "2025-04-10";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "dense-analysis";
       repo = "ale";
-      rev = "366de225fdd9ddef29a5b947c419303278af0c01";
-      sha256 = "0hhzbn1zv5bf03gjvsynkykrhzamiiwxqkryfnjbpy6jb6y2gc1g";
+      rev = "baaca9a5d7016c52466c3b4cd2d161b317d801ed";
+      sha256 = "1difjr5lj2adhp1r0damgfdrdvkj0qki31zc3vm5sqrb8izdh7mn";
     };
     meta.homepage = "https://github.com/dense-analysis/ale/";
     meta.hydraPlatforms = [ ];
···
 
   astrolsp = buildVimPlugin {
     pname = "astrolsp";
-    version = "2025-03-28";
+    version = "2025-04-15";
     src = fetchFromGitHub {
       owner = "AstroNvim";
       repo = "astrolsp";
-      rev = "bb0051597474971b93e1cde2fd960dda978c2378";
-      sha256 = "04v1vg0zyp3bjyikxm4qw6agylw4hjv2jg77vspnijvikb2qk6zq";
+      rev = "59a0228a6ededb8cebcd8557a61744f5c8afac1f";
+      sha256 = "0sxfm6bz044bpicxf40ksa9xbgfsm69v6803q912m335s53ffhwk";
     };
     meta.homepage = "https://github.com/AstroNvim/astrolsp/";
     meta.hydraPlatforms = [ ];
···
 
   astroui = buildVimPlugin {
     pname = "astroui";
-    version = "2025-04-09";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "AstroNvim";
       repo = "astroui";
-      rev = "4b1a46eb9576a187246e5fc41cb4670c3daf749e";
-      sha256 = "09yxv7kxw5bw1m9x0zv72sm2sqkv9hyjv5q2m0q7lzv44ijqdmrg";
+      rev = "fded232ee0001c6bed9b654188e3dd4b0c58317c";
+      sha256 = "0vh7qyj0cyd3vq1mv253sd48dcapf7idfnh7wv29qvvpsvwvamxc";
     };
     meta.homepage = "https://github.com/AstroNvim/astroui/";
     meta.hydraPlatforms = [ ];
···
 
   auto-session = buildVimPlugin {
     pname = "auto-session";
-    version = "2025-04-10";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "rmagatti";
       repo = "auto-session";
-      rev = "095b0b54d40c8cc7fe37f2ae4d948ec3069bb1c2";
-      sha256 = "0l0p9jxpwcngxl0isc7vbrqa5xg329h0qpqnfvaq0z2a1cb19xlb";
+      rev = "71c8af9a99e96b9d2533cf4bac4dfed1eafab923";
+      sha256 = "1g3lm02rhyg4s1kqpmazrdz4r8qibaxgb44pdpl8sfp2w2kssb1l";
     };
     meta.homepage = "https://github.com/rmagatti/auto-session/";
     meta.hydraPlatforms = [ ];
···
 
   base16-nvim = buildVimPlugin {
     pname = "base16-nvim";
-    version = "2025-04-14";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "RRethy";
       repo = "base16-nvim";
-      rev = "595861241130ad49222755cf90fb5aea8e0eab8d";
-      sha256 = "0b42jkzf5kfqj9zazkrvpdih1c06z4v3q6yj516r6va7kp14dkhs";
+      rev = "965160025d0facbe9caa863e5beef2a7a488e9d1";
+      sha256 = "02w1mn15gydma9canvqrlwf4l5z76s1vs01zanipwwflvwclsb8f";
     };
     meta.homepage = "https://github.com/RRethy/base16-nvim/";
     meta.hydraPlatforms = [ ];
···
 
   blink-compat = buildVimPlugin {
     pname = "blink.compat";
-    version = "2025-03-17";
+    version = "2025-04-15";
     src = fetchFromGitHub {
       owner = "Saghen";
       repo = "blink.compat";
-      rev = "2ed6d9a28b07fa6f3bface818470605f8896408c";
-      sha256 = "009475xy41l4dpayswhx65q6a7djzw7rz2ycbrbpyg041y0qynqs";
+      rev = "f1836ed7a07f8d082ff6c3fbae1e476ba2adee84";
+      sha256 = "0b22c943vbxn8cgfc3m0wmmia9rja6x766ywa798nx7s7x0sd53x";
     };
     meta.homepage = "https://github.com/Saghen/blink.compat/";
     meta.hydraPlatforms = [ ];
···
 
   blink-ripgrep-nvim = buildVimPlugin {
     pname = "blink-ripgrep.nvim";
-    version = "2025-03-31";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "mikavilpas";
       repo = "blink-ripgrep.nvim";
-      rev = "56084d1f45c8621d23d4bac724c2dc50b1eb75db";
-      sha256 = "1lyczjvwpi5f1mjgw059yzkxxjrk48vcvhdjzkjgakhsq76s125x";
+      rev = "ca538d15bd22fedd3408064d2b25ff8d56ec8ce8";
+      sha256 = "1rg40x0lvz11rl95b3q3kqzb8ygvyvhcxiw255200ccxl6q21jg8";
     };
     meta.homepage = "https://github.com/mikavilpas/blink-ripgrep.nvim/";
     meta.hydraPlatforms = [ ];
···
     meta.hydraPlatforms = [ ];
   };
 
+  claude-code-nvim = buildVimPlugin {
+    pname = "claude-code.nvim";
+    version = "2025-03-29";
+    src = fetchFromGitHub {
+      owner = "greggh";
+      repo = "claude-code.nvim";
+      rev = "b5c64c42832e5c6c7a02e8e8aa44cfa38a4ae0b2";
+      sha256 = "10s4bn1vcmvkgfxdcilqw85zzlfm2qipw25aqw7jjarys5y3jfik";
+    };
+    meta.homepage = "https://github.com/greggh/claude-code.nvim/";
+    meta.hydraPlatforms = [ ];
+  };
+
   clever-f-vim = buildVimPlugin {
     pname = "clever-f.vim";
     version = "2022-10-15";
···
 
   cmp-ai = buildVimPlugin {
     pname = "cmp-ai";
-    version = "2025-01-06";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "tzachar";
       repo = "cmp-ai";
-      rev = "f5e4dcbf763770880d0a01fe2bc139eb47597261";
-      sha256 = "093l4cdlmdgrhnv502kkyj4qi4jk656ks90wmfjbkxdffx6xdsrc";
+      rev = "5aa4530c1da98fc2e27f406170fe0635bae99c06";
+      sha256 = "1ak769vpbnp44vdna2c8b56aa99g1vc3mmbd8y7fnzai700slhdk";
     };
     meta.homepage = "https://github.com/tzachar/cmp-ai/";
     meta.hydraPlatforms = [ ];
···
 
   coc-nvim = buildVimPlugin {
     pname = "coc.nvim";
-    version = "2025-04-12";
+    version = "2025-04-15";
     src = fetchFromGitHub {
       owner = "neoclide";
       repo = "coc.nvim";
-      rev = "2bf3a4d979060e897fcee92a1c9f9abab501f06e";
-      sha256 = "09rgj3zqbw98l0d20y1jpk7b9xq112nhzyscwmrclhpmv2bb6lg4";
+      rev = "993a4a273bf0415296a1a8d512466b183670568a";
+      sha256 = "0nrsxl9faaq5rlvfsbwqpil7gczf2lz65jil4nj8kwmfi113rw37";
     };
     meta.homepage = "https://github.com/neoclide/coc.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   codecompanion-nvim = buildVimPlugin {
     pname = "codecompanion.nvim";
-    version = "2025-04-13";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "olimorris";
       repo = "codecompanion.nvim";
-      rev = "d71d8b96c0b1ec8c047fb938552035864d530bb1";
-      sha256 = "0rn7vhb5508lq0dx4xipyc249r09jh9ldmp6fqpwbskxw6809ms4";
+      rev = "b7c1fb1ced98468b3a9836101eaccdcdfc768c46";
+      sha256 = "1pplq2bzdg8vgikvhagml81zqq7qx4svbz5i57wkfhg2976hwdfq";
     };
     meta.homepage = "https://github.com/olimorris/codecompanion.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   competitest-nvim = buildVimPlugin {
     pname = "competitest.nvim";
-    version = "2025-04-09";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "xeluxee";
       repo = "competitest.nvim";
-      rev = "602cad3f5c4a116cdf8d0e8557bb0a9a2cea7245";
-      sha256 = "1fmsbjvd2w9fsc5k5l55sry21gysvxin5lxl4r8d3jvnr649j3w2";
+      rev = "c9be46ff8f0649987459b21006215bc5be20a95b";
+      sha256 = "0chj7mzqkwg74nbapyzfy5rq9p1vdq54l260rya69qkyzn3brkdi";
     };
     meta.homepage = "https://github.com/xeluxee/competitest.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   conform-nvim = buildVimPlugin {
     pname = "conform.nvim";
-    version = "2025-04-06";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "stevearc";
       repo = "conform.nvim";
-      rev = "eebc724d12c5579d733d1f801386e0ceb909d001";
-      sha256 = "122v0svrsss8g4gzy9fz2ppzm2lxf85l4m8wincxsy75x9v3ywgn";
+      rev = "372fc521f8421b7830ea6db4d6ea3bae1c77548c";
+      sha256 = "0b6qbwyb6ashpia7pk0r5kp82pdrblhmhmx1fprgy7lmgnm8mw97";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/stevearc/conform.nvim/";
···
 
   conjure = buildVimPlugin {
     pname = "conjure";
-    version = "2025-03-23";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "Olical";
       repo = "conjure";
-      rev = "980452d93fd6165d3f268f50a181ad7ca4c7b990";
-      sha256 = "0pwl2h19rx3cqkn5l8qdyvia09zkg7fsjafd3py65imji9anqzxi";
+      rev = "dc929e83287d84ac40a8e9635aa806415143beff";
+      sha256 = "124xwhlpp356lsa555876nskqi2c9sgyvc2v9wkbfr87i6jhdbk8";
     };
     meta.homepage = "https://github.com/Olical/conjure/";
     meta.hydraPlatforms = [ ];
···
 
   copilot-lua = buildVimPlugin {
     pname = "copilot.lua";
-    version = "2025-04-14";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "zbirenbaum";
       repo = "copilot.lua";
-      rev = "d712de3bc210fd8f28ab91de4bb23693fc0a2328";
-      sha256 = "0frwc1kfaa9151bgxickavyk4nznm839i0mrli3dx5iyzn2bziik";
+      rev = "dc579f98536029610cfa32c6bad86c0d24363679";
+      sha256 = "16zx9a8f2mjmj7ibdsjyj0vqdsc10yl1vrna0kkkgccj957rd99x";
     };
     meta.homepage = "https://github.com/zbirenbaum/copilot.lua/";
     meta.hydraPlatforms = [ ];
···
 
   copilot-vim = buildVimPlugin {
     pname = "copilot.vim";
-    version = "2025-04-11";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "github";
       repo = "copilot.vim";
-      rev = "250f24cc485aede5d0069e8765542c3787448d8d";
-      sha256 = "19n1zzvr7w2j5p2cc3d7fhf41zk3bhlf5nv1751fyf0fq1lacvpb";
+      rev = "8d1e0f86d8aaa64070c080589bc2a516beb4024f";
+      sha256 = "17q357rawgcvvdgpirqbgglpy110gk7j6lzy2n3ln02ajr8acs61";
     };
     meta.homepage = "https://github.com/github/copilot.vim/";
     meta.hydraPlatforms = [ ];
···
 
   csvview-nvim = buildVimPlugin {
     pname = "csvview.nvim";
-    version = "2025-04-07";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "hat0uma";
       repo = "csvview.nvim";
-      rev = "9cc5dcb060c96517d8c34b74e5b81d58529b3ea2";
-      sha256 = "1pmdh9y3z51cgywnr8byx8gl82bb7mxw76a86nmzipqhcl38yf6j";
+      rev = "6eb9c7293d35c40a71ec1eb9c653d80e8de5a2e9";
+      sha256 = "17ax71iyf8n8brxs71ckq218ccwajxqj2ird0pijqdmylm2mcy4z";
     };
     meta.homepage = "https://github.com/hat0uma/csvview.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   cyberdream-nvim = buildVimPlugin {
     pname = "cyberdream.nvim";
-    version = "2025-04-11";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "scottmckendry";
       repo = "cyberdream.nvim";
-      rev = "274eacedda3362faaa4fa850eebfc5911294992e";
-      sha256 = "0g12a6bfcd1ilzzsc2cx1cm4n3w2i9civhd79s4dpzvhcdbnnqfq";
+      rev = "982c9b33612a9cd97e6df141c3d8c535c74381c5";
+      sha256 = "16cwkcdsxanb37p6k3md4pflspf1cs8asvvjvqm7fjv9hfg38pyl";
     };
     meta.homepage = "https://github.com/scottmckendry/cyberdream.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   dropbar-nvim = buildVimPlugin {
     pname = "dropbar.nvim";
-    version = "2025-04-13";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "Bekaboo";
       repo = "dropbar.nvim";
-      rev = "a64fc20c4ec7e10fc92dc80312457010755bb019";
-      sha256 = "1rl81hfpha65gvvf98jd3m9skpfky5nssdmhbz2g8pxc0pkxm1p0";
+      rev = "cb7c17bb35fe8860d490dfd1d5c45fce40ecba26";
+      sha256 = "1m8yawharg9z01m34l5vwryzq4006wgk766vsjkizcfjiwvyvnjy";
     };
     meta.homepage = "https://github.com/Bekaboo/dropbar.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   easy-dotnet-nvim = buildVimPlugin {
     pname = "easy-dotnet.nvim";
-    version = "2025-04-13";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "GustavEikaas";
       repo = "easy-dotnet.nvim";
-      rev = "19ffa96ed51a2b536cedfdc107d9002293c606c6";
-      sha256 = "0cbcl5a6gir8ww0shsm440qf1dc7a8wmyck2lm4fbmad3r7zfzsz";
+      rev = "a2dff2b31d43ef31a87e6e979110f2736ee07db1";
+      sha256 = "16478bc60w44i6v39n7rrm7vri2yd1v8dxkap6ygq7w3h81kywhh";
     };
     meta.homepage = "https://github.com/GustavEikaas/easy-dotnet.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   edge = buildVimPlugin {
     pname = "edge";
-    version = "2025-02-24";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "sainnhe";
       repo = "edge";
-      rev = "04b2e25fa08b81e071ad512bdec6e5af114b01b3";
-      sha256 = "0mz0k0fx27dvnyim22fr48slqdqpzcaxcljfysx07b5ladn0jhzz";
+      rev = "8eeab1bc9d93eec3511cb4d3c87d2d599c7ce3d4";
+      sha256 = "1d6k3b6z9a4hrhk9ma3my28iga5y1s6srgv9jxwy6yg2wzi0lf9q";
     };
     meta.homepage = "https://github.com/sainnhe/edge/";
     meta.hydraPlatforms = [ ];
···
 
   everforest = buildVimPlugin {
     pname = "everforest";
-    version = "2025-02-26";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "sainnhe";
       repo = "everforest";
-      rev = "29d1f4f8b63dc91db277e977068f912939c8cae8";
-      sha256 = "1p946h4zq7qvkkb3y74bh3r4hbx4qykg4zzn088hvkki4ln7xaac";
+      rev = "ffa5a2032fd41903135fa829bd4b49ba2e1d5d18";
+      sha256 = "1s1m9z8061yvdr124hvwdpfhkyx1l46gcp860rz1bxlbk5h02g1z";
     };
     meta.homepage = "https://github.com/sainnhe/everforest/";
     meta.hydraPlatforms = [ ];
···
 
   friendly-snippets = buildVimPlugin {
     pname = "friendly-snippets";
-    version = "2025-04-13";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "rafamadriz";
       repo = "friendly-snippets";
-      rev = "31f2a2657b6261724313281fe0d8ba6f43f4a4fa";
-      sha256 = "0rkz7zbv1maqhr22nxq39w7pahahcapfyc4rgscmr3bm4dcymk2a";
+      rev = "16833311a0c51e7ee9a1ce939000f5b20a5d9d2b";
+      sha256 = "03n4f7vi0msdayjjiwk3jia8ip7470nbv058zlj3b14fci6in3kg";
     };
     meta.homepage = "https://github.com/rafamadriz/friendly-snippets/";
     meta.hydraPlatforms = [ ];
···
 
   fzf-vim = buildVimPlugin {
     pname = "fzf.vim";
-    version = "2025-03-21";
+    version = "2025-04-15";
     src = fetchFromGitHub {
       owner = "junegunn";
       repo = "fzf.vim";
-      rev = "1fff637559f29d5edbdb05e03327954a8cd9e406";
-      sha256 = "13xh17bqnb1k32jm53x9kqc8x6njwcdha9xbwn2zhm0s8dgqikzx";
+      rev = "3cb44a8ba588e1ada409af495bdc6a4d2d37d5da";
+      sha256 = "0v1svsw4wj4i2rayvksdpz8q65yvkdq9igpa64qq7xyd07jh6g8n";
     };
     meta.homepage = "https://github.com/junegunn/fzf.vim/";
     meta.hydraPlatforms = [ ];
···
 
   go-nvim = buildVimPlugin {
     pname = "go.nvim";
-    version = "2025-04-07";
+    version = "2025-04-15";
     src = fetchFromGitHub {
       owner = "ray-x";
       repo = "go.nvim";
-      rev = "ef38820e413e10f47d83688dee41785bd885fb2a";
-      sha256 = "1widcvlh2a8c8yk1qi35i11nx1cf8cadzj629l2nwbjy3z1vymb8";
+      rev = "ecffa1757ac8e84e1e128f12e0fdbf8418354f6f";
+      sha256 = "1d208n8iamhxq1gcmm69cahxqfdyc3w8shbdiavllxn2d9if823y";
     };
     meta.homepage = "https://github.com/ray-x/go.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   gruvbox = buildVimPlugin {
     pname = "gruvbox";
-    version = "2023-08-14";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "morhetz";
       repo = "gruvbox";
-      rev = "f1ecde848f0cdba877acb0c740320568252cc482";
-      sha256 = "1qqb0a5fscqglii8vh9v2wqk40cka2f2k7h8ylysh89w9ppnx142";
+      rev = "697c00291db857ca0af00ec154e5bd514a79191f";
+      sha256 = "0gj1bikyz13jgd5rqmkdgxmva2mnmd672hhn4jd1dr7nw1dghrby";
     };
     meta.homepage = "https://github.com/morhetz/gruvbox/";
     meta.hydraPlatforms = [ ];
···
 
   gruvbox-material = buildVimPlugin {
     pname = "gruvbox-material";
-    version = "2025-02-24";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "sainnhe";
       repo = "gruvbox-material";
-      rev = "146f40fd42cbef30fed69b4ef51329aeeaceb909";
-      sha256 = "0bgxfflssqhmlq9v613xw017niyram12vnshd3znlgbsblxa5frx";
+      rev = "f5f912fbc7cf2d45da6928b792d554f85c7aa89a";
+      sha256 = "0ld6rpmz2r4kjz7i0fhjyr7shq8fgcaw04542g0al4k92izb8xmg";
     };
     meta.homepage = "https://github.com/sainnhe/gruvbox-material/";
     meta.hydraPlatforms = [ ];
···
 
   gruvbox-nvim = buildVimPlugin {
     pname = "gruvbox.nvim";
-    version = "2025-04-02";
+    version = "2025-04-15";
     src = fetchFromGitHub {
       owner = "ellisonleao";
       repo = "gruvbox.nvim";
-      rev = "12b5420b665e8053d74eb075d8a589477333f67d";
-      sha256 = "16fa841cv0dbn7pkcs44r5ch241vhax8jfxgcxwwd0z4srlbj6gy";
+      rev = "a933d8666dad9363dc6908ae72cfc832299c2f59";
+      sha256 = "02r2h0ip2vzmgmv9b36ff2r6br3ql0b9ggzl8ijsyjy7pgiij04y";
     };
     meta.homepage = "https://github.com/ellisonleao/gruvbox.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   helpview-nvim = buildVimPlugin {
     pname = "helpview.nvim";
-    version = "2025-03-07";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "OXY2DEV";
       repo = "helpview.nvim";
-      rev = "49e8d4782ae73274a35d606fde2844b6e958a0c7";
-      sha256 = "1ichkr5f3wcyadjc8n0mbk3x6i128cyl4603h6skdbc17yfm7iw6";
+      rev = "493060153bc99927a64b203ea2ee49bb2884c190";
+      sha256 = "0gvs61bxzl3mmfvradcsl2wyaamzw8ch8d6yiwhaw9v4a7gspyvl";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/OXY2DEV/helpview.nvim/";
···
 
   iron-nvim = buildVimPlugin {
     pname = "iron.nvim";
-    version = "2025-04-01";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "Vigemus";
       repo = "iron.nvim";
-      rev = "93b3b97cf4313613fba5e91055deaf091cd78483";
-      sha256 = "1nbi4ypayz2w3z99ycrirgad9yd8cm3n1psxdwwfcr5q6jsyh5l9";
+      rev = "c005b01b779f1b6c038e11248db403bb3df6a7f3";
+      sha256 = "1nk1aij16akmq7f3s5malzywik0jw6ppd9p2mp7d0p1n8nq9ifnl";
     };
     meta.homepage = "https://github.com/Vigemus/iron.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   jinja-vim = buildVimPlugin {
     pname = "jinja.vim";
-    version = "2025-02-28";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "HiPhish";
       repo = "jinja.vim";
-      rev = "a56da59ed3b49f09b4b20e35b80a197bc7f54fe4";
-      sha256 = "1k233zaxp4kwkqb74g93jv3w9c9sc4s7ycgadc6knhfy9i3cr4mp";
+      rev = "f29c4abc60dae17b2931621748d14d2759e00a6c";
+      sha256 = "1f341lg551v72jc0m0c2rbp7nyni0rnfhr66ckggfwnqlskz4xaw";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/HiPhish/jinja.vim/";
···
 
   kulala-nvim = buildVimPlugin {
     pname = "kulala.nvim";
-    version = "2025-04-14";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "mistweaverco";
       repo = "kulala.nvim";
-      rev = "5fddda621630fef17e09cec930d2e307f4a5a138";
-      sha256 = "1gwqr1rrs1asviv30v7hwb7afgvqx7v1k6spg511qi25zp94108j";
+      rev = "f2a5d94d4fe5f67707bf8a36331fdd803044c051";
+      sha256 = "11407b8974y7kghjgkc0dhn4kjs7cijjpjmihdzcvyhxvaxfhqsk";
     };
     meta.homepage = "https://github.com/mistweaverco/kulala.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   lean-nvim = buildVimPlugin {
     pname = "lean.nvim";
-    version = "2025-04-11";
+    version = "2025-04-21";
     src = fetchFromGitHub {
       owner = "Julian";
       repo = "lean.nvim";
-      rev = "c3fb55496b1e48e2d755734c71f5ba5f1c1d4f59";
-      sha256 = "03774wk7pnf0bfxaqv138d2dbvr6799bla9jx0j7msrlmk7pm7s5";
+      rev = "b66d9cdd931cbec760ead7bb81e514301466a20c";
+      sha256 = "0ndrsmgahnmv3rd9m6hhj3c0w3blbn2cx7ixaflq4c89jhsb0m9k";
     };
     meta.homepage = "https://github.com/Julian/lean.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   leap-nvim = buildVimPlugin {
     pname = "leap.nvim";
-    version = "2025-04-14";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "ggandor";
       repo = "leap.nvim";
-      rev = "8a0efa79133fee211017d769c8031512192008b3";
-      sha256 = "0pgg26r5rh1r2364yj05w4scarzy6zwsp6w7s9yxgfmk7l9x89yk";
+      rev = "2b68ddc0802bd295e64c9e2e75f18f755e50dbcc";
+      sha256 = "07bdhfsig70qblvk2x0n35i5apz3mjdr05ba3082mh438ikgfmvx";
     };
     meta.homepage = "https://github.com/ggandor/leap.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   lspsaga-nvim = buildVimPlugin {
     pname = "lspsaga.nvim";
-    version = "2025-03-26";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "nvimdev";
       repo = "lspsaga.nvim";
-      rev = "778d56ff9b387dacd14ae648ed5604394b486f51";
-      sha256 = "1rm8ww8krxliwli9m2j6j37xgwgjsrgapvgrcdr6nd4mi6hgmczm";
+      rev = "920b1253e1a26732e53fac78412f6da7f674671d";
+      sha256 = "0wkcgy2x119sd9xn6k9vs83pvrj0m4ali1ac72pah8pnlzfvkw7i";
     };
     meta.homepage = "https://github.com/nvimdev/lspsaga.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   markview-nvim = buildVimPlugin {
     pname = "markview.nvim";
-    version = "2025-04-12";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "OXY2DEV";
       repo = "markview.nvim";
-      rev = "3cc0a687bfddf50eac2370c194f8d7ad14344db2";
-      sha256 = "19qbdrhcjdnnqifvl7x8bq0s6s03xr1i4g4jgn205qcx9j8570xz";
+      rev = "74983021512660bbade34a46cd03595b993412c0";
+      sha256 = "0wrwapf6cxrnkjcccy70azv3nccxlc41gj2az0nra5r4p0w7xfvb";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/OXY2DEV/markview.nvim/";
···
 
   mini-completion = buildVimPlugin {
     pname = "mini.completion";
-    version = "2025-04-12";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "echasnovski";
       repo = "mini.completion";
-      rev = "cf3625d2c4a437f5edf7e61382e0fe522fc76fb7";
-      sha256 = "0lpvl1kd7vmyy00p97am9ghj6gdmnk1dbw93wjmnvin057w9sysw";
+      rev = "35130cebc63ace7d6e4583f349af8cd3f3141af7";
+      sha256 = "0h5z5i62cc780bzw60rbizngvpyl4vk7j858pndyi2g572plz929";
     };
     meta.homepage = "https://github.com/echasnovski/mini.completion/";
     meta.hydraPlatforms = [ ];
···
 
   mini-nvim = buildVimPlugin {
     pname = "mini.nvim";
-    version = "2025-04-12";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "echasnovski";
       repo = "mini.nvim";
-      rev = "b418d585d99bd1c1a4b04dc8b2c585471665173a";
-      sha256 = "0fvr4f847jp3fyskpn16w995ijzl98bzmjbhfjqm4h37viqib06b";
+      rev = "c404fc5717866ff738aadeeb1f54ab8ed270ae1e";
+      sha256 = "09yv0iwswrzvinq6rdr9b6l9zd7xgr0sc4psb3k1bpsi58mmc0cg";
     };
     meta.homepage = "https://github.com/echasnovski/mini.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   mini-snippets = buildVimPlugin {
     pname = "mini.snippets";
-    version = "2025-04-01";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "echasnovski";
       repo = "mini.snippets";
-      rev = "e05106957fc178285dbc510ff833985da59d3e5a";
-      sha256 = "0pn9i6sfh3fxkjzh9yyyc05lgcgm8wsanvl7axmy4p7a9spnfa2q";
+      rev = "d005684e620e76eb2a5fbbbd211a1eba7212b4aa";
+      sha256 = "19xmqzgx0lv6m6lp6dn4pcr53clgjyrlnh45j795cy9szizw4y0x";
     };
     meta.homepage = "https://github.com/echasnovski/mini.snippets/";
     meta.hydraPlatforms = [ ];
···
 
   minuet-ai-nvim = buildVimPlugin {
     pname = "minuet-ai.nvim";
-    version = "2025-04-13";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "milanglacier";
       repo = "minuet-ai.nvim";
-      rev = "a647a85a7a1ad6bb2624de9ebe25cba2fe4dcc7c";
-      sha256 = "0j3fnh56i640h7iyvr7c821p0ncf02xbmars58bf28h10hh3iwyq";
+      rev = "f5272221c3378421dc416a0efa5007e1de104b7f";
+      sha256 = "1443nr2f80df6d3d4sgm0v9p2biii6si9x7wwbn8padsmsma4837";
     };
     meta.homepage = "https://github.com/milanglacier/minuet-ai.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   nabla-nvim = buildVimPlugin {
     pname = "nabla.nvim";
-    version = "2023-12-23";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "jbyuki";
       repo = "nabla.nvim";
-      rev = "27a6ea9ed7452bb9e0b19eb0942b5bcf7d051b2f";
-      sha256 = "1dnd6s6abwxihliqqyl1vrds14w502m0x7aadlxrrfh970bqikg0";
+      rev = "8247b977bd9ef249bee0eea8db57e422c1d12762";
+      sha256 = "0pj05zbl31w9a6bs42qvi5kla89zq7w8nffb6s78nqk9m7ny92as";
     };
     meta.homepage = "https://github.com/jbyuki/nabla.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   neo-tree-nvim = buildVimPlugin {
     pname = "neo-tree.nvim";
-    version = "2025-04-09";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "nvim-neo-tree";
       repo = "neo-tree.nvim";
-      rev = "5224467c6a49a6c77b8a8333f4d9af0abc788e10";
-      sha256 = "0dzppxi4w38s3pqsgwd3z0xr1r14bd0v4qpakxw3kjn9wr2d8y7n";
+      rev = "1ef260eb4f54515fe121a2267b477efb054d108a";
+      sha256 = "0j0gr2pisrj5vsiwsvrd3dkrdrd3q2742srk23rw2x0h055c0mxh";
     };
     meta.homepage = "https://github.com/nvim-neo-tree/neo-tree.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   neoconf-nvim = buildVimPlugin {
     pname = "neoconf.nvim";
-    version = "2025-04-14";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "folke";
       repo = "neoconf.nvim";
-      rev = "0c3cb10a7ff11acfa3067896a6108db3bd18d8aa";
-      sha256 = "14yf91wvw6vfrsyb9i2zhm74hpx7bnw515drw5pnfsp9s49w056a";
+      rev = "114aa200d636dd62fb5ec2323f2c291d6168128b";
+      sha256 = "1fcdkpnb2pabgz7b6rngkfvqns0q70nw3whmjaw5aapk1sdn28f8";
     };
     meta.homepage = "https://github.com/folke/neoconf.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   neogit = buildVimPlugin {
     pname = "neogit";
-    version = "2025-04-08";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "NeogitOrg";
       repo = "neogit";
-      rev = "97f83f1dc51dee41e08e3c7a8adf00e1083e3178";
-      sha256 = "0xsrfy0lzf9nq62gii67a5k21d1460fdpy32hh40k4i6zpsbn28f";
+      rev = "9bb1e73c534f767607e0a888f3de4c942825c501";
+      sha256 = "06qcyz3snk8bphbd2n9q4dzizkksn65is0nksd76q0zzkvb9qxhp";
     };
     meta.homepage = "https://github.com/NeogitOrg/neogit/";
     meta.hydraPlatforms = [ ];
···
 
   neorg-telescope = buildVimPlugin {
     pname = "neorg-telescope";
-    version = "2024-07-30";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "nvim-neorg";
       repo = "neorg-telescope";
-      rev = "ddb2556644cae922699a239bbb0fe16e25b084b7";
-      sha256 = "0p2s3n22fy1vkqc9n55x6kssqs4n0znwlszfrs532hj8m992wbks";
+      rev = "7fb6ca6a632c3c095601d379a664c0c1f802dc6c";
+      sha256 = "12pbixkb7175qb9wblq01mbpkccm9h0si7b2jjaf7yip8j8frxmn";
     };
     meta.homepage = "https://github.com/nvim-neorg/neorg-telescope/";
     meta.hydraPlatforms = [ ];
···
 
   neotest-haskell = buildVimPlugin {
     pname = "neotest-haskell";
-    version = "2025-04-13";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "MrcJkb";
       repo = "neotest-haskell";
-      rev = "b1a01f95d2359e87d43bd6df5cf9135655fe9e1a";
-      sha256 = "1b3wsm8794bf0c9n853issfnhyayx439wvjiqj50rfmzhlb1xrq5";
+      rev = "aaf371f3d44fbf35ff189d16cb22c2a732309c37";
+      sha256 = "1v4hjhfimyr53j28bi1p62cydbrn5nfkj4mk7ljkifrkmnyahbsd";
     };
     meta.homepage = "https://github.com/MrcJkb/neotest-haskell/";
     meta.hydraPlatforms = [ ];
···
 
   nfnl = buildVimPlugin {
     pname = "nfnl";
-    version = "2025-04-08";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "Olical";
       repo = "nfnl";
-      rev = "c0e153c8c63926647a70b90cc2c98897278f53c8";
-      sha256 = "1b7imv4yjbrz96fk8na7f38n38j1n54kgnigmz9m41mk40vf17ja";
+      rev = "9f05512f3d933d3aba6ae067f5cb58e891be31a6";
+      sha256 = "11cdc18219yaaphjxl00mia8d3rmq7cm9k16751675p36hx26xpy";
     };
     meta.homepage = "https://github.com/Olical/nfnl/";
     meta.hydraPlatforms = [ ];
···
 
   nlsp-settings-nvim = buildVimPlugin {
     pname = "nlsp-settings.nvim";
-    version = "2025-04-14";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "tamago324";
       repo = "nlsp-settings.nvim";
-      rev = "fa95b60dad126efebbf0180ab42ccc66e98f4f84";
-      sha256 = "0kw6kb2456va3abn660sswqjmm1wcjivhxp1kfiilr87l6a2b59n";
+      rev = "852140cecf00e4d41289da6d20a2dddeca70e967";
+      sha256 = "175nysna5xz7mn6ml4xmlrh02aq1ck0qsyhk739wws81zrfk3062";
     };
     meta.homepage = "https://github.com/tamago324/nlsp-settings.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   no-neck-pain-nvim = buildVimPlugin {
     pname = "no-neck-pain.nvim";
-    version = "2025-03-07";
+    version = "2025-04-15";
     src = fetchFromGitHub {
       owner = "shortcuts";
       repo = "no-neck-pain.nvim";
-      rev = "53c8ef094c86e8897be2dcce0259d35914f6cdc0";
-      sha256 = "0irbl28jr9h20zyfm5m3wf7saxq1acc48kn3vp4ijc271l0bs97g";
+      rev = "8d17abf5ff9208865439e683da7bbe93dde8d4e1";
+      sha256 = "1dr43al236bhifrc740vwfwz6xsma4m3fza2qm5xjgjdcz7ib23c";
     };
     meta.homepage = "https://github.com/shortcuts/no-neck-pain.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   none-ls-nvim = buildVimPlugin {
     pname = "none-ls.nvim";
-    version = "2025-04-13";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "nvimtools";
       repo = "none-ls.nvim";
-      rev = "1280b7965b6ed17787ffab1d4e3d9795ecdd0f51";
-      sha256 = "01r495800dm1b1n25skv081hb701i3npvwxb5dabg2iy5b6nzyms";
+      rev = "fb50cf17e926a037c9f8d96d8db29ddbd04965d4";
+      sha256 = "07zfkjdqwlrm1d07za0payqs37gmn4x8m489438nv84sqqhnfrvd";
     };
     meta.homepage = "https://github.com/nvimtools/none-ls.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   nvchad = buildVimPlugin {
     pname = "nvchad";
-    version = "2025-04-08";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "nvchad";
       repo = "nvchad";
-      rev = "46b15ef1b9d10a83ab7df26b14f474d15c01e770";
-      sha256 = "1fca00xiqsc3ixl9d8qqypp7hzm6vmyikva2iwcxpdnnrvbvwi2v";
+      rev = "84f8170fdab2a9bb82f36fe76c68bca2241c50d8";
+      sha256 = "10va5jv8s670jn8ayqylpksb1rcgjr1m43vh0vq5qdxswanqzby7";
     };
     meta.homepage = "https://github.com/nvchad/nvchad/";
     meta.hydraPlatforms = [ ];
···
 
   nvchad-ui = buildVimPlugin {
     pname = "nvchad-ui";
-    version = "2025-04-12";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "nvchad";
       repo = "ui";
-      rev = "9201de37eb4992bef5fec974618a9a14082765fe";
-      sha256 = "0g8rlw7s38pzy3ig18lzjrww0apqw505q614qb32jidxw715291c";
+      rev = "c448a23a66089f73d6ec4090278c054668f4ae69";
+      sha256 = "044mlfjgm0a15fjn5gb1a3w259nzsz2y73v2z8akkp519s8vxyvi";
     };
     meta.homepage = "https://github.com/nvchad/ui/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-dap = buildVimPlugin {
     pname = "nvim-dap";
-    version = "2025-03-29";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "mfussenegger";
       repo = "nvim-dap";
-      rev = "7aade9e99bef5f0735cf966e715b3ce45515d786";
-      sha256 = "0cr2y3lkr6ffxxd9b2pj8hr3fzb5dlj003fcknswqwsdhws75l22";
+      rev = "98bf130702eaafad8567c0e3ea1171c2552d58bb";
+      sha256 = "045sajd5amwxq4964yj4lbh20daa0g8473a0ggbwggxpq6qz2678";
     };
     meta.homepage = "https://github.com/mfussenegger/nvim-dap/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-dap-view = buildVimPlugin {
     pname = "nvim-dap-view";
-    version = "2025-04-14";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "igorlfs";
       repo = "nvim-dap-view";
-      rev = "de489c1b1e0fa426c5e6c42e05218c707e2c7373";
-      sha256 = "1liwi829rj981wi6hhi7mqn662bvxva5a3annrsg7n33z6z7nznc";
+      rev = "aeba18d93cd2f32a5f4a710555c6de72085a0e2e";
+      sha256 = "1l9cxshd5zjxm0rsc7dq3s5xdk6dyp0hail41mjv020p4iynbis1";
     };
     meta.homepage = "https://github.com/igorlfs/nvim-dap-view/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-highlite = buildVimPlugin {
     pname = "nvim-highlite";
-    version = "2025-04-01";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "Iron-E";
       repo = "nvim-highlite";
-      rev = "2fbe9708880020f169ac61bb4fce904c36d9ccad";
-      sha256 = "1b2g12inhkjm7xs3lsmfwnrrriik43d3v8ja3rq322xhxrqbhxlz";
+      rev = "89607b55b321a9d55979e0cc4229223cd0db4cbd";
+      sha256 = "09i8fsr47nq78s7gys6cli73savpmmz3b5cw6jp3997vh085nzfq";
     };
     meta.homepage = "https://github.com/Iron-E/nvim-highlite/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-hlslens = buildVimPlugin {
     pname = "nvim-hlslens";
-    version = "2025-03-28";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "kevinhwang91";
       repo = "nvim-hlslens";
-      rev = "00b9c7359eaaa4804a9be943ea46bc64e6d2e065";
-      sha256 = "0hkilzijh6xhscd03pr1khvcza7qy606fj9lw0cranbgkd05nlr4";
+      rev = "bf55af8789948fac50d959e6e051af3ed280d9b8";
+      sha256 = "0q6s301vh6m4sz8w2i1xrmks7jijzi1qdjq8jxhmzlhvg7kh4c4a";
     };
     meta.homepage = "https://github.com/kevinhwang91/nvim-hlslens/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-jdtls = buildVimPlugin {
     pname = "nvim-jdtls";
-    version = "2025-04-11";
+    version = "2025-04-15";
     src = fetchFromGitHub {
       owner = "mfussenegger";
       repo = "nvim-jdtls";
-      rev = "7223b812dde98f4260084fe9303c8301b9831a58";
-      sha256 = "0pj5fm6k8684qbpd7q6y9cnznz4s91qjv5wp8f49rivsqxsmg9sr";
+      rev = "5ecf13c53c9a66ee97c200970029ab2ebe1c1112";
+      sha256 = "127ndcm3hdm5s3xjh1rsijg6wdd9mpp966vds1scdmbqcxssn0zq";
     };
     meta.homepage = "https://github.com/mfussenegger/nvim-jdtls/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-lint = buildVimPlugin {
     pname = "nvim-lint";
-    version = "2025-04-10";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "mfussenegger";
       repo = "nvim-lint";
-      rev = "5b1bdf306bd3e565908145279e8bbfc594dac3b3";
-      sha256 = "0kwdb9wggkgzg9msrvnf15njqm9a8acljdak9fxnfh9al1ks8cav";
+      rev = "d698d3b6fd7b1b85657d05a2a31d843ddb682c63";
+      sha256 = "0m4hj1yc0s6cb3icshcr3qkd5wknksnnw97axjbacsan5vc6831z";
     };
     meta.homepage = "https://github.com/mfussenegger/nvim-lint/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-lspconfig = buildVimPlugin {
     pname = "nvim-lspconfig";
-    version = "2025-04-14";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "neovim";
       repo = "nvim-lspconfig";
-      rev = "e39da6a820d2a700904117d29f0dd476d64262cf";
-      sha256 = "1kmxrvqj48z131myhwlfk50lj0iizxcl97risnnh5rma9lnd189m";
+      rev = "32b6a6449aaba11461fffbb596dd6310af79eea4";
+      sha256 = "0rbqg3xdsdfklcsadzbbphzrgwa2c54lsipfqd67jq2p4baxsgxn";
     };
     meta.homepage = "https://github.com/neovim/nvim-lspconfig/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-metals = buildVimPlugin {
     pname = "nvim-metals";
-    version = "2025-04-04";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "scalameta";
       repo = "nvim-metals";
-      rev = "bc896458ac639dea568e8dc06862074f8cba7fa3";
-      sha256 = "0k7c300rf62f50vqzxxdgh7pqpb61im6xbz230fysvdjdx1ddglh";
+      rev = "04d8ce24638412a2c93dd79fecca4b2c7b9c07f9";
+      sha256 = "19mdfn5ni35ldjmwdg25cwiy9cvkg2cxrdhcjr9xplx7ln6zsld9";
     };
     meta.homepage = "https://github.com/scalameta/nvim-metals/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-navic = buildVimPlugin {
     pname = "nvim-navic";
-    version = "2023-11-30";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "smiteshp";
       repo = "nvim-navic";
-      rev = "8649f694d3e76ee10c19255dece6411c29206a54";
-      sha256 = "0964wgwh6i4nm637vx36bshkpd5i63ipwzqmrdbkz5h9bzyng7nj";
+      rev = "39231352aec0d1e09cebbffdd9dc20a5dc691ffe";
+      sha256 = "1xj2bzax8hynm2x9zbvsaxv1j22chklyygzm1kbqxxs077qn45ws";
     };
     meta.homepage = "https://github.com/smiteshp/nvim-navic/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-scrollview = buildVimPlugin {
     pname = "nvim-scrollview";
-    version = "2025-04-13";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "dstein64";
       repo = "nvim-scrollview";
-      rev = "d519e9fcf7ec32ede158e13161519bf11acfadd1";
-      sha256 = "05l3krv534n4639s61lvxh1zdgycyhd37nfsrsm8cybs2grspx9p";
+      rev = "cf766a45303e8cd94b624a94dc6c256405ef6bbc";
+      sha256 = "1jlk3d7479a278j2rbna9vm7asp8qglgz95w72frmzvkxzmmafba";
     };
     meta.homepage = "https://github.com/dstein64/nvim-scrollview/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-surround = buildVimPlugin {
     pname = "nvim-surround";
-    version = "2025-03-22";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "kylechui";
       repo = "nvim-surround";
-      rev = "caf6f633d4d77a29b6e265b560c5a035d171a913";
-      sha256 = "130y0b2f69y5rzm64ss34a9zyqkpkybr2d1s4p0pcvvaq1ngq0r0";
+      rev = "0e62500b98f4513feaaf7425c135472457ea5b7d";
+      sha256 = "0rwzz98n8gyx2bffxg7ga7vxxxcc4crbwimvglx6bxkdg2abwyrn";
     };
     meta.homepage = "https://github.com/kylechui/nvim-surround/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-tree-lua = buildVimPlugin {
     pname = "nvim-tree.lua";
-    version = "2025-04-11";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "nvim-tree";
       repo = "nvim-tree.lua";
-      rev = "5bea2b37523a31288e0fcab42f3be5c1bd4516bb";
-      sha256 = "1mizgknbbjqv7a8fqc0n7glgabl0fq660nrqwq6w04qqynp0z1ax";
+      rev = "64bb47f868e1d120df1ff0cb63fb626c4b076459";
+      sha256 = "1zminyhvka47rp0pc2v1i0rw4y6lcn10l4p7wwy0wb5nsxdaj2mp";
     };
     meta.homepage = "https://github.com/nvim-tree/nvim-tree.lua/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-treesitter = buildVimPlugin {
     pname = "nvim-treesitter";
-    version = "2025-04-13";
+    version = "2025-04-15";
     src = fetchFromGitHub {
       owner = "nvim-treesitter";
       repo = "nvim-treesitter";
-      rev = "7bbed4b548d9a81c14351bda93d16336edefd067";
-      sha256 = "1i0fffs915jc340s63pis2rblzr4gji42hg3s99qvbfnf6k4lnpi";
+      rev = "684eeac91ed8e297685a97ef70031d19ac1de25a";
+      sha256 = "00ccbnnvpcf0lrpbaygzz9wdnf59ixp43z0zry1qvblnjplrlwb7";
     };
     meta.homepage = "https://github.com/nvim-treesitter/nvim-treesitter/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-treesitter-context = buildVimPlugin {
     pname = "nvim-treesitter-context";
-    version = "2025-04-04";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "nvim-treesitter";
       repo = "nvim-treesitter-context";
-      rev = "439789a9a8df9639ecd749bb3286b77117024a6f";
-      sha256 = "04x9nza48d2vz262myhhfnmjzcc2fkdjb21mdqvlmnzkhh7ysyz2";
+      rev = "6daca3ad780f045550b820f262002f35175a6c04";
+      sha256 = "0qprwd44hw9sz0vh14p6lpvs9vxrick462pfkradmal6ak1kfwn3";
     };
     meta.homepage = "https://github.com/nvim-treesitter/nvim-treesitter-context/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-treesitter-endwise = buildVimPlugin {
     pname = "nvim-treesitter-endwise";
-    version = "2025-04-02";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "RRethy";
       repo = "nvim-treesitter-endwise";
-      rev = "63a8f855c6b6019ef9f7f63b5c59b8a00c215d0d";
-      sha256 = "1vbjmdafnfcfzj3gczg2py370cjvaaglxr4jwbnaa200vhgn8jj6";
+      rev = "8b6436303dda9ce6ed4b3733fd15703eb3589c36";
+      sha256 = "134k6b66c0ycqqdxzmsyzpl5igd5vlvxjjbdncswqyxwpypm9mq6";
     };
     meta.homepage = "https://github.com/RRethy/nvim-treesitter-endwise/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-treesitter-textobjects = buildVimPlugin {
     pname = "nvim-treesitter-textobjects";
-    version = "2025-04-06";
+    version = "2025-04-15";
     src = fetchFromGitHub {
       owner = "nvim-treesitter";
       repo = "nvim-treesitter-textobjects";
-      rev = "698b5f805722254bca3c509591c1806d268b6c2f";
-      sha256 = "0lxikjxgfjbr28xf00p7rphbfp4fwrxj0yma9cin0i74ah5gxam3";
+      rev = "205e3369bc83d8cb83f7409c36120e24611f8c5c";
+      sha256 = "13qmsnahlj88wxs75kvpn9hj89gnhm4dm6rb400ysrzmmx5ypg39";
     };
     meta.homepage = "https://github.com/nvim-treesitter/nvim-treesitter-textobjects/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-ufo = buildVimPlugin {
     pname = "nvim-ufo";
-    version = "2025-04-11";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "kevinhwang91";
       repo = "nvim-ufo";
-      rev = "a026364df62e88037b26d37c9f14c17c006fd577";
-      sha256 = "02mqjwc4h29i9s9l8lsfwrx4ac69n3mpr9hw2vg7ji3c20mbh413";
+      rev = "fb1da7d49c8f2704bb593a9683dc2ce3933d892a";
+      sha256 = "13l8qsm61vxirwgr2m02b6vazwcih6gfh82a5zkcam0syry66rpq";
     };
     meta.homepage = "https://github.com/kevinhwang91/nvim-ufo/";
     meta.hydraPlatforms = [ ];
···
 
   nvim-various-textobjs = buildVimPlugin {
     pname = "nvim-various-textobjs";
-    version = "2025-04-14";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "chrisgrieser";
       repo = "nvim-various-textobjs";
-      rev = "1b6caa4431fc3e637d26db70605736d10f05d2fd";
-      sha256 = "1ir083jsvjzzqbjly6csrmrnxq80b65861qmcplpvr7xhl98bdl3";
+      rev = "dcf0cd99a1ae0bade0e812a381ac4399d65cc0c3";
+      sha256 = "0gczvica73yr5fd1injab5iwwvc7lwby0zq2jy4kdkwjsbwsvcp0";
     };
     meta.homepage = "https://github.com/chrisgrieser/nvim-various-textobjs/";
     meta.hydraPlatforms = [ ];
···
 
   obsidian-nvim = buildVimPlugin {
     pname = "obsidian.nvim";
-    version = "2025-04-13";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "obsidian-nvim";
       repo = "obsidian.nvim";
-      rev = "0cf0dab342e88b8c8102bb352517d1aa88917af0";
-      sha256 = "0qd3nhhr33qhfjsjsnjcichq38pq227bgfncibdm11h4jv6fb6l2";
+      rev = "6704029e7b2dc0ea5465943cb1c0a331e8e894be";
+      sha256 = "1wg5qbj2qcgq55qlbqi5cv2w3x47lmql0bbx94fj45cxxqq1mim3";
     };
     meta.homepage = "https://github.com/obsidian-nvim/obsidian.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   octo-nvim = buildVimPlugin {
     pname = "octo.nvim";
-    version = "2025-04-14";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "pwntester";
       repo = "octo.nvim";
-      rev = "e3f4b7d711eeb0cefc1e3bff8cf6ddd0e166b868";
-      sha256 = "01cyjh8m51g1df8ciy7qqnq0ifkm7w3mg1f4gwpm777bd10jfj25";
+      rev = "d00dadb7286b0e1c6dd22448477ebb4277707ca9";
+      sha256 = "03xfjfp4yzjw8ab2c1xz9rjadj6g4s1xr3296k6b40jj1cqc7igp";
     };
     meta.homepage = "https://github.com/pwntester/octo.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   onedarkpro-nvim = buildVimPlugin {
     pname = "onedarkpro.nvim";
-    version = "2025-04-13";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "olimorris";
       repo = "onedarkpro.nvim";
-      rev = "5d9f719f622f798bea37bc243ec46581b8efc9b7";
-      sha256 = "0x8r64n9qrvdlyfmk4jw1mpll0s4cvlj6xarfycdn5g8z5445340";
+      rev = "d3d3e11331d30f7d5c1453232bad9c24d04e564f";
+      sha256 = "00hfm3rav9blsxaf28rz5vnhp5dvg25ychya3si0pzgbpi6y161s";
     };
     meta.homepage = "https://github.com/olimorris/onedarkpro.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   onenord-nvim = buildVimPlugin {
     pname = "onenord.nvim";
-    version = "2025-03-30";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "rmehri01";
       repo = "onenord.nvim";
-      rev = "502abed6c21b19daa6f5f7b0f74d762e137aee3f";
-      sha256 = "04zyvh1i3wrdqdn67rp19zr9vz9kn99vvl1awd5agn9sv0hzvadd";
+      rev = "039f76baf948acfc7c7d987ad9392fdc2a0e8a1c";
+      sha256 = "1m6i7jks0pfzml2i3gzr3y20k9dv3hx2fg0a357cps9rg84nx0qd";
     };
     meta.homepage = "https://github.com/rmehri01/onenord.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   org-roam-nvim = buildVimPlugin {
     pname = "org-roam.nvim";
-    version = "2025-04-11";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "chipsenkbeil";
       repo = "org-roam.nvim";
-      rev = "d7ac6a394f5158984b29596aee4861fb93030e81";
-      sha256 = "1kwimzssknzkcz3lj8k0rr4qv45qlhn0jnag6rq25ps7vn4nbd68";
+      rev = "5ff1c9b0d89ac4a142abe3723e535fb127a516e4";
+      sha256 = "0c1vcq4rzilyqb8d21jqh8icdqa22n9xswx919mf8pmhz1smbs2c";
     };
     meta.homepage = "https://github.com/chipsenkbeil/org-roam.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   outline-nvim = buildVimPlugin {
     pname = "outline.nvim";
-    version = "2025-02-23";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "hedyhli";
       repo = "outline.nvim";
-      rev = "ae473fb51b7b6086de0876328c81a63f9c3ecfef";
-      sha256 = "12dayhk8m3d34xip6v8hcmb65jvnp5yp2967mk2693i1kakxc8sy";
+      rev = "321f89ef79f168a78685f70d70c52d0e7b563abb";
+      sha256 = "1rg907hqdgz3h87ba262jqhph3m72g5r40jy9ngnjxmk0d45bcvx";
     };
     meta.homepage = "https://github.com/hedyhli/outline.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   papercolor-theme-slim = buildVimPlugin {
     pname = "papercolor-theme-slim";
-    version = "2025-04-14";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "pappasam";
       repo = "papercolor-theme-slim";
-      rev = "244f209dc93a42534d9712271a37b89f58915525";
-      sha256 = "1s7mb5p9nna8v5zfs1swycl25sym4rsdzygzlv6h1z2p932s4r8n";
+      rev = "a94f57fadfac6f213e165ffdc9b1bd4a482b73d2";
+      sha256 = "0g9419wq38j4g1461690chf4y8k4ks3r0dhyq24b1n09yzpjznl6";
     };
     meta.homepage = "https://github.com/pappasam/papercolor-theme-slim/";
     meta.hydraPlatforms = [ ];
···
 
   parrot-nvim = buildVimPlugin {
     pname = "parrot.nvim";
-    version = "2025-04-10";
+    version = "2025-04-14";
     src = fetchFromGitHub {
       owner = "frankroeder";
       repo = "parrot.nvim";
-      rev = "8213c2b8a494fafb64e6aa24563c050ea27d9110";
-      sha256 = "0a399jx267wbxndrfnir6g2kqmgk52jpy20iwffj81w01l8dy43v";
+      rev = "01a6e1f1297a5434dacbcd1e59e063d93b006c9d";
+      sha256 = "1lz7la6vgk280wnldgkf09ckir3ypyjjdj8dby062hyjxd3phjiy";
     };
     meta.homepage = "https://github.com/frankroeder/parrot.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   pum-vim = buildVimPlugin {
     pname = "pum.vim";
-    version = "2025-04-07";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "Shougo";
       repo = "pum.vim";
-      rev = "4bbb2cbd094f9aa70f05ee3398ef727f13bce8af";
-      sha256 = "16axpvf0s7s700y4jg5wffsn36zjvfpq5vnnb2ns5rddh2p6jd8f";
+      rev = "bde317cfafafefb47920fb4ed4bcd4f3829fe827";
+      sha256 = "14a6zpysx3pm7a12r1x4hkf0cd3ycjcj2c8ic8iz358q4c1dcjw2";
     };
     meta.homepage = "https://github.com/Shougo/pum.vim/";
     meta.hydraPlatforms = [ ];
···
 
   render-markdown-nvim = buildVimPlugin {
     pname = "render-markdown.nvim";
-    version = "2025-04-12";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "MeanderingProgrammer";
       repo = "render-markdown.nvim";
-      rev = "8bb0d4725cc4909a603158d44ff28b6158ad9278";
-      sha256 = "18yqhy2y36rydyqs9z3s1h6rghd02bd9kb3rkxs88spm18wvq41z";
+      rev = "dfc1299d9f32b53b34b7ac6c3a7553b5fd29977f";
+      sha256 = "1r636cyjflhpybjwfi01blbwkrxwi4lvykffrjclwfaf4l4gwddd";
     };
     meta.homepage = "https://github.com/MeanderingProgrammer/render-markdown.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   roslyn-nvim = buildVimPlugin {
     pname = "roslyn.nvim";
-    version = "2025-04-12";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "seblyng";
       repo = "roslyn.nvim";
-      rev = "f64609e4ab21a4cc28af2f526974c961d6adacca";
-      sha256 = "1b8k5i4rw4qysvvvygdmxsad8y4vmyyys5vwl76cyh6575vc71n1";
+      rev = "d06aa2f6c5990dd195eb12e68bc5a96b6fd23bff";
+      sha256 = "10s2mr9xgh4ldjv3fc9sacd4k9k0lniy1fydak1gj9609v2kmrjr";
     };
     meta.homepage = "https://github.com/seblyng/roslyn.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   sideways-vim = buildVimPlugin {
     pname = "sideways.vim";
-    version = "2025-02-24";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "AndrewRadev";
       repo = "sideways.vim";
-      rev = "1dc47d2e0ba04da0f5e654f6b3bd65ce9ca8ce9f";
-      sha256 = "13vykz2j2bimgkx08n0awrpjj039k9ggjjgkar9m3sq2hwkm5j3f";
+      rev = "3b353b19972a1138261d939055aff4844b9c472f";
+      sha256 = "07jsyq5qa3psv314mvy0a4grbpjp936iqsf7ac22v3rylcvp1dmx";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/AndrewRadev/sideways.vim/";
···
 
   smart-splits-nvim = buildVimPlugin {
     pname = "smart-splits.nvim";
-    version = "2025-04-11";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "mrjones2014";
       repo = "smart-splits.nvim";
-      rev = "d3011454da78dd72883e131d4b1e7239a29d086e";
-      sha256 = "161pj2aj7kc1dzyglh2dxcid1sc0fh3gwmkiak97wc6g9gja2sd7";
+      rev = "26db22d9b09b7c82e1ff03affd64da3f5441febd";
+      sha256 = "1mpzwrkm2k7cwsw6jbdjh4pydy3afxjrra55bwi7wsynw3x7k35x";
     };
     meta.homepage = "https://github.com/mrjones2014/smart-splits.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   smear-cursor-nvim = buildVimPlugin {
     pname = "smear-cursor.nvim";
-    version = "2025-04-14";
+    version = "2025-04-19";
     src = fetchFromGitHub {
       owner = "sphamba";
       repo = "smear-cursor.nvim";
-      rev = "3879bc2eb4a2a07a8637256fe33cc4484a23a813";
-      sha256 = "09v3p135gh1czz8fy85bi0nrj1shgz51r690nz589v20xr52vipr";
+      rev = "a20e2682b551c610bdd1becbf95f6f3b8a896f9a";
+      sha256 = "11617sjsy35x51cmlf4sl5fzm4azbzw6fwkv23mwwrpra0j5qj5x";
     };
     meta.homepage = "https://github.com/sphamba/smear-cursor.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   sonokai = buildVimPlugin {
     pname = "sonokai";
-    version = "2025-02-24";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "sainnhe";
       repo = "sonokai";
-      rev = "9679341d4141ed81376f2bdf5e69b78dc348d212";
-      sha256 = "1jbkfcs3ylsv2xsldjalp9agm4w7c5gda5kaawlrxcfngrh0pvnk";
+      rev = "f59c796780655c3b9da442d310ad2f2d735f2e56";
+      sha256 = "0sxf6z3yzg4hggad172ljy6vxpnfll9q84pqa7n40m26g2alg29x";
     };
     meta.homepage = "https://github.com/sainnhe/sonokai/";
     meta.hydraPlatforms = [ ];
···
 
   statuscol-nvim = buildVimPlugin {
     pname = "statuscol.nvim";
-    version = "2025-03-03";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "luukvbaal";
       repo = "statuscol.nvim";
-      rev = "c399884e8f64019ec9bb581251f9710915b7f996";
-      sha256 = "0ia3hw4jvh3mlsj372ncp7hj27mw98h9jghvw8q9vk37bghy5455";
+      rev = "a2580e009a3b4c51b5978768d907dafae2c919ac";
+      sha256 = "0k3wj5mzv38wrmq17pd9xpdcc8p3l1bwx078931ylrga5j1ld3vx";
     };
     meta.homepage = "https://github.com/luukvbaal/statuscol.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   switch-vim = buildVimPlugin {
     pname = "switch.vim";
-    version = "2025-02-13";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "AndrewRadev";
       repo = "switch.vim";
-      rev = "b6bab56113312ebaa53038461c1a61bcb1e4a9d9";
-      sha256 = "1n5nlyda1hyvid236i2p74ddf74jwdijsy77j8abwrb4hpsbzblb";
+      rev = "f4b831b86e1e65af8c4f8be6434e15bef98d111e";
+      sha256 = "1ygv1wj9034r6g2yr9ibb10hnm8z0f1dkf8a3rk5mc59803f3mvs";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/AndrewRadev/switch.vim/";
···
 
   tiny-inline-diagnostic-nvim = buildVimPlugin {
     pname = "tiny-inline-diagnostic.nvim";
-    version = "2025-04-10";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "rachartier";
       repo = "tiny-inline-diagnostic.nvim";
-      rev = "842983e91e0b8825f1084b8323c7806c8bf64c74";
-      sha256 = "01q056nmms882x9526qdmr4nqgpyd1247bsb84gzzbclxhg48m1m";
+      rev = "cd401038de4cbae37651cfe02510294ccf5cdc98";
+      sha256 = "1ma2zc75v2ryda4r3k20w4kiz5fq2cw85khkvfiqwqv9jlfsz3zn";
     };
     meta.homepage = "https://github.com/rachartier/tiny-inline-diagnostic.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   treewalker-nvim = buildVimPlugin {
     pname = "treewalker.nvim";
-    version = "2025-04-05";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "aaronik";
       repo = "treewalker.nvim";
-      rev = "7d993149867ea05898626bf19df8b7d020de10ef";
-      sha256 = "1c0dv8g33hir02d6s46pw9fxfyyrqrhvj3in1w2fjpxcqnw5xs3n";
+      rev = "34bf0a6044e0b5e3d93b7012ae7bdf457de91ba1";
+      sha256 = "0rixswfrv4xlwalvi3kqhcdi3l14kml6mds32pp0gvjcig9x6myk";
     };
     meta.homepage = "https://github.com/aaronik/treewalker.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   typescript-tools-nvim = buildVimPlugin {
     pname = "typescript-tools.nvim";
-    version = "2025-04-07";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "pmizio";
       repo = "typescript-tools.nvim";
-      rev = "a4109c70e7d6a3a86f971cefea04ab6720582ba9";
-      sha256 = "1qcwp61sawm69ckah2j3sx2bagdl1m93rxbgzzh212z9fb2gcx3s";
+      rev = "885f4cc150f996f5bff5804874f92ff3051c883d";
+      sha256 = "0b1mgz21h8hdrnczb6pfh3wizbp00y9cvi67hh04019xsygykhix";
     };
     meta.homepage = "https://github.com/pmizio/typescript-tools.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   typst-preview-nvim = buildVimPlugin {
     pname = "typst-preview.nvim";
-    version = "2025-04-12";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "chomosuke";
       repo = "typst-preview.nvim";
-      rev = "2503b188cd2a17ce44fdd21a944a93335e935215";
-      sha256 = "0l981pjiz2ycn6rw1xwvmhdjpml7nrrlymwfyc942inw173k1jsg";
+      rev = "dea4525d5420b7c32eebda7de15a6beb9d6574fa";
+      sha256 = "0y658l2ibq0x4cwa4rl3lab7aw4ba68xcrdnxp81p2rsk0d60qq4";
     };
     meta.homepage = "https://github.com/chomosuke/typst-preview.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   unison = buildVimPlugin {
     pname = "unison";
-    version = "2025-04-09";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "unisonweb";
       repo = "unison";
-      rev = "6d0178a069d195d0a9f987476731e16a1c7fae06";
-      sha256 = "0a2r2kbyar38hppplmam9lhs74yfrg2iq39yskyij7dzsq3g0xdw";
+      rev = "821869214dbb39d27d5e2a59212683e3e3549d4d";
+      sha256 = "1is8f1i4dna0qiq13gj5ag4v9r2rgrispl6mvsa95bl0x795s6w3";
     };
     meta.homepage = "https://github.com/unisonweb/unison/";
     meta.hydraPlatforms = [ ];
···
 
   vifm-vim = buildVimPlugin {
     pname = "vifm.vim";
-    version = "2025-04-09";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "vifm";
       repo = "vifm.vim";
-      rev = "f188b2e18396ef82091930b58fafecf18b76d7a5";
-      sha256 = "004q5lpb1zv2mnib0473gsyhnnpn5hvmjads2yiiz9vlw2nah9kx";
+      rev = "b8fb54d5a1e3a19ed25387852e720c558fcfe436";
+      sha256 = "1r6lzxvd6niwdwvm2vcvghxiigd0hksfgq1nj4594ygwcdpnq4p5";
     };
     meta.homepage = "https://github.com/vifm/vifm.vim/";
     meta.hydraPlatforms = [ ];
···
 
   vim-dadbod-ui = buildVimPlugin {
     pname = "vim-dadbod-ui";
-    version = "2025-03-26";
+    version = "2025-04-14";
     src = fetchFromGitHub {
       owner = "kristijanhusak";
       repo = "vim-dadbod-ui";
-      rev = "685e75b34ee0e12f92ec4507ea8bb7f1aaa936e5";
-      sha256 = "1ir8m3nks2aqh0jkmkyx46qprg7xm0bva72r83hwai79j1q6fk7j";
+      rev = "460432301a5cb280ea265ddfa15c9f3dcd1d26b7";
+      sha256 = "0adpm2sv0lwcfgn90lka3wj8slzbx0bl3lp201syrc8w6w7jgljr";
     };
     meta.homepage = "https://github.com/kristijanhusak/vim-dadbod-ui/";
     meta.hydraPlatforms = [ ];
···
 
   vim-go = buildVimPlugin {
     pname = "vim-go";
-    version = "2025-03-10";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "fatih";
       repo = "vim-go";
-      rev = "1d641b739624199ab9ab745d220f36fe7b655d65";
-      sha256 = "02qfql3c6njqkq7pbzrqknca638f3fczkx651v3wwl94339ln6ky";
+      rev = "59e208d5212b86c8afd69d8590f181594f859ddb";
+      sha256 = "09n71iy4wfqvrdfzvvc4za0alc5fsbds7xd4ln6zip17z89hkym7";
     };
     meta.homepage = "https://github.com/fatih/vim-go/";
     meta.hydraPlatforms = [ ];
···
 
   vim-horizon = buildVimPlugin {
     pname = "vim-horizon";
-    version = "2023-03-17";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "ntk148v";
       repo = "vim-horizon";
-      rev = "3864f6281b0b852712d8e9ef86edde512f94c1d2";
-      sha256 = "152v4x7sj3nidj0710ick0p7xh020cjvhd8bjd28vfqd8xlv2nqw";
+      rev = "32baaaca1337a0df287216b0775404fe913eaecd";
+      sha256 = "0gaj44w0iixri82r4999pqd46mlixrvsq326696jb5mv2aczlw7b";
     };
     meta.homepage = "https://github.com/ntk148v/vim-horizon/";
     meta.hydraPlatforms = [ ];
···
 
   vim-illuminate = buildVimPlugin {
     pname = "vim-illuminate";
-    version = "2025-04-11";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "RRethy";
       repo = "vim-illuminate";
-      rev = "08aa184f1bd508f6a59371b52cba26be07bc016d";
-      sha256 = "0sqs4q2qk9hfkh5vn08y664568pl15b88yyvb9za0f5k7v3z1bcw";
+      rev = "1fa4b23409e22a03823648e344c77f260e2572cb";
+      sha256 = "1z27z6mpj4jazmifyz5scrniqr7sgh9hbkqx4g27yk0dnn9cm9ff";
     };
     meta.homepage = "https://github.com/RRethy/vim-illuminate/";
     meta.hydraPlatforms = [ ];
···
 
   vim-pandoc-syntax = buildVimPlugin {
     pname = "vim-pandoc-syntax";
-    version = "2025-03-15";
+    version = "2025-04-18";
     src = fetchFromGitHub {
       owner = "vim-pandoc";
       repo = "vim-pandoc-syntax";
-      rev = "05ef7f44ebaea37159db8d365058c0a9e2ef14b5";
-      sha256 = "0w48hmcs0dfpc28v9bxslxgvizppkcvw0zpj6sxha747bbi715fc";
+      rev = "ea3fc415784bdcbae7f0093b80070ca4ff9e44c8";
+      sha256 = "0mk33skbybrs4mwrwbsxkj9vcjik7bbrhk0lncxd9pvswnxrw053";
     };
     meta.homepage = "https://github.com/vim-pandoc/vim-pandoc-syntax/";
     meta.hydraPlatforms = [ ];
···
 
   vim-slime = buildVimPlugin {
     pname = "vim-slime";
-    version = "2025-02-03";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "jpalardy";
       repo = "vim-slime";
-      rev = "9bc2e13f8441b09fd7352a11629a4da0ea4cb058";
-      sha256 = "0j4anbhpyyfnb846n7yhx2smr6q7ik11272zyfh7jwdr699c2dcj";
+      rev = "869260840bd05c92408c6867e11d7288e3b24d9b";
+      sha256 = "0djj139x1pqx4y72mz8hddamwx5ggqyqqcbx309l6mhjiprf0iy5";
     };
     meta.homepage = "https://github.com/jpalardy/vim-slime/";
     meta.hydraPlatforms = [ ];
···
 
   vim-spirv = buildVimPlugin {
     pname = "vim-spirv";
-    version = "2025-04-10";
+    version = "2025-04-17";
     src = fetchFromGitHub {
       owner = "kbenzie";
       repo = "vim-spirv";
-      rev = "f48d169fd6b0ab178807f01e73e9937f1377a77c";
-      sha256 = "0jkkl3cqib5az534dyzkfrkwys5la9qd8bcrv1j2hcgbcfwf5zw4";
+      rev = "0193f11a7da93e8d14357b32413900009c31a90c";
+      sha256 = "11z3xqp91p2l5kzmkfyy9v0xky97h60cgcgr1r3ix584jxli55il";
     };
     meta.homepage = "https://github.com/kbenzie/vim-spirv/";
     meta.hydraPlatforms = [ ];
···
 
   vimtex = buildVimPlugin {
     pname = "vimtex";
-    version = "2025-04-13";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "lervag";
       repo = "vimtex";
-      rev = "237671ff5852e30f1ad47a572d55a9c2e2dbe91d";
-      sha256 = "0bq2nhf44qbndjbs3hj75s6iigv9g08qz45p8260rvvjq4jln52x";
+      rev = "cfd4e528b0b44804b51a2929ddcde0b99ebae52f";
+      sha256 = "1a7pifx5i38pakhf946xh1sakc4vslak62hqyx37biyspjvxbym7";
     };
     meta.homepage = "https://github.com/lervag/vimtex/";
     meta.hydraPlatforms = [ ];
···
 
   visual-whitespace-nvim = buildVimPlugin {
     pname = "visual-whitespace.nvim";
-    version = "2025-04-14";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "mcauley-penney";
       repo = "visual-whitespace.nvim";
-      rev = "b3a1383c152cf8fbee6c29ac0f48fdb31f16f550";
-      sha256 = "0367q0cilcdnx963xs81lim8yf84y7lpka986hvbf84qip83gh1g";
+      rev = "8efff74c6811d1e858bbea49be6f21828df96458";
+      sha256 = "0rglcg0m45k7js26i3qyxzfcw40sg2rcxk37lhvx5qlah7sdk88b";
     };
     meta.homepage = "https://github.com/mcauley-penney/visual-whitespace.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   vscode-nvim = buildVimPlugin {
     pname = "vscode.nvim";
-    version = "2025-03-26";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "Mofiqul";
       repo = "vscode.nvim";
-      rev = "49d6014ba151fc6cc585b8d5f057ca7839077bf8";
-      sha256 = "1ik0jz4d39jsi117hvcksvzx2b1k3aiqc1x4rgjfd43zg400mi58";
+      rev = "5769f298af4abf371528b25623fecb1e069c858c";
+      sha256 = "1l9jm1yjfq73bsb1izs26ssd714rc8hshkks4yf52jva2i92p15h";
     };
     meta.homepage = "https://github.com/Mofiqul/vscode.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   yazi-nvim = buildVimPlugin {
     pname = "yazi.nvim";
-    version = "2025-04-12";
+    version = "2025-04-20";
     src = fetchFromGitHub {
       owner = "mikavilpas";
       repo = "yazi.nvim";
-      rev = "8418e7028f91feacffcf75236fd4e93a5a3fe911";
-      sha256 = "1jrwpg3pp50rybzb02np39zpcmibgvv56xl09xpxrhldmmb5p6bp";
+      rev = "50446f185d8b97b225d47852813f0e415cd70689";
+      sha256 = "0qidjs15lk01j0kmhwv4p2vyfj5dswdf5f9qmzjxh4ha5xs9gmg4";
     };
     meta.homepage = "https://github.com/mikavilpas/yazi.nvim/";
     meta.hydraPlatforms = [ ];
···
 
   zenbones-nvim = buildVimPlugin {
     pname = "zenbones.nvim";
-    version = "2025-03-04";
+    version = "2025-04-16";
     src = fetchFromGitHub {
       owner = "zenbones-theme";
       repo = "zenbones.nvim";
-      rev = "dbd485fa5d5230d175e024374d41dab5ad71b119";
-      sha256 = "102375anp0b4iygnxcrx173r5cll3x1gwhfm4qnl3xq26691xy9p";
+      rev = "0c14c7d00016953c41f22c6eb885ade87010bb69";
+      sha256 = "1dv5d2bmqxdm08hzwkh9hal5p30m9hr0z3jb4jyaqxf6nqwjl4pf";
     };
     meta.homepage = "https://github.com/zenbones-theme/zenbones.nvim/";
     meta.hydraPlatforms = [ ];

pkgs/applications/editors/vim/plugins/non-generated/cmp-async-path/default.nix

···
 }:
 vimUtils.buildVimPlugin {
   pname = "cmp-async-path";
-  version = "0-unstable-2024-10-21";
+  version = "0-unstable-2025-04-13";
 
   src = fetchFromGitea {
     domain = "codeberg.org";
     owner = "FelipeLema";
     repo = "cmp-async-path";
-    rev = "d6d1ffa2075039632a2d71e8fa139818e15ac757";
-    hash = "sha256-MZFpNPtSDMZNkfoz+3ZcDxLb8PvDtm9nb1dE0CbYIPQ=";
+    rev = "0ed1492f59e730c366d261a5ad822fa37e44c325";
+    hash = "sha256-J1Iw7yNfvWq7Jul25Eyx4qk9lSiLpZt4TRvTYi1DXtk=";
   };
 
   checkInputs = [ vimPlugins.nvim-cmp ];

pkgs/applications/editors/vim/plugins/non-generated/sonarlint-nvim/default.nix

···
+{
+  lib,
+  vimUtils,
+  fetchFromGitLab,
+  nix-update-script,
+}:
+vimUtils.buildVimPlugin {
+  pname = "sonarlint.nvim";
+  version = "0-unstable-2025-04-18";
+
+  src = fetchFromGitLab {
+    owner = "schrieveslaach";
+    repo = "sonarlint.nvim";
+    rev = "0b78f1db800f9ba76f81de773ba09ce2222bdcc2";
+    hash = "sha256-EUwuIFFe4tmw8u6RqEvOLL0Yi8J5cLBQx7ICxnmkT4k=";
+  };
+
+  passthru.updateScript = nix-update-script { };
+
+  meta = {
+    homepage = "https://gitlab.com/schrieveslaach/sonarlint.nvim";
+    description = "Extensions for the built-in Language Server Protocol support in Neovim for sonarlint-language-server";
+    license = lib.licenses.gpl3;
+    maintainers = [ lib.maintainers.sinics ];
+  };
+}

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

···
       '';
   };
 
+  claude-code-nvim = super.claude-code-nvim.overrideAttrs {
+    dependencies = with self; [
+      plenary-nvim
+    ];
+  };
+
   clighter8 = super.clighter8.overrideAttrs {
     preFixup = ''
       sed "/^let g:clighter8_libclang_path/s|')$|${lib.getLib llvmPackages.clang.cc}/lib/libclang.so')|" \
···
       "nvchad.cheatsheet.grid"
       "nvchad.cheatsheet.simple"
       "nvchad.blink.config"
+      # Circular dependency with base46
+      "nvchad.utils"
     ];
   };
 

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

···
 https://github.com/projekt0n/circles.nvim/,,
 https://github.com/zootedb0t/citruszest.nvim/,,
 https://github.com/xavierd/clang_complete/,,
+https://github.com/greggh/claude-code.nvim/,HEAD,
 https://github.com/rhysd/clever-f.vim/,,
 https://github.com/bbchung/clighter8/,,
 https://github.com/ekickx/clipboard-image.nvim/,,

pkgs/applications/editors/zee/default.nix pkgs/by-name/ze/zee/package.nix

···
   openssl,
 }:
 
-rustPlatform.buildRustPackage rec {
+rustPlatform.buildRustPackage (finalAttrs: {
   pname = "zee";
   version = "0.3.2";
 
   src = fetchFromGitHub {
     owner = "zee-editor";
-    repo = pname;
-    rev = "v${version}";
-    sha256 = "sha256-/9SogKOaXdFDB+e0//lrenTTbfmXqNFGr23L+6Pnm8w=";
+    repo = "zee";
+    tag = "v${finalAttrs.version}";
+    hash = "sha256-/9SogKOaXdFDB+e0//lrenTTbfmXqNFGr23L+6Pnm8w=";
   };
+
+  cargoHash = "sha256-auwbpavF/WZQIE/htYXJ4di6xoRtXkBBkP/Bj4lFp6U=";
 
   cargoPatches = [
     # fixed upstream but unreleased
···
   # disable downloading and building the tree-sitter grammars at build time
   # grammars can be configured in a config file and installed with `zee --build`
   # see https://github.com/zee-editor/zee#syntax-highlighting
-  ZEE_DISABLE_GRAMMAR_BUILD = 1;
+  env.ZEE_DISABLE_GRAMMAR_BUILD = 1;
 
-  useFetchCargoVendor = true;
-  cargoHash = "sha256-auwbpavF/WZQIE/htYXJ4di6xoRtXkBBkP/Bj4lFp6U=";
-
-  meta = with lib; {
+  meta = {
     description = "Modern text editor for the terminal written in Rust";
     homepage = "https://github.com/zee-editor/zee";
-    license = licenses.mit;
-    maintainers = with maintainers; [ booklearner ];
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ booklearner ];
     mainProgram = "zee";
   };
-}
+})

pkgs/applications/misc/electrum/ltc-aiorpcX-version-bump.patch

···
  protobuf>=3.12
  qdarkstyle>=2.7
 -aiorpcx>=0.22.0,<0.23
-+aiorpcx>=0.22.0,<0.24
++aiorpcx>=0.22.0
  aiohttp>=3.3.0,<4.0.0
  aiohttp_socks>=0.3
  certifi
···
 index a1b30f29e..cb22f8724 100755
 --- a/run_electrum
 +++ b/run_electrum
-@@ -67,8 +67,8 @@ def check_imports():
+@@ -67,8 +67,6 @@ def check_imports():
          import aiorpcx
      except ImportError as e:
          sys.exit(f"Error: {str(e)}. Try 'sudo python3 -m pip install <module-name>'")
 -    if not ((0, 22, 0) <= aiorpcx._version < (0, 23)):
 -        raise RuntimeError(f'aiorpcX version {aiorpcx._version} does not match required: 0.22.0<=ver<0.23')
-+    if not ((0, 22, 0) <= aiorpcx._version < (0, 24)):
-+        raise RuntimeError(f'aiorpcX version {aiorpcx._version} does not match required: 0.22.0<=ver<0.24')
      # the following imports are for pyinstaller
      from google.protobuf import descriptor
      from google.protobuf import message

pkgs/applications/office/scribus/default.nix

···
 stdenv.mkDerivation (finalAttrs: {
   pname = "scribus";
 
-  version = "1.6.3";
+  version = "1.6.4";
 
   src = fetchurl {
     url = "mirror://sourceforge/scribus/scribus-devel/scribus-${finalAttrs.version}.tar.xz";
-    hash = "sha256-CuWM7UEBAegmVeO0wgoHDPF2cUWtojPc73wguLpr1Ic=";
+    hash = "sha256-UzvnrwOs+qc27F96P8JWKr0gD+9coqfN7gK19E1hgp4=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/am/amnezia-vpn/package.nix

···
   lib,
   stdenv,
   fetchFromGitHub,
+  fetchpatch,
   cmake,
   pkg-config,
   kdePackages,
···
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "amnezia-vpn";
-  version = "4.8.5.0";
+  version = "4.8.6.0";
 
   src = fetchFromGitHub {
     owner = "amnezia-vpn";
     repo = "amnezia-client";
     tag = finalAttrs.version;
-    hash = "sha256-k0BroQYrmJzM0+rSZMf20wHba5NbOK/xm5lbUFBNEHI=";
+    hash = "sha256-WQbay3dtGNPPpcK1O7bfs/HKO4ytfmQo60firU/9o28=";
     fetchSubmodules = true;
   };
 
+  # Temporary patch header file to fix build with QT 6.9
+  patches = [
+    (fetchpatch {
+      name = "add-missing-include.patch";
+      url = "https://github.com/amnezia-vpn/amnezia-client/commit/c44ce0d77cc3acdf1de48a12459a1a821d404a1c.patch";
+      hash = "sha256-Q6UMD8PlKAcI6zNolT5+cULECnxNrYrD7cifvNg1ZrY=";
+    })
+  ];
+
   postPatch =
     ''
       substituteInPlace client/platforms/linux/daemon/wireguardutilslinux.cpp \
···
     install -m444 ../deploy/data/linux/AmneziaVPN.service $out/lib/systemd/system/
 
     runHook postInstall
-  '';
-
-  postFixup = ''
-    # Temporary unwrap non-binary executable until qt6.wrapQtAppsHook is fixed
-    mv $out/libexec/.update-resolv-conf.sh-wrapped $out/libexec/update-resolv-conf.sh
   '';
 
   passthru = {

pkgs/by-name/as/asdbctl/package.nix

···
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  rustPlatform,
+  pkg-config,
+  udev,
+}:
+
+rustPlatform.buildRustPackage (finalAttrs: {
+  pname = "asdbctl";
+  version = "1.0.0";
+
+  src = fetchFromGitHub {
+    owner = "juliuszint";
+    repo = "asdbctl";
+    tag = "v${finalAttrs.version}";
+    hash = "sha256-S5m1iQlchGKc0PODQNDHpNzaNXRepmk5zfK5aXdiMiM=";
+  };
+
+  useFetchCargoVendor = true;
+  cargoHash = "sha256-OPmnGh6xN6XeREeIgyYB2aeHUpdQ5hFS5MivcTeY29E=";
+
+  nativeBuildInputs = [
+    pkg-config
+  ];
+
+  buildInputs = lib.optionals stdenv.hostPlatform.isLinux [
+    udev
+  ];
+
+  postInstall = ''
+    install -Dm444 \
+      rules.d/20-asd-backlight.rules \
+      $out/lib/udev/rules.d/20-asd-backlight.rules
+  '';
+
+  meta = {
+    description = "Apple Studio Display brightness controll";
+    mainProgram = "asdbctl";
+    homepage = "https://github.com/juliuszint/asdbctl";
+    changelog = "https://github.com/juliuszint/asdbctl/releases/tag/${finalAttrs.version}";
+    license = lib.licenses.mit;
+    maintainers = [
+      lib.maintainers.danieldk
+    ];
+  };
+})

pkgs/by-name/aw/awsebcli/package.nix

···
 
 python.pkgs.buildPythonApplication rec {
   pname = "awsebcli";
-  version = "3.21";
+  version = "3.22";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "aws";
     repo = "aws-elastic-beanstalk-cli";
     tag = version;
-    hash = "sha256-VU8bXvS4m4eIamjlgGmHE2qwDXWAXvWTa0QHomXR5ZE=";
+    hash = "sha256-I85VteUjPPWRixXC1mEiMmk46mYPzQJoaYcHV8ztMU4=";
   };
 
   pythonRelaxDeps = [
···
     "termcolor"
     "urllib3"
   ];
-
-  postPatch = ''
-    # https://github.com/aws/aws-elastic-beanstalk-cli/pull/469
-    substituteInPlace setup.py \
-      --replace-fail "scripts=['bin/eb']," ""
-  '';
 
   dependencies = with python.pkgs; [
     blessed
···
     "test_generate_and_upload_keypair__exit_code_1"
     "test_generate_and_upload_keypair__exit_code_is_other_than_1_and_0"
     "test_generate_and_upload_keypair__ssh_keygen_not_present"
+
+    # AssertionError: Expected 'echo' to be called once. Called 2 times
+    "test_multiple_modules__one_or_more_of_the_specified_modules_lacks_an_env_yaml"
   ];
 
   meta = with lib; {

pkgs/by-name/bl/blackfire/php-probe.nix

···
         "8.1" = "sha256-oRd6PbBLOboH9EVRfZl5u71ZoVMFO4K/uftxlL/vm18=";
         "8.2" = "sha256-95qBidNHIGLGCb3QbUIzBMHsRi2GTPhwAjJg+JTteDk=";
         "8.3" = "sha256-8TO28o4YYFK1r2tInjXKenki/izHzZL0Dblaippekl8=";
+        "8.4" = "sha256-Dg+Q0W6Rh2L4J7hmxLxuM3l/dKYHT499Mix4Zpu2Vno=";
       };
     };
     "i686-linux" = {
···
         "8.1" = "sha256-mXJ1hO8NcODG7Wj3lQ+5lkSjcbkKLN5OOzcobigScKI=";
         "8.2" = "sha256-P5fQTVfE/DvLD4E3kUPE+eeOM9YVNNixgWVRq3Ca5M4=";
         "8.3" = "sha256-rMUv2EUlepBahMaEvs60i7RFTmaBe4P4qB1hcARqP9Y=";
+        "8.4" = "sha256-g7v7oN7wfrER9VPk6bGhr+l6GMh2iYHUihcXF9T4GOc=";
       };
     };
     "aarch64-linux" = {
···
         "8.1" = "sha256-Tj7LHXS4m9hF9gY/9vfOQPJVP+vHM1h8XdBY9vyRhFo=";
         "8.2" = "sha256-6kfotMptfVLPL414mr6LeJZ3ODnjepYQYnKvg4fHIAg=";
         "8.3" = "sha256-M/GTdinOi3Em7GJOm1iUKkuDNg8La3iQpG+wGHp0ycE=";
+        "8.4" = "sha256-/wwgP76liAb6//uvDLGD5l+skh4P22Q8KdZN7nlEbXI=";
       };
     };
     "aarch64-darwin" = {

pkgs/by-name/ca/cargo-mobile2/package.nix

···
 
 let
   pname = "cargo-mobile2";
-  version = "0.17.6";
+  version = "0.20.0";
 in
 rustPlatform.buildRustPackage {
   inherit pname version;
···
     owner = "tauri-apps";
     repo = pname;
     rev = "cargo-mobile2-v${version}";
-    hash = "sha256-kIy5Ic7Zk6twcEbZN/wRLwMK0XeMF0lNkFDIc2vO944=";
+    hash = "sha256-7/ol4Jb/2s007LeSMo6YYDT5vipsZZF6O4hfJ7ylHGg=";
   };
 
   # Manually specify the sourceRoot since this crate depends on other crates in the workspace. Relevant info at
···
   # sourceRoot = "${src.name}/tooling/cli";
 
   useFetchCargoVendor = true;
-  cargoHash = "sha256-An9EuNv+6ttNKp50RutzxtHl/RS5gn9sUNlWtipAujk=";
+  cargoHash = "sha256-zSUT2zClpSlBDu6vgMv4TZn9Jp0Ych6EQKo1AwkSMXU=";
 
   preBuild = ''
     mkdir -p $out/share/

pkgs/by-name/cl/clean-css-cli/package.nix

···
   buildNpmPackage,
   fetchFromGitHub,
 }:
+buildNpmPackage (finalAttrs: {
+  pname = "clean-css-cli";
+  version = "5.6.3";
 
-let
-  version = "5.6.3";
   src = fetchFromGitHub {
     owner = "clean-css";
     repo = "clean-css-cli";
-    rev = "v${version}";
+    tag = "v${finalAttrs.version}";
     hash = "sha256-tsFNcQg55uY2gL5xLLLS6INLlYzbsU6M3hnsYeOFGEw=";
   };
-in
-buildNpmPackage {
-  pname = "clean-css-cli";
-  inherit version src;
 
   npmDepsHash = "sha256-uvI9esVVOE18syHUCJpoiDY+Vh3hJO+GsMOTZSYJaxg=";
 
   dontNpmBuild = true;
+
+  dontCheckForBrokenSymlinks = true;
 
   meta = {
-    changelog = "https://github.com/clean-css/clean-css-cli/blob/${src.rev}/History.md";
     description = "Command-line interface to the clean-css CSS optimization library";
     homepage = "https://github.com/clean-css/clean-css-cli";
+    changelog = "https://github.com/clean-css/clean-css-cli/blob/v${finalAttrs.version}/History.md";
     license = lib.licenses.mit;
     mainProgram = "cleancss";
     maintainers = with lib.maintainers; [ momeemt ];
   };
-}
+})

pkgs/by-name/co/copilot-language-server/package.nix

···
 in
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "copilot-language-server";
-  version = "1.294.0";
+  version = "1.304.0";
 
   src = fetchzip {
     url = "https://github.com/github/copilot-language-server-release/releases/download/${finalAttrs.version}/copilot-language-server-native-${finalAttrs.version}.zip";
-    hash = "sha256-8nB8vlrSy+949HiJRCa9yFqu/GAaluFH1VzE63AUUs8=";
+    hash = "sha256-F0urL3bMlNcxHTrePYsagEx2664C7USYAcnhCCzB/rA=";
     stripRoot = false;
   };
 

pkgs/by-name/cp/cpuid/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "cpuid";
-  version = "20241023";
+  version = "20250419";
 
   src = fetchurl {
     url = "http://etallen.com/cpuid/${pname}-${version}.src.tar.gz";
-    sha256 = "sha256-/HdDWo1dKzVRcTMB6M24PmKjz+3IQTKw7JsbteUkT9w=";
+    sha256 = "sha256-Mcz8A/k92ISKZ5jydPoDeR9cO/uxp2f+IIamnONyess=";
   };
 
   # For pod2man during the build process.

pkgs/by-name/di/discordchatexporter-desktop/package.nix

···
     homepage = "https://github.com/Tyrrrz/DiscordChatExporter";
     license = licenses.gpl3Plus;
     changelog = "https://github.com/Tyrrrz/DiscordChatExporter/blob/${version}/Changelog.md";
-    maintainers = with maintainers; [ kekschen ];
+    maintainers = with maintainers; [ willow ];
     platforms = [ "x86_64-linux" ];
     mainProgram = "discordchatexporter";
   };

pkgs/by-name/el/eliza/package.nix

···
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  nix-update-script,
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "eliza";
+  version = "0-unstable-2025-02-21";
+  src = fetchFromGitHub {
+    owner = "anthay";
+    repo = "ELIZA";
+    rev = "27bcf6e5fb1d32812cc0aab8133fa5e395d41773";
+    hash = "sha256-/i8mckRQWTK1yI/MNaieSuE+dx94DMdrABkqf/bXQbM=";
+  };
+
+  doCheck = true;
+
+  # Unit tests are executed automatically on execution
+  checkPhase = ''
+    runHook preCheck
+    echo Corki is mana | ./eliza
+    runHook postCheck
+  '';
+
+  buildPhase = ''
+    runHook preBuild
+    $CXX -std=c++20 -pedantic -o eliza ./src/eliza.cpp
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+    install -Dm544 ./eliza $out/bin/eliza
+    runHook postInstall
+  '';
+
+  passthru.updateScript = nix-update-script {
+    extraArgs = [
+      "--version=branch=master"
+    ];
+  };
+
+  meta = {
+    description = "C++ simulation of Joseph Weizenbaum’s 1966 ELIZA";
+    longDescription = ''
+      This is an implementation in C++ of ELIZA that attempts to be as close
+      to the original as possible.
+      It was made to closely follow Joseph Weizenbaum’s description of his program
+      given in his January 1966 Communications of the ACM paper, and later changed
+      to follow the ELIZA source code found on 2021 and the SLIP programming
+      function HASH(D,N) found on 2022.
+      It is controlled by a script identical to the one given in the appendix of
+      the 1966 paper.
+    '';
+    license = lib.licenses.cc0;
+    mainProgram = "eliza";
+    homepage = "https://github.com/anthay/ELIZA";
+    maintainers = with lib.maintainers; [ EmanuelM153 ];
+    platforms = lib.platforms.all;
+  };
+})

pkgs/by-name/fi/firezone-gateway/package.nix

···
 }:
 rustPlatform.buildRustPackage rec {
   pname = "firezone-gateway";
-  version = "1.4.5";
+  version = "1.4.6";
   src = fetchFromGitHub {
     owner = "firezone";
     repo = "firezone";
     tag = "gateway-${version}";
-    hash = "sha256-2MDQyMCQIqV1Kbem53jnE8DGUZ6SrZqp2LpGJXvLBgA=";
+    hash = "sha256-ra5ZWPwNhyZEc9pBkcITvQyomgQ22yiWI16dnv1Fm3E=";
   };
 
   useFetchCargoVendor = true;
-  cargoHash = "sha256-Yz9xuH8Eph1pzv0siTpvdSXZLj/AjS5PR06CitK9NdE=";
+  cargoHash = "sha256-5B9nvFanHXZV8p8m2vsRLC5pSzwL2lX+V651oV8joJs=";
   sourceRoot = "${src.name}/rust";
   buildAndTestSubdir = "gateway";
   RUSTFLAGS = "--cfg system_certs";

pkgs/by-name/fi/firezone-headless-client/package.nix

···
 }:
 rustPlatform.buildRustPackage rec {
   pname = "firezone-headless-client";
-  version = "1.4.5";
+  version = "1.4.6";
   src = fetchFromGitHub {
     owner = "firezone";
     repo = "firezone";
     tag = "headless-client-${version}";
-    hash = "sha256-IVbMdRtb6cu4obTFYPAYQXu9sXH7vT7K9j79IXg0KXk=";
+    hash = "sha256-ra5ZWPwNhyZEc9pBkcITvQyomgQ22yiWI16dnv1Fm3E=";
   };
 
   useFetchCargoVendor = true;
-  cargoHash = "sha256-8//Gg45iJw9rfEn08FW+wDbg7Dz2MyKFGf3p2Td7kHA=";
+  cargoHash = "sha256-5B9nvFanHXZV8p8m2vsRLC5pSzwL2lX+V651oV8joJs=";
   sourceRoot = "${src.name}/rust";
   buildAndTestSubdir = "headless-client";
   RUSTFLAGS = "--cfg system_certs";

pkgs/by-name/fi/fish/1d78c8bd4295262a3118f478e6b3a7c7536fa282.patch

···
-From 1d78c8bd4295262a3118f478e6b3a7c7536fa282 Mon Sep 17 00:00:00 2001
-From: Johannes Altmanninger <[e-mail]>
-Date: Wed, 19 Mar 2025 09:39:04 +0100
-Subject: [PATCH] Fix concurrent setlocale() in string escape tests
-
-In our C++ implementation, these tests were run serially.  As pointed out in
-https://github.com/fish-shell/fish-shell/issues/11254#issuecomment-2735623229
-we run them in parallel now, which means that one test could be changing
-the global locale used by another.
-
-In theory this could be fine because all tests are setting setting the
-global locale to the same thing but the existence of a lock suggests that
-setlocale() is not guaranteed to be atomic, so it's possible that another
-thread uses a temporarily-invalid locale.
-
-Fixes #11254
----
- src/tests/string_escape.rs | 14 ++++++++------
- 1 file changed, 8 insertions(+), 6 deletions(-)
-
-diff --git a/src/tests/string_escape.rs b/src/tests/string_escape.rs
-index ba8ee7534ebf..4428d679cd35 100644
---- a/src/tests/string_escape.rs
-+++ b/src/tests/string_escape.rs
-@@ -1,3 +1,5 @@
-+use std::sync::MutexGuard;
-+
- use crate::common::{
-     escape_string, str2wcstring, unescape_string, wcs2string, EscapeFlags, EscapeStringStyle,
-     UnescapeStringStyle, ENCODE_DIRECT_BASE, ENCODE_DIRECT_END,
-@@ -10,21 +12,21 @@ use rand::{Rng, RngCore};
- 
- /// wcs2string is locale-dependent, so ensure we have a multibyte locale
- /// before using it in a test.
--fn setlocale() {
--    let _guard = LOCALE_LOCK.lock().unwrap();
-+fn setlocale() -> MutexGuard<'static, ()> {
-+    let guard = LOCALE_LOCK.lock().unwrap();
- 
-     #[rustfmt::skip]
-     const UTF8_LOCALES: &[&str] = &[
-         "C.UTF-8", "en_US.UTF-8", "en_GB.UTF-8", "de_DE.UTF-8", "C.utf8", "UTF-8",
-     ];
-     if crate::libc::MB_CUR_MAX() > 1 {
--        return;
-+        return guard;
-     }
-     for locale in UTF8_LOCALES {
-         let locale = std::ffi::CString::new(locale.to_owned()).unwrap();
-         unsafe { libc::setlocale(libc::LC_CTYPE, locale.as_ptr()) };
-         if crate::libc::MB_CUR_MAX() > 1 {
--            return;
-+            return guard;
-         }
-     }
-     panic!("No UTF-8 locale found");
-@@ -100,7 +102,7 @@ fn test_escape_var() {
- }
- 
- fn escape_test(escape_style: EscapeStringStyle, unescape_style: UnescapeStringStyle) {
--    setlocale();
-+    let _locale_guard = setlocale();
-     let seed: u128 = 92348567983274852905629743984572;
-     let mut rng = get_seeded_rng(seed);
- 
-@@ -174,7 +176,7 @@ fn str2hex(input: &[u8]) -> String {
- /// string comes back through double conversion.
- #[test]
- fn test_convert() {
--    setlocale();
-+    let _locale_guard = setlocale();
-     let seed = get_rng_seed();
-     let mut rng = get_seeded_rng(seed);
-     let mut origin = Vec::new();

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

···
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "fish";
-  version = "4.0.1";
+  version = "4.0.2";
 
   src = fetchFromGitHub {
     owner = "fish-shell";
     repo = "fish-shell";
     tag = finalAttrs.version;
-    hash = "sha256-Mj4v2ubYr4ufs7aU/1AdY239byiCJHKXam64af/VO3U=";
+    hash = "sha256-UpoZPipXZbzLWCOXzDjfyTDrsKyXGbh3Rkwj5IeWeY4=";
   };
 
   env = {
···
 
   cargoDeps = rustPlatform.fetchCargoVendor {
     inherit (finalAttrs) src patches;
-    hash = "sha256-4kqBrpeneCpF0WohP1ZArKrV3duHAE01XA5+GT9f56w=";
+    hash = "sha256-FkJB33vVVz7Kh23kfmjQDn61X2VkKLG9mUt8f3TrCHg=";
   };
 
   patches = [
···
     # * <https://github.com/LnL7/nix-darwin/issues/122>
     # * <https://github.com/fish-shell/fish-shell/issues/7142>
     ./nix-darwin-path.patch
-
-    # remove 4.0.2
-    # https://github.com/fish-shell/fish-shell/issues/11254
-    ./1d78c8bd4295262a3118f478e6b3a7c7536fa282.patch
   ];
 
   # Fix FHS paths in tests

pkgs/by-name/ga/gaw/package.nix

···
 {
   stdenv,
-  fetchurl,
+  runCommandLocal,
   lib,
+  htmlq,
+  curl,
+  cacert,
   gtk3,
   pkg-config,
 }:
 
 stdenv.mkDerivation rec {
-  pname = "gaw";
-  version = "20220315";
+  pname = "gaw3";
+  version = "20250128";
+
+  # https://www.rvq.fr/php/ndl.php?id=gaw.*
+  # https://www.rvq.fr/php/ndl.php?id=gaw3-20250128.tar.gz
+  src =
+    runCommandLocal "gaw3-${version}.tar.gz"
+      {
+        BASE = "https://www.rvq.fr/php/ndl.php";
+        FNAME = "gaw3-${version}.tar.gz";
+
+        nativeBuildInputs = [
+          htmlq
+          curl
+        ];
+        SSL_CERT_FILE = "${cacert}/etc/ssl/certs/ca-bundle.crt";
+
+        outputHashMode = "recursive";
+        outputHashAlgo = "sha256";
+        outputHash = "sha256-3uO+209+cmu231iabyYmABmgegyxAxswWDWA/v8WSy0=";
+      }
+      ''
+        # fetch download page
+        html_form=$(
+          curl "$BASE?id=$FNAME" |
+            tr '\n' ' ' | tr -s ' ' | # minimize whitespace
+            htmlq tr | # select table rows, one per line
+            grep "<td>$FNAME</td>" | # filter for row of interest
+            head -n1 | # first match, just in case
+            htmlq form --base "$BASE"
+        )
+
+        declare -a curl_args=()
+
+        # hidden fields
+        declare -a input_names=()
+        readarray -td $'\n' input_names < <(
+          htmlq <<<"$html_form" "input[type=hidden]" -a name
+        )
+        for input_name in "''${input_names[@]}"; do
+          input_value=$(
+            htmlq <<<"$html_form" "input[type=hidden][name=''${input_name}]" -a value
+          )
+          echo "$input_name = $input_value"
+          curl_args+=( --form "$input_name=$input_value" )
+        done
+
+        # destination
+        curl_args+=(
+          "https://www.rvq.fr/$( htmlq <<<"$html_form"  form -a action )"
+        )
+
+        # POST and download
+        (set -x
+          curl -X POST "''${curl_args[@]}" $NIX_CURL_FLAGS --output "$FNAME"
+        )
 
-  src = fetchurl {
-    url = "https://download.tuxfamily.org/gaw/download/gaw3-${version}.tar.gz";
-    sha256 = "0j2bqi9444s1mfbr7x9rqp232xf7ab9z7ifsnl305jsklp6qmrbg";
-  };
+        # unpack and strip root dir
+        mkdir unpack/
+        tar xvf "$FNAME" --directory=unpack/
+        [[ "$(printf "%s\n" unpack/* | wc -l)" -eq 1 ]]
+        cp -a unpack/* $out
+      '';
 
   nativeBuildInputs = [ pkg-config ];
 
···
       input from sound cards. Data can be imported to gaw using files,
       direct tcp/ip connection or directly from the sound card.
     '';
-    homepage = "http://gaw.tuxfamily.org";
+    homepage = "https://www.rvq.fr/linux/gaw.php";
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ fbeffa ];
     platforms = platforms.linux;

pkgs/by-name/gi/gitu/package.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "gitu";
-  version = "0.29.0";
+  version = "0.30.3";
 
   src = fetchFromGitHub {
     owner = "altsem";
     repo = "gitu";
     rev = "v${version}";
-    hash = "sha256-c2YVcE+a/9Z6qTLEbcSFE6393SEeudyvdbzCRJfszcc=";
+    hash = "sha256-WXz8H68EpvkUEpdEbdukggbjFXUPA+FRcZTsk48W6TU=";
   };
 
   useFetchCargoVendor = true;
-  cargoHash = "sha256-+tSNUtsDFKqx5W8+cuxyFsG1etm44eYgoYuoUt5tw3E=";
+  cargoHash = "sha256-0+KHO7CGYdifQGbtywuK5xQmS2BuxFX50eMGpo5RRYU=";
 
   nativeBuildInputs = [
     pkg-config

pkgs/by-name/go/golangci-lint-langserver/package.nix

···
 
   subPackages = [ "." ];
 
-  # renable after https://github.com/nametake/golangci-lint-langserver/pull/52
-  doCheck = false;
-
   nativeCheckInputs = [
     golangci-lint
     writableTmpDirAsHomeHook

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

···
 
 rustPlatform.buildRustPackage rec {
   pname = "harper";
-  version = "0.29.0";
+  version = "0.29.1";
 
   src = fetchFromGitHub {
     owner = "Automattic";
     repo = "harper";
     rev = "v${version}";
-    hash = "sha256-wsCUB3UO5czqJPGctb3ZsTtcVXMqBB7/8/uk5ShL8ZA=";
+    hash = "sha256-bar4AdLovV8MBGF/yGHbcw1w3MQ4FFbmJkiDDS2Iq5g=";
   };
 
   buildAndTestSubdir = "harper-ls";
   useFetchCargoVendor = true;
-  cargoHash = "sha256-KrW4I4Tg30/Yg5PuZCEWkrtjNUKMZmzqCmFAnKtj7A4=";
+  cargoHash = "sha256-CJZSBs8EtUstUNDUt3QQhv/f/GriaGzF9fw9IJWDNAk=";
 
   passthru.updateScript = nix-update-script { };
 

pkgs/by-name/hj/hjson-go/package.nix

···
 
 buildGoModule rec {
   pname = "hjson-go";
-  version = "4.4.0";
+  version = "4.5.0";
 
   src = fetchFromGitHub {
     owner = "hjson";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-fonPxk/9ue8LzHTdKpuHJcucQoMl4P6gq+tbjS8Ui7Q=";
+    hash = "sha256-0xFTxnXMJA98+Y6gwO8zCDPQvLecG1qmbGAISCFMaPw=";
   };
 
   vendorHash = null;

pkgs/by-name/hy/hydralauncher/package.nix

···
 }:
 let
   pname = "hydralauncher";
-  version = "3.4.0";
+  version = "3.4.4";
   src = fetchurl {
     url = "https://github.com/hydralauncher/hydra/releases/download/v${version}/hydralauncher-${version}.AppImage";
-    hash = "sha256-d2ZtCAbj7xYkLhsuTPi9/ORb+Nkk5KbGvaDSaawqGcU=";
+    hash = "sha256-7mYwjxfef9uiBI2idLUqQxJ4hiWiPVCdMnw1MaovUEM=";
   };
 
   appimageContents = appimageTools.extractType2 { inherit pname src version; };

pkgs/by-name/kr/krillinai/package.nix

···
 
 buildGoModule (finalAttrs: {
   pname = "krillinai";
-  version = "1.1.0";
+  version = "1.1.3";
 
   src = fetchFromGitHub {
     owner = "krillinai";
     repo = "KrillinAI";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-AAlefejME+XLERcDJDeVgzySVX+KGrCMt7PJyWaxnoM=";
+    hash = "sha256-hEKjqQcHnrxY266EP5uoLMzw6csi2bS5Q+ghGb6TJ4c=";
   };
 
   vendorHash = "sha256-mpvypCZmvVVljftGpcV1aea3s7Xmhr0jLfKZIZ0nkX8=";

pkgs/by-name/le/ledger-live-desktop/package.nix

···
 
 let
   pname = "ledger-live-desktop";
-  version = "2.107.0";
+  version = "2.109.0";
 
   src = fetchurl {
     url = "https://download.live.ledger.com/${pname}-${version}-linux-x86_64.AppImage";
-    hash = "sha256-PtoazbAwwG856M2HoPjN6yuTHlSiIJs5PziDrkLAEZE=";
+    hash = "sha256-wqY5f+A4j+KY99LulL8YS1eACvEsTSfMGV7Be6yOMqM=";
   };
 
   appimageContents = appimageTools.extractType2 {

pkgs/by-name/li/libyang/package.nix

···
     hash = "sha256-5oJV8gr2rwvSdpX5w3gmIw/LTrWtXVnl6oLr/soNTDk=";
   };
 
+  outputs = [
+    "out"
+    "dev"
+  ];
+
   nativeBuildInputs = [
     cmake
     pkg-config
   ];
 
-  buildInputs = [
+  propagatedBuildInputs = [
     pcre2
   ];
 

pkgs/by-name/mo/mosdepth/package.nix

···
   lib,
   buildNimPackage,
   fetchFromGitHub,
-  pcre,
   versionCheckHook,
 }:
 
···
 
   lockFile = ./lock.json;
 
-  buildInputs = [ pcre ];
   nativeBuildInputs = [ versionCheckHook ];
 
   nimFlags = [ ''--passC:"-Wno-incompatible-pointer-types"'' ];

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

···
 
 stdenv.mkDerivation rec {
   pname = "nb";
-  version = "7.16.1";
+  version = "7.17.0";
 
   src = fetchFromGitHub {
     owner = "xwmx";
     repo = "nb";
     rev = version;
-    hash = "sha256-RX3DEjk+/tivTyv0+j3lZAKYgca4Zq9zQ+P1a/RXj2I=";
+    hash = "sha256-gUI7hAZabYPHkSwGtFZxEoi5Hw76fOLYbMZQIvsnSas=";
   };
 
   nativeBuildInputs = [ installShellFiles ];

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

···
 {
+  stdenv,
   lib,
   rustPlatform,
   installShellFiles,
···
   nix-update-script,
   nvd,
   nix-output-monitor,
+  buildPackages,
 }:
 let
-  version = "3.6.0";
   runtimeDeps = [
     nvd
     nix-output-monitor
   ];
 in
-rustPlatform.buildRustPackage {
-  inherit version;
+rustPlatform.buildRustPackage (finalAttrs: {
   pname = "nh";
+  version = "3.6.0";
 
   src = fetchFromGitHub {
-    owner = "viperML";
+    owner = "nix-community";
     repo = "nh";
-    tag = "v${version}";
+    tag = "v${finalAttrs.version}";
     hash = "sha256-k8rz5RF1qi7RXzQYWGbw5pJRNRFIdX85SIYN+IHiVL4=";
   };
 
···
     makeBinaryWrapper
   ];
 
-  preFixup = ''
-    mkdir completions
-    $out/bin/nh completions --shell bash > completions/nh.bash
-    $out/bin/nh completions --shell zsh > completions/nh.zsh
-    $out/bin/nh completions --shell fish > completions/nh.fish
+  preFixup = lib.optionalString (stdenv.hostPlatform.emulatorAvailable buildPackages) (
+    let
+      emulator = stdenv.hostPlatform.emulator buildPackages;
+    in
+    ''
+      mkdir completions
+      ${emulator} $out/bin/nh completions --shell bash > completions/nh.bash
+      ${emulator} $out/bin/nh completions --shell zsh > completions/nh.zsh
+      ${emulator} $out/bin/nh completions --shell fish > completions/nh.fish
 
-    installShellCompletion completions/*
-  '';
+      installShellCompletion completions/*
+    ''
+  );
 
   postFixup = ''
     wrapProgram $out/bin/nh \
···
 
   meta = {
     description = "Yet another nix cli helper";
-    homepage = "https://github.com/viperML/nh";
+    homepage = "https://github.com/nix-community/nh";
     license = lib.licenses.eupl12;
     mainProgram = "nh";
     maintainers = with lib.maintainers; [
···
       viperML
     ];
   };
-}
+})

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

···
   testers,
   paretosecurity,
   nixosTests,
+  pkg-config,
+  gtk3,
+  webkitgtk_4_1,
 }:
 
-buildGoModule rec {
+buildGoModule (finalAttrs: {
+  nativeBuildInputs = [ pkg-config ];
+  buildInputs = [
+    gtk3
+    webkitgtk_4_1
+  ];
   pname = "paretosecurity";
-  version = "0.1.3";
+  version = "0.1.9";
 
   src = fetchFromGitHub {
     owner = "ParetoSecurity";
     repo = "agent";
-    rev = version;
-    hash = "sha256-ovyfHqLCf5U3UR1HfoA+UQhqLZ6IaILcpqptPRQsb60=";
+    rev = finalAttrs.version;
+    hash = "sha256-KJs4xC3EtGG4116UE+oIEwAMcuDWIm9gqgZY+Bv14ac=";
   };
 
-  vendorHash = "sha256-7mKAFkKGpBOjXc3J/sfF3k3pJF53tFybXZgbfJInuSY=";
+  vendorHash = "sha256-3plpvwLe32AsGuVzdM2fSmTPkKwRFmhi651NEIRdOxw=";
   proxyVendor = true;
 
   ldflags = [
     "-s"
-    "-X=github.com/ParetoSecurity/agent/shared.Version=${version}"
-    "-X=github.com/ParetoSecurity/agent/shared.Commit=${src.rev}"
+    "-X=github.com/ParetoSecurity/agent/shared.Version=${finalAttrs.version}"
+    "-X=github.com/ParetoSecurity/agent/shared.Commit=${finalAttrs.src.rev}"
     "-X=github.com/ParetoSecurity/agent/shared.Date=1970-01-01T00:00:00Z"
   ];
 
   postInstall = ''
     # Install global systemd files
-    install -Dm400 ${src}/apt/paretosecurity.socket $out/lib/systemd/system/paretosecurity.socket
-    install -Dm400 ${src}/apt/paretosecurity.service $out/lib/systemd/system/paretosecurity.service
+    install -Dm400 ${finalAttrs.src}/apt/paretosecurity.socket $out/lib/systemd/system/paretosecurity.socket
+    install -Dm400 ${finalAttrs.src}/apt/paretosecurity.service $out/lib/systemd/system/paretosecurity.service
     substituteInPlace $out/lib/systemd/system/paretosecurity.service \
         --replace-fail "/usr/bin/paretosecurity" "$out/bin/paretosecurity"
 
     # Install user systemd files
-    install -Dm444 ${src}/apt/paretosecurity-user.timer $out/lib/systemd/user/paretosecurity-user.timer
-    install -Dm444 ${src}/apt/paretosecurity-user.service $out/lib/systemd/user/paretosecurity-user.service
+    install -Dm444 ${finalAttrs.src}/apt/paretosecurity-user.timer $out/lib/systemd/user/paretosecurity-user.timer
+    install -Dm444 ${finalAttrs.src}/apt/paretosecurity-user.service $out/lib/systemd/user/paretosecurity-user.service
     substituteInPlace $out/lib/systemd/user/paretosecurity-user.service \
         --replace-fail "/usr/bin/paretosecurity" "$out/bin/paretosecurity"
-    install -Dm444 ${src}/apt/paretosecurity-trayicon.service $out/lib/systemd/user/paretosecurity-trayicon.service
+    install -Dm444 ${finalAttrs.src}/apt/paretosecurity-trayicon.service $out/lib/systemd/user/paretosecurity-trayicon.service
     substituteInPlace $out/lib/systemd/user/paretosecurity-trayicon.service \
         --replace-fail "/usr/bin/paretosecurity" "$out/bin/paretosecurity"
   '';
 
   passthru.tests = {
     version = testers.testVersion {
-      version = "${version}";
+      inherit (finalAttrs) version;
       package = paretosecurity;
     };
     integration_test = nixosTests.paretosecurity;
···
     maintainers = with lib.maintainers; [ zupo ];
     mainProgram = "paretosecurity";
   };
-}
+})

pkgs/by-name/pr/proton-pass/package.nix

···
 }:
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "proton-pass";
-  version = "1.30.1";
+  version = "1.31.1";
 
   src = fetchurl {
     url = "https://proton.me/download/pass/linux/x64/proton-pass_${finalAttrs.version}_amd64.deb";
-    hash = "sha256-0IEQAzK3Pu195kjpo9l2HdLUCySR0HKSl1M8Z9URgJA=";
+    hash = "sha256-OYd26KTq2uoZzqyb2ntk3bS5cKcJJ7od0VIHfSK8lqs=";
   };
 
   dontConfigure = true;

pkgs/by-name/q2/q2pro/package.nix

···
 
 stdenv.mkDerivation (finalAttrs: rec {
   pname = "q2pro";
-  version = "0-unstable-2025-04-03";
+  version = "0-unstable-2025-04-18";
 
   src = fetchFromGitHub {
     owner = "skullernet";
     repo = "q2pro";
-    rev = "0e00beedaa892fd5f6e50d33231978846ab2d5de";
-    hash = "sha256-xw09M7EtXJ7i6myj/Em0Rtg5CmZtpbyRWmkPhCApu7I=";
+    rev = "1cc95be8bb967f4274e54a6d7251e4cd7f5ed9c1";
+    hash = "sha256-7dsFzCnWiVNioyRIW0KjicfgGTxjozicUpDJG5jGvB0=";
   };
 
   # build date and rev number is displayed in the game's console
-  revCount = "3749"; # git rev-list --count ${src.rev}
-  SOURCE_DATE_EPOCH = "1743706497"; # git show -s --format=%ct ${src.rev}
+  revCount = "3782"; # git rev-list --count ${src.rev}
+  SOURCE_DATE_EPOCH = "1744997502"; # git show -s --format=%ct ${src.rev}
 
   nativeBuildInputs =
     [

pkgs/by-name/ru/ruff-lsp/package.nix

···
-{
-  lib,
-  python3Packages,
-  fetchFromGitHub,
-
-  # tests
-  versionCheckHook,
-
-  # passthru
-  nix-update-script,
-}:
-
-python3Packages.buildPythonApplication rec {
-  pname = "ruff-lsp";
-  version = "0.0.62";
-  pyproject = true;
-
-  src = fetchFromGitHub {
-    owner = "astral-sh";
-    repo = "ruff-lsp";
-    tag = "v${version}";
-    hash = "sha256-aYhNvT4rcaEzuqwql7TpFkCoyH77uSG7r6uY5aIzhrk=";
-  };
-
-  build-system = with python3Packages; [ hatchling ];
-
-  dependencies = with python3Packages; [
-    lsprotocol
-    packaging
-    pygls
-    ruff
-    typing-extensions
-  ];
-
-  nativeCheckInputs = with python3Packages; [
-    pytest-asyncio
-    pytestCheckHook
-    python-lsp-jsonrpc
-    ruff
-    versionCheckHook
-  ];
-  versionCheckProgramArg = "--version";
-
-  makeWrapperArgs = [
-    # prefer ruff from user's PATH, that's usually desired behavior
-    "--suffix PATH : ${lib.makeBinPath (with python3Packages; [ ruff ])}"
-    # Unset ambient PYTHONPATH in the wrapper, so ruff-lsp only ever runs with
-    # its own, isolated set of dependencies. This works because the correct
-    # PYTHONPATH is set in the Python script, which runs after the wrapper.
-    "--unset PYTHONPATH"
-  ];
-
-  passthru = {
-    updateScript = nix-update-script { };
-  };
-
-  meta = {
-    changelog = "https://github.com/astral-sh/ruff-lsp/releases/tag/v${version}";
-    description = "Language Server Protocol implementation for Ruff";
-    homepage = "https://github.com/astral-sh/ruff-lsp";
-    license = lib.licenses.mit;
-    mainProgram = "ruff-lsp";
-    maintainers = with lib.maintainers; [
-      figsoda
-      kalekseev
-    ];
-  };
-}

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

···
   versionCheckHook,
 
   # passthru
-  ruff-lsp,
   nixosTests,
   nix-update-script,
 }:
···
   doInstallCheck = true;
 
   passthru = {
-    tests =
-      {
-        inherit ruff-lsp;
-      }
-      // lib.optionalAttrs stdenv.hostPlatform.isLinux {
-        nixos-test-driver-busybox = nixosTests.nixos-test-driver.busybox;
-      };
+    tests = lib.optionalAttrs stdenv.hostPlatform.isLinux {
+      nixos-test-driver-busybox = nixosTests.nixos-test-driver.busybox;
+    };
     updateScript = nix-update-script { };
   };
 

pkgs/by-name/ry/ryubing/package.nix

···
     maintainers = with maintainers; [
       jk
       artemist
-      kekschen
+      willow
     ];
     platforms = [
       "x86_64-linux"

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

···
   stdenv,
   zlib,
   # Boolean flags
+  enableSTB ? true,
   ## Darwin headless will hang when trying to run the SDL test program
   enableSdltest ? (!stdenv.hostPlatform.isDarwin),
 }:
···
     pkg-config
   ];
 
-  buildInputs = [
-    SDL2
-    giflib
-    libXpm
-    libjpeg
-    libpng
-    libtiff
-    libwebp
-    zlib
-  ];
+  buildInputs =
+    [
+      SDL2
+      libtiff
+      libwebp
+      zlib
+    ]
+    ++ lib.optionals (!enableSTB) [
+      libjpeg
+      libpng
+    ];
 
   configureFlags =
     [
···
       (lib.enableFeature false "png-shared")
       (lib.enableFeature false "tif-shared")
       (lib.enableFeature false "webp-shared")
+      (lib.enableFeature enableSTB "stb-image")
       (lib.enableFeature enableSdltest "sdltest")
     ]
     ++ lib.optionals stdenv.hostPlatform.isDarwin [

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

···
-# Dependency of pygame, toppler
-{ SDL2_image, fetchurl }:
-
-SDL2_image.overrideAttrs (oldAttrs: {
-  version = "2.0.5";
-  src = fetchurl {
-    inherit (oldAttrs.src) url;
-    hash = "sha256-vdX24CZoL31+G+C2BRsgnaL0AqLdi9HEvZwlrSYxCNA";
-  };
-
-  postPatch =
-    (oldAttrs.postPatch or "")
-    + ''
-      # allow newer autoreconf to run successfully
-      touch NEWS README AUTHORS ChangeLog
-    '';
-})

pkgs/by-name/sl/slint-lsp/package.nix

···
   xorg,
   libxkbcommon,
   wayland,
-  libiconv,
+  versionCheckHook,
+  nix-update-script,
 }:
+rustPlatform.buildRustPackage (finalAttrs: {
+  pname = "slint-lsp";
+  version = "1.10.0";
 
-let
+  src = fetchCrate {
+    inherit (finalAttrs) pname version;
+    hash = "sha256-5LDEjJx+PC6pOem06DKFkPcjpIkF20gbxi/PAVZT1ns=";
+  };
+
+  cargoHash = "sha256-1/4dOlhByJDpduExu9ZOjb7JYFKehnLiLCboWUnmfp8=";
+
   rpathLibs =
     [
       fontconfig
···
       libxkbcommon
       wayland
     ];
-in
-rustPlatform.buildRustPackage rec {
-  pname = "slint-lsp";
-  version = "1.10.0";
-
-  src = fetchCrate {
-    inherit pname version;
-    hash = "sha256-5LDEjJx+PC6pOem06DKFkPcjpIkF20gbxi/PAVZT1ns=";
-  };
-
-  useFetchCargoVendor = true;
-  cargoHash = "sha256-1/4dOlhByJDpduExu9ZOjb7JYFKehnLiLCboWUnmfp8=";
 
   nativeBuildInputs = [
     cmake
     pkg-config
     fontconfig
   ];
-  buildInputs =
-    rpathLibs
-    ++ [ xorg.libxcb.dev ]
-    ++ lib.optionals stdenv.hostPlatform.isDarwin [
-      libiconv
-    ];
+  buildInputs = finalAttrs.rpathLibs ++ [ xorg.libxcb.dev ];
 
   # Tests requires `i_slint_backend_testing` which is only a dev dependency
   doCheck = false;
 
   postInstall = lib.optionalString stdenv.hostPlatform.isLinux ''
-    patchelf --set-rpath ${lib.makeLibraryPath rpathLibs} $out/bin/slint-lsp
+    patchelf --set-rpath ${lib.makeLibraryPath finalAttrs.rpathLibs} $out/bin/slint-lsp
   '';
 
   dontPatchELF = true;
 
-  meta = with lib; {
+  doInstallCheck = true;
+  nativeInstallCheckInputs = [ versionCheckHook ];
+
+  passthru.updateScript = nix-update-script { };
+
+  meta = {
     description = "Language Server Protocol (LSP) for Slint UI language";
     mainProgram = "slint-lsp";
     homepage = "https://slint-ui.com/";
-    changelog = "https://github.com/slint-ui/slint/blob/v${version}/CHANGELOG.md";
-    license = with licenses; [ gpl3Plus ];
-    maintainers = with maintainers; [ xgroleau ];
+    downloadPage = "https://github.com/slint-ui/slint/";
+    changelog = "https://github.com/slint-ui/slint/blob/v${finalAttrs.version}/CHANGELOG.md";
+    license = with lib.licenses; [ gpl3Plus ];
+    maintainers = with lib.maintainers; [ xgroleau ];
   };
-}
+})

pkgs/by-name/so/source-meta-json-schema/package.nix

···
   cmake,
 }:
 let
-  version = "8.0.0";
+  version = "9.1.0";
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "source-meta-json-schema";
···
     owner = "sourcemeta";
     repo = "jsonschema";
     rev = "v${version}";
-    hash = "sha256-EH+wi8MAgAxTy7OPQK/faX6OVY38/Z5fXhaK92xKkyA=";
+    hash = "sha256-YxIRDTAAvkltT4HGUvPt/davarGRfE808OoI9UheqCA=";
   };
 
   nativeBuildInputs = [

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

···
 
 rustPlatform.buildRustPackage rec {
   pname = "stargazer";
-  version = "1.3.1";
+  version = "1.3.2";
 
   src = fetchFromSourcehut {
     owner = "~zethra";
     repo = "stargazer";
     rev = version;
-    hash = "sha256-0vbQDHuLrgrsWiOb2hb6lYylJm5o/wOzoDIw85H8Eh0=";
+    hash = "sha256-Yulm0XkVaN+yBKj8LDsn8pBYXEqTOSGLqbpIKDN0G2U=";
   };
 
   useFetchCargoVendor = true;
-  cargoHash = "sha256-KdHYyuH1RMLRueqYbfADUktBx9aL8yTagB0KxEGQsCs=";
+  cargoHash = "sha256-MtpJTLKhlVF5AE3huL0JRWXtNCtc0Z5b/S28ekzirPA=";
 
   passthru = {
     tests.basic-functionality = nixosTests.stargazer;

pkgs/by-name/sy/sysdig-cli-scanner/sysdig-cli-scanner.versions.nix

···
 {
-  version = "1.22.0";
+  version = "1.22.1";
 
   x86_64-linux = {
-    url = "https://download.sysdig.com/scanning/bin/sysdig-cli-scanner/1.22.0/linux/amd64/sysdig-cli-scanner";
-    hash = "sha256-qGbQRiUvoynxUeYSmjrz5r9bunthcmQWDzLtTqPu4IU=";
+    url = "https://download.sysdig.com/scanning/bin/sysdig-cli-scanner/1.22.1/linux/amd64/sysdig-cli-scanner";
+    hash = "sha256-ogQ7NhpU0KZkcZXWSBX4VaTWwXz5WWMXhqZ9abHX6+Y=";
   };
 
   aarch64-linux = {
-    url = "https://download.sysdig.com/scanning/bin/sysdig-cli-scanner/1.22.0/linux/arm64/sysdig-cli-scanner";
-    hash = "sha256-bfY5FRPU7rEVN0o/nf39q8qFP7zgffoEX1iPXbZ22pw=";
+    url = "https://download.sysdig.com/scanning/bin/sysdig-cli-scanner/1.22.1/linux/arm64/sysdig-cli-scanner";
+    hash = "sha256-apj4GqN7sdZSzpk+FvqcYJLgh+UlcJgPUdXhhurFENQ=";
   };
 
   x86_64-darwin = {
-    url = "https://download.sysdig.com/scanning/bin/sysdig-cli-scanner/1.22.0/darwin/amd64/sysdig-cli-scanner";
-    hash = "sha256-F5br4BJnB9yRWfpqEJgy79csjfYY/St1a/rPGXdvj6A=";
+    url = "https://download.sysdig.com/scanning/bin/sysdig-cli-scanner/1.22.1/darwin/amd64/sysdig-cli-scanner";
+    hash = "sha256-o5AYd3/8Ot7+EtQ2SXaV72JbR/hI/5Pu7g2jdHZYepo=";
   };
 
   aarch64-darwin = {
-    url = "https://download.sysdig.com/scanning/bin/sysdig-cli-scanner/1.22.0/darwin/arm64/sysdig-cli-scanner";
-    hash = "sha256-CsMZ8m9eJNcOxq77IVLuW1COOa2+mABoMGJ+xk/NARI=";
+    url = "https://download.sysdig.com/scanning/bin/sysdig-cli-scanner/1.22.1/darwin/arm64/sysdig-cli-scanner";
+    hash = "sha256-FDkqWstWMTtF0QLWk+iadJr7aRHRnpiatqAeoHftVDk=";
   };
 }

pkgs/by-name/sy/system76-power/package.nix

···
 
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "system76-power";
-  version = "1.2.3";
+  version = "1.2.4";
 
   src = fetchFromGitHub {
     owner = "pop-os";
     repo = "system76-power";
     tag = finalAttrs.version;
-    hash = "sha256-fyatAoWw/4ORojayA90er+H5weRykg+2ZzTsGThpW5g=";
+    hash = "sha256-SHGfs3ZokPOM2nkd/8F/5zjxh9sPXVBtHWkCbmKwEMo=";
   };
 
   nativeBuildInputs = [ pkg-config ];
···
   ];
 
   useFetchCargoVendor = true;
-  cargoHash = "sha256-/dhuWgHysJ2oWgJ6jc9u4tsUOxlFt/awlK/9Jk1GHCM=";
+  cargoHash = "sha256-Q/6OFNbqvRDTCT1MyJ3gqd4BTXXRouvnKSM3cm1jQ1g=";
 
   postInstall = ''
     install -D -m 0644 data/com.system76.PowerDaemon.conf $out/etc/dbus-1/system.d/com.system76.PowerDaemon.conf

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

···
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  fetchurl,
+  cmake,
+  withQt ? true,
+  libsForQt5,
+  withCurses ? false,
+  ncurses,
+}:
+stdenv.mkDerivation (finalAttrs: {
+  version = "12.4";
+  pname = "textadept";
+
+  src = fetchFromGitHub {
+    name = "textadept11";
+    owner = "orbitalquark";
+    repo = "textadept";
+    tag = "textadept_${finalAttrs.version}";
+    hash = "sha256-nPgpQeBq5Stv2o0Ke4W2Ltnx6qLe5TIC5a8HSYVkmfI=";
+  };
+
+  nativeBuildInputs = [ cmake ] ++ lib.optionals withQt [ libsForQt5.wrapQtAppsHook ];
+
+  buildInputs = lib.optionals withQt [ libsForQt5.qtbase ] ++ lib.optionals withCurses ncurses;
+
+  cmakeFlags =
+    lib.optional withQt [ "-DQT=ON" ]
+    ++ lib.optional withCurses [
+      "-DCURSES=ON"
+      "-DQT=OFF"
+    ];
+
+  preConfigure =
+    ''
+      mkdir -p $PWD/build/_deps
+
+    ''
+    + lib.concatStringsSep "\n" (
+      lib.mapAttrsToList (
+        name: params: "ln -s ${fetchurl params} $PWD/build/_deps/${name}"
+      ) (import ./deps.nix)
+    );
+
+  meta = {
+    description = "Extensible text editor based on Scintilla with Lua scripting";
+    homepage = "http://foicica.com/textadept";
+    downloadPage = "https://github.com/orbitalquark/textadept";
+    changelog = "https://github.com/orbitalquark/textadept/releases/tag/textadept_${finalAttrs.version}";
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [
+      raskin
+      mirrexagon
+      arcuru
+    ];
+    platforms = lib.platforms.linux;
+    mainProgram = "textadept";
+  };
+})

pkgs/by-name/ti/timewarrior/package.nix

···
 
 stdenv.mkDerivation rec {
   pname = "timewarrior";
-  version = "1.7.1";
+  version = "1.8.0";
 
   src = fetchFromGitHub {
     owner = "GothenburgBitFactory";
     repo = "timewarrior";
     rev = "v${version}";
-    hash = "sha256-sc4AfdXLuA9evoGU6Z97+Hq7zj9nx093+nPALRkhziQ=";
+    hash = "sha256-6WZ5k9cxWe+eS9me700ITq0rKEiIuDhTtmuzhOnUM4k=";
     fetchSubmodules = true;
   };
 

pkgs/by-name/tr/trilium-next-desktop/package.nix

···
 
 let
   pname = "trilium-next-desktop";
-  version = "0.92.7";
+  version = "0.93.0";
 
   triliumSource = os: arch: sha256: {
     url = "https://github.com/TriliumNext/Notes/releases/download/v${version}/TriliumNextNotes-v${version}-${os}-${arch}.zip";
···
   darwinSource = triliumSource "macos";
 
   # exposed like this for update.sh
-  x86_64-linux.sha256 = "0m907hc7bvamkvijsbxqg6ns7dv7qz02d5fsl6wgqx5vi6w02y9w";
-  aarch64-linux.sha256 = "1hb3sjkzz3d9vrjramz47l4aqqm7ah2k7a9s14csxllcjqjmv8nz";
-  x86_64-darwin.sha256 = "0qscjw2j0nyxvx9w6m4n9yb30wzk5xmg7ylf8yp0k58jxvi7b87q";
-  aarch64-darwin.sha256 = "1ah25g41x7kpjvwih59mfcf2lylwppdklrmmm1s1p2fn4261jds4";
+  x86_64-linux.sha256 = "02cz98bgv8l5c96irmxla93h9vpxpfh2l25q5h4r1wcyg00k0gqc";
+  aarch64-linux.sha256 = "0ahkskdaggff34zn6ml8s3v3ig8fq3isrcrckpvy9acyhk2nm924";
+  x86_64-darwin.sha256 = "0p1db3bij5pipwjjh0vyscvd6anq1qriny7y7yxx2sviksgyl0i8";
+  aarch64-darwin.sha256 = "0fkqlxssrdz2g63yhs1l74h037xac04y3dng7kqnrzhn740p2wjc";
 
   sources = {
     x86_64-linux = linuxSource "x64" x86_64-linux.sha256;

pkgs/by-name/tr/trilium-next-server/package.nix

···
 }:
 
 let
-  version = "0.92.7";
+  version = "0.93.0";
 
   serverSource_x64.url = "https://github.com/TriliumNext/Notes/releases/download/v${version}/TriliumNextNotes-Server-v${version}-linux-x64.tar.xz";
-  serverSource_x64.sha256 = "0ckwfk27wfskd8pk5blvcvn6pd4jmq0dys283gsqk271n8ca4537";
+  serverSource_x64.sha256 = "0gm0j8w16ynwb1rsgxd7g4pa4vm47728d8393bazppxgf91gnh3d";
   serverSource_arm64.url = "https://github.com/TriliumNext/Notes/releases/download/v${version}/TriliumNextNotes-Server-v${version}-linux-arm64.tar.xz";
-  serverSource_arm64.sha256 = "1lk0mf4h74d9z1w5jdfwbxsdh1mbbjr6gx0q0w0wg6y3ylyjcii9";
+  serverSource_arm64.sha256 = "0in1y3zsx4mni02lq17q0camn07p7fngl1qjmjnhkps7pr799d2q";
 
   serverSource =
     if stdenv.hostPlatform.isx86_64 then

pkgs/by-name/ul/ultrastardx/package.nix

···
 in
 stdenv.mkDerivation rec {
   pname = "ultrastardx";
-  version = "2025.3.0";
+  version = "2025.4.0";
 
   src = fetchFromGitHub {
     owner = "UltraStar-Deluxe";
     repo = "USDX";
     rev = "v${version}";
-    hash = "sha256-tMYw+nkyEEK7AqG9AvMchCGzzKWlfut4poXc1WK6vkA=";
+    hash = "sha256-Ymz4RwPJCGV8HW5pXBIitiQmTMPGH6qLVLpCa7N3EMg=";
   };
 
   nativeBuildInputs = [

pkgs/by-name/up/update-python-libraries/package.nix

···
 {
+  lib,
   python3,
   runCommand,
   git,
···
 runCommand "update-python-libraries"
   {
     buildInputs = [
-      nix
-      nix-prefetch-git
       (python3.withPackages (
         ps: with ps; [
           packaging
···
           toolz
         ]
       ))
-      git
     ];
   }
   ''
     cp ${./update-python-libraries.py} $out
     patchShebangs $out
-    substituteInPlace $out --replace 'GIT = "git"' 'GIT = "${git}/bin/git"'
+    substituteInPlace $out \
+      --replace-fail 'NIX = "nix"' 'NIX = "${lib.getExe nix}"' \
+      --replace-fail 'NIX_PREFETCH_URL = "nix-prefetch-url"' 'NIX_PREFETCH_URL = "${lib.getExe' nix "nix-prefetch-url"}"' \
+      --replace-fail 'NIX_PREFETCH_GIT = "nix-prefetch-git"' 'NIX_PREFETCH_GIT = "${lib.getExe nix-prefetch-git}"' \
+      --replace-fail 'GIT = "git"' 'GIT = "${lib.getExe git}"'
   ''

pkgs/by-name/up/update-python-libraries/update-python-libraries.py

···
 
 BULK_UPDATE = False
 
+NIX = "nix"
+NIX_PREFETCH_URL = "nix-prefetch-url"
+NIX_PREFETCH_GIT = "nix-prefetch-git"
 GIT = "git"
 
 NIXPKGS_ROOT = (
-    subprocess.check_output(["git", "rev-parse", "--show-toplevel"])
+    subprocess.check_output([GIT, "rev-parse", "--show-toplevel"])
     .decode("utf-8")
     .strip()
 )
···
     try:
         response = subprocess.check_output(
             [
-                "nix",
+                NIX,
                 "--extra-experimental-features",
                 "nix-command",
                 "eval",
···
     return (
         subprocess.check_output(
             [
-                "nix",
+                NIX,
                 "--extra-experimental-features",
                 "nix-command",
                 "hash",
···
     try:
         homepage = subprocess.check_output(
             [
-                "nix",
+                NIX,
                 "--extra-experimental-features",
                 "nix-command",
                 "eval",
···
 
         algorithm = "sha256"
         cmd = [
-            "nix-prefetch-git",
+            NIX_PREFETCH_GIT,
             f"https://github.com/{owner}/{repo}.git",
             "--hash",
             algorithm,
···
             hash = (
                 subprocess.check_output(
                     [
-                        "nix-prefetch-url",
+                        NIX_PREFETCH_URL,
                         "--type",
                         "sha256",
                         "--unpack",
···
             try:
                 hash = (
                     subprocess.check_output(
-                        ["nix-prefetch-url", "--type", "sha256", "--unpack", tag_url],
+                        [NIX_PREFETCH_URL, "--type", "sha256", "--unpack", tag_url],
                         stderr=subprocess.DEVNULL,
                     )
                     .decode("utf-8")

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

···
 
 python3Packages.buildPythonApplication rec {
   pname = "vectorcode";
-  version = "0.5.5";
+  version = "0.5.6";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "Davidyz";
     repo = "VectorCode";
     tag = version;
-    hash = "sha256-hoANo+CqGvMyFSPDVYVWJUf6UUo3n9C1Yu8xt5yrZUs=";
+    hash = "sha256-paFUgPf8zTtMli0qh2bXjnmny2bDQxDwWE03yn0rWUY=";
   };
 
   build-system = with python3Packages; [

pkgs/by-name/vu/vulkan-cts/package.nix

···
 in
 stdenv.mkDerivation (finalAttrs: {
   pname = "vulkan-cts";
-  version = "1.3.10.0";
+  version = "1.4.1.3";
 
   src = fetchFromGitHub {
     owner = "KhronosGroup";
     repo = "VK-GL-CTS";
     rev = "vulkan-cts-${finalAttrs.version}";
-    hash = "sha256-owa4Z/gu9+plPxeSfduS3gUk9WTOHSDoXLTBju6tTGc=";
+    hash = "sha256-44UGGeuKMCP4fLsZnIPdWDjozd87su9TUbFBnftVrNY=";
   };
 
   prePatch = ''
···
     # For vulkan-validation-layers
     "-DGLSLANG_INSTALL_DIR=${glslang}"
     "-DSPIRV_HEADERS_INSTALL_DIR=${spirv-headers}"
+    "-DSELECTED_BUILD_TARGETS=deqp-vk"
   ];
 
   postInstall = ''
···
     ! test -e $out
 
     mkdir -p $out/bin $out/archive-dir
-    cp -a external/vulkancts/modules/vulkan/deqp-vk external/vulkancts/modules/vulkan/deqp-vksc $out/bin/
+    cp -a external/vulkancts/modules/vulkan/deqp-vk $out/bin/
     cp -a external/vulkancts/modules/vulkan/vulkan $out/archive-dir/
     cp -a external/vulkancts/modules/vulkan/vk-default $out/
 

pkgs/by-name/vu/vulkan-cts/sources.nix

···
   amber = fetchFromGitHub {
     owner = "google";
     repo = "amber";
-    rev = "67fea651b886460d7b72295e680528c059bbbe40";
-    hash = "sha256-oDN7UdyfNMG4r36nnRJmYdbd0wyd1titGQQNa9e/3tU=";
+    rev = "1ec5e96db7e0343d045a52c590e30eba154f74a8";
+    hash = "sha256-4LoV7PfkwLrg+7GyuB1poC/9zE/3jy8nhs+uPe2U3lA=";
   };
 
   glslang = fetchFromGitHub {
     owner = "KhronosGroup";
     repo = "glslang";
-    rev = "c5b76b78c9dec95251e9c1840a671e19bf61abe3";
-    hash = "sha256-N7vGPqQieWnr+mbrmdbvzz7n9q3bbRKLxkYt6OiaJvU=";
+    rev = "3a2834e7702651043ca9f35d022739e740563516";
+    hash = "sha256-hHmqvdgBS23bLGCzlKJtlElw79/WvxEbPSwpbQFHQYY=";
   };
 
   jsoncpp = fetchFromGitHub {
···
   nvidia-video-samples = fetchFromGitHub {
     owner = "Igalia";
     repo = "vk_video_samples";
-    rev = "6821adf11eb4f84a2168264b954c170d03237699";
-    hash = "sha256-prshOzxUHLYi64Pbyytsp+XvmtIIyhx/3n5IVimYH64=";
+    rev = "45fe88b456c683120138f052ea81f0a958ff3ec4";
+    hash = "sha256-U5IoiRKXsdletVlnHVz8rgMEwDOZFAuld5Bzs0rvcR4=";
   };
 
   spirv-headers = fetchFromGitHub {
     owner = "KhronosGroup";
     repo = "SPIRV-Headers";
-    rev = "2a9b6f951c7d6b04b6c21fe1bf3f475b68b84801";
-    hash = "sha256-o1yRTvP7a+XVwendTKBJKNnelVGWLD0gH258GGeUDhQ=";
+    rev = "36d5e2ddaa54c70d2f29081510c66f4fc98e5e53";
+    hash = "sha256-8hx8/1vaY4mRnfNaBsghWqpzyzY4hkVkNFbQEFZif9g=";
   };
 
   spirv-tools = fetchFromGitHub {
     owner = "KhronosGroup";
     repo = "SPIRV-Tools";
-    rev = "44936c4a9d42f1c67e34babb5792adf5bce7f76b";
-    hash = "sha256-kSiP94hMlblFod2mQhlAQDAENGOvBh7v8bCxxaiYWq4=";
+    rev = "3fb52548bc8a68d349d31e21bd4e80e3d953e87c";
+    hash = "sha256-RJ3Q3U4GjqvUXDy8Jd4NWgjhKOxYMMK1Jerj19dAqno=";
+  };
+
+  video_generator = fetchFromGitHub {
+    owner = "Igalia";
+    repo = "video_generator";
+    rev = "426300e12a5cc5d4676807039a1be237a2b68187";
+    hash = "sha256-zdYYpX3hed7i5onY7c60LnM/e6PLa3VdrhXTV9oSlvg=";
   };
 
   vulkan-docs = fetchFromGitHub {
     owner = "KhronosGroup";
     repo = "Vulkan-Docs";
-    rev = "486e4b289053a7d64784e7ce791711843c60c235";
-    hash = "sha256-LGAHUeWF9X6Li1HcdD14pgnBUquWxA+bQpAL09JmwLQ=";
+    rev = "c7a3955e47d223c6a37fb29e2061c973eec98d0a";
+    hash = "sha256-dTkLzENuEfe0TVvJAgYevJNPyI/lWbjx8Pzz3Lj76PY=";
   };
 
   vulkan-validationlayers = fetchFromGitHub {
     owner = "KhronosGroup";
     repo = "Vulkan-ValidationLayers";
-    rev = "9a46ae006fa5c92e2d2af7944187f7794210844b";
-    hash = "sha256-qVQy3kKkZRWHjtj2YxJTZqKg1kwnmLa3bgVathisfOc=";
+    rev = "902f3cf8d51e76be0c0deb4be39c6223abebbae2";
+    hash = "sha256-p4DFlyU1jjfVFlEOE21aNHfqaTZ8QbSCFQfpsYS0KR0=";
+  };
+
+  vulkan-video-samples = fetchFromGitHub {
+    owner = "KhronosGroup";
+    repo = "Vulkan-Video-Samples";
+    rev = "0e87744edbb84c9c56c3fc8de9ea5150af5ee4ea";
+    hash = "sha256-CZ1zoX9gI+Ac/jf2IxWk59NXPiW6qcMhj9laoZnQfd8=";
   };
 
   prePatch = ''
-    mkdir -p external/amber external/glslang external/jsoncpp external/nvidia-video-samples external/spirv-headers external/spirv-tools external/vulkan-docs external/vulkan-validationlayers
+    mkdir -p external/amber external/glslang external/jsoncpp external/nvidia-video-samples external/spirv-headers external/spirv-tools external/video_generator external/vulkan-docs external/vulkan-validationlayers external/vulkan-video-samples
 
     cp -r ${amber} external/amber/src
     cp -r ${glslang} external/glslang/src
···
     cp -r ${nvidia-video-samples} external/nvidia-video-samples/src
     cp -r ${spirv-headers} external/spirv-headers/src
     cp -r ${spirv-tools} external/spirv-tools/src
+    cp -r ${video_generator} external/video_generator/src
     cp -r ${vulkan-docs} external/vulkan-docs/src
     cp -r ${vulkan-validationlayers} external/vulkan-validationlayers/src
+    cp -r ${vulkan-video-samples} external/vulkan-video-samples/src
   '';
 }

pkgs/by-name/vu/vulkan-cts/vk-cts-sources.py

···
                 f.write(f"    hash = \"{hash}\";\n");
                 f.write(f"  }};\n");
 
-        f.write("\n\n  prePatch = ''\n");
+        f.write("\n  prePatch = ''\n");
         f.write("    mkdir -p");
         for pkg in pkgs:
             if isinstance(pkg, fetch_sources.GitRepo):

pkgs/by-name/we/weblate/package.nix

···
   pythonRelaxDeps = [
     "celery"
     "rapidfuzz"
+    "weblate-schemas"
   ];
 
   # We don't just use wrapGAppsNoGuiHook because we need to expose GI_TYPELIB_PATH

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

···
 
 stdenvNoCC.mkDerivation (finalAttrs: {
   pname = "winbox";
-  version = "4.0beta16";
+  version = "4.0beta18";
 
   src = fetchurl {
     name = "WinBox_Linux-${finalAttrs.version}.zip";
     url = "https://download.mikrotik.com/routeros/winbox/${finalAttrs.version}/WinBox_Linux.zip";
-    hash = "sha256-RZpsKew3BaId6+tcwUV6fniUpCH4wIP9ab6P5oE7OAk=";
+    hash = "sha256-Eyvp1hCdYlyGQw+kQOZ4O2CdAMaI75GU4Uucp7RwY+0=";
   };
 
   sourceRoot = ".";

pkgs/by-name/xa/xastir/package.nix

···
   libgeotiff,
   xorg,
   motif,
-  pcre,
+  pcre2,
   perl,
   proj,
   graphicsmagick,
···
     xorg.libXpm
     xorg.libXt
     motif
-    pcre
+    pcre2
     perl
     proj
     graphicsmagick

pkgs/desktops/pantheon/services/elementary-settings-daemon/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "elementary-settings-daemon";
-  version = "8.2.0";
+  version = "8.3.0";
 
   src = fetchFromGitHub {
     owner = "elementary";
     repo = "settings-daemon";
     rev = version;
-    sha256 = "sha256-mLchzYp2HB4QEJS/Jz9o7ZSKUJtbUUUbFCTHwHZYCEE=";
+    sha256 = "sha256-0/G5h1eZi3qnjesrvWF6MiMX+FmpW4ys2tRUMBiUCS0=";
   };
 
   nativeBuildInputs = [

pkgs/development/libraries/protobuf/23.nix

···
-{ callPackage, ... }@args:
-
-callPackage ./generic.nix (
-  {
-    version = "23.4";
-    hash = "sha256-eI+mrsZAOLEsdyTC3B+K+GjD3r16CmPx1KJ2KhCwFdg=";
-  }
-  // args
-)

pkgs/development/libraries/readline/8.2.nix

···
   curses-library ? if stdenv.hostPlatform.isWindows then termcap else ncurses,
 }:
 
-stdenv.mkDerivation rec {
-  pname = "readline";
-  version = "8.2p${toString (builtins.length upstreamPatches)}";
+stdenv.mkDerivation (
+  finalAttrs:
+  let
+    inherit (finalAttrs) upstreamPatches meta;
+  in
+  {
+    pname = "readline";
+    version = "8.2p${toString (builtins.length upstreamPatches)}";
 
-  src = fetchurl {
-    url = "mirror://gnu/readline/readline-${meta.branch}.tar.gz";
-    sha256 = "sha256-P+txcfFqhO6CyhijbXub4QmlLAT0kqBTMx19EJUAfDU=";
-  };
+    src = fetchurl {
+      url = "mirror://gnu/readline/readline-${meta.branch}.tar.gz";
+      sha256 = "sha256-P+txcfFqhO6CyhijbXub4QmlLAT0kqBTMx19EJUAfDU=";
+    };
 
-  outputs = [
-    "out"
-    "dev"
-    "man"
-    "doc"
-    "info"
-  ];
+    outputs = [
+      "out"
+      "dev"
+      "man"
+      "doc"
+      "info"
+    ];
 
-  strictDeps = true;
-  propagatedBuildInputs = [ curses-library ];
-  nativeBuildInputs = [ updateAutotoolsGnuConfigScriptsHook ];
+    strictDeps = true;
+    propagatedBuildInputs = [ curses-library ];
+    nativeBuildInputs = [ updateAutotoolsGnuConfigScriptsHook ];
 
-  patchFlags = [ "-p0" ];
+    patchFlags = [ "-p0" ];
 
-  upstreamPatches = (
-    let
-      patch =
-        nr: sha256:
-        fetchurl {
-          url = "mirror://gnu/readline/readline-${meta.branch}-patches/readline82-${nr}";
-          inherit sha256;
-        };
-    in
-    import ./readline-8.2-patches.nix patch
-  );
+    upstreamPatches = (
+      let
+        patch =
+          nr: sha256:
+          fetchurl {
+            url = "mirror://gnu/readline/readline-${meta.branch}-patches/readline82-${nr}";
+            inherit sha256;
+          };
+      in
+      import ./readline-8.2-patches.nix patch
+    );
 
-  patches =
-    lib.optionals (curses-library.pname == "ncurses") [
-      ./link-against-ncurses.patch
-    ]
-    ++ [
-      ./no-arch_only-8.2.patch
-    ]
-    ++ upstreamPatches
-    ++ lib.optionals stdenv.hostPlatform.isWindows [
-      (fetchpatch {
-        name = "0001-sigwinch.patch";
-        url = "https://github.com/msys2/MINGW-packages/raw/90e7536e3b9c3af55c336d929cfcc32468b2f135/mingw-w64-readline/0001-sigwinch.patch";
-        stripLen = 1;
-        hash = "sha256-sFK6EJrSNl0KLWqFv5zBXaQRuiQoYIZVoZfa8BZqfKA=";
-      })
-      (fetchpatch {
-        name = "0002-event-hook.patch";
-        url = "https://github.com/msys2/MINGW-packages/raw/3476319d2751a676b911f3de9e1ec675081c03b8/mingw-w64-readline/0002-event-hook.patch";
-        stripLen = 1;
-        hash = "sha256-F8ytYuIjBtH83ZCJdf622qjwSw+wZEVyu53E/mPsoAo=";
-      })
-      (fetchpatch {
-        name = "0003-fd_set.patch";
-        url = "https://github.com/msys2/MINGW-packages/raw/35830ab27e5ed35c2a8d486961ab607109f5af50/mingw-w64-readline/0003-fd_set.patch";
-        stripLen = 1;
-        hash = "sha256-UiaXZRPjKecpSaflBMCphI2kqOlcz1JkymlCrtpMng4=";
-      })
-      (fetchpatch {
-        name = "0004-locale.patch";
-        url = "https://github.com/msys2/MINGW-packages/raw/f768c4b74708bb397a77e3374cc1e9e6ef647f20/mingw-w64-readline/0004-locale.patch";
-        stripLen = 1;
-        hash = "sha256-dk4343KP4EWXdRRCs8GRQlBgJFgu1rd79RfjwFD/nJc=";
-      })
-    ];
+    patches =
+      lib.optionals (curses-library.pname == "ncurses") [
+        ./link-against-ncurses.patch
+      ]
+      ++ [
+        ./no-arch_only-8.2.patch
+      ]
+      ++ upstreamPatches
+      ++ lib.optionals stdenv.hostPlatform.isWindows [
+        (fetchpatch {
+          name = "0001-sigwinch.patch";
+          url = "https://github.com/msys2/MINGW-packages/raw/90e7536e3b9c3af55c336d929cfcc32468b2f135/mingw-w64-readline/0001-sigwinch.patch";
+          stripLen = 1;
+          hash = "sha256-sFK6EJrSNl0KLWqFv5zBXaQRuiQoYIZVoZfa8BZqfKA=";
+        })
+        (fetchpatch {
+          name = "0002-event-hook.patch";
+          url = "https://github.com/msys2/MINGW-packages/raw/3476319d2751a676b911f3de9e1ec675081c03b8/mingw-w64-readline/0002-event-hook.patch";
+          stripLen = 1;
+          hash = "sha256-F8ytYuIjBtH83ZCJdf622qjwSw+wZEVyu53E/mPsoAo=";
+        })
+        (fetchpatch {
+          name = "0003-fd_set.patch";
+          url = "https://github.com/msys2/MINGW-packages/raw/35830ab27e5ed35c2a8d486961ab607109f5af50/mingw-w64-readline/0003-fd_set.patch";
+          stripLen = 1;
+          hash = "sha256-UiaXZRPjKecpSaflBMCphI2kqOlcz1JkymlCrtpMng4=";
+        })
+        (fetchpatch {
+          name = "0004-locale.patch";
+          url = "https://github.com/msys2/MINGW-packages/raw/f768c4b74708bb397a77e3374cc1e9e6ef647f20/mingw-w64-readline/0004-locale.patch";
+          stripLen = 1;
+          hash = "sha256-dk4343KP4EWXdRRCs8GRQlBgJFgu1rd79RfjwFD/nJc=";
+        })
+      ];
 
-  # This install error is caused by a very old libtool. We can't autoreconfHook this package,
-  # so this is the best we've got!
-  postInstall = lib.optionalString stdenv.hostPlatform.isOpenBSD ''
-    ln -s $out/lib/libhistory.so* $out/lib/libhistory.so
-    ln -s $out/lib/libreadline.so* $out/lib/libreadline.so
-  '';
+    # This install error is caused by a very old libtool. We can't autoreconfHook this package,
+    # so this is the best we've got!
+    postInstall = lib.optionalString stdenv.hostPlatform.isOpenBSD ''
+      ln -s $out/lib/libhistory.so* $out/lib/libhistory.so
+      ln -s $out/lib/libreadline.so* $out/lib/libreadline.so
+    '';
 
-  meta = with lib; {
-    description = "Library for interactive line editing";
+    meta = with lib; {
+      description = "Library for interactive line editing";
 
-    longDescription = ''
-      The GNU Readline library provides a set of functions for use by
-      applications that allow users to edit command lines as they are
-      typed in.  Both Emacs and vi editing modes are available.  The
-      Readline library includes additional functions to maintain a
-      list of previously-entered command lines, to recall and perhaps
-      reedit those lines, and perform csh-like history expansion on
-      previous commands.
+      longDescription = ''
+        The GNU Readline library provides a set of functions for use by
+        applications that allow users to edit command lines as they are
+        typed in.  Both Emacs and vi editing modes are available.  The
+        Readline library includes additional functions to maintain a
+        list of previously-entered command lines, to recall and perhaps
+        reedit those lines, and perform csh-like history expansion on
+        previous commands.
 
-      The history facilities are also placed into a separate library,
-      the History library, as part of the build process.  The History
-      library may be used without Readline in applications which
-      desire its capabilities.
-    '';
+        The history facilities are also placed into a separate library,
+        the History library, as part of the build process.  The History
+        library may be used without Readline in applications which
+        desire its capabilities.
+      '';
 
-    homepage = "https://savannah.gnu.org/projects/readline/";
+      homepage = "https://savannah.gnu.org/projects/readline/";
 
-    license = licenses.gpl3Plus;
+      license = licenses.gpl3Plus;
 
-    maintainers = with maintainers; [ dtzWill ];
+      maintainers = with maintainers; [ dtzWill ];
 
-    platforms = platforms.unix ++ platforms.windows;
-    branch = "8.2";
-  };
-}
+      platforms = platforms.unix ++ platforms.windows;
+      branch = "8.2";
+    };
+  }
+  // lib.optionalAttrs stdenv.hostPlatform.isMinGW {
+    # Make mingw-w64 provide a dummy alarm() function
+    #
+    # Method borrowed from
+    # https://github.com/msys2/MINGW-packages/commit/35830ab27e5ed35c2a8d486961ab607109f5af50
+    CFLAGS = "-D__USE_MINGW_ALARM -D_POSIX";
+  }
+)

pkgs/development/lua-modules/generated-packages.nix

···
     }:
     buildLuarocksPackage {
       pname = "fzf-lua";
-      version = "0.0.1836-1";
+      version = "0.0.1848-1";
       knownRockspec =
         (fetchurl {
-          url = "mirror://luarocks/fzf-lua-0.0.1836-1.rockspec";
-          sha256 = "1q0wfck09d0449q8dyb95cyyr8z0r8292dp8vrqq3jcd7qkjcf1q";
+          url = "mirror://luarocks/fzf-lua-0.0.1848-1.rockspec";
+          sha256 = "1xvgdbzdszflhr5f846glyzag74j6z2s3g74xisjgy698gg0a5vc";
         }).outPath;
       src = fetchzip {
-        url = "https://github.com/ibhagwan/fzf-lua/archive/ba5ba606f11967e08165aeeb9d7abe04d0835f58.zip";
-        sha256 = "1r66yrpzzzazasmb450xpr11f0sjg8ckrf91x4c66ypsanz2z2ws";
+        url = "https://github.com/ibhagwan/fzf-lua/archive/ea2bda8a9717307affd921e1b540dc06acdf8ea8.zip";
+        sha256 = "0ba9ncwjv9kcnw7nimifyad54xdf1cacbdlc7hjyy2zlivf4pm3g";
       };
 
       disabled = luaOlder "5.1";
···
       src = fetchFromGitHub {
         owner = "lewis6991";
         repo = "gitsigns.nvim";
-        rev = "fcfa7a989cd6fed10abf02d9880dc76d7a38167d";
-        hash = "sha256-cg8r0yuuSE8G5MTj0pET8MzJ+VQf+HsXDJx5FzriM78=";
+        rev = "2149fc2009d1117d58e86e56836f70c969f60a82";
+        hash = "sha256-7WQ428oPr43z01HvNpArZJcUov61/pDtLqJtkEKnBAY=";
       };
 
       disabled = lua.luaversion != "5.1";
···
     }:
     buildLuarocksPackage {
       pname = "grug-far.nvim";
-      version = "1.6.6-1";
+      version = "1.6.9-1";
       knownRockspec =
         (fetchurl {
-          url = "mirror://luarocks/grug-far.nvim-1.6.6-1.rockspec";
-          sha256 = "1axdj580nv078d4rh7q9rqd5rd46cvd3gfif0cbqys2kpv0xx53d";
+          url = "mirror://luarocks/grug-far.nvim-1.6.9-1.rockspec";
+          sha256 = "1svzjpgig2vbjc2hr4wh5k6rbdpw0c2bvd08v5kay73nlkyqz6zm";
         }).outPath;
       src = fetchzip {
-        url = "https://github.com/MagicDuck/grug-far.nvim/archive/d6c682af0033b4fbb3645a997e3b4a9189ed1ed6.zip";
-        sha256 = "0v1nfyiymb17p3fkk6ih1pxiib25f8vg74k79vp9r5wr56l9ja9c";
+        url = "https://github.com/MagicDuck/grug-far.nvim/archive/1c9325f6ab18fc8ac4d4c57e765aa845af148277.zip";
+        sha256 = "0rcnl4lfcg4lxlbix0v5r19vmbnn6j4pzi6k1fg4k6200yfghnzq";
       };
 
       disabled = luaOlder "5.1";
···
     }:
     buildLuarocksPackage {
       pname = "lua-resty-openssl";
-      version = "1.6.0-1";
+      version = "1.6.1-1";
       knownRockspec =
         (fetchurl {
-          url = "mirror://luarocks/lua-resty-openssl-1.6.0-1.rockspec";
-          sha256 = "108a53210khinpwk88pcz6s8n2f6hhaib3jfrgi9kjp0r4s14c4q";
+          url = "mirror://luarocks/lua-resty-openssl-1.6.1-1.rockspec";
+          sha256 = "179rc1n1zn0995zfdcl6a97v7ld95p55cppvj20lssrjkq93rk9z";
         }).outPath;
       src = fetchFromGitHub {
         owner = "fffonion";
         repo = "lua-resty-openssl";
-        rev = "1.6.0";
-        hash = "sha256-TqBRTFV1255Ct2mm2T8bLJNdSWZTEB6wOOHGRZczcVk=";
+        rev = "1.6.1";
+        hash = "sha256-8LxembMadP+I4jvjNBLn+OHxhzB+R8qSCHxk+mFL4WE=";
       };
 
       meta = {
···
     }:
     buildLuarocksPackage {
       pname = "lua-resty-session";
-      version = "4.1.0-1";
+      version = "4.1.1-1";
       knownRockspec =
         (fetchurl {
-          url = "mirror://luarocks/lua-resty-session-4.1.0-1.rockspec";
-          sha256 = "0cmx2rwiwiprg1112chxrfvp7gs2jg0grdnkb5n7yhd5rnp0bhhw";
+          url = "mirror://luarocks/lua-resty-session-4.1.1-1.rockspec";
+          sha256 = "1ndkivmrrcdd1qm762ajkkzvncyyssfq1zpkinqkj6qqydjvpzws";
         }).outPath;
       src = fetchFromGitHub {
         owner = "bungle";
         repo = "lua-resty-session";
-        rev = "v4.1.0";
-        hash = "sha256-MXB7Z/0drMOcTwJBHNwZx4iqem1XfG6uwozW+RxL588=";
+        rev = "v4.1.1";
+        hash = "sha256-rsMUnszo0QnK4dYWDrHMue9Nsyf6jOMMYh6VdH3mXPM=";
       };
 
       disabled = luaOlder "5.1";
···
     }:
     buildLuarocksPackage {
       pname = "luasystem";
-      version = "0.6.0-1";
+      version = "0.6.2-1";
       knownRockspec =
         (fetchurl {
           url = "mirror://luarocks/luasystem-0.6.2-1.rockspec";
···
     }:
     buildLuarocksPackage {
       pname = "lzextras";
-      version = "0.4.0-1";
+      version = "0.4.2-1";
       knownRockspec =
         (fetchurl {
-          url = "mirror://luarocks/lzextras-0.4.0-1.rockspec";
-          sha256 = "12s4jy3xqzb1dcan0gmgza6c9wyh44h348f4m3zzj29icffx4vyv";
+          url = "mirror://luarocks/lzextras-0.4.2-1.rockspec";
+          sha256 = "1awxr7bmf5hfgvn5vjra1rdn57dcsmv9v33b5pgp13q6yjhr750s";
         }).outPath;
       src = fetchzip {
-        url = "https://github.com/BirdeeHub/lzextras/archive/v0.4.0.zip";
-        sha256 = "1c92vm5q9vrr1imc3h9z9vvpkhlayywgk1n3wfkqbfi37ni066kw";
+        url = "https://github.com/BirdeeHub/lzextras/archive/v0.4.2.zip";
+        sha256 = "1apgv3g9blwh25hqjhz1b7la3m2c3pfzalg42kg7y0x66ga78qf0";
       };
 
       disabled = luaOlder "5.1";
···
     }:
     buildLuarocksPackage {
       pname = "rustaceanvim";
-      version = "6.0.2-1";
+      version = "6.0.3-1";
       knownRockspec =
         (fetchurl {
-          url = "mirror://luarocks/rustaceanvim-6.0.2-1.rockspec";
-          sha256 = "1z2s2f91mnc9fxr5ykffajpj2c92rjgnwipfvi2lhhl2p5hpgf9f";
+          url = "mirror://luarocks/rustaceanvim-6.0.3-1.rockspec";
+          sha256 = "1x0wh2nxf2g2kkbfyb9yspi5psvdra521ii01dn4chy9zp77br65";
         }).outPath;
       src = fetchzip {
-        url = "https://github.com/mrcjkb/rustaceanvim/archive/v6.0.2.zip";
-        sha256 = "09wrfmzbk81xax5p4wzczsvv1x28nv54mayi12fvzv6c3bmcsbvj";
+        url = "https://github.com/mrcjkb/rustaceanvim/archive/v6.0.3.zip";
+        sha256 = "0g40qj67pazf428wdgzijvf1a4xr2l1nimxisyka52fpwi1rah4y";
       };
 
       disabled = luaOlder "5.1";

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

···
     pytestCheckHook
   ];
 
-  disabledTests = lib.optionals stdenv.hostPlatform.isDarwin [
-    # SystemError: nanobind::detail::nb_func_error_except(): exception could not be translated!
-    "test_filter"
-  ];
+  disabledTests =
+    [
+      # AssertionError: assert '<function te...n.<locals>.f>' == '<function f>'
+      # https://github.com/patrick-kidger/equinox/issues/1008
+      "test_function"
+    ]
+    ++ lib.optionals stdenv.hostPlatform.isDarwin [
+      # SystemError: nanobind::detail::nb_func_error_except(): exception could not be translated!
+      "test_filter"
+    ];
 
   pythonImportsCheck = [ "equinox" ];
 

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

···
 
 buildPythonPackage rec {
   pname = "flametree";
-  version = "0.1.12";
+  version = "0.2.0";
   format = "setuptools";
 
   src = fetchFromGitHub {
     owner = "Edinburgh-Genome-Foundry";
     repo = "Flametree";
     tag = "v${version}";
-    hash = "sha256-oyiuhsYouGDKRssKc0aYIoG32H7GS6Bn4RtI7/9N158=";
+    hash = "sha256-4yU4u5OmVP3adz9DNsU0BtuQ7LZYqbOLxbuS48lksHM=";
   };
 
   nativeCheckInputs = [

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

···
 
 buildPythonPackage rec {
   pname = "granian";
-  version = "2.2.4";
+  version = "2.2.5";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "emmett-framework";
     repo = "granian";
     tag = "v${version}";
-    hash = "sha256-DZFTQLZx+p2SoR1/7atAqxjVqDGgJBkz3fmXGF0iojA=";
+    hash = "sha256-fToH8sKh0M75D9YuyqkMEqY+cQio1NUmYdk/TEGy3fk=";
   };
 
   cargoDeps = rustPlatform.fetchCargoVendor {
     inherit pname version src;
-    hash = "sha256-4MwIQTjS+SH0d+wPB4wfRXzo3f8CBMOAUy/3tf2uXYo=";
+    hash = "sha256-ThH4sk3yLvR9bklosUhCbklkcbpLW/5I1ukBNxUyqr8=";
   };
 
   nativeBuildInputs = with rustPlatform; [

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

···
   # tests
   pytestCheckHook,
   psutil,
+  writableTmpDirAsHomeHook,
 }:
 
 buildPythonPackage rec {
   pname = "jupysql";
-  version = "0.10.17";
+  version = "0.11.1";
 
   pyproject = true;
 
···
     owner = "ploomber";
     repo = "jupysql";
     tag = version;
-    hash = "sha256-0lrcNKDKmM3Peodc9ZzgqkzwPHPLMxxXHAj4OOKWZxA=";
+    hash = "sha256-7wfKvKqDf8LlUiLoevNRxmq8x5wLheOgIeWz72oFcuw=";
   };
 
   pythonRelaxDeps = [ "sqlalchemy" ];
···
   nativeCheckInputs = [
     pytestCheckHook
     psutil
+    writableTmpDirAsHomeHook
   ] ++ optional-dependencies.dev;
 
   disabledTests =
     [
       # AttributeError: 'DataFrame' object has no attribute 'frame_equal'
       "test_resultset_polars_dataframe"
+
       # all of these are broken with later versions of duckdb; see
       # https://github.com/ploomber/jupysql/issues/1030
       "test_resultset_getitem"
···
       "test_resultset_repr_html_with_reduced_feedback"
       "test_invalid_operation_error"
       "test_resultset_config_autolimit_dict"
+
       # fails due to strict warnings
       "test_calling_legacy_plotting_functions_displays_warning"
     ]
     ++ lib.optionals stdenv.hostPlatform.isDarwin [
-      # Fatal Python error: Aborted (in matplotlib)
+      # RuntimeError: *** -[__NSPlaceholderArray initWithObjects:count:]: attempt to insert nil object from objects[1]
       "test_no_errors_with_stored_query"
     ];
 
···
     # require js2py (which is unmaintained and insecure)
     "src/tests/test_widget.py"
   ];
-
-  preCheck = ''
-    # tests need to write temp data
-    export HOME=$(mktemp -d)
-  '';
 
   pythonImportsCheck = [ "sql" ];
 

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

···
     description = "Human friendly interface to Linux subsystems using Python";
     homepage = "https://github.com/tiagocoutinho/linuxpy";
     license = licenses.gpl3Plus;
-    maintainers = with lib.maintainers; [ kekschen ];
+    maintainers = with lib.maintainers; [ willow ];
     platforms = lib.platforms.linux;
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "neo";
-  version = "0.14.0";
+  version = "0.14.1";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "NeuralEnsemble";
     repo = "python-neo";
     tag = version;
-    hash = "sha256-lLs70BsbFxTmd/qR0EqsceG+fAKI1P+em5Ix2kM9w/w=";
+    hash = "sha256-n0+K1J6K3WYN+1LxcHoVuA+U3LeiRG0EsicJf5uKvnE=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/pygame-ce/default.nix

···
   libpng,
   libX11,
   portmidi,
-  SDL2,
+  SDL2_classic,
   SDL2_image,
   SDL2_mixer,
   SDL2_ttf,
···
         ]) buildInputs
       );
     })
-    # Skip tests that should be disabled without video driver
-    ./skip-surface-tests.patch
   ];
 
   postPatch =
···
     libjpeg
     libpng
     portmidi
-    SDL2
-    SDL2_image
+    SDL2_classic
+    (SDL2_image.override { enableSTB = false; })
     SDL2_mixer
     SDL2_ttf
   ];
···
 
   env =
     {
-      SDL_CONFIG = lib.getExe' (lib.getDev SDL2) "sdl2-config";
+      SDL_CONFIG = lib.getExe' (lib.getDev SDL2_classic) "sdl2-config";
     }
     // lib.optionalAttrs stdenv.cc.isClang {
       NIX_CFLAGS_COMPILE = "-Wno-error=incompatible-function-pointer-types";

pkgs/development/python-modules/pygame-ce/skip-surface-tests.patch

···
-diff --git a/test/surface_test.py b/test/surface_test.py
-index 5ce78b6e..8b8f7ed5 100644
---- a/test/surface_test.py
-+++ b/test/surface_test.py
-@@ -1091,6 +1091,10 @@ class GeneralSurfaceTests(unittest.TestCase):
-         finally:
-             pygame.display.quit()
- 
-+    @unittest.skipIf(
-+        os.environ.get("SDL_VIDEODRIVER") == "dummy",
-+        'requires a non-"dummy" SDL_VIDEODRIVER',
-+    )
-     def test_convert_init(self):
-         """Ensure initialization exceptions are raised
-         for surf.convert()."""
-@@ -1118,6 +1122,10 @@ class GeneralSurfaceTests(unittest.TestCase):
-         finally:
-             pygame.display.quit()
- 
-+    @unittest.skipIf(
-+        os.environ.get("SDL_VIDEODRIVER") == "dummy",
-+        'requires a non-"dummy" SDL_VIDEODRIVER',
-+    )
-     def test_convert_alpha_init(self):
-         """Ensure initialization exceptions are raised
-         for surf.convert_alpha()."""

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

···
     libX11
     portmidi
     SDL2_classic
-    SDL2_image
+    (SDL2_image.override { enableSTB = false; })
     SDL2_mixer
     SDL2_ttf
   ];

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

···
     owner = "pymc-devs";
     repo = "pytensor";
     tag = "rel-${version}";
-    hash = "sha256-Tsu+q3PeJSIVdW5wRB1RRk4oolXpj58ZbBQ20gaHJ7o=";
+    hash = "sha256-Iyiuvt86pfz8MmpwgDecKJFVOw+fKpEaA9m1MBA9Yxs=";
   };
 
   build-system = [

pkgs/development/python-modules/python-codon-tables/default.nix

···
 
 buildPythonPackage rec {
   pname = "python-codon-tables";
-  version = "0.1.13";
+  version = "0.1.15";
   format = "setuptools";
 
   src = fetchPypi {
     pname = "python_codon_tables";
     inherit version;
-    hash = "sha256-3PQLBgZJjefCOrh+PHbaViy4VwZGR68mkwC58usi51o=";
+    hash = "sha256-bK0Y8y5W6xmtGeRUtLDGsg1voVKp1uU37tBqi0/raLY=";
   };
 
   # no tests in tarball

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

···
 
 buildPythonPackage rec {
   pname = "pyytlounge";
-  version = "3.1.0";
+  version = "3.2.0";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "FabioGNR";
     repo = "pyytlounge";
     tag = "v${version}";
-    hash = "sha256-87m1lrI5ryqaMgtuFtWUVUiKzM7J8u1mkR9l98tU1I0=";
+    hash = "sha256-8cdahP1u8Rf4m/167ie9aKcELLiWNvZOx7tV9YLK4nU=";
   };
 
   build-system = [ hatchling ];

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

···
 
 buildPythonPackage rec {
   pname = "rq";
-  version = "2.2";
+  version = "2.3.1";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "rq";
     repo = "rq";
     tag = "v${version}";
-    hash = "sha256-RuqLfPEwdwfJo+mdY4vB3lpyGkbP/GQDfRU+TmUur3s=";
+    hash = "sha256-RnnYO6gKhbcft61EhTFbfvhC+9SsVfDsu64GuNfGKvE=";
   };
 
   build-system = [ hatchling ];

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

···
   lib,
   stdenv,
   buildPythonPackage,
-  callPackage,
-  catalogue,
+  fetchFromGitHub,
+
+  # build-system
   cymem,
   cython_0,
-  fetchPypi,
-  git,
-  hypothesis,
+  murmurhash,
+  numpy,
+  preshed,
+  thinc,
+
+  # dependencies
+  catalogue,
   jinja2,
   langcodes,
-  mock,
-  murmurhash,
-  nix-update,
-  nix,
-  numpy,
   packaging,
-  preshed,
   pydantic,
-  pytestCheckHook,
-  pythonOlder,
   requests,
   setuptools,
   spacy-legacy,
   spacy-loggers,
-  spacy-lookups-data,
-  spacy-transformers,
   srsly,
-  thinc,
   tqdm,
   typer,
   wasabi,
   weasel,
+
+  # optional-dependencies
+  spacy-transformers,
+  spacy-lookups-data,
+
+  # tests
+  pytestCheckHook,
+  hypothesis,
+  mock,
+
+  # passthru
   writeScript,
+  git,
+  nix,
+  nix-update,
+  callPackage,
 }:
 
 buildPythonPackage rec {
···
   version = "3.8.5";
   pyproject = true;
 
-  src = fetchPypi {
-    inherit pname version;
-    hash = "sha256-OLyLh3+yT0FJBf8XliADFgfNMf5vkA1noGcwFCcVZRw=";
+  src = fetchFromGitHub {
+    owner = "explosion";
+    repo = "spaCy";
+    tag = "release-v${version}";
+    hash = "sha256-rgMstGSscUBACA5+veXD9H/lHuvWKs7hJ6hz6aKOB/0=";
   };
-
-  postPatch = ''
-    # unpin numpy, cannot use pythonRelaxDeps because it's in build-system
-    substituteInPlace pyproject.toml setup.cfg \
-      --replace-fail ",<2.1.0" ""
-  '';
 
   build-system = [
     cymem
···
     weasel
   ];
 
+  optional-dependencies = {
+    transformers = [ spacy-transformers ];
+    lookups = [ spacy-lookups-data ];
+  };
+
   nativeCheckInputs = [
     pytestCheckHook
     hypothesis
     mock
   ];
 
-  optional-dependencies = {
-    transformers = [ spacy-transformers ];
-    lookups = [ spacy-lookups-data ];
-  };
-
   # Fixes ModuleNotFoundError when running tests on Cythonized code. See #255262
   preCheck = ''
     cd $out
···
       set -eou pipefail
       PATH=${
         lib.makeBinPath [
-          nix
           git
+          nix
           nix-update
         ]
       }
···
     tests.annotation = callPackage ./annotation-test { };
   };
 
-  meta = with lib; {
+  meta = {
     description = "Industrial-strength Natural Language Processing (NLP)";
     homepage = "https://github.com/explosion/spaCy";
     changelog = "https://github.com/explosion/spaCy/releases/tag/release-v${version}";
-    license = licenses.mit;
+    license = lib.licenses.mit;
     maintainers = [ ];
     mainProgram = "spacy";
+    # Cython.Compiler.Errors.CompileError: spacy/ml/parser_model.pyx
+    broken = true;
   };
 }

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

···
 
 buildPythonPackage rec {
   pname = "trimesh";
-  version = "4.6.6";
+  version = "4.6.8";
   pyproject = true;
 
   disabled = pythonOlder "3.8";
···
     owner = "mikedh";
     repo = "trimesh";
     tag = version;
-    hash = "sha256-A/obsrJIItNszMleMP1kkysSVdiFV2WxKTmYG+g1nks=";
+    hash = "sha256-ut5wCEjhC4h299TJufBOmWZHtu24Ve/BsgMaNpRDAPg=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/wadler-lindig/default.nix

···
 
 buildPythonPackage rec {
   pname = "wadler-lindig";
-  version = "0.1.4";
+  version = "0.1.5";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "patrick-kidger";
     repo = "wadler_lindig";
     tag = "v${version}";
-    hash = "sha256-ykRyJ5kCxYb3jBb8/8ogGjpgXMcb/mvvvHaSy9fecxA=";
+    hash = "sha256-owqtKooc7b7RRJglDC5K5M88pxAepHRr+lZCsOOzw7E=";
   };
 
   build-system = [
···
   ];
 
   meta = {
-    description = "A Wadler--Lindig pretty printer for Python";
+    description = "Wadler--Lindig pretty printer for Python";
     homepage = "https://github.com/patrick-kidger/wadler_lindig";
     changelog = "https://github.com/patrick-kidger/wadler_lindig/releases/tag/v${version}";
     license = lib.licenses.asl20;

pkgs/development/python-modules/weblate-schemas/default.nix

···
 
 buildPythonPackage rec {
   pname = "weblate-schemas";
-  version = "2024.2";
+  version = "2025.1";
 
   pyproject = true;
 
   src = fetchPypi {
     pname = "weblate_schemas";
     inherit version;
-    hash = "sha256-Y7hWqfv1gZ2sT2fNbWLVDzwbVdB/1rT/oND9p/mkYAs=";
+    hash = "sha256-R2G5s51XmZfc3qewNGv5D9K03pvCFeod4RH4VtY9cAA=";
   };
 
   build-system = [ setuptools ];

pkgs/games/dwarf-fortress/README.md

···
+# dwarf-fortress
+
+Maintainers, please read me!
+
+The policy for updates is currently keeping one major version of DF around since 0.44.
+See [Save Compatibility](https://dwarffortresswiki.org/index.php/Save_compatibility)
+on the DF wiki. Note that saves are backwards compatible, but not forwards-compatible.
+
+This policy has been in effect since Nixpkgs 25.05.

pkgs/games/dwarf-fortress/default.nix

···
   libsForQt5,
   newScope,
   perlPackages,
-  jdk8,
-  jre8,
 }:
 
 # To whomever it may concern:
···
   # out, ensure that (unfuck|dfhack|twbt) are all up to date before changing
   # this. Note that unfuck and twbt are not required for 50.
   latestVersion =
-    if stdenv.hostPlatform.isLinux then
-      "50.13"
-    else if stdenv.hostPlatform.isDarwin then
-      "0.47.05"
-    else
-      throw "Unsupported system";
+    self.dfVersions.game.latest.${
+      if stdenv.hostPlatform.isLinux then
+        "linux"
+      else if stdenv.hostPlatform.isDarwin then
+        "darwin"
+      else
+        throw "Unsupported system"
+    };
 
   # Converts a version to a package name.
   versionToName = version: "dwarf-fortress_${replaceStrings [ "." ] [ "_" ] version}";
···
             stdenv = gccStdenv;
           };
 
-          dwarf-therapist = libsForQt5.callPackage ./dwarf-therapist/wrapper.nix {
-            inherit dwarf-fortress;
-            dwarf-therapist = (libsForQt5.callPackage ./dwarf-therapist { }).override (
-              optionalAttrs (!isAtLeast50) {
-                # 41.2.5 is the last version to support Dwarf Fortress 0.47.
-                version = "41.2.5";
-                hash = "sha256-xfYBtnO1n6OcliVt07GsQ9alDJIfWdVhtuyWwuvXSZs=";
+          mkDfWrapper =
+            {
+              dwarf-fortress,
+              dfhack,
+              dwarf-therapist ? null,
+              ...
+            }@args:
+            callPackage ./wrapper (
+              {
+                inherit (self) themes;
+                inherit
+                  dwarf-fortress
+                  twbt
+                  dfhack
+                  dwarf-therapist
+                  ;
               }
+              // args
             );
+
+          dwarf-therapist = libsForQt5.callPackage ./dwarf-therapist/wrapper.nix {
+            inherit dwarf-fortress dfhack mkDfWrapper;
+            dwarf-therapist =
+              (libsForQt5.callPackage ./dwarf-therapist {
+                inherit (self) dfVersions;
+              }).override
+                (
+                  optionalAttrs (!isAtLeast50) {
+                    # 41.2.5 is the last version to support Dwarf Fortress 0.47.
+                    version = "41.2.5";
+                    maxDfVersion = "0.47.05";
+                    hash = "sha256-xfYBtnO1n6OcliVt07GsQ9alDJIfWdVhtuyWwuvXSZs=";
+                  }
+                );
           };
         in
-        callPackage ./wrapper {
-          inherit (self) themes;
-          inherit
-            dwarf-fortress
-            twbt
-            dfhack
-            dwarf-therapist
-            ;
-
-          jdk = jdk8; # TODO: remove override https://github.com/NixOS/nixpkgs/pull/89731
-        };
-    }) (attrNames self.df-hashes)
+        mkDfWrapper { inherit dwarf-fortress dfhack dwarf-therapist; };
+    }) (attrNames self.dfVersions.game.versions)
   );
 
   self = rec {
-    df-hashes = importJSON ./game.json;
+    dfVersions = importJSON ./df.lock.json;
 
     # Aliases for the latest Dwarf Fortress and the selected Therapist install
     dwarf-fortress = getAttr (versionToName latestVersion) df-games;
···
 
     soundSense = callPackage ./soundsense.nix { };
 
-    legends-browser = callPackage ./legends-browser {
-      jre = jre8; # TODO: remove override https://github.com/NixOS/nixpkgs/pull/89731
-    };
+    legends-browser = callPackage ./legends-browser { };
 
     themes = recurseIntoAttrs (
       callPackage ./themes {

pkgs/games/dwarf-fortress/df.lock.json

···
+{
+  "game": {
+    "latest": {
+      "linux": "51.10",
+      "darwin": "0.47.05"
+    },
+    "versions": {
+      "51.10": {
+        "df": {
+          "version": "51.10",
+          "urls": {
+            "linux": {
+              "url": "https://www.bay12games.com/dwarves/df_51_10_linux.tar.bz2",
+              "outputHash": "sha256-r4dadc/nch2smNHt4Ixa2FG2Sc1NFmY88iSnFFeMcz0="
+            }
+          }
+        },
+        "hack": {
+          "version": "51.10-r1",
+          "git": {
+            "url": "https://github.com/DFHack/dfhack.git",
+            "revision": "51.10-r1",
+            "outputHash": "sha256-TsgafCiLX/IZXgBdqQaRt7hmATwKz80x2xclCwdE3fM="
+          },
+          "xmlRev": "ec3ab067aef716817d9c5b84a6fb85bc22516caa"
+        }
+      },
+      "50.15": {
+        "df": {
+          "version": "50.15",
+          "urls": {
+            "linux": {
+              "url": "https://www.bay12games.com/dwarves/df_50_15_linux.tar.bz2",
+              "outputHash": "sha256-KkKcXfXjD7dUjQDfKtXiaKfoieRN8wJSYxyN6liBwU4="
+            }
+          }
+        },
+        "hack": {
+          "version": "50.15-r2",
+          "git": {
+            "url": "https://github.com/DFHack/dfhack.git",
+            "revision": "50.15-r2",
+            "outputHash": "sha256-6T1RXdBJdo/tvHXwYATS8emLIfDg7/0cGL4i982iHdY="
+          },
+          "xmlRev": "c6c8f15afec05d457813c003a869509901993af4"
+        }
+      },
+      "0.47.05": {
+        "df": {
+          "version": "0.47.05",
+          "urls": {
+            "linux": {
+              "url": "https://www.bay12games.com/dwarves/df_47_05_linux.tar.bz2",
+              "outputHash": "sha256-rHSm27fX2WIfQwQFCAMiq1DDX2YyNS/y6pI/bcWv/KM="
+            },
+            "darwin": {
+              "url": "https://www.bay12games.com/dwarves/df_47_05_osx.tar.bz2",
+              "outputHash": "sha256-vHmpKtuWSX1ZVGN46MmrLvZ8oiq/vZdjYW3pwuAOXyQ="
+            }
+          }
+        },
+        "hack": {
+          "version": "0.47.05-r8",
+          "git": {
+            "url": "https://github.com/DFHack/dfhack.git",
+            "revision": "0.47.05-r8",
+            "outputHash": "sha256-y5XluaNU0ewUg2uAd77+h80CYDwNr1rsxB8IslZWip8="
+          },
+          "xmlRev": "afe7e908e9e7e863412e8983f9feb2b999fae498"
+        }
+      },
+      "0.44.12": {
+        "df": {
+          "version": "0.44.12",
+          "urls": {
+            "linux": {
+              "url": "https://www.bay12games.com/dwarves/df_44_12_linux.tar.bz2",
+              "outputHash": "sha256-Wi0Vcw0htBpo2gnOPDtww+Km/RW5XGy/toV47S0tuXk="
+            },
+            "darwin": {
+              "url": "https://www.bay12games.com/dwarves/df_44_12_osx.tar.bz2",
+              "outputHash": "sha256-IY1TGZ9+ufWMA146XUTYgvG2ngfvY/mKZZDWGm/IptU="
+            }
+          }
+        },
+        "hack": {
+          "version": "0.44.12-r3",
+          "git": {
+            "url": "https://github.com/DFHack/dfhack.git",
+            "revision": "0.44.12-r3",
+            "outputHash": "sha256-8ChD4P7SpSNlhhOsrbIxoJ/T/CWobwvOY7QswxP0KK0="
+          },
+          "xmlRev": "4053321b202a29f667d64d824ba8339ec1b1df4f"
+        }
+      }
+    }
+  },
+  "therapist": {
+    "version": "42.1.12",
+    "maxDfVersion": "51.10",
+    "git": {
+      "url": "https://github.com/Dwarf-Therapist/Dwarf-Therapist.git",
+      "revision": "v42.1.12",
+      "outputHash": "sha256-/6tiFjfrAziw7XeEzPoNFgrsXk8Z7ea2PGjCvJlRt+A="
+    }
+  }
+}

pkgs/games/dwarf-fortress/dfhack/default.nix

···
   binutils,
   gnused,
   dfVersion,
+  dfVersions,
 }:
 
 let
···
     versionAtLeast
     ;
 
-  dfhack-releases = {
-    "0.44.10" = {
-      dfHackRelease = "0.44.10-r2";
-      hash = "sha256-0RikMwFv/eJk26Hptnam6J97flekapQhjWvw3+HTfaU=";
-      xmlRev = "321bd48b10c4c3f694cc801a7dee6be392c09b7b";
-    };
-    "0.44.11" = {
-      dfHackRelease = "0.44.11-beta2.1";
-      hash = "sha256-Yi/8BdoluickbcQQRbmuhcfrvrl02vf12MuHmh5m/Mk=";
-      xmlRev = "f27ebae6aa8fb12c46217adec5a812cd49a905c8";
-      prerelease = true;
-    };
-    "0.44.12" = {
-      dfHackRelease = "0.44.12-r1";
-      hash = "sha256-3j83wgRXbfcrwPRrJVHFGcLD+tXy1M3MR2dwIw2mA0g=";
-      xmlRev = "23500e4e9bd1885365d0a2ef1746c321c1dd5094";
-    };
-    "0.47.02" = {
-      dfHackRelease = "0.47.02-alpha0";
-      hash = "sha256-ScrFcfyiimuLgEaFjN5DKKRaFuKfdJjaTlGDit/0j6Y=";
-      xmlRev = "23500e4e9bd1885365d0a2ef1746c321c1dd509a";
-      prerelease = true;
-    };
-    "0.47.04" = {
-      dfHackRelease = "0.47.04-r5";
-      hash = "sha256-0s+/LKbqsS/mrxKPDeniqykE5+Gy3ZzCa8yEDzMyssY=";
-      xmlRev = "be0444cc165a1abff053d5893dc1f780f06526b7";
-    };
-    "0.47.05" = {
-      dfHackRelease = "0.47.05-r7";
-      hash = "sha256-vBKUTSjfCnalkBzfjaIKcxUuqsGGOTtoJC1RHJIDlNc=";
-      xmlRev = "f5019a5c6f19ef05a28bd974c3e8668b78e6e2a4";
-    };
-    "50.10" = {
-      dfHackRelease = "50.10-r1.1";
-      hash = "sha256-k2j8G4kJ/RYE8W0YDOxcsRb5qjjn4El+rigf0v3AqZU=";
-      xmlRev = "041493b221e0799c106abeac1f86df4535ab80d3";
-      needsPatches = true;
-    };
-    "50.11" = {
-      dfHackRelease = "50.11-r7";
-      hash = "sha256-3KsFc0i4XkzoeRvcl5GUlx/fJB1HyqfZm+xL6T4oT/A=";
-      xmlRev = "cca87907c1cbfcf4af957b0bea3a961a345b1581";
-      needsPatches = true;
-    };
-    "50.12" = {
-      dfHackRelease = "50.12-r3";
-      hash = "sha256-2mO8DpNmZRCV7IRY0arf3SMvlO4Pxs61Kxfh3q3k3HU=";
-      xmlRev = "980b1af13acc31660dce632f913c968f52e2b275";
-    };
-    "50.13" = {
-      dfHackRelease = "50.13-r3";
-      hash = "sha256-WbkJ8HmLT5GdZgDmcuFh+1uzhloKM9um0b9YO//uR7Y=";
-      xmlRev = "f0530a22149606596e97e3e17d941df3aafe29b9";
-    };
-  };
-
   release =
     if isAttrs dfVersion then
       dfVersion
-    else if hasAttr dfVersion dfhack-releases then
-      getAttr dfVersion dfhack-releases
+    else if hasAttr dfVersion dfVersions.game.versions then
+      (getAttr dfVersion dfVersions.game.versions).hack
     else
       throw "[DFHack] Unsupported Dwarf Fortress version: ${dfVersion}";
 
-  version = release.dfHackRelease;
+  inherit (release) version;
   isAtLeast50 = versionAtLeast version "50.0";
   needs50Patches = isAtLeast50 && (release.needsPatches or false);
 
   # revision of library/xml submodule
-  xmlRev = release.xmlRev;
+  inherit (release) xmlRev;
 
   arch =
     if stdenv.hostPlatform.system == "x86_64-linux" then
···
   src = fetchFromGitHub {
     owner = "DFHack";
     repo = "dfhack";
-    rev = release.dfHackRelease;
-    inherit (release) hash;
+    tag = release.git.revision;
+    hash = release.git.outputHash;
     fetchSubmodules = true;
   };
 

pkgs/games/dwarf-fortress/dwarf-therapist/default.nix

···
   qtdeclarative,
   cmake,
   ninja,
-  version ? "42.1.6",
-  hash ? "sha256-VjCXT4sl3HsFILrqTc3JJSeRedZaOXUbf4KvSzTo0uc=",
+  dfVersions,
+
+  # see: https://github.com/Dwarf-Therapist/Dwarf-Therapist/releases
+  version ? dfVersions.therapist.version,
+  maxDfVersion ? dfVersions.therapist.maxDfVersion,
+  hash ? dfVersions.therapist.git.outputHash,
 }:
 
 stdenv.mkDerivation rec {
···
   src = fetchFromGitHub {
     owner = "Dwarf-Therapist";
     repo = "Dwarf-Therapist";
-    rev = "v${version}";
+    tag = "v${version}";
     inherit hash;
   };
 
···
       null;
 
   dontWrapQtApps = true;
+
+  passthru = {
+    inherit maxDfVersion;
+  };
 
   meta = with lib; {
     mainProgram = "dwarftherapist";

pkgs/games/dwarf-fortress/dwarf-therapist/wrapper.nix

···
 {
+  lib,
   stdenv,
+  writeText,
   dwarf-therapist,
   dwarf-fortress,
+  dfhack,
+  mkDfWrapper,
   replaceVars,
   coreutils,
   wrapQtAppsHook,
+  expect,
+  xvfb-run,
 }:
 
 let
···
     in
     prefix + base;
   inifile = "linux/v0.${builtins.toString dwarf-fortress.baseVersion}.${dwarf-fortress.patchVersion}${platformSlug}.ini";
+  unsupportedVersion = lib.versionOlder dwarf-therapist.maxDfVersion dwarf-fortress.dfVersion;
 
+  # Used to run dfhack to produce a Therapist ini file for the current memory map.
+  # See: http://www.bay12forums.com/smf/index.php?topic=168411.msg8532557#msg8532557
+  dfHackExpectScript = writeText "dfhack.exp" ''
+    spawn xvfb-run dfhack +devel/export-dt-ini
+    expect "DFHack is ready. Have a nice day!"
+    send "die\r"
+  '';
+
+  dfHackWrapper = mkDfWrapper {
+    inherit dwarf-fortress dfhack;
+    enableDFHack = true;
+  };
 in
 
 stdenv.mkDerivation {
   pname = "dwarf-therapist";
-  inherit (dwarf-therapist) version meta;
+  inherit (dwarf-therapist) version meta maxDfVersion;
+  inherit (dwarf-fortress) dfVersion;
 
   wrapper = replaceVars ./dwarf-therapist.in {
     stdenv_shell = "${stdenv.shell}";
···
 
   paths = [ dwarf-therapist ];
 
-  nativeBuildInputs = [ wrapQtAppsHook ];
+  nativeBuildInputs =
+    [ wrapQtAppsHook ]
+    ++ lib.optionals unsupportedVersion [
+      expect
+      xvfb-run
+      dfHackWrapper
+    ];
 
   passthru = { inherit dwarf-fortress dwarf-therapist; };
 
-  buildCommand = ''
-    mkdir -p $out/bin
+  buildCommand =
+    lib.optionalString unsupportedVersion ''
+      fixupMemoryMaps() (
+        local output="$1"
+        local orig_md5="$2"
+        local patched_md5="$3"
+        echo "It doesn't support DF $dfVersion out of the box, so we're doing it the hard way."
+        export NIXPKGS_DF_HOME="$(mktemp -dt dfhack.XXXXXX)"
+        expect ${dfHackExpectScript}
+        local ini="$NIXPKGS_DF_HOME/therapist.ini"
+        if [ -f "$ini" ]; then
+          if grep -q "$patched_md5" "$ini"; then
+            cp -v "$ini" "$output"
+          else
+            echo "Couldn't find MD5 ($patched_md5) in $ini"
+            exit 1
+          fi
+        else
+          echo "Couldn't find $ini!"
+          exit 1
+        fi
+      )
+    ''
+    + lib.optionalString (!unsupportedVersion) ''
+      fixupMemoryMaps() {
+        echo "It should support DF $dfVersion, but we couldn't find any memory maps."
+        echo "This is a nixpkgs bug, please report it!"
+        exit 1
+      }
+    ''
+    + ''
+      mkdir -p $out/bin
 
-    install -Dm755 $wrapper $out/bin/dwarftherapist
-    ln -s $out/bin/dwarftherapist $out/bin/DwarfTherapist
+      install -Dm755 $wrapper $out/bin/dwarftherapist
+      ln -s $out/bin/dwarftherapist $out/bin/DwarfTherapist
 
-    substituteInPlace $out/bin/dwarftherapist \
-      --subst-var-by install $out
-    wrapQtApp $out/bin/dwarftherapist
+      substituteInPlace $out/bin/dwarftherapist \
+        --subst-var-by install $out
+      wrapQtApp $out/bin/dwarftherapist
 
-    # Fix up memory layouts
-    ini_path="$out/share/dwarftherapist/memory_layouts/${inifile}"
-    rm -f "$ini_path"
-    mkdir -p "$(dirname -- "$ini_path")"
-    orig_md5=$(cat "${dwarf-fortress}/hash.md5.orig" | cut -c1-8)
-    patched_md5=$(cat "${dwarf-fortress}/hash.md5" | cut -c1-8)
-    input_file="${dwarf-therapist}/share/dwarftherapist/memory_layouts/${inifile}"
-    output_file="$out/share/dwarftherapist/memory_layouts/${inifile}"
+      # Fix up memory layouts
+      input_file="${dwarf-therapist}/share/dwarftherapist/memory_layouts/${inifile}"
+      output_file="$out/share/dwarftherapist/memory_layouts/${inifile}"
+      rm -f "$output_file"
+      mkdir -p "$(dirname -- "$output_file")"
+
+      orig_md5=$(cat "${dwarf-fortress}/hash.md5.orig" | cut -c1-8)
+      patched_md5=$(cat "${dwarf-fortress}/hash.md5" | cut -c1-8)
 
-    echo "[Dwarf Therapist Wrapper] Fixing Dwarf Fortress MD5 prefix:"
-    echo "  Input:   $input_file"
-    echo "  Search:  $orig_md5"
-    echo "  Output:  $output_file"
-    echo "  Replace: $patched_md5"
+      if [ -f "$input_file" ]; then
+        echo "[Dwarf Therapist Wrapper] Fixing Dwarf Fortress MD5 prefix:"
+        echo "  Input:   $input_file"
+        echo "  Search:  $orig_md5"
+        echo "  Output:  $output_file"
+        echo "  Replace: $patched_md5"
 
-    substitute "$input_file" "$output_file" --replace-fail "$orig_md5" "$patched_md5"
-  '';
+        substitute "$input_file" "$output_file" --replace-fail "$orig_md5" "$patched_md5"
+      else
+        echo "[Dwarf Therapist Wrapper] OH NO! No memory maps found!"
+        echo "This version of Therapist ($dfVersion) has max DF version $maxDfVersion."
+        fixupMemoryMaps "$output_file" "$orig_md5" "$patched_md5"
+      fi
+    '';
 
   preferLocalBuild = true;
 }

pkgs/games/dwarf-fortress/game.json

···
-{
-  "0.43.05": {
-    "linux": "1r0b96yrdf24m9476k5x7rmp3faxr0kfwwdf35agpvlb1qbi6v45",
-    "linux32": "16l1lydpkbnl3zhz4i2snmjk7pps8vmw3zv0bjgr8dncbsrycd03",
-    "osx": "1j2zdkjnmxy8yn599pm0qmbi4zjp1m8h4ggqjxhyzp135h0lqqf9",
-    "osx32": "09ym4mflp5z78pk5mvj7b44xihnsvrxmh0b5kix6h1m6z3cc90l4",
-    "win": "0m337wh4c47ij1f3zrimvy7baff7nzrmgjbmrwdy89d0z90xpnx8",
-    "win_s": "0bjk5m1qkn3ldhqiwbq24y2m9fz9r574d54ngdb8b4ri2xfl1fbp",
-    "win32": "162rl9ygpj66pis87bqc5bwc0mk75hxv6ianhn87pbl4rh7g8ax8",
-    "win32_s": "0gv1jyw5fdskjjs27pr41grbmkk7ipqn0ry615f5g79k3mhl200i",
-    "legacy": "09lvbmg1gq257qchlbmq7hxc5nl9r39jpf73zhmwb5xfbpprn0zs",
-    "legacy_s": "023a5b27fm65w7gmzjssyyci70fdjk2zbv965y4n0f23kc4rj9gl",
-    "legacy32": "1m75arxj1q82l2dkk8qcargm3xczxlqi8krwvg3iimddky34gipq",
-    "legacy32_s": "1hgzsk66isfr5vcraxwgl7cvycl14kwf8w9kzxr8jyp5z7k24q29"
-  },
-  "0.44.05": {
-    "linux": "18bjyhjp5458bfbizm8vq4s00pqpfs097qp6pv76m84kgbc4ghg3",
-    "linux32": "1b9i4kf4c8s6bhqwn8jx100mg7fqp8nmswrai5w8dsma01py4amr",
-    "osx": "1ssc8vq3ad38x9c04j8gg96kxv0g2npi3jwcg40676byx5nrx7b6",
-    "osx32": "12i7x8idcbvp5h62jyc7b7j98jf4lrisnwglvnrms6jclj0b3g0q",
-    "win": "1kaifarjx0akg7s5a2ngfw0vm0vyr4jnax5rrbv96dliqn5knddz",
-    "win_s": "1a1xikrjdv4b0yfgnp5s8d6xn0njylynsqd8zixdc01vccl5kqm6",
-    "win32": "1j3cq0h7jdvxbsbpfxa7bli45smvy9m4fji0j6849kj7x0vcpwq4",
-    "win32_s": "10cw1n48ffkrv9ms07ka5b5370d9k2fm051cnnq03lkcvlwrq145",
-    "legacy": "0y7xpgmwn4nshhc7apyf8mj5ycl0q5vckdaviwzz6w1x31s3dp6n",
-    "legacy_s": "0j8rbw9ww1avmh8zhyzljjj6in87q4qffpffdl394fsi74n8px0d",
-    "legacy32": "0d3l4jvx53a01fjf1lf20ar9lfyykfhk05dlrfwz3w4k7vj4vvlf",
-    "legacy32_s": "1c5x9x44bblz7anhmk4y9a7p1b39b9k7gzvj4pi55jzfq0k60kl7"
-  },
-  "0.44.09": {
-    "linux": "1haikynkg1pqyrzzqk1qxm19p36ww58qp8brh3fjxssp4x71rcdy",
-    "linux32": "0lmbrdf7wjdwj5yx0khnq871yxvhfwqxjjyfkqcdy5ik18lvlkj8",
-    "osx": "01dss8g9lmi8majp6lxcfw166ydz4himkz6am5pi29gixaf4vfqs",
-    "osx32": "1iwlvmz1ir9k0kzn6726frmkznvsg9a99bbqnxvwcnq3nnnjxw3s",
-    "win": "08g5irgp59dfjgj3jxc8ixwzgnz2wghcl8cg1b1g4088dsf2x3x8",
-    "win_s": "1xyb4msn9wfrh7x136r8xn3sjz6z8c4zksbzifa0z0bpa3pdviap",
-    "win32": "0m8bs2mnyi1r4x84fwnfgd1ijdcf08xsq5zy84476svci932g5kz",
-    "win32_s": "0pl319qmyy96ibzlgj4wfj19dv1wzyg8ig6q11l4c7rivzc9286i",
-    "legacy": "0l8nrvppfzazhjsfkd5nd0bxnc6ljk8fs6yg8qh69g7q7zvzgnd3",
-    "legacy_s": "1c49z539a31czzq0rnhg6yrv1zbaja35sd0ssr4k7lsghjv84k1z",
-    "legacy32": "155xg6dpb8frlw7d9h7m1y0spw55wl4nkn7zrm70bpyp39pydlqp",
-    "legacy32_s": "05qkzjfx1ybrv96wya1dirdfxdkhj6a440sjpzwbqpkqgr8z57a3"
-  },
-  "0.44.10": {
-    "linux": "1cqm43hn3ar9d8a7y7dwq48ajp72cirn1gclh8r2fykkypprxmp2",
-    "linux32": "0gdb6sq8725nwdisxwha8f5b6arq570s73aj4gdrh611gxh13r6n",
-    "osx": "1wpa45d81q8f5mhqmaxvdkz93k6cm3pg7vpsqjjjsp5s961gd74g",
-    "osx32": "0rsy1n19n12gh8rddgi3db32in488f2nizq8kw25hga03hsh4r6x",
-    "win": "04i0ka12hmn3chsyfmk2pbknr1pdf3p8yaz7kv82ri4g6dvsjfv6",
-    "win_s": "01m6nqcrz4rhdc8wb31azj3vmjid8bdpqaf9wkz4g4vvjyy7xiyz",
-    "win32": "1nymin8wbzbh8gm2702dy7h5spdijdxnysdz71ldyl0xx4vw68d9",
-    "win32_s": "1skz0jpfm6j9bins04kn96f3v3k0kvjqlh25x3129r3hh8xacnd3",
-    "legacy": "0s84vpfr2b5y1kda9allqjrpkaxw15mkblk9dq08syhsj19vspa7",
-    "legacy_s": "18b7ikp7xy2y071h3ydfh5mq9hw9y303rdqyikvra5ji3n5p96cm",
-    "legacy32": "1yh2fl3qwpy6wrxavhn75grbjygymnfh746hxbmc60la7y5flrpy",
-    "legacy32_s": "0j65w2hxgpccg9qsaz14r82qvnvfd0pbl2gyx9fv8d77kxhkc4pw"
-  },
-  "0.44.11": {
-    "linux": "1qizfkxl2k6pn70is4vz94q4k55bc3pm13b2r6yqi6lw1cnna4sf",
-    "linux32": "11m39lfyrsxlw1g7f269q7fzwichg06l21fxhqzgvlvmzmxsf8q5",
-    "osx": "073hmcj7bm323m3xqi42605rkvmgmv83bnxz1byymgs8aqyfykkx",
-    "osx32": "0w5avnj86wprk8q0rb5qm9kxbigzk6dk0akqbw4m76jgg2jdmir7",
-    "win": "1yxyv1sycn5jc3g1y02d82154xydg3kbghis7l3xi28n3bh8387b",
-    "win_s": "1xzwl6c362wqgps911y9q8vndp8zyd20fc2p7pkzzmw2hrgfqi6q",
-    "win32": "16x2rg3gm3lh2akg7n057kkxxigb2ljz0nk685lmn4j0adq8l31p",
-    "win32_s": "1a2y220111d94mzj5y3jwpy062k8fw25akyp7yn3fwa17vwvn8zq",
-    "legacy": "0gfjmsfqj21hs4d1hm7fvppbdjspc4r2qnnp6mwcbgh67i5p5rdb",
-    "legacy_s": "1wr4hpzmhgl8haric3jpfd3kwqv1fi4vkb1gvaax5f7kplvfqfac",
-    "legacy32": "1cpzckwvqkxqn0c498mmh4papsjdi3mcvcp2vzlvj46kvdl3n0f0",
-    "legacy32_s": "024vzwfcrx7ms4dip0ccwd0vizzck2pwz2ryyvlz4rpjzhswj5gi"
-  },
-  "0.44.12": {
-    "win32": "0bxrc7zj4vgcgdwc130g6f5jnp13vgx9a2kn2l1jcc958x8a367g",
-    "linux32": "0fmr8diskmbh12s0bpfn5gky9lmrc7xxj6va5adjm6ahxv9jwr06",
-    "osx": "1md6r1pimmlhcn5gjqzg0ygbdwc2v125sfjy0f6gbfbykwcm7391",
-    "osx32": "1dbg7pavxw20r8iqc566fn558avgj5glsycvi6ggbvsh0rpw6n5v",
-    "win": "0zb5ximqi5j7vyvgjzfz7ycadh5sgb7jlyaa68x0sjlbybdr1min",
-    "win_s": "1ncf5zr1fggr5knf30l0wh7spp376v1jcc6m9c86zim8azcfx0y7",
-    "linux": "0ydr5lnysy45nsznqp5r2pysdqn3f0xkrkh9v9l1md111mriabas",
-    "win32_s": "1mxbjkikf010skrpng51r86jmv4nal51j5n1y9kyhv344bq6chr9",
-    "legacy": "11a212ynhx18p3k8hvdjx199din14wggxiwz191b4309fznzpprz",
-    "legacy_s": "05madj529y18ndxrih96mivbzng1vz2zbzicrcnj58i2084zm23f",
-    "legacy32": "0rapcydiic2nq6idjf7fg53xsxk8dxzyi1vflpz554ghdrnsmwjv",
-    "legacy32_s": "16fgbd3lx4r270dxqj6gr1g1iqjj8cv389h2hw1l646xx28g8d2m"
-  },
-  "0.47.01": {
-    "linux": "1wbybkfpgvpd2yliy8mfgddnz806ac4rv4j0lhlsqwpk8jj0mx81",
-    "linux32": "1fnz1mydqgybcm8kzranvjzc2x9g6bcalxv3fsjngvpv13x6izzv",
-    "osx": "18wdffidasbrsbhqjwds08ckbrjhcw0759aynz7zggyy5is9q8iw",
-    "osx32": "1b4kf3vg0zd5w5s0rdhzfz0rswkl6sq0j1f8qmimnw7qd09h43wx",
-    "win": "1v3v2z7g67d6926h9lxakznvbddyxyr85i1ym34y2wywnc886z7r",
-    "win_s": "0yahynimhz4nvdi5qp5a612vf7ikg87w2aj2r8s1lhdw6xwdkpyc",
-    "win32": "07mqhm64c1ddjc3vpyhf9qf14lp19xwz3pgg4c2pvcwy4yyrys22",
-    "win32_s": "07acbxai8g04yxg7n68nyx4jwcqqkgjn7n96q2lzxdvc988kiivz",
-    "legacy32_s": "1gxmc3rsl9glai3wb4wzsda3qyhdimd8s5kbr5m753n8lmzasafx"
-  },
-  "0.47.02": {
-    "linux": "1zbsygbfiqxxs767qxkxjp3ayywi5q0d8xlrqlbd0l8a3ccg5avw",
-    "linux32": "1ddc9s4n408j8gidgign51bgv2wgy5z4cy74jzx00pvnhsfp2mpy",
-    "osx": "1mwy88yxip1wys1kxpfsbg7wlvfrkc4lg04gqw0d266a88dj7a30",
-    "osx32": "08ssnzl52gqqgcqhl0ynyikbxz76825kpcg1d6yx8g7ifjndf19n",
-    "win": "08g7fy18y8q32l0158314bny0qg57xz37qj9fri9r4xbhci67ldk",
-    "win_s": "0x56s1md62yk661aqcdgnz8k0zir0zr8qwan5vrqc0q9yh069yl1",
-    "win32": "0ww64mymbilb235n93d7w4c9axq3ww2mxa0f7bl4x8yrxwc8k942",
-    "win32_s": "0r801vip807v88icf47i3s82v7lshx67q4ilzfjirqfslh1x00bs",
-    "legacy": "14f4d6r7swfjnlaalg4l5916ihj6wvhlsgjp7cygamzp4c2wgng8",
-    "legacy_s": "1jxf52kaijf4crwxj30a4f6z7rzs6xa91y6vn5s8jr0cvbr5pz64",
-    "legacy32": "0j7shqdv3gimacj03cil2y0fmr0j0fp57cwmdjwnxwx3m96k3xwm",
-    "legacy32_s": "1wc7pcp9dwz0q1na3i5pbqknya595qdkmr7hsmgh2kk8rsp3g9g2"
-  },
-  "0.47.04": {
-    "linux": "1ri82c5hja6n0wv538srf2nbcyb8ip49w4l201m90cmcycmqgr8x",
-    "linux32": "00yz8gl75sbx15d7vl22ij0a5qd325kpc9mgm1lh5g7i065vgzn8",
-    "osx": "0c1g655bn5n4pbzxw3v83gmy54va5y87m7ksi6iryfal0m9lshhv",
-    "osx32": "1knfgqbwa7v9va1w6i8yzz6xp3dj633dbs50izx6ldszm0ra42pg",
-    "win": "0j7ixr3rf9900zzfw3nd3vg97kdkspm530cmf9dkwhf6klmpks7s",
-    "win_s": "11amw5gjhi753mvf17wifcjiyikjx0qwa16787gfhj9jfp0yw764",
-    "win32": "1xw9f49n85c31kbzkm5zh81kccjx9msjyy3xwr0klak5w398a59l",
-    "win32_s": "0s26hrgfk2b5wg4dvg90wgw1mvrrvbyjhmsys9f5fl7zn1pjbxxr",
-    "legacy": "103bcnn8gxi2rkpjmjfgv5a5kxmh1zd7vagrsscv55sppd7fcl7n",
-    "legacy_s": "19ai7lvxx0y3iha9qrbl5krric547rzs6vm4ibk8x61vv97jrbd8",
-    "legacy32": "0lli6s1g7yj3p3h26ajgq3h619n88qn6s7amyz6z8w7hyzfi7wij",
-    "legacy32_s": "1wzxbzgln9pmsk2nchrl94d2yd09xdgynmjl4qwcaqzkrnf3sfqc"
-  },
-  "0.47.05": {
-    "linux": "18zwmz2nsgwjxbr2yd9jcrgw6l5b481hh1848cgn5nfpnzdscx5c",
-    "linux32": "1jbav7ghsjsxd6cdp6f2x5qn83zc8707dqan5sp73fp6mbj2jasl",
-    "osx": "092z1vhc5sbdc5irggdz5ai7rxifmg4yhy33aicpsjcnvcmajydw",
-    "osx32": "0lpbwfiagp0zp280aw3fmj8938w5fc5r9gibzk2h86jy63ps29ww",
-    "win": "0bbk7j3d4h2wn9hmbsbbbbr0ajf3ddlprxfaajfbnbiyv72cpn9s",
-    "win_s": "0nl7c9dpfx7jjpy7y52z8h3kiy4cpax1m58apbcfyy95an4jz8s4",
-    "win32": "08ka1lklly82h4mr770y9p0a21x9dx6jqvjgxdsxj5979f26il1v",
-    "win32_s": "06w844zxzx3lfykibgkk4gbg4xymnqraj1ikv4mzlv31l727a1x4",
-    "legacy": "042a0gbad3cp5dwhnrzg3vr9w48b8ybqgxgw5i9rk4c1i0gjjpw2",
-    "legacy_s": "1rb7h8lzlsjs08rvhhl3nwbrpj54zijijp4y0qdp4vyzsig6nisk",
-    "legacy32": "0ayw09x9smihh8qp5pdvr6vvhwkvcqz36h3lh4g1b5kzxj7g9cyf",
-    "legacy32_s": "10gfxlysfs9gyi1mv52idp5xk45g9h517g2jq4a8cqp2j7594v9c"
-  },
-  "50.10": {
-    "linux": "13s5p7205r9ha2j5n7carrwd0y7krq34bcdl08khp0kh2v4470a3"
-  },
-  "50.11": {
-    "linux": "0iz2d88gzvn0vjxlr99f13j4awhvh2lggjmipdwpbxhfsqih7dx0"
-  },
-  "50.12": {
-    "linux": "070014fzwszfgjyxjyij0k0hadah6s62lpi91ykp3vs220azya1m"
-  },
-  "50.13": {
-    "linux": "19wzgsdgv0vq7v2dxhypr9hayky3nm3lbra1kk9vn8ri96jdkfkw"
-  }
-}

pkgs/games/dwarf-fortress/game.nix

···
   gcc,
 
   dfVersion,
-  df-hashes,
+  dfVersions,
 }:
 
 let
···
     ;
 
   # Map Dwarf Fortress platform names to Nixpkgs platform names.
-  # Other srcs are available like 32-bit mac & win, but I have only
-  # included the ones most likely to be needed by Nixpkgs users.
   platforms = {
     x86_64-linux = "linux";
-    i686-linux = "linux32";
-    x86_64-darwin = "osx";
-    x86_64-cygwin = "win";
-    i686-cygwin = "win32";
+    x86_64-darwin = "darwin";
   };
 
   dfVersionTuple = splitVersion dfVersion;
···
     && (dwarf-fortress-unfuck.dfVersion or null) == dfVersion;
 
   game =
-    if hasAttr dfVersion df-hashes then
-      getAttr dfVersion df-hashes
+    if hasAttr dfVersion dfVersions.game.versions then
+      (getAttr dfVersion dfVersions.game.versions).df
     else
       throw "Unknown Dwarf Fortress version: ${dfVersion}";
   dfPlatform =
···
       getAttr stdenv.hostPlatform.system platforms
     else
       throw "Unsupported system: ${stdenv.hostPlatform.system}";
-  sha256 =
-    if hasAttr dfPlatform game then
-      getAttr dfPlatform game
+  url =
+    if hasAttr dfPlatform game.urls then
+      getAttr dfPlatform game.urls
     else
       throw "Unsupported dfPlatform: ${dfPlatform}";
   exe =
···
   version = dfVersion;
 
   src = fetchurl {
-    url = "https://www.bay12games.com/dwarves/df_${toString baseVersion}_${toString patchVersion}_${dfPlatform}.tar.bz2";
-    inherit sha256;
+    inherit (url) url;
+    hash = url.outputHash;
   };
 
   sourceRoot = ".";
···
       dfVersion
       exe
       ;
-    updateScript = ./update.sh;
+    updateScript = {
+      command = [ ./update.rb ];
+      attrPath = "dwarf-fortress-packages";
+      supportedFeatures = [ "commit" ];
+    };
   };
 
   meta = {

pkgs/games/dwarf-fortress/legends-browser/default.nix

···
 
 let
   name = "legends-browser-${version}";
-  version = "1.17.1";
+  version = "1.19.2";
 
   jar = fetchurl {
     url = "https://github.com/robertjanetzko/LegendsBrowser/releases/download/${version}/legendsbrowser-${version}.jar";
-    sha256 = "05b4ksbl4481rh3ykfirbp6wvxhppcd5mvclhn9995gsrcaj8gx9";
+    hash = "sha256-jkv7InwaRn0K3VAa0LqkYpH6TnrT/tGYBtbvNGM6t98=";
   };
 
   script = writeShellScriptBin "legends-browser" ''
···
       echo 'Creating initial configuration for legends-browser'
       echo "last=$(cd ..; pwd)" > legendsbrowser.properties
     fi
-    ${jre}/bin/java -jar ${jar}
+    exec ${jre}/bin/java -jar ${jar}
   '';
 in
 
···
 
   meta = with lib; {
     description = "Multi-platform, open source, java-based legends viewer for dwarf fortress";
-    maintainers = with maintainers; [ Baughn ];
+    maintainers = with maintainers; [
+      Baughn
+      numinit
+    ];
     sourceProvenance = with sourceTypes; [ binaryBytecode ];
     license = licenses.mit;
     platforms = platforms.all;

pkgs/games/dwarf-fortress/soundsense.nix

···
 {
+  lib,
   stdenv,
   fetchzip,
   dos2unix,
   soundPack ? stdenv.mkDerivation {
     name = "soundsense-soundpack";
     src = fetchzip {
-      url = "http://df.zweistein.cz/soundsense/soundpack.zip";
-      sha256 = "0qz0mjkp7wp0gxk3ws2x760awv8c9lkacj2fn9bz3gqqnq262ffa";
+      url = "https://df.zweistein.cz/soundsense/soundpack.zip";
+      hash = "sha256-yjlhBLYYv/FXsk5IpiZNDG2ugDldaD5mf+Dyc6es4GM=";
     };
     installPhase = ''
       cp -r . $out
···
   inherit soundPack;
   pname = "soundsense";
   src = fetchzip {
-    url = "http://df.zweistein.cz/soundsense/soundSense_${version}.zip";
-    sha256 = "1gkrs69l3xsh858yjp204ddp29m668j630akm7arssc9359wxqkk";
+    url = "https://df.zweistein.cz/soundsense/soundSense_${version}.zip";
+    hash = "sha256-c+LOUxmJaZ3VqVOBYSQypiZxWyNAXOlRQVD3QZPReb4=";
   };
   nativeBuildInputs = [ dos2unix ];
   buildPhase = ''
···
     ln -s $soundPack $out/soundsense/packs
   '';
   passthru = { inherit version dfVersion; };
+  meta = {
+    description = "Plays sound based on Dwarf Fortress game logs";
+    maintainers = with lib.maintainers; [
+      numinit
+    ];
+    sourceProvenance = with lib.sourceTypes; [ binaryBytecode ];
+    license = lib.licenses.gpl3Only;
+    platforms = lib.platforms.all;
+    homepage = "https://df.zweistein.cz/soundsense";
+  };
 }

pkgs/games/dwarf-fortress/themes/default.nix

···
     listToAttrs
     maintainers
     platforms
-    readFile
     ;
 in
 

pkgs/games/dwarf-fortress/twbt/default.nix

···
     ;
 
   twbt-releases = {
-    "0.44.10" = {
-      twbtRelease = "6.49";
-      sha256 = "1qjkc7k33qhxj2g18njzasccjqsis5y8zrw5vl90h4rs3i8ld9xz";
-      prerelease = false;
-    };
-    "0.44.11" = {
-      twbtRelease = "6.51";
-      sha256 = "1yclqmarjd97ch054h425a12r8a5ailmflsd7b39cg4qhdr1nii5";
-      prerelease = true;
-    };
     "0.44.12" = {
       twbtRelease = "6.54";
-      sha256 = "10gfd6vv0vk4v1r5hjbz7vf1zqys06dsad695gysc7fbcik2dakh";
+      hash = "sha256-cKomZmTLHab9K8k0pZsB2uMf3D5/SVhy2GRusLdp7oE=";
       prerelease = false;
     };
-    "0.47.02" = {
-      twbtRelease = "6.61";
-      sha256 = "07bqy9rkd64h033sxdpigp5zq4xrr0xd36wdr1b21g649mv8j6yw";
-      prerelease = false;
-    };
-    "0.47.04" = {
-      twbtRelease = "6.xx";
-      dfhackRelease = "0.47.04-r5";
-      sha256 = "sha256-+C3g4KJShCb2VXGQ4mtkDOufXZQ1P+ebDTmUzL3tNyU=";
-      prerelease = true;
-    };
     "0.47.05" = {
       twbtRelease = "6.xx";
-      dfhackRelease = "0.47.05-r7";
-      sha256 = "sha256-4xMKuSP5J6pMK+hwjTAcTI0gsLJfw+Xt+vh9CopR4tk=";
-      prerelease = true;
+      dfhackRelease = "0.47.05-r8";
+      hash = "sha256-qiNs6iMAUNGiq0kpXqEs4u4Wcrjf6/qA/dzBe947Trc=";
+      prerelease = false;
     };
   };
 
···
         "https://github.com/thurin/df-twbt/releases/download/${release.dfhackRelease}/twbt-${version}-linux64-${release.dfhackRelease}.zip"
       else
         "https://github.com/mifki/df-twbt/releases/download/v${version}/twbt-${version}-linux.zip";
-    sha256 = release.sha256;
+    inherit (release) hash;
   };
 
   sourceRoot = ".";

pkgs/games/dwarf-fortress/unfuck.nix

···
     ;
 
   unfuck-releases = {
-    "0.43.05" = {
-      unfuckRelease = "0.43.05";
-      hash = "sha256-4iLVrKmlVdvBICb8NLe/U7pHtL372CGDkxt/2lf2bZw=";
-    };
-    "0.44.05" = {
-      unfuckRelease = "0.44.05";
-      hash = "sha256-iwR9st4VsPJBn7cKH/cy8YS6Tcw8J+lMJK9/9Qgl0gM=";
-    };
-    "0.44.09" = {
-      unfuckRelease = "0.44.09";
-      hash = "sha256-9W9qON0QEjfXe2XzRvseixc+YznPzDQdcId08dEGF40=";
-    };
-    "0.44.10" = {
-      unfuckRelease = "0.44.10";
-      hash = "sha256-8ldEFcf5zPRdC/yXgMByeCC0pqZprreITIetKDpOYW0=";
-    };
-    "0.44.11" = {
-      unfuckRelease = "0.44.11.1";
-      hash = "sha256-f9vDe3Q3Vl2hFLCPSzYtqyv9rLKBKEnARZTu0MKaX88=";
-    };
     "0.44.12" = {
       unfuckRelease = "0.44.12";
       hash = "sha256-f9vDe3Q3Vl2hFLCPSzYtqyv9rLKBKEnARZTu0MKaX88=";
-    };
-    "0.47.01" = {
-      unfuckRelease = "0.47.01";
-      hash = "sha256-k8yrcJVHlHNlmOL2kEPTftSfx4mXO35TcS0zAvFYu4c=";
-    };
-    "0.47.02" = {
-      unfuckRelease = "0.47.01";
-      hash = "sha256-k8yrcJVHlHNlmOL2kEPTftSfx4mXO35TcS0zAvFYu4c=";
-    };
-    "0.47.04" = {
-      unfuckRelease = "0.47.04";
-      hash = "sha256-KRr0A/2zANAOSDeP8V9tYe7tVO2jBLzU+TF6vTpISfE=";
     };
     "0.47.05" = {
       unfuckRelease = "0.47.05-final";

pkgs/games/dwarf-fortress/update.rb

···
+#!/usr/bin/env nix-shell
+#!nix-shell -i ruby -p "ruby.withPackages (ps: with ps; [ curb nokogiri ])" nix-prefetch-git
+
+require 'set'
+require 'json'
+require 'uri'
+require 'shellwords'
+require 'erb'
+require 'rubygems'
+require 'curb'
+require 'nokogiri'
+
+# Performs a GET to an arbitrary address.
+# +url+:: the URL
+def get url, &block
+  curl = Curl::Easy.new(url) do |http|
+    http.follow_location = false
+    http.headers['User-Agent'] = 'nixpkgs dwarf fortress update bot'
+    yield http if block_given?
+  end
+
+  curl.perform
+  curl.body_str
+end
+
+# Performs a GET on the Github API.
+# +url+:: the relative URL to api.github.com
+def get_gh url, &block
+  ret = get URI.join('https://api.github.com/', url) do |http|
+    http.headers['Accept'] = 'application/vnd.github+json'
+    http.headers['Authorization'] = "Bearer #{ENV['GH_TOKEN']}" if ENV.include?('GH_TOKEN')
+    http.headers['X-GitHub-Api-Version'] = '2022-11-28'
+    yield http if block_given?
+  end
+  JSON.parse(ret, symbolize_names: true)
+end
+
+def normalize_keys hash
+  Hash[hash.map {
+    [
+      _1.to_s,
+      _2.is_a?(Hash) ? normalize_keys(_2) : _2
+    ]
+  }]
+end
+
+module Mergeable
+  # Merges this Mergeable with something else.
+  # +other+:: The other Mergeable.
+  def merge other
+    if !other
+      return self
+    end
+
+    if !other.is_a?(Mergeable) || self.members != other.members
+      raise "invalid right-hand operand for merge: #{other.members}"
+    end
+
+    hash = {}
+    self.members.each do |member|
+      if @@expensive && @@expensive.include?(member)
+        # Already computed
+        hash[member] = self[member]
+      elsif self[member] && self[member].is_a?(Mergeable)
+        # Merge it
+        hash[member] = self[member].merge(other[member])
+      elsif self[member] && self[member].is_a?(Hash)
+        hash[member] = Hash[other[member].map {
+          [_1, self[member][_1] && self[member][_1].is_a?(Mergeable) ? self[member][_1].merge(_2) : _2]
+        }]
+      else
+        # Compute it
+        hash[member] = other[member]
+      end
+    end
+    self.class.new(**hash)
+  end
+
+  # Marks some attributes as expensive.
+  def expensive *attrs
+    @@expensive ||= Set.new
+    attrs.each {@@expensive << _1}
+    self
+  end
+end
+
+module Versionable
+  # Parses the version.
+  def parsed_version
+    @version ||= Gem::Version.create(self.version.partition('-').first)
+  end
+
+  # Drops the last component of the version for chunking.
+  def major_version
+    @major_version ||= Gem::Version.create(self.parsed_version.canonical_segments[..-2].join('.'))
+  end
+
+  # Compares the major version.
+  def =~ other
+    self.major_version == other.major_version
+  end
+
+  # Negation of the above.
+  def !~ other
+    !(self =~ other)
+  end
+
+  # Compares two versions.
+  def <=> other
+    other.parsed_version <=> self.parsed_version
+  end
+end
+
+class DFUrl < Struct.new(:url, :output_hash, keyword_init: true)
+  include Mergeable
+  extend Mergeable
+
+  expensive :output_hash
+
+  # Converts this DFUrl to a hash.
+  def to_h
+    {
+      url: self.url,
+      outputHash: self.output_hash
+    }
+  end
+
+  # Returns or computes the output hash.
+  def output_hash
+    return super if super
+    self.output_hash = `nix-prefetch-url #{Shellwords.escape(self.url.to_s)} | xargs nix-hash --to-sri --type sha256`.strip
+    super
+  end
+
+  # Converts this DFUrl from a hash.
+  # +hash+:: The hash
+  def self.from_hash hash
+    DFUrl.new(
+      url: hash.fetch(:url),
+      output_hash: hash[:outputHash]
+    )
+  end
+end
+
+class DFGithub < Struct.new(:url, :revision, :output_hash, keyword_init: true)
+  include Mergeable
+  extend Mergeable
+
+  expensive :output_hash
+
+  # Converts this DFGithub to a hash.
+  def to_h
+    {
+      url: self.url,
+      revision: self.revision,
+      outputHash: self.output_hash
+    }
+  end
+
+  # Returns or computes the output hash.
+  def output_hash
+    return super if super
+    url = URI.parse(self.url.to_s)
+    if ENV['GH_TOKEN']
+      url.userinfo = ENV['GH_TOKEN']
+    end
+    self.output_hash = JSON.parse(`nix-prefetch-git --no-deepClone --fetch-submodules #{Shellwords.escape(url.to_s)} #{Shellwords.escape(self.revision.to_s)}`, symbolize_names: true).fetch(:hash)
+    super
+  end
+
+  # Converts a hash to a DFGithub.
+  # +hash+:: The hash
+  def self.from_hash hash
+    DFGithub.new(
+      url: hash.fetch(:url),
+      revision: hash.fetch(:revision),
+      output_hash: hash[:outputHash]
+    )
+  end
+end
+
+class DFVersion < Struct.new(:version, :urls, keyword_init: true)
+  include Mergeable
+  extend Mergeable
+  include Versionable
+
+  # Converts a DFVersion to a hash.
+  def to_h
+    {
+      version: self.version,
+      urls: Hash[self.urls.map {
+        [_1, _2.to_h]
+      }]
+    }
+  end
+
+  # Converts a hash to a DFVersion.
+  # +hash+:: The hash
+  def self.from_hash hash
+    DFVersion.new(
+      version: hash.fetch(:version),
+      urls: Hash[hash.fetch(:urls).map {
+        [_1, DFUrl.from_hash(_2)]
+      }]
+    )
+  end
+
+  # Converts an HTML node to a DFVersion.
+  # +base+:: The base URL for DF downloads.
+  # +node+:: The HTML node
+  def self.from_node base, node
+    match = node.text.match(/DF\s+(\d+\.\d+(?:\.\d+)?)/)
+    if match
+      systems = {}
+      node.css('a').each do |a|
+        case a['href']
+        when /osx\.tar/ then systems[:darwin] = DFUrl.new(url: URI.join(base, a['href']).to_s)
+        when /linux\.tar/ then systems[:linux] = DFUrl.new(url: URI.join(base, a['href']).to_s)
+        end
+      end
+
+      if systems.empty?
+        nil
+      else
+        DFVersion.new(version: match[1], urls: systems)
+      end
+    else
+      nil
+    end
+  end
+
+  # Returns all DFVersions from the download page.
+  # +cutoff+:: The minimum version
+  def self.all cutoff:
+    cutoff = Gem::Version.create(cutoff)
+
+    base = 'https://www.bay12games.com/dwarves/'
+    res = get URI.join(base, 'older_versions.html')
+    parsed = Nokogiri::HTML(res)
+
+    # Figure out which versions we care about.
+    parsed.css('p.menu').map {DFVersion.from_node(base, _1)}.select {
+      _1 && _1.parsed_version >= cutoff
+    }.sort.chunk {
+      _1.major_version
+    }.map {|*, versions|
+      versions.max_by {_1.parsed_version}
+    }.to_a
+  end
+end
+
+class DFHackVersion < Struct.new(:version, :git, :xml_rev, keyword_init: true)
+  include Mergeable
+  extend Mergeable
+  include Versionable
+
+  expensive :xml_rev
+
+  # Returns the download URL.
+  def git
+    return super if super
+    self.git = DFGithub.new(
+      url: "https://github.com/DFHack/dfhack.git",
+      revision: self.version
+    )
+    super
+  end
+
+  # Converts this DFHackVersion to a hash.
+  def to_h
+    {
+      version: self.version,
+      git: self.git.to_h,
+      xmlRev: self.xml_rev,
+    }
+  end
+
+  # Returns the revision number in the version. Defaults to 0.
+  def rev
+    return @rev if @rev
+    rev = self.version.match(/-r([\d\.]+)\z/)
+    @rev = rev[1].to_f if rev
+    @rev ||= 0
+    @rev
+  end
+
+  # Returns the XML revision, fetching it if necessary.
+  def xml_rev
+    return super if super
+    url = "repos/dfhack/dfhack/contents/library/xml?ref=#{URI.encode_uri_component(self.git.revision)}"
+    body = get_gh url
+    self.xml_rev = body.fetch(:sha)
+    super
+  end
+
+  # Compares two DFHack versions.
+  # +other+:: the other dfhack version
+  def <=> other
+    ret = super
+    ret = other.rev <=> self.rev if ret == 0
+    ret
+  end
+
+  # Returns a version from a hash.
+  # +hash+:: the hash
+  def self.from_hash hash
+    DFHackVersion.new(
+      version: hash.fetch(:version),
+      git: DFGithub.from_hash(hash.fetch(:git)),
+      xml_rev: hash[:xmlRev]
+    )
+  end
+
+  # Returns a release from a github object.
+  # +github_obj+:: The github object. Returns null for prereleases.
+  def self.from_github github_obj
+    if github_obj.fetch(:prerelease)
+      return nil
+    end
+    version = github_obj.fetch(:tag_name)
+    DFHackVersion.new(version: version)
+  end
+
+  # Returns all dfhack versions.
+  # +cutoff+:: The cutoff version.
+  def self.all cutoff:
+    cutoff = Gem::Version.create(cutoff)
+    ret = {}
+    (1..).each do |page|
+      url = "repos/dfhack/dfhack/releases?per_page=100&page=#{page}"
+      releases = get_gh url
+
+      releases.each do |release|
+        release = DFHackVersion.from_github(release)
+        if release && release.parsed_version >= cutoff
+          ret[release.major_version] ||= {}
+          ret[release.major_version][release.parsed_version] ||= []
+          ret[release.major_version][release.parsed_version] << release
+        end
+      end
+
+      break if releases.length < 1
+    end
+
+    ret.each do |_, dfhack_major_versions|
+      dfhack_major_versions.each do |_, dfhack_minor_versions|
+        dfhack_minor_versions.sort!
+      end
+    end
+
+    ret
+  end
+end
+
+class DFWithHackVersion < Struct.new(:df, :hack, keyword_init: true)
+  include Mergeable
+  extend Mergeable
+
+  # Converts this DFWithHackVersion to a hash.
+  def to_h
+    {
+      df: self.df.to_h,
+      hack: self.hack.to_h
+    }
+  end
+
+  # Converts a hash to a DFWithHackVersion.
+  # +hash+:: the hash to convert
+  def self.from_hash hash
+    DFWithHackVersion.new(
+      df: DFVersion.from_hash(hash.fetch(:df)),
+      hack: DFHackVersion.from_hash(hash.fetch(:hack))
+    )
+  end
+end
+
+class DFWithHackVersions < Struct.new(:latest, :versions, keyword_init: true)
+  include Mergeable
+  extend Mergeable
+
+  # Initializes this DFWithHackVersions.
+  def initialize *args, **kw
+    super *args, **kw
+    self.latest ||= {}
+    self.versions ||= {}
+  end
+
+  # Converts this DFWithHackVersions to a hash.
+  def to_h
+    {
+      latest: self.latest,
+      versions: Hash[self.versions.map {
+        [_1.to_s, _2.to_h]
+      }]
+    }
+  end
+
+  # Loads this DFWithHackVersions.
+  # +cutoff+:: The minimum version to load.
+  def load! cutoff:
+    df_versions = DFVersion.all(cutoff: cutoff)
+    dfhack_versions = DFHackVersion.all(cutoff: cutoff)
+
+    df_versions.each do |df_version|
+      latest_dfhack_version = nil
+      corresponding_dfhack_versions = dfhack_versions.dig(df_version.major_version, df_version.parsed_version)
+      if corresponding_dfhack_versions
+        latest_dfhack_version = corresponding_dfhack_versions.first
+      end
+
+      if latest_dfhack_version
+        df_version.urls.each do |platform, url|
+          if !self.latest[platform] || df_version.parsed_version > Gem::Version.create(self.latest[platform])
+            self.latest[platform] = df_version.version
+          end
+        end
+        self.versions[df_version.version] = DFWithHackVersion.new(df: df_version, hack: latest_dfhack_version)
+      end
+    end
+  end
+
+  # Converts a hash to a DFWithHackVersions.
+  # +hash+:: The hash
+  def self.from_hash hash
+    DFWithHackVersions.new(
+      latest: hash.fetch(:latest),
+      versions: Hash[hash.fetch(:versions).map {
+        [_1.to_s, DFWithHackVersion.from_hash(_2)]
+      }]
+    )
+  end
+end
+
+class Therapist < Struct.new(:version, :max_df_version, :git, keyword_init: true)
+  include Mergeable
+  extend Mergeable
+  include Versionable
+
+  expensive :max_df_version
+
+  # Converts this Therapist instance to a hash.
+  def to_h
+    {
+      version: self.version,
+      maxDfVersion: self.max_df_version,
+      git: self.git.to_h
+    }
+  end
+
+  # Returns the max supported DF version.
+  def max_df_version
+    return super if super
+    url = "repos/Dwarf-Therapist/Dwarf-Therapist/contents/share/memory_layouts/linux?ref=#{URI.encode_uri_component(self.git.revision)}"
+    body = get_gh url
+
+    # Figure out the max supported memory layout.
+    max_version = nil
+    max_version_str = nil
+    body.each do |item|
+      name = item[:name] || ""
+      match = name.match(/\Av(?:0\.)?(\d+\.\d+)-classic_linux\d*\.ini/)
+      if match
+        version = Gem::Version.create(match[1])
+        if !max_version || version > max_version
+          max_version = version
+          max_version_str = match[1]
+        end
+      end
+    end
+
+    self.max_df_version = max_version_str
+
+    super
+  end
+
+  # Returns a Github URL.
+  def git
+    return super if super
+    self.git = DFGithub.new(
+      url: "https://github.com/Dwarf-Therapist/Dwarf-Therapist.git",
+      revision: 'v' + self.version
+    )
+    super
+  end
+
+  # Loads this therapist instance from Github.
+  def load!
+    latest = self.class.latest
+    self.version = latest.version
+    self.max_df_version = latest.max_df_version
+    self.git = nil
+    self
+  end
+
+  # Loads a hash into this Therapist instance.
+  # +hash+: the hash
+  def self.from_hash hash
+    Therapist.new(
+      version: hash.fetch(:version),
+      max_df_version: hash[:maxDfVersion],
+      git: DFGithub.from_hash(hash.fetch(:git))
+    )
+  end
+
+  # Returns a release from a github object.
+  # +github_obj+:: The github object. Returns null for prereleases.
+  def self.from_github github_obj
+    if github_obj.fetch(:prerelease)
+      return nil
+    end
+
+    version = github_obj.fetch(:tag_name)
+    match = version.match(/\Av([\d\.]+)\z/)
+    if match
+      Therapist.new(version: match[1])
+    else
+      nil
+    end
+  end
+
+  # Returns the latest Therapist version.
+  def self.latest
+    url = "repos/Dwarf-Therapist/Dwarf-Therapist/releases"
+    releases = get_gh url
+
+    releases.each do |release|
+      release = Therapist.from_github(release)
+      if release
+        return release
+      end
+    end
+
+    nil
+  end
+end
+
+class DFLock < Struct.new(:game, :therapist, keyword_init: true)
+  include Mergeable
+  extend Mergeable
+
+  # Initializes this DFLock.
+  def initialize *args, **kw
+    super *args, **kw
+    self.game ||= DFWithHackVersions.new
+    self.therapist ||= Therapist.new
+  end
+
+  # Converts this DFLock to a hash.
+  def to_h
+    {
+      game: self.game.to_h,
+      therapist: self.therapist.to_h
+    }
+  end
+
+  # Returns an array containing all versions.
+  def all_versions
+    self.game.versions.keys.map {"DF #{_1}"}.to_a + ["DT #{self.therapist.version}"]
+  end
+
+  # Loads this DFLock.
+  # +cutoff+:: The minimum DF version to load.
+  def load! cutoff:
+    self.game.load! cutoff: cutoff
+    self.therapist.load!
+  end
+
+  # Converts a hash to a DFLock.
+  # +hash+:: The hash
+  def self.from_hash hash
+    DFLock.new(
+      game: DFWithHackVersions.from_hash(hash.fetch(:game)),
+      therapist: Therapist.from_hash(hash.fetch(:therapist))
+    )
+  end
+end
+
+# 0.43 and below has a broken dfhack.
+new_df_lock = DFLock.new
+new_df_lock.load! cutoff: '0.44'
+
+df_lock_file = File.join(__dir__, 'df.lock.json')
+df_lock, df_lock_json = if File.file?(df_lock_file)
+                          json = JSON.parse(File.read(df_lock_file), symbolize_names: true)
+                          [DFLock.from_hash(json), json]
+                        else
+                          [DFLock.new, {}]
+                        end
+
+new_df_lock_json = df_lock.merge(new_df_lock).to_h
+json = JSON.pretty_generate(new_df_lock_json)
+json << "\n"
+STDERR.puts json
+File.write(df_lock_file, json)
+
+# See if there were any changes.
+changed_paths = []
+if normalize_keys(df_lock_json) != normalize_keys(new_df_lock_json)
+  all_old_versions = df_lock.all_versions
+  all_new_versions = new_df_lock.all_versions
+  just_old_versions = all_old_versions - all_new_versions
+  just_new_versions = all_new_versions - all_old_versions
+  changes = just_old_versions.zip(just_new_versions)
+
+  template = ERB.new(<<-EOF, trim_mode: '<>-')
+dwarf-fortress-packages: <%= changes.map {|old, new| '%s -> %s' % [old, new]}.join('; ') %>
+
+Performed the following automatic DF updates:
+
+<% changes.each do |old, new| %>
+- <%= old -%> -> <%= new -%>
+<% end %>
+EOF
+
+  changed_paths << {
+    attrPath: 'dwarf-fortress-packages',
+    oldVersion: just_old_versions.join('; '),
+    newVersion: just_new_versions.join('; '),
+    files: [
+      File.realpath(df_lock_file)
+    ],
+    commitMessage: template.result(binding)
+  }
+end
+
+STDOUT.puts JSON.pretty_generate(changed_paths)

pkgs/games/dwarf-fortress/update.sh

···
-#!/usr/bin/env nix-shell
-#! nix-shell -i bash -p jq nix coreutils curl
-
-# systems to generate hashes for
-systems='linux osx'
-
-if [ $# -eq 0 ]; then
-    versions="$(curl http://www.bay12games.com/dwarves/ \
-           | grep 'DWARF FORTRESS CLASSIC ' \
-           | sed 's/.*DWARF FORTRESS CLASSIC \([0-9.]*\) .*/\1/')"
-else
-    versions="$@"
-fi
-
-tmp1="$(mktemp)"
-tmp2="$(mktemp)"
-for version in $versions; do
-    for system in $systems; do
-    echo -n $version,$system,
-    ver=$(echo $version | sed -e s,^0\.,, | tr . _)
-    if [[ "$system" = *win* ]] || [[ "$system" = *legacy* ]]; then
-        ext=zip
-    else
-        ext=tar.bz2
-    fi
-    nix-prefetch-url \
-        http://www.bay12games.com/dwarves/df_${ver}_${system}.${ext}
-    done
-done | jq --slurp --raw-input \
-      'split("\n")  | .[:-1] | map(split(",")) |
-           map({ "version": .[0], "platform": .[1], "sha256": .[2] }) |
-       group_by(.version) |
-       map(map({"version": .version, (.platform): .sha256}) | add |
-           {(.version): .} | map_values(del(.version))) | add' \
-      > "$tmp1"
-
-# Append $tmp1 to game.json. There should be a better way to handle
-# this but all other attempts failed for me.
-jq -M --slurpfile a "$tmp1" '. + $a[]' < "$(dirname "$0")/game.json" > "$tmp2"
-cat "$tmp2" > "$(dirname "$0")/game.json"

pkgs/games/dwarf-fortress/wrapper/default.nix

···
   gawk,
   dwarf-fortress,
   dwarf-therapist,
+  SDL2_mixer,
   enableDFHack ? false,
   dfhack,
   enableSoundSense ? false,
   soundSense,
-  jdk,
+  jre,
   expect,
   xvfb-run,
   writeText,
···
   "dwarf-fortress: text mode and TWBT are mutually exclusive"
 
   stdenv.mkDerivation
-  rec {
+  {
     pname = "dwarf-fortress";
     version = dwarf-fortress.dfVersion;
 
···
       mkdir = "${coreutils}/bin/mkdir";
       printf = "${coreutils}/bin/printf";
       uname = "${coreutils}/bin/uname";
+      SDL2_mixer = "${SDL2_mixer}/lib/libSDL2_mixer.so";
     };
 
     runDF = ./dwarf-fortress.in;
···
       + lib.optionalString enableSoundSense ''
         substitute $runSoundSense $out/bin/soundsense \
           --subst-var-by stdenv_shell ${stdenv.shell} \
-          --subst-var-by jre ${jdk.jre} \
+          --subst-var-by jre ${jre} \
           --subst-var dfInit
         chmod 755 $out/bin/soundsense
       '';
···
 
     installCheckPhase =
       let
-        commonExpectStatements =
-          fmod:
-          lib.optionalString isAtLeast50 ''
-            expect "Loading audio..."
-          ''
-          + lib.optionalString (!fmod && isAtLeast50) ''
-            expect "Failed to load fmod, trying SDL_mixer"
-          ''
-          + lib.optionalString isAtLeast50 ''
-            expect "Audio loaded successfully!"
-          ''
-          + ''
-            expect "Loading bindings from data/init/interface.txt"
-          '';
+        commonExpectStatements = ''
+          expect "Loading bindings from data/init/interface.txt"
+        '';
         dfHackExpectScript = writeText "dfhack-test.exp" (
           ''
             spawn env NIXPKGS_DF_OPTS=debug xvfb-run $env(out)/bin/dfhack
           ''
-          + commonExpectStatements false
+          + commonExpectStatements
           + ''
             expect "DFHack is ready. Have a nice day!"
-            expect "DFHack version ${version}"
+            expect "DFHack version ${dfhack'.version}"
             expect "\[DFHack\]#"
             send -- "lua print(os.getenv('out'))\r"
             expect "$env(out)"
···
             ''
               spawn env NIXPKGS_DF_OPTS=debug,${lib.optionalString fmod "fmod"} xvfb-run $env(out)/bin/dwarf-fortress
             ''
-            + commonExpectStatements fmod
+            + commonExpectStatements
             + ''
               exit 0
             ''

pkgs/games/dwarf-fortress/wrapper/dwarf-fortress-init.in

···
   cd "$NIXPKGS_DF_HOME"
   debug "Executing: $NIXPKGS_DF_HOME/$NIXPKGS_DF_EXE"
 
+  # Only mess with the library paths if we're starting Dwarf Fortress (not Soundsense).
+  if [ "$NIXPKGS_DF_GAME" -eq 1 ]; then
+    # Handle library paths on Darwin.
+    if [ "$NIXPKGS_DF_PLATFORM" == df_osx ]; then
+      if [ "${NIXPKGS_DF_PLATFORM_REV%%.*}" -ge 11 ]; then
+        export DYLD_LIBRARY_PATH="$NIXPKGS_DF_ENV/libs"
+        export DYLD_FRAMEWORK_PATH="$NIXPKGS_DF_ENV/libs"
+      else
+        export DYLD_FALLBACK_LIBRARY_PATH="$NIXPKGS_DF_ENV/libs"
+        export DYLD_FALLBACK_FRAMEWORK_PATH="$NIXPKGS_DF_ENV/libs"
+      fi
+    fi
+
+    if [ "$NIXPKGS_DF_PLATFORM" == df_linux ]; then
+      # We have to preload the audio plugin for audio to work. See Nix Pill #12 for this pattern:
+      # https://nixos.org/guides/nix-pills/12-inputs-design-pattern.html
+      if [ "${_NIXPKGS_DF_OPTS[fmod]}" -eq 0 ] && [ -f "$NIXPKGS_DF_HOME/libfmod.so.13" ]; then
+        export LD_PRELOAD="$NIXPKGS_DF_HOME/libfmod.so.13${LD_PRELOAD:+:}${LD_PRELOAD:-}"
+      else
+        export LD_PRELOAD="@SDL2_mixer@${LD_PRELOAD:+:}${LD_PRELOAD:-}"
+      fi
+    fi
+  fi
+
   # If we make it past here, we want to log.
   # shellcheck disable=SC2093
-  exec -a "$NIXPKGS_DF_EXE" "$NIXPKGS_DF_HOME/$NIXPKGS_DF_EXE"
+  exec -a "$NIXPKGS_DF_EXE" "$NIXPKGS_DF_HOME/$NIXPKGS_DF_EXE" "$@"
   log "Execution of $NIXPKGS_DF_HOME/$NIXPKGS_DF_EXE failed!"
   exit 1
 }
 
+# Figure out the Dwarf Fortress directory (df_linux or df_osx).
 os_name="$(@uname@)"
-os_rev="$(@uname@ -r)"
-
 if [ "$os_name" == Linux ]; then
-  df_dir="df_linux"
+  export NIXPKGS_DF_PLATFORM="df_linux"
 elif [ "$os_name" == Darwin ]; then
-  df_dir="df_osx"
+  export NIXPKGS_DF_PLATFORM="df_osx"
 else
   log "Unknown platform: $os_name"
   exit 1
 fi
+export NIXPKGS_DF_PLATFORM_REV="$(@uname@ -r)"
 
 if [[ -v DF_DIR ]] && [ -n "$DF_DIR" ] && { [[ ! -v NIXPKGS_DF_HOME ]] || [ -z "$NIXPKGS_DF_HOME" ]; }; then
   # Compatibility for users that were using DF_DIR, since the dfhack script clobbers this variable.
···
 fi
 
 if [[ ! -v NIXPKGS_DF_HOME ]] || [ -z "$NIXPKGS_DF_HOME" ]; then
-  export NIXPKGS_DF_HOME="${XDG_DATA_HOME:-$HOME/.local/share}/$df_dir"
+  export NIXPKGS_DF_HOME="${XDG_DATA_HOME:-$HOME/.local/share}/$NIXPKGS_DF_PLATFORM"
 fi
 
 # Compatibility.
···
 EOF
 
 cd "$NIXPKGS_DF_ENV"
-
-# All potential important files in DF 50 and below.
-for path in dwarfort dwarfort.exe df *.so libs raw data/init/* data/!(init|index|announcement); do
-  force_delete=0
-  if [[ "$path" == libfmod*.so* ]] && [ "${_NIXPKGS_DF_OPTS[fmod]}" -eq 0 ]; then
-    force_delete=1
-  fi
-
-  if [ -e "$path" ] && [ "$force_delete" -eq 0 ]; then
-    update_path "$path"
-  else
-    cleanup_path "$path"
-  fi
-done
-
-# These need to be copied due to read only flags on older versions of DF.
-for path in index announcement help dipscript; do
-  forcecopy_path "data/$path"
-done
-
-# Handle library paths on Darwin.
-if [ "$os_name" == Darwin ]; then
-  if [ "${os_rev%%.*}" -ge 11 ]; then
-    export DYLD_LIBRARY_PATH="$NIXPKGS_DF_ENV/libs"
-    export DYLD_FRAMEWORK_PATH="$NIXPKGS_DF_ENV/libs"
-  else
-    export DYLD_FALLBACK_LIBRARY_PATH="$NIXPKGS_DF_ENV/libs"
-    export DYLD_FALLBACK_FRAMEWORK_PATH="$NIXPKGS_DF_ENV/libs"
-  fi
-fi

pkgs/games/dwarf-fortress/wrapper/dwarf-fortress.in

···
 #!@stdenv_shell@ -e
 
 export NIXPKGS_DF_EXE="@dfExe@"
+export NIXPKGS_DF_GAME=1
 source @dfInit@
+
+# All potential important files in DF 50 and below.
+for path in dwarfort dwarfort.exe df *.so* libs raw data/init/* data/!(init|index|announcement); do
+  force_delete=0
+  if [[ "$path" == *fmod*.so* ]] && [ "${_NIXPKGS_DF_OPTS[fmod]}" -eq 0 ]; then
+    # Delete fmod plugins if we're using SDL_mixer.
+    force_delete=1
+  elif [[ "$path" == *mixer*.so* ]] && [ "${_NIXPKGS_DF_OPTS[fmod]}" -ne 0 ]; then
+    # Delete SDL_mixer plugins if we're using fmod.
+    force_delete=1
+  fi
+
+  if [ -e "$path" ] && [ "$force_delete" -eq 0 ]; then
+    update_path "$path"
+  else
+    cleanup_path "$path"
+  fi
+done
+
+# These need to be copied due to read only flags on older versions of DF.
+for path in index announcement help dipscript; do
+  forcecopy_path "data/$path"
+done
 
 # If we're switching back from dfhack to vanilla, cleanup all dfhack
 # links so Dwarf Fortress doesn't autoload its leftover libdfhooks.so.
···
   done
 fi
 
-go
+go "$@"

pkgs/games/dwarf-fortress/wrapper/soundSense.in

···
 #!@stdenv_shell@ -e
 
 export NIXPKGS_DF_EXE="soundsense/soundSense.sh"
+export NIXPKGS_DF_GAME=0
 source @dfInit@
 
 for path in soundsense/*; do
   update_path "$path"
 done
 
-PATH="@jre@/bin:$PATH" go
+JDK_JAVA_OPTIONS='--add-opens=java.xml/com.sun.org.apache.xerces.internal.parsers=ALL-UNNAMED' PATH="@jre@/bin:$PATH" go "$@"

pkgs/kde/third-party/krohnkite/default.nix

···
 {
   lib,
+  nix-update-script,
   buildNpmPackage,
   fetchFromGitHub,
   nodejs_22,
···
   kpackage,
   zip,
 }:
-buildNpmPackage rec {
+buildNpmPackage (finalAttrs: {
   pname = "krohnkite";
-  version = "0.9.8.5";
+  version = "0.9.9.0";
 
   src = fetchFromGitHub {
     owner = "anametologin";
     repo = "krohnkite";
-    tag = version;
-    hash = "sha256-DcNU0nx6KHztfMPFs5PZtZIeu4hDxNYIJa5E1fwMa0Q=";
+    tag = finalAttrs.version;
+    hash = "sha256-23GNKxP/ItGJgElS8gK2lMMkjZ/3LITr40LXo9/o6Iw=";
   };
 
   npmDepsHash = "sha256-Q/D6s0wOPSEziE1dBXgTakjhXCGvzhvLVS7zXcZlPCI=";
···
     runHook preInstall
 
     substituteInPlace Makefile --replace-fail '7z a -tzip' 'zip -r'
-    make KWINPKG_FILE=krohnkite.kwinscript krohnkite.kwinscript
+    # Override PROJECT_VER and PROJECT_REV because we don't have .git
+    make \
+      KWINPKG_FILE=krohnkite.kwinscript \
+      PROJECT_REV=${finalAttrs.version} \
+      PROJECT_VER=${finalAttrs.version} \
+      krohnkite.kwinscript
     kpackagetool6 --type=KWin/Script --install=krohnkite.kwinscript --packageroot=$out/share/kwin/scripts
 
     runHook postInstall
   '';
 
+  passthru.updateScript = nix-update-script { };
+
   meta = {
     description = "Dynamic Tiling Extension for KWin 6";
     homepage = "https://github.com/anametologin/krohnkite";
+    changelog = "https://github.com/anametologin/krohnkite/releases/tag/${finalAttrs.version}";
     license = lib.licenses.mit;
-    maintainers = with lib.maintainers; [ ben9986 ];
+    maintainers = with lib.maintainers; [
+      ben9986
+      dramforever
+    ];
     platforms = lib.platforms.all;
   };
-}
+})

pkgs/misc/documentation-highlighter/mono-blue.css

···
 pre code.hljs {
-  display: block;
-  overflow-x: auto;
-  padding: 1em
+    display: block;
+    overflow-x: auto;
+    padding: 1em;
 }
 code.hljs {
-  padding: 3px 5px
+    padding: 3px 5px;
 }
 /*
   Five-color theme from a single blue hue.
 */
 .hljs {
-  background: #eaeef3;
-  color: #00193a
+    background: #eaeef3;
+    color: #00193a;
 }
 .hljs-keyword,
 .hljs-selector-tag,
···
 .hljs-doctag,
 .hljs-name,
 .hljs-strong {
-  font-weight: bold
+    font-weight: bold;
 }
 .hljs-comment {
-  color: #738191
+    color: var(--color-1);
 }
 .hljs-string,
 .hljs-title,
···
 .hljs-name,
 .hljs-selector-id,
 .hljs-selector-class {
-  color: #0048ab
+    color: var(--color-2);
 }
 .hljs-meta,
 .hljs-subst,
···
 .hljs-template-variable,
 .hljs-link,
 .hljs-bullet {
-  color: #4c81c9
+    color: var(--color-3);
 }
 .hljs-emphasis {
-  font-style: italic
-}
+    font-style: italic;
+}
+
+:root {
+    --color-1: #738191;
+    --color-2: #0048ab;
+    --color-3: #4c81c9;
+}
+
+@media (prefers-color-scheme: dark) {
+    :root {
+        --color-1: #8b9caf;
+        --color-2: #3b85e7;
+        --color-3: #5795e7;
+    }
+}

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

···
+{
+  lib,
+  fetchFromGitHub,
+  buildHomeAssistantComponent,
+}:
+
+buildHomeAssistantComponent rec {
+  owner = "thomasddn";
+  domain = "volvo_cars";
+  version = "1.5.1";
+
+  src = fetchFromGitHub {
+    owner = "thomasddn";
+    repo = "ha-volvo-cars";
+    tag = "v${version}";
+    hash = "sha256-UG/anp9ThEOQsRWraTayuyx6kS9r2vTH/8Bak4ZzYzo";
+  };
+
+  meta = with lib; {
+    changelog = "https://github.com/thomasddn/ha-volvo-cars/releases/tag/${src.tag}";
+    homepage = "https://github.com/thomasddn/ha-volvo-cars";
+    description = "Volvo Cars Home Assistant integration";
+    maintainers = with maintainers; [ seberm ];
+    license = licenses.gpl3Only;
+  };
+}

pkgs/servers/monitoring/grafana/plugins/grafana-lokiexplore-app/default.nix

···
+{ grafanaPlugin, lib }:
+
+grafanaPlugin {
+  pname = "grafana-lokiexplore-app";
+  version = "1.0.10";
+  zipHash = "sha256-1+5xil0XmcLCDKpObuxpnoMnQZaT1I62zL6xatlyKc4=";
+  meta = with lib; {
+    description = "The Grafana Logs Drilldown app offers a queryless experience for browsing Loki logs without the need for writing complex queries.";
+    license = licenses.agpl3Only;
+    maintainers = lib.teams.fslabs.members;
+    platforms = platforms.unix;
+  };
+}

pkgs/servers/monitoring/grafana/plugins/plugins.nix

···
   grafana-discourse-datasource = callPackage ./grafana-discourse-datasource { };
   grafana-github-datasource = callPackage ./grafana-github-datasource { };
   grafana-googlesheets-datasource = callPackage ./grafana-googlesheets-datasource { };
+  grafana-lokiexplore-app = callPackage ./grafana-lokiexplore-app { };
   grafana-mqtt-datasource = callPackage ./grafana-mqtt-datasource { };
   grafana-oncall-app = callPackage ./grafana-oncall-app { };
   grafana-opensearch-datasource = callPackage ./grafana-opensearch-datasource { };

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

···
 
 postgresqlBuildExtension (finalAttrs: {
   pname = "timescaledb${lib.optionalString (!enableUnfree) "-apache"}";
-  version = "2.19.2";
+  version = "2.19.3";
 
   src = fetchFromGitHub {
     owner = "timescale";
     repo = "timescaledb";
     tag = finalAttrs.version;
-    hash = "sha256-H46lhvM6rA9J4nLRLeFArCc7tqmVmpWztsGFAboSM0k=";
+    hash = "sha256-CMK9snkMXsXqmq3f1hTDYCduL0arwM7XyIg4xq6UfR8=";
   };
 
   nativeBuildInputs = [ cmake ];

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

···
   inherit postgresql;
 
   pname = "timescaledb_toolkit";
-  version = "1.19.0";
+  version = "1.21.0";
 
   src = fetchFromGitHub {
     owner = "timescale";
     repo = "timescaledb-toolkit";
     tag = finalAttrs.version;
-    hash = "sha256-7yUbtWbYL4AnuUX8OXG4OVqYCY2Lf0pISSTlcFdPqog=";
+    hash = "sha256-gGGSNvvJprqLkVwPr7cfmGY1qEUTXMdqdvwPYIzXaTA=";
   };
 
   useFetchCargoVendor = true;
-  cargoHash = "sha256-g5pIIifsJAs0C02o/+y+ILLnTXFqwG9tZcvY6NqfnDA=";
+  cargoHash = "sha256-kyUpfNEXJ732VO6JDxU+dIoL57uWzG4Ff03/GnvsxLE=";
   buildAndTestSubdir = "extension";
 
   passthru = {
···
     maintainers = with lib.maintainers; [ typetetris ];
     platforms = postgresql.meta.platforms;
     license = lib.licenses.tsl;
+    broken = lib.versionOlder postgresql.version "15";
   };
 })

pkgs/servers/web-apps/discourse/default.nix

···
   bundlerEnv,
   callPackage,
 
-  ruby_3_2,
+  ruby_3_3,
   replace,
   gzip,
   gnutar,
···
   procps,
   rsync,
   icu,
-  fetchYarnDeps,
-  yarn,
-  fixup-yarn-lock,
+  pnpm_9,
   nodePackages,
-  nodejs_18,
+  nodejs,
   jq,
   moreutils,
   terser,
···
 }@args:
 
 let
-  version = "3.3.2";
+  version = "3.4.2";
 
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse";
     rev = "v${version}";
-    sha256 = "sha256-FaPcUta5z/8oasw+9zGBRZnUVYD8eCo1t/XwwsFoSM8=";
+    sha256 = "sha256-glTuY9aQ7wYvFZstOP579RkdSwKKh3q9mJt4wqg3zYk=";
   };
 
-  ruby = ruby_3_2;
+  ruby = ruby_3_3;
 
   runtimeDeps = [
     # For backups, themes and assets
···
     gnutar
     git
     brotli
-    nodejs_18
+    nodejs
 
     # Misc required system utils
     which
···
               cd ../..
 
               mkdir -p vendor/v8/${stdenv.hostPlatform.system}/libv8/obj/
-              ln -s "${nodejs_18.libv8}/lib/libv8.a" vendor/v8/${stdenv.hostPlatform.system}/libv8/obj/libv8_monolith.a
+              ln -s "${nodejs.libv8}/lib/libv8.a" vendor/v8/${stdenv.hostPlatform.system}/libv8/obj/libv8_monolith.a
 
-              ln -s ${nodejs_18.libv8}/include vendor/v8/include
+              ln -s ${nodejs.libv8}/include vendor/v8/include
 
               mkdir -p ext/libv8-node
               echo '--- !ruby/object:Libv8::Node::Location::Vendor {}' >ext/libv8-node/.location.yml
···
     pname = "discourse-assets";
     inherit version src;
 
-    yarnOfflineCache = fetchYarnDeps {
-      yarnLock = src + "/yarn.lock";
-      hash = "sha256-cSQofaULCmPuWGxS+hK4KlRq9lSkCPiYvhax9X6Dor8=";
+    pnpmDeps = pnpm_9.fetchDeps {
+      pname = "discourse-assets";
+      inherit version src;
+      hash = "sha256-WyRBnuKCl5NJLtqy3HK/sJcrpMkh0PjbasGPNDV6+7Y=";
     };
 
     nativeBuildInputs = runtimeDeps ++ [
···
       redis
       uglify-js
       terser
-      yarn
       jq
       moreutils
-      fixup-yarn-lock
+      nodejs
+      pnpm_9.configHook
     ];
 
     outputs = [
···
     # run. This means that Redis and PostgreSQL has to be running and
     # database migrations performed.
     preBuild = ''
-      # Yarn wants a real home directory to write cache, config, etc to
-      export HOME=$NIX_BUILD_TOP/fake_home
-
-      yarn_install() {
-        local offlineCache=$1 yarnLock=$2
-
-        # Make yarn install packages from our offline cache, not the registry
-        yarn config --offline set yarn-offline-mirror $offlineCache
-
-        # Fixup "resolved"-entries in yarn.lock to match our offline cache
-        fixup-yarn-lock $yarnLock
-
-        # Install while ignoring hook scripts
-        yarn --offline --ignore-scripts --cwd $(dirname $yarnLock) install
-      }
-
-      # Install runtime and devDependencies.
-      # The dev deps are necessary for generating the theme-transpiler executed as dependent task
-      # assets:precompile:theme_transpiler before db:migrate and unfortunately also in the runtime
-      yarn_install $yarnOfflineCache yarn.lock
-
       # Patch before running postinstall hook script
       patchShebangs node_modules/
       patchShebangs --build app/assets/javascripts
-      yarn --offline --cwd app/assets/javascripts run postinstall
       export SSL_CERT_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt
 
       redis-server >/dev/null &
···
 
       runHook postInstall
     '';
+
+    # The node_modules output by design has broken symlinks, as it refers to the source code.
+    # They are resolved in the primary discourse derivation.
+    dontCheckForBrokenSymlinks = true;
   };
 
   discourse = stdenv.mkDerivation {
···
       ln -sf /var/lib/discourse/tmp $out/share/discourse/tmp
       ln -sf /run/discourse/config $out/share/discourse/config
       ln -sf /run/discourse/public $out/share/discourse/public
-      # This needs to be copied because of symlinks in node_modules
-      # Also this needs to be full node_modules (including dev deps) because without loader.js it just throws 500
-      cp -r ${assets.node_modules} $out/share/discourse/node_modules
+      ln -sf ${assets.node_modules} $out/share/discourse/node_modules
       ln -sf ${assets} $out/share/discourse/public.dist/assets
       rm -r $out/share/discourse/app/assets/javascripts
-      ln -sf ${assets.javascripts} $out/share/discourse/app/assets/javascripts
+      # This needs to be copied because it contains symlinks to node_modules
+      cp -r ${assets.javascripts} $out/share/discourse/app/assets/javascripts
       ${lib.concatMapStringsSep "\n" (
         p: "ln -sf ${p} $out/share/discourse/plugins/${p.pluginName or ""}"
       ) plugins}
···
       maintainers = with maintainers; [ talyz ];
       license = licenses.gpl2Plus;
       description = "Discourse is an open source discussion platform";
-      # fails to compile mini_racer:
-      # mini_racer_v8.cc:316:45: error: no matching function for call to 'v8::ScriptOrigin::ScriptOrigin(v8::Local<v8::String>&)'
-      broken = true;
     };
   };
 in

pkgs/servers/web-apps/discourse/plugins/discourse-assign/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-assign";
-    rev = "6472f4593e1a4abbb457288db012ddb10f0b16f5";
-    sha256 = "sha256-+jcL/6ddXldUG0VvcWiEMaFk0f37HyOf+bOFEMzuoXo=";
+    rev = "bf2a4bdb3ea4e26ec493d8dbc1f4cc8680f6c543";
+    sha256 = "sha256-inoANPG7xlKdhnuyoRay7Oyz7OSZWzphWS599kNP4Uo=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-docs";

pkgs/servers/web-apps/discourse/plugins/discourse-bbcode-color/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-bbcode-color";
-    rev = "6a26e5937b48bbf3ca9bd19e4f40adc513bcd774";
-    sha256 = "sha256-dWXvCZLxhCxte/88EnYOsy1gjBWjk24BjUM01s55CaU=";
+    rev = "ecd4befeb4eae48aa0a37a88e5aca60e59730411";
+    sha256 = "sha256-enpeXc6pE9+5EdbMIFsnWd++ixlHBKFRxbXmvJYJftg=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-bbcode-color";

pkgs/servers/web-apps/discourse/plugins/discourse-calendar/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-calendar";
-    rev = "908ad614bc412f831f929ca726a4bda0b9ccaab6";
-    sha256 = "sha256-ZzzcmTY/w9wa5wTR7ofJiNVmXwoKTKaKN202O80DO9g=";
+    rev = "c1031224a552ea01958d153350c2d1254b323579";
+    sha256 = "sha256-xwaYoJpBBvbmuPsDLxczLPXU862OVcirxeYpW5sfy5A=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-calendar";

pkgs/servers/web-apps/discourse/plugins/discourse-chat-integration/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-chat-integration";
-    rev = "e19808d4ad3f7d16cd9b93f315ca586f694e6288";
-    sha256 = "sha256-EplT9bQFtOvraSkFpBpe7TyNLROsdcRXz79j4MNPEs4=";
+    rev = "29ad813cd04812786780e1706cbc043810dea7d8";
+    sha256 = "sha256-5mGnHLlw3qIGi8et3WV1RXnrPB+bySi3wQryKTa5wNg=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-chat-integration";

pkgs/servers/web-apps/discourse/plugins/discourse-data-explorer/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-data-explorer";
-    rev = "2d0dc39767f0c68d333f113c550731a5546c3137";
-    sha256 = "sha256-3eQDMzTjfcSip94BXy1/VcbulsTsL1EHjRs41c27+ns=";
+    rev = "2ba204a1de2638a7959e588b88f3b6c7fcf7a70f";
+    sha256 = "sha256-u8yGKANEyqm63/ZnJLe3u1nkNGZyX0wFUBIKU5GgjzY=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-data-explorer";

pkgs/servers/web-apps/discourse/plugins/discourse-docs/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-docs";
-    rev = "7721b1646dead4719c02868ef7965f1b27c74eb3";
-    sha256 = "sha256-k2m88wsUmxAXC2LLvElwHVlMp6UzGSLDzEB+HJmKm5g=";
+    rev = "4e42539cda9a54d7827bcdf51b6dfbcf56d24cc9";
+    sha256 = "sha256-sv9Q0qEQVncQw3QLiro5YfVcHJAG8sJ0GTjduCZ0iP4=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-docs";

pkgs/servers/web-apps/discourse/plugins/discourse-github/Gemfile.lock

···
   specs:
     addressable (2.8.7)
       public_suffix (>= 2.0.2, < 7.0)
-    faraday (2.12.0)
-      faraday-net_http (>= 2.0, < 3.4)
+    faraday (2.12.3)
+      faraday-net_http (>= 2.0, < 3.5)
       json
       logger
-    faraday-net_http (3.3.0)
-      net-http
-    json (2.7.3)
-    logger (1.6.1)
-    net-http (0.4.1)
+    faraday-net_http (3.4.0)
+      net-http (>= 0.5.0)
+    json (2.10.2)
+    logger (1.7.0)
+    net-http (0.6.0)
       uri
     octokit (5.6.1)
       faraday (>= 1, < 3)
···
     sawyer (0.9.2)
       addressable (>= 2.3.5)
       faraday (>= 0.17.3, < 3)
-    uri (0.13.1)
+    uri (1.0.3)
 
 PLATFORMS
   ruby
···
   sawyer (= 0.9.2)
 
 BUNDLED WITH
-   2.4.22
+   2.5.22

pkgs/servers/web-apps/discourse/plugins/discourse-github/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-github";
-    rev = "e24de3f5cd6ec5cef17dc3e07dfb3bfac8867e08";
-    sha256 = "sha256-MbVYIsO2m0O5FriF5HphNhLcazgAJzIsl0aVd2YQGaA=";
+    rev = "59e5fc5692959c6c564ab0e09de364ccfedd6702";
+    sha256 = "sha256-b+8eSw8Kbz2CZN16Rd7c8uyH5P1iYhOJmdXu1C5UclU=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-github";

pkgs/servers/web-apps/discourse/plugins/discourse-github/gemset.nix

···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "05s5pyxh7y68jphb0lgrh0ksxbp4lmbsc6a6qg0ahj15pjqx01ni";
+      sha256 = "0dxalpc0ldvjjmd7z95na9lm99d2baz48sf9axk3a6x3pn50ibdi";
       type = "gem";
     };
-    version = "2.12.0";
+    version = "2.12.3";
   };
   faraday-net_http = {
     dependencies = [ "net-http" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0rg54k4skaz8z7j358p6pdzc9pr84fjq7sdlpicf7s5ig7vb1rlk";
+      sha256 = "0jp5ci6g40d6i50bsywp35l97nc2fpi9a592r2cibwicdb6y9wd1";
       type = "gem";
     };
-    version = "3.3.0";
+    version = "3.4.0";
   };
   json = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1prbjd8r4rq6hjc6d5hn8hlpf4g9h62swxj7absjac7qqnzwrhvw";
+      sha256 = "01lbdaizhkxmrw4y8j3wpvsryvnvzmg0pfs56c52laq2jgdfmq1l";
       type = "gem";
     };
-    version = "2.7.3";
+    version = "2.10.2";
   };
   logger = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0lwncq2rf8gm79g2rcnnyzs26ma1f4wnfjm6gs4zf2wlsdz5in9s";
+      sha256 = "00q2zznygpbls8asz5knjvvj2brr3ghmqxgr83xnrdj4rk3xwvhr";
       type = "gem";
     };
-    version = "1.6.1";
+    version = "1.7.0";
   };
   net-http = {
     dependencies = [ "uri" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "10n2n9aq00ih8v881af88l1zyrqgs5cl3njdw8argjwbl5ggqvm9";
+      sha256 = "1ysrwaabhf0sn24jrp0nnp51cdv0jf688mh5i6fsz63q2c6b48cn";
       type = "gem";
     };
-    version = "0.4.1";
+    version = "0.6.0";
   };
   octokit = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "07ndgxyhzd02cg94s6rnfhkb9rwx9z72lzk368sa9j78wc9qnbfz";
+      sha256 = "04bhfvc25b07jaiaf62yrach7khhr5jlr5bx6nygg8pf11329wp9";
       type = "gem";
     };
-    version = "0.13.1";
+    version = "1.0.3";
   };
 }

pkgs/servers/web-apps/discourse/plugins/discourse-ldap-auth/Gemfile

···
 # gem "rails"
 gem 'pyu-ruby-sasl', '0.0.3.3', require: false
 gem 'rubyntlm', '0.3.4', require: false
-gem 'net-ldap', '0.17.1'
-gem 'omniauth-ldap', '1.0.5'
+gem 'net-ldap', '0.18.0'

pkgs/servers/web-apps/discourse/plugins/discourse-ldap-auth/Gemfile.lock

···
 GEM
   remote: https://rubygems.org/
   specs:
-    hashie (5.0.0)
-    net-ldap (0.17.1)
-    omniauth (1.9.2)
-      hashie (>= 3.4.6)
-      rack (>= 1.6.2, < 3)
-    omniauth-ldap (1.0.5)
-      net-ldap (~> 0.12)
-      omniauth (~> 1.0)
-      pyu-ruby-sasl (~> 0.0.3.2)
-      rubyntlm (~> 0.3.4)
+    net-ldap (0.18.0)
     pyu-ruby-sasl (0.0.3.3)
-    rack (2.2.7)
     rubyntlm (0.3.4)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  net-ldap (= 0.17.1)
-  omniauth-ldap (= 1.0.5)
+  net-ldap (= 0.18.0)
   pyu-ruby-sasl (= 0.0.3.3)
   rubyntlm (= 0.3.4)
 
 BUNDLED WITH
-   2.4.10
+   2.5.22

pkgs/servers/web-apps/discourse/plugins/discourse-ldap-auth/default.nix

···
   src = fetchFromGitHub {
     owner = "jonmbake";
     repo = "discourse-ldap-auth";
-    rev = "edcf06957090e8d978a89fe7b07a6ba56fe35214";
-    sha256 = "sha256-VxBBip8QEXDQGDOsU5cXjUZe2HThJn20BPsNr33KhKI=";
+    rev = "fa1d661004ca99036ff628a9c4be12a81265d784";
+    sha256 = "sha256-2DYrYgC3H+e8USoo1MbJin1f5tshIUsQa6J7avnpvEc=";
   };
   meta = with lib; {
     homepage = "https://github.com/jonmbake/discourse-ldap-auth";

pkgs/servers/web-apps/discourse/plugins/discourse-ldap-auth/gemset.nix

···
 {
-  hashie = {
-    groups = [ "default" ];
-    platforms = [ ];
-    source = {
-      remotes = [ "https://rubygems.org" ];
-      sha256 = "1nh3arcrbz1rc1cr59qm53sdhqm137b258y8rcb4cvd3y98lwv4x";
-      type = "gem";
-    };
-    version = "5.0.0";
-  };
   net-ldap = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1ycw0qsw3hap8svakl0i30jkj0ffd4lpyrn17a1j0w8mz5ainmsj";
-      type = "gem";
-    };
-    version = "0.17.1";
-  };
-  omniauth = {
-    dependencies = [
-      "hashie"
-      "rack"
-    ];
-    groups = [ "default" ];
-    platforms = [ ];
-    source = {
-      remotes = [ "https://rubygems.org" ];
-      sha256 = "1jn9j54l5h7xcba2vjq74l1dk0xrwvsjxam4qhylpi52nw0h5502";
-      type = "gem";
-    };
-    version = "1.9.2";
-  };
-  omniauth-ldap = {
-    dependencies = [
-      "net-ldap"
-      "omniauth"
-      "pyu-ruby-sasl"
-      "rubyntlm"
-    ];
-    groups = [ "default" ];
-    platforms = [ ];
-    source = {
-      remotes = [ "https://rubygems.org" ];
-      sha256 = "1ld3mx46xa1qhc0cpnck1n06xcxs0ag4n41zgabxri27a772f9wz";
+      sha256 = "0xqcffn3c1564c4fizp10dzw2v5g2pabdzrcn25hq05bqhsckbar";
       type = "gem";
     };
-    version = "1.0.5";
+    version = "0.18.0";
   };
   pyu-ruby-sasl = {
     groups = [ "default" ];
···
       type = "gem";
     };
     version = "0.0.3.3";
-  };
-  rack = {
-    groups = [ "default" ];
-    platforms = [ ];
-    source = {
-      remotes = [ "https://rubygems.org" ];
-      sha256 = "16w217k9z02c4hqizym8dkj6bqmmzx4qdvqpnskgzf174a5pwdxk";
-      type = "gem";
-    };
-    version = "2.2.7";
   };
   rubyntlm = {
     groups = [ "default" ];

pkgs/servers/web-apps/discourse/plugins/discourse-math/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-math";
-    rev = "19ab34b62ab75589419ee39af7d6ba2fec1bdc4a";
-    sha256 = "sha256-Z6+Bx1DKEE+s1flt5K/HfevzXsA+mA0YfQxmg7JQMfA=";
+    rev = "90a56a5b463546cba5017cf25168bae759bcbf77";
+    sha256 = "sha256-q8cNRIHYEkaE6QkdsHu4tPwSw3LnCNgKjbyESBXheE0=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-math";

pkgs/servers/web-apps/discourse/plugins/discourse-openid-connect/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-openid-connect";
-    rev = "07e30e59bf5ca3925328e936359a5564d7f5b0af";
-    sha256 = "sha256-uqxwUjbkS2o9r9pvnTgv+3jzFhUOb8KmorT3ody2d3o=";
+    rev = "e08efecc012a5ab8fa95084be93d4fd07ccebab9";
+    sha256 = "sha256-v4UWFDdOFON+nHkH490kBQ4sXX7Mrp7KVhN1x9HML7w=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-openid-connect";

pkgs/servers/web-apps/discourse/plugins/discourse-prometheus/Gemfile

···
 source "https://rubygems.org"
 
 # gem "rails"
-gem "webrick", "1.8.1"
-gem "prometheus_exporter", "2.0.6"
+gem "prometheus_exporter", "2.2.0"

pkgs/servers/web-apps/discourse/plugins/discourse-prometheus/Gemfile.lock

···
 GEM
   remote: https://rubygems.org/
   specs:
-    prometheus_exporter (2.0.6)
+    prometheus_exporter (2.2.0)
       webrick
-    webrick (1.8.1)
+    webrick (1.9.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  prometheus_exporter (= 2.0.6)
-  webrick (= 1.8.1)
+  prometheus_exporter (= 2.2.0)
 
 BUNDLED WITH
-   2.4.22
+   2.5.22

pkgs/servers/web-apps/discourse/plugins/discourse-prometheus/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-prometheus";
-    rev = "b1b899ca995783ef5eba90c35dbfc120a2949c38";
-    sha256 = "sha256-tSU1aba8EadObOsb/nRM4jAdQ6D1F9QiIaGoHi2GGDk=";
+    rev = "f46906e1d555f6838d74ea38d5037264cc1020b0";
+    sha256 = "sha256-czrxhH0L+vCZA8DKN6acW///iWJs9GIppEeaP2MOJBQ=";
   };
 
   patches = [

pkgs/servers/web-apps/discourse/plugins/discourse-prometheus/gemset.nix

···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0pb4k6px8b36bvnw3d14j31s33ns60dcwxixbcgvhpzavd7fparb";
+      sha256 = "15vl8fw8vjnaj9g129dzrwk9nlrdqgffaj3rys4ba9ns2bqim9rq";
       type = "gem";
     };
-    version = "2.0.6";
+    version = "2.2.0";
   };
   webrick = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "13qm7s0gr2pmfcl7dxrmq38asaza4w0i2n9my4yzs499j731wh8r";
+      sha256 = "12d9n8hll67j737ym2zw4v23cn4vxyfkb6vyv1rzpwv6y6a3qbdl";
       type = "gem";
     };
-    version = "1.8.1";
+    version = "1.9.1";
   };
 }

pkgs/servers/web-apps/discourse/plugins/discourse-prometheus/spec-import-fix-abi-version.patch

···
 diff --git a/bin/collector b/bin/collector
-index 6bd04a8caffb..119526fc6ea3 100644
+index 4bdce08178..5edc0a4aee 100755
 --- a/bin/collector
 +++ b/bin/collector
-@@ -3,12 +3,14 @@
- 
+@@ -3,9 +3,11 @@
+
  Process.setproctitle("discourse prometheus-collector")
- 
+
 +# We need the ABI version {MAJOR}.{MINOR}.0 here.
 +abi_version = ENV['GEM_PATH'].split("/")[-1]
- [
-   "webrick-#{ENV["WEBRICK_VERSION"]}",
-   "prometheus_exporter-#{ENV["PROMETHEUS_EXPORTER_VERSION"]}",
- ].each do |spec_name|
-   spec_file =
--    File.expand_path("../../gems/#{RUBY_VERSION}/specifications/#{spec_name}.gemspec", __FILE__)
-+    File.expand_path("../../gems/#{abi_version}/specifications/#{spec_name}.gemspec", __FILE__)
-   spec = Gem::Specification.load(spec_file)
-   spec.activate
- end
+ spec_file =
+   File.expand_path(
+-    "../../gems/#{RUBY_VERSION}/specifications/#{"prometheus_exporter-#{ENV["PROMETHEUS_EXPORTER_VERSION"]}"}.gemspec",
++    "../../gems/#{abi_version}/specifications/#{"prometheus_exporter-#{ENV["PROMETHEUS_EXPORTER_VERSION"]}"}.gemspec",
+     __FILE__,
+   )

pkgs/servers/web-apps/discourse/plugins/discourse-reactions/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-reactions";
-    rev = "c4cde3bb12841733d1f2ac4df1bb099aae15cece";
-    sha256 = "sha256-JXyXBJX7PBYmVylZ7PE+14RnlgR4EA1XBSue1ek0P/g=";
+    rev = "4844fe7afc2fc6a809ed0249a6b42a4c92384461";
+    sha256 = "sha256-iudlFK+U+FwjNbduNTdwnT7oHww+xPz0+rZgzFUKT/8=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-reactions";

pkgs/servers/web-apps/discourse/plugins/discourse-saved-searches/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-saved-searches";
-    rev = "16bde9b0bcb3b517cfabc0ea740c10b091157799";
-    sha256 = "sha256-tn1AKiRPaunqlrtcC/6NETUnNxJq1uNi+IIF0TZPbDg=";
+    rev = "b78aae086e95255b1a1e91a01e2d56b45b7aead2";
+    sha256 = "sha256-Wai+oZR+Pzjre6Th0kQDgvFOwfPRHlZkpKYYOUKNlx4=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-saved-searches";

pkgs/servers/web-apps/discourse/plugins/discourse-solved/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-solved";
-    rev = "1bbdfd8f5681171dc3f0e9ea93cd56997dc7938a";
-    sha256 = "sha256-nuF/tCoHgsKE+wjQ3BRV1s1X77vjQiASLRCWErh64C4=";
+    rev = "e82c6ae1ca38ccebb34669148f8de93a3028906e";
+    sha256 = "sha256-KwpBCk4fjkZlSzgtc0OXvQupPd+aPb9nONyyALpEZhg=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-solved";

pkgs/servers/web-apps/discourse/plugins/discourse-voting/default.nix

···
   name = "discourse-voting";
   src = fetchFromGitHub {
     owner = "discourse";
-    repo = "discourse-voting";
-    rev = "4ebcd1187b59290b79db8c61c89df9f72bf1363c";
-    sha256 = "sha256-aDJKy7Qpsj1n+HrumoORUo+R9HF3gQ0juJBKXj7GHsY=";
+    repo = "discourse-topic-voting";
+    rev = "b31bc6e037af776d2cea3f34c44b02a105b34d24";
+    sha256 = "sha256-835xFg2NnhE4HPju2j3w+N5rtRYinOBbBMerRJpnpxQ=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-voting";

pkgs/servers/web-apps/discourse/plugins/discourse-yearly-review/default.nix

···
   src = fetchFromGitHub {
     owner = "discourse";
     repo = "discourse-yearly-review";
-    rev = "bb124c211c37873c1d54e96e7063f1868c65d0ad";
-    sha256 = "sha256-xAFpt/uVW8+Y2wwL20u/rMixcFgygwrarsdRsywsbmQ=";
+    rev = "5229931ace1ee19ef2d1b7ed2469911f315669bb";
+    sha256 = "sha256-2xgHtXB7F5XP2OmB1QswrnPk5Sf32DFoUhlU4RMEZhI=";
   };
   meta = with lib; {
     homepage = "https://github.com/discourse/discourse-yearly-review";

pkgs/servers/web-apps/discourse/prebuild-theme-transpiler.patch

···
 diff --git a/lib/discourse_js_processor.rb b/lib/discourse_js_processor.rb
-index 26d142fa4d..6040aba6f4 100644
+index f1642386c5..5a672818da 100644
 --- a/lib/discourse_js_processor.rb
 +++ b/lib/discourse_js_processor.rb
-@@ -68,7 +68,7 @@ class DiscourseJsProcessor
-     TRANSPILER_PATH =
-       (
-         if Rails.env.production?
--          "tmp/theme-transpiler.js"
-+          "app/assets/javascripts/theme-transpiler.js"
-         else
-           "tmp/theme-transpiler/#{Process.pid}.js"
-         end
-@@ -87,6 +87,6 @@ class DiscourseJsProcessor
-         "node",
-         "app/assets/javascripts/theme-transpiler/build.js",
-         TRANSPILER_PATH,
--      )
-+      ) if !Rails.env.production? or !File.file?(TRANSPILER_PATH)
+@@ -54,7 +54,7 @@ class DiscourseJsProcessor
+   end
+
+   class Transpiler
+-    TRANSPILER_PATH = "tmp/theme-transpiler.js"
++    TRANSPILER_PATH = "app/assets/javascripts/theme-transpiler.js"
+
+     @mutex = Mutex.new
+     @ctx_init = Mutex.new
+@@ -75,7 +75,9 @@ class DiscourseJsProcessor
+     end
+
+     def self.build_production_theme_transpiler
+-      File.write(TRANSPILER_PATH, build_theme_transpiler)
++      if (!Rails.env.production? or !File.file?(TRANSPILER_PATH))
++        File.write(TRANSPILER_PATH, build_theme_transpiler)
++      end
        TRANSPILER_PATH
      end

pkgs/servers/web-apps/discourse/rubyEnv/Gemfile

···
 
 gem "bootsnap", require: false, platform: :mri
 
-gem "actionmailer", "~> 7.1.0"
-gem "actionpack", "~> 7.1.0"
-gem "actionview", "~> 7.1.0"
-gem "activemodel", "~> 7.1.0"
-gem "activerecord", "~> 7.1.0"
-gem "activesupport", "~> 7.1.0"
-gem "railties", "~> 7.1.0"
+gem "actionmailer", "~> 7.2.0"
+gem "actionpack", "~> 7.2.0"
+gem "actionview", "~> 7.2.0"
+gem "activemodel", "~> 7.2.0"
+gem "activerecord", "~> 7.2.0"
+gem "activesupport", "~> 7.2.0"
+gem "railties", "~> 7.2.0"
 gem "sprockets-rails"
 
 gem "json"
···
 gem "mini_scheduler"
 
 gem "execjs", require: false
-gem "mini_racer"
+gem "mini_racer", "0.17.pre13"
 
 gem "highline", require: false
 
···
 
   gem "syntax_tree"
   gem "syntax_tree-disable_ternary"
+
+  gem "rspec-multi-mock"
 end
 
 group :development do
···
   gem "reverse_markdown"
   gem "tiny_tds"
   gem "csv"
-
-  gem "parallel", require: false
 end
 
 group :generic_import, optional: true do
···
 gem "tzinfo-data"
 gem "csv", require: false
 
-# TODO: Can be removed once we upgrade to Rails 7.1
-gem "mutex_m"
-gem "drb"
-
 # dependencies for the automation plugin
 gem "iso8601"
 gem "rrule"
+
+group :migrations, optional: true do
+  gem "extralite-bundle", require: "extralite"
+
+  # auto-loading
+  gem "zeitwerk"
+
+  # databases
+  gem "trilogy"
+
+  # CLI
+  gem "ruby-progressbar"
+
+  # non-cryptographic hashing algorithm for generating placeholder IDs
+  gem "digest-xxhash"
+end
+
+gem "dry-initializer", "~> 3.1"
+
+gem "parallel"

pkgs/servers/web-apps/discourse/rubyEnv/Gemfile.lock

···
 GEM
   remote: https://rubygems.org/
   specs:
-    actionmailer (7.1.3.4)
-      actionpack (= 7.1.3.4)
-      actionview (= 7.1.3.4)
-      activejob (= 7.1.3.4)
-      activesupport (= 7.1.3.4)
-      mail (~> 2.5, >= 2.5.4)
-      net-imap
-      net-pop
-      net-smtp
+    actionmailer (7.2.2.1)
+      actionpack (= 7.2.2.1)
+      actionview (= 7.2.2.1)
+      activejob (= 7.2.2.1)
+      activesupport (= 7.2.2.1)
+      mail (>= 2.8.0)
       rails-dom-testing (~> 2.2)
-    actionpack (7.1.3.4)
-      actionview (= 7.1.3.4)
-      activesupport (= 7.1.3.4)
+    actionpack (7.2.2.1)
+      actionview (= 7.2.2.1)
+      activesupport (= 7.2.2.1)
       nokogiri (>= 1.8.5)
       racc
-      rack (>= 2.2.4)
+      rack (>= 2.2.4, < 3.2)
       rack-session (>= 1.0.1)
       rack-test (>= 0.6.3)
       rails-dom-testing (~> 2.2)
       rails-html-sanitizer (~> 1.6)
-    actionview (7.1.3.4)
-      activesupport (= 7.1.3.4)
+      useragent (~> 0.16)
+    actionview (7.2.2.1)
+      activesupport (= 7.2.2.1)
       builder (~> 3.1)
       erubi (~> 1.11)
       rails-dom-testing (~> 2.2)
···
       actionview (>= 6.0.a)
     active_model_serializers (0.8.4)
       activemodel (>= 3.0)
-    activejob (7.1.3.4)
-      activesupport (= 7.1.3.4)
+    activejob (7.2.2.1)
+      activesupport (= 7.2.2.1)
       globalid (>= 0.3.6)
-    activemodel (7.1.3.4)
-      activesupport (= 7.1.3.4)
-    activerecord (7.1.3.4)
-      activemodel (= 7.1.3.4)
-      activesupport (= 7.1.3.4)
+    activemodel (7.2.2.1)
+      activesupport (= 7.2.2.1)
+    activerecord (7.2.2.1)
+      activemodel (= 7.2.2.1)
+      activesupport (= 7.2.2.1)
       timeout (>= 0.4.0)
-    activesupport (7.1.3.4)
+    activesupport (7.2.2.1)
       base64
+      benchmark (>= 0.3)
       bigdecimal
-      concurrent-ruby (~> 1.0, >= 1.0.2)
+      concurrent-ruby (~> 1.0, >= 1.3.1)
       connection_pool (>= 2.2.5)
       drb
       i18n (>= 1.6, < 2)
+      logger (>= 1.4.2)
       minitest (>= 5.1)
-      mutex_m
-      tzinfo (~> 2.0)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
     addressable (2.8.7)
       public_suffix (>= 2.0.2, < 7.0)
     annotate (3.2.0)
···
     aws-sigv4 (1.8.0)
       aws-eventstream (~> 1, >= 1.0.2)
     base64 (0.2.0)
+    benchmark (0.4.0)
     better_errors (2.10.1)
       erubi (>= 1.0.0)
       rack (>= 0.9.0)
       rouge (>= 1.0.0)
-    bigdecimal (3.1.8)
+    bigdecimal (3.1.9)
     binding_of_caller (1.0.1)
       debug_inspector (>= 1.2.0)
-    bootsnap (1.18.3)
+    bootsnap (1.18.4)
       msgpack (~> 1.2)
     builder (3.3.0)
-    bullet (7.2.0)
+    bullet (8.0.0)
       activesupport (>= 3.0.0)
       uniform_notifier (~> 1.11)
     byebug (11.1.3)
···
     cgi (0.4.1)
     chunky_png (1.4.0)
     coderay (1.1.3)
-    colored2 (4.0.0)
-    concurrent-ruby (1.3.3)
-    connection_pool (2.4.1)
-    cose (1.3.0)
+    colored2 (4.0.3)
+    concurrent-ruby (1.3.5)
+    connection_pool (2.5.0)
+    cose (1.3.1)
       cbor (~> 0.5.9)
       openssl-signature_algorithm (~> 1.0)
-    cppjieba_rb (0.4.2)
+    cppjieba_rb (0.4.4)
     crack (1.0.0)
       bigdecimal
       rexml
     crass (1.0.6)
-    css_parser (1.17.1)
+    css_parser (1.21.0)
       addressable
-    csv (3.3.0)
-    date (3.3.4)
+    csv (3.3.2)
+    date (3.4.1)
     debug_inspector (1.2.0)
     diff-lcs (1.5.1)
-    diffy (3.4.2)
-    digest (3.1.1)
-    discourse-fonts (0.0.9)
+    diffy (3.4.3)
+    digest (3.2.0)
+    digest-xxhash (0.2.9)
+    discourse-fonts (0.0.18)
     discourse-seed-fu (2.3.12)
       activerecord (>= 3.1)
       activesupport (>= 3.1)
···
       literate_randomizer
     docile (1.4.1)
     drb (2.2.1)
-    email_reply_trimmer (0.1.13)
-    erubi (1.13.0)
-    excon (0.111.0)
-    execjs (2.9.1)
-    exifr (1.4.0)
+    dry-initializer (3.2.0)
+    email_reply_trimmer (0.2.0)
+    erubi (1.13.1)
+    excon (1.2.3)
+    execjs (2.10.0)
+    exifr (1.4.1)
+    extralite-bundle (2.8.2)
     fabrication (2.31.0)
     faker (2.23.0)
       i18n (>= 1.8.11, < 2)
     fakeweb (1.3.0)
-    faraday (2.10.0)
-      faraday-net_http (>= 2.0, < 3.2)
+    faraday (2.12.2)
+      faraday-net_http (>= 2.0, < 3.5)
+      json
       logger
-    faraday-net_http (3.1.1)
-      net-http
+    faraday-net_http (3.4.0)
+      net-http (>= 0.5.0)
     faraday-retry (2.2.1)
       faraday (~> 2.0)
     fast_blank (1.0.1)
     fastimage (2.3.1)
-    ffi (1.17.0)
-    ffi (1.17.0-arm64-darwin)
-    ffi (1.17.0-x86_64-darwin)
+    ffi (1.17.1)
+    ffi (1.17.1-arm64-darwin)
+    ffi (1.17.1-x86_64-darwin)
     fspath (3.1.2)
     globalid (1.2.1)
       activesupport (>= 6.1)
-    google-protobuf (4.27.2)
+    google-protobuf (4.29.3)
       bigdecimal
       rake (>= 13)
-    google-protobuf (4.27.2-arm64-darwin)
+    google-protobuf (4.29.3-arm64-darwin)
       bigdecimal
       rake (>= 13)
-    google-protobuf (4.27.2-x86_64-darwin)
+    google-protobuf (4.29.3-x86_64-darwin)
       bigdecimal
       rake (>= 13)
     guess_html_encoding (0.0.11)
     hana (1.3.7)
-    hashdiff (1.1.0)
+    hashdiff (1.1.2)
     hashie (5.0.0)
-    highline (3.1.0)
+    highline (3.1.2)
       reline
     htmlentities (4.3.4)
     http_accept_language (2.1.1)
-    i18n (1.14.5)
+    i18n (1.14.7)
       concurrent-ruby (~> 1.0)
-    image_optim (0.31.3)
+    image_optim (0.31.4)
       exifr (~> 1.2, >= 1.2.2)
       fspath (~> 3.0)
       image_size (>= 1.5, < 4)
···
       progress (~> 3.0, >= 3.0.1)
     image_size (3.4.0)
     in_threads (1.6.0)
-    io-console (0.7.2)
-    irb (1.14.0)
+    io-console (0.8.0)
+    irb (1.15.1)
+      pp (>= 0.6.0)
       rdoc (>= 4.0.0)
       reline (>= 0.4.2)
     iso8601 (0.13.0)
     jmespath (1.6.2)
-    json (2.7.2)
-    json-schema (4.3.1)
-      addressable (>= 2.8)
-    json_schemer (2.3.0)
+    json (2.9.1)
+    json-schema (5.1.1)
+      addressable (~> 2.8)
+      bigdecimal (~> 3.1)
+    json_schemer (2.4.0)
       bigdecimal
       hana (~> 1.3)
       regexp_parser (~> 2.0)
       simpleidn (~> 0.2)
-    jwt (2.8.2)
+    jwt (2.10.1)
       base64
     kgio (2.11.4)
-    language_server-protocol (3.17.0.3)
-    libv8-node (18.19.0.0)
-    libv8-node (18.19.0.0-arm64-darwin)
-    libv8-node (18.19.0.0-x86_64-darwin)
+    language_server-protocol (3.17.0.4)
+    libv8-node (22.7.0.4)
+    libv8-node (22.7.0.4-arm64-darwin)
+    libv8-node (22.7.0.4-x86_64-darwin)
     listen (3.9.0)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
     literate_randomizer (0.4.0)
-    logger (1.6.0)
+    logger (1.6.5)
     lograge (0.14.0)
       actionpack (>= 4)
       activesupport (>= 4)
···
       request_store (~> 1.0)
     logstash-event (1.2.02)
     logster (2.20.0)
-    loofah (2.22.0)
+    loofah (2.24.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.12.0)
     lru_redux (1.1.0)
···
       net-smtp
     matrix (0.4.2)
     maxminddb (0.1.22)
-    memory_profiler (1.0.2)
+    memory_profiler (1.1.0)
     message_bus (4.3.8)
       rack (>= 1.1.3)
     messageformat-wrapper (1.1.0)
       mini_racer (>= 0.6.3)
     method_source (1.1.0)
     mini_mime (1.1.5)
-    mini_portile2 (2.8.7)
-    mini_racer (0.14.1)
-      libv8-node (~> 18.19.0.0)
-    mini_scheduler (0.16.0)
-      sidekiq (>= 4.2.3, < 7.0)
-    mini_sql (1.5.0)
+    mini_portile2 (2.8.8)
+    mini_racer (0.17.0.pre13)
+      libv8-node (~> 22.7.0.4)
+    mini_scheduler (0.18.0)
+      sidekiq (>= 6.5, < 8.0)
+    mini_sql (1.6.0)
     mini_suffix (0.3.3)
       ffi (~> 1.9)
     minio_runner (0.1.2)
-    minitest (5.24.1)
-    mocha (2.4.5)
+    minitest (5.25.4)
+    mocha (2.7.1)
       ruby2_keywords (>= 0.0.5)
-    msgpack (1.7.2)
+    msgpack (1.7.5)
     multi_json (1.15.0)
     multi_xml (0.7.1)
       bigdecimal (~> 3.1)
     mustache (1.1.1)
-    mutex_m (0.2.0)
-    net-http (0.4.1)
+    net-http (0.6.0)
       uri
-    net-imap (0.4.14)
+    net-imap (0.5.5)
       date
       net-protocol
     net-pop (0.1.2)
···
       timeout
     net-smtp (0.5.0)
       net-protocol
-    nio4r (2.7.3)
-    nokogiri (1.16.7)
+    nio4r (2.7.4)
+    nokogiri (1.18.2)
       mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
-    nokogiri (1.16.7-arm64-darwin)
+    nokogiri (1.18.2-arm64-darwin)
       racc (~> 1.4)
-    nokogiri (1.16.7-x86_64-darwin)
+    nokogiri (1.18.2-x86_64-darwin)
       racc (~> 1.4)
     oauth (1.1.0)
       oauth-tty (~> 1.0, >= 1.0.1)
···
       multi_json (~> 1.3)
       multi_xml (~> 0.5)
       rack (>= 1.2, < 4)
-    oj (3.16.4)
+    oj (3.16.9)
       bigdecimal (>= 3.0)
+      ostruct (>= 0.2)
     omniauth (1.9.2)
       hashie (>= 3.4.6)
       rack (>= 1.6.2, < 3)
···
       oauth2 (~> 1.1)
       omniauth (~> 1.1)
       omniauth-oauth2 (>= 1.6)
-    omniauth-oauth (1.2.0)
+    omniauth-oauth (1.2.1)
       oauth
       omniauth (>= 1.0, < 3)
+      rack (>= 1.6.2, < 4)
     omniauth-oauth2 (1.7.3)
       oauth2 (>= 1.4, < 3)
       omniauth (>= 1.9, < 3)
     omniauth-twitter (1.4.0)
       omniauth-oauth (~> 1.1)
       rack
-    openssl (3.2.0)
+    openssl (3.3.0)
     openssl-signature_algorithm (1.3.0)
       openssl (> 2.0)
-    optimist (3.1.0)
-    parallel (1.25.1)
-    parallel_tests (4.7.1)
+    optimist (3.2.0)
+    ostruct (0.6.1)
+    parallel (1.26.3)
+    parallel_tests (4.9.0)
       parallel
-    parser (3.3.4.0)
+    parser (3.3.7.0)
       ast (~> 2.4.1)
       racc
-    pg (1.5.4)
+    pg (1.5.9)
+    pp (0.6.2)
+      prettyprint
     prettier_print (1.2.1)
+    prettyprint (0.2.0)
     progress (3.6.0)
     pry (0.14.2)
       coderay (~> 1.1)
···
     pry-stack_explorer (0.6.1)
       binding_of_caller (~> 1.0)
       pry (~> 0.13)
-    psych (5.1.2)
+    psych (5.2.3)
+      date
       stringio
     public_suffix (6.0.1)
-    puma (6.4.2)
+    puma (6.6.0)
       nio4r (~> 2.0)
-    racc (1.8.0)
-    rack (2.2.9)
+    racc (1.8.1)
+    rack (2.2.10)
     rack-mini-profiler (3.3.1)
       rack (>= 1.2.0)
     rack-protection (3.2.0)
···
       rack (~> 2.2, >= 2.2.4)
     rack-session (1.0.2)
       rack (< 3)
-    rack-test (2.1.0)
+    rack-test (2.2.0)
       rack (>= 1.3)
-    rackup (1.0.0)
+    rackup (1.0.1)
       rack (< 3)
       webrick
     rails-dom-testing (2.2.0)
       activesupport (>= 5.0.0)
       minitest
       nokogiri (>= 1.6)
-    rails-html-sanitizer (1.6.0)
+    rails-html-sanitizer (1.6.2)
       loofah (~> 2.21)
-      nokogiri (~> 1.14)
-    rails_failover (2.1.1)
+      nokogiri (>= 1.15.7, != 1.16.7, != 1.16.6, != 1.16.5, != 1.16.4, != 1.16.3, != 1.16.2, != 1.16.1, != 1.16.0.rc1, != 1.16.0)
+    rails_failover (2.2.0)
       activerecord (>= 6.1, < 8.0)
       concurrent-ruby
       railties (>= 6.1, < 8.0)
-    rails_multisite (6.0.0)
+    rails_multisite (6.1.0)
       activerecord (>= 6.0)
       railties (>= 6.0)
-    railties (7.1.3.4)
-      actionpack (= 7.1.3.4)
-      activesupport (= 7.1.3.4)
-      irb
+    railties (7.2.2.1)
+      actionpack (= 7.2.2.1)
+      activesupport (= 7.2.2.1)
+      irb (~> 1.13)
       rackup (>= 1.0.0)
       rake (>= 12.2)
       thor (~> 1.0, >= 1.2.2)
···
       ffi (>= 1.0.6)
       msgpack (>= 0.4.3)
       optimist (>= 3.0.0)
-    rchardet (1.8.0)
-    rdoc (6.7.0)
+    rchardet (1.9.0)
+    rdoc (6.11.0)
       psych (>= 4.0.0)
     redcarpet (3.6.0)
     redis (4.8.1)
     redis-namespace (1.11.0)
       redis (>= 4)
-    regexp_parser (2.9.2)
-    reline (0.5.9)
+    regexp_parser (2.10.0)
+    reline (0.6.0)
       io-console (~> 0.5)
     request_store (1.7.0)
       rack (>= 1.4)
-    rexml (3.3.2)
-      strscan
+    rexml (3.4.0)
     rinku (2.0.6)
     rotp (6.3.0)
-    rouge (4.3.0)
+    rouge (4.5.1)
     rqrcode (2.2.0)
       chunky_png (~> 1.0)
       rqrcode_core (~> 1.0)
···
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
       rspec-mocks (~> 3.13.0)
-    rspec-core (3.13.0)
+    rspec-core (3.13.2)
       rspec-support (~> 3.13.0)
-    rspec-expectations (3.13.1)
+    rspec-expectations (3.13.3)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
     rspec-html-matchers (0.10.0)
       nokogiri (~> 1)
       rspec (>= 3.0.0.a)
-    rspec-mocks (3.13.1)
+    rspec-mocks (3.13.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-rails (6.1.3)
-      actionpack (>= 6.1)
-      activesupport (>= 6.1)
-      railties (>= 6.1)
+    rspec-multi-mock (0.3.1)
+      rspec (>= 3.7.0)
+    rspec-rails (7.1.0)
+      actionpack (>= 7.0)
+      activesupport (>= 7.0)
+      railties (>= 7.0)
       rspec-core (~> 3.13)
       rspec-expectations (~> 3.13)
       rspec-mocks (~> 3.13)
       rspec-support (~> 3.13)
-    rspec-support (3.13.1)
-    rss (0.3.0)
+    rspec-support (3.13.2)
+    rss (0.3.1)
       rexml
-    rswag-specs (2.13.0)
-      activesupport (>= 3.1, < 7.2)
-      json-schema (>= 2.2, < 5.0)
-      railties (>= 3.1, < 7.2)
+    rswag-specs (2.16.0)
+      activesupport (>= 5.2, < 8.1)
+      json-schema (>= 2.2, < 6.0)
+      railties (>= 5.2, < 8.1)
       rspec-core (>= 2.14)
     rtlcss (0.2.1)
       mini_racer (>= 0.6.3)
-    rubocop (1.65.0)
+    rubocop (1.71.1)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 2.4, < 3.0)
-      rexml (>= 3.2.5, < 4.0)
-      rubocop-ast (>= 1.31.1, < 2.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.38.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.31.3)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.38.0)
       parser (>= 3.3.1.0)
     rubocop-capybara (2.21.0)
       rubocop (~> 1.41)
-    rubocop-discourse (3.8.1)
+    rubocop-discourse (3.9.3)
       activesupport (>= 6.1)
       rubocop (>= 1.59.0)
       rubocop-capybara (>= 2.0.0)
···
       rubocop-rspec_rails (>= 2.30.0)
     rubocop-factory_bot (2.26.1)
       rubocop (~> 1.61)
-    rubocop-rails (2.25.1)
+    rubocop-rails (2.29.1)
       activesupport (>= 4.2.0)
       rack (>= 1.1)
-      rubocop (>= 1.33.0, < 2.0)
+      rubocop (>= 1.52.0, < 2.0)
       rubocop-ast (>= 1.31.1, < 2.0)
-    rubocop-rspec (3.0.3)
+    rubocop-rspec (3.4.0)
       rubocop (~> 1.61)
     rubocop-rspec_rails (2.30.0)
       rubocop (~> 1.61)
       rubocop-rspec (~> 3, >= 3.0.1)
-    ruby-prof (1.7.0)
+    ruby-prof (1.7.1)
     ruby-progressbar (1.13.0)
-    ruby-readability (0.7.1)
+    ruby-readability (0.7.2)
       guess_html_encoding (>= 0.0.4)
       nokogiri (>= 1.6.0)
     ruby2_keywords (0.0.5)
-    rubyzip (2.3.2)
-    sanitize (6.1.2)
+    rubyzip (2.4.1)
+    sanitize (7.0.0)
       crass (~> 1.0.2)
-      nokogiri (>= 1.12.0)
+      nokogiri (>= 1.16.8)
     sass-embedded (1.77.5)
       google-protobuf (>= 3.25, < 5.0)
       rake (>= 13)
···
       google-protobuf (>= 3.25, < 5.0)
     sassc-embedded (1.77.7)
       sass-embedded (~> 1.77)
-    selenium-devtools (0.126.0)
+    securerandom (0.4.1)
+    selenium-devtools (0.132.0)
       selenium-webdriver (~> 4.2)
-    selenium-webdriver (4.23.0)
+    selenium-webdriver (4.28.0)
       base64 (~> 0.2)
       logger (~> 1.4)
       rexml (~> 3.2, >= 3.2.5)
       rubyzip (>= 1.2.2, < 3.0)
       websocket (~> 1.0)
-    shoulda-matchers (6.2.0)
+    shoulda-matchers (6.4.0)
       activesupport (>= 5.2.0)
     sidekiq (6.5.12)
       connection_pool (>= 2.2.5, < 3)
···
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
-    simplecov-html (0.12.3)
+    simplecov-html (0.13.1)
     simplecov_json_formatter (0.1.4)
     simpleidn (0.2.3)
     snaky_hash (2.0.1)
       hashie
       version_gem (~> 1.1, >= 1.1.1)
-    sprockets (3.7.3)
+    sprockets (3.7.5)
       base64
       concurrent-ruby (~> 1.0)
       rack (> 1, < 3)
-    sprockets-rails (3.5.1)
+    sprockets-rails (3.5.2)
       actionpack (>= 6.1)
       activesupport (>= 6.1)
       sprockets (>= 3.0.0)
-    sqlite3 (2.0.2)
+    sqlite3 (2.5.0)
       mini_portile2 (~> 2.8.0)
-    sqlite3 (2.0.2-arm64-darwin)
-    sqlite3 (2.0.2-x86_64-darwin)
+    sqlite3 (2.5.0-arm64-darwin)
+    sqlite3 (2.5.0-x86_64-darwin)
     sshkey (3.0.0)
-    stackprof (0.2.26)
-    stringio (3.1.1)
-    strscan (3.1.0)
+    stackprof (0.2.27)
+    stringio (3.1.2)
     syntax_tree (6.2.0)
       prettier_print (>= 1.2.0)
     syntax_tree-disable_ternary (1.0.0)
-    test-prof (1.3.3.1)
-    thor (1.3.1)
-    timeout (0.4.1)
+    test-prof (1.4.4)
+    thor (1.3.2)
+    timeout (0.4.3)
+    trilogy (2.9.0)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    tzinfo-data (1.2024.1)
+    tzinfo-data (1.2025.1)
       tzinfo (>= 1.0.0)
-    uglifier (4.2.0)
+    uglifier (4.2.1)
       execjs (>= 0.3.0, < 3)
-    unf (0.1.4)
-      unf_ext
-    unf_ext (0.0.9.1)
-    unicode-display_width (2.5.0)
+    unf (0.2.0)
+    unicode-display_width (3.1.4)
+      unicode-emoji (~> 4.0, >= 4.0.4)
+    unicode-emoji (4.0.4)
     unicorn (6.1.0)
       kgio (~> 2.6)
       raindrops (~> 0.7)
     uniform_notifier (1.16.0)
-    uri (0.13.0)
+    uri (1.0.2)
+    useragent (0.16.11)
     version_gem (1.1.4)
     web-push (3.0.1)
       jwt (~> 2.0)
       openssl (~> 3.0)
-    webmock (3.23.1)
+    webmock (3.24.0)
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.0)
-    webrick (1.8.1)
+    webrick (1.9.1)
     websocket (1.2.11)
     xpath (3.2.0)
       nokogiri (~> 1.8)
     yaml-lint (0.1.2)
-    yard (0.9.36)
-    zeitwerk (2.6.16)
+    yard (0.9.37)
+    zeitwerk (2.7.1)
 
 PLATFORMS
   arm64-darwin-21
···
   arm64-darwin-24
   ruby
   x86_64-darwin-22
+  x86_64-darwin-23
+  x86_64-darwin-24
 
 DEPENDENCIES
-  actionmailer (~> 7.1.0)
-  actionpack (~> 7.1.0)
-  actionview (~> 7.1.0)
+  actionmailer (~> 7.2.0)
+  actionpack (~> 7.2.0)
+  actionview (~> 7.2.0)
   actionview_precompiler
   active_model_serializers (~> 0.8.3)
-  activemodel (~> 7.1.0)
-  activerecord (~> 7.1.0)
-  activesupport (~> 7.1.0)
+  activemodel (~> 7.2.0)
+  activerecord (~> 7.2.0)
+  activesupport (~> 7.2.0)
   addressable
   annotate
   aws-sdk-s3
···
   csv
   diffy
   digest
+  digest-xxhash
   discourse-fonts
   discourse-seed-fu
   discourse_dev_assets
-  drb
+  dry-initializer (~> 3.1)
   email_reply_trimmer
   excon
   execjs
+  extralite-bundle
   fabrication
   faker (~> 2.16)
   fakeweb
···
   message_bus
   messageformat-wrapper
   mini_mime
-  mini_racer
+  mini_racer (= 0.17.pre13)
   mini_scheduler
   mini_sql
   mini_suffix
···
   mocha
   multi_json
   mustache
-  mutex_m
   net-http
   net-imap
   net-pop
···
   omniauth-google-oauth2
   omniauth-oauth2
   omniauth-twitter
+  parallel
   parallel_tests
   pg
   pry-byebug
···
   rails-dom-testing
   rails_failover
   rails_multisite
-  railties (~> 7.1.0)
+  railties (~> 7.2.0)
   rake
   rb-fsevent
   rbtrace
···
   rrule
   rspec
   rspec-html-matchers
+  rspec-multi-mock
   rspec-rails
   rss
   rswag-specs
   rtlcss
   rubocop-discourse
   ruby-prof
+  ruby-progressbar
   ruby-readability
   rubyzip
   sanitize
···
   syntax_tree-disable_ternary
   test-prof
   thor
+  trilogy
   tzinfo-data
   uglifier
   unf
···
   webmock
   yaml-lint
   yard
+  zeitwerk
 
 BUNDLED WITH
-   2.4.22
+   2.5.22

pkgs/servers/web-apps/discourse/rubyEnv/gemset.nix

···
       "activejob"
       "activesupport"
       "mail"
-      "net-imap"
-      "net-pop"
-      "net-smtp"
       "rails-dom-testing"
     ];
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0l835a50h95wlzcy76c2vg54ix3i55kqmnrmz67b11q5fjb6068z";
+      sha256 = "07xjqxmwif57wxz28ch10c3c2261ydv1x56vsiidg2icqciyaamh";
       type = "gem";
     };
-    version = "7.1.3.4";
+    version = "7.2.2.1";
   };
   actionpack = {
     dependencies = [
···
       "rack-test"
       "rails-dom-testing"
       "rails-html-sanitizer"
+      "useragent"
     ];
     groups = [
       "default"
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1lpd0lvn6abcq5k8g0qw8kmzx6igirlqxvd1hhwmr5vaxhdwgbyw";
+      sha256 = "0d7pq6fsf041fvskzmqm12xcgk5m9d5fa6kbs1lsbmfbgc51dchp";
       type = "gem";
     };
-    version = "7.1.3.4";
+    version = "7.2.2.1";
   };
   actionview = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0nv1ifjhm59abc52k2hwazl38r9cc4bkfgdsl00f24gc5ljgbz21";
+      sha256 = "19arngl1nshasvbh90gzc23z1vpid2xzg3043grbmcfqyc68iz39";
       type = "gem";
     };
-    version = "7.1.3.4";
+    version = "7.2.2.1";
   };
   actionview_precompiler = {
     dependencies = [ "actionview" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0qhg0izdckgyqmrsgigh1vkqg8ccrkdjhf36k9gxcbgvzpqfx2iz";
+      sha256 = "0nryqb19i3frxhanykf6lmrw0rb09863z114gi7sm55kff2mmygj";
       type = "gem";
     };
-    version = "7.1.3.4";
+    version = "7.2.2.1";
   };
   activemodel = {
     dependencies = [ "activesupport" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0wmdw440l4h75zk6c4ynbnv21bj26dh8kb1kwikqkjnzfvm3ij7l";
+      sha256 = "1bzxvccj8349slymls7navb5y14anglkkasphcd6gi72kqgqd643";
       type = "gem";
     };
-    version = "7.1.3.4";
+    version = "7.2.2.1";
   };
   activerecord = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1wihj9xhr7yj10hh8fqw6ralanbwlisncbam8pa92czjssjfqkkq";
+      sha256 = "1fgscw775wj4l7f5pj274a984paz23zy0111giqkhl9dqdqiz8vr";
       type = "gem";
     };
-    version = "7.1.3.4";
+    version = "7.2.2.1";
   };
   activesupport = {
     dependencies = [
       "base64"
+      "benchmark"
       "bigdecimal"
       "concurrent-ruby"
       "connection_pool"
       "drb"
       "i18n"
+      "logger"
       "minitest"
-      "mutex_m"
+      "securerandom"
       "tzinfo"
     ];
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0283wk1zxb76lg79dk501kcf5xy9h25qiw15m86s4nrfv11vqns5";
+      sha256 = "1xa7hr4gp2p86ly6n1j2skyx8pfg6yi621kmnh7zhxr9m7wcnaw4";
       type = "gem";
     };
-    version = "7.1.3.4";
+    version = "7.2.2.1";
   };
   addressable = {
     dependencies = [ "public_suffix" ];
···
     };
     version = "0.2.0";
   };
+  benchmark = {
+    groups = [
+      "default"
+      "development"
+      "test"
+    ];
+    platforms = [ ];
+    source = {
+      remotes = [ "https://rubygems.org" ];
+      sha256 = "0jl71qcgamm96dzyqk695j24qszhcc7liw74qc83fpjljp2gh4hg";
+      type = "gem";
+    };
+    version = "0.4.0";
+  };
   better_errors = {
     dependencies = [
       "erubi"
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1gi7zqgmqwi5lizggs1jhc3zlwaqayy9rx2ah80sxy24bbnng558";
+      sha256 = "1k6qzammv9r6b2cw3siasaik18i6wjc5m0gw5nfdc6jj64h79z1g";
       type = "gem";
     };
-    version = "3.1.8";
+    version = "3.1.9";
   };
   binding_of_caller = {
     dependencies = [ "debug_inspector" ];
···
     ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1srlq3gqirzdkhv12ljpnp5cb0f8jfrl3n8xs9iivyz2c7khvdyp";
+      sha256 = "0mdgj9yw1hmx3xh2qxyjc31y8igmxzd9h0c245ay2zkz76pl4k5c";
       type = "gem";
     };
-    version = "1.18.3";
+    version = "1.18.4";
   };
   builder = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "12gacycw1adsdjp14pm43619c6lcdaddhgbdizy7gnzmnjhwh0im";
+      sha256 = "0kfyg2j6a4sg94sajnmy0scv9dxjh7jka9dlil1fzpx137g2zw3p";
       type = "gem";
     };
-    version = "7.2.0";
+    version = "8.0.0";
   };
   byebug = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1zj06gjqwykgzxmbkp2hmg3wv5kv8zz5d77acxipzcgicdjgvfan";
+      sha256 = "0drbrv5m3l3qpal7s87gvss81cbzl76gad1hqkpqfqlphf0h7qb3";
       type = "gem";
     };
-    version = "4.0.0";
+    version = "4.0.3";
   };
   concurrent-ruby = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0skwdasxq7mnlcccn6aqabl7n9r3jd7k19ryzlzzip64cn4x572g";
+      sha256 = "1ipbrgvf0pp6zxdk5ascp6i29aybz2bx9wdrlchjmpx6mhvkwfw1";
       type = "gem";
     };
-    version = "1.3.3";
+    version = "1.3.5";
   };
   connection_pool = {
-    groups = [ "default" ];
+    groups = [
+      "default"
+      "development"
+      "test"
+    ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1x32mcpm2cl5492kd6lbjbaf17qsssmpx9kdyr7z1wcif2cwyh0g";
+      sha256 = "1z7bag6zb2vwi7wp2bkdkmk7swkj6zfnbsnc949qq0wfsgw94fr3";
       type = "gem";
     };
-    version = "2.4.1";
+    version = "2.5.0";
   };
   cose = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "00c6x4ha7qiaaf88qdbyf240mk146zz78rbm4qwyaxmwlmk7q933";
+      sha256 = "1rbdzl9n8ppyp38y75hw06s17kp922ybj6jfvhz52p83dg6xpm6m";
       type = "gem";
     };
-    version = "1.3.0";
+    version = "1.3.1";
   };
   cppjieba_rb = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0ijzvnm5jclyhf6ls30kv7dqy05f3hbha69f59jwbzdid7dndla5";
+      sha256 = "1bzsr3k926cwz6r0sx6p60cjyhqls7n8fd123f6qmhkfgfspm6ii";
       type = "gem";
     };
-    version = "0.4.2";
+    version = "0.4.4";
   };
   crack = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1rhqn05w27w2mjrf0a6ppb4fxpxbfvyhwgdxa8z886jr4qnhywzb";
+      sha256 = "0625073hwx41c246v9dvkp0rk0xgh9d0sc0gm73dbmlxnjwgalv7";
       type = "gem";
     };
-    version = "1.17.1";
+    version = "1.21.0";
   };
   csv = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0zfn40dvgjk1xv1z8l11hr9jfg3jncwsc9yhzsz4l4rivkpivg8b";
+      sha256 = "0kmx36jjh2sahd989vcvw74lrlv07dqc3rnxchc5sj2ywqsw3w3g";
       type = "gem";
     };
-    version = "3.3.0";
+    version = "3.3.2";
   };
   date = {
-    groups = [ "default" ];
+    groups = [
+      "default"
+      "development"
+      "test"
+    ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "149jknsq999gnhy865n33fkk22s0r447k76x9pmcnnwldfv2q7wp";
+      sha256 = "0kz6mc4b9m49iaans6cbx031j9y7ldghpi5fzsdh0n3ixwa8w9mz";
       type = "gem";
     };
-    version = "3.3.4";
+    version = "3.4.1";
   };
   debug_inspector = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1qcsv29ljfhy76gq4xi8zpn6dc6nv15c41r131bdr38kwpxjzd1n";
+      sha256 = "19xaz5qmw0kg1rdsjh13vk7674bpcmjy6cnddx1cvl80vgkvjr22";
       type = "gem";
     };
-    version = "3.4.2";
+    version = "3.4.3";
   };
   digest = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "01qkpbkxq83ip3iysfh2kjrg9sh2n2q91prhyxh3vq10lcfzv9l1";
+      sha256 = "149r5nnr76g0lp0iz7xiw0zf4civrbs5zpmd5zc6agv8xj970bps";
       type = "gem";
     };
-    version = "3.1.1";
+    version = "3.2.0";
+  };
+  digest-xxhash = {
+    groups = [ "migrations" ];
+    platforms = [ ];
+    source = {
+      remotes = [ "https://rubygems.org" ];
+      sha256 = "1mwqln5078r4arxzngbzvr82fshl1bn836ga9dm17i03khqdi2d9";
+      type = "gem";
+    };
+    version = "0.2.9";
   };
   discourse-fonts = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1q1q9fmqc7dir2nj94nai58h26zsh6fqmbr6hfax5d6xpy4pm1yf";
+      sha256 = "18bj5d0hf7bwy0pppah55aawg7yn61sjgjhh03j5lcnkxl9mrlm7";
       type = "gem";
     };
-    version = "0.0.9";
+    version = "0.0.18";
   };
   discourse-seed-fu = {
     dependencies = [
···
     };
     version = "2.2.1";
   };
+  dry-initializer = {
+    groups = [ "default" ];
+    platforms = [ ];
+    source = {
+      remotes = [ "https://rubygems.org" ];
+      sha256 = "1qy4cv0j0ahabprdbp02nc3r1606jd5dp90lzqg0mp0jz6c9gm9p";
+      type = "gem";
+    };
+    version = "3.2.0";
+  };
   email_reply_trimmer = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1jgcxifm48xq5dz9k47q43pqm5bfnf14l62l3bqhmv8f6z8dw4ki";
+      sha256 = "09f5sq41fb912jxsbzh68hmkwq9gj9p8fg0zbwikf80sxsjkz105";
       type = "gem";
     };
-    version = "0.1.13";
+    version = "0.2.0";
   };
   erubi = {
     groups = [
···
     ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0qnd6ff4az22ysnmni3730c41b979xinilahzg86bn7gv93ip9pw";
+      sha256 = "1naaxsqkv5b3vklab5sbb9sdpszrjzlfsbqpy7ncbnw510xi10m0";
       type = "gem";
     };
-    version = "1.13.0";
+    version = "1.13.1";
   };
   excon = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0ala6123d3cv965ss48iyi0q4hcbzrznfwv2f1mr91sy98cigq4h";
+      sha256 = "1am69fn9nzj2pa05fd02q4zbzn1g7c9w5g52yjzdsbhm1x9n9g95";
       type = "gem";
     };
-    version = "0.111.0";
+    version = "1.2.3";
   };
   execjs = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1yywajqlpjhrj1m43s3lfg3i4lkb6pxwccmwps7qw37ndmphdzg8";
+      sha256 = "03a590q16nhqvfms0lh42mp6a1i41w41qpdnf39zjbq5y3l8pjvb";
       type = "gem";
     };
-    version = "2.9.1";
+    version = "2.10.0";
   };
   exifr = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "11v201jljn327fwjqcsglrbdnyhivnj7j6nh6wym5zjqgrwxy3kn";
+      sha256 = "155qqhai5z2742aqa4mwkxmqrpcv48siqz55rcx79wvgdg6790vn";
       type = "gem";
     };
-    version = "1.4.0";
+    version = "1.4.1";
+  };
+  extralite-bundle = {
+    groups = [ "migrations" ];
+    platforms = [ ];
+    source = {
+      remotes = [ "https://rubygems.org" ];
+      sha256 = "1x73a43hjw7f9vwlhfax4rmp7hpwaadvcamnbw31hh94bx3i71lv";
+      type = "gem";
+    };
+    version = "2.8.2";
   };
   fabrication = {
     groups = [
···
   faraday = {
     dependencies = [
       "faraday-net_http"
+      "json"
       "logger"
     ];
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1adx342h7s3imyrwwbda73g9ni1y07qj35br9lrzq4f5mh16qghs";
+      sha256 = "1mls9g490k63rdmjc9shqshqzznfn1y21wawkxrwp2vvbk13jwqm";
       type = "gem";
     };
-    version = "2.10.0";
+    version = "2.12.2";
   };
   faraday-net_http = {
     dependencies = [ "net-http" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0f49frpfdr8czwm2mjkfny4pini6fy49b6hamw4jrppl4vsg14ys";
+      sha256 = "0jp5ci6g40d6i50bsywp35l97nc2fpi9a592r2cibwicdb6y9wd1";
       type = "gem";
     };
-    version = "3.1.1";
+    version = "3.4.0";
   };
   faraday-retry = {
     dependencies = [ "faraday" ];
···
     ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "07139870npj59jnl8vmk39ja3gdk3fb5z9vc0lf32y2h891hwqsi";
+      sha256 = "0fgwn1grxf4zxmyqmb9i4z2hr111585n9jnk17y6y7hhs7dv1xi6";
       type = "gem";
     };
-    version = "1.17.0";
+    version = "1.17.1";
   };
   fspath = {
     groups = [ "default" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0vwnr6fmxig4pkag86yzbznpxk8ii7rhjz0rrprkqvnymhhfnscz";
+      sha256 = "0rmmp533ypc5c2r3ks8zqxchqkf1g8laig87f7hdfmwz0p07cmcs";
       type = "gem";
     };
-    version = "4.27.2";
+    version = "4.29.3";
   };
   guess_html_encoding = {
     groups = [ "default" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1jf9dxgjz6z7fvymyz2acyvn9iyvwkn6d9sk7y4fxwbmfc75yimm";
+      sha256 = "0xqsnx25lm1wwgchvrl5xla5zzk3d6gbkdfj062cwggdsvgfwc1c";
       type = "gem";
     };
-    version = "1.1.0";
+    version = "1.1.2";
   };
   hashie = {
     groups = [ "default" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1sxqnaz6wvkwbwzsipwsqcg1zw2kn67x7l362whv87zl5133w60l";
+      sha256 = "0jmvyhjp2v3iq47la7w6psrxbprnbnmzz0hxxski3vzn356x7jv7";
       type = "gem";
     };
-    version = "3.1.0";
+    version = "3.1.2";
   };
   htmlentities = {
     groups = [ "default" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1ffix518y7976qih9k1lgnc17i3v6yrlh0a3mckpxdb4wc2vrp16";
+      sha256 = "03sx3ahz1v5kbqjwxj48msw3maplpp2iyzs22l4jrzrqh4zmgfnf";
       type = "gem";
     };
-    version = "1.14.5";
+    version = "1.14.7";
   };
   image_optim = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "02iw1plldayr1l8bdw2gshq0h083h0fxwji1m1nfhzikz917c07p";
+      sha256 = "1h3n8x1rlxz4mkk49lij22x1nn0qk5cvir3fsj4x3s382a4x1zsv";
       type = "gem";
     };
-    version = "0.31.3";
+    version = "0.31.4";
   };
   image_size = {
     groups = [ "default" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "08d2lx42pa8jjav0lcjbzfzmw61b8imxr9041pva8xzqabrczp7h";
+      sha256 = "18pgvl7lfjpichdfh1g50rpz0zpaqrpr52ybn9liv1v9pjn9ysnd";
       type = "gem";
     };
-    version = "0.7.2";
+    version = "0.8.0";
   };
   irb = {
     dependencies = [
+      "pp"
       "rdoc"
       "reline"
     ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "05g6vpz3997q4j3xhrliswfx3g5flsn5cfn1p1s4h6dx7c0hbn2k";
+      sha256 = "1478m97wiy6nwg6lnl0szy39p46acsvrhax552vsh1s2mi2sgg6r";
       type = "gem";
     };
-    version = "1.14.0";
+    version = "1.15.1";
   };
   iso8601 = {
     groups = [ "default" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0b4qsi8gay7ncmigr0pnbxyb17y3h8kavdyhsh7nrlqwr35vb60q";
+      sha256 = "048danb0x10mpch6mf88mky35zjn6wk4hpbqq68ssbq58i3fzgfj";
       type = "gem";
     };
-    version = "2.7.2";
+    version = "2.9.1";
   };
   json-schema = {
-    dependencies = [ "addressable" ];
+    dependencies = [
+      "addressable"
+      "bigdecimal"
+    ];
     groups = [
       "default"
       "development"
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "09bq393nrxa7hmphc3li8idgxdnb5hwgj15d0q5qsh4l5g1qvrnm";
+      sha256 = "1gzrf6q4d9kbixj6bpi2bp8dizmqxcmlq30ni86h3ifzpkcrm0mk";
       type = "gem";
     };
-    version = "4.3.1";
+    version = "5.1.1";
   };
   json_schemer = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0dgbrps0ydiyxcgj5n4dny0cmzwj125x1s792l7m5jjrp1rs27wz";
+      sha256 = "093wb42zyy0a7kk7zxdvs0jivm0knlaz9lrsncjxjj2ppcbn3jsn";
       type = "gem";
     };
-    version = "2.3.0";
+    version = "2.4.0";
   };
   jwt = {
     dependencies = [ "base64" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "04mw326i9vsdcqwm4bf0zvnqw237f8l7022nhlbmak92bqqpg62s";
+      sha256 = "1i8wmzgb5nfhvkx1f6bhdwfm7v772172imh439v3xxhkv3hllhp6";
       type = "gem";
     };
-    version = "2.8.2";
+    version = "2.10.1";
   };
   kgio = {
     groups = [ "default" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0gvb1j8xsqxms9mww01rmdl78zkd72zgxaap56bhv8j45z05hp1x";
+      sha256 = "0scnz2fvdczdgadvjn0j9d49118aqm3hj66qh8sd2kv6g1j65164";
       type = "gem";
     };
-    version = "3.17.0.3";
+    version = "3.17.0.4";
   };
   libv8-node = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "13gmrl4lq1rfpdn76v5nid2hsajhrw27s6n88j09v26f0axgp4vp";
+      sha256 = "1ki1vjkq8nhmlz7rqi1ic0mjmbjsa7d1bgcvkzdl4q9vhaa5dzvn";
       type = "gem";
     };
-    version = "18.19.0.0";
+    version = "22.7.0.4";
   };
   listen = {
     dependencies = [
···
   logger = {
     groups = [
       "default"
+      "development"
       "test"
     ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0gpg8gzi0xwymw4aaq2iafcbx31i3xzkg3fb30mdxn1d4qhc3dqa";
+      sha256 = "0sz584vw17pwrrc5zg6yd8lqcgfpjf4qplq3s7fr0r3505nybky3";
       type = "gem";
     };
-    version = "1.6.0";
+    version = "1.6.5";
   };
   lograge = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1zkjqf37v2d7s11176cb35cl83wls5gm3adnfkn2zcc61h3nxmqh";
+      sha256 = "07pfa5kgl7k2hxlzzn89qna6bmiyrxlchgbzi0885frsi08agrk1";
       type = "gem";
     };
-    version = "2.22.0";
+    version = "2.24.0";
   };
   lru_redux = {
     groups = [ "default" ];
···
     ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1pv28xh8mss25fj4nd5r6zds1br8ssr2bpxr0md5pskv38m5qz0f";
+      sha256 = "1y58ba08n4lx123c0hjcc752fc4x802mjy39qj1hq50ak3vpv8br";
       type = "gem";
     };
-    version = "1.0.2";
+    version = "1.1.0";
   };
   message_bus = {
     dependencies = [ "rack" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1q1f2sdw3y3y9mnym9dhjgsjr72sq975cfg5c4yx7gwv8nmzbvhk";
+      sha256 = "0x8asxl83msn815lwmb2d7q5p29p7drhjv5va0byhk60v9n16iwf";
       type = "gem";
     };
-    version = "2.8.7";
+    version = "2.8.8";
   };
   mini_racer = {
     dependencies = [ "libv8-node" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1ling4ynn7na1cw69wzn8zn00jifwjrnprnynn05rcca1pzs58d1";
+      sha256 = "168a3crdgakm9mk5yrqlqsrx587rm7sk1f2l7sfs9cg87f7xb7ji";
       type = "gem";
     };
-    version = "0.14.1";
+    version = "0.17.0.pre13";
   };
   mini_scheduler = {
     dependencies = [ "sidekiq" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "19c72wlr0zsrg1fiak61h0z1b3glv2l23041xvlwv2i71fw5xavy";
+      sha256 = "00rmlcnwhi6gnrwpcv2yicm9ij8zs1mhsbx98ic6rmx8iprq9w6j";
       type = "gem";
     };
-    version = "0.16.0";
+    version = "0.18.0";
   };
   mini_sql = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0yrxjmwhfnvcwbj9vscyq0z67sq09zl8qhmzgakq2ywy4yvcpwgg";
+      sha256 = "1vnn88gv935szjz2hndnisfgys19k9z07237w11vpxaad9zn75jj";
       type = "gem";
     };
-    version = "1.5.0";
+    version = "1.6.0";
   };
   mini_suffix = {
     dependencies = [ "ffi" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0jj629q3vw5yn90q4di4dyb87pil4a8qfm2srhgy5nc8j2n33v1i";
+      sha256 = "0izrg03wn2yj3gd76ck7ifbm9h2kgy8kpg4fk06ckpy4bbicmwlw";
       type = "gem";
     };
-    version = "5.24.1";
+    version = "5.25.4";
   };
   mocha = {
     dependencies = [ "ruby2_keywords" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "04k1k9cmdv7q2p1b2z2y1k9dn1hhwjdlwkrp46gfq84v7887xhdl";
+      sha256 = "0lgqyxxdxgfik77a7lk2hjkr6flimgxr4gcbg3y7bg1ybn6m6zcg";
       type = "gem";
     };
-    version = "2.4.5";
+    version = "2.7.1";
   };
   msgpack = {
     groups = [ "default" ];
···
     ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1a5adcb7bwan09mqhj3wi9ib52hmdzmqg7q08pggn3adibyn5asr";
+      sha256 = "1a5fsgchkpcca4wf3pipbb2jbj523l7fbaq37j10cr0yymwlkc7z";
       type = "gem";
     };
-    version = "1.7.2";
+    version = "1.7.5";
   };
   multi_json = {
     groups = [ "default" ];
···
     };
     version = "1.1.1";
   };
-  mutex_m = {
-    groups = [ "default" ];
-    platforms = [ ];
-    source = {
-      remotes = [ "https://rubygems.org" ];
-      sha256 = "1ma093ayps1m92q845hmpk0dmadicvifkbf05rpq9pifhin0rvxn";
-      type = "gem";
-    };
-    version = "0.2.0";
-  };
   net-http = {
     dependencies = [ "uri" ];
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "10n2n9aq00ih8v881af88l1zyrqgs5cl3njdw8argjwbl5ggqvm9";
+      sha256 = "1ysrwaabhf0sn24jrp0nnp51cdv0jf688mh5i6fsz63q2c6b48cn";
       type = "gem";
     };
-    version = "0.4.1";
+    version = "0.6.0";
   };
   net-imap = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0rc08fxm10vv73bg0nqyp5bdvl4cvzb3y4cdk4kwmxx414zln652";
+      sha256 = "0ak8w6ypw4lba1y1mdmqwvkrh84ps6h9kd7hn029h9k85j9sirmb";
       type = "gem";
     };
-    version = "0.4.14";
+    version = "0.5.5";
   };
   net-pop = {
     dependencies = [ "net-protocol" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "017nbw87dpr4wyk81cgj8kxkxqgsgblrkxnmmadc77cg9gflrfal";
+      sha256 = "1a9www524fl1ykspznz54i0phfqya4x45hqaz67in9dvw1lfwpfr";
       type = "gem";
     };
-    version = "2.7.3";
+    version = "2.7.4";
   };
   nokogiri = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "15gysw8rassqgdq3kwgl4mhqmrgh7nk2qvrcqp4ijyqazgywn6gq";
+      sha256 = "1gzqcs1kkykj8lrnbxc1iwr1wqmmaml8l6wyxdvy0vqq6gxiqyck";
       type = "gem";
     };
-    version = "1.16.7";
+    version = "1.18.2";
   };
   oauth = {
     dependencies = [
···
     version = "1.4.11";
   };
   oj = {
-    dependencies = [ "bigdecimal" ];
+    dependencies = [
+      "bigdecimal"
+      "ostruct"
+    ];
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0b2narmcw4723lfyy7j0l4pfyv5n0qnmkm4mqgi832p5cg31k090";
+      sha256 = "091kbavd1rfiwr6kn1laladspyk67y6hdlsdilz752nqxm9w3ibg";
       type = "gem";
     };
-    version = "3.16.4";
+    version = "3.16.9";
   };
   omniauth = {
     dependencies = [
···
     dependencies = [
       "oauth"
       "omniauth"
+      "rack"
     ];
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0yw2vzx633p9wpdkd4jxsih6mw604mj7f6myyfikmj4d95c8d9z7";
+      sha256 = "1a4dqmlv3if6hb4ddyx4y5v7vkpi7zq901104nl0ya1l0b4j5gr5";
       type = "gem";
     };
-    version = "1.2.0";
+    version = "1.2.1";
   };
   omniauth-oauth2 = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "054d6ybgjdzxw567m7rbnd46yp6gkdbc5ihr536vxd3p15vbhjrw";
+      sha256 = "0ygfbbs3c61d32ymja2k6sznj5pr540cip9z91lhzcvsr4zmffpz";
       type = "gem";
     };
-    version = "3.2.0";
+    version = "3.3.0";
   };
   openssl-signature_algorithm = {
     dependencies = [ "openssl" ];
···
     ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0q4jqq3v1bxlfr9jgqmahnygkvl81lr6s1rhm8qg66c9xr9nz241";
+      sha256 = "073pk2rhyjq2vhdiz3xh2s884r15cvprw1yfjs7h9bmwdf1f9j81";
+      type = "gem";
+    };
+    version = "3.2.0";
+  };
+  ostruct = {
+    groups = [ "default" ];
+    platforms = [ ];
+    source = {
+      remotes = [ "https://rubygems.org" ];
+      sha256 = "05xqijcf80sza5pnlp1c8whdaay8x5dc13214ngh790zrizgp8q9";
       type = "gem";
     };
-    version = "3.1.0";
+    version = "0.6.1";
   };
   parallel = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "145bn5q7ysnjj02jdf1x4nc1f0xxrv7ihgz9yr1j7sinmawqkq0j";
+      sha256 = "1vy7sjs2pgz4i96v5yk9b7aafbffnvq7nn419fgvw55qlavsnsyq";
       type = "gem";
     };
-    version = "1.25.1";
+    version = "1.26.3";
   };
   parallel_tests = {
     dependencies = [ "parallel" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0q5q38sfrpwgcqwf5sl6xals5w11xayh8i9nq1vxya2sbrzrgbcq";
+      sha256 = "0nikqa0h9znbg31p3hl4y3280sqggjd7m47gmjydxw6iasm66l09";
       type = "gem";
     };
-    version = "4.7.1";
+    version = "4.9.0";
   };
   parser = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "10ly2wind06nylyqa5724ld2l0l46d3ag4fm04ifjgw7qdlpf94d";
+      sha256 = "16qi2qhpszm842awxghmsp64yvvawafq96w5jw98irz3f4bh2jbl";
       type = "gem";
     };
-    version = "3.3.4.0";
+    version = "3.3.7.0";
   };
   pg = {
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0pfj771p5a29yyyw58qacks464sl86d5m3jxjl5rlqqw2m3v5xq4";
+      sha256 = "1p2gqqrm895fzr9vi8d118zhql67bm8ydjvgqbq1crdnfggzn7kn";
       type = "gem";
     };
-    version = "1.5.4";
+    version = "1.5.9";
+  };
+  pp = {
+    dependencies = [ "prettyprint" ];
+    groups = [
+      "default"
+      "development"
+      "test"
+    ];
+    platforms = [ ];
+    source = {
+      remotes = [ "https://rubygems.org" ];
+      sha256 = "1zxnfxjni0r9l2x42fyq0sqpnaf5nakjbap8irgik4kg1h9c6zll";
+      type = "gem";
+    };
+    version = "0.6.2";
   };
   prettier_print = {
     groups = [
···
     };
     version = "1.2.1";
   };
+  prettyprint = {
+    groups = [
+      "default"
+      "development"
+      "test"
+    ];
+    platforms = [ ];
+    source = {
+      remotes = [ "https://rubygems.org" ];
+      sha256 = "14zicq3plqi217w6xahv7b8f7aj5kpxv1j1w98344ix9h5ay3j9b";
+      type = "gem";
+    };
+    version = "0.2.0";
+  };
   progress = {
     groups = [ "default" ];
     platforms = [ ];
···
     version = "0.6.1";
   };
   psych = {
-    dependencies = [ "stringio" ];
+    dependencies = [
+      "date"
+      "stringio"
+    ];
     groups = [
       "default"
       "development"
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0s5383m6004q76xm3lb732bp4sjzb6mxb6rbgn129gy2izsj4wrk";
+      sha256 = "1vjrx3yd596zzi42dcaq5xw7hil1921r769dlbz08iniaawlp9c4";
       type = "gem";
     };
-    version = "5.1.2";
+    version = "5.2.3";
   };
   public_suffix = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0i2vaww6qcazj0ywva1plmjnj6rk23b01szswc5jhcq7s2cikd1y";
+      sha256 = "11xd3207k5rl6bz0qxhcb3zcr941rhx7ig2f19gxxmdk7s3hcp7j";
       type = "gem";
     };
-    version = "6.4.2";
+    version = "6.6.0";
   };
   racc = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "021s7maw0c4d9a6s07vbmllrzqsj2sgmrwimlh8ffkvwqdjrld09";
+      sha256 = "0byn0c9nkahsl93y9ln5bysq4j31q8xkf2ws42swighxd4lnjzsa";
       type = "gem";
     };
-    version = "1.8.0";
+    version = "1.8.1";
   };
   rack = {
     groups = [
···
     ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0hj0rkw2z9r1lcg2wlrcld2n3phwrcgqcp7qd1g9a7hwgalh2qzx";
+      sha256 = "0ax778fsfvlhj7c11n0d1wdcb8bxvkb190a9lha5d91biwzyx9g4";
       type = "gem";
     };
-    version = "2.2.9";
+    version = "2.2.10";
   };
   rack-mini-profiler = {
     dependencies = [ "rack" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1ysx29gk9k14a14zsp5a8czys140wacvp91fja8xcja0j1hzqq8c";
+      sha256 = "0qy4ylhcfdn65a5mz2hly7g9vl0g13p5a0rmm6sc0sih5ilkcnh0";
       type = "gem";
     };
-    version = "2.1.0";
+    version = "2.2.0";
   };
   rackup = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1wbr03334ba9ilcq25wh9913xciwj0j117zs60vsqm0zgwdkwpp9";
+      sha256 = "0jf2ncj2nx56vh96hh2nh6h4r530nccxh87z7c2f37wq515611ms";
       type = "gem";
     };
-    version = "1.0.0";
+    version = "1.0.1";
   };
   rails-dom-testing = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1pm4z853nyz1bhhqr7fzl44alnx4bjachcr6rh6qjj375sfz3sc6";
+      sha256 = "0q55i6mpad20m2x1lg5pkqfpbmmapk0sjsrvr1sqgnj2hb5f5z1m";
       type = "gem";
     };
-    version = "1.6.0";
+    version = "1.6.2";
   };
   rails_failover = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1yxbh9xim46jqv9ap63ygvwv9bglbkqssn5hvr065gqly32mi407";
+      sha256 = "0pvwgm413fza8q1zc3mmzx504wiljm9d7b9qrkzfzsb2yzpidxs2";
       type = "gem";
     };
-    version = "2.1.1";
+    version = "2.2.0";
   };
   rails_multisite = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1zlfmm19k0p19jzknimqhhzs1phswmfgispph9b5fkag0w3ajxci";
+      sha256 = "1al624kvcxa5ijprali9gxp0bqv1w1573iswb5fkg4p2i4xvimvv";
       type = "gem";
     };
-    version = "6.0.0";
+    version = "6.1.0";
   };
   railties = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1z0slb2dlwrwgqijbk37hl4r9bh4h8vzcyswz6a9srl8lzrljq3c";
+      sha256 = "07zy8b88qxx493pc5sfkzvxqj3zcf363r1128n3hsvfx2vqipwg3";
       type = "gem";
     };
-    version = "7.1.3.4";
+    version = "7.2.2.1";
   };
   rainbow = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1isj1b3ywgg2m1vdlnr41lpvpm3dbyarf1lla4dfibfmad9csfk9";
+      sha256 = "1455yhd1arccrns3ghhvn4dl6gnrf4zn1xxsaa33ffyqrn399216";
       type = "gem";
     };
-    version = "1.8.0";
+    version = "1.9.0";
   };
   rdoc = {
     dependencies = [ "psych" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0ygk2zk0ky3d88v3ll7qh6xqvbvw5jin0hqdi1xkv1dhaw7myzdi";
+      sha256 = "0h00mb8wcj937srrafpjzq0klfi8rfpd4b3xpbvn9ghrn2wnzimy";
       type = "gem";
     };
-    version = "6.7.0";
+    version = "6.11.0";
   };
   redcarpet = {
     groups = [ "generic_import" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0ik40vcv7mqigsfpqpca36hpmnx0536xa825ai5qlkv3mmkyf9ss";
+      sha256 = "0qccah61pjvzyyg6mrp27w27dlv6vxlbznzipxjcswl7x3fhsvyb";
       type = "gem";
     };
-    version = "2.9.2";
+    version = "2.10.0";
   };
   reline = {
     dependencies = [ "io-console" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0y6kyz7kcilwdpfy3saqfgnar38vr5ys9sp40ndffy6h1znxfbax";
+      sha256 = "1lirwlw59apc8m1wjk85y2xidiv0fkxjn6f7p84yqmmyvish6qjp";
       type = "gem";
     };
-    version = "0.5.9";
+    version = "0.6.0";
   };
   request_store = {
     dependencies = [ "rack" ];
···
     version = "1.7.0";
   };
   rexml = {
-    dependencies = [ "strscan" ];
     groups = [
       "default"
-      "development"
       "test"
     ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0zr5qpa8lampaqzhdcjcvyqnrqcjl7439mqjlkjz43wdhmpnh4s5";
+      sha256 = "1ch4k2y80r4glr579kxliqnxld2qa91ydq8fiqam38bzpbps3gpg";
       type = "gem";
     };
-    version = "3.3.2";
+    version = "3.4.0";
   };
   rinku = {
     groups = [ "default" ];
···
     ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "072qvvrcqj0yfr3b0j932mlhvn41i38bq37z7z07i3ikagndkqwy";
+      sha256 = "1pchwrkr0994v7mh054lcp0na3bk3mj2sk0dc33bn6bhxrnirj1a";
       type = "gem";
     };
-    version = "4.3.0";
+    version = "4.5.1";
   };
   rqrcode = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0k252n7s80bvjvpskgfm285a3djjjqyjcarlh3aq7a4dx2s94xsm";
+      sha256 = "001kazj244cb6fbkmh7ap74csbr78717qaskqzqpir1q8xpdmywl";
       type = "gem";
     };
-    version = "3.13.0";
+    version = "3.13.2";
   };
   rspec-expectations = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0022nxs9gqfhx35n4klibig770n0j31pnkd8anz00yvrvkdghk41";
+      sha256 = "0n3cyrhsa75x5wwvskrrqk56jbjgdi2q1zx0irllf0chkgsmlsqf";
       type = "gem";
     };
-    version = "3.13.1";
+    version = "3.13.3";
   };
   rspec-html-matchers = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0f3vgp43hajw716vmgjv6f4ar6f97zf50snny6y3fy9kkj4qjw88";
+      sha256 = "1vxxkb2sf2b36d8ca2nq84kjf85fz4x7wqcvb8r6a5hfxxfk69r3";
       type = "gem";
     };
-    version = "3.13.1";
+    version = "3.13.2";
+  };
+  rspec-multi-mock = {
+    dependencies = [ "rspec" ];
+    groups = [
+      "development"
+      "test"
+    ];
+    platforms = [ ];
+    source = {
+      remotes = [ "https://rubygems.org" ];
+      sha256 = "0k3rafylxilq9jzdz450vgiwf3bvz4a9l3ppmgncv78xipr71518";
+      type = "gem";
+    };
+    version = "0.3.1";
   };
   rspec-rails = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0nqwvyma86zchh4ki416h7cms38h521ghyypaq27b6yvkmp3h8yw";
+      sha256 = "0izfwfb9bfb5q3wjgjc85b9nlkribqn8vk75zadafv08qilmnn4l";
       type = "gem";
     };
-    version = "6.1.3";
+    version = "7.1.0";
   };
   rspec-support = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "03z7gpqz5xkw9rf53835pa8a9vgj4lic54rnix9vfwmp2m7pv1s8";
+      sha256 = "1v6v6xvxcpkrrsrv7v1xgf7sl0d71vcfz1cnrjflpf6r7x3a58yf";
       type = "gem";
     };
-    version = "3.13.1";
+    version = "3.13.2";
   };
   rss = {
     dependencies = [ "rexml" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1wv27axi39hhr0nmaffdl5bdjqiafcvp9xhfgnsgfczsblja50sn";
+      sha256 = "0dv74a07j3ih5ykyszs1k2cjvgs5c1pzrvcb1wc2bfai8p038qml";
       type = "gem";
     };
-    version = "0.3.0";
+    version = "0.3.1";
   };
   rswag-specs = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1iyqd95l8r8m6jna451xb20lsp0jiajk1gbw845qlyqf6d69xyx2";
+      sha256 = "149apnslj99w2fvhlwk39k9wf5zlh1f03j0xs8pbvc08qj2n18lb";
       type = "gem";
     };
-    version = "2.13.0";
+    version = "2.16.0";
   };
   rtlcss = {
     dependencies = [ "mini_racer" ];
···
       "parser"
       "rainbow"
       "regexp_parser"
-      "rexml"
       "rubocop-ast"
       "ruby-progressbar"
       "unicode-display_width"
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "18g462bccr0rvszc7kirr89laggdf6254p7pqsckk3izg901chv2";
+      sha256 = "1ypwxjy2cp44278m9ljg3s937n2cd6x4yskcyzf1k9m3hkjd3pyk";
       type = "gem";
     };
-    version = "1.65.0";
+    version = "1.71.1";
   };
   rubocop-ast = {
     dependencies = [ "parser" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "063qgvqbyv354icl2sgx758z22wzq38hd9skc3n96sbpv0cdc1qv";
+      sha256 = "1bi6pgnii77763dzwhafcp8lrmnh4n1bqbdimhc9lfj4zs96gpsg";
       type = "gem";
     };
-    version = "1.31.3";
+    version = "1.38.0";
   };
   rubocop-capybara = {
     dependencies = [ "rubocop" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1bcy1zl88f4fxjsda2nf6k13kqrj60z8nsqdv9z51fdkv0aj82wk";
+      sha256 = "13n46107615lc8lkx4dh38hpzv4qxx4a0m6dvf0r21zxnvz7ysyl";
       type = "gem";
     };
-    version = "3.8.1";
+    version = "3.9.3";
   };
   rubocop-factory_bot = {
     dependencies = [ "rubocop" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "19g6m8ladix1dq8darrqnhbj6n3cgp2ivxnh48yj3nrgw0z97229";
+      sha256 = "1ahpgc22shmkk1n96rz3islcpx5sgg4z3mblynjz8qjxipsgrhj1";
       type = "gem";
     };
-    version = "2.25.1";
+    version = "2.29.1";
   };
   rubocop-rspec = {
     dependencies = [ "rubocop" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0495y1bwv5j6r9dak7860i6qnm68c53vz2bx2js5lwm6p7py147f";
+      sha256 = "11a89mzbby49hbd8nhkjrxpr8bq24fafl728mjkk15ccd8xw28c7";
       type = "gem";
     };
-    version = "3.0.3";
+    version = "3.4.0";
   };
   rubocop-rspec_rails = {
     dependencies = [
···
     ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0hnalxnvli6248g34n0bj8p3v35vpabak34qjg778bbaavbqg5h5";
+      sha256 = "097ac9ns2j29zj5fw08libz8izibrlfgg6vkj55d4bzrii296qq2";
       type = "gem";
     };
-    version = "1.7.0";
+    version = "1.7.1";
   };
   ruby-progressbar = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "11kqx5yp6syd99k1ksnw84b0sc3cr7icf63dibn2m025qg27ml2i";
+      sha256 = "032qqqaj5v09a7r5jpblv7dc37f278qv3b1nag9wsbn6kb4dslbk";
       type = "gem";
     };
-    version = "0.7.1";
+    version = "0.7.2";
   };
   ruby2_keywords = {
     groups = [
···
     version = "0.0.5";
   };
   rubyzip = {
-    groups = [ "default" ];
+    groups = [
+      "default"
+      "test"
+    ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0grps9197qyxakbpw02pda59v45lfgbgiyw48i0mq9f2bn9y6mrz";
+      sha256 = "05an0wz87vkmqwcwyh5rjiaavydfn5f4q1lixcsqkphzvj7chxw5";
       type = "gem";
     };
-    version = "2.3.2";
+    version = "2.4.1";
   };
   sanitize = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1c9j1rwdp87k7b7mawf8agpdycdr2dsl2wvjipmcy1c55kllp2qp";
+      sha256 = "111r4xdcf6ihdnrs6wkfc6nqdzrjq0z69x9sf83r7ri6fffip796";
       type = "gem";
     };
-    version = "6.1.2";
+    version = "7.0.0";
   };
   sass-embedded = {
     dependencies = [
···
     };
     version = "1.77.7";
   };
+  securerandom = {
+    groups = [
+      "default"
+      "development"
+      "test"
+    ];
+    platforms = [ ];
+    source = {
+      remotes = [ "https://rubygems.org" ];
+      sha256 = "1cd0iriqfsf1z91qg271sm88xjnfd92b832z49p1nd542ka96lfc";
+      type = "gem";
+    };
+    version = "0.4.1";
+  };
   selenium-devtools = {
     dependencies = [ "selenium-webdriver" ];
     groups = [ "test" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0ph7b947h5cgqyhb5a4jk467bggx48xy619ggh6p38ys8bjszp1l";
+      sha256 = "076vwy4x41hahcwni4bjkpc6fira79y1f9qbvx6w5ciwvn99k9qa";
       type = "gem";
     };
-    version = "0.126.0";
+    version = "0.132.0";
   };
   selenium-webdriver = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "00dq3450kadsvxh1lpndasy0bab0ilrjhrnvlicfmkvrx3gfs2j9";
+      sha256 = "1lw9b8gxr921akpc02zvwkig5m0m6y6xd438c6f1ysf3c8h75xsc";
       type = "gem";
     };
-    version = "4.23.0";
+    version = "4.28.0";
   };
   shoulda-matchers = {
     dependencies = [ "activesupport" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1pfq0w167v4055k0km64sxik1qslhsi32wl2jlidmfzkqmcw00m7";
+      sha256 = "1c082vpfdf3865xq6xayxw2hwqswhnc9g030p1gi4hmk9dzvnmch";
       type = "gem";
     };
-    version = "6.2.0";
+    version = "6.4.0";
   };
   sidekiq = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0yx01bxa8pbf9ip4hagqkp5m0mqfnwnw2xk8kjraiywz4lrss6jb";
+      sha256 = "02zi3rwihp7rlnp9x18c9idnkx7x68w6jmxdhyc0xrhjwrz0pasx";
       type = "gem";
     };
-    version = "0.12.3";
+    version = "0.13.1";
   };
   simplecov_json_formatter = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0lyc6mx4yalsnxc9yp4a5xra4nz1nwwbk5634wlfncml0ll1bnnw";
+      sha256 = "10ykzsa76cf8kvbfkszlvbyn4ckcx1mxjhfvwxzs7y28cljhzhkj";
       type = "gem";
     };
-    version = "3.7.3";
+    version = "3.7.5";
   };
   sprockets-rails = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0j7gwm749b3ff6544wxa878fpd1kvf2qc9fafassi8c7735jcin4";
+      sha256 = "17hiqkdpcjyyhlm997mgdcr45v35j5802m5a979i5jgqx5n8xs59";
       type = "gem";
     };
-    version = "3.5.1";
+    version = "3.5.2";
   };
   sqlite3 = {
     dependencies = [ "mini_portile2" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0k8myqn1g7sfmxs1h0x7jijh5ybszxw5153l0aq0w1cxp3zm6vij";
+      sha256 = "0sqshkafxa1r34yj4yxisd4kddmjq9jrhx6azqy3z71nwqv01yl7";
       type = "gem";
     };
-    version = "2.0.2";
+    version = "2.5.0";
   };
   sshkey = {
     groups = [ "default" ];
···
     ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1gdqqwnampxmc54nf6zfy9apkmkpdavzipvfssmjlhnrrjy8qh7f";
+      sha256 = "03788mbipmihq2w7rznzvv0ks0s9z1321k1jyr6ffln8as3d5xmg";
       type = "gem";
     };
-    version = "0.2.26";
+    version = "0.2.27";
   };
   stringio = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "07mfqb40b2wh53k33h91zva78f9zwcdnl85jiq74wnaw2wa6wiak";
+      sha256 = "0cd1kdrf62p2ya3ia4rz49d5012bqinvqjmcgkakknswz0l1hkr0";
       type = "gem";
     };
-    version = "3.1.1";
-  };
-  strscan = {
-    groups = [
-      "default"
-      "development"
-      "test"
-    ];
-    platforms = [ ];
-    source = {
-      remotes = [ "https://rubygems.org" ];
-      sha256 = "0mamrl7pxacbc79ny5hzmakc9grbjysm3yy6119ppgsg44fsif01";
-      type = "gem";
-    };
-    version = "3.1.0";
+    version = "3.1.2";
   };
   syntax_tree = {
     dependencies = [ "prettier_print" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0lxik4ngvbphivyhss9i59c67zxkc0z7k0r683qshw1gdkfxzd8f";
+      sha256 = "1vsk2ca9kfrxhyd2xiiyr28hmxkh9vd8j2vwl5f1yfnkv4z52n8s";
       type = "gem";
     };
-    version = "1.3.3.1";
+    version = "1.4.4";
   };
   thor = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1vq1fjp45az9hfp6fxljhdrkv75cvbab1jfrwcw738pnsiqk8zps";
+      sha256 = "1nmymd86a0vb39pzj2cwv57avdrl6pl3lf5bsz58q594kqxjkw7f";
       type = "gem";
     };
-    version = "1.3.1";
+    version = "1.3.2";
   };
   timeout = {
-    groups = [ "default" ];
+    groups = [
+      "default"
+      "development"
+      "test"
+    ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "16mvvsmx90023wrhf8dxc1lpqh0m8alk65shb7xcya6a9gflw7vg";
+      sha256 = "03p31w5ghqfsbz5mcjzvwgkw3h9lbvbknqvrdliy8pxmn9wz02cm";
       type = "gem";
     };
-    version = "0.4.1";
+    version = "0.4.3";
+  };
+  trilogy = {
+    groups = [ "migrations" ];
+    platforms = [ ];
+    source = {
+      remotes = [ "https://rubygems.org" ];
+      sha256 = "0zq6yrp1074yd5lflz7yqzpicpcg4bxrl7sxw5c4g2m67dk3pmm2";
+      type = "gem";
+    };
+    version = "2.9.0";
   };
   tzinfo = {
     dependencies = [ "concurrent-ruby" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1rg1dmx6mknjazb8qq0j9sb9fah470my5sbjb6f3pa6si5018682";
+      sha256 = "02yz3x0qxnnwbf7k18yck5pggbnyy43rq0d5w2r6rwlk3981m31d";
       type = "gem";
     };
-    version = "1.2024.1";
+    version = "1.2025.1";
   };
   uglifier = {
     dependencies = [ "execjs" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0wgh7bzy68vhv9v68061519dd8samcy8sazzz0w3k8kqpy3g4s5f";
+      sha256 = "1apmqsad2y1avffh79f4lfysfppz94fvpyi7lkkj3z8bn60jpm3m";
       type = "gem";
     };
-    version = "4.2.0";
+    version = "4.2.1";
   };
   unf = {
-    dependencies = [ "unf_ext" ];
     groups = [ "default" ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "0bh2cf73i2ffh4fcpdn9ir4mhq8zi50ik0zqa1braahzadx536a9";
+      sha256 = "1aq4bfddln9kx4lycqdgmahsssljsm3vfgbmb6a3y3nq07hw5g76";
       type = "gem";
     };
-    version = "0.1.4";
+    version = "0.2.0";
   };
-  unf_ext = {
-    groups = [ "default" ];
+  unicode-display_width = {
+    dependencies = [ "unicode-emoji" ];
+    groups = [
+      "default"
+      "development"
+      "test"
+    ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1sf6bxvf6x8gihv6j63iakixmdddgls58cpxpg32chckb2l18qcj";
+      sha256 = "1has87asspm6m9wgqas8ghhhwyf2i1yqrqgrkv47xw7jq3qjmbwc";
       type = "gem";
     };
-    version = "0.0.9.1";
+    version = "3.1.4";
   };
-  unicode-display_width = {
+  unicode-emoji = {
     groups = [
       "default"
       "development"
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1d0azx233nags5jx3fqyr23qa2rhgzbhv8pxp46dgbg1mpf82xky";
+      sha256 = "0ajk6rngypm3chvl6r0vwv36q1931fjqaqhjjya81rakygvlwb1c";
       type = "gem";
     };
-    version = "2.5.0";
+    version = "4.0.4";
   };
   unicorn = {
     dependencies = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "094gk72ckazf495qc76gk09b5i318d5l9m7bicg2wxlrjcm3qm96";
+      sha256 = "09qyg6a29cfgd46qid8qvx4sjbv596v19ym73xvhanbyxd6500xk";
+      type = "gem";
+    };
+    version = "1.0.2";
+  };
+  useragent = {
+    groups = [
+      "default"
+      "development"
+      "test"
+    ];
+    platforms = [ ];
+    source = {
+      remotes = [ "https://rubygems.org" ];
+      sha256 = "0i1q2xdjam4d7gwwc35lfnz0wyyzvnca0zslcfxm9fabml9n83kh";
       type = "gem";
     };
-    version = "0.13.0";
+    version = "0.16.11";
   };
   version_gem = {
     groups = [ "default" ];
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "158d2ikjfzw43kgm095klp43ihphk0cv5xjprk44w73xfv03i9qg";
+      sha256 = "08kixkdp41dw39kqfxf2wp5m4z9b6fxg6yfa6xin0wy7dxzka0dy";
       type = "gem";
     };
-    version = "3.23.1";
+    version = "3.24.0";
   };
   webrick = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "13qm7s0gr2pmfcl7dxrmq38asaza4w0i2n9my4yzs499j731wh8r";
+      sha256 = "12d9n8hll67j737ym2zw4v23cn4vxyfkb6vyv1rzpwv6y6a3qbdl";
       type = "gem";
     };
-    version = "1.8.1";
+    version = "1.9.1";
   };
   websocket = {
     groups = [
···
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "1r0b8w58p7gy06wph1qdjv2p087hfnmhd9jk23vjdj803dn761am";
+      sha256 = "14k9lb9a60r9z2zcqg08by9iljrrgjxdkbd91gw17rkqkqwi1sd6";
       type = "gem";
     };
-    version = "0.9.36";
+    version = "0.9.37";
   };
   zeitwerk = {
     groups = [
       "default"
       "development"
+      "migrations"
       "test"
     ];
     platforms = [ ];
     source = {
       remotes = [ "https://rubygems.org" ];
-      sha256 = "08cfb35232p9s1r4jqv8wacv38vxh699mgbr9y03ga89gx9lipqp";
+      sha256 = "0mi7b90hvc6nqv37q27df4i2m27yy56yfy2ki5073474a1h9hi89";
       type = "gem";
     };
-    version = "2.6.16";
+    version = "2.7.1";
   };
 }

pkgs/servers/web-apps/discourse/update.py

···
 #!/usr/bin/env nix-shell
-#! nix-shell -i python3 -p "python3.withPackages (ps: with ps; [ requests click click-log packaging ])" bundix bundler nix-update nurl prefetch-yarn-deps
+#! nix-shell -i python3 -p "python3.withPackages (ps: with ps; [ requests click click-log packaging ])" bundix bundler nix-update nurl
 from __future__ import annotations
 
 import click
···
 
         return self._latest_commit_sha
 
-    def get_yarn_lock_hash(self, rev: str, path: str):
-        yarnLockText = self.get_file(path, rev)
-        with tempfile.NamedTemporaryFile(mode='w') as lockFile:
-            lockFile.write(yarnLockText)
-            hash = subprocess.check_output(['prefetch-yarn-deps', lockFile.name]).decode().strip()
-            return subprocess.check_output(["nix", "hash", "to-sri", "--type", "sha256", hash]).decode().strip()
-
     def get_file(self, filepath, rev):
         """Return file contents at a given rev.
 
···
         r = requests.get(f'https://raw.githubusercontent.com/{self.owner}/{self.repo}/{rev}/{filepath}')
         r.raise_for_status()
         return r.text
+
+
+def _get_build_lock_hash():
+    nixpkgs_path = Path(__file__).parent / '../../../../'
+    output = subprocess.run(['nix-build', '-A', 'discourse'], text=True, cwd=nixpkgs_path, capture_output=True)
+    # The line is of the form "    got:    sha256-xxx"
+    lines = [i.strip() for i in output.stderr.splitlines()]
+    new_hash_lines = [i.strip("got:").strip() for i in lines if i.startswith("got:")]
+    if len(new_hash_lines) == 0:
+        if output.returncode != 0:
+            print("Error while fetching new hash with nix build")
+            print(output.stderr)
+        print("No hash change is needed")
+        return None
+    if len(new_hash_lines) > 1:
+        print(new_hash_lines)
+        raise Exception("Got an unexpected number of new hash lines:")
+    return new_hash_lines[0]
 
 
 def _call_nix_update(pkg, version):
···
 
     _call_nix_update('discourse', version.version)
 
-    old_yarn_hash = _nix_eval('discourse.assets.yarnOfflineCache.outputHash')
-    new_yarn_hash = repo.get_yarn_lock_hash(version.tag, "yarn.lock")
-    click.echo(f"Updating yarn lock hash: {old_yarn_hash} -> {new_yarn_hash}")
+    old_pnpm_hash = _nix_eval('discourse.assets.pnpmDeps.outputHash')
+    new_pnpm_hash = _get_build_lock_hash()
+    if new_pnpm_hash is not None:
+        click.echo(f"Updating yarn lock hash: {old_pnpm_hash} -> {new_pnpm_hash}")
 
-    with open(Path(__file__).parent / "default.nix", 'r+') as f:
-        content = f.read()
-        content = content.replace(old_yarn_hash, new_yarn_hash)
-        f.seek(0)
-        f.write(content)
-        f.truncate()
+        with open(Path(__file__).parent / "default.nix", 'r+') as f:
+            content = f.read()
+            content = content.replace(old_pnpm_hash, new_pnpm_hash)
+            f.seek(0)
+            f.write(content)
+            f.truncate()
 
 
 @cli.command()
···
         {'name': 'discourse-saved-searches'},
         {'name': 'discourse-solved'},
         {'name': 'discourse-spoiler-alert'},
-        {'name': 'discourse-voting'},
+        {'name': 'discourse-voting', 'repo_name': "discourse-topic-voting"},
         {'name': 'discourse-yearly-review'},
     ]
 
···
         # https://meta.discourse.org/t/pinning-plugin-and-theme-versions-for-older-discourse-installs/156971
         # this makes sure we don't upgrade plugins to revisions that
         # are incompatible with the packaged Discourse version
+        repo_latest_commit = repo.latest_commit_sha
         try:
-            compatibility_spec = repo.get_file('.discourse-compatibility', repo.latest_commit_sha)
+            compatibility_spec = repo.get_file('.discourse-compatibility', repo_latest_commit)
             versions = [(DiscourseVersion(discourse_version), plugin_rev.strip(' '))
                         for [discourse_version, plugin_rev]
                         in [line.lstrip("< ").split(':')
···
             discourse_version = DiscourseVersion(_get_current_package_version('discourse'))
             versions = list(filter(lambda ver: ver[0] >= discourse_version, versions))
             if versions == []:
-                rev = repo.latest_commit_sha
+                rev = repo_latest_commit
             else:
                 rev = versions[0][1]
                 print(rev)
         except requests.exceptions.HTTPError:
-            rev = repo.latest_commit_sha
+            rev = repo_latest_commit
 
         filename = _nix_eval(f'builtins.unsafeGetAttrPos "src" discourse.plugins.{name}')
         if filename is None:

pkgs/tools/package-management/nix-prefetch-scripts/default.nix

···
         description = "Script used to obtain source hashes for fetch${tool}";
         maintainers = with maintainers; [ bennofs ];
         platforms = platforms.unix;
+        mainProgram = "nix-prefetch-${tool}";
       };
     };
 in

pkgs/top-level/aliases.nix

···
   prometheus-openldap-exporter = throw "'prometheus-openldap-exporter' has been removed from nixpkgs, as it was unmaintained"; # Added 2024-09-01
   prometheus-minio-exporter = throw "'prometheus-minio-exporter' has been removed from nixpkgs, use Minio's built-in Prometheus integration instead"; # Added 2024-06-10
   prometheus-tor-exporter = throw "'prometheus-tor-exporter' has been removed from nixpkgs, as it was broken and unmaintained"; # Added 2024-10-30
+  protobuf_23 = throw "'protobuf_23' has been removed from nixpkgs. Consider using a more recent version of the protobuf library"; # Added 2025-04-20
   protobuf3_24 = protobuf_24;
   protobuf3_23 = protobuf_23;
   protobuf3_21 = protobuf_21;
···
   SDL_classic = SDL1; # Added 2024-09-03
   SDL1 = throw "'SDL1' has been removed as development ended long ago with SDL 2.0 replacing it, use SDL_compat instead"; # Added 2025-03-27
   SDL_gpu = throw "'SDL_gpu' has been removed due to lack of upstream maintenance and known users"; # Added 2025-03-15
+  SDL_image_2_0 = throw "'SDL_image_2_0' has been removed in favor of the latest version"; # Added 2025-04-20
   s2n = throw "'s2n' has been renamed to/replaced by 's2n-tls'"; # Converted to throw 2024-10-17
   sandboxfs = throw "'sandboxfs' has been removed due to being unmaintained, consider using linux namespaces for sandboxing instead"; # Added 2024-06-06
   sane-backends-git = throw "'sane-backends-git' has been renamed to/replaced by 'sane-backends'"; # Converted to throw 2024-10-17

pkgs/top-level/all-packages.nix

···
 
   copilot-language-server-fhs = copilot-language-server.fhs;
 
-  databricks-sql-cli = callPackage ../applications/misc/databricks-sql-cli { };
-
   deck = callPackage ../by-name/de/deck/package.nix {
     buildGoModule = buildGo123Module;
   };
···
   enochecker-test = with python3Packages; callPackage ../development/tools/enochecker-test { };
 
   inherit (gridlock) nyarr;
-
-  html5validator = callPackage ../applications/misc/html5validator { };
 
   inspec = callPackage ../tools/misc/inspec { };
 
···
 
   mpy-utils = python3Packages.callPackage ../tools/misc/mpy-utils { };
 
-  mymcplus = callPackage ../tools/games/mymcplus { };
-
   networkd-notify = python3Packages.callPackage ../tools/networking/networkd-notify {
     systemd = pkgs.systemd;
   };
···
   sdkmanager = with python3Packages; toPythonApplication sdkmanager;
 
   shaperglot = with python3Packages; toPythonApplication shaperglot;
-
-  snagboot = callPackage ../applications/misc/snagboot { };
 
   slipstream = callPackage ../tools/games/slipstream {
     jdk = jdk8;
···
     pythonPackages = python3Packages;
   };
 
-  gitmux = callPackage ../applications/version-management/gitmux { };
-
   gittyup = libsForQt5.callPackage ../applications/version-management/gittyup { };
 
   lucky-commit = callPackage ../applications/version-management/lucky-commit { };
···
 
   certipy = with python3Packages; toPythonApplication certipy-ad;
 
-  catcli = callPackage ../tools/filesystems/catcli { };
-
   chipsec = callPackage ../tools/security/chipsec {
     kernel = null;
     withDriver = false;
···
 
   catch2_3 = callPackage ../development/libraries/catch2/3.nix { };
 
-  cardpeek = callPackage ../applications/misc/cardpeek { };
-
   ceres-solver = callPackage ../development/libraries/ceres-solver {
     gflags = null; # only required for examples/tests
   };
···
   clickgen = with python3Packages; toPythonApplication clickgen;
 
   cloud-init = callPackage ../tools/virtualization/cloud-init { inherit systemd; };
-
-  cloudflared = callPackage ../applications/networking/cloudflared { };
 
   clingo = callPackage ../applications/science/logic/potassco/clingo.nix { };
 
···
     enableSSH = true;
   };
 
-  easyabc = callPackage ../applications/audio/easyabc { };
-
   easyaudiosync = qt6Packages.callPackage ../applications/audio/easyaudiosync { };
 
   easycrypt = callPackage ../applications/science/logic/easycrypt {
···
 
   dvtm-unstable = callPackage ../tools/misc/dvtm/unstable.nix { };
 
-  ecryptfs = callPackage ../tools/security/ecryptfs { };
-
   eid-mw = callPackage ../tools/security/eid-mw {
     autoreconfHook = buildPackages.autoreconfHook269;
   };
···
   wrangler_1 = callPackage ../development/tools/wrangler_1 { };
 
   xkcdpass = with python3Packages; toPythonApplication xkcdpass;
-
-  zee = callPackage ../applications/editors/zee { };
 
   zeek = callPackage ../applications/networking/ids/zeek { };
 
···
 
   pinentry_mac = callPackage ../tools/security/pinentry/mac.nix { };
 
-  pingu = callPackage ../tools/networking/pingu { };
-
   pinnwand = callPackage ../servers/pinnwand { };
 
   piping-server-rust = callPackage ../servers/piping-server-rust { };
···
 
   texmaker = qt6Packages.callPackage ../applications/editors/texmaker { };
 
-  textadept = libsForQt5.callPackage ../applications/editors/textadept { };
-
   texworks = qt6Packages.callPackage ../applications/editors/texworks { };
 
   theLoungePlugins =
···
     python3Packages.callPackage ../applications/misc/twitch-chat-downloader
       { };
 
-  twtxt = callPackage ../applications/networking/twtxt { };
-
   twurl = callPackage ../tools/misc/twurl { };
-
-  ubidump = callPackage ../tools/filesystems/ubidump { };
 
   ubpm = libsForQt5.callPackage ../applications/misc/ubpm { };
 
···
   crystalline = callPackage ../development/tools/language-servers/crystalline {
     llvmPackages = crystal.llvmPackages;
   };
-
-  devpi-client = callPackage ../development/tools/devpi-client { };
 
   devpi-server = python3Packages.callPackage ../development/tools/devpi-server { };
 
···
   cargo-fund = callPackage ../development/tools/rust/cargo-fund { };
   cargo-hf2 = callPackage ../development/tools/rust/cargo-hf2 { };
   cargo-ndk = callPackage ../development/tools/rust/cargo-ndk { };
-
+  cargo-rdme = callPackage ../by-name/ca/cargo-rdme/package.nix { };
   cargo-udeps = callPackage ../development/tools/rust/cargo-udeps { };
   cargo-vet = callPackage ../development/tools/rust/cargo-vet { };
   cargo-watch = callPackage ../development/tools/rust/cargo-watch { };
···
     )
       haskellPackages.haskell-ci;
 
-  nimbo = callPackage ../applications/misc/nimbo { };
-
   nixbang = callPackage ../development/tools/misc/nixbang {
     pythonPackages = python3Packages;
   };
···
   swftools = callPackage ../tools/video/swftools {
     stdenv = gccStdenv;
   };
-
-  tarmac = callPackage ../development/tools/tarmac { };
 
   teensyduino = arduino-core.override {
     withGui = true;
···
 
   aribb25 = callPackage ../development/libraries/aribb25 { };
 
-  arrayfire = callPackage ../development/libraries/arrayfire { };
-
   asio_1_10 = callPackage ../development/libraries/asio/1.10.nix { };
   asio = callPackage ../development/libraries/asio { };
 
···
 
   enchant2 = callPackage ../development/libraries/enchant/2.x.nix { };
   enchant = enchant2;
-
-  libepoxy = callPackage ../development/libraries/libepoxy { };
 
   factorPackages-0_99 = callPackage ./factor-packages.nix {
     factor-unwrapped = callPackage ../development/compilers/factor-lang/0.99.nix { };
···
       protobuf_26 = callPackage ../development/libraries/protobuf/26.nix { };
       protobuf_25 = callPackage ../development/libraries/protobuf/25.nix { };
       protobuf_24 = callPackage ../development/libraries/protobuf/24.nix { };
-      protobuf_23 = callPackage ../development/libraries/protobuf/23.nix {
-        abseil-cpp = abseil-cpp_202301;
-      };
       protobuf_21 = callPackage ../development/libraries/protobuf/21.nix {
         abseil-cpp = abseil-cpp_202103;
       };
···
     protobuf_26
     protobuf_25
     protobuf_24
-    protobuf_23
     protobuf_21
     ;
 
···
 
   airwave = libsForQt5.callPackage ../applications/audio/airwave { };
 
-  alembic = callPackage ../development/libraries/alembic { };
-
   amarok = libsForQt5.callPackage ../applications/audio/amarok { };
   amarok-kf5 = amarok; # for compatibility
 
···
   openrsync = callPackage ../applications/networking/sync/openrsync { };
 
   openscad = libsForQt5.callPackage ../applications/graphics/openscad { };
-
-  opentimestamps-client = callPackage ../tools/misc/opentimestamps-client { };
 
   opentoonz = libsForQt5.callPackage ../applications/graphics/opentoonz { };
 
···
     inherit (xfce) xfce4-dev-tools;
   };
 
-  ly = callPackage ../applications/display-managers/ly { };
-
   curaengine_stable = callPackage ../applications/misc/curaengine/stable.nix { };
 
   curaengine = callPackage ../applications/misc/curaengine {
···
   };
 
   trojita = libsForQt5.callPackage ../applications/networking/mailreaders/trojita { };
-
-  tunefish = callPackage ../applications/audio/tunefish { };
 
   tuxclocker = libsForQt5.callPackage ../applications/misc/tuxclocker {
     tuxclocker-plugins = tuxclocker-plugins-with-unfree;
···
 
   dwarf-fortress-packages = recurseIntoAttrs (callPackage ../games/dwarf-fortress { });
 
-  dwarf-fortress = dwarf-fortress-packages.dwarf-fortress;
+  inherit (dwarf-fortress-packages) dwarf-fortress dwarf-fortress-full dwarf-therapist;
 
-  dwarf-therapist = dwarf-fortress-packages.dwarf-therapist;
+  dfhack = dwarf-fortress-packages.dwarf-fortress-full;
 
   dxx-rebirth = callPackage ../games/dxx-rebirth { };
 
···
 
   gscrabble = python3Packages.callPackage ../games/gscrabble { };
 
-  gshogi = callPackage ../games/gshogi { };
-
   qtads = qt5.callPackage ../games/qtads { };
 
   ibmcloud-cli = callPackage ../tools/admin/ibmcloud-cli { stdenv = stdenvNoCC; };
···
     target = "server";
     protobuf = protobuf_21;
   };
-
-  pysolfc = callPackage ../games/pysolfc { };
 
   quake3wrapper = callPackage ../games/quake3/wrapper { };
 
···
     inherit (ocaml-ng.ocamlPackages_4_14) ocaml;
   };
 
-  nextinspace = callPackage ../applications/science/misc/nextinspace { };
-
   ns-3 = callPackage ../development/libraries/science/networking/ns-3 { python = python3; };
 
   rink = callPackage ../applications/science/misc/rink { };
···
   terraforming = callPackage ../applications/networking/cluster/terraforming { };
 
   terraform-landscape = callPackage ../applications/networking/cluster/terraform-landscape { };
-
-  tftui = callPackage ../applications/networking/cluster/tftui { };
 
   trufflehog = callPackage ../tools/security/trufflehog {
     buildGoModule = buildGo123Module;

pkgs/top-level/python-aliases.nix

···
   ruamel_base = ruamel-base; # added 2021-11-01
   ruamel_yaml = ruamel-yaml; # added 2021-11-01
   ruamel_yaml_clib = ruamel-yaml-clib; # added 2021-11-01
-  inherit (super.pkgs) ruff-lsp; # added 2023-06-23
+  ruff-lsp = throw "ruff-lsp has been deprecated, use `ruff server` instead"; # added 2025-04-21
   runway-python = throw "SDK has been deprecated and was archived by upstream"; # added 2023-05-03
   safe = throw "safe has been removed, it was unmaintained sinced October 2019"; # added 2024-07-28
   sampledata = throw "sampledata has been removed, it was unmaintained since 2017"; # added 2024-07-27

pkgs/top-level/python-packages.nix

···
 
   pygal = callPackage ../development/python-modules/pygal { };
 
-  pygame = callPackage ../development/python-modules/pygame { SDL2_image = pkgs.SDL2_image_2_0; };
+  pygame = callPackage ../development/python-modules/pygame { };
 
   pygame-ce = callPackage ../development/python-modules/pygame-ce {
     SDL2_image = pkgs.SDL2_image_2_0;