Merge staging-next into staging

.github/workflows/periodic-merge-24h.yml

@@ -22,7 +22,7 @@ defaults:
 
 jobs:
   periodic-merge:
-    if: github.repository_owner == 'NixOS'
+    if: github.repository_owner == 'NixOS' || github.event_name == 'workflow_dispatch'
     strategy:
       # don't fail fast, so that all pairs are tried
       fail-fast: false
@@ -49,3 +49,34 @@ jobs:
     name: ${{ matrix.pairs.name || format('{0} → {1}', matrix.pairs.from, matrix.pairs.into) }}
     secrets:
       NIXPKGS_CI_APP_PRIVATE_KEY: ${{ secrets.NIXPKGS_CI_APP_PRIVATE_KEY }}
+
+  # Resets the target branch of the current haskell-updates PR.
+  # This makes GitHub hide all the commits that are already part of staging and gives us a much clearer PR view.
+  haskell-updates:
+    needs: periodic-merge
+    runs-on: ubuntu-slim
+    permissions:
+      pull-requests: write
+    steps:
+      - name: Find PR and update target branch
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        with:
+          script: |
+            // There will at most be a single haskell-updates PR anyway, so no need to paginate.
+            await Promise.all(
+              (
+                await github.rest.pulls.list({
+                  ...context.repo,
+                  state: 'open',
+                  head: `${context.repo.owner}:haskell-updates`,
+                })
+              ).data.map((pr) =>
+                github.rest.pulls.update({
+                  ...context.repo,
+                  pull_number: pr.number,
+                  // Just updating to the same branch to trigger a UI update.
+                  // This is staging most of the time, but could be staging-next in rare cases.
+                  base: pr.base.ref,
+                }),
+              ),
+            )

.github/workflows/periodic-merge-6h.yml

@@ -22,7 +22,7 @@ defaults:
 
 jobs:
   periodic-merge:
-    if: github.repository_owner == 'NixOS'
+    if: github.repository_owner == 'NixOS' || github.event_name == 'workflow_dispatch'
     strategy:
       # don't fail fast, so that all pairs are tried
       fail-fast: false

lib/modules.nix

@@ -1598,6 +1598,28 @@ let
     inherit priority content;
   };
 
+  /**
+    Applies a function to the value inside a definition,
+    preserving all surrounding properties (`mkForce`, `mkOrder`, `mkIf`, etc.).
+  */
+  mapDefinitionValue =
+    f: def:
+    if def ? _type then
+      if def._type == "merge" then
+        def // { contents = map (mapDefinitionValue f) def.contents; }
+      else if def._type == "if" then
+        def // { content = mapDefinitionValue f def.content; }
+      else if def._type == "override" then
+        def // { content = mapDefinitionValue f def.content; }
+      else if def._type == "order" then
+        def // { content = mapDefinitionValue f def.content; }
+      else if def._type == "definition" then
+        def // { value = mapDefinitionValue f def.value; }
+      else
+        f def
+    else
+      f def;
+
   mkBefore = mkOrder 500;
   defaultOrderPriority = 1000;
   mkAfter = mkOrder 1500;
@@ -2302,6 +2324,7 @@ private
     importApply
     importJSON
     importTOML
+    mapDefinitionValue
     mergeDefinitions
     mergeAttrDefinitionsWithPrio
     mergeOptionDecls # should be private?

lib/tests/misc.nix

@@ -5114,4 +5114,96 @@ runTests {
     );
     expected = false;
   };
+
+  # mapDefinitionValue
+
+  testMapDefinitionValuePlain = {
+    expr = lib.modules.mapDefinitionValue (x: x + 1) 5;
+    expected = 6;
+  };
+
+  testMapDefinitionValueMkForce = {
+    expr = lib.modules.mapDefinitionValue (x: x + 1) (lib.mkForce 5);
+    expected = lib.mkForce 6;
+  };
+
+  testMapDefinitionValueMkDefault = {
+    expr = lib.modules.mapDefinitionValue (x: x + 1) (lib.mkDefault 5);
+    expected = lib.mkDefault 6;
+  };
+
+  testMapDefinitionValueMkOrder = {
+    expr = lib.modules.mapDefinitionValue (x: x + 1) (lib.mkOrder 500 5);
+    expected = lib.mkOrder 500 6;
+  };
+
+  testMapDefinitionValueMkOverrideNested = {
+    expr = lib.modules.mapDefinitionValue (x: x + 1) (lib.mkForce (lib.mkOrder 500 5));
+    expected = lib.mkForce (lib.mkOrder 500 6);
+  };
+
+  testMapDefinitionValueMkIf = {
+    expr = lib.modules.mapDefinitionValue (x: x + 1) (lib.mkIf true 5);
+    expected = lib.mkIf true 6;
+  };
+
+  testMapDefinitionValueMkMerge = {
+    expr = lib.modules.mapDefinitionValue (x: x + 1) (
+      lib.mkMerge [
+        5
+        10
+      ]
+    );
+    expected = lib.mkMerge [
+      6
+      11
+    ];
+  };
+
+  testMapDefinitionValueMkDefinition = {
+    expr = lib.modules.mapDefinitionValue (x: x + 1) (
+      lib.mkDefinition {
+        file = "test";
+        value = 5;
+      }
+    );
+    expected = lib.mkDefinition {
+      file = "test";
+      value = 6;
+    };
+  };
+
+  testMapDefinitionValueDeep = {
+    expr = lib.modules.mapDefinitionValue (x: x + 1) (lib.mkIf true (lib.mkForce (lib.mkOrder 500 5)));
+    expected = lib.mkIf true (lib.mkForce (lib.mkOrder 500 6));
+  };
+
+  testMapDefinitionValueAllNested = {
+    expr = lib.modules.mapDefinitionValue (x: x + 1) (
+      lib.mkMerge [
+        (lib.mkIf true (
+          lib.mkForce (
+            lib.mkOrder 500 (
+              lib.mkDefinition {
+                file = "test";
+                value = lib.mkBefore 5;
+              }
+            )
+          )
+        ))
+      ]
+    );
+    expected = lib.mkMerge [
+      (lib.mkIf true (
+        lib.mkForce (
+          lib.mkOrder 500 (
+            lib.mkDefinition {
+              file = "test";
+              value = lib.mkBefore 6;
+            }
+          )
+        )
+      ))
+    ];
+  };
 }

lib/tests/modules.sh

@@ -899,6 +899,19 @@ checkConfigError 'Did you mean .enable., .ebe. or .enabled.\?' config ./error-ty
 checkConfigError 'Did you mean .services\.myservice\.port. or .services\.myservice\.enable.\?' config.services.myservice ./error-typo-submodule.nix
 checkConfigError 'Did you mean .services\.nginx\.virtualHosts\."example\.com"\.ssl\.certificate. or .services\.nginx\.virtualHosts\."example\.com"\.ssl\.certificateKey.\?' config.services.nginx.virtualHosts.\"example.com\" ./error-typo-deeply-nested.nix
 
+# types.attrListOf
+checkConfigOutput '"ok"' config.assertions ./declare-attrList.nix
+checkConfigError 'A definition for option .attrListInt.badValue.a. is not of type .signed integer.. Definition values:' config.attrListIntStrict.badValue ./declare-attrList.nix
+checkConfigError 'A definition for option .attrList.badListElem. is not of type .attribute list of string.. Each list element must be a single-key attribute set, but got 2 keys' config.attrListStrict.badListElem ./declare-attrList.nix
+checkConfigError 'A definition for option .attrList.badString. is not of type .attribute list of string.. TypeError: Definition values:' config.attrListStrict.badString ./declare-attrList.nix
+checkConfigError 'A definition for option .attrList.badListString. is not of type .attribute list of string.. Each list element must be an attribute set, but got string' config.attrListStrict.badListString ./declare-attrList.nix
+
+# attrListWith valueMeta.definitions: file propagation
+checkConfigError 'the-defs-file\.nix' config.argv ./attrList-valueMeta-definitions-file-diagnostic-forwarding.nix
+
+# attrListOf does not support type merging
+checkConfigError 'The option .merged. in .*/declare-attrList-type-merge.nix. is already declared in .*/declare-attrList-type-merge.nix' config.merged ./declare-attrList-type-merge.nix
+
 cat <<EOF
 ====== module tests ======
 $pass Pass

lib/tests/modules/attrList-valueMeta-definitions-file-diagnostic-forwarding.nix

@@ -0,0 +1,25 @@
+{ lib, options, ... }:
+let
+  inherit (lib) mkOption mkMerge types;
+in
+{
+  imports = [
+    {
+      _file = "the-defs-file.nix";
+      config.flags.my-flag = 3.14;
+    }
+  ];
+
+  options.flags = mkOption {
+    type = types.attrListWith {
+      elemType = types.anything;
+      asAttrs = true;
+      mergeAttrValues = _name: vs: lib.head vs;
+    };
+  };
+  options.argv = mkOption { type = types.listOf types.str; };
+
+  # Feed definitions into argv; the float from the-defs-file.nix should cause
+  # a type error mentioning that file
+  config.argv = mkMerge options.flags.valueMeta.definitions;
+}

lib/tests/modules/declare-attrList-type-merge.nix

@@ -0,0 +1,12 @@
+# Test that attrListOf does not support type merging:
+# two declarations of the same option should fail.
+{ lib, ... }:
+let
+  inherit (lib) mkOption types;
+in
+{
+  imports = [
+    { options.merged = mkOption { type = types.attrListOf types.str; }; }
+    { options.merged = mkOption { type = types.attrListOf types.str; }; }
+  ];
+}

lib/tests/modules/declare-attrList.nix

@@ -0,0 +1,925 @@
+# Run with:
+#   cd nixpkgs
+#   ./lib/tests/modules.sh
+{ lib, config, ... }:
+let
+  inherit (lib)
+    mkOption
+    mkOrder
+    mkMerge
+    mkBefore
+    mkAfter
+    mkIf
+    mkOverride
+    mkDefault
+    mkForce
+    types
+    ;
+in
+{
+  options = {
+    attrList = mkOption {
+      type = types.lazyAttrsOf (types.attrListOf types.str);
+    };
+
+    attrListInt = mkOption {
+      type = types.lazyAttrsOf (types.attrListOf types.int);
+    };
+
+    attrListSubmodule = mkOption {
+      type = types.attrListOf (
+        types.submodule {
+          options.port = mkOption {
+            type = types.int;
+            description = "Port number";
+          };
+          options.host = mkOption {
+            type = types.str;
+            default = "localhost";
+            description = "Hostname";
+          };
+        }
+      );
+    };
+
+    # asAttrs: value is a merged attrset, ordered list in valueMeta
+    asAttrs = mkOption {
+      type = types.lazyAttrsOf (
+        types.attrListWith {
+          elemType = types.str;
+          asAttrs = true;
+          mergeAttrValues = _name: values: lib.last values;
+        }
+      );
+    };
+
+    # asAttrs with default mergeAttrValues: duplicates collected into lists
+    asAttrsDefault = mkOption {
+      type = types.lazyAttrsOf (
+        types.attrListWith {
+          elemType = types.int;
+          asAttrs = true;
+        }
+      );
+    };
+
+    # Strict wrappers that force deep evaluation, for testing error cases
+    attrListStrict = mkOption {
+      type = types.lazyAttrsOf types.raw;
+    };
+
+    attrListIntStrict = mkOption {
+      type = types.lazyAttrsOf types.raw;
+    };
+
+    # either picks attrList when input is list/attrset, int when input is int
+    eitherAttrListOrInt = mkOption {
+      type = types.either (types.attrListOf types.str) types.int;
+    };
+
+    eitherAttrListOrIntFallback = mkOption {
+      type = types.either (types.attrListOf types.str) types.int;
+    };
+
+    eitherIntOrAttrList = mkOption {
+      type = types.either types.int (types.attrListOf types.str);
+    };
+
+    eitherIntOrAttrListFallback = mkOption {
+      type = types.either types.int (types.attrListOf types.str);
+    };
+
+    assertions = mkOption { };
+  };
+
+  imports = [
+    # Second module contributing to multiModule
+    {
+      attrListInt.multiModule = [
+        { b = 2; }
+      ];
+    }
+  ];
+
+  config = {
+
+    # List input: pass-through
+    attrList.listInput = [
+      { a = "alpha"; }
+      { b = "beta"; }
+    ];
+
+    # Attrset input with explicit ordering
+    attrList.attrsetOrdered = {
+      x = mkOrder 200 "x-val";
+      y = mkOrder 100 "y-val";
+    };
+
+    # Mixed: list elements at default priority, attrset with mkOrder
+    attrList.mixed = mkMerge [
+      [
+        { m = "from-list"; }
+      ]
+      {
+        n = mkOrder 50 "from-attrset";
+      }
+    ];
+
+    # Multiple list definitions from separate modules
+    attrListInt.multiModule = [
+      { a = 1; }
+    ];
+
+    # Attrset without mkOrder uses default priority
+    attrList.attrsetNoOrder = {
+      foo = "bar";
+      baz = "qux";
+    };
+
+    # Empty list
+    attrList.empty = [ ];
+
+    # Ordering test: lower priority first
+    attrList.ordering = mkMerge [
+      {
+        last = mkOrder 1500 "last";
+      }
+      {
+        first = mkOrder 500 "first";
+      }
+      [
+        { middle = "middle"; }
+      ]
+    ];
+
+    # List elements support mkOrder/mkBefore/mkAfter
+    attrList.listOrdering = [
+      (mkAfter { z = "after"; })
+      { m = "default"; }
+      (mkBefore { a = "before"; })
+    ];
+
+    # Plain list entries land at default priority (1000):
+    # they appear after mkOrder 999 and before mkOrder 1001.
+    attrList.listDefaultPrio = mkMerge [
+      { after = mkOrder 1001 "after"; }
+      [
+        { mid = "list-entry"; }
+      ]
+      { before = mkOrder 999 "before"; }
+    ];
+
+    # mkBefore and mkAfter
+    attrList.beforeAfter = mkMerge [
+      {
+        z = mkAfter "after";
+      }
+      {
+        a = mkBefore "before";
+      }
+      [
+        { m = "default"; }
+      ]
+    ];
+
+    # mkIf: conditional definition
+    attrList.withMkIf = mkMerge [
+      (mkIf true [
+        { yes = "included"; }
+      ])
+      (mkIf false [
+        { no = "excluded"; }
+      ])
+    ];
+
+    # mkOverride: higher priority override wins
+    attrList.withOverride = mkMerge [
+      (mkOverride 100 [
+        { replaced = "gone"; }
+      ])
+      (mkOverride 50 [
+        { winner = "wins"; }
+      ])
+    ];
+
+    # mkDefault: lower priority than normal
+    attrList.withDefault = mkMerge [
+      (mkDefault [
+        { default = "overridden"; }
+      ])
+      [
+        { normal = "wins"; }
+      ]
+    ];
+
+    # mkForce on the whole option (should discard other defs)
+    attrList.withForce = mkMerge [
+      [
+        { discarded = "gone"; }
+      ]
+      (mkForce [
+        { forced = "wins"; }
+      ])
+    ];
+
+    # mkForce with mkOrder inside
+    attrList.forceWithOrder = mkForce [
+      (mkAfter { second = "after"; })
+      (mkBefore { first = "before"; })
+    ];
+
+    # mkForce on individual element values; non-forced entries are discarded.
+    # Discarded values use a mix of: plain value, mkDefault(abort ...), mkOverride 100 (abort ...).
+    # The abort variants verify laziness: peelProperties sees the wrapper without forcing the content.
+    attrListInt.forceElementValue = [
+      { a = mkDefault (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated"); }
+      { a = mkForce 42; }
+      { a = mkOverride 100 (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated"); }
+      { b = 2; }
+    ];
+
+    # mkForce on attrset format
+    attrList.forceAttrset = mkMerge [
+      [
+        { discarded = "gone"; }
+      ]
+      (mkForce {
+        x = mkOrder 200 "x-val";
+        y = mkOrder 100 "y-val";
+      })
+    ];
+
+    # mkForce on repeated key: forced entries override non-forced
+    attrList.forceRepeatedKey = [
+      { x = mkOverride 100 (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated"); }
+      { x = mkForce "wins"; }
+      { x = mkForce "wins 2"; }
+    ];
+
+    # mkForce on repeated key across mkMerge
+    attrList.forceRepeatedKeyMerge = mkMerge [
+      [
+        { x = "unused: overridden by mkForce"; }
+        { x = mkDefault (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated"); }
+      ]
+      [
+        { x = mkOverride 100 (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated"); }
+      ]
+      [
+        { x = mkForce "forced"; }
+      ]
+    ];
+
+    # mkForce on repeated key in attrset format across mkMerge
+    attrList.forceRepeatedKeyAttrs = mkMerge [
+      {
+        x = mkDefault (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated");
+        y = "kept";
+      }
+      { x = mkForce "forced"; }
+    ];
+
+    # mkForce only affects the key it's on, other keys survive
+    attrList.forcePartialAttrs = mkMerge [
+      {
+        x = "unused: overridden by mkForce";
+        y = "normal y";
+      }
+      { x = mkForce "forced x"; }
+    ];
+
+    # mkForce in attrset format overrides same key from list format
+    attrList.forceMixedFormats = mkMerge [
+      [
+        { x = mkOverride 100 (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated"); }
+        { y = "list y"; }
+      ]
+      { x = mkForce "attrset forced x"; }
+    ];
+
+    # Nesting: list format, mkOrder on element + mkForce on value
+    attrList.nestListOrderForce = mkMerge [
+      [
+        { x = mkDefault (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated"); }
+        (mkOrder 500 { x = mkForce "forced-early"; })
+        (mkOrder 1500 { y = "late"; })
+      ]
+      [
+        (mkOrder 100 { z = "earliest"; })
+      ]
+    ];
+
+    # Nesting: list format, mkOrder(mkForce(val)) on value
+    attrList.nestListOrderOfForce = mkMerge [
+      [
+        { x = mkOverride 100 (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated"); }
+        { y = "plain-early"; }
+      ]
+      [
+        { x = mkOrder 1500 (mkForce "forced-late"); }
+        { z = mkOrder 500 "earliest"; }
+      ]
+      [
+        { x = "unused: overridden by mkForce"; }
+        { w = mkOrder 1200 "mid"; }
+      ]
+    ];
+
+    # Nesting: list format, mkForce(mkOrder(val)) on value
+    attrList.nestListForceOfOrder = mkMerge [
+      [
+        { x = "unused: overridden by mkForce"; }
+        { y = "plain-early"; }
+      ]
+      [
+        { x = mkForce (mkOrder 1500 "forced-late"); }
+        { z = mkOrder 500 "earliest"; }
+      ]
+      [
+        { x = mkDefault (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated"); }
+        { w = mkOrder 1200 "mid"; }
+      ]
+    ];
+
+    # Nesting: attrset format, mkOrder wrapping mkForce
+    attrList.nestAttrsOrderOfForce = mkMerge [
+      {
+        x = mkOverride 100 (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated");
+        y = "plain-early";
+      }
+      {
+        x = mkOrder 1500 (mkForce "forced-late");
+        z = mkOrder 500 "earliest";
+      }
+      {
+        x = "unused: overridden by mkForce";
+        w = mkOrder 1200 "mid";
+      }
+    ];
+
+    # Nesting: attrset format, mkForce wrapping mkOrder
+    attrList.nestAttrsForceOfOrder = mkMerge [
+      {
+        x = "unused: overridden by mkForce";
+        y = "plain-early";
+      }
+      {
+        x = mkForce (mkOrder 1500 "forced-late");
+        z = mkOrder 500 "earliest";
+      }
+      {
+        x = mkDefault (abort "overridden by mkForce; laziness guarantee: MUST NOT be evaluated");
+        w = mkOrder 1200 "mid";
+      }
+    ];
+
+    # mkIf false on individual element value filters it out (list format)
+    attrListInt.optionalValueList = [
+      { a = mkIf true 1; }
+      { b = mkIf false 2; }
+      { c = 3; }
+    ];
+
+    # mkIf false on individual element value filters it out (attrset format)
+    attrListInt.optionalValueAttrs = {
+      a = mkIf true 1;
+      b = mkIf false 2;
+      c = 3;
+    };
+
+    # submodule elemType: produces real valueMeta
+    attrListSubmodule = [
+      {
+        web = {
+          port = 80;
+        };
+      }
+      {
+        db = {
+          port = 5432;
+          host = "dbhost";
+        };
+      }
+    ];
+
+    # asAttrs: unique keys — value is a plain attrset
+    asAttrs.unique = [
+      { a = "alpha"; }
+      { b = "beta"; }
+    ];
+
+    # asAttrs: duplicate keys — last in order wins
+    asAttrs.duplicateKeys = mkMerge [
+      { x = mkOrder 500 "first"; }
+      { x = mkOrder 1500 "last"; }
+      { y = "only"; }
+    ];
+
+    # asAttrs: with ordering — value is attrset, ordered list in valueMeta
+    asAttrs.ordered = {
+      z = mkOrder 200 "z-val";
+      a = mkOrder 100 "a-val";
+    };
+
+    # asAttrs: with mkForce — forced key overrides
+    asAttrs.withForce = mkMerge [
+      { x = "unused: overridden by mkForce"; }
+      {
+        x = mkForce "forced";
+        y = "kept";
+      }
+    ];
+
+    # asAttrs: empty
+    asAttrs.empty = [ ];
+
+    # asAttrsDefault: unique keys
+    asAttrsDefault.unique = [
+      { a = 1; }
+      { b = 2; }
+    ];
+
+    # asAttrsDefault: duplicate keys — default collects into lists
+    asAttrsDefault.duplicates = mkMerge [
+      { x = mkOrder 500 10; }
+      { x = mkOrder 1500 30; }
+      { y = 99; }
+      [
+        { x = 20; }
+      ]
+    ];
+
+    # either: attrList branch matches for list input
+    eitherAttrListOrInt = [
+      { a = "hello"; }
+      { b = "world"; }
+    ];
+
+    # either: int input falls through to int branch
+    eitherAttrListOrIntFallback = 42;
+
+    # either (swapped): int first, attrList second — int input matches int
+    eitherIntOrAttrList = 42;
+
+    # either (swapped): list input falls through to attrList branch
+    eitherIntOrAttrListFallback = [
+      { a = "hello"; }
+    ];
+
+    # Bad: string where int expected
+    attrListInt.badValue = [
+      { a = "not-an-int"; }
+    ];
+
+    # Bad: list element with multiple keys
+    attrList.badListElem = [
+      {
+        a = "ok";
+        b = "extra";
+      }
+    ];
+
+    # Bad: plain string instead of list or attrset
+    attrList.badString = "not-a-container";
+
+    # Bad: list element is a bare string, not a singleton attrset
+    attrList.badListString = [
+      "not a singleton attribute"
+    ];
+
+    attrListStrict = builtins.mapAttrs (k: v: builtins.deepSeq v v) config.attrList;
+    attrListIntStrict = builtins.mapAttrs (k: v: builtins.deepSeq v v) config.attrListInt;
+
+    assertions =
+      let
+        c = lib.evalModules {
+          modules = [ ./declare-attrList.nix ];
+        };
+        cfg = c.config;
+      in
+
+      # List input preserves elements
+      assert
+        cfg.attrList.listInput == [
+          { a = "alpha"; }
+          { b = "beta"; }
+        ];
+
+      # Attrset input with mkOrder: lower priority comes first
+      assert
+        cfg.attrList.attrsetOrdered == [
+          { y = "y-val"; }
+          { x = "x-val"; }
+        ];
+
+      # Mixed input: mkOrder 50 < default 1000
+      assert
+        cfg.attrList.mixed == [
+          { n = "from-attrset"; }
+          { m = "from-list"; }
+        ];
+
+      # Multiple definitions from separate modules concatenate
+      # (import module's definition comes before this module's)
+      assert
+        cfg.attrListInt.multiModule == [
+          { b = 2; }
+          { a = 1; }
+        ];
+
+      # Attrset without mkOrder: all at default priority
+      assert builtins.length cfg.attrList.attrsetNoOrder == 2;
+
+      # Empty list stays empty
+      assert cfg.attrList.empty == [ ];
+
+      # List elements support mkOrder/mkBefore/mkAfter
+      assert
+        cfg.attrList.listOrdering == [
+          { a = "before"; }
+          { m = "default"; }
+          { z = "after"; }
+        ];
+
+      # Plain list entries are at default priority (1000)
+      assert
+        cfg.attrList.listDefaultPrio == [
+          { before = "before"; }
+          { mid = "list-entry"; }
+          { after = "after"; }
+        ];
+
+      # Ordering: 500 < 1000 (default) < 1500
+      assert
+        cfg.attrList.ordering == [
+          { first = "first"; }
+          { middle = "middle"; }
+          { last = "last"; }
+        ];
+
+      # mkBefore (500) < default (1000) < mkAfter (1500)
+      assert
+        cfg.attrList.beforeAfter == [
+          { a = "before"; }
+          { m = "default"; }
+          { z = "after"; }
+        ];
+
+      # mkIf true includes, mkIf false excludes
+      assert
+        cfg.attrList.withMkIf == [
+          { yes = "included"; }
+        ];
+
+      # mkOverride: only lowest priority override survives
+      assert
+        cfg.attrList.withOverride == [
+          { winner = "wins"; }
+        ];
+
+      # mkDefault is overridden by normal definitions
+      assert
+        cfg.attrList.withDefault == [
+          { normal = "wins"; }
+        ];
+
+      # mkForce discards other definitions
+      assert
+        cfg.attrList.withForce == [
+          { forced = "wins"; }
+        ];
+
+      # mkForce with mkOrder inside: ordering still works
+      assert
+        cfg.attrList.forceWithOrder == [
+          { first = "before"; }
+          { second = "after"; }
+        ];
+
+      # mkForce on individual element values passes through
+      assert
+        cfg.attrListInt.forceElementValue == [
+          { a = 42; }
+          { b = 2; }
+        ];
+
+      # mkForce on attrset format: discards other defs, ordering preserved
+      assert
+        cfg.attrList.forceAttrset == [
+          { y = "y-val"; }
+          { x = "x-val"; }
+        ];
+
+      # mkForce on repeated key: forced entries override non-forced
+      assert
+        cfg.attrList.forceRepeatedKey == [
+          { x = "wins"; }
+          { x = "wins 2"; }
+        ];
+
+      # mkForce on repeated key across mkMerge: forced wins
+      assert
+        cfg.attrList.forceRepeatedKeyMerge == [
+          { x = "forced"; }
+        ];
+
+      # mkForce on repeated key in attrset format: discards other x, keeps y
+      assert
+        cfg.attrList.forceRepeatedKeyAttrs == [
+          { y = "kept"; }
+          { x = "forced"; }
+        ];
+
+      # mkForce only affects its own key
+      assert
+        cfg.attrList.forcePartialAttrs == [
+          { y = "normal y"; }
+          { x = "forced x"; }
+        ];
+
+      # mkForce in attrset format overrides same key from list format
+      assert
+        cfg.attrList.forceMixedFormats == [
+          { y = "list y"; }
+          { x = "attrset forced x"; }
+        ];
+
+      # Nesting: list format, mkOrder on element + mkForce on value
+      # z(100) < x-forced(500) < y(1500); x-discarded filtered by mkForce
+      assert
+        cfg.attrList.nestListOrderForce == [
+          { z = "earliest"; }
+          { x = "forced-early"; }
+          { y = "late"; }
+        ];
+
+      # Nesting: list format, mkOrder(mkForce(val)) on value
+      # z(500) < y(1000) < w(1200) < x-forced(1500); x-discarded entries filtered
+      assert
+        cfg.attrList.nestListOrderOfForce == [
+          { z = "earliest"; }
+          { y = "plain-early"; }
+          { w = "mid"; }
+          { x = "forced-late"; }
+        ];
+
+      # Nesting: list format, mkForce(mkOrder(val)) on value
+      # z(500) < y(1000) < w(1200) < x-forced(1500); x-discarded entries filtered
+      assert
+        cfg.attrList.nestListForceOfOrder == [
+          { z = "earliest"; }
+          { y = "plain-early"; }
+          { w = "mid"; }
+          { x = "forced-late"; }
+        ];
+
+      # Nesting: attrset format, mkOrder(mkForce(val))
+      # z(500) < y(1000) < w(1200) < x-forced(1500); x-discarded entries filtered
+      assert
+        cfg.attrList.nestAttrsOrderOfForce == [
+          { z = "earliest"; }
+          { y = "plain-early"; }
+          { w = "mid"; }
+          { x = "forced-late"; }
+        ];
+
+      # Nesting: attrset format, mkForce(mkOrder(val))
+      # z(500) < y(1000) < w(1200) < x-forced(1500); x-discarded entries filtered
+      assert
+        cfg.attrList.nestAttrsForceOfOrder == [
+          { z = "earliest"; }
+          { y = "plain-early"; }
+          { w = "mid"; }
+          { x = "forced-late"; }
+        ];
+
+      # mkIf false on individual element value filters it out (list format)
+      assert
+        cfg.attrListInt.optionalValueList == [
+          { a = 1; }
+          { c = 3; }
+        ];
+
+      # mkIf false on individual element value filters it out (attrset format)
+      assert
+        cfg.attrListInt.optionalValueAttrs == [
+          { a = 1; }
+          { c = 3; }
+        ];
+
+      # submodule: value, option descriptions, and valueMeta with real configuration metadata
+      assert
+        cfg.attrListSubmodule == [
+          {
+            web = {
+              host = "localhost";
+              port = 80;
+            };
+          }
+          {
+            db = {
+              host = "dbhost";
+              port = 5432;
+            };
+          }
+        ];
+      assert
+        builtins.map (m: m.configuration.config) c.options.attrListSubmodule.valueMeta.attrList == [
+          {
+            host = "localhost";
+            port = 80;
+          }
+          {
+            host = "dbhost";
+            port = 5432;
+          }
+        ];
+      assert
+        builtins.map (
+          m:
+          builtins.mapAttrs (n: o: o.description) (builtins.removeAttrs m.configuration.options [ "_module" ])
+        ) c.options.attrListSubmodule.valueMeta.attrList == [
+          {
+            host = "Hostname";
+            port = "Port number";
+          }
+          {
+            host = "Hostname";
+            port = "Port number";
+          }
+        ];
+
+      # valueMeta.attrList has one entry per (non-filtered) element
+      assert
+        c.options.attrList.valueMeta.attrs.listInput.attrList == [
+          { }
+          { }
+        ];
+      assert
+        c.options.attrList.valueMeta.attrs.attrsetOrdered.attrList == [
+          { }
+          { }
+        ];
+      assert
+        c.options.attrList.valueMeta.attrs.mixed.attrList == [
+          { }
+          { }
+        ];
+      assert c.options.attrList.valueMeta.attrs.empty.attrList == [ ];
+      assert
+        c.options.attrListInt.valueMeta.attrs.optionalValueList.attrList == [
+          { }
+          { }
+        ];
+
+      # either: headError is null for valid attrList input, so attrList branch is picked
+      assert
+        cfg.eitherAttrListOrInt == [
+          { a = "hello"; }
+          { b = "world"; }
+        ];
+
+      # either: headError is non-null for int input, so int branch is picked
+      assert cfg.eitherAttrListOrIntFallback == 42;
+
+      # either (swapped): int first — int input matches
+      assert cfg.eitherIntOrAttrList == 42;
+
+      # either (swapped): list input falls through to attrList branch
+      assert
+        cfg.eitherIntOrAttrListFallback == [
+          { a = "hello"; }
+        ];
+
+      # asAttrs: unique keys — value is a plain attrset
+      assert
+        cfg.asAttrs.unique == {
+          a = "alpha";
+          b = "beta";
+        };
+      # ordered list preserved in valueMeta
+      assert
+        c.options.asAttrs.valueMeta.attrs.unique.attrListValue == [
+          { a = "alpha"; }
+          { b = "beta"; }
+        ];
+
+      # asAttrs: duplicate keys — last in order wins
+      assert
+        cfg.asAttrs.duplicateKeys == {
+          x = "last";
+          y = "only";
+        };
+      assert
+        c.options.asAttrs.valueMeta.attrs.duplicateKeys.attrListValue == [
+          { x = "first"; }
+          { y = "only"; }
+          { x = "last"; }
+        ];
+
+      # asAttrs: ordered — value is attrset (unordered), list in valueMeta preserves order
+      assert
+        cfg.asAttrs.ordered == {
+          a = "a-val";
+          z = "z-val";
+        };
+      assert
+        c.options.asAttrs.valueMeta.attrs.ordered.attrListValue == [
+          { a = "a-val"; }
+          { z = "z-val"; }
+        ];
+
+      # asAttrs: mkForce — forced key overrides, value is attrset
+      assert
+        cfg.asAttrs.withForce == {
+          x = "forced";
+          y = "kept";
+        };
+
+      # asAttrs: empty — value is empty attrset
+      assert cfg.asAttrs.empty == { };
+
+      # asAttrsDefault: unique keys — each value wrapped in singleton list
+      assert
+        cfg.asAttrsDefault.unique == {
+          a = [ 1 ];
+          b = [ 2 ];
+        };
+
+      # asAttrsDefault: duplicate keys — values collected into list in order
+      assert
+        cfg.asAttrsDefault.duplicates == {
+          x = [
+            10
+            20
+            30
+          ];
+          y = [ 99 ];
+        };
+      assert
+        c.options.asAttrsDefault.valueMeta.attrs.duplicates.attrListValue == [
+          { x = 10; }
+          { y = 99; }
+          { x = 20; }
+          { x = 30; }
+        ];
+
+      # valueMeta.definitions: mkDefinition records with mkOrder-wrapped single-key attrsets
+      # Use duplicateKeys which has mixed priorities and repeated keys
+      assert
+        let
+          defs = c.options.asAttrs.valueMeta.attrs.duplicateKeys.definitions;
+          extract = d: {
+            prio = d.value.priority;
+            value = d.value.content;
+          };
+        in
+        map extract defs == [
+          {
+            prio = 500;
+            value = {
+              x = "first";
+            };
+          }
+          {
+            prio = 1000;
+            value = {
+              y = "only";
+            };
+          }
+          {
+            prio = 1500;
+            value = {
+              x = "last";
+            };
+          }
+        ];
+
+      # Round-trip: feed definitions through mapDefinitionValue + mkMerge into a listOf option
+      assert
+        let
+          rendered = lib.modules.mapDefinitionValue (attr: lib.cli.toCommandLineGNU { } attr) (
+            mkMerge c.options.asAttrs.valueMeta.attrs.duplicateKeys.definitions
+          );
+          result =
+            (lib.evalModules {
+              modules = [
+                { options.out = mkOption { type = types.listOf types.str; }; }
+                { config.out = rendered; }
+                # Interleave: mkOrder 800 lands between x(500) and y(1000)
+                { config.out = mkOrder 800 [ "--interleaved" ]; }
+              ];
+            }).config.out;
+        in
+        result == [
+          "-xfirst"
+          "--interleaved"
+          "-yonly"
+          "-xlast"
+        ];
+
+      # Error cases are tested via checkConfigError in modules.sh
+
+      "ok";
+  };
+}

lib/tests/modules/types.nix

@@ -167,6 +167,28 @@ in
           elemType = str;
           lazy = false;
         }).description == "attribute set of string";
+      assert (attrListOf str).description == "attribute list of string";
+      assert (attrListOf int).description == "attribute list of signed integer";
+      assert (attrListOf bool).description == "attribute list of boolean";
+      assert (attrListOf (either int str)).description == "attribute list of (signed integer or string)";
+      assert (attrListOf (nullOr str)).description == "attribute list of (null or string)";
+      assert (attrListOf (listOf str)).description == "attribute list of list of string";
+      assert
+        (attrListOf (attrsOf int)).description == "attribute list of attribute set of signed integer";
+      assert (attrListOf (attrListOf str)).description == "attribute list of attribute list of string";
+      assert (attrListOf ints.positive).description == "attribute list of (positive integer, meaning >0)";
+      assert
+        (attrListOf (enum [
+          "a"
+          "b"
+        ])).description == "attribute list of (one of \"a\", \"b\")";
+      assert
+        (attrListOf (strMatching "[0-9]+")).description
+        == "attribute list of string matching the pattern [0-9]+";
+      assert
+        (attrListOf (nonEmptyListOf str)).description == "attribute list of non-empty (list of string)";
+      assert (attrListOf (submodule { })).description == "attribute list of (submodule)";
+
       assert (coercedTo str abort int).description == "signed integer or string convertible to it";
       assert (coercedTo int abort str).description == "string or signed integer convertible to it";
       assert (coercedTo bool abort str).description == "string or boolean convertible to it";

lib/types.nix

@@ -20,6 +20,7 @@ let
     isStorePath
     isString
     substring
+    sort
     throwIf
     toDerivation
     toList
@@ -27,6 +28,7 @@ let
     ;
   inherit (lib.lists)
     concatLists
+    concatMap
     elemAt
     filter
     foldl'
@@ -70,6 +72,11 @@ let
     mergeDefinitions
     fixupOptionType
     mergeOptionDecls
+    defaultOrderPriority
+    defaultOverridePriority
+    mkDefinition
+    mkOrder
+    mkOverride
     ;
   inherit (lib.fileset)
     isFileset
@@ -805,6 +812,179 @@ rec {
       substSubModules = m: nonEmptyListOf (elemType.substSubModules m);
     };
 
+  attrListOf = elemType: attrListWith { inherit elemType; };
+
+  attrListWith =
+    {
+      elemType,
+      asAttrs ? false,
+      mergeAttrValues ? _name: values: values,
+    }:
+    mkOptionType rec {
+      name = "attrListOf";
+      description = "attribute list of ${
+        optionDescriptionPhrase (class: class == "noun" || class == "composite") elemType
+      }";
+      descriptionClass = "composite";
+      check = {
+        __functor = _self: x: isList x || isAttrs x;
+        isV2MergeCoherent = true;
+      };
+      merge = {
+        __functor =
+          self: loc: defs:
+          (self.v2 { inherit loc defs; }).value;
+        v2 =
+          { loc, defs }:
+          let
+            # Peel order and override properties from a value in any nesting order.
+            # Returns { value, prio, overridePrio }.
+            # mkOrder is stripped (we consume it for sorting).
+            # mkOverride is preserved in value (mergeDefinitions strips it).
+            peelProperties =
+              value:
+              let
+                type = value._type or null;
+              in
+              if type == "order" then
+                let
+                  inner = peelProperties value.content;
+                in
+                {
+                  inherit (inner) value overridePrio;
+                  prio = value.priority;
+                }
+              else if type == "override" then
+                let
+                  inner = peelProperties value.content;
+                in
+                {
+                  inherit (inner) prio;
+                  overridePrio = value.priority;
+                  # Re-wrap mkOverride around the inner value (with mkOrder stripped)
+                  value = mkOverride value.priority inner.value;
+                }
+              else
+                {
+                  inherit value;
+                  prio = defaultOrderPriority;
+                  overridePrio = defaultOverridePriority;
+                };
+
+            # Extract { file, key, value, prio, overridePrio } from a single-key attrset,
+            # optionally wrapped in mkOrder at the element level (list format).
+            extractItem =
+              file: raw:
+              let
+                hasOrder = isType "order" raw;
+                item = if hasOrder then raw.content else raw;
+                key = head (attrNames item);
+                peeled = peelProperties item.${key};
+              in
+              if isAttrs item && length (attrNames item) == 1 then
+                peeled
+                // {
+                  inherit file key;
+                  prio = if hasOrder then raw.priority else peeled.prio;
+                }
+              else
+                throw "A definition for option `${showOption loc}' is not of type `${description}'. ${
+                  if !isAttrs item then
+                    "Each list element must be an attribute set, but got ${builtins.typeOf item}"
+                  else
+                    "Each list element must be a single-key attribute set, but got ${toString (length (attrNames item))} keys"
+                }.${
+                  showDefs [
+                    {
+                      inherit file;
+                      value = raw;
+                    }
+                  ]
+                }";
+
+            # Convert a definition to a flat list of { file, key, value, prio, overridePrio }
+            defToItems =
+              def:
+              if isList def.value then
+                map (extractItem def.file) def.value
+              else
+                # isAttrs: properties are on the values directly
+                map (
+                  key:
+                  peelProperties def.value.${key}
+                  // {
+                    inherit (def) file;
+                    inherit key;
+                  }
+                ) (attrNames def.value);
+
+            allItems = concatMap defToItems defs;
+
+            # Per key, find the highest override priority (lowest number)
+            winningOverridePrio = foldl' (
+              acc: item:
+              let
+                prev = acc.${item.key} or defaultOverridePriority;
+              in
+              if item.overridePrio < prev then
+                acc // { ${item.key} = item.overridePrio; }
+              else
+                # minimize `//` operations
+                acc
+            ) { } allItems;
+
+            # Keep only items at the winning override priority for their key
+            items = sort (a: b: a.prio < b.prio) (
+              filter (
+                item: item.overridePrio == winningOverridePrio.${item.key} or defaultOverridePriority
+              ) allItems
+            );
+
+            evals = filter (e: e.eval.optionalValue ? value) (
+              map (item: {
+                inherit (item) key file prio;
+                eval = mergeDefinitions (loc ++ [ item.key ]) elemType [
+                  {
+                    inherit (item) file value;
+                  }
+                ];
+              }) items
+            );
+
+            attrListValue = map (e: { ${e.key} = e.eval.optionalValue.value or e.eval.mergedValue; }) evals;
+          in
+          {
+            headError = checkDefsForError check loc defs;
+            value = if asAttrs then zipAttrsWith mergeAttrValues attrListValue else attrListValue;
+            valueMeta.attrList = map (e: e.eval.checkedAndMerged.valueMeta) evals;
+            /**
+              The ordered list representation, especially useful when asAttrs is set.
+            */
+            valueMeta.attrListValue = attrListValue;
+            valueMeta.definitions = map (
+              e:
+              mkDefinition {
+                inherit (e) file;
+                value = mkOrder e.prio { ${e.key} = e.eval.optionalValue.value or e.eval.mergedValue; };
+              }
+            ) evals;
+          };
+      };
+      emptyValue = {
+        value = if asAttrs then { } else [ ];
+      };
+      getSubOptions = prefix: elemType.getSubOptions (prefix ++ [ "*" ]);
+      getSubModules = elemType.getSubModules;
+      substSubModules =
+        m:
+        attrListWith {
+          inherit asAttrs mergeAttrValues;
+          elemType = elemType.substSubModules m;
+        };
+      typeMerge = t: null; # Disable type merging
+      nestedTypes.elemType = elemType;
+    };
+
   attrsOf = elemType: attrsWith { inherit elemType; };
 
   # A version of attrsOf that's lazy in its values at the expense of

maintainers/maintainer-list.nix

@@ -5058,12 +5058,6 @@
     github = "cigrainger";
     githubId = 3984794;
   };
-  ciil = {
-    email = "simon@lackerbauer.com";
-    github = "ciil";
-    githubId = 3956062;
-    name = "Simon Lackerbauer";
-  };
   cilki = {
     github = "cilki";
     githubId = 10459406;
@@ -7360,12 +7354,6 @@
     github = "DSeeLP";
     githubId = 46624152;
   };
-  dsferruzza = {
-    email = "david.sferruzza@gmail.com";
-    github = "dsferruzza";
-    githubId = 1931963;
-    name = "David Sferruzza";
-  };
   dsluijk = {
     name = "Dany Sluijk";
     email = "nix@dany.dev";
@@ -10141,6 +10129,12 @@
     githubId = 6893840;
     name = "Yacine Hmito";
   };
+  gquetel = {
+    email = "gregor.quetel@telecom-paris.fr";
+    github = "gquetel";
+    githubId = 48437427;
+    name = "Grégor Quetel";
+  };
   gracicot = {
     email = "dev@gracicot.com";
     matrix = "@gracicot-59e8f173d73408ce4f7ac803:gitter.im";
@@ -15812,12 +15806,6 @@
     githubId = 23727619;
     name = "Luca Ruperto";
   };
-  lnl7 = {
-    email = "daiderd@gmail.com";
-    github = "LnL7";
-    githubId = 689294;
-    name = "Daiderd Jordan";
-  };
   lo1tuma = {
     email = "schreck.mathias@gmail.com";
     github = "lo1tuma";
@@ -17398,12 +17386,6 @@
     githubId = 613740;
     name = "Martin Baillie";
   };
-  mbbx6spp = {
-    email = "me@susanpotter.net";
-    github = "mbbx6spp";
-    githubId = 564;
-    name = "Susan Potter";
-  };
   mbe = {
     email = "brandonedens@gmail.com";
     github = "brandonedens";

nixos/doc/manual/development/option-types.section.md

@@ -494,6 +494,47 @@ Composed types are types that take a type as parameter. `listOf
 
       Displays the option as `foo.<id>` in the manual.
 
+`types.attrListOf` *`t`*
+
+:   An ordered list of single-attribute attribute sets, where each value is of *`t`* type.
+    The output is always `[ { name1 = value1; } { name2 = value2; } ... ]`.
+
+    Definitions can be provided in two formats, which may be mixed via `lib.mkMerge`, `imports`, etc:
+
+    - **List format**: `[ { a = 1; } { b = 2; } ]` — each element must be a single-attribute attribute set.
+      Elements may be wrapped in `lib.mkOrder` (or `lib.mkBefore`/`lib.mkAfter`) to control ordering;
+      unwrapped elements use the default order priority.
+
+    - **Attribute set format**: `{ a = lib.mkOrder 100 1; b = 2; }` — each name-value pair becomes a single-attribute attribute set in the output.
+      Values may be wrapped in `lib.mkOrder` (or `lib.mkBefore`/`lib.mkAfter`) to control ordering.
+      Values without `lib.mkOrder` use the default priority.
+
+    Multiple definitions of the same option are concatenated and then sorted by priority.
+    Entries at the same priority level preserve their definition order.
+
+`types.attrListWith` { *`elemType`*, *`asAttrs`* ? false, *`mergeAttrValues`* ? _name: values: values }
+
+:   An ordered list of single-attribute attribute sets, where each value is of *`elemType`* type.
+
+    **Parameters**
+
+    `elemType` (Required)
+    : Specifies the type of each value in the attribute list.
+
+    `asAttrs`
+    : When `true`, the option value is an attribute set instead of a list.
+      Duplicate keys are merged using `mergeAttrValues`.
+      The ordered list is always available via `valueMeta.attrListValue`.
+
+    `mergeAttrValues`
+    : A function `name: values: mergedValue` that controls how duplicate keys
+      are combined when `asAttrs = true`. This is passed as the callback to
+      `lib.zipAttrsWith`. The `values` list is in order of priority.
+      By default, all values are collected into a list.
+
+    **Behavior**
+
+    - `attrListWith { elemType = t; }` is equivalent to `attrListOf t`
 
 `types.uniq` *`t`*
 

nixos/tests/clatd.nix

@@ -13,8 +13,8 @@
 #        +--|---
 #        | eth2    Address: 2001:db8::1/64
 # Router |
-#        | nat64   Address: 64:ff9b::1/128
-#        |         Route:   64:ff9b::/96
+#        | nat64   Address: fde7:6c52:047e::1/128
+#        |         Route:   fde7:6c52:047e::/96
 #        |         Address: 192.0.2.0/32
 #        |         Route:   192.0.2.0/24
 #        |
@@ -37,11 +37,7 @@
   ];
 
   nodes = {
-    # The server is configured with static IPv4 addresses. RFC 6052 Section 3.1
-    # disallows the mapping of non-global IPv4 addresses like RFC 1918 into the
-    # Well-Known Prefix 64:ff9b::/96. TAYGA also does not allow the mapping of
-    # documentation space (RFC 5737). To circumvent this, 100.64.0.2/24 from
-    # RFC 6589 (Carrier Grade NAT) is used here.
+    # The server is configured with static IPv4 addresses.
     # To reach the IPv4 address pool of the NAT64 gateway, there is a static
     # route configured. In normal cases, where the router would also source NAT
     # the pool addresses to one IPv4 addresses, this would not be needed.
@@ -73,7 +69,7 @@
     # The router is configured with static IPv4 addresses towards the server
     # and IPv6 addresses towards the client. DNS64 is exposed towards the
     # client so clatd is able to auto-discover the PLAT prefix. For NAT64, the
-    # Well-Known prefix 64:ff9b::/96 is used. NAT64 is done with TAYGA which
+    # ULA prefix fde7:6c52:047e::/96 is used. NAT64 is done with TAYGA which
     # provides the tun-interface nat64 and does the translation over it. The
     # IPv6 packets are sent to this interfaces and received as IPv4 packets and
     # vice versa. As TAYGA only translates IPv6 addresses to dedicated IPv4
@@ -121,7 +117,7 @@
       systemd.network.networks."40-eth2" = {
         networkConfig.IPv6SendRA = true;
         ipv6Prefixes = [ { Prefix = "2001:db8::/64"; } ];
-        ipv6PREF64Prefixes = [ { Prefix = "64:ff9b::/96"; } ];
+        ipv6PREF64Prefixes = [ { Prefix = "fde7:6c52:047e::/96"; } ];
         ipv6SendRAConfig = {
           EmitDNS = true;
           DNS = "_link_local";
@@ -141,7 +137,7 @@
           .:53 {
             bind ::
             hosts /etc/hosts
-            dns64 64:ff9b::/96
+            dns64 fde7:6c52:047e::/96
           }
         '';
       };
@@ -161,10 +157,10 @@
         ipv6 = {
           address = "2001:db8::1";
           router = {
-            address = "64:ff9b::1";
+            address = "fde7:6c52:047e::1";
           };
           pool = {
-            address = "64:ff9b::";
+            address = "fde7:6c52:047e::";
             prefixLength = 96;
           };
         };
@@ -221,7 +217,7 @@
     with subtest("networkd exports PREF64 prefix"):
       assert json.loads(client.succeed("networkctl status eth1 --json=short"))[
           "NDisc"
-      ]["PREF64"][0]["Prefix"] == [0x0, 0x64, 0xFF, 0x9B] + ([0] * 12)
+      ]["PREF64"][0]["Prefix"] == [0xfd, 0xe7, 0x6c, 0x52, 0x04, 0x7e] + ([0] * 10)
 
     with subtest("Test ICMP"):
       client.wait_until_succeeds("ping -c3 100.64.0.2 >&2")

nixos/tests/docker-tools-overlay.nix

@@ -4,7 +4,6 @@
   name = "docker-tools-overlay";
   meta = with pkgs.lib.maintainers; {
     maintainers = [
-      lnl7
       roberth
     ];
   };

nixos/tests/docker-tools.nix

@@ -91,7 +91,6 @@ in
   name = "docker-tools";
   meta = with pkgs.lib.maintainers; {
     maintainers = [
-      lnl7
       roberth
     ];
   };

nixos/tests/nginx.nix

@@ -4,13 +4,11 @@
 #   2. whether the ETag header is properly generated whenever we're serving
 #      files in Nix store paths
 #   3. nginx doesn't restart on configuration changes (only reloads)
-{ pkgs, ... }:
+{ ... }:
 {
   name = "nginx";
-  meta = with pkgs.lib.maintainers; {
-    maintainers = [
-      mbbx6spp
-    ];
+  meta = {
+    maintainers = [ ];
   };
 
   nodes = {

nixos/tests/uwsgi.nix

@@ -1,8 +1,8 @@
 { pkgs, ... }:
 {
   name = "uwsgi";
-  meta = with pkgs.lib.maintainers; {
-    maintainers = [ lnl7 ];
+  meta = {
+    maintainers = [ ];
   };
 
   nodes.machine =

nixos/tests/vault-dev.nix

@@ -3,7 +3,6 @@
   name = "vault-dev";
   meta = with pkgs.lib.maintainers; {
     maintainers = [
-      lnl7
       mic92
     ];
   };

nixos/tests/vault-postgresql.nix

@@ -11,7 +11,6 @@
   name = "vault-postgresql";
   meta = with pkgs.lib.maintainers; {
     maintainers = [
-      lnl7
       roberth
     ];
   };

nixos/tests/vault.nix

@@ -1,8 +1,8 @@
 { pkgs, ... }:
 {
   name = "vault";
-  meta = with pkgs.lib.maintainers; {
-    maintainers = [ lnl7 ];
+  meta = {
+    maintainers = [ ];
   };
   nodes.machine =
     { pkgs, ... }:

pkgs/applications/audio/deadbeef/plugins/lyricbar.nix

@@ -26,7 +26,7 @@ stdenv.mkDerivation {
     libxmlxx3
   ];
 
-  NIX_CFLAGS_COMPILE = "-Wno-incompatible-pointer-types";
+  env.NIX_CFLAGS_COMPILE = "-Wno-incompatible-pointer-types";
 
   buildFlags = [ "gtk3" ];
 

pkgs/applications/audio/deadbeef/plugins/musical-spectrum.nix

@@ -29,7 +29,7 @@ stdenv.mkDerivation {
   ];
   makeFlags = [ "gtk3" ];
 
-  NIX_CFLAGS_COMPILE = "-Wno-incompatible-pointer-types";
+  env.NIX_CFLAGS_COMPILE = "-Wno-incompatible-pointer-types";
 
   installPhase = ''
     runHook preInstall

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

@@ -446,12 +446,12 @@ final: prev: {
 
   SchemaStore-nvim = buildVimPlugin {
     pname = "SchemaStore.nvim";
-    version = "0-unstable-2026-05-19";
+    version = "0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "b0o";
       repo = "SchemaStore.nvim";
-      rev = "05a0a69ca52c31aa687e8251ae11dd913df10061";
-      hash = "sha256-eM8plzS2vjOsNCzicPXfJbCs86Hc+plJeQOl+6diSJ8=";
+      rev = "68ba9015c0cc77a0fe954bd2578dfa7a5c24134f";
+      hash = "sha256-Odk14VqfchdeGwSAaQyNmIX42GaJSm/1xpX7jth6oxU=";
     };
     meta.homepage = "https://github.com/b0o/SchemaStore.nvim/";
     meta.license = getLicenseFromSpdxId "Apache-2.0";
@@ -755,12 +755,12 @@ final: prev: {
 
   aerial-nvim = buildVimPlugin {
     pname = "aerial.nvim";
-    version = "3.1.0";
+    version = "4.0.0";
     src = fetchFromGitHub {
       owner = "stevearc";
       repo = "aerial.nvim";
-      tag = "v3.1.0";
-      hash = "sha256-ugzNA/+Z2ReIy/8ks9wHEtmpTwpr8qqVR0xemw+GrUc=";
+      tag = "v4.0.0";
+      hash = "sha256-rFVYNwNkIYqJxH6bSNmXJ/e2T919NTeH+Uz1nF/JC+0=";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/stevearc/aerial.nvim/";
@@ -1260,12 +1260,12 @@ final: prev: {
 
   asynctasks-vim = buildVimPlugin {
     pname = "asynctasks.vim";
-    version = "0-unstable-2026-04-29";
+    version = "0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "skywind3000";
       repo = "asynctasks.vim";
-      rev = "14892013f671614afae315f91ed5ef700334e773";
-      hash = "sha256-RsZ8NjOH4j4m9gO4PiQCJVzdatvhiveoSL2gESaon/8=";
+      rev = "281cca79bf98ffe3913427b76adae59413823bd7";
+      hash = "sha256-6859GtjXxM7Pxp6U95Oz+/hg8FClulT2t2R2FY4yq7A=";
     };
     meta.homepage = "https://github.com/skywind3000/asynctasks.vim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -1400,12 +1400,12 @@ final: prev: {
 
   auto-session = buildVimPlugin {
     pname = "auto-session";
-    version = "2.5.1-unstable-2026-05-05";
+    version = "2.5.1-unstable-2026-05-21";
     src = fetchFromGitHub {
       owner = "rmagatti";
       repo = "auto-session";
-      rev = "daa7c996a0395e26342934843938647d0f1e87f4";
-      hash = "sha256-Dy538JjSm47paDiXbPw+gM+UiPQlM4dM7bcRWzYY9w8=";
+      rev = "3e145ee9af42eb6764908a1a481f53fe7f0bdbe5";
+      hash = "sha256-Ew7l61hyWpF1YkyvDEzh8U1+zIslPP5UQpOt7O242Qs=";
     };
     meta.homepage = "https://github.com/rmagatti/auto-session/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -3470,12 +3470,12 @@ final: prev: {
 
   coc-nvim = buildVimPlugin {
     pname = "coc.nvim";
-    version = "0.0.82-unstable-2026-05-12";
+    version = "0.0.82-unstable-2026-05-22";
     src = fetchFromGitHub {
       owner = "neoclide";
       repo = "coc.nvim";
-      rev = "269f4465f304f7f2412b9cc46fbdc98667b84546";
-      hash = "sha256-3YaXdNL7Kh2aVZAU1hVtdWfMLB12NGrknts6OUiTtYg=";
+      rev = "a23e8e5c3a7ee77073862c98800948ef20a5e7e6";
+      hash = "sha256-3l0e0jbtVvALHVfOHeCiWY3/Z5MfPCJqI43UrKk3FKM=";
     };
     meta.homepage = "https://github.com/neoclide/coc.nvim/";
     meta.license = unfree;
@@ -3946,12 +3946,12 @@ final: prev: {
 
   conform-nvim = buildVimPlugin {
     pname = "conform.nvim";
-    version = "9.1.0-unstable-2026-05-15";
+    version = "9.1.0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "stevearc";
       repo = "conform.nvim";
-      rev = "18aeab3d63d350dcf44d64c462cc489a3412af40";
-      hash = "sha256-+NzRZItrF344sp+xt07vKcu+EbHO1wtSGolYtIz0CP4=";
+      rev = "24c70347f6b2128679f47d2eb765156ef34bf9e0";
+      hash = "sha256-Jky3GonVfO4M5G9KD8JQYorNav9PKSe4NvZXVbn9EYg=";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/stevearc/conform.nvim/";
@@ -4563,12 +4563,12 @@ final: prev: {
 
   ddc-source-file = buildVimPlugin {
     pname = "ddc-source-file";
-    version = "0-unstable-2025-09-03";
+    version = "0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "LumaKernel";
       repo = "ddc-source-file";
-      rev = "e2386ed1e6739f48d4f3cfea9cc961fb5785480a";
-      hash = "sha256-UndfTc+awrlzJUziPEv5FFwwDjQTSqOVZXheQ/CERpg=";
+      rev = "294a3274eaff4b3a37d1a033effd07f4d0d6cec1";
+      hash = "sha256-y03JT0/QOEjfxOBPzwN7c5xorCkSOUKkcZs+OVh5Q6A=";
     };
     meta.homepage = "https://github.com/LumaKernel/ddc-source-file/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -4577,12 +4577,12 @@ final: prev: {
 
   ddc-source-lsp = buildVimPlugin {
     pname = "ddc-source-lsp";
-    version = "1.2.0-unstable-2026-05-15";
+    version = "1.2.0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "Shougo";
       repo = "ddc-source-lsp";
-      rev = "1debc85415b3175cd76b6313efda70dbb5bfdfeb";
-      hash = "sha256-bzAkGV0N6HS+lQg28szTIQwFaHUIzaEmIMOdH/kio+U=";
+      rev = "a8fef26851f3b648e064fa3aeb7c8c054684e846";
+      hash = "sha256-vB3sCEJw67kJLON+AXo6B/38jBAFq079EouVxaI9QlQ=";
     };
     meta.homepage = "https://github.com/Shougo/ddc-source-lsp/";
     meta.license = unfree;
@@ -5391,12 +5391,12 @@ final: prev: {
 
   easy-dotnet-nvim = buildVimPlugin {
     pname = "easy-dotnet.nvim";
-    version = "0-unstable-2026-05-18";
+    version = "0-unstable-2026-05-22";
     src = fetchFromGitHub {
       owner = "GustavEikaas";
       repo = "easy-dotnet.nvim";
-      rev = "5bdd2b8f6891c64607393698be7fd0f441443c1d";
-      hash = "sha256-dp4N8fn9c7/uGM1G8HT2tM/zjCN089eik6I6M8w3ncQ=";
+      rev = "5d5b3e2491a81efe252004e1876bd67af7dfc9c1";
+      hash = "sha256-0rvkOKGWSYrB/GoV48Q4JSwbcz5SKIJGvXPwR7vJROM=";
     };
     meta.homepage = "https://github.com/GustavEikaas/easy-dotnet.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -5518,12 +5518,12 @@ final: prev: {
 
   efmls-configs-nvim = buildVimPlugin {
     pname = "efmls-configs-nvim";
-    version = "1.11.1-unstable-2026-04-10";
+    version = "1.11.1-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "creativenull";
       repo = "efmls-configs-nvim";
-      rev = "5dc52088c231f2721f545570fcb541b04802ce6b";
-      hash = "sha256-QO4R/+qAMXV+NN3gsMcKz7Z2BHZbwbwNBoD1AxfA/aY=";
+      rev = "2f5dc31042cc76fc3d5a859842a8416085c4d41f";
+      hash = "sha256-mtHihfpaV9gJFqZBD0h90dAC6kECNxbFPH3OYJoKVT0=";
     };
     meta.homepage = "https://github.com/creativenull/efmls-configs-nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -6206,12 +6206,12 @@ final: prev: {
 
   fugit2-nvim = buildVimPlugin {
     pname = "fugit2.nvim";
-    version = "0.2.1-unstable-2026-05-03";
+    version = "0.2.1-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "SuperBo";
       repo = "fugit2.nvim";
-      rev = "e1543df308f36a02a3b2c1128c6e7a54de5c764c";
-      hash = "sha256-LFgwf7TNuL/Z1CsJF2OCb0Hb7Zu+06cE843Qa+v5UH0=";
+      rev = "d6513bfc443470a85426ab366be591aadd444053";
+      hash = "sha256-bvr/iosdWFGUEfbwELCdV/tnlxeDfg/94AssXGVZSEw=";
     };
     meta.homepage = "https://github.com/SuperBo/fugit2.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -6332,12 +6332,12 @@ final: prev: {
 
   fzf-vim = buildVimPlugin {
     pname = "fzf.vim";
-    version = "0-unstable-2026-04-10";
+    version = "0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "junegunn";
       repo = "fzf.vim";
-      rev = "b9624aa012ddcbae9e79964bfd30cc1fbe3cf263";
-      hash = "sha256-VPxTYXdJaVbr2U7d6VuO4CpIyTC62uo3TAuf1MYiAXI=";
+      rev = "e5b53de3d3b402d2ef9f74da91c2bb808d0afb34";
+      hash = "sha256-6xu9+EC4V9CaqlogvVSCb0U7YJU35UWPMGrrdam4Ug0=";
     };
     meta.homepage = "https://github.com/junegunn/fzf.vim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -6626,11 +6626,11 @@ final: prev: {
 
   gitlab-vim = buildVimPlugin {
     pname = "gitlab.vim";
-    version = "1.1.0-unstable-2026-05-13";
+    version = "1.1.0-unstable-2026-05-21";
     src = fetchgit {
       url = "https://gitlab.com/gitlab-org/editor-extensions/gitlab.vim";
-      rev = "915a6265430a578fa4a1d7f8063e9e6fabca1184";
-      hash = "sha256-9dmIWXQNUEp0IfZ3nJaA5HYzDVejNZfS/ueorremBNM=";
+      rev = "9e196cf8497eb99c4a0834f801d2f55499630cc9";
+      hash = "sha256-yXVtP6SZ5H121VWUiFTDcWZ2l/xst1O38jI3iBav6VA=";
     };
     meta.homepage = "https://gitlab.com/gitlab-org/editor-extensions/gitlab.vim";
     meta.license = unfree;
@@ -7017,12 +7017,12 @@ final: prev: {
 
   guihua-lua = buildVimPlugin {
     pname = "guihua.lua";
-    version = "0.1-unstable-2026-05-19";
+    version = "0.1-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "ray-x";
       repo = "guihua.lua";
-      rev = "26e2e557f5b1a0c5cb25cab41d71ddba61523cba";
-      hash = "sha256-9VeU2HS1IRyixmbt1/jblHU5SNoqc+FJI52fAOq85aI=";
+      rev = "8c34ebbb59990c6cb70110d786ad82b2a7182c78";
+      hash = "sha256-TWXsHAYXz4UejiRpsMyuYKA70wFrXGvVMXsFL8qnGyY=";
     };
     meta.homepage = "https://github.com/ray-x/guihua.lua/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -8559,11 +8559,11 @@ final: prev: {
 
   leap-nvim = buildVimPlugin {
     pname = "leap.nvim";
-    version = "0-unstable-2026-05-09";
+    version = "0-unstable-2026-05-17";
     src = fetchgit {
       url = "https://codeberg.org/andyg/leap.nvim/";
-      rev = "940bc5e716a8cde63bd47e1b13f30fd9075ec0c8";
-      hash = "sha256-bwyZzOq0OGYMqJks3ijEWD3wgdbTNhUwNT96tWUNXK4=";
+      rev = "59d70b1bdf8e76e0637e6ebcc150fb6767f67fc5";
+      hash = "sha256-B3nwquR/ilBtuIPXw0r0048Ougt1VZ7FUFhT66yAH+8=";
     };
     meta.homepage = "https://codeberg.org/andyg/leap.nvim/";
     meta.license = unfree;
@@ -9496,12 +9496,12 @@ final: prev: {
 
   mason-nvim = buildVimPlugin {
     pname = "mason.nvim";
-    version = "2.2.1-unstable-2026-05-18";
+    version = "2.3.0";
     src = fetchFromGitHub {
       owner = "mason-org";
       repo = "mason.nvim";
-      rev = "cbf8d285e1462dd24acf3507817be2bbcb035919";
-      hash = "sha256-DLhPbrp591zwn9STDiyOXcKmLFy/AtGscsWn3vU2U+E=";
+      tag = "v2.3.0";
+      hash = "sha256-O+11o3c0iNZ4tMZV80QbzwuMV3mP2Ml4lXQKHz4uR54=";
     };
     meta.homepage = "https://github.com/mason-org/mason.nvim/";
     meta.license = getLicenseFromSpdxId "Apache-2.0";
@@ -9706,12 +9706,12 @@ final: prev: {
 
   mini-ai = buildVimPlugin {
     pname = "mini.ai";
-    version = "0.17.0-unstable-2026-05-12";
+    version = "0.17.0-unstable-2026-05-21";
     src = fetchFromGitHub {
       owner = "nvim-mini";
       repo = "mini.ai";
-      rev = "a783ce6e1a5b3bc90519f20b51f4a5f6702734af";
-      hash = "sha256-mxc3ZO9vwJd7GvwOFmiFUYtMaYj8uMje3eQSSgJwdwQ=";
+      rev = "4ce4c35e411ea329a15d4b15e9c89c2a3089e437";
+      hash = "sha256-mLdjjacl8Lx5wJG0nfYnD4l+h3xIUQjw09iqKJx1uRs=";
     };
     meta.homepage = "https://github.com/nvim-mini/mini.ai/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -9762,12 +9762,12 @@ final: prev: {
 
   mini-basics = buildVimPlugin {
     pname = "mini.basics";
-    version = "0.17.0-unstable-2026-05-18";
+    version = "0.17.0-unstable-2026-05-21";
     src = fetchFromGitHub {
       owner = "nvim-mini";
       repo = "mini.basics";
-      rev = "69d3f97431788b27df5edf90e9922ba4af38f990";
-      hash = "sha256-r3UxzMl8Z171XzkBlPfxw7dyrnt0TKCXPWAtTIneUDs=";
+      rev = "4255727accba14db930823da4168c7f1ea68ff80";
+      hash = "sha256-UVZkMfRub44plD0+wOd+//P7BejCqwf3mxCH9fMiosw=";
     };
     meta.homepage = "https://github.com/nvim-mini/mini.basics/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -9930,12 +9930,12 @@ final: prev: {
 
   mini-extra = buildVimPlugin {
     pname = "mini.extra";
-    version = "0.17.0-unstable-2026-05-12";
+    version = "0.17.0-unstable-2026-05-21";
     src = fetchFromGitHub {
       owner = "nvim-mini";
       repo = "mini.extra";
-      rev = "cf027da13fd217cfe3af6ef978d0e947c7ee0f7a";
-      hash = "sha256-LSbcIx/1GtTDWhZGKzFPOdiDp2qglcI+1ymn9k2dAio=";
+      rev = "5b0acf09d7f7958946973367c66bf5aafe4209dd";
+      hash = "sha256-+uTcSFEYSgfk72rg6t+1+TMNzeqJUplg2WKCulw778g=";
     };
     meta.homepage = "https://github.com/nvim-mini/mini.extra/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -10140,12 +10140,12 @@ final: prev: {
 
   mini-nvim = buildVimPlugin {
     pname = "mini.nvim";
-    version = "0.17.0-unstable-2026-05-19";
+    version = "0.17.0-unstable-2026-05-23";
     src = fetchFromGitHub {
       owner = "nvim-mini";
       repo = "mini.nvim";
-      rev = "264b5c8fc6e82212af0dc5c345145cfa916efeb6";
-      hash = "sha256-2E8EYYWQcN3rpsKqV8AYzPPAF7PalLpDTe3t3Lo9SmE=";
+      rev = "44657837c7338e52727facc85c1d95bec1f6bd7c";
+      hash = "sha256-BjGHDUWVyyodTJmTbMqUWDy70Ug5iCqpPkCJwhOLTaI=";
     };
     meta.homepage = "https://github.com/nvim-mini/mini.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -10182,12 +10182,12 @@ final: prev: {
 
   mini-pick = buildVimPlugin {
     pname = "mini.pick";
-    version = "0.17.0-unstable-2026-05-19";
+    version = "0.17.0-unstable-2026-05-21";
     src = fetchFromGitHub {
       owner = "nvim-mini";
       repo = "mini.pick";
-      rev = "0e25916ec4b0f3ad81329e529db55ef350ac9901";
-      hash = "sha256-OmGZQ3MK++mgtSNgLQhdWsQkbHr81iTfsQnLl8gBxoM=";
+      rev = "4522d9ab65224675df2cf1ede8c12f0410aae2be";
+      hash = "sha256-ppt7E8v/8deRpKbx0aknqGvZ7FM8a3T1jsMsoitaizA=";
     };
     meta.homepage = "https://github.com/nvim-mini/mini.pick/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -10266,12 +10266,12 @@ final: prev: {
 
   mini-surround = buildVimPlugin {
     pname = "mini.surround";
-    version = "0.17.0-unstable-2026-05-19";
+    version = "0.17.0-unstable-2026-05-22";
     src = fetchFromGitHub {
       owner = "nvim-mini";
       repo = "mini.surround";
-      rev = "c375ea503646fe8393593b5fb8a40406eaa437b2";
-      hash = "sha256-uwip1qJ6qGbVmOrttjCCoOybQ1/3vYsIO+fJ5Xnrs2g=";
+      rev = "1e37ade260e2b655c3a9b8407ba7e6b0fb995b28";
+      hash = "sha256-ruFYkITEmjRC3Luat1X3fW2vXBUBe785c9DRn6fWjIE=";
     };
     meta.homepage = "https://github.com/nvim-mini/mini.surround/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -10896,12 +10896,12 @@ final: prev: {
 
   neoconf-nvim = buildVimPlugin {
     pname = "neoconf.nvim";
-    version = "1.4.0-unstable-2026-05-19";
+    version = "1.4.0-unstable-2026-05-20";
     src = fetchFromGitHub {
       owner = "folke";
       repo = "neoconf.nvim";
-      rev = "39609069a03ac7fc7604a2b45944df15b67f3ed8";
-      hash = "sha256-KbQ97HC/66cVH+McpIzACYtWsffVgcImNJ9P33zctT0=";
+      rev = "de6cd4ce8491116a7df44b714b4b963dbad50393";
+      hash = "sha256-8RJ/jjbFa6C389u7CfYAqx+yM33Lijh40egIg+Vt1sU=";
     };
     meta.homepage = "https://github.com/folke/neoconf.nvim/";
     meta.license = getLicenseFromSpdxId "Apache-2.0";
@@ -11347,12 +11347,12 @@ final: prev: {
 
   neotest-java = buildVimPlugin {
     pname = "neotest-java";
-    version = "0.37.1";
+    version = "0.37.3";
     src = fetchFromGitHub {
       owner = "rcasia";
       repo = "neotest-java";
-      tag = "v0.37.1";
-      hash = "sha256-t+nqylLLHITU8li1cOl97jFKkZRmvmDbSAwvmv1yk+M=";
+      tag = "v0.37.3";
+      hash = "sha256-ALVudtC49gAQOGwucOh7zvhbUyZX0lTGyizhn+QCPl4=";
     };
     meta.homepage = "https://github.com/rcasia/neotest-java/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -11808,12 +11808,12 @@ final: prev: {
 
   nightfly = buildVimPlugin {
     pname = "nightfly";
-    version = "0-unstable-2026-04-26";
+    version = "0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "bluz71";
       repo = "vim-nightfly-colors";
-      rev = "4980ccc6de5f361fc9da116240ce7592e7d9a53a";
-      hash = "sha256-UGGHRCSZXq7vxgWntXTZDTiKuIDBs0MhWdeOucO3cxo=";
+      rev = "e197d138ecdac92c28de82fbebdc9ba2de77162a";
+      hash = "sha256-P424oLG8GefnMyol3uEMpKXHoIWbgOSqKx9ob3Yu4ko=";
     };
     meta.homepage = "https://github.com/bluz71/vim-nightfly-colors/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -12354,11 +12354,11 @@ final: prev: {
 
   nvim-dap = buildVimPlugin {
     pname = "nvim-dap";
-    version = "0.10.0-unstable-2026-04-06";
+    version = "0.10.0-unstable-2026-05-20";
     src = fetchgit {
       url = "https://codeberg.org/mfussenegger/nvim-dap/";
-      rev = "45a69eba683a2c448dd9ecfc4de89511f0646b5f";
-      hash = "sha256-9NF0+QoHOEAg6pd+oRBxr3ExWLqbvRrIMoMSZvNdqX4=";
+      rev = "531771530d4f82ad2d21e436e3cc052d68d7aebb";
+      hash = "sha256-pgD51NWFyjK1FrXZ8MFFIM9DX2OBxL7cd7JlST2Twvc=";
     };
     meta.homepage = "https://codeberg.org/mfussenegger/nvim-dap/";
     meta.license = unfree;
@@ -12477,12 +12477,12 @@ final: prev: {
 
   nvim-dap-ruby = buildVimPlugin {
     pname = "nvim-dap-ruby";
-    version = "0-unstable-2025-07-08";
+    version = "0-unstable-2026-05-20";
     src = fetchFromGitHub {
       owner = "suketa";
       repo = "nvim-dap-ruby";
-      rev = "ba36f9905ca9c6d89e5af5467a52fceeb2bbbf6d";
-      hash = "sha256-57BBhdrikDEswZe2QW+jHMSgfXIjauc6iDNpWS0YUaU=";
+      rev = "fa73da2f5124d10a4cd09ce589441b5901df706a";
+      hash = "sha256-oLohNzCdLu8kGG90NvFoRgpWov2waXfTENi5XvwWLS8=";
     };
     meta.homepage = "https://github.com/suketa/nvim-dap-ruby/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -12799,11 +12799,11 @@ final: prev: {
 
   nvim-jdtls = buildVimPlugin {
     pname = "nvim-jdtls";
-    version = "0.2.0-unstable-2026-02-10";
+    version = "0.2.0-unstable-2026-05-20";
     src = fetchgit {
       url = "https://codeberg.org/mfussenegger/nvim-jdtls/";
-      rev = "77ccaeb422f8c81b647605da5ddb4a7f725cda90";
-      hash = "sha256-ySaJ/eKtYmFoTWEKoFiiNWf+B8YIwUEqg/tKUOTcFfI=";
+      rev = "6e9d953f0b82bccdb834cfde0e893f3119c22592";
+      hash = "sha256-4EQxTo9MQagXCdWGs8oCR153VHhEm745dzgr2FdlS0s=";
     };
     meta.homepage = "https://codeberg.org/mfussenegger/nvim-jdtls/";
     meta.license = unfree;
@@ -12937,11 +12937,11 @@ final: prev: {
 
   nvim-lint = buildVimPlugin {
     pname = "nvim-lint";
-    version = "05-unstable-2026-05-18";
+    version = "05-unstable-2026-05-19";
     src = fetchgit {
       url = "https://codeberg.org/mfussenegger/nvim-lint/";
-      rev = "8b06eeec3c674744b993caecd73343df108c052d";
-      hash = "sha256-aDMmKNQSwo+evuHJtub85rX1eQGVSIhx2gvmWhlM/vA=";
+      rev = "d48f3a76189d03b2239f6df1b2f7e3fa8353743b";
+      hash = "sha256-5mlNCE0KFGfJTocV5NMlczZMmZKGzxqVdUO23KVZ4O8=";
     };
     meta.homepage = "https://codeberg.org/mfussenegger/nvim-lint/";
     meta.license = unfree;
@@ -13412,12 +13412,12 @@ final: prev: {
 
   nvim-sioyek-highlights = buildVimPlugin {
     pname = "nvim-sioyek-highlights";
-    version = "0-unstable-2026-05-17";
+    version = "0-unstable-2026-05-20";
     src = fetchFromGitHub {
       owner = "jbuck95";
       repo = "nvim-sioyek-highlights";
-      rev = "1dc885c08e895178f2d5b2474bc366a962077849";
-      hash = "sha256-9wEFRB4OSBnRYLW8BbUgGjs5XbiZ6ZpxC5LPXJ/Mi7k=";
+      rev = "753f5d309d08229325134e5992cd032d06f72ee8";
+      hash = "sha256-JiHBw/3LqYW4oxT+ObvU3IsDU1Q5JaKr4TDBZautNV0=";
     };
     meta.homepage = "https://github.com/jbuck95/nvim-sioyek-highlights/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -14294,12 +14294,12 @@ final: prev: {
 
   opencode-nvim = buildVimPlugin {
     pname = "opencode.nvim";
-    version = "0.10.0";
+    version = "0.10.1";
     src = fetchFromGitHub {
       owner = "nickjvandyke";
       repo = "opencode.nvim";
-      tag = "v0.10.0";
-      hash = "sha256-H++d+0xdqfkYM7XjnDRN5MgHOTIJA3fBNRY1zBgGonk=";
+      tag = "v0.10.1";
+      hash = "sha256-hpRlUUI1wEluMyWfAnxjztbozIVgN7Yan2zH+HmEsSw=";
     };
     meta.homepage = "https://github.com/nickjvandyke/opencode.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -14406,12 +14406,12 @@ final: prev: {
 
   overseer-nvim = buildVimPlugin {
     pname = "overseer.nvim";
-    version = "2.1.0-unstable-2026-05-14";
+    version = "2.1.0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "stevearc";
       repo = "overseer.nvim";
-      rev = "3d0c7e7bbfe1a1c6f9bfecd0af8709171a97df71";
-      hash = "sha256-hxVnBKiyIFtb2PkRHOlClVXSJ20Gtg2w7QzuwpiVqsQ=";
+      rev = "473944a838d7efa112a6c8e481d27f1a76236a90";
+      hash = "sha256-Ie4yhebBv+Pq7pqBx+TGHA7p3HUCU1+nQ5d/IpcjUqU=";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/stevearc/overseer.nvim/";
@@ -14547,12 +14547,12 @@ final: prev: {
 
   parrot-nvim = buildVimPlugin {
     pname = "parrot.nvim";
-    version = "2.5.1-unstable-2026-01-21";
+    version = "2.5.1-unstable-2026-05-20";
     src = fetchFromGitHub {
       owner = "frankroeder";
       repo = "parrot.nvim";
-      rev = "34bff8b294d85f445843cb70faa205e07e22d4f0";
-      hash = "sha256-xXrjfZQOzqXfm0vq1eQjwjyMxQMSrzF3CNBBd3LgG9Y=";
+      rev = "964675ca588efae2a50bef35b01729acc36cb3d5";
+      hash = "sha256-EPrisAicCUpUPl0q5h/uBBSpQuuzOlSCbQpu0ispwvU=";
     };
     meta.homepage = "https://github.com/frankroeder/parrot.nvim/";
     meta.license = unfree;
@@ -15010,12 +15010,12 @@ final: prev: {
 
   pum-vim = buildVimPlugin {
     pname = "pum.vim";
-    version = "2.0-unstable-2026-05-02";
+    version = "2.0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "Shougo";
       repo = "pum.vim";
-      rev = "16a70a73d98e08f0327a7317450590a449ebcbb9";
-      hash = "sha256-Qa0AYO91rUsLgDpUsD0hqMLJQhwo6jg/72nolnc2Jh0=";
+      rev = "f3c2436bd93f6d4818a91e480f991ccc3b20338e";
+      hash = "sha256-cfd3yckABLaG8CQtDwyUgivAH6rHxPSubqVvNJrzxdk=";
     };
     meta.homepage = "https://github.com/Shougo/pum.vim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -15137,12 +15137,12 @@ final: prev: {
 
   quicker-nvim = buildVimPlugin {
     pname = "quicker.nvim";
-    version = "1.5.0-unstable-2026-05-15";
+    version = "1.5.1";
     src = fetchFromGitHub {
       owner = "stevearc";
       repo = "quicker.nvim";
-      rev = "1c9322b7e2967472548ba9bccd1ccd40e49d0a49";
-      hash = "sha256-K1jaWpTSNCni6CgR9mlNguiPyhQ1BMjj4p3/V+6XoMA=";
+      tag = "v1.5.1";
+      hash = "sha256-CVW0GJhSD/J4iSFgGpXlTWViPePIlw+Wu3tF9urWMIE=";
     };
     meta.homepage = "https://github.com/stevearc/quicker.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -15332,12 +15332,12 @@ final: prev: {
 
   refactoring-nvim = buildVimPlugin {
     pname = "refactoring.nvim";
-    version = "0-unstable-2026-05-13";
+    version = "0-unstable-2026-05-23";
     src = fetchFromGitHub {
       owner = "theprimeagen";
       repo = "refactoring.nvim";
-      rev = "f5b54f3605d9ed709521db1827b8686dea283622";
-      hash = "sha256-h2ZOwdva5f3VeZASKjq/DhBiuaZI2Ovpc/vzBMerv9g=";
+      rev = "8f2045241fb105ab092021e3e58b5b99f34f07d0";
+      hash = "sha256-ZYEX22JJ1d+BeTq1aaTR/sKwjVCUlJMnEOtyVBrVt9A=";
     };
     meta.homepage = "https://github.com/theprimeagen/refactoring.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -15458,12 +15458,12 @@ final: prev: {
 
   resession-nvim = buildVimPlugin {
     pname = "resession.nvim";
-    version = "1.2.1-unstable-2025-11-05";
+    version = "1.2.1-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "stevearc";
       repo = "resession.nvim";
-      rev = "05adc14db5c2d0eae064765101dd5e9c594c7851";
-      hash = "sha256-7Wa3PwTWEueRkhKBhOMbvstT5vFj2sxyiHoJOrdcJAc=";
+      rev = "0983fbdd3fe938c80fb7dd33817f08f428426ac8";
+      hash = "sha256-uvKyEgd/tnRZvYS/+vR5airpgE8cFo5CqGxNWBKbMdQ=";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/stevearc/resession.nvim/";
@@ -15557,12 +15557,12 @@ final: prev: {
 
   roslyn-nvim = buildVimPlugin {
     pname = "roslyn.nvim";
-    version = "0-unstable-2026-05-18";
+    version = "0-unstable-2026-05-22";
     src = fetchFromGitHub {
       owner = "seblyng";
       repo = "roslyn.nvim";
-      rev = "49526a2958893d0c8000d03b16ed923340ce13cc";
-      hash = "sha256-MUosD7oF1hBA9sYl5RAAogxco+jLiyu0YKKpzui6Vs4=";
+      rev = "426984d6c1e8ee88a394a562eb925e687340f91e";
+      hash = "sha256-gbYRc8l0MrP7cnp3ggpjXBmXB8IZUXHD8bHgMiu16FM=";
     };
     meta.homepage = "https://github.com/seblyng/roslyn.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -15906,12 +15906,12 @@ final: prev: {
 
   seoul256-vim = buildVimPlugin {
     pname = "seoul256.vim";
-    version = "0-unstable-2026-04-17";
+    version = "0-unstable-2026-05-20";
     src = fetchFromGitHub {
       owner = "junegunn";
       repo = "seoul256.vim";
-      rev = "d8499250154f0b26a398cd76769861afd8fb68fd";
-      hash = "sha256-dPwFpT8O91uxnxJ9drKvou+quM4iFqFW9EyeAFdWNoU=";
+      rev = "88997adf362f57c3eadedde6b8c1393fe218c02c";
+      hash = "sha256-Em9vpXJmUyLfBHOLHVQQUGsOuluwyx+J4Q5vU8akyS0=";
     };
     meta.homepage = "https://github.com/junegunn/seoul256.vim/";
     meta.license = unfree;
@@ -16033,12 +16033,12 @@ final: prev: {
 
   smart-splits-nvim = buildVimPlugin {
     pname = "smart-splits.nvim";
-    version = "2.1.0-unstable-2026-05-15";
+    version = "2.1.0-unstable-2026-05-22";
     src = fetchFromGitHub {
       owner = "mrjones2014";
       repo = "smart-splits.nvim";
-      rev = "3151100591670148cb0065388117622212208ee3";
-      hash = "sha256-uRMQy89pDA2LwgDKj2mcvrTLCf7LyCIM2EHdq8EBcq4=";
+      rev = "b24335c3186b6c35522fa108af63646a2f70b3b6";
+      hash = "sha256-GNcTzTqwHaiDbMW9tHUYDb0AQsBc3eA608cthW2vN8U=";
     };
     meta.homepage = "https://github.com/mrjones2014/smart-splits.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -16103,12 +16103,12 @@ final: prev: {
 
   snacks-nvim = buildVimPlugin {
     pname = "snacks.nvim";
-    version = "2.31.0-unstable-2026-03-21";
+    version = "2.31.0-unstable-2026-05-21";
     src = fetchFromGitHub {
       owner = "folke";
       repo = "snacks.nvim";
-      rev = "ad9ede6a9cddf16cedbd31b8932d6dcdee9b716e";
-      hash = "sha256-7lDH1JlTM+H/LWjMlAQPNY6A+xmS/cp+wChy4buGYIU=";
+      rev = "0770753c88228f7f15449c6a5b242e3f7cd0d71c";
+      hash = "sha256-lMCozVT9RRgJwsudAUrrinI6WdiPb+gykcQe46OmRh4=";
     };
     meta.homepage = "https://github.com/folke/snacks.nvim/";
     meta.license = getLicenseFromSpdxId "Apache-2.0";
@@ -16368,12 +16368,12 @@ final: prev: {
 
   splitjoin-vim = buildVimPlugin {
     pname = "splitjoin.vim";
-    version = "1.2.0-unstable-2026-04-10";
+    version = "1.2.0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "AndrewRadev";
       repo = "splitjoin.vim";
-      rev = "8c4c87e72d20d8d5eee8b29c320eb61767578841";
-      hash = "sha256-6QLiYYanMcJjPcw1pWaYCcsqPijox8E85BF7PwTzyfA=";
+      rev = "b26971a7fdc7ca645b766459e3ed7949300c404f";
+      hash = "sha256-IWBFDaltzAhM0QSTPTgb7wdrCM4CysQpaZ3kw0NkQAU=";
       fetchSubmodules = true;
     };
     meta.homepage = "https://github.com/AndrewRadev/splitjoin.vim/";
@@ -17142,12 +17142,12 @@ final: prev: {
 
   telescope-frecency-nvim = buildVimPlugin {
     pname = "telescope-frecency.nvim";
-    version = "1.2.2-unstable-2026-05-10";
+    version = "1.2.2-unstable-2026-05-21";
     src = fetchFromGitHub {
       owner = "nvim-telescope";
       repo = "telescope-frecency.nvim";
-      rev = "ab7b69366f46a8749e3c3ec21ba0cbc59a440ddd";
-      hash = "sha256-FVo2odnwxImjSd+mYciHznwrRwY8W80mn4lJtQKAEZE=";
+      rev = "5479d8a269e30479280c59e44f805396127653e6";
+      hash = "sha256-gC3pmeBCUPDFvBSNNn6RXAbbeBRcIqiAyZVCO3TKJz4=";
     };
     meta.homepage = "https://github.com/nvim-telescope/telescope-frecency.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -17231,7 +17231,7 @@ final: prev: {
     src = fetchFromGitHub {
       owner = "alduraibi";
       repo = "telescope-glyph.nvim";
-      rev = "f63f01e129e71cc25b79637610674bbf0be5ce9d";
+      rev = "6e0bdece0d0382e664b2dc716a9c5641994148c9";
       hash = "sha256-6H4afMXtaZn066oBq3z8vvR7WH7WhqZkvziyOXlsNVg=";
     };
     meta.homepage = "https://github.com/alduraibi/telescope-glyph.nvim/";
@@ -18042,12 +18042,12 @@ final: prev: {
 
   treewalker-nvim = buildVimPlugin {
     pname = "treewalker.nvim";
-    version = "0-unstable-2026-05-08";
+    version = "0-unstable-2026-05-20";
     src = fetchFromGitHub {
       owner = "aaronik";
       repo = "treewalker.nvim";
-      rev = "fcaa112f8c3dfba3a91c52a5a95701a7917f61e3";
-      hash = "sha256-5s3P1xekniVgtEfAwuxbOwGsSi90UuutctVLgXC/C0g=";
+      rev = "0b081bf6c6875cf3e478b633796a9e2b64b730e8";
+      hash = "sha256-+TwgQm109yt1LXOWzU+vWjWYVKmZ5snsqRrikUZfVJE=";
     };
     meta.homepage = "https://github.com/aaronik/treewalker.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -18436,12 +18436,12 @@ final: prev: {
 
   unified-nvim = buildVimPlugin {
     pname = "unified.nvim";
-    version = "0.0.2-unstable-2026-03-05";
+    version = "0.0.4";
     src = fetchFromGitHub {
       owner = "axkirillov";
       repo = "unified.nvim";
-      rev = "d4427c8d0d89fc3737bb5f53d56a2ea153c94ec7";
-      hash = "sha256-BPoSViNDO678SWVaGl9FHfSzWLEbqFR39v+MmfOPSo4=";
+      tag = "0.0.4";
+      hash = "sha256-CmMq6Kw5q6vKDj4Tktu7q4YeQHmLVJYa9AN5BTb4V2E=";
     };
     meta.homepage = "https://github.com/axkirillov/unified.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -18478,12 +18478,12 @@ final: prev: {
 
   unison = buildVimPlugin {
     pname = "unison";
-    version = "1.2.0";
+    version = "1.3.0";
     src = fetchFromGitHub {
       owner = "unisonweb";
       repo = "unison";
-      tag = "release/1.2.0";
-      hash = "sha256-ku6Bxg3jJruYOgrBRUzsankQtNryDmv1nWWjhvdskXs=";
+      tag = "release/1.3.0";
+      hash = "sha256-uw1QBTY6Shj2liDdLaoNjqkEAYr5pMG7SfrLuhdDi8k=";
     };
     meta.homepage = "https://github.com/unisonweb/unison/";
     meta.license = unfree;
@@ -18618,12 +18618,12 @@ final: prev: {
 
   venv-selector-nvim = buildVimPlugin {
     pname = "venv-selector.nvim";
-    version = "0-unstable-2026-05-18";
+    version = "0-unstable-2026-05-20";
     src = fetchFromGitHub {
       owner = "linux-cultist";
       repo = "venv-selector.nvim";
-      rev = "a46c77978abc1aa1b3e17918d964bd30287abb42";
-      hash = "sha256-dyB/2aPr0XNTi6W1ikRcHQtxaYpe2JiVT5NZhSLpsKg=";
+      rev = "cc4bb3975de8835291f9bb45889e96c6b2795fc4";
+      hash = "sha256-+GRJuvsO4nf+RczyDOojfUc+nfsM9JIENUv43fEZPYU=";
     };
     meta.homepage = "https://github.com/linux-cultist/venv-selector.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -22022,12 +22022,12 @@ final: prev: {
 
   vim-lsp-settings = buildVimPlugin {
     pname = "vim-lsp-settings";
-    version = "0.0.1-unstable-2026-04-04";
+    version = "0.0.1-unstable-2026-05-21";
     src = fetchFromGitHub {
       owner = "mattn";
       repo = "vim-lsp-settings";
-      rev = "a0ec2ee4e75a14f2471896a1192c1970d7be4258";
-      hash = "sha256-G7+ToiCUgdwANcPtVZFqBsAEcON+mwgpaRQtOaXtpb8=";
+      rev = "1558bbaba4cbb593901e3dfc4d0f1a0cd212b09c";
+      hash = "sha256-wMF4y4eMz7UR50GpBvStDsQ0SpKUt48tll6rqEr6AHY=";
     };
     meta.homepage = "https://github.com/mattn/vim-lsp-settings/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -22162,12 +22162,12 @@ final: prev: {
 
   vim-matchup = buildVimPlugin {
     pname = "vim-matchup";
-    version = "0.8.0-unstable-2026-04-10";
+    version = "0.8.0-unstable-2026-05-19";
     src = fetchFromGitHub {
       owner = "andymass";
       repo = "vim-matchup";
-      rev = "dccb2d12ef2a703d2f076b3cda36a3339449d1eb";
-      hash = "sha256-REbSURtBOLWhjyZyJdEQ4VQXifX6e3bv9+B9PpKlq8o=";
+      rev = "a2d618496223386844acb5a6763cfc3cc1357af1";
+      hash = "sha256-6v4kWrOxGvrtSkL7itcxXgOarKWmb0y++8mLnyc1XRI=";
     };
     meta.homepage = "https://github.com/andymass/vim-matchup/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -22302,12 +22302,12 @@ final: prev: {
 
   vim-moonfly-colors = buildVimPlugin {
     pname = "vim-moonfly-colors";
-    version = "0-unstable-2026-04-26";
+    version = "0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "bluz71";
       repo = "vim-moonfly-colors";
-      rev = "4ed07bc0c6083cdd547c63f5c245e02c068b0c45";
-      hash = "sha256-78F44cldvn+D/cfeaSe4A7LURMArCvkUJER22oTUuyM=";
+      rev = "1c0a9994bb6bb5b43859c67924aabd061c4b7905";
+      hash = "sha256-x3IbuNHg+y0NtNguJnWCpz3bsj9aR41ecTToUYFQlNM=";
     };
     meta.homepage = "https://github.com/bluz71/vim-moonfly-colors/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -22918,12 +22918,12 @@ final: prev: {
 
   vim-plug = buildVimPlugin {
     pname = "vim-plug";
-    version = "0.14.0-unstable-2026-05-17";
+    version = "0.14.0-unstable-2026-05-22";
     src = fetchFromGitHub {
       owner = "junegunn";
       repo = "vim-plug";
-      rev = "d7db1b637c68f7c9a6b4c2c2bc73d8c18e7b40c0";
-      hash = "sha256-MqmNRtjN/tvDJKZjiUqqzVuq/tvD9OO5bgWmN2Fa058=";
+      rev = "88e31471818e9a29a8a20a0ee61360cfd7bdc1cd";
+      hash = "sha256-zdk3aAAH3N8oBxd1if8p42Cp9FIuRCdk5wgivX6IyVw=";
     };
     meta.homepage = "https://github.com/junegunn/vim-plug/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -23827,12 +23827,12 @@ final: prev: {
 
   vim-spirv = buildVimPlugin {
     pname = "vim-spirv";
-    version = "0.5.2-unstable-2026-05-16";
+    version = "0.5.2-unstable-2026-05-21";
     src = fetchFromGitHub {
       owner = "kbenzie";
       repo = "vim-spirv";
-      rev = "46a58ad2e5b173ada034e6bfe23f746c29df94a1";
-      hash = "sha256-DDOxzEp0L1M3hJYkOF1BeEscShaTx5oINuJPE0haJBk=";
+      rev = "4f35017d1a52c3fa836329a50c29783fc765da5e";
+      hash = "sha256-xIoJeN7wOM5piBFGBJNzuzguCanAZfBZCZGUPJpV8Jk=";
     };
     meta.homepage = "https://github.com/kbenzie/vim-spirv/";
     meta.license = getLicenseFromSpdxId "MIT";
@@ -23841,12 +23841,12 @@ final: prev: {
 
   vim-splunk = buildVimPlugin {
     pname = "vim-splunk";
-    version = "0-unstable-2025-08-25";
+    version = "0-unstable-2026-05-24";
     src = fetchFromGitHub {
       owner = "yorokobi";
       repo = "vim-splunk";
-      rev = "b6306fc0105caa3ff9d8a2bb0a858a691a98a4af";
-      hash = "sha256-cacNP4C9vl4h36GzWrrSZlRg53HelyYt+oXX0krHnyA=";
+      rev = "003bc863caa442dbcbb711d8c61ad8895c0da47a";
+      hash = "sha256-KRF707b0O9FuS5R7m688+9x7RxNzRlDFI3Nz2g6nels=";
     };
     meta.homepage = "https://github.com/yorokobi/vim-splunk/";
     meta.license = getLicenseFromSpdxId "Unlicense";
@@ -25689,12 +25689,12 @@ final: prev: {
 
   yanky-nvim = buildVimPlugin {
     pname = "yanky.nvim";
-    version = "2.0.0-unstable-2026-03-12";
+    version = "2.0.0-unstable-2026-05-20";
     src = fetchFromGitHub {
       owner = "gbprod";
       repo = "yanky.nvim";
-      rev = "784188e0a7363e762e53140f39124d786aec0832";
-      hash = "sha256-oGiXbSXo48NbaImzIKquEvplPCotLeIs4scvbhO6wyA=";
+      rev = "b13d318dc7c816e2eee626dde61fa0a7237bc77e";
+      hash = "sha256-6WukBxyEIc9vEay0vN8R0zfxxU54+bkxLAQzsqc6AA8=";
     };
     meta.homepage = "https://github.com/gbprod/yanky.nvim/";
     meta.license = getLicenseFromSpdxId "WTFPL";
@@ -25718,12 +25718,12 @@ final: prev: {
 
   yazi-nvim = buildVimPlugin {
     pname = "yazi.nvim";
-    version = "13.1.5-unstable-2026-05-19";
+    version = "13.1.6";
     src = fetchFromGitHub {
       owner = "mikavilpas";
       repo = "yazi.nvim";
-      rev = "cad24771df41423022233f11078087c4c8400e51";
-      hash = "sha256-ln4eMzgrrdMCQBWJrJaCb3q5VLYFkmWExgTYcp1dL+g=";
+      tag = "v13.1.6";
+      hash = "sha256-8NDBtyAWddj4t76Sl0phUdA9pTbEf4Q1RvodDd/bN4w=";
     };
     meta.homepage = "https://github.com/mikavilpas/yazi.nvim/";
     meta.license = getLicenseFromSpdxId "MIT";

pkgs/applications/editors/vscode/extensions/saoudrizwan.claude-dev/default.nix

@@ -7,8 +7,8 @@ vscode-utils.buildVscodeMarketplaceExtension {
   mktplcRef = {
     name = "claude-dev";
     publisher = "saoudrizwan";
-    version = "3.83.0";
-    hash = "sha256-d9b8mXi/PI87T9J67yzI2yID7hhd6OPdM2+Na3I5Wg8=";
+    version = "3.84.0";
+    hash = "sha256-j+EnHm4ucqzMgB0u5J4ki1x3YhMPWFj3/p/C95sbQH0=";
   };
 
   meta = {

pkgs/applications/networking/znc/default.nix

@@ -74,8 +74,7 @@ stdenv.mkDerivation (finalAttrs: {
   meta = {
     description = "Advanced IRC bouncer";
     homepage = "https://wiki.znc.in/ZNC";
-    maintainers = with lib.maintainers; [
-      lnl7
+    maintainers = [
     ];
     license = lib.licenses.asl20;
     platforms = lib.platforms.unix;

pkgs/applications/science/logic/abella/default.nix

@@ -54,10 +54,7 @@ stdenv.mkDerivation (finalAttrs: {
     '';
     homepage = "https://abella-prover.org";
     license = lib.licenses.gpl3;
-    maintainers = with lib.maintainers; [
-      bcdarwin
-      ciil
-    ];
+    maintainers = [ lib.maintainers.bcdarwin ];
     platforms = lib.platforms.unix;
   };
 })

pkgs/by-name/au/authentik/package.nix

@@ -20,13 +20,13 @@
 let
   nodejs = nodejs_24;
 
-  version = "2025.12.4";
+  version = "2025.12.5";
 
   src = fetchFromGitHub {
     owner = "goauthentik";
     repo = "authentik";
     tag = "version/${version}";
-    hash = "sha256-alTyrMBbjZbw4jhEna8saabf93sqSrZCu+Z5xH3pZ7M=";
+    hash = "sha256-LPGAhbtmuztDQ4CVhUXb+vBU5HjvNZ7JicI5r3lr1QQ=";
   };
 
   meta = {
@@ -52,7 +52,7 @@ let
     src = fetchFromGitHub {
       owner = "goauthentik";
       repo = "client-go";
-      tag = "v3.${version}";
+      tag = "v3.2025.12.4";
       hash = "sha256-+/CfOE2HkBU+ZddvdXGenB/z8xNFk8cujpZpMXyh3cY=";
     };
 
@@ -137,8 +137,8 @@ let
 
     outputHash =
       {
-        "aarch64-linux" = "sha256-GL5FPIBnoEXYtw8DPJpRPe3tT3qioN4AdoeOmCoiYsM=";
-        "x86_64-linux" = "sha256-AnceTipq6uUvTbOAZanVshAbAJ9LS1kwImbttTOcWxc=";
+        "aarch64-linux" = "sha256-smm9x29z7gOI7Wq0NvP45KHtBbT6p1lH6IjEf9LRuGs=";
+        "x86_64-linux" = "sha256-K86wnn50svP+QG3i0mggH8RQgfoIqEmyQTouz35xzw8=";
       }
       .${stdenvNoCC.hostPlatform.system} or (throw "authentik-website-deps: unsupported host platform");
 
@@ -208,8 +208,8 @@ let
 
     outputHash =
       {
-        "aarch64-linux" = "sha256-eZZ5Ynj81KwFsU5emPtYZ2CxO8MFvWbJnCHs+L88KQQ=";
-        "x86_64-linux" = "sha256-yUAyyO1NFav1EptrRYGSzC8dxCxYVj0FmzHk8IckFZM=";
+        "aarch64-linux" = "sha256-J9wGQe7iMfKznNk3woqi0VNVNA/dE6TGi2f44DOlG1c=";
+        "x86_64-linux" = "sha256-9Q590Rw0mk3q5osxOKGWU7+XtKwkTyA+CLC2LxAA/3g=";
       }
       .${stdenvNoCC.hostPlatform.system} or (throw "authentik-webui-deps: unsupported host platform");
     outputHashMode = "recursive";

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

@@ -14,16 +14,16 @@
 
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "cargo-dist";
-  version = "0.31.0";
+  version = "0.32.0";
 
   src = fetchFromGitHub {
     owner = "axodotdev";
     repo = "cargo-dist";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-BSE3pXo7Kk104v7VEh5WUk+Km1/n/kNf8NJGVGjUKoc=";
+    hash = "sha256-WNbo3sm5tSNYQMLB4bjiNtLwp5pD4KAoyG2lwWYEpzk=";
   };
 
-  cargoHash = "sha256-bfX2Yt0wrPg1pbvYdr2O9VUqYlCFVRh4PIABWxZTgjg=";
+  cargoHash = "sha256-gzaDAGAjWDcJyoES0foFOyhTP4HDsaQHrrwCQmAzXZA=";
 
   nativeBuildInputs = [
     pkg-config

pkgs/by-name/cm/cmake/package.nix

@@ -207,7 +207,6 @@ stdenv.mkDerivation (finalAttrs: {
     license = lib.licenses.bsd3;
     maintainers = with lib.maintainers; [
       ttuegel
-      lnl7
     ];
     platforms = lib.platforms.all;
     mainProgram = "cmake";

pkgs/by-name/cr/crunch/package.nix

@@ -34,6 +34,6 @@ stdenv.mkDerivation (finalAttrs: {
     homepage = "https://sourceforge.net/projects/crunch-wordlist/";
     platforms = lib.platforms.unix;
     license = with lib.licenses; [ gpl2Only ];
-    maintainers = with lib.maintainers; [ lnl7 ];
+    maintainers = [ ];
   };
 })

pkgs/by-name/da/daktari/package.nix

@@ -7,7 +7,7 @@
 
 python3Packages.buildPythonApplication (finalAttrs: {
   pname = "daktari";
-  version = "0.0.321";
+  version = "0.0.324";
   pyproject = true;
   __structuredAttrs = true;
 
@@ -15,7 +15,7 @@ python3Packages.buildPythonApplication (finalAttrs: {
     owner = "genio-learn";
     repo = "daktari";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-ZxSyN1yv0MCKo5y9uTGFRURA3hc04DnzOzXAuNHi/s0=";
+    hash = "sha256-f9TpdxarSTMmXhalrjFmGT+zIUNMY+add5OiTq/xW7A=";
   };
 
   patches = [ ./optional-pyclip.patch ];

pkgs/by-name/dd/ddhx/package.nix

@@ -31,5 +31,6 @@ buildDubPackage (finalAttrs: {
     license = lib.licenses.mit;
     maintainers = [ lib.maintainers.ryand56 ];
     platforms = lib.platforms.unix;
+    mainProgram = "ddhx";
   };
 })

pkgs/by-name/ga/garnet/deps.json

@@ -31,8 +31,8 @@
   },
   {
     "pname": "diskann-garnet",
-    "version": "1.0.26",
-    "hash": "sha256-xKcv20olcK/0HBKsiaB+gNXqz6YyKHEdvYVjqssIjy0="
+    "version": "1.0.27",
+    "hash": "sha256-z1kj3LbJGVk0X4SDocHO9SaS/b5bMhRIvHNhjTEObi8="
   },
   {
     "pname": "KeraLua",

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

@@ -8,13 +8,13 @@
 
 buildDotnetModule rec {
   pname = "garnet";
-  version = "1.1.6";
+  version = "1.1.9";
 
   src = fetchFromGitHub {
     owner = "microsoft";
     repo = "garnet";
     tag = "v${version}";
-    hash = "sha256-OUCztqeE8oHaO0Cz/4Oz6bsp8GKszxwTjpbMLFvkCTE=";
+    hash = "sha256-8oZrUb3ed/M3juchn6OSRQAX6tfplekwmLLjHURtms8=";
   };
 
   projectFile = "main/GarnetServer/GarnetServer.csproj";

pkgs/by-name/gi/git-branchless/fix-esl01-indexedlog-for-rust-1_89.patch

@@ -1,18 +0,0 @@
-diff --git a/src/lock.rs b/src/lock.rs
---- a/src/lock.rs
-+++ b/src/lock.rs
-@@ -132,10 +132,10 @@ impl ScopedDirLock {
- 
-         // Lock
-         match (opts.exclusive, opts.non_blocking) {
--            (true, false) => file.lock_exclusive(),
--            (true, true) => file.try_lock_exclusive(),
--            (false, false) => file.lock_shared(),
--            (false, true) => file.try_lock_shared(),
-+            (true, false) => fs2::FileExt::lock_exclusive(&file),
-+            (true, true) => fs2::FileExt::try_lock_exclusive(&file),
-+            (false, false) => fs2::FileExt::lock_shared(&file),
-+            (false, true) => fs2::FileExt::try_lock_shared(&file),
-         }
-         .context(&path, || {
-             format!(

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

@@ -13,30 +13,16 @@
 
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "git-branchless";
-  version = "0.10.0";
+  version = "0.11.0";
 
   src = fetchFromGitHub {
     owner = "arxanas";
     repo = "git-branchless";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-8uv+sZRr06K42hmxgjrKk6FDEngUhN/9epixRYKwE3U=";
+    hash = "sha256-mxZLS39/QNDSR3RZsG17Sd+ses3IEqtbqIMASxOpzmo=";
   };
 
-  # Patch the vendored esl01-indexedlog crate.
-  # This is necessary to fix the build for rust 1.89. See:
-  # - https://github.com/NixOS/nixpkgs/issues/437051
-  # - https://github.com/arxanas/git-branchless/issues/1585
-  # - https://github.com/facebook/sapling/issues/1119
-  # The patch is derived from:
-  # - https://github.com/facebook/sapling/commit/9e27acb84605079bf4e305afb637a4d6801831ac
-  postPatch = ''
-    (
-      cd $cargoDepsCopy/*/esl01-indexedlog-*/
-      patch -p1 < ${./fix-esl01-indexedlog-for-rust-1_89.patch}
-    )
-  '';
-
-  cargoHash = "sha256-i7KpTd4fX3PrhDjj3R9u98rdI0uHkpQCxSmEF+Gu7yk=";
+  cargoHash = "sha256-bAZ0M3/RD3L+x0Xb+n6XPn0wRj+bQkoOmErSDuOHIRw=";
 
   nativeBuildInputs = [ pkg-config ];
 

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

@@ -33,7 +33,7 @@ stdenv.mkDerivation (finalAttrs: {
     mainProgram = "gnushogi";
     homepage = "https://www.gnu.org/software/gnushogi/";
     license = lib.licenses.gpl3;
-    maintainers = [ lib.maintainers.ciil ];
+    maintainers = [ ];
     platforms = lib.platforms.unix;
   };
 })

pkgs/by-name/gr/grpc/package.nix

@@ -132,7 +132,7 @@ stdenv.mkDerivation (finalAttrs: {
   meta = {
     description = "C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#)";
     license = lib.licenses.asl20;
-    maintainers = with lib.maintainers; [ lnl7 ];
+    maintainers = [ ];
     homepage = "https://grpc.io/";
     platforms = lib.platforms.all;
     changelog = "https://github.com/grpc/grpc/releases/tag/v${finalAttrs.version}";

pkgs/by-name/gs/gshogi/package.nix

@@ -51,6 +51,6 @@ python3.pkgs.buildPythonApplication (finalAttrs: {
     mainProgram = "gshogi";
     license = lib.licenses.gpl3Plus;
     platforms = lib.platforms.linux;
-    maintainers = [ lib.maintainers.ciil ];
+    maintainers = [ ];
   };
 })

pkgs/by-name/ic/icm/package.nix

@@ -12,17 +12,17 @@
 
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "icm";
-  version = "0.10.49";
+  version = "0.10.50";
   __structuredAttrs = true;
 
   src = fetchFromGitHub {
     owner = "rtk-ai";
     repo = "icm";
     tag = "icm-v${finalAttrs.version}";
-    hash = "sha256-GB2SH/Y2l4AkxoFqJfWcsGmWK4uOayCs1FSxBuXShwc=";
+    hash = "sha256-zaKpKMVH2vzUk0ryWupE4ByqqcmAdJwAe5ybb2TNlvM=";
   };
 
-  cargoHash = "sha256-U0mHWzRI6BDVC4LRpwWz/QbCeT0fEPxKoY5+1DrI048=";
+  cargoHash = "sha256-5NcmFaRqDla2ei694fJiqNr5n4V3A/ai3/9fzBHNa3s=";
 
   nativeBuildInputs = [
     pkg-config

pkgs/by-name/in/inform7/package.nix

@@ -40,7 +40,7 @@ stdenv.mkDerivation {
     mainProgram = "i7";
     homepage = "http://inform7.com/";
     license = lib.licenses.artistic2;
-    maintainers = with lib.maintainers; [ mbbx6spp ];
+    maintainers = [ ];
     platforms = lib.platforms.unix;
     # never built on aarch64-darwin since first introduction in nixpkgs
     broken =

pkgs/by-name/in/invidious/package.nix

@@ -1,7 +1,7 @@
 {
   lib,
   callPackage,
-  crystal_1_16,
+  crystal,
   fetchFromGitHub,
   librsvg,
   pkg-config,
@@ -27,7 +27,6 @@
 let
   # normally video.js is downloaded at build time
   videojs = callPackage ./videojs.nix { inherit versions; };
-  crystal = crystal_1_16;
 in
 crystal.buildCrystalPackage rec {
   pname = "invidious";
@@ -69,7 +68,7 @@ crystal.buildCrystalPackage rec {
 
       # Patch the assets and locales paths to be absolute
       substituteInPlace src/invidious.cr \
-          --replace-fail 'public_folder "assets"' 'public_folder "${placeholder "out"}/share/invidious/assets"'
+          --replace-fail 'StaticAssetsHandler.new("assets"' 'StaticAssetsHandler.new("${placeholder "out"}/share/invidious/assets"'
       substituteInPlace src/invidious/helpers/i18n.cr \
           --replace-fail 'File.read("locales/' 'File.read("${placeholder "out"}/share/invidious/locales/'
 

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

@@ -13,7 +13,7 @@
 }:
 buildNpmPackage (finalAttrs: {
   pname = "jellyfin-web";
-  version = "10.11.8";
+  version = "10.11.10";
 
   src =
     assert finalAttrs.version == jellyfin.version;
@@ -21,7 +21,7 @@ buildNpmPackage (finalAttrs: {
       owner = "jellyfin";
       repo = "jellyfin-web";
       tag = "v${finalAttrs.version}";
-      hash = "sha256-Nrh4BNlhJyzj9cXQ6Yr7349r5H+4r9W3aldcg9+J6dU=";
+      hash = "sha256-fSpzF6Arx0JfL9fuQHjzf3m82XZR2BZkV0lA37L4DN4=";
     };
 
   nodejs = nodejs_22;
@@ -31,7 +31,7 @@ buildNpmPackage (finalAttrs: {
       --replace-fail "git describe --always --dirty" "echo ${finalAttrs.src.rev}"
   '';
 
-  npmDepsHash = "sha256-oxytp6n/4X1bhpfFqpqMAji86sbjV669F324zY3hoK4=";
+  npmDepsHash = "sha256-DCFgivbZrDufRaB+4PeFxO6ISbEM9lXhXmlzc/5GbVU=";
 
   preBuild = ''
     # using sass-embedded fails at executing node_modules/sass-embedded-linux-x64/dart-sass/src/dart

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

@@ -14,13 +14,13 @@
 
 buildDotnetModule (finalAttrs: {
   pname = "jellyfin";
-  version = "10.11.8"; # ensure that jellyfin-web has matching version
+  version = "10.11.10"; # ensure that jellyfin-web has matching version
 
   src = fetchFromGitHub {
     owner = "jellyfin";
     repo = "jellyfin";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-wBf561mZvC65Hu4MHHSu8YeILQDp/WN9vGA+JxGXwE8=";
+    hash = "sha256-bad532F8Ln5Y3TV4x5c7mgsiI+ZJGTZoahuSZhefMvQ=";
   };
 
   propagatedBuildInputs = [ sqlite ];

pkgs/by-name/ki/kimai/package.nix

@@ -7,13 +7,13 @@
 
 php.buildComposerProject2 (finalAttrs: {
   pname = "kimai";
-  version = "2.56.0";
+  version = "2.57.0";
 
   src = fetchFromGitHub {
     owner = "kimai";
     repo = "kimai";
     tag = finalAttrs.version;
-    hash = "sha256-rax67E/Zr50ejSAjA4Aa1NDsAbJYuAAE4k8hji5UhOg=";
+    hash = "sha256-WbZivDI5xU/pM52yFvG6vMK3LaCjbLoJGNFP3Exb8qc=";
   };
 
   php = php.buildEnv {
@@ -38,7 +38,7 @@ php.buildComposerProject2 (finalAttrs: {
     '';
   };
 
-  vendorHash = "sha256-XHicbYXOfCPFIMKrhyBpchd89anj6kG1/7prpER7aCo=";
+  vendorHash = "sha256-6WthU0w8V69sDlBjtz2MIavkmyYXWQ+5NflZLGQCLJs=";
 
   composerNoPlugins = false;
   postInstall = ''

pkgs/by-name/ki/kirimoto/package.nix

@@ -5,12 +5,12 @@
 }:
 
 let
-  version = "4.6.3";
+  version = "4.7.0";
   pname = "kirimoto";
 
   src = fetchurl {
     url = "https://github.com/GridSpace/grid-apps/releases/download/${version}/KiriMoto-linux-x86_64.AppImage";
-    hash = "sha256-YCfDCR92xtwL3634iIMYf6IjkeqoWrF7/YNCwKSjnfs==";
+    hash = "sha256-bLeGDZzAzBVC4tTwcC8uDngqOEeJ/vyTJGre+EovOgs=";
   };
 
   appimageContents = appimageTools.extractType2 { inherit pname version src; };

pkgs/by-name/lb/lbreakout2/package.nix

@@ -48,9 +48,7 @@ stdenv.mkDerivation (finalAttrs: {
     description = "Breakout clone from the LGames series";
     license = with lib.licenses; [ gpl2Plus ];
     mainProgram = "lbreakout2";
-    maintainers = with lib.maintainers; [
-      ciil
-    ];
+    maintainers = [ ];
     platforms = lib.platforms.unix;
     hydraPlatforms = lib.platforms.linux; # build hangs on both Darwin platforms, needs investigation
   };

pkgs/by-name/li/lint-staged/package.nix

@@ -8,16 +8,16 @@
 
 buildNpmPackage rec {
   pname = "lint-staged";
-  version = "17.0.4";
+  version = "17.0.5";
 
   src = fetchFromGitHub {
     owner = "okonet";
     repo = "lint-staged";
     rev = "v${version}";
-    hash = "sha256-E0qShnB3zVz7oL+qPzPzLhEJ9PQDlMc4+L4vpD2enI8=";
+    hash = "sha256-W9OW4ylRhgeUq7AlJlSkfN0IKv8Us6IEhmfE08UXzH8=";
   };
 
-  npmDepsHash = "sha256-KYltk2z/1nTnaLroTErIu6eTyofvWp/wC1awEf0Ryg0=";
+  npmDepsHash = "sha256-ifz75kaLfDq42cdnN7eel/HtG6Fmr+1BFbD0b1vcjCA=";
 
   dontNpmBuild = true;
 

pkgs/by-name/ml/mlflow-server/package.nix

@@ -1,37 +1,10 @@
-{ python3Packages, writers }:
+{ python3Packages }:
 
-let
-  py = python3Packages;
-
-  gunicornScript = writers.writePython3 "gunicornMlflow" { } ''
-    import re
-    import sys
-    from gunicorn.app.wsgiapp import run
-    if __name__ == '__main__':
-        sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', ''', sys.argv[0])
-        sys.exit(run())
-  '';
-in
-py.toPythonApplication (
-  py.mlflow.overridePythonAttrs (old: {
-
-    propagatedBuildInputs = old.dependencies ++ [
-      py.boto3
-      py.mysqlclient
+python3Packages.toPythonApplication (
+  python3Packages.mlflow.overridePythonAttrs (old: {
+    propagatedBuildInputs = (old.propagatedBuildInputs or [ ]) ++ [
+      python3Packages.boto3
+      python3Packages.mysqlclient
     ];
-
-    postPatch = (old.postPatch or "") + ''
-      cat mlflow/utils/process.py
-
-      substituteInPlace mlflow/utils/process.py --replace-fail \
-        "process = subprocess.Popen(" \
-        "cmd[0]='${gunicornScript}'; process = subprocess.Popen("
-    '';
-
-    postInstall = ''
-      gpath=$out/bin/gunicornMlflow
-      cp ${gunicornScript} $gpath
-      chmod 555 $gpath
-    '';
   })
 )

pkgs/by-name/mt/mtail/package.nix

@@ -8,13 +8,13 @@
 
 buildGoModule (finalAttrs: {
   pname = "mtail";
-  version = "3.2.50";
+  version = "3.2.51";
 
   src = fetchFromGitHub {
     owner = "jaqx0r";
     repo = "mtail";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-RdDZgmnA9wDN7uEUGle85jLFRmgBNBaRGTu+MthCsfw=";
+    hash = "sha256-0ZgCcKudrKBgjx2653sp5HZCC8G6pgBymtMMmcbD4tg=";
   };
 
   proxyVendor = true;

pkgs/by-name/nc/ncspot/package.nix

@@ -32,16 +32,16 @@
 }:
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "ncspot";
-  version = "1.3.3";
+  version = "1.3.4";
 
   src = fetchFromGitHub {
     owner = "hrkfdn";
     repo = "ncspot";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-U2uadZzC38pZf4For6Nyo91IXr9XqNSU6B+gpuTZJQo=";
+    hash = "sha256-QQeiVmMRF5ql2GVR5nopKtBrTAP8K1Rjs/B89+Azg5s=";
   };
 
-  cargoHash = "sha256-ny1vGZSUHxjUZb/nxu2SXP1gimPlPBUejAjiqPpe+CM=";
+  cargoHash = "sha256-u6T5zaeN+rmTH5eM7Inpw/EZh48RauhhVhnAmUMYFIc=";
 
   nativeBuildInputs = [ pkg-config ] ++ lib.optional withClipboard python3;
 

pkgs/by-name/ne/newrelic-sysmond/package.nix

@@ -26,6 +26,6 @@ stdenv.mkDerivation rec {
     sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
     license = lib.licenses.unfree;
     platforms = lib.platforms.linux;
-    maintainers = with lib.maintainers; [ lnl7 ];
+    maintainers = [ ];
   };
 }

pkgs/by-name/nu/nushell/package.nix

@@ -24,16 +24,16 @@ rustPlatform.buildRustPackage (finalAttrs: {
   # NOTE: when updating this to a new non-patch version, please also try to
   # update the plugins. Plugins only work if they are compiled for the same
   # major/minor version.
-  version = "0.112.2";
+  version = "0.113.0";
 
   src = fetchFromGitHub {
     owner = "nushell";
     repo = "nushell";
     tag = finalAttrs.version;
-    hash = "sha256-wc7mfbwkJO5gq9mwsiTVx74+btqU6Ox8tPhnXkfmXRU=";
+    hash = "sha256-qIiPEW2XO2gf9pMDHhGEvCfSU5iiOKMwi+9wAQEfjjw=";
   };
 
-  cargoHash = "sha256-KBDgICbdYcqgMLtUXWQsMPe1fO7zT4NcavAyS2i0cDc=";
+  cargoHash = "sha256-E7xO6oTw4uWh41g92AqkQ5iIr/uD6RCc2kBAYUP3Flg=";
 
   nativeBuildInputs = [
     pkg-config

pkgs/by-name/of/officecli/package.nix

@@ -8,7 +8,7 @@
 
 buildDotnetModule (finalAttrs: {
   pname = "officecli";
-  version = "1.0.93";
+  version = "1.0.97";
 
   strictDeps = true;
   __structuredAttrs = true;
@@ -17,7 +17,7 @@ buildDotnetModule (finalAttrs: {
     owner = "iOfficeAI";
     repo = "OfficeCLI";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-FCBq3Ua3mSvkIqmtwSi+j5Z76Pe/uGDUVVbDOMC/DaA=";
+    hash = "sha256-JQQbMQhuT2S808Z64RQSkGcarmPaF1T8oypnUUTmV7Y=";
   };
 
   projectFile = "src/officecli/officecli.csproj";

pkgs/by-name/pl/plexRaw/package.nix

@@ -95,7 +95,6 @@ stdenv.mkDerivation rec {
     maintainers = with lib.maintainers; [
       badmutex
       forkk
-      lnl7
       pjones
       thoughtpolice
       MayNiklas

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

@@ -7,16 +7,16 @@
 
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "polarity";
-  version = "latest-unstable-2026-04-28";
+  version = "0-unstable-2026-05-20";
 
   src = fetchFromGitHub {
     owner = "polarity-lang";
     repo = "polarity";
-    rev = "dbcece0e8b572193a5605296392ef1f0d85bba74";
-    hash = "sha256-8wVsiLSTbjIZOObdiawvQy5rw+sf93cp6+wbY+XaByI=";
+    rev = "522f7a7b70608cda6ce3207c81d26bef17b0cdf9";
+    hash = "sha256-o2+tOrWr8Rjy+r05PX9C6qtx70HDyhWlvza2Ssw15mk=";
   };
 
-  cargoHash = "sha256-9PMQQHydqgeKeB0eM49dJpL+8cstK8yUkc728ATXroQ=";
+  cargoHash = "sha256-7vBLZwUpZ/LQ4MO1JZhpErFvh5EQyS+7IN1U5wyAP/E=";
 
   passthru.updateScript = nix-update-script { extraArgs = [ "--version=branch" ]; };
 

pkgs/by-name/pr/proxelar/package.nix

@@ -8,16 +8,16 @@
 
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "proxelar";
-  version = "0.4.4";
+  version = "0.4.5";
 
   src = fetchFromGitHub {
     owner = "emanuele-em";
     repo = "proxelar";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-dUz20mk9ghUyCRuxkEpjjibhDMk7kAezZxGPadQhhM0=";
+    hash = "sha256-/uRvk0bUkDtxpNEKLOgh8J1V2+xaTxAHZdrXTnLApFM=";
   };
 
-  cargoHash = "sha256-Jc6NExi2BUs1Hoia4MyDouj/LUO9tCRN0Pu2/32uG7c=";
+  cargoHash = "sha256-j94fVzAJa/4B4et98LowZmbKwAy9eZ/qhfKjZ9p/9NI=";
 
   __structuredAttrs = true;
 

pkgs/by-name/ps/pscale/package.nix

@@ -10,16 +10,16 @@
 
 buildGoModule (finalAttrs: {
   pname = "pscale";
-  version = "0.282.0";
+  version = "0.284.0";
 
   src = fetchFromGitHub {
     owner = "planetscale";
     repo = "cli";
     rev = "v${finalAttrs.version}";
-    sha256 = "sha256-qCbdsSu4XTMbinW87AUO6y125nHhsD+dQ0JioMXIqVM=";
+    sha256 = "sha256-Zc9QPqina0GWPeS+mHe5lc9Flmo+xAyWPdLq+Znptmw=";
   };
 
-  vendorHash = "sha256-+XZRC6Q2Qc1Oc4fn6SsLNqDvZTvgK6HDFESrmvxKzGo=";
+  vendorHash = "sha256-bI939rwDZMP0UJqKJ7UdQnd1FK1RkeyOToFTfDCmSVc=";
 
   ldflags = [
     "-s"

pkgs/by-name/py/py-spy/package.nix

@@ -43,7 +43,7 @@ rustPlatform.buildRustPackage (finalAttrs: {
     homepage = "https://github.com/benfred/py-spy";
     changelog = "https://github.com/benfred/py-spy/releases/tag/v${finalAttrs.version}";
     license = lib.licenses.mit;
-    maintainers = with lib.maintainers; [ lnl7 ];
+    maintainers = [ ];
     platforms = lib.platforms.linux ++ lib.platforms.darwin;
     # https://github.com/benfred/py-spy/pull/330
     broken = stdenv.hostPlatform.isAarch64 && stdenv.hostPlatform.isLinux;

pkgs/by-name/re/reattach-to-user-namespace/package.nix

@@ -31,7 +31,7 @@ stdenv.mkDerivation rec {
   meta = {
     description = "Wrapper that provides access to the Mac OS X pasteboard service";
     license = lib.licenses.bsd2;
-    maintainers = with lib.maintainers; [ lnl7 ];
+    maintainers = [ ];
     platforms = lib.platforms.darwin;
   };
 }

pkgs/by-name/ri/rio/package.nix

@@ -51,16 +51,16 @@ let
 in
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "rio";
-  version = "0.4.4";
+  version = "0.4.5";
 
   src = fetchFromGitHub {
     owner = "raphamorim";
     repo = "rio";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-fjPuB2/sEXsE8gnnvDLU5a6Qgac3crbs7v/kOlUhtZE=";
+    hash = "sha256-ON7CJ1NDwLfjvLZ0ugN45LUjBGiwRNASiQwuDa6F1vM=";
   };
 
-  cargoHash = "sha256-4J9JppiaL377m2THRZhxCkDuHJggJBCHhnWaV1E0fIA=";
+  cargoHash = "sha256-vSQ5heZZ8tYKeMABhZ8AziEAniavnAasH04BVlqYF4g=";
 
   nativeBuildInputs = [
     rustPlatform.bindgenHook

pkgs/by-name/rs/rstudio/package.nix

@@ -370,10 +370,7 @@ stdenv.mkDerivation (finalAttrs: {
     description = "Set of integrated tools for the R language";
     homepage = "https://www.rstudio.com/";
     license = lib.licenses.agpl3Only;
-    maintainers = with lib.maintainers; [
-      ciil
-      tomasajt
-    ];
+    maintainers = [ lib.maintainers.tomasajt ];
     mainProgram = "rstudio" + lib.optionalString server "-server";
     # rstudio-server on darwin is only partially supported by upstream
     platforms = lib.platforms.linux ++ lib.optionals (!server) lib.platforms.darwin;

pkgs/by-name/se/seconlay/package.nix

@@ -12,14 +12,14 @@
 
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "seconlay";
-  version = "0-unstable-2026-04-30";
+  version = "0-unstable-2026-05-21";
 
   src = fetchFromGitLab {
     group = "alasca.cloud";
     owner = "scl";
     repo = "scl-management";
-    rev = "a2020efbbc950d037e17a3ae8d628e3205a80447";
-    hash = "sha256-/m2HUdyT/euFVvWPZAHjPGsBH9XeUMuNGlfJFfH/A8Y=";
+    rev = "3ebeeda26e919750790c24899320ac1f6ba82904";
+    hash = "sha256-+erlSKH8FBG2Ncpn6D61itTiB2IhbMefgO7EZ7NgZa8=";
   };
 
   cargoHash = "sha256-pb9xqdgWrf8Lc10jSkkDb/1n0e15fMQ3AcKNPw6/vi8=";

pkgs/by-name/sh/shairport-sync/package.nix

@@ -153,7 +153,6 @@ stdenv.mkDerivation (finalAttrs: {
     license = lib.licenses.mit;
     mainProgram = "shairport-sync";
     maintainers = with lib.maintainers; [
-      lnl7
       jordanisaacs
     ];
     platforms = lib.platforms.unix;

pkgs/by-name/sk/skhd/package.nix

@@ -38,7 +38,6 @@ stdenv.mkDerivation (finalAttrs: {
     mainProgram = "skhd";
     maintainers = with lib.maintainers; [
       cmacrae
-      lnl7
       khaneliman
     ];
     platforms = lib.platforms.darwin;

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

@@ -2,40 +2,55 @@
   lib,
   stdenv,
   fetchFromGitHub,
+  fetchpatch2,
   nixosTests,
 }:
 
 stdenv.mkDerivation (finalAttrs: {
-  version = "0.9.5";
   pname = "tayga";
+  version = "0.9.6";
 
   src = fetchFromGitHub {
     owner = "apalrd";
     repo = "tayga";
     tag = finalAttrs.version;
-    hash = "sha256-xOm4fetFq2UGuhOojrT8WOcX78c6MLTMVbDv+O62x2E=";
+    hash = "sha256-OsF2RqZzDvf8FMLHN6YAKvWfFgAIQfVkbBTC8hjf2dU=";
   };
 
-  makeFlags = [ "CC=${lib.getExe stdenv.cc}" ];
+  patches = [
+    # nat64.c: call inet_ntop with properly sized buffers
+    # https://github.com/apalrd/tayga/pull/168
+    (fetchpatch2 {
+      url = "https://github.com/apalrd/tayga/commit/b41bd030846451d72b277854678b58370b1d5c8f.patch?full_index=1";
+      hash = "sha256-vFQTlZs9ghxdx4k/iODDOUBAglyll1OxUdTjzDtcwB0=";
+    })
+  ];
+
+  makeFlags = [
+    "prefix=${placeholder "out"}"
+  ];
+
+  installFlags = [
+    "WITH_SYSTEMD=1"
+    "sbindir=${placeholder "out"}/bin"
+    "sysconfdir=${placeholder "out"}/etc"
+    "servicedir=${placeholder "out"}/lib/systemd/system"
+  ];
+
+  postInstall = ''
+    substituteInPlace "$out/lib/systemd/system/tayga@.service" \
+      --replace-fail "ExecSearchPath=/usr/local/sbin:/usr/sbin" "" \
+      --replace-fail "ExecStart=tayga" "ExecStart=$out/bin/tayga"
+  '';
 
   env = lib.optionalAttrs stdenv.hostPlatform.is32bit {
     NIX_CFLAGS_COMPILE = "-D_TIME_BITS=64 -D_FILE_OFFSET_BITS=64";
   };
 
-  preBuild = ''
-    echo "#define TAYGA_VERSION \"${finalAttrs.version}\"" > version.h
-  '';
-
-  installPhase = ''
-    install -Dm755 tayga $out/bin/tayga
-    install -D tayga.conf.5 $out/share/man/man5/tayga.conf.5
-    install -D tayga.8 $out/share/man/man8/tayga.8
-    cp -R docs $out/share/
-    cp tayga.conf.example $out/share/docs/
-  '';
-
   passthru.tests.tayga = nixosTests.tayga;
 
+  doCheck = true;
+
   meta = {
     description = "Userland stateless NAT64 daemon";
     longDescription = ''

pkgs/by-name/tm/tmux-sessionizer/package.nix

@@ -9,16 +9,16 @@
 }:
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "tmux-sessionizer";
-  version = "0.5.0";
+  version = "0.6.0";
 
   src = fetchFromGitHub {
     owner = "jrmoulton";
     repo = "tmux-sessionizer";
     rev = "v${finalAttrs.version}";
-    hash = "sha256-6eMKwp5639DIyhM6OD+db7jr4uF34JSt0Xg+lpyIPSI=";
+    hash = "sha256-tJ8aKajSWc62BZ8hb3u+OQtlu04z8Ala5nAK5H4Byp4=";
   };
 
-  cargoHash = "sha256-gIsqHbCmfYs1c3LPNbE4zLVjzU3GJ4MeHMt0DC5sS3c=";
+  cargoHash = "sha256-AJqlzLr6MDFfPssSFMxslxFFuPVxoQGcuG7sZeu+8pg=";
 
   nativeInstallCheckInputs = [
     versionCheckHook

pkgs/by-name/un/undmg/package.nix

@@ -41,8 +41,7 @@ stdenv.mkDerivation {
     homepage = "https://github.com/matthewbauer/undmg";
     license = lib.licenses.gpl3;
     mainProgram = "undmg";
-    maintainers = with lib.maintainers; [
-      lnl7
+    maintainers = [
     ];
     platforms = lib.platforms.all;
   };

pkgs/by-name/v2/v2ray-domain-list-community/package.nix

@@ -9,12 +9,12 @@
 let
   generator = pkgsBuildBuild.buildGoModule rec {
     pname = "v2ray-domain-list-community";
-    version = "20260514020130";
+    version = "20260522120028";
     src = fetchFromGitHub {
       owner = "v2fly";
       repo = "domain-list-community";
       rev = version;
-      hash = "sha256-OlR+lo2Xh3p/30RU7+ok3JWhYsB9FkGzXGIhccECeSk=";
+      hash = "sha256-+w+waGLxlkrp42Cy0WJoawcUpBuXbssD5/lokJhUJyw=";
     };
     vendorHash = "sha256-9tXv+rDBowxDN9gH4zHCr4TRbic4kijco3Y6bojJKRk=";
     meta = {

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

@@ -73,7 +73,6 @@ buildGoModule (finalAttrs: {
     mainProgram = "vault";
     maintainers = with lib.maintainers; [
       rushmorem
-      lnl7
       Chili-Man
       techknowlogick
     ];

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

@@ -74,10 +74,7 @@ stdenv.mkDerivation (finalAttrs: {
       asl20 # and
       unfree # TrueCrypt License version 3.0
     ];
-    maintainers = with lib.maintainers; [
-      dsferruzza
-      ryand56
-    ];
+    maintainers = [ lib.maintainers.ryand56 ];
     platforms = lib.platforms.linux;
   };
 })

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

@@ -9,16 +9,16 @@
 
 rustPlatform.buildRustPackage (finalAttrs: {
   pname = "versatiles";
-  version = "4.1.0";
+  version = "4.1.2";
 
   src = fetchFromGitHub {
     owner = "versatiles-org";
     repo = "versatiles-rs";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-U83jh74h1GKb6JKO62mDfDa8monknUqQ33oXlC6E6Q0=";
+    hash = "sha256-kWUosTubAD/qk6xEGKUiLrw4mrAaOwwuQ3r+UeLsEJU=";
   };
 
-  cargoHash = "sha256-yD4oBrk8GaI9E7Lq1Z45yqFTpRnLgNXq6CyzzV7Z/0Q=";
+  cargoHash = "sha256-rTVk8c00b94x6wEIDLvwadCQ/DXSFOPWcKYFSI9YI64=";
 
   nativeBuildInputs = [
     pkg-config

pkgs/by-name/vg/vg/0001-Use-order-only-prerequisite-for-making-sure-dirs-exi.patch

@@ -0,0 +1,68 @@
+From 27023ebb5e5b0fef98682c179889c3a9a799d2ae Mon Sep 17 00:00:00 2001
+From: eljamm <fedi.jamoussi@protonmail.ch>
+Date: Tue, 12 May 2026 18:02:52 +0200
+Subject: [PATCH] Use order-only prerequisite for making sure dirs exist
+
+instead of using `.pre-build` with `-include`, which could cause a
+failure if targets start executing before it finishes.
+---
+ Makefile | 23 ++++++++++++-----------
+ 1 file changed, 12 insertions(+), 11 deletions(-)
+
+diff --git a/Makefile b/Makefile
+index 4436f14..8e66c66 100644
+--- a/Makefile
++++ b/Makefile
+@@ -47,20 +47,21 @@ test: all $(BIN_DIR)/test_libbdsg
+ docs:
+ 	cd $(DOC_DIR) && $(MAKE) html
+ 
+-.pre-build:
+-	@if [ ! -d $(LIB_DIR) ]; then mkdir -p $(LIB_DIR); fi
+-	@if [ ! -d $(OBJ_DIR) ]; then mkdir -p $(OBJ_DIR); fi
+-	@if [ ! -d $(BIN_DIR) ]; then mkdir -p $(BIN_DIR); fi
+-
+-# run .pre-build before we make anything at all.
+--include .pre-build
+-
+ # Make sure to pull in dependency files
+ include $(wildcard $(OBJ_DIR)/*.d)
+ 
+ # Use a fake rule to build .d files, so we don't complain if they don't exist.
+ $(OBJ_DIR)/%.d: ;
+ 
++$(OBJ_DIR):
++	mkdir -p $(OBJ_DIR)
++
++$(LIB_DIR):
++	mkdir -p $(LIB_DIR)
++
++$(BIN_DIR):
++	mkdir -p $(BIN_DIR)
++
+ # Don't delete them.
+ .PRECIOUS: $(OBJ_DIR)/%.d
+ 
+@@ -69,16 +70,16 @@ $(OBJ_DIR)/%.d: ;
+ # Make sure to touch the .o file after the compiler finishes so it is always newer than the .d file
+ # Use static pattern rules so the dependency files will not be ignored if the output exists
+ # See <https://stackoverflow.com/a/34983297>
+-$(OBJS): $(OBJ_DIR)/%.o : $(SRC_DIR)/%.cpp $(OBJ_DIR)/%.d
++$(OBJS): $(OBJ_DIR)/%.o : $(SRC_DIR)/%.cpp $(OBJ_DIR)/%.d | $(OBJ_DIR)
+ 	$(CXX) $(LDFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@
+ 	@touch $@
+ 
+ 
+-$(LIB_DIR)/libbdsg.a: $(OBJS)
++$(LIB_DIR)/libbdsg.a: $(OBJS) | $(LIB_DIR)
+ 	rm -f $@
+ 	ar rs $@ $(OBJS)
+ 
+-$(BIN_DIR)/test_libbdsg: $(LIB_DIR)/libbdsg.a $(SRC_DIR)/test_libbdsg.cpp
++$(BIN_DIR)/test_libbdsg: $(LIB_DIR)/libbdsg.a $(SRC_DIR)/test_libbdsg.cpp | $(BIN_DIR)
+ 	mkdir -p $(BIN_DIR)
+ 	$(CXX) $(LDFLAGS) $(CPPFLAGS) $(CXXFLAGS) -L $(LIB_DIR) $(SRC_DIR)/test_libbdsg.cpp -o $(BIN_DIR)/test_libbdsg $(LIB_FLAGS)
+ 	chmod +x $(BIN_DIR)/test_libbdsg
+-- 
+2.51.2
+

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

@@ -0,0 +1,209 @@
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  nix-update-script,
+  runCommand,
+
+  # build-time
+  autoconf,
+  automake,
+  bison,
+  cmake,
+  flex,
+  gettext,
+  hostname,
+  libtool,
+  perl,
+  pkg-config,
+  python3,
+  util-linux,
+  which,
+  whoami,
+
+  # run-time
+  boost,
+  bzip2,
+  cairo,
+  curl,
+  expat,
+  jansson,
+  libxdmcp,
+  ncurses,
+  openssl,
+  protobuf,
+  xz,
+  zlib,
+  zstd,
+
+  # test
+  graphviz,
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "vg";
+  version = "1.74.1";
+
+  src = fetchFromGitHub {
+    owner = "vgteam";
+    repo = "vg";
+    tag = "v${finalAttrs.version}";
+    hash = "sha256-CY4nUtVetdmoex/sRnoncEbvuQloV0WMZXtQpPksO1s=";
+    fetchSubmodules = true;
+  };
+
+  postPatch = ''
+    substituteInPlace \
+      Makefile \
+        --replace-fail "/bin/bash" "${stdenv.shell}" \
+        --replace-fail "\$(shell arch)" "${stdenv.hostPlatform.uname.processor}" \
+        --replace-fail "vg_git_version.hpp]" "vg_git_version.hpp ]"
+
+    substituteInPlace \
+      deps/libbdsg/bdsg/deps/pybind11/tests/CMakeLists.txt \
+      deps/vcflib/CMakeLists.txt \
+        --replace-fail \
+          "find_package(pybind11 " \
+          "set(PYBIND11_FINDPYTHON ON)
+          find_package(pybind11 "
+
+    patchShebangs ./
+    patchShebangs deps/
+
+    patch -p1 -d deps/libbdsg -i ${./0001-Use-order-only-prerequisite-for-making-sure-dirs-exi.patch}
+
+    pushd deps/htslib
+      PACKAGE_VERSION=$(./version.sh)
+      echo '#define HTSCODECS_VERSION_TEXT "$PACKAGE_VERSION"' > ./htscodecs/htscodecs/version.h
+    popd
+  '';
+
+  dontUseCmake = true; # cmake needed for deps, but not main package
+  dontConfigure = true;
+  enableParallelBuilding = true;
+
+  __structuredAttrs = true;
+  strictDeps = true;
+
+  nativeBuildInputs = [
+    autoconf
+    automake
+    bison
+    cmake
+    finalAttrs.passthru.customPython
+    flex
+    gettext
+    hostname
+    libtool
+    perl
+    pkg-config
+    which
+    whoami
+  ]
+  ++ lib.optionals stdenv.hostPlatform.isLinux [
+    util-linux # rev, and possibly others
+  ];
+
+  buildInputs = [
+    boost
+    bzip2
+    cairo
+    curl
+    expat
+    jansson
+    ncurses
+    openssl
+    protobuf
+    xz
+    zlib
+    zstd
+  ]
+  ++ lib.optionals stdenv.hostPlatform.isLinux [
+    libxdmcp
+  ];
+
+  passthru.customPython = python3.withPackages (
+    ps: with ps; [
+      pybind11
+    ]
+  );
+
+  env = {
+    # needed, else build fails
+    VG_GIT_VERSION = finalAttrs.src.tag;
+    # deps/elfutils
+    NIX_CFLAGS_COMPILE = toString [
+      "-Wno-error=stringop-overflow"
+      "-Wno-error=unterminated-string-initialization"
+    ];
+  };
+
+  makeFlags = [
+    # don't build statically
+    "START_STATIC="
+    "END_STATIC="
+  ];
+
+  preBuild = ''
+    # Install directories may not exist when parallel builds complete their
+    # output steps, so we create them here to prevent build failures.
+    mkdir -p lib include obj/{pic/algorithms,algorithms,config,io,subcommand,unittest/support}
+  '';
+
+  # no install target
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p $out/{bin,lib}
+
+    cp bin/* $out/bin/
+    cp -R lib/lib{handlegraph,vgio,hts,deflate}.so* $out/lib/
+
+    runHook postInstall
+  '';
+
+  fixupPhase = ''
+    runHook preFixup
+
+    for bin in $out/bin/* ; do
+      patchelf --allowed-rpath-prefixes /nix/store --shrink-rpath $bin
+      patchelf --set-rpath "$out/lib:$(patchelf --print-rpath $bin)" $bin
+    done
+
+    # remove debugging symbols that make the binary bloated in size
+    strip -d $out/bin/vg
+
+    runHook postFixup
+  '';
+
+  passthru = {
+    updateScript = nix-update-script { };
+    tests = runCommand "test-vg-basic" { } ''
+      HOME=$(mktemp -d) # fontconfig cache
+
+      cp -R ${finalAttrs.src}/test .
+
+      # build graph
+      ${finalAttrs.finalPackage}/bin/vg construct \
+        -r test/tiny/tiny.fa \
+        -v test/tiny/tiny.vcf.gz \
+        >x.vg
+
+      # convert graph to image
+      ${finalAttrs.finalPackage}/bin/vg view -d x.vg >x.dot
+      ${graphviz}/bin/dot -Tpng x.dot -o $out
+    '';
+  };
+
+  meta = {
+    description = "Tools for working with genome variation graphs";
+    homepage = "https://github.com/vgteam/vg";
+    changelog = "https://github.com/vgteam/vg/releases/tag/${finalAttrs.src.tag}";
+    mainProgram = "vg";
+    license = lib.licenses.mit;
+    # TODO: build on darwin
+    platforms = lib.platforms.linux;
+    maintainers = with lib.maintainers; [ eljamm ];
+    teams = with lib.teams; [ ngi ];
+  };
+})

pkgs/by-name/vo/voicevox-engine/package.nix

@@ -97,6 +97,11 @@ python3Packages.buildPythonApplication (finalAttrs: {
     httpx
   ];
 
+  disabledTests = [
+    # test expects an exact response, but OpenAPI is returning something a tiny bit different
+    "test_OpenAPIの形が変わっていないことを確認"
+  ];
+
   passthru = {
     resources = fetchFromGitHub {
       name = "voicevox-resource-${finalAttrs.version}"; # this contains ${version} to invalidate the hash upon updating the package

pkgs/by-name/vu/vuetorrent/package.nix

@@ -7,16 +7,16 @@
 
 buildNpmPackage rec {
   pname = "vuetorrent";
-  version = "2.33.0";
+  version = "2.34.0";
 
   src = fetchFromGitHub {
     owner = "VueTorrent";
     repo = "VueTorrent";
     tag = "v${version}";
-    hash = "sha256-7jr7spoJBt4YqOgTmIC2bNjygrSlUgF1AuDPzCe+YuU=";
+    hash = "sha256-Zz7ZFtxT26/4HCkM/HHVyLXxbmDvhTRFaJpiXA08JPY=";
   };
 
-  npmDepsHash = "sha256-l8b/WazCUKWwxlv+b8OnLLYslhGezdoWIGsRExIsZyU=";
+  npmDepsHash = "sha256-PxTe/anj3VgdEaSdv37XuBYD8N3gs9wc+idCboX8Bic=";
 
   installPhase = ''
     runHook preInstall

pkgs/by-name/wh/whosthere/package.nix

@@ -10,16 +10,16 @@
 
 buildGoModule (finalAttrs: {
   pname = "whosthere";
-  version = "0.7.1";
+  version = "0.8.2";
 
   src = fetchFromGitHub {
     owner = "ramonvermeulen";
     repo = "whosthere";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-+cG9iJhIkIQ3yakx/DYGKqd+pX/AaqnCgDdC/3Spvws=";
+    hash = "sha256-FgjsmUg4oEF+WVBhZXIE0MzpBr+s9sXuXIFxqHKD8U8=";
   };
 
-  vendorHash = "sha256-sNx1Ej8vh/Lw4wpitWQdLZ2LM8K6JgM/snSZRw9RN94=";
+  vendorHash = "sha256-mQ17BCJGc4LQOUdyWGlWoSJPbqwg55vRGfEbrcDllG4=";
 
   nativeBuildInputs = [
     installShellFiles

pkgs/by-name/xh/xhyve/package.nix

@@ -39,7 +39,7 @@ stdenv.mkDerivation rec {
   meta = {
     description = "Lightweight Virtualization on macOS Based on bhyve";
     homepage = "https://github.com/mist64/xhyve";
-    maintainers = [ lib.maintainers.lnl7 ];
+    maintainers = [ ];
     license = lib.licenses.bsd2;
     platforms = lib.platforms.darwin;
     # never built on aarch64-darwin since first introduction in nixpkgs

pkgs/by-name/yc/ycmd/package.nix

@@ -135,7 +135,6 @@ stdenv.mkDerivation {
     homepage = "https://github.com/ycm-core/ycmd";
     license = lib.licenses.gpl3;
     maintainers = with lib.maintainers; [
-      lnl7
       mel
       S0AndS0
     ];

pkgs/development/compilers/purescript/purescript/default.nix

@@ -85,7 +85,6 @@ stdenv.mkDerivation rec {
     sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
     maintainers = with lib.maintainers; [
       justinwoo
-      mbbx6spp
       cdepillabout
     ];
     platforms = [

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

@@ -4,21 +4,24 @@
   async-timeout,
   buildPythonPackage,
   fetchFromGitHub,
+  setuptools,
 }:
 
-buildPythonPackage rec {
+buildPythonPackage (finalAttrs: {
   pname = "adax";
   version = "0.4.0";
-  format = "setuptools";
+  pyproject = true;
 
   src = fetchFromGitHub {
     owner = "Danielhiversen";
     repo = "pyadax";
-    tag = version;
+    tag = finalAttrs.version;
     hash = "sha256-wmcZtiML02i1XfqpFzni2WDrxutTvP5laVvTAGtNg0Y=";
   };
 
-  propagatedBuildInputs = [
+  build-system = [ setuptools ];
+
+  dependencies = [
     aiohttp
     async-timeout
   ];
@@ -31,8 +34,8 @@ buildPythonPackage rec {
   meta = {
     description = "Python module to communicate with Adax";
     homepage = "https://github.com/Danielhiversen/pyAdax";
-    changelog = "https://github.com/Danielhiversen/pyAdax/releases/tag/${version}";
+    changelog = "https://github.com/Danielhiversen/pyAdax/releases/tag/${finalAttrs.version}";
     license = with lib.licenses; [ mit ];
     maintainers = with lib.maintainers; [ fab ];
   };
-}
+})

pkgs/development/python-modules/agent-client-protocol/default.nix

@@ -19,7 +19,7 @@
 
 buildPythonPackage (finalAttrs: {
   pname = "agent-client-protocol";
-  version = "0.10.0";
+  version = "0.10.1";
   pyproject = true;
   __structuredAttrs = true;
 
@@ -27,7 +27,7 @@ buildPythonPackage (finalAttrs: {
     owner = "agentclientprotocol";
     repo = "python-sdk";
     tag = finalAttrs.version;
-    hash = "sha256-JndUYT3oimoDs6WDA4ixhNCZnswUAZA4nab5DT1xpbQ=";
+    hash = "sha256-iVmNzAx/YlvFXXVPjS1SmjDqGAr9aRDdSW93Nw2ayAY=";
   };
 
   build-system = [

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

@@ -3,35 +3,33 @@
   aiohttp,
   beautifulsoup4,
   buildPythonPackage,
-  colorlog,
   cryptography,
   fetchFromGitHub,
   orjson,
-  poetry-core,
   pycryptodome,
   pytest-cov-stub,
   pytestCheckHook,
   segno,
+  setuptools,
 }:
 
 buildPythonPackage (finalAttrs: {
   pname = "aiovodafone";
-  version = "3.2.0";
+  version = "3.3.0";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "chemelli74";
     repo = "aiovodafone";
     tag = "v${finalAttrs.version}";
-    hash = "sha256-CZz/rRRgZwP7gowYORkt8j99mU0CMgOX+M1JExvFNDI=";
+    hash = "sha256-KKd8dOabm/6YksBG6+51zYUsgiA4wFW6dGe2tiX3fQA=";
   };
 
-  build-system = [ poetry-core ];
+  build-system = [ setuptools ];
 
   dependencies = [
     aiohttp
     beautifulsoup4
-    colorlog
     cryptography
     orjson
     pycryptodome

pkgs/development/python-modules/disposable-email-domains/default.nix

@@ -8,7 +8,7 @@
 
 buildPythonPackage (finalAttrs: {
   pname = "disposable-email-domains";
-  version = "0.0.181";
+  version = "0.0.188";
   pyproject = true;
   __structuredAttrs = true;
 
@@ -16,7 +16,7 @@ buildPythonPackage (finalAttrs: {
   src = fetchPypi {
     pname = "disposable_email_domains";
     inherit (finalAttrs) version;
-    hash = "sha256-BtW0MXgFTphae3O5XPDnix8RTKDx/tvzpTN4znZjFSI=";
+    hash = "sha256-CRSFrSo7wSUIBY3l/n5Uf3wM0AwbrxRiELepz0NWOXQ=";
   };
 
   build-system = [

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

@@ -40,6 +40,6 @@ buildPythonPackage rec {
     description = "Low-level components of distutils2/packaging";
     homepage = "https://distlib.readthedocs.io";
     license = lib.licenses.psfl;
-    maintainers = with lib.maintainers; [ lnl7 ];
+    maintainers = [ ];
   };
 }

pkgs/development/python-modules/geoarrow-rust/default.nix

@@ -5,20 +5,30 @@
   rustPlatform,
   pytestCheckHook,
   arro3-core,
-  pyarrow,
-  pyproj,
+  obstore,
+
+  # tests
+  arro3-compute,
+  arro3-io,
+  geoarrow-types,
+  geodatasets,
+  geopandas,
   numpy,
   pandas,
-  geoarrow-types,
+  pyarrow,
+  pyogrio,
+  pyproj,
+  pytest-asyncio,
+  shapely,
 }:
 let
-  version = "0.6.1";
+  version = "0.6.2";
 
   src = fetchFromGitHub {
     owner = "geoarrow";
     repo = "geoarrow-rs";
     tag = "py-v${version}";
-    hash = "sha256-3/HOQsgQVpEd9iAVvIHvpb0slg55/V6X6KLLvhDUVz4=";
+    hash = "sha256-qQGGG8aGwFR7ApLaQAE0iQSElpSBeRTtbq4+1xbTC/o=";
   };
 
   cargoDeps = rustPlatform.fetchCargoVendor {
@@ -100,6 +110,7 @@ let
     pythonImportsCheck = [ "geoarrow.rust.io" ];
     dependencies = [
       arro3-core
+      obstore
       pyproj
     ];
   };
@@ -113,16 +124,40 @@ let
     dontInstall = true;
 
     nativeCheckInputs = [
-      pytestCheckHook
-      geoarrow-types
-      pandas
-      pyarrow
-      numpy
+      arro3-compute
+      arro3-io
       geoarrow-rust-core
       geoarrow-rust-io
+      geoarrow-types
+      geodatasets
+      geopandas
+      numpy
+      obstore
+      pandas
+      pyarrow
+      pyogrio
+      pytest-asyncio
+      pytestCheckHook
+      shapely
     ];
 
-    pytestFlags = [ "python" ];
+    # use the latest test folder (skips the tests_old folder)
+    pytestFlags = [ "python/tests" ];
+
+    disabledTests = [
+      # require internet access to download datasets
+      "test_parse_nybb"
+      "test_parse_nybb_chunked"
+      "test_getitem"
+      "test_geo_interface_polygon"
+      "test_parquet_file"
+    ];
+
+    # fix the directory name, as it is named as source for nix build
+    postPatch = ''
+      substituteInPlace python/tests/utils.py \
+        --replace-fail 'while current_dir.stem != "geoarrow-rs":' 'while current_dir.stem != "source":'
+    '';
   };
 in
 {

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

@@ -1,23 +1,27 @@
 {
   lib,
   nix-update-script,
-  fetchPypi,
+  fetchFromGitHub,
   buildPythonApplication,
   setuptools,
+  pytestCheckHook,
   click,
   fonttools,
   uharfbuzz,
   pyyaml,
   colorlog,
+  packaging,
 }:
 buildPythonApplication rec {
   pname = "hyperglot";
-  version = "0.7.3";
+  version = "0.8.1";
   pyproject = true;
 
-  src = fetchPypi {
-    inherit pname version;
-    hash = "sha256-Pd9Yxmv9a1T2xV03q2U1m1laHE3WifHwmnGBfTTCSxM=";
+  src = fetchFromGitHub {
+    owner = "rosettatype";
+    repo = "hyperglot";
+    tag = version;
+    hash = "sha256-fiiDYggMBwd7nTHeQLWnSc3BNDyU+JUgAIk8pHLntUY=";
   };
 
   dependencies = [
@@ -26,10 +30,12 @@ buildPythonApplication rec {
     uharfbuzz
     pyyaml
     colorlog
+    packaging
   ];
 
   build-system = [ setuptools ];
 
+  nativeCheckInputs = [ pytestCheckHook ];
   pythonImportsCheck = [ "hyperglot" ];
 
   passthru.updateScript = nix-update-script { };
@@ -38,7 +44,7 @@ buildPythonApplication rec {
     description = "Database and tools for detecting language support in fonts";
     homepage = "https://hyperglot.rosettatype.com";
     changelog = "https://github.com/rosettatype/hyperglot/blob/${version}/CHANGELOG.md";
-    license = lib.licenses.gpl3Only;
+    license = lib.licenses.asl20;
     maintainers = with lib.maintainers; [ imatpot ];
     mainProgram = "hyperglot";
   };

pkgs/development/python-modules/mlflow-skinny/default.nix

@@ -1,5 +1,7 @@
 {
+  lib,
   buildPythonPackage,
+  fetchFromGitHub,
   mlflow,
 
   # build-system
@@ -30,10 +32,17 @@
 
 buildPythonPackage (finalAttrs: {
   pname = "mlflow-skinny";
-  inherit (mlflow) version src;
+  inherit (mlflow) version;
   pyproject = true;
   __structuredAttrs = true;
 
+  src = fetchFromGitHub {
+    owner = "mlflow";
+    repo = "mlflow";
+    rev = "v${finalAttrs.version}";
+    hash = "sha256-OxhM+KCem0sb9cwtyzrUD/MGfoiiCfgU47qipYRDaFk=";
+  };
+
   sourceRoot = "${finalAttrs.src.name}/libs/skinny";
 
   build-system = [ setuptools ];
@@ -69,5 +78,6 @@ buildPythonPackage (finalAttrs: {
   meta = mlflow.meta // {
     description = "Lightweight version of MLflow that is designed to minimize package size";
     homepage = "https://github.com/mlflow/mlflow/tree/master/libs/skinny";
+    sourceProvenance = with lib.sourceTypes; [ fromSource ];
   };
 })

pkgs/development/python-modules/mlflow-tracing/default.nix

@@ -1,6 +1,7 @@
 {
   lib,
   buildPythonPackage,
+  fetchFromGitHub,
   mlflow,
 
   # build-system
@@ -15,9 +16,6 @@
   packaging,
   protobuf,
   pydantic,
-
-  # tests
-  pytestCheckHook,
 }:
 buildPythonPackage (finalAttrs: {
   pname = "mlflow-tracing";
@@ -25,13 +23,16 @@ buildPythonPackage (finalAttrs: {
   pyproject = true;
   __structuredAttrs = true;
 
-  inherit (mlflow) src;
+  src = fetchFromGitHub {
+    owner = "mlflow";
+    repo = "mlflow";
+    rev = "v${finalAttrs.version}";
+    hash = "sha256-OxhM+KCem0sb9cwtyzrUD/MGfoiiCfgU47qipYRDaFk=";
+  };
 
   sourceRoot = "${finalAttrs.src.name}/libs/tracing";
 
-  build-system = [
-    setuptools
-  ];
+  build-system = [ setuptools ];
 
   dependencies = [
     cachetools
@@ -53,6 +54,9 @@ buildPythonPackage (finalAttrs: {
     description = "Open-Source SDK for observability and monitoring GenAI applications";
     homepage = "https://github.com/mlflow/mlflow/tree/master/libs/tracing";
     inherit (mlflow.meta) license;
-    maintainers = with lib.maintainers; [ GaetanLepage ];
+    maintainers = with lib.maintainers; [
+      GaetanLepage
+      gquetel
+    ];
   };
 })

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

@@ -1,10 +1,7 @@
 {
   lib,
   buildPythonPackage,
-  fetchFromGitHub,
-
-  # build-system
-  setuptools,
+  fetchPypi,
 
   # dependencies
   aiohttp,
@@ -31,26 +28,32 @@
 buildPythonPackage (finalAttrs: {
   pname = "mlflow";
   version = "3.12.0";
-  pyproject = true;
+  format = "wheel";
   __structuredAttrs = true;
 
-  src = fetchFromGitHub {
-    owner = "mlflow";
-    repo = "mlflow";
-    tag = "v${finalAttrs.version}";
-    hash = "sha256-OxhM+KCem0sb9cwtyzrUD/MGfoiiCfgU47qipYRDaFk=";
+  # We build from the PyPI wheel rather than fetchFromGitHub, because the mlflow-server
+  # JS UI is absent from GitHub but provided in the wheel.
+  src = fetchPypi {
+    pname = "mlflow";
+    inherit (finalAttrs) version;
+    format = "wheel";
+    dist = "py3";
+    python = "py3";
+    hash = "sha256-4cKO1MSFV8xSx2bxfxylgmdT3fJB1D8w+ZxF9+prPOA=";
   };
 
-  # ppyproject.release.toml is the one shipped in the Pypi package, so we use it too.
-  postPatch = ''
-    mv pyproject.release.toml pyproject.toml
+  # Nix-wrapped python populates sys.path via NIX_PYTHONPATH/site hooks,
+  # but PYTHONPATH stays unset in os.environ. mlflow spawns the server
+  # in a subprocess with a curated env, so without this patch the child
+  # interpreter cannot import uvicorn / mlflow itself.
+  postInstall = ''
+    patch -p1 -d "$out/lib/python"*/site-packages < ${./subprocess-pythonpath.patch}
   '';
 
-  build-system = [ setuptools ];
-
   pythonRelaxDeps = [
     "cryptography"
   ];
+
   dependencies = [
     aiohttp
     alembic
@@ -85,10 +88,15 @@ buildPythonPackage (finalAttrs: {
     description = "Open source platform for the machine learning lifecycle";
     mainProgram = "mlflow";
     homepage = "https://github.com/mlflow/mlflow";
-    changelog = "https://github.com/mlflow/mlflow/blob/${finalAttrs.src.tag}/CHANGELOG.md";
+    changelog = "https://github.com/mlflow/mlflow/blob/v${finalAttrs.version}/CHANGELOG.md";
     license = lib.licenses.asl20;
+    # Build from wheel which contains pure Python and pre-built JS bundle.
+    sourceProvenance = with lib.sourceTypes; [
+      binaryBytecode
+    ];
     maintainers = with lib.maintainers; [
       GaetanLepage
+      gquetel
     ];
   };
 })

pkgs/development/python-modules/mlflow/subprocess-pythonpath.patch

@@ -0,0 +1,14 @@
+--- a/mlflow/server/__init__.py
++++ b/mlflow/server/__init__.py
+@@ -471,6 +471,11 @@
+             else tempfile.mkdtemp()
+         )
++    # In Nix-packaged environments sys.path is populated by wrappers but
++    # PYTHONPATH is never set in os.environ, so subprocesses (uvicorn,
++    # gunicorn) cannot find packages. Propagate it when not already set.
++    if "PYTHONPATH" not in os.environ:
++        env_map.setdefault("PYTHONPATH", os.pathsep.join(p for p in sys.path if p))
+
+     server_proc = _exec_cmd(
+         full_command,
+         extra_env=env_map,

pkgs/development/python-modules/mypy-protobuf/default.nix

@@ -50,6 +50,6 @@ buildPythonPackage (finalAttrs: {
     homepage = "https://github.com/nipunn1313/mypy-protobuf";
     license = lib.licenses.asl20;
     mainProgram = "protoc-gen-mypy";
-    maintainers = with lib.maintainers; [ lnl7 ];
+    maintainers = [ ];
   };
 })

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

@@ -146,6 +146,6 @@ buildPythonPackage rec {
     downloadPage = "https://github.com/python/mypy";
     license = lib.licenses.mit;
     mainProgram = "mypy";
-    maintainers = with lib.maintainers; [ lnl7 ];
+    maintainers = [ ];
   };
 }

pkgs/development/python-modules/mypy/extensions.nix

@@ -37,6 +37,6 @@ buildPythonPackage rec {
     description = "Experimental type system extensions for programs checked with the mypy typechecker";
     homepage = "https://www.mypy-lang.org";
     license = lib.licenses.mit;
-    maintainers = with lib.maintainers; [ lnl7 ];
+    maintainers = [ ];
   };
 }

pkgs/development/python-modules/pytest-resource-path/default.nix

@@ -8,16 +8,16 @@
   setuptools,
 }:
 
-buildPythonPackage rec {
+buildPythonPackage (finalAttrs: {
   pname = "pytest-resource-path";
-  version = "1.4.1";
+  version = "1.5.0";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "yukihiko-shinoda";
     repo = "pytest-resource-path";
-    tag = "v${version}";
-    hash = "sha256-f0jN6V6tQRbr/DHOKKTrFCb1EBUUxZAQRckMy2iiVqI=";
+    tag = "v${finalAttrs.version}";
+    hash = "sha256-Y/mB5Gmkt3Rt8rRBOFZrWIREnpEiSxf/MChqymXDNws=";
   };
 
   build-system = [ setuptools ];
@@ -36,4 +36,4 @@ buildPythonPackage rec {
     license = lib.licenses.mit;
     maintainers = with lib.maintainers; [ fab ];
   };
-}
+})

pkgs/development/python-modules/sev-snp-measure/default.nix

@@ -8,7 +8,7 @@
 
 buildPythonPackage rec {
   pname = "sev-snp-measure";
-  version = "0.0.12";
+  version = "0.0.13";
 
   pyproject = true;
 
@@ -16,7 +16,7 @@ buildPythonPackage rec {
     owner = "virtee";
     repo = "sev-snp-measure";
     tag = "v${version}";
-    hash = "sha256-UcXU6rNjcRN1T+iWUNrqeJCkSa02WU1/pBwLqHVPRyw=";
+    hash = "sha256-euAmKIdLJiA+iRlsPJCxPuquE9eznwd937LVWO4DKpc=";
   };
 
   nativeBuildInputs = [

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

@@ -19,14 +19,14 @@
 
 buildPythonPackage (finalAttrs: {
   pname = "twilio";
-  version = "9.10.5";
+  version = "9.10.9";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "twilio";
     repo = "twilio-python";
     tag = finalAttrs.version;
-    hash = "sha256-WLgx8kAHfLf7BHhu4A7b4gI3pB7WODb/CPV1qw7oNXM=";
+    hash = "sha256-CQWP8QujDvV5+Z5JDUcWhQ4mJZqaXnxpScS9sBxIX4Q=";
   };
 
   build-system = [ setuptools ];

pkgs/development/python-modules/uuid-utils/default.nix

@@ -9,19 +9,19 @@
 
 buildPythonPackage rec {
   pname = "uuid-utils";
-  version = "0.14.1";
+  version = "0.16.0";
   pyproject = true;
 
   src = fetchFromGitHub {
     owner = "aminalaee";
     repo = "uuid-utils";
     tag = version;
-    hash = "sha256-AcHb/wGrucsGPHEuX8TkBDqDEUrCPhXKz/YTCVu/m4I=";
+    hash = "sha256-vHezizqhVS6vHowX7231ZJtmEDOp8PG4KtJgSwevqWM=";
   };
 
   cargoDeps = rustPlatform.fetchCargoVendor {
     inherit pname src version;
-    hash = "sha256-Zbtu8DbQo+8/8Kt0SJmXsOU0pRLihIOV0O7QjbR8AHU=";
+    hash = "sha256-MG2IonqvB+G8Vz+fHls/F8sUEGhXO2nA4a027yhfrCk=";
   };
 
   nativeBuildInputs = with rustPlatform; [

pkgs/development/tools/haskell/vaultenv/default.nix

@@ -86,7 +86,6 @@ mkDerivation rec {
   homepage = "https://github.com/channable/vaultenv#readme";
   description = "Runs processes with secrets from HashiCorp Vault";
   license = lib.licenses.bsd3;
-  maintainers = with lib.maintainers; [
-    lnl7
+  maintainers = [
   ];
 }

pkgs/misc/tmux-plugins/default.nix

@@ -770,6 +770,42 @@ in
     };
   };
 
+  search-panes = mkTmuxPlugin {
+    pluginName = "search-panes";
+    version = "0-unstable-2025-07-27";
+    src = fetchFromGitHub {
+      owner = "multi-io";
+      repo = "tmux-search-panes";
+      rev = "3996b5c56c6be69d3a85ef26065b1877d9ac71c6";
+      hash = "sha256-Z9Gu4v2LAyG6UxXVLTvQUz1wU4PaJlBQXjLiSzfSP7s=";
+    };
+    rtpFilePath = "tmux-search-panes.tmux";
+    nativeBuildInputs = [ pkgs.makeWrapper ];
+    postInstall = ''
+      for f in search-panes.sh _fzf-and-switch.sh _render-preview.sh; do
+        chmod +x $target/bin/$f
+        wrapProgram $target/bin/$f \
+          --prefix PATH : ${
+            with pkgs;
+            lib.makeBinPath [
+              coreutils
+              fzf
+              gnugrep
+              gnused
+              tmux
+            ]
+          }
+      done
+    '';
+    meta = {
+      homepage = "https://github.com/multi-io/tmux-search-panes";
+      description = "Tmux plugin that allows you to perform a fulltext search";
+      license = lib.licenses.mit;
+      platforms = lib.platforms.unix;
+      maintainers = [ lib.maintainers.DieracDelta ];
+    };
+  };
+
   sensible = mkTmuxPlugin {
     pluginName = "sensible";
     version = "unstable-2022-08-14";