push sheeet

pkgs/tools/package-management/lix/common-lix.nix

@@ -0,0 +1,411 @@
+{
+  lib,
+  suffix ? "",
+  version,
+  src,
+  # For Lix versions >= 2.92, Rust sources are in the Lix repository root.
+  cargoDeps ? null,
+  # For previous versions, Rust sources are only in a subdirectory for
+  # `lix-doc`.
+  docCargoDeps ? null,
+  patches ? [ ],
+  knownVulnerabilities ? [ ],
+}@args:
+
+assert lib.assertMsg (
+  lib.versionOlder version "2.92" -> docCargoDeps != null
+) "`lix-doc` `cargoDeps` must be set for Lix < 2.92";
+assert lib.assertMsg (
+  lib.versionAtLeast version "2.92" -> cargoDeps != null
+) "`cargoDeps` must be set for Lix ≥ 2.92";
+
+{
+  stdenv,
+  meson,
+  bison,
+  boehmgc,
+  boost,
+  brotli,
+  busybox-sandbox-shell,
+  bzip2,
+  callPackage,
+  capnproto,
+  cargo,
+  curl,
+  cmake,
+  doxygen,
+  editline,
+  flex,
+  git,
+  gtest,
+  jq,
+  lib,
+  libarchive,
+  libcpuid,
+  libsodium,
+  libsystemtap,
+  llvmPackages,
+  lowdown,
+  lowdown-unsandboxed,
+  lsof,
+  mercurial,
+  mdbook,
+  mdbook-linkcheck,
+  nlohmann_json,
+  ninja,
+  openssl,
+  pkgsStatic,
+  rustc,
+  toml11,
+  pegtl,
+  buildPackages,
+  pkg-config,
+  rapidcheck,
+  sqlite,
+  systemtap-sdt,
+  util-linuxMinimal,
+  removeReferencesTo,
+  xz,
+  yq,
+  nixosTests,
+  rustPlatform,
+  # Only used for versions before 2.92.
+  lix-doc ? callPackage ./doc {
+    inherit src;
+    version = "${version}${suffix}";
+    cargoDeps = docCargoDeps;
+  },
+
+  enableDocumentation ? stdenv.hostPlatform == stdenv.buildPlatform,
+  enableStatic ? stdenv.hostPlatform.isStatic,
+  enableStrictLLVMChecks ? true,
+  withAWS ?
+    lib.meta.availableOn stdenv.hostPlatform aws-c-common
+    && !enableStatic
+    && (stdenv.hostPlatform.isLinux || stdenv.hostPlatform.isDarwin),
+  aws-c-common,
+  aws-sdk-cpp,
+  # FIXME support Darwin once https://github.com/NixOS/nixpkgs/pull/392918 lands
+  withDtrace ?
+    lib.meta.availableOn stdenv.hostPlatform libsystemtap
+    && lib.meta.availableOn stdenv.buildPlatform systemtap-sdt,
+  # RISC-V support in progress https://github.com/seccomp/libseccomp/pull/50
+  withLibseccomp ? lib.meta.availableOn stdenv.hostPlatform libseccomp,
+  libseccomp,
+  pastaFod ? lib.meta.availableOn stdenv.hostPlatform passt,
+  passt,
+
+  confDir,
+  stateDir,
+  storeDir,
+}:
+let
+  isLLVMOnly = lib.versionAtLeast version "2.92";
+  hasExternalLixDoc = lib.versionOlder version "2.92";
+  isLegacyParser = lib.versionOlder version "2.91";
+  hasDtraceSupport = lib.versionAtLeast version "2.93";
+  parseToYAML = lib.versionAtLeast version "2.93";
+  usesCapnp = lib.versionAtLeast version "2.94";
+in
+# gcc miscompiles coroutines at least until 13.2, possibly longer
+# do not remove this check unless you are sure you (or your users) will not report bugs to Lix upstream about GCC miscompilations.
+assert lib.assertMsg (enableStrictLLVMChecks && isLLVMOnly -> stdenv.cc.isClang)
+  "Lix upstream strongly discourage the usage of GCC to compile Lix as there's known miscompilations in important places. If you are a compiler developer, please get in touch with us.";
+stdenv.mkDerivation (finalAttrs: {
+  pname = "lix";
+
+  version = "${version}${suffix}";
+  VERSION_SUFFIX = suffix;
+
+  inherit src patches;
+
+  outputs = [
+    "out"
+    "dev"
+  ]
+  ++ lib.optionals enableDocumentation [
+    "man"
+    "doc"
+    "devdoc"
+  ];
+
+  strictDeps = true;
+  disallowedReferences = lib.optionals isLLVMOnly [
+    # We don't want the Clang.
+    stdenv.cc.cc
+    # We don't want the underlying GCC neither!
+    stdenv.cc.cc.stdenv.cc.cc
+  ];
+  __structuredAttrs = true;
+
+  # We only include CMake so that Meson can locate toml11, which only ships CMake dependency metadata.
+  dontUseCmakeConfigure = true;
+
+  nativeBuildInputs = [
+    # python3.withPackages does not splice properly, see https://github.com/NixOS/nixpkgs/issues/305858
+    (buildPackages.python3.withPackages (
+      p:
+      [ p.python-frontmatter ]
+      ++ lib.optionals (lib.versionOlder version "2.94") [ p.toml ]
+      ++ lib.optionals finalAttrs.doInstallCheck [
+        p.aiohttp
+        p.pytest
+        p.pytest-xdist
+      ]
+      ++ lib.optionals usesCapnp [ p.pycapnp ]
+    ))
+    pkg-config
+    flex
+    jq
+    meson
+    ninja
+    cmake
+    # Required for libstd++ assertions that leaks inside of the final binary.
+    removeReferencesTo
+
+    # Tests
+    git
+    mercurial
+    jq
+    lsof
+  ]
+  ++ lib.optionals isLLVMOnly [
+    rustc
+    cargo
+    rustPlatform.cargoSetupHook
+  ]
+  ++ lib.optionals isLegacyParser [ bison ]
+  ++ lib.optionals enableDocumentation [
+    (lib.getBin lowdown-unsandboxed)
+    mdbook
+    mdbook-linkcheck
+    doxygen
+  ]
+  ++ lib.optionals (hasDtraceSupport && withDtrace) [ systemtap-sdt ]
+  ++ lib.optionals pastaFod [ passt ]
+  ++ lib.optionals parseToYAML [ yq ]
+  ++ lib.optionals usesCapnp [ capnproto ]
+  ++ lib.optionals stdenv.hostPlatform.isLinux [ util-linuxMinimal ];
+
+  buildInputs = [
+    boost
+    brotli
+    bzip2
+    curl
+    capnproto
+    editline
+    libsodium
+    openssl
+    sqlite
+    xz
+    gtest
+    libarchive
+    lowdown
+    rapidcheck
+    toml11
+  ]
+  ++ lib.optionals hasExternalLixDoc [ lix-doc ]
+  ++ lib.optionals (!isLegacyParser) [ pegtl ]
+  ++ lib.optionals (lib.versionOlder version "2.94") [ libsodium ]
+  # NOTE(Raito): I'd have expected that the LLVM packaging would inject the
+  # libunwind library path directly in the wrappers, but it does inject
+  # -lunwind without injecting the library path...
+  ++ lib.optionals stdenv.hostPlatform.isStatic [ llvmPackages.libunwind ]
+  ++ lib.optionals (stdenv.hostPlatform.isx86_64) [ libcpuid ]
+  ++ lib.optionals withLibseccomp [ libseccomp ]
+  ++ lib.optionals withAWS [ aws-sdk-cpp ]
+  ++ lib.optionals (hasDtraceSupport && withDtrace) [ libsystemtap ];
+
+  inherit cargoDeps;
+
+  env = {
+    # Meson allows referencing a /usr/share/cargo/registry shaped thing for subproject sources.
+    # Turns out the Nix-generated Cargo dependencies are named the same as they
+    # would be in a Cargo registry cache.
+    MESON_PACKAGE_CACHE_DIR =
+      if finalAttrs.cargoDeps != null then
+        finalAttrs.cargoDeps
+      else
+        "lix: no `MESON_PACKAGE_CACHE_DIR`, set `cargoDeps`";
+  };
+
+  propagatedBuildInputs = [
+    boehmgc
+    nlohmann_json
+  ];
+
+  postPatch = ''
+    patchShebangs --build tests doc/manual
+  '';
+
+  preConfigure =
+    # Copy libboost_context so we don't get all of Boost in our closure.
+    # https://github.com/NixOS/nixpkgs/issues/45462
+    lib.optionalString (lib.versionOlder version "2.91" && !enableStatic) ''
+      mkdir -p $out/lib
+      cp -pd ${boost}/lib/{libboost_context*,libboost_thread*,libboost_system*} $out/lib
+      rm -f $out/lib/*.a
+      ${lib.optionalString stdenv.hostPlatform.isLinux ''
+        chmod u+w $out/lib/*.so.*
+        patchelf --set-rpath $out/lib:${lib.getLib stdenv.cc.cc}/lib $out/lib/libboost_thread.so.*
+      ''}
+      ${lib.optionalString stdenv.hostPlatform.isDarwin ''
+        for LIB in $out/lib/*.dylib; do
+          chmod u+w $LIB
+          install_name_tool -id $LIB $LIB
+          install_name_tool -delete_rpath ${boost}/lib/ $LIB || true
+        done
+        install_name_tool -change ${boost}/lib/libboost_system.dylib $out/lib/libboost_system.dylib $out/lib/libboost_thread.dylib
+      ''}
+    '';
+
+  # -O3 seems to anger a gcc bug and provide no performance benefit.
+  # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114360
+  # We use -O2 upstream https://gerrit.lix.systems/c/lix/+/554
+  mesonBuildType = "debugoptimized";
+
+  mesonFlags = [
+    # Enable LTO, since it improves eval performance a fair amount
+    # LTO is disabled on:
+    # - static builds (strange linkage errors)
+    # - darwin builds (install test failures. see fj#568 & fj#832)
+    (lib.mesonBool "b_lto" (
+      !stdenv.hostPlatform.isStatic && !stdenv.hostPlatform.isDarwin && (isLLVMOnly || stdenv.cc.isGNU)
+    ))
+    (lib.mesonEnable "gc" true)
+    (lib.mesonBool "enable-tests" true)
+    (lib.mesonBool "enable-docs" enableDocumentation)
+    (lib.mesonEnable "internal-api-docs" enableDocumentation)
+    (lib.mesonBool "enable-embedded-sandbox-shell" (
+      stdenv.hostPlatform.isLinux && stdenv.hostPlatform.isStatic
+    ))
+    (lib.mesonEnable "seccomp-sandboxing" withLibseccomp)
+
+    (lib.mesonOption "store-dir" storeDir)
+    (lib.mesonOption "state-dir" stateDir)
+    (lib.mesonOption "sysconfdir" confDir)
+  ]
+  ++ lib.optionals hasDtraceSupport [
+    (lib.mesonEnable "dtrace-probes" withDtrace)
+  ]
+  ++ lib.optionals stdenv.hostPlatform.isLinux [
+    (lib.mesonOption "sandbox-shell" "${busybox-sandbox-shell}/bin/busybox")
+  ]
+  ++
+    lib.optionals
+      (stdenv.hostPlatform.isLinux && finalAttrs.doInstallCheck && lib.versionAtLeast version "2.94")
+      [
+        (lib.mesonOption "build-test-shell" "${pkgsStatic.busybox}/bin")
+      ];
+
+  ninjaFlags = [ "-v" ];
+
+  postInstall =
+    lib.optionalString enableDocumentation ''
+      mkdir -p $doc/nix-support
+      echo "doc manual $doc/share/doc/nix/manual" >> $doc/nix-support/hydra-build-products
+
+      mkdir -p $devdoc/nix-support
+      echo "devdoc internal-api $devdoc/share/doc/nix/internal-api" >> $devdoc/nix-support/hydra-build-products
+    ''
+    + lib.optionalString (lib.versionOlder version "2.94" && !hasExternalLixDoc) ''
+      # We do not need static archives.
+      rm $out/lib/liblix_doc.a
+    ''
+    + lib.optionalString stdenv.hostPlatform.isStatic ''
+      mkdir -p $out/nix-support
+      echo "file binary-dist $out/bin/nix" >> $out/nix-support/hydra-build-products
+    ''
+    + lib.optionalString (lib.versionOlder version "2.91" && stdenv.hostPlatform.isDarwin) ''
+      for lib in liblixutil.dylib liblixexpr.dylib; do
+        install_name_tool \
+          -change "${lib.getLib boost}/lib/libboost_context.dylib" \
+          "$out/lib/libboost_context.dylib" \
+          "$out/lib/$lib"
+      done
+    ''
+    + ''
+      # Drop all references to libstd++ include files due to `__FILE__` leaking in libstd++ assertions.
+      find "$out" -type f -exec remove-references-to -t ${stdenv.cc.cc.stdenv.cc.cc} '{}' +
+    '';
+
+  # This needs to run after _multioutDocs moves the docs to $doc
+  postFixup = lib.optionalString enableDocumentation ''
+    mkdir -p $devdoc/share/doc/nix
+    mv $doc/share/doc/nix/internal-api $devdoc/share/doc/nix
+  '';
+
+  doCheck = true;
+  mesonCheckFlags = [
+    "--suite=check"
+    "--print-errorlogs"
+  ];
+  checkInputs = [
+    gtest
+    rapidcheck
+  ];
+
+  doInstallCheck = true;
+  mesonInstallCheckFlags = [
+    "--suite=installcheck"
+    "--print-errorlogs"
+  ];
+
+  preInstallCheck = lib.optionalString stdenv.hostPlatform.isDarwin ''
+    # socket path becomes too long otherwise
+    export TMPDIR=$NIX_BUILD_TOP
+    # Prevent crashes in libcurl due to invoking Objective-C `+initialize` methods after `fork`.
+    # See http://sealiesoftware.com/blog/archive/2017/6/5/Objective-C_and_fork_in_macOS_1013.html.
+    export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES
+  '';
+
+  installCheckPhase = ''
+    runHook preInstallCheck
+    flagsArray=($mesonInstallCheckFlags "''${mesonInstallCheckFlagsArray[@]}")
+    meson test --no-rebuild "''${flagsArray[@]}"
+    runHook postInstallCheck
+  '';
+  hardeningDisable = [
+    "shadowstack"
+    # strictoverflow is disabled because we trap on signed overflow instead
+    "strictoverflow"
+  ]
+  # fortify breaks the build with lto and musl for some reason
+  ++ lib.optional stdenv.hostPlatform.isMusl "fortify";
+
+  # hardeningEnable = lib.optionals (!stdenv.hostPlatform.isDarwin) [ "pie" ];
+  separateDebugInfo = stdenv.hostPlatform.isLinux && !enableStatic;
+  enableParallelBuilding = true;
+
+  # Used by (1) test which has dynamic port assignment.
+  __darwinAllowLocalNetworking = true;
+
+  passthru = {
+    inherit aws-sdk-cpp boehmgc;
+    tests = {
+      misc = nixosTests.nix-misc.default.passthru.override { nixPackage = finalAttrs.finalPackage; };
+      installer = nixosTests.installer.simple.override { selectNixPackage = _: finalAttrs.finalPackage; };
+    };
+  };
+
+  # point 'nix edit' and ofborg at the file that defines the attribute,
+  # not this common file.
+  pos = builtins.unsafeGetAttrPos "version" args;
+  meta = {
+    description = "Powerful package manager that makes package management reliable and reproducible";
+    longDescription = ''
+      Lix (a fork of Nix) is a powerful package manager for Linux and other Unix systems that
+      makes package management reliable and reproducible. It provides atomic
+      upgrades and rollbacks, side-by-side installation of multiple versions of
+      a package, multi-user package management and easy setup of build
+      environments.
+    '';
+    homepage = "https://lix.systems";
+    license = lib.licenses.lgpl21Plus;
+    teams = [ lib.teams.lix ];
+    platforms = lib.platforms.unix;
+    outputsToInstall = [ "out" ] ++ lib.optional enableDocumentation "man";
+    mainProgram = "nix";
+    inherit knownVulnerabilities;
+  };
+})

pkgs/tools/package-management/lix/common-nix-eval-jobs.nix

@@ -0,0 +1,70 @@
+{
+  lib,
+  suffix ? "",
+  version,
+  src,
+  patches ? [ ],
+}@args:
+
+{
+  stdenv,
+  lib,
+  lix,
+  boost,
+  capnproto,
+  nlohmann_json,
+  meson,
+  pkg-config,
+  ninja,
+  cmake,
+  buildPackages,
+}:
+
+stdenv.mkDerivation {
+  pname = "nix-eval-jobs";
+  version = "${version}${suffix}";
+  inherit src patches;
+  sourceRoot = if lib.versionAtLeast version "2.93" then "source/subprojects/nix-eval-jobs" else null;
+  buildInputs = [
+    nlohmann_json
+    lix
+    boost
+  ]
+  ++ lib.optionals (lib.versionAtLeast version "2.93") [
+    capnproto
+  ];
+  nativeBuildInputs = [
+    meson
+    pkg-config
+    ninja
+    # nlohmann_json can be only discovered via cmake files
+    cmake
+  ]
+  ++ (lib.optional stdenv.cc.isClang [ buildPackages.clang-tools ]);
+
+  # point 'nix edit' and ofborg at the file that defines the attribute,
+  # not this common file.
+  pos = builtins.unsafeGetAttrPos "version" args;
+
+  # Since this package is intimately tied to a specific Nix release, we
+  # propagate the Nix used for building it to make it easier for users
+  # downstream to reference it.
+  passthru = {
+    nix = lix;
+  };
+
+  meta = {
+    description = "Hydra's builtin `hydra-eval-jobs` as a standalone tool";
+    mainProgram = "nix-eval-jobs";
+    homepage =
+      # Starting with 2.93, `nix-eval-jobs` lives in the `lix` repository.
+      if lib.versionAtLeast version "2.93" then
+        "https://git.lix.systems/lix-project/lix/src/branch/main/subprojects/nix-eval-jobs"
+      else
+        "https://git.lix.systems/lix-project/nix-eval-jobs";
+    license = lib.licenses.gpl3;
+    teams = [ lib.teams.lix ];
+    platforms = lib.platforms.unix;
+    broken = lib.versionOlder version "2.94" && stdenv.hostPlatform.isStatic;
+  };
+}

pkgs/tools/package-management/lix/default.nix

@@ -0,0 +1,270 @@
+{
+  lib,
+  config,
+  stdenv,
+  makeScopeWithSplicing',
+  generateSplicesForMkScope,
+  aws-sdk-cpp,
+  boehmgc,
+  callPackage,
+  fetchgit,
+  fetchFromGitHub,
+  fetchFromGitea,
+  fetchpatch2,
+  fetchpatch,
+  rustPlatform,
+  editline,
+  ncurses,
+  clangStdenv,
+  nixpkgs-review,
+  nix-direnv,
+  nix-fast-build,
+  haskell,
+  nix-serve-ng,
+  colmena,
+  nix-update,
+
+  storeDir ? "/nix/store",
+  stateDir ? "/nix/var",
+  confDir ? "/etc",
+}:
+let
+  makeLixScope =
+    {
+      attrName,
+      lix-args,
+      # Starting with 2.93, `nix-eval-jobs` lives in the `lix` repository.
+      nix-eval-jobs-args ? { inherit (lix-args) version src; },
+    }:
+    let
+      # GCC 13.2 is known to miscompile Lix coroutines (introduced in 2.92).
+      lixStdenv = if lib.versionAtLeast lix-args.version "2.92" then clangStdenv else stdenv;
+    in
+    makeScopeWithSplicing' {
+      otherSplices = generateSplicesForMkScope [
+        "lixPackageSets"
+        attrName
+      ];
+      f =
+        self:
+        lib.recurseIntoAttrs {
+          inherit
+            storeDir
+            stateDir
+            confDir
+            ;
+
+          boehmgc =
+            # TODO: Why is this called `boehmgc-nix_2_3`?
+            let
+              boehmgc-nix_2_3 = boehmgc.override {
+                enableLargeConfig = true;
+                initialMarkStackSize = 1048576;
+              };
+            in
+            # Since Lix 2.91 does not use boost coroutines, it does not need boehmgc patches either.
+            if lib.versionOlder lix-args.version "2.91" then
+              boehmgc-nix_2_3.overrideAttrs (drv: {
+                patches = (drv.patches or [ ]) ++ [
+                  # Part of the GC solution in https://github.com/NixOS/nix/pull/4944
+                  ../nix/patches/boehmgc-coroutine-sp-fallback.patch
+                ];
+              })
+            else
+              boehmgc-nix_2_3;
+
+          aws-sdk-cpp =
+            (aws-sdk-cpp.override {
+              apis = [
+                "s3"
+                "transfer"
+              ];
+              customMemoryManagement = false;
+            }).overrideAttrs
+              {
+                # only a stripped down version is build which takes a lot less resources to build
+                requiredSystemFeatures = [ ];
+              };
+
+          editline = editline.override {
+            inherit ncurses;
+            enableTermcap = true;
+          };
+
+          # NOTE: The `common-*.nix` helpers contain a top-level function which
+          # takes the Lix source to build and version information. We use the
+          # outer `callPackage` for that.
+          #
+          # That *returns* another function which takes the actual build
+          # dependencies, and that uses the new scope's `self.callPackage` so
+          # that `nix-eval-jobs` can be built against the correct `lix` version.
+          lix = self.callPackage (callPackage ./common-lix.nix lix-args) {
+            stdenv = lixStdenv;
+          };
+
+          nixpkgs-review = nixpkgs-review.override {
+            nix = self.lix;
+          };
+
+          nix-direnv = nix-direnv.override {
+            nix = self.lix;
+          };
+
+          nix-eval-jobs = self.callPackage (callPackage ./common-nix-eval-jobs.nix nix-eval-jobs-args) {
+            stdenv = lixStdenv;
+          };
+
+          nix-fast-build = nix-fast-build.override {
+            inherit (self) nix-eval-jobs;
+          };
+
+          nix-serve-ng = lib.pipe (nix-serve-ng.override { nix = self.lix; }) [
+            (haskell.lib.compose.enableCabalFlag "lix")
+            (haskell.lib.compose.overrideCabal (drv: {
+              # https://github.com/aristanetworks/nix-serve-ng/issues/46
+              # Resetting (previous) broken flag since it may be related to C++ Nix
+              broken = lib.versionAtLeast self.lix.version "2.93";
+            }))
+          ];
+
+          colmena = colmena.override {
+            nix = self.lix;
+            inherit (self) nix-eval-jobs;
+          };
+
+          nix-update = nix-update.override {
+            nix = self.lix;
+            inherit (self) nixpkgs-review;
+          };
+        };
+    };
+
+  removedMessage = version: ''
+    Lix ${version} is now removed from this revision of Nixpkgs. Consider upgrading to stable or the latest version.
+
+          If you notice a problem while upgrading disrupting your workflows which did not occur in version ${version}, please reach out to the Lix team.
+  '';
+in
+lib.makeExtensible (
+  self:
+  {
+    inherit makeLixScope;
+
+    lix_2_93 = self.makeLixScope {
+      attrName = "lix_2_93";
+
+      lix-args = rec {
+        version = "2.93.3";
+
+        src = fetchFromGitea {
+          domain = "git.lix.systems";
+          owner = "lix-project";
+          repo = "lix";
+          rev = version;
+          hash = "sha256-Oqw04eboDM8rrUgAXiT7w5F2uGrQdt8sGX+Mk6mVXZQ=";
+        };
+
+        cargoDeps = rustPlatform.fetchCargoVendor {
+          name = "lix-${version}";
+          inherit src;
+          hash = "sha256-YMyNOXdlx0I30SkcmdW/6DU0BYc3ZOa2FMJSKMkr7I8=";
+        };
+
+        patches = [
+          # Support for lowdown >= 1.4, https://gerrit.lix.systems/c/lix/+/3731
+          (fetchpatch2 {
+            name = "lix-lowdown-1.4.0.patch";
+            url = "https://git.lix.systems/lix-project/lix/commit/858de5f47a1bfd33835ec97794ece339a88490f1.patch";
+            hash = "sha256-FfLO2dFSWV1qwcupIg8dYEhCHir2XX6/Hs89eLwd+SY=";
+          })
+
+          # Support for toml11 >= 4.0, https://gerrit.lix.systems/c/lix/+/3953
+          (fetchpatch {
+            name = "lix-2.93-toml11-4-1.patch";
+            url = "https://git.lix.systems/lix-project/lix/commit/96a39dc464165a3e503a6dc7bd44518a116fe846.patch";
+            hash = "sha256-j1DOScY2IFvcouhoap9CQwIZf99MZ92HtY7CjInF/s4=";
+          })
+          (fetchpatch {
+            name = "lix-2.93-toml11-4-2.patch";
+            url = "https://git.lix.systems/lix-project/lix/commit/699d3a63a6351edfdbc8c05f814cc93d6c3637ca.patch";
+            hash = "sha256-2iUynAdimxhe5ZSDB7DlzFG3tu1yWhq+lTvjf6+M0pM=";
+          })
+          (fetchpatch {
+            name = "lix-2.93-toml11-4-3.patch";
+            url = "https://git.lix.systems/lix-project/lix/commit/ad52cbde2faa677b711ec950dae74e4aede965a4.patch";
+            hash = "sha256-ajQwafL3yZDJMVrR+D9eTGh7L0xbDbqhAUagRur4HDE=";
+          })
+          (fetchpatch {
+            name = "lix-2.93-toml11-4-4.patch";
+            url = "https://git.lix.systems/lix-project/lix/commit/e29a1ccf0af2e2890ec7b7fde82f0e53a1d0aad9.patch";
+            hash = "sha256-sXqZxCUtZsO7uEVk2AZx3IkP8b8EPVghYboetcQTp2A=";
+          })
+          (fetchpatch {
+            name = "lix-2.93-toml11-4-5.patch";
+            url = "https://git.lix.systems/lix-project/lix/commit/176b834464b7285b74a72d35df7470a46362ce60.patch";
+            hash = "sha256-/KIszfHf2XoB+GeVvXad2AV8pazffYdQRDtIXb9tbj8=";
+          })
+          (fetchpatch {
+            name = "lix-2.93-toml11-4-6.patch";
+            url = "https://git.lix.systems/lix-project/lix/commit/b6d5670bcffebdd43352ea79b36135e35a8148d9.patch";
+            hash = "sha256-f4s0TR5MhNMNM5TYLOR7K2/1rtZ389KDjTCKFVK0OcE=";
+          })
+        ];
+      };
+    };
+
+    git = self.makeLixScope {
+      attrName = "git";
+
+      lix-args = rec {
+        version = "2.94.0-pre-20251001_${builtins.substring 0 12 src.rev}";
+
+        src = fetchFromGitea {
+          domain = "git.lix.systems";
+          owner = "lix-project";
+          repo = "lix";
+          rev = "f1ef994f120a723839a6d837cc2b33914a30a4db";
+          hash = "sha256-Rmq98EchbKygPo+2g0nDsZ7QNMLe+loiMbflV5VKDzc=";
+        };
+
+        cargoDeps = rustPlatform.fetchCargoVendor {
+          name = "lix-${version}";
+          inherit src;
+          hash = "sha256-APm8m6SVEAO17BBCka13u85/87Bj+LePP7Y3zHA3Mpg=";
+        };
+      };
+    };
+
+    latest = self.lix_2_93;
+
+    stable = self.lix_2_93;
+
+    # Previously, `nix-eval-jobs` was not packaged here, so we export an
+    # attribute with the previously-expected structure for compatibility. This
+    # is also available (for now) as `pkgs.lixVersions`.
+    renamedDeprecatedLixVersions =
+      let
+        mkAlias =
+          version:
+          lib.warnOnInstantiate "'lixVersions.${version}' has been renamed to 'lixPackageSets.${version}.lix'"
+            self.${version}.lix;
+      in
+      lib.dontRecurseIntoAttrs {
+        # NOTE: Do not add new versions of Lix here.
+        stable = mkAlias "stable";
+        latest = mkAlias "latest";
+      }
+      // lib.optionalAttrs config.allowAliases {
+        # Legacy removed versions. We keep their aliases until the lixPackageSets one is dropped.
+        lix_2_90 = mkAlias "lix_2_90";
+        lix_2_91 = mkAlias "lix_2_91";
+      };
+  }
+  // lib.optionalAttrs config.allowAliases {
+    # Removed versions.
+    # When removing a version, add an alias with a date attached to it so we can clean it up after a while.
+    lix_2_90 = throw (removedMessage "2.90"); # added in 2025-09-11
+    lix_2_91 = throw (removedMessage "2.91"); # added in 2025-09-11
+    lix_2_92 = throw (removedMessage "2.92"); # added in 2025-09-11
+  }
+)

pkgs/tools/package-management/lix/doc/default.nix

@@ -0,0 +1,16 @@
+{
+  src,
+  rustPlatform,
+  version,
+  cargoDeps,
+}:
+
+rustPlatform.buildRustPackage {
+  pname = "lix-doc";
+  sourceRoot = "${src.name or src}/lix-doc";
+  inherit
+    version
+    src
+    cargoDeps
+    ;
+}