From b477d662de1bf91d4576689b38076bdd09e6b40e Mon Sep 17 00:00:00 2001
From: Kiskae <Kiskae@users.noreply.github.com>
Date: Fri, 29 Sep 2023 23:09:18 +0200
Subject: [PATCH] WIP updater

---
 dev/flake.lock                                |  67 +++-
 dev/flake.nix                                 |  38 +-
 dev/treefmt.nix                               |  35 +-
 dev/updater/module.nix                        | 103 ++++++
 .../nvchecker_source/tesla_releases.py        |  27 ++
 dev/updater/nvchecker_source/unix_drivers.py  |  61 ++++
 flake.nix                                     |  13 +-
 nixos/default.nix                             |   3 +
 nixos/nvidia/legacy.nix                       |   1 +
 pkgs/nvidia-driver/components.nix             |  84 +++++
 pkgs/nvidia-driver/default.nix                |  30 ++
 .../nvidia-installer/default.nix              |  33 ++
 .../nvidia-installer/parse-manifest.py        |   0
 pkgs/overlay.nix                              |   5 +
 {pkgs => pkgs_old}/kmod.nix                   |   0
 pkgs_old/nvidia-driver/components.nix         |   1 +
 .../nvidia-driver}/default.nix                |   0
 .../nvidia-driver}/hashes.json                |   0
 .../nvidia-installer/components.nix           |   0
 .../nvidia-installer/default.nix              |   2 +-
 .../nvidia-installer/parse-manifest.py        | 329 ++++++++++++++++++
 .../nvidia-driver}/refs.json                  |   0
 .../nvidia-driver}/refs/get-hash.sh           |   0
 .../nvidia-driver}/refs/tesla.jq              |   0
 .../nvidia-driver}/refs/tesla.json            |   0
 .../nvidia-driver}/refs/versions.jq           |   0
 .../nvidia-driver}/refs/versions.json         |   0
 .../nvidia-driver}/refs/vulkan-dev.jq         |   0
 .../nvidia-driver}/refs/vulkan-dev.json       |   0
 {pkgs => pkgs_old}/nvidia-settings.nix        |   0
 {pkgs => pkgs_old}/vulkan-samples.nix         |   0
 31 files changed, 799 insertions(+), 33 deletions(-)
 create mode 100644 dev/updater/module.nix
 create mode 100644 dev/updater/nvchecker_source/tesla_releases.py
 create mode 100644 dev/updater/nvchecker_source/unix_drivers.py
 create mode 100644 nixos/default.nix
 create mode 100644 nixos/nvidia/legacy.nix
 create mode 100644 pkgs/nvidia-driver/components.nix
 create mode 100644 pkgs/nvidia-driver/default.nix
 create mode 100644 pkgs/nvidia-driver/nvidia-installer/default.nix
 rename {nvidia-driver => pkgs/nvidia-driver}/nvidia-installer/parse-manifest.py (100%)
 create mode 100644 pkgs/overlay.nix
 rename {pkgs => pkgs_old}/kmod.nix (100%)
 create mode 100644 pkgs_old/nvidia-driver/components.nix
 rename {nvidia-driver => pkgs_old/nvidia-driver}/default.nix (100%)
 rename {nvidia-driver => pkgs_old/nvidia-driver}/hashes.json (100%)
 rename {nvidia-driver => pkgs_old/nvidia-driver}/nvidia-installer/components.nix (100%)
 rename {nvidia-driver => pkgs_old/nvidia-driver}/nvidia-installer/default.nix (99%)
 create mode 100755 pkgs_old/nvidia-driver/nvidia-installer/parse-manifest.py
 rename {nvidia-driver => pkgs_old/nvidia-driver}/refs.json (100%)
 rename {nvidia-driver => pkgs_old/nvidia-driver}/refs/get-hash.sh (100%)
 rename {nvidia-driver => pkgs_old/nvidia-driver}/refs/tesla.jq (100%)
 rename {nvidia-driver => pkgs_old/nvidia-driver}/refs/tesla.json (100%)
 rename {nvidia-driver => pkgs_old/nvidia-driver}/refs/versions.jq (100%)
 rename {nvidia-driver => pkgs_old/nvidia-driver}/refs/versions.json (100%)
 rename {nvidia-driver => pkgs_old/nvidia-driver}/refs/vulkan-dev.jq (100%)
 rename {nvidia-driver => pkgs_old/nvidia-driver}/refs/vulkan-dev.json (100%)
 rename {pkgs => pkgs_old}/nvidia-settings.nix (100%)
 rename {pkgs => pkgs_old}/vulkan-samples.nix (100%)

diff --git a/dev/flake.lock b/dev/flake.lock
index fa1a83e..8e3720b 100644
--- a/dev/flake.lock
+++ b/dev/flake.lock
@@ -3,7 +3,7 @@
     "flake": {
       "locked": {
         "lastModified": 0,
-        "narHash": "sha256-ZCBBS14pkSYLUbDtVEN6BRCEMm2e9ahpQHOG7toP9Rw=",
+        "narHash": "sha256-jyyAhyStjFcaG9VOipFdN0Souk/fzgTD3uQjT/I2z3w=",
         "path": "../",
         "type": "path"
       },
@@ -12,13 +12,46 @@
         "type": "path"
       }
     },
+    "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1693611461,
+        "narHash": "sha256-aPODl8vAgGQ0ZYFIRisxYG5MOGSkIczvu2Cd8Gb9+1Y=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "7f53fdb7bdc5bb237da7fefef12d099e4fd611ca",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
+    "flake-root": {
+      "locked": {
+        "lastModified": 1692742795,
+        "narHash": "sha256-f+Y0YhVCIJ06LemO+3Xx00lIcqQxSKJHXT/yk1RTKxw=",
+        "owner": "srid",
+        "repo": "flake-root",
+        "rev": "d9a70d9c7a5fd7f3258ccf48da9335e9b47c3937",
+        "type": "github"
+      },
+      "original": {
+        "owner": "srid",
+        "repo": "flake-root",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1694068030,
-        "narHash": "sha256-q21JdfZjK4XN5QwWTzCHF/G6uuZtwASNW9/ZBaak65M=",
+        "lastModified": 1695962284,
+        "narHash": "sha256-vygWW+zz/5NHWpH7nIfNFlKiJChp6kVRXkzAcPK08hY=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "9e26139b45147aadd25ab7ab3bc4a93d6d5e94e7",
+        "rev": "cdd726e1deb44c031ee8975528d6b283ed8cf021",
         "type": "github"
       },
       "original": {
@@ -28,9 +61,29 @@
         "type": "github"
       }
     },
+    "nixpkgs-lib": {
+      "locked": {
+        "dir": "lib",
+        "lastModified": 1693471703,
+        "narHash": "sha256-0l03ZBL8P1P6z8MaSDS/MvuU8E75rVxe5eE1N6gxeTo=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "3e52e76b70d5508f3cec70b882a29199f4d1ee85",
+        "type": "github"
+      },
+      "original": {
+        "dir": "lib",
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
     "root": {
       "inputs": {
         "flake": "flake",
+        "flake-parts": "flake-parts",
+        "flake-root": "flake-root",
         "nixpkgs": "nixpkgs",
         "systems": "systems",
         "treefmt-nix": "treefmt-nix"
@@ -57,11 +110,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1693817438,
-        "narHash": "sha256-fg3+n4Ky1gCzDtPm0MomMTFw0YkH05Y8ojy5t7bkfHg=",
+        "lastModified": 1695822946,
+        "narHash": "sha256-IQU3fYo0H+oGlqX5YrgZU3VRhbt2Oqe6KmslQKUO4II=",
         "owner": "numtide",
         "repo": "treefmt-nix",
-        "rev": "b8d3a059f5487d6767d07c3716386753e3132d9f",
+        "rev": "720bd006d855b08e60664e4683ccddb7a9ff614a",
         "type": "github"
       },
       "original": {
diff --git a/dev/flake.nix b/dev/flake.nix
index 00c9fb7..db55fe5 100644
--- a/dev/flake.nix
+++ b/dev/flake.nix
@@ -8,28 +8,32 @@
 
     treefmt-nix.url = "github:numtide/treefmt-nix";
     treefmt-nix.inputs.nixpkgs.follows = "nixpkgs";
+
+    flake-parts.url = "github:hercules-ci/flake-parts";
+    flake-root.url = "github:srid/flake-root";
   };
 
-  outputs = {
-    self,
-    nixpkgs,
+  outputs = inputs @ {
+    flake-parts,
     systems,
-    treefmt-nix,
     ...
-  }: let
-    # Small tool to iterate over each systems
-    eachSystem = f: nixpkgs.lib.genAttrs (import systems) (system: f nixpkgs.legacyPackages.${system});
-
-    # Eval the treefmt modules from ./treefmt.nix
-    treefmtEval = eachSystem (pkgs: treefmt-nix.lib.evalModule pkgs ./treefmt.nix);
-  in {
-    # for `nix fmt`
-    formatter = eachSystem (pkgs: treefmtEval.${pkgs.system}.config.build.wrapper);
-    # for `nix flake check`
-    checks = eachSystem (pkgs: {
-      formatting = treefmtEval.${pkgs.sytem}.config.build.check self;
+  }:
+    flake-parts.lib.mkFlake {inherit inputs;} ({self, ...}: {
+      flake = {
+        inherit (inputs.flake) nixosModules overlays;
+      };
+      debug = true;
+      systems = import systems;
+      imports = [
+        ./treefmt.nix
+        ./updater/module.nix
+      ];
+      perSystem = {pkgs, ...}: {
+        packages = let
+          nvPkgs = (pkgs.extend self.overlays.default).nvidiaPackages;
+        in {driver = nvPkgs.driver.test;};
+      };
     });
-  };
 
   /*
 
diff --git a/dev/treefmt.nix b/dev/treefmt.nix
index 912e794..a3c5f4b 100644
--- a/dev/treefmt.nix
+++ b/dev/treefmt.nix
@@ -1,9 +1,30 @@
-{pkgs, ...}: {
-  projectRootFile = ".git/config";
-  programs.alejandra.enable = true;
-  programs.black.enable = true;
-  programs.isort = {
-    enable = true;
-    profile = "black";
+{
+  lib,
+  inputs,
+  ...
+}: {
+  imports = [
+    inputs.treefmt-nix.flakeModule
+  ];
+
+  perSystem = {
+    pkgs,
+    config,
+    ...
+  }: {
+    treefmt = {
+      inherit (config.flake-root) projectRootFile;
+
+      # Nix
+      programs.alejandra.enable = true;
+      programs.statix.enable = true;
+
+      # Python
+      programs.black.enable = true;
+      programs.isort = {
+        enable = true;
+        profile = "black";
+      };
+    };
   };
 }
diff --git a/dev/updater/module.nix b/dev/updater/module.nix
new file mode 100644
index 0000000..b7f204d
--- /dev/null
+++ b/dev/updater/module.nix
@@ -0,0 +1,103 @@
+{inputs, ...}: {
+  imports = [
+    inputs.flake-root.flakeModule
+  ];
+
+  perSystem = {
+    pkgs,
+    config,
+    ...
+  }: {
+    flake-root.projectRootFile = "pkgs/overlay.nix";
+
+    devShells.update = let
+      inherit (pkgs) lib python3 formats;
+
+      pytools = python3.withPackages (ps: [
+        ps.nvchecker
+        ps.lxml
+      ]);
+
+      extra_sources = lib.fileset.toSource {
+        root = ./.;
+        fileset = ./nvchecker_source;
+      };
+
+      configFormat = formats.toml {};
+      configFile = configFormat.generate "nvchecker.toml" {
+        "__config__" = {
+          "oldver" = "\${FLAKE_ROOT}/pkgs/refs.json";
+          #"newver" = "\${FLAKE_ROOT}/dev/current-versions.json";
+        };
+        "driver.vulkan-dev" = {
+          source = "htmlparser";
+          prefix = "Linux ";
+          include_regex = "^Linux [.0-9]+$";
+          url = "https://developer.nvidia.com/vulkan-driver";
+          xpath = ''//*[@id="content"]/div/section/h3'';
+        };
+        "driver.display" = {
+          source = "unix_drivers";
+          known = lib.mapAttrsToList (match: data:
+            {
+              inherit match;
+            }
+            // data) {
+            "Production Branch Version" = {
+              maturity = "long-lived-branch-release";
+            };
+            "New Feature Branch Version" = {};
+            "Beta Version" = {
+              maturity = "beta";
+            };
+            "Legacy GPU version (470.xx series)" = {
+              branch = "R470_00";
+            };
+            "Legacy GPU version (390.xx series)" = {
+              branch = "R390_00";
+            };
+            "Legacy GPU version (340.xx series)" = {
+              branch = "R340_00";
+            };
+            "Legacy GPU version (304.xx series)" = {
+              branch = "R304_00";
+            };
+            "Legacy GPU Version (71.86.xx series)" = {
+              branch = "L7160";
+            };
+            "Legacy GPU Version (96.43.xx series)" = {
+              branch = "L9622";
+            };
+            "Legacy GPU Version (173.14.xx series)" = {
+              branch = "R173_14";
+            };
+          };
+        };
+        "driver.tesla" = {
+          source = "tesla_releases";
+          url = "https://docs.nvidia.com/datacenter/tesla/drivers/releases.json";
+          from_pattern = ''(?:[^-]+-)*(.+)'';
+          to_pattern = ''\1'';
+        };
+      };
+    in
+      pkgs.mkShell {
+        packages = [pytools pkgs.jq];
+
+        inputsFrom = [config.flake-root.devShell];
+
+        env = {
+          PYTHONPATH = toString extra_sources;
+          NVCHECKER_CONFIG = toString configFile;
+        };
+
+        shellHook = ''
+          export SCRATCHDIR=$(mktemp -d)
+
+          nvchecker -c ''${NVCHECKER_CONFIG}
+
+          exit
+        '';
+      };
+  };
+}
diff --git a/dev/updater/nvchecker_source/tesla_releases.py b/dev/updater/nvchecker_source/tesla_releases.py
new file mode 100644
index 0000000..b69ee2e
--- /dev/null
+++ b/dev/updater/nvchecker_source/tesla_releases.py
@@ -0,0 +1,27 @@
+import asyncio
+
+from nvchecker.api import AsyncCache, BaseWorker, RawResult
+
+
+class Worker(BaseWorker):
+    async def run(self) -> None:
+        self.cache = AsyncCache()
+        await asyncio.gather(
+            *[self._run_entry(name, entry) for (name, entry) in self.tasks]
+        )
+
+    async def _run_entry(self, name, entry):
+        async with self.task_sem:
+            data = await self.cache.get_json(entry["url"])
+            for branch, data in data.items():
+                versions = [
+                    f"{r['release_date']}-{r['release_version']}"
+                    for r in data["driver_info"]
+                ]
+                await self.result_q.put(
+                    RawResult(
+                        f"{name}.r{branch}",
+                        versions,
+                        entry,
+                    )
+                )
diff --git a/dev/updater/nvchecker_source/unix_drivers.py b/dev/updater/nvchecker_source/unix_drivers.py
new file mode 100644
index 0000000..08fca28
--- /dev/null
+++ b/dev/updater/nvchecker_source/unix_drivers.py
@@ -0,0 +1,61 @@
+import re
+
+from nvchecker.api import BaseWorker, RawResult, session
+
+PATTERN = re.compile(rb"Latest (?P<label>[^:]+)[^>]+>\s*(?P<version>[^<]+)</a>")
+
+
+class Worker(BaseWorker):
+    async def get_data(self, url):
+        for match in PATTERN.finditer(res.body):
+            yield match.groupdict()
+
+    async def get_unix_results(self, url):
+        results = {}
+        res = await session.get(url)
+
+        for match in PATTERN.finditer(res.body):
+            label = match["label"].lower()
+            versions = results.get(label) or set()
+            versions.add(match["version"].decode("UTF-8"))
+            if label not in results:
+                results[label] = versions
+
+        return results
+
+    def match_label(self, label: str, known_entries):
+        for known in known_entries:
+            if known["match"].lower() in label:
+                return (
+                    known.get("branch", "current"),
+                    known.get("maturity", "official"),
+                )
+
+        return (None, None)
+
+    async def run(self) -> None:
+        results = None
+        async with self.task_sem:
+            results = await self.get_unix_results(
+                "https://www.nvidia.com/en-us/drivers/unix/"
+            )
+
+        for name, entry in self.tasks:
+            known_entries = entry.get("known")
+
+            async with self.task_sem:
+                for label, versions in results.items():
+                    label_str = label.decode("UTF-8")
+                    (branch, maturity) = self.match_label(label_str, known_entries)
+
+                    new_name = f"{name}.unknown.{label_str}"
+                    if branch:
+                        new_name = f"{name}.{branch}.{maturity}"
+
+                    await self.result_q.put(
+                        RawResult(
+                            new_name,
+                            list(versions),
+                            entry,
+                        )
+                    )
diff --git a/flake.nix b/flake.nix
index 0b04344..8c5b6c1 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1,5 +1,16 @@
 {
   description = "nvidia.nix flake";
 
-  outputs = {self}: {};
+  outputs = {self}: {
+    overlays.default = import ./pkgs/overlay.nix;
+
+    modules.nixos = import ./nixos;
+
+    nixosModules = self.modules.nixos;
+
+    nixci.dev = {
+      dir = "./dev";
+      overrideInputs.flake = ./.;
+    };
+  };
 }
diff --git a/nixos/default.nix b/nixos/default.nix
new file mode 100644
index 0000000..3e5bcd3
--- /dev/null
+++ b/nixos/default.nix
@@ -0,0 +1,3 @@
+{
+  nvidia-driver-legacy = ./nvidia/legacy.nix;
+}
diff --git a/nixos/nvidia/legacy.nix b/nixos/nvidia/legacy.nix
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/nixos/nvidia/legacy.nix
@@ -0,0 +1 @@
+{}
diff --git a/pkgs/nvidia-driver/components.nix b/pkgs/nvidia-driver/components.nix
new file mode 100644
index 0000000..b14b337
--- /dev/null
+++ b/pkgs/nvidia-driver/components.nix
@@ -0,0 +1,84 @@
+{lib}: let
+  kernel_source_profile = {
+    test,
+    meta ? {},
+    ...
+  }: {
+    test = t:
+      t.all [
+        (test t)
+        (t.type t.startsWith [
+          "KERNEL_MODULE_"
+          "UVM_MODULE_"
+          "DKMS_CONF"
+        ])
+      ];
+
+    meta =
+      {
+        # kernel sources distributed by nvidia include precompiled object files.
+        sourceProvenance = with lib.sourceTypes; [fromSource binaryNativeCode];
+      }
+      // meta;
+  };
+
+  dylib_profile = {
+    pname,
+    test ? t: t.filePath t.basename t.startsWith pname,
+    meta ? {},
+    ...
+  }: {
+    inherit test;
+    meta =
+      meta
+      // {
+        sourceProvenance = with lib.sourceTypes; (meta.sourceProvenance or []) ++ [binaryNativeCode];
+      };
+  };
+in {
+  egl_glvnd_icd = {
+    test = t: t.type t.eq "GLVND_EGL_ICD_JSON";
+  };
+
+  egl_platform_gbm = {
+    test = t: t.filePath t.contains "_gbm";
+  };
+
+  egl_platform_wayland = {
+    test = t: t.filePath t.contains "_wayland";
+  };
+
+  firmware = {
+    test = t: t.module t.eq "gsp";
+
+    meta = {
+      sourceProvenance = with lib.sourceTypes; [binaryFirmware];
+      license = lib.licenses.unfreeRedistributableFirmware;
+    };
+  };
+
+  html-docs = {
+    test = t: t.path t.eq "NVIDIA_GLX-1.0/html";
+  };
+
+  kmod-open = {
+    test = t: t.filePath t.startsWith "kernel-open/";
+  };
+
+  kmod-unfree = {
+    test = t: t.filePath t.startsWith ''\($header[0].kernel_module_build_dir)/'';
+    profile = kernel_source_profile;
+  };
+
+  libcuda = {
+    profile = dylib_profile;
+  };
+
+  test = {
+    test = t: t.literal "error";
+  };
+
+  test2 = {
+    test = t: "error";
+  };
+}
diff --git a/pkgs/nvidia-driver/default.nix b/pkgs/nvidia-driver/default.nix
new file mode 100644
index 0000000..515eb79
--- /dev/null
+++ b/pkgs/nvidia-driver/default.nix
@@ -0,0 +1,30 @@
+{
+  lib,
+  buildPackages,
+  fetchurl,
+  writeText,
+  linkFarm,
+}: let
+  components = let
+    evalComponent = pname: {profile ? lib.const {}, ...} @ src:
+      (builtins.removeAttrs src ["profile"]) // (profile ({inherit pname;} // src));
+  in
+    lib.mapAttrs evalComponent (import ./components.nix {inherit lib;});
+  mkRunfilePackageSet = buildPackages.callPackage ./nvidia-installer {
+    # TODO: inject components data
+  };
+in {
+  test = mkRunfilePackageSet {
+    runfile = fetchurl {
+      passthru = {
+        version = "450.216.04";
+      };
+      url = "https://us.download.nvidia.com/tesla/450.216.04/NVIDIA-Linux-x86_64-450.216.04.run";
+      hash = "sha256-B+CrLBBnRqXpC0xY+VMLHuIYLWx6VdnsPYDRmC3oKAE=";
+    };
+  };
+
+  components = linkFarm "nvidia-report" {
+    "final-components.nix" = writeText "final-components.nix" (lib.generators.toPretty {} components);
+  };
+}
diff --git a/pkgs/nvidia-driver/nvidia-installer/default.nix b/pkgs/nvidia-driver/nvidia-installer/default.nix
new file mode 100644
index 0000000..809b992
--- /dev/null
+++ b/pkgs/nvidia-driver/nvidia-installer/default.nix
@@ -0,0 +1,33 @@
+{
+  lib,
+  runCommand,
+  python3,
+  jq,
+  libarchive,
+}: let
+  extractRunfile = src @ {
+    version,
+    meta ? {},
+    ...
+  }:
+    runCommand "nvidia-source-${version}" {
+      inherit src version meta;
+
+      nativeBuildInputs = [libarchive];
+
+      # Ensure we don't need to keep the tarball around
+      disallowedReferences = [src];
+    } ''
+      skip=$(sed 's/^skip=//; t; d' $src)
+
+      mkdir -p $out
+      tail -n +$skip $src | bsdtar xvf - -C $out
+    '';
+in
+  {
+    runfile ? null,
+    src ? extractRunfile runfile,
+    version ? src.version,
+    meta ? src.meta,
+  }:
+    src
diff --git a/nvidia-driver/nvidia-installer/parse-manifest.py b/pkgs/nvidia-driver/nvidia-installer/parse-manifest.py
similarity index 100%
rename from nvidia-driver/nvidia-installer/parse-manifest.py
rename to pkgs/nvidia-driver/nvidia-installer/parse-manifest.py
diff --git a/pkgs/overlay.nix b/pkgs/overlay.nix
new file mode 100644
index 0000000..00acd76
--- /dev/null
+++ b/pkgs/overlay.nix
@@ -0,0 +1,5 @@
+final: prev: {
+  nvidiaPackages = final.lib.makeScope final.newScope (self: {
+    driver = self.callPackage ./nvidia-driver {};
+  });
+}
diff --git a/pkgs/kmod.nix b/pkgs_old/kmod.nix
similarity index 100%
rename from pkgs/kmod.nix
rename to pkgs_old/kmod.nix
diff --git a/pkgs_old/nvidia-driver/components.nix b/pkgs_old/nvidia-driver/components.nix
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/pkgs_old/nvidia-driver/components.nix
@@ -0,0 +1 @@
+{}
diff --git a/nvidia-driver/default.nix b/pkgs_old/nvidia-driver/default.nix
similarity index 100%
rename from nvidia-driver/default.nix
rename to pkgs_old/nvidia-driver/default.nix
diff --git a/nvidia-driver/hashes.json b/pkgs_old/nvidia-driver/hashes.json
similarity index 100%
rename from nvidia-driver/hashes.json
rename to pkgs_old/nvidia-driver/hashes.json
diff --git a/nvidia-driver/nvidia-installer/components.nix b/pkgs_old/nvidia-driver/nvidia-installer/components.nix
similarity index 100%
rename from nvidia-driver/nvidia-installer/components.nix
rename to pkgs_old/nvidia-driver/nvidia-installer/components.nix
diff --git a/nvidia-driver/nvidia-installer/default.nix b/pkgs_old/nvidia-driver/nvidia-installer/default.nix
similarity index 99%
rename from nvidia-driver/nvidia-installer/default.nix
rename to pkgs_old/nvidia-driver/nvidia-installer/default.nix
index 59c3ac8..ba631b6 100644
--- a/nvidia-driver/nvidia-installer/default.nix
+++ b/pkgs_old/nvidia-driver/nvidia-installer/default.nix
@@ -204,7 +204,7 @@
         (removeAttrs src.meta ["sourceProvenance"])
         // meta
         // {
-          broken = !(availability.${pname});
+          broken = !availability.${pname};
         };
       allowedReferences = [];
       succeedOnFailure = true;
diff --git a/pkgs_old/nvidia-driver/nvidia-installer/parse-manifest.py b/pkgs_old/nvidia-driver/nvidia-installer/parse-manifest.py
new file mode 100755
index 0000000..cd76fdb
--- /dev/null
+++ b/pkgs_old/nvidia-driver/nvidia-installer/parse-manifest.py
@@ -0,0 +1,329 @@
+import argparse
+import json
+import sys
+from collections import deque
+from dataclasses import asdict, dataclass
+from pathlib import PurePosixPath
+from typing import Any, Callable, Generic, Iterable, Iterator, Optional, TextIO, TypeVar
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+class FlippableDeque(Generic[T]):
+    _handlers: list[tuple[int, Callable[[deque[T]], T]]] = [
+        (0, deque[T].popleft),
+        (-1, deque[T].pop),
+    ]
+
+    def __init__(self, it: Iterable[T]) -> None:
+        self._data = deque(it)
+        self._flipped = False
+
+    def __len__(self):
+        return len(self._data)
+
+    def __repr__(self) -> str:
+        return repr(self._data)
+
+    def _current_handler(self):
+        return self._handlers[int(self._flipped)]
+
+    def flip(self) -> None:
+        self._flipped = not self._flipped
+
+    def peek(self) -> T:
+        (index, _) = self._current_handler()
+        return self._data[index]
+
+    def pop(self) -> T:
+        (_, pop) = self._current_handler()
+        return pop(self._data)
+
+    def pop_if(self, test: Callable[[T], R]) -> Optional[R]:
+        result = None
+
+        if len(self):
+            result = test(self.peek())
+
+        if result is not None:
+            self.pop()
+
+        return result
+
+
+def to_relative_path(p: PurePosixPath) -> PurePosixPath:
+    return p.relative_to(p.root)
+
+
+@dataclass
+class ManifestHeader:
+    """nvidia-installer manifest header"""
+
+    # a description string
+    description: str
+    # a version string
+    version: str
+    # the kernel module file name
+    # NOTE: has been removed from nvidia-installer for quite a while
+    kernel_module_file: Optional[PurePosixPath]
+    # the kernel interface file name
+    kernel_interface_file: Optional[PurePosixPath]
+    # the list of kernel modules
+    kernel_module_names: list[str]
+    # a whitespace-separated list of module names that should be
+    #  removed before installing a new kernel module
+    module_names_to_uninstall: list[str]
+    # a whitespace-separated list of kernel module filenames that
+    #  should be uninstalled before installing a new kernel module
+    module_files_to_uninstall: list[PurePosixPath]
+    # kernel module build directory
+    kernel_module_build_dir: PurePosixPath
+    # directory containing precompiled kernel interfaces
+    precompiled_kernel_dir: PurePosixPath
+
+    @classmethod
+    def parse_header(cls, source: Iterator[str]) -> "ManifestHeader":
+        def to_path_list(line: str) -> Iterable[PurePosixPath]:
+            return map(PurePosixPath, line.split())
+
+        description = next(source)
+        version = next(source)
+        kernel_module_file = None
+        kernel_interface_file = next(to_path_list(next(source)), None)
+
+        # at some point manifests stopped including the module filename,
+        #  can be detected by checking the 4th line for an object file extension
+        tmp = next(source)
+        if tmp.endswith(".o"):
+            kernel_module_file = kernel_interface_file
+            kernel_interface_file = next(to_path_list(tmp), None)
+            tmp = next(source)
+        kernel_module_names = tmp.split()
+
+        module_names_to_uninstall = next(source).split()
+        module_files_to_uninstall = list(to_path_list(next(source)))
+        kernel_module_build_dir = next(to_path_list(next(source)))
+        precompiled_kernel_dir = next(to_path_list(next(source)))
+
+        return cls(
+            description=description,
+            version=version,
+            kernel_module_file=kernel_module_file,
+            kernel_interface_file=kernel_interface_file,
+            kernel_module_names=kernel_module_names,
+            module_names_to_uninstall=module_names_to_uninstall,
+            module_files_to_uninstall=module_files_to_uninstall,
+            kernel_module_build_dir=kernel_module_build_dir,
+            precompiled_kernel_dir=precompiled_kernel_dir,
+        )
+
+
+@dataclass
+class ManifestEntry:
+    file_path: PurePosixPath
+    mode: str
+    type: str
+
+    path: PurePosixPath
+    ln_target: Optional[PurePosixPath]
+
+    architecture: Optional[str]
+    tls_class: Optional[str]
+    glvnd_variant: Optional[str]
+    module: Optional[str]
+
+    @staticmethod
+    def match_enum(*values: str) -> Callable[[str], Optional[str]]:
+        """checks if the input is one of the given values,
+        returning the value if true"""
+
+        def matcher(token: str):
+            if token in values:
+                return token
+
+        return matcher
+
+    @staticmethod
+    def match_tag(tag: str) -> Callable[[str], Optional[str]]:
+        """checks if the input has the form "{tag}:{str}",
+        returns {str} if it matches"""
+
+        def matcher(token: str):
+            parts = token.split(":", 2)
+            if parts[0] == tag and len(parts) == 2:
+                return parts[1]
+
+        return matcher
+
+    @classmethod
+    def parse_entry(cls, raw_entry: str) -> "ManifestEntry":
+        q = FlippableDeque(raw_entry.split())
+
+        # a filename (relative to the cwd)
+        file_path = PurePosixPath(q.pop())
+        # an octal value describing the permissions
+        mode = q.pop()
+        # a flag describing the file type
+        type = q.pop()
+
+        # flags whether it concerns a native or 32-bit executable
+        architecture = q.pop_if(cls.match_enum("NATIVE", "COMPAT32"))
+        # kernel TLS implementations
+        tls_class = q.pop_if(cls.match_enum("CLASSIC", "NEW"))
+
+        # the following items are more consistently parsed back-to-front
+        q.flip()
+        module = q.pop_if(cls.match_tag("MODULE"))
+        # on builds that ship both, ambiguates native and glvnd implementations
+        glvnd_variant = q.pop_if(cls.match_enum("GLVND", "NON_GLVND"))
+
+        ln_target = None
+        if type == "SYSTEMD_UNIT_SYMLINK":
+            # manifest doesnt actually include a symlink target
+            #  but since it involves .requires directory links
+            #  we can safely link to the parent directory
+            # NOTE: actually a bug and memory leak in the nvidia-installer
+            ln_target = PurePosixPath("..") / file_path.name
+        elif mode == "0000":
+            # technically speaking a regular file can have a mode of 0000
+            #  but that doesnt make sense for the nvidia installer to do
+            ln_target = PurePosixPath(q.pop())
+
+        q.flip()
+
+        inherit_path_depth = q.pop_if(cls.match_tag("INHERIT_PATH_DEPTH"))
+        if inherit_path_depth is not None:
+            path = PurePosixPath(*file_path.parent.parts[int(inherit_path_depth) :])
+        elif len(q):
+            # make sure the path is relative
+            path = to_relative_path(PurePosixPath(q.pop()))
+        else:
+            path = PurePosixPath(".")
+
+        assert not len(q), f"unhandled data: {q}"
+
+        return cls(
+            file_path=file_path,
+            mode=mode,
+            type=type,
+            architecture=architecture,
+            tls_class=tls_class,
+            module=module,
+            glvnd_variant=glvnd_variant,
+            ln_target=ln_target,
+            path=path,
+        )
+
+
+@dataclass
+class InstallableEntry:
+    raw_entry: str
+    entry: ManifestEntry
+
+
+def read_manifest(
+    source: TextIO,
+) -> tuple[ManifestHeader, Iterable[InstallableEntry]]:
+    def remove_known_prefixes(
+        path: PurePosixPath, prefixes: list[str]
+    ) -> tuple[PurePosixPath, Optional[str]]:
+        for prefix in prefixes:
+            if path.is_relative_to(prefix):
+                return (path.relative_to(prefix), prefix)
+        return (path, None)
+
+    def patch_entry(entry: ManifestEntry, legacy_kernel_dir: PurePosixPath) -> None:
+        # Patch output directory for kernel sources, keeping the directory structure
+        #  pre build-390, where INHERIT_PATH_DEPTH was added for this problem
+        if entry.file_path.is_relative_to(legacy_kernel_dir) and not len(
+            entry.path.parts
+        ):
+            entry.path = entry.file_path.relative_to(legacy_kernel_dir).parent
+
+        # ancient legacy builds have non-consistent types:
+        # example from 1.0-6106: OPENGL_SYMLINK_NEW_TLS_32
+        type = entry.type.removesuffix("_32")
+        if type.endswith("_TLS"):
+            type_segments = type.split("_")
+            type_segments[0] = "TLS"
+            # patch type and tls variant
+            entry.tls_class = type_segments[-2]
+            entry.type = "_".join(type_segments[:-2])
+
+        # some ancient builds dont set the target directory for opengl headers
+        if type == "OPENGL_HEADER":
+            entry.path = PurePosixPath("GL")
+
+        (new_path, popped) = remove_known_prefixes(
+            entry.path,
+            [
+                # ancient builds embed FHS into manifest paths
+                "share/doc/",
+                "lib64/",
+                "lib/",
+            ],
+        )
+
+        entry.path = new_path
+
+        # if we need to remove lib64/ or lib/, the
+        #   architecture isn't specified
+        if popped and entry.architecture is None:
+            entry.architecture = {"lib64/": "NATIVE", "lib/": "COMPAT32"}.get(
+                popped, None
+            )
+
+    source = map(str.rstrip, source)
+    header = ManifestHeader.parse_header(source)
+
+    def iter() -> Iterable[InstallableEntry]:
+        for raw_entry in source:
+            try:
+                entry = ManifestEntry.parse_entry(raw_entry)
+                # patch some inconsistencies in manifest data...
+                patch_entry(entry, header.kernel_module_build_dir)
+                yield InstallableEntry(raw_entry, entry)
+            except Exception as ex:
+                raise ValueError(f"unexpected entry: {raw_entry}") from ex
+
+    return header, iter()
+
+
+class PathEncoder(json.JSONEncoder):
+    def default(self, o: Any) -> Any:
+        if isinstance(o, PurePosixPath):
+            return o.as_posix()
+        return super().default(o)
+
+
+def process_manifest(
+    manifestSource: TextIO, entrySink: TextIO, headerSink: TextIO
+) -> None:
+    (header, entries) = read_manifest(manifestSource)
+
+    # write out header data
+    json.dump(asdict(header), fp=headerSink, cls=PathEncoder)
+    headerSink.flush()
+
+    # write manifest entries
+    for entry in entries:
+        json.dump(asdict(entry), fp=entrySink, cls=PathEncoder)
+        entrySink.write("\n")
+    entrySink.flush()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--entries", type=argparse.FileType("w"), default=sys.stdout)
+    parser.add_argument("--header", type=argparse.FileType("w"), default=sys.stderr)
+    parser.add_argument(
+        "manifest", nargs="?", type=argparse.FileType("r"), default=sys.stdin
+    )
+    args = parser.parse_args()
+
+    process_manifest(args.manifest, args.entries, args.header)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nvidia-driver/refs.json b/pkgs_old/nvidia-driver/refs.json
similarity index 100%
rename from nvidia-driver/refs.json
rename to pkgs_old/nvidia-driver/refs.json
diff --git a/nvidia-driver/refs/get-hash.sh b/pkgs_old/nvidia-driver/refs/get-hash.sh
similarity index 100%
rename from nvidia-driver/refs/get-hash.sh
rename to pkgs_old/nvidia-driver/refs/get-hash.sh
diff --git a/nvidia-driver/refs/tesla.jq b/pkgs_old/nvidia-driver/refs/tesla.jq
similarity index 100%
rename from nvidia-driver/refs/tesla.jq
rename to pkgs_old/nvidia-driver/refs/tesla.jq
diff --git a/nvidia-driver/refs/tesla.json b/pkgs_old/nvidia-driver/refs/tesla.json
similarity index 100%
rename from nvidia-driver/refs/tesla.json
rename to pkgs_old/nvidia-driver/refs/tesla.json
diff --git a/nvidia-driver/refs/versions.jq b/pkgs_old/nvidia-driver/refs/versions.jq
similarity index 100%
rename from nvidia-driver/refs/versions.jq
rename to pkgs_old/nvidia-driver/refs/versions.jq
diff --git a/nvidia-driver/refs/versions.json b/pkgs_old/nvidia-driver/refs/versions.json
similarity index 100%
rename from nvidia-driver/refs/versions.json
rename to pkgs_old/nvidia-driver/refs/versions.json
diff --git a/nvidia-driver/refs/vulkan-dev.jq b/pkgs_old/nvidia-driver/refs/vulkan-dev.jq
similarity index 100%
rename from nvidia-driver/refs/vulkan-dev.jq
rename to pkgs_old/nvidia-driver/refs/vulkan-dev.jq
diff --git a/nvidia-driver/refs/vulkan-dev.json b/pkgs_old/nvidia-driver/refs/vulkan-dev.json
similarity index 100%
rename from nvidia-driver/refs/vulkan-dev.json
rename to pkgs_old/nvidia-driver/refs/vulkan-dev.json
diff --git a/pkgs/nvidia-settings.nix b/pkgs_old/nvidia-settings.nix
similarity index 100%
rename from pkgs/nvidia-settings.nix
rename to pkgs_old/nvidia-settings.nix
diff --git a/pkgs/vulkan-samples.nix b/pkgs_old/vulkan-samples.nix
similarity index 100%
rename from pkgs/vulkan-samples.nix
rename to pkgs_old/vulkan-samples.nix