Update n-e-j

Not required anymore :3

.gitignore

@@ -0,0 +1,2 @@
+result
+result-*

LICENSE

@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
+OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,79 @@
+# Lix NixOS module
+
+See the [official installation guide][install-guide] for details on usage of
+release versions.
+
+[install-guide]: https://lix.systems/install/
+
+See the [beta guide][beta-guide] for a setup guide on how to use HEAD:
+
+[beta-guide]: https://wiki.lix.systems/link/1
+
+## What does this do?
+
+This is an overlay wrapped in a NixOS module that will replace CppNix with Lix
+in nixpkgs. This is useful so that `nixos-rebuild`, `nix-direnv` and similar
+will use Lix.
+
+Optionally, it can build Lix from source.
+
+## Versioning with Lix
+
+The version of this overlay should match the major Lix version, *and* if
+running HEAD, it should be the latest available version of the overlay.
+Changes breaking the overlay are shamelessly done on HEAD, and we expect people
+doing such changes to have prepared corresponding fix commits to make to the
+overlay immediately after submitting their changes. If your build randomly
+broke when updating HEAD, try updating your overlay.
+
+The version of Lix pinned in this flake's `flake.lock` is a version of Lix
+that is expected to work, however if running HEAD, it can be assumed to work
+with HEAD as well if both `lix-nixos-module` and `lix` are the latest version.
+
+## Common pitfalls
+
+Various flake frameworks such as flake-parts and snowfall (and possibly Colmena
+in the future if they do a similar optimization) manage overlays separately
+from NixOS, since they provide `pkgs` pre-imported to NixOS. This saves a
+couple of seconds of evaluation time and resources, but it means that the NixOS
+option `nixpkgs.overlays` **is completely ignored** on these frameworks.
+
+If you are using such a framework, add `overlays.default` to the overlays list
+for said framework.
+
+## Flake structure and usage
+
+The flake here has two inputs of note:
+- `nixpkgs`, *which is unused for most people*. It is purely used for `checks`
+  in developing `lix-nixos-module` itself.
+
+  The installation instructions make it `follows` to make `flake.lock` less
+  confusing, but it is nonetheless unused.
+- `lix`, which determines the version of Lix to do source builds for, if doing
+  source builds.
+
+These are the most relevant outputs for most people:
+
+- `nixosModules.lixFromNixpkgs` - uses Lix from nixpkgs and installs the
+  overlay to use Lix on a NixOS system. This is only useful for a stable
+  version of Lix, and cannot be used for running HEAD.
+- `nixosModules.default` - uses Lix from source and installs the overlay to use
+  Lix on a NixOS system.
+- `overlays.lixFromNixpkgs` - overlay to use Lix from nixpkgs in place of Nix.
+- `overlays.default` - overlay to use Lix from source in place of Nix.
+
+## Non-flake usage
+
+Import `module.nix` or `overlay.nix` as desired, with the arguments `lix`
+(derivation-like attribute set with the Lix sources, or `null` to use Lix from
+nixpkgs) and `versionSuffix` (optional string).
+
+It's desirable to also include a `versionSuffix` like the following while
+building HEAD from source, to have `nix --version` include date and commit
+information. To get such metadata, it depends on which pinning system is in
+use, but `builtins.fetchGit` will provide the necessary metadata for the
+following to work:
+
+```
+versionSuffix = "pre${builtins.substring 0 8 lix.lastModifiedDate}-${lix.shortRev or lix.dirtyShortRev}";
+```

flake.lock

@@ -5,11 +5,11 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1709126324,
-        "narHash": "sha256-q6EQdSeUZOG26WelxqkmR7kArjgWCdw5sfJVHPH/7j8=",
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "d465f4819400de7c8d874d50b982301f28a84605",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
         "type": "github"
       },
       "original": {
@@ -18,28 +18,42 @@
         "type": "github"
       }
     },
+    "flakey-profile": {
+      "locked": {
+        "lastModified": 1712898590,
+        "narHash": "sha256-FhGIEU93VHAChKEXx905TSiPZKga69bWl1VB37FK//I=",
+        "owner": "lf-",
+        "repo": "flakey-profile",
+        "rev": "243c903fd8eadc0f63d205665a92d4df91d42d9d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "lf-",
+        "repo": "flakey-profile",
+        "type": "github"
+      }
+    },
     "lix": {
+      "flake": false,
       "locked": {
-        "lastModified": 1709811453,
-        "narHash": "sha256-UOyTAdUAJv80w3s6rrgYB5tQjp43u5Zp2dlM94uud04=",
-        "ref": "refs/heads/main",
-        "rev": "8a268359b06471b463a8f3fc46c83a1fced8ab75",
-        "revCount": 15077,
-        "type": "git",
-        "url": "ssh://gerrit.lix.systems:2022/lix"
+        "lastModified": 1731683711,
+        "narHash": "sha256-bq21I1EjXJa/s5Rra9J9ot2NkPCnI0F5uNPurwYLdpE=",
+        "rev": "c859d03013712b349d82ee6223948d6d03e63a8d",
+        "type": "tarball",
+        "url": "https://git.lix.systems/api/v1/repos/lix-project/lix/archive/c859d03013712b349d82ee6223948d6d03e63a8d.tar.gz?rev=c859d03013712b349d82ee6223948d6d03e63a8d"
       },
       "original": {
-        "type": "git",
-        "url": "ssh://gerrit.lix.systems:2022/lix"
+        "type": "tarball",
+        "url": "https://git.lix.systems/lix-project/lix/archive/main.tar.gz"
       }
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1709703039,
-        "narHash": "sha256-6hqgQ8OK6gsMu1VtcGKBxKQInRLHtzulDo9Z5jxHEFY=",
+        "lastModified": 1731676054,
+        "narHash": "sha256-OZiZ3m8SCMfh3B6bfGC/Bm4x3qc1m2SVEAlkV6iY7Yg=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "9df3e30ce24fd28c7b3e2de0d986769db5d6225d",
+        "rev": "5e4fbfb6b3de1aa2872b76d49fafc942626e2add",
         "type": "github"
       },
       "original": {
@@ -52,6 +66,7 @@
     "root": {
       "inputs": {
         "flake-utils": "flake-utils",
+        "flakey-profile": "flakey-profile",
         "lix": "lix",
         "nixpkgs": "nixpkgs"
       }

flake.nix

@@ -1,25 +1,66 @@
 {
-  # fixme: use the forgejo address
   inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
   inputs.lix = {
-    url = "git+ssh://gerrit.lix.systems:2022/lix";
+    url = "https://git.lix.systems/lix-project/lix/archive/main.tar.gz";
     flake = false;
   };
   inputs.flake-utils.url = "github:numtide/flake-utils";
+  inputs.flakey-profile.url = "github:lf-/flakey-profile";
 
-  outputs = { self, nixpkgs, lix, flake-utils }: {
-    nixosModules.default = import ./module.nix { inherit lix; };
-    overlays.default = import ./overlay.nix { inherit lix; };
+  outputs = inputs@{ self, nixpkgs, lix, flake-utils, flakey-profile, ... }:
+    let
+      lixVersionJson = builtins.fromJSON (builtins.readFile (lix + "/version.json"));
+      versionSuffix = nixpkgs.lib.optionalString (!lixVersionJson.official_release)
+        "-pre${builtins.substring 0 8 lix.lastModifiedDate}-${lix.shortRev or lix.dirtyShortRev}";
+    in
+    {
+      inherit inputs;
+      nixosModules = {
+        # Use a locally built Lix
+        default = import ./module.nix { inherit lix versionSuffix; };
+
+        # Use Lix from nixpkgs
+        lixFromNixpkgs = import ./module.nix { lix = null; };
+      };
+
+      overlays = {
+        # Use a locally built Lix
+        default = import ./overlay.nix { inherit lix versionSuffix; };
+
+        # Use Lix from nixpkgs
+        lixFromNixpkgs = import ./overlay.nix { lix = null; };
+      };
     } // flake-utils.lib.eachDefaultSystem (system:
       let
         pkgs = import nixpkgs {
           inherit system;
           overlays = [ self.overlays.default ];
         };
+
+        linux64BitSystems = [
+          "x86_64-linux"
+          "aarch64-linux"
+        ];
+
+        inherit (pkgs) lib;
       in
       {
         inherit pkgs;
-      packages.default = pkgs.nixVersions.nix_2_18;
-      packages.nix-doc = pkgs.nix-doc;
+        packages = {
+          default = pkgs.nix;
+          inherit (pkgs) nix-doc nix-eval-jobs;
+        };
+
+        packages.system-profile = import ./system-profile.nix { inherit pkgs flakey-profile; };
+
+        nixosTests = pkgs.recurseIntoAttrs (pkgs.callPackage ./test-nixos.nix { inherit pkgs; lix-module = self.nixosModules.default; });
+
+        checks = {
+          inherit (self.packages.${system}) default nix-eval-jobs;
+          inherit (pkgs) nixos-option nix-doc;
+        } // lib.optionalAttrs (lib.elem system linux64BitSystems) {
+          # wrongMajor intentionally not included here since it is expected to fail
+          inherit (self.nixosTests.${system}) it-builds;
+        };
       });
 }

module.nix

@@ -1,5 +1,5 @@
-{ lix }:
+{ lix, versionSuffix ? "" }:
 { pkgs, config, ... }:
 {
-  nixpkgs.overlays = [ (import ./overlay.nix { inherit lix; }) ];
+  nixpkgs.overlays = [ (import ./overlay.nix { inherit lix versionSuffix; }) ];
 }

overlay.nix

@@ -1,47 +1,127 @@
-{ lix }:
+{ lix, versionSuffix ? "" }:
 final: prev:
 let
-  boehmgc-patched = ((final.boehmgc.override {
-    enableLargeConfig = true;
-  }).overrideAttrs (o: {
-    patches = (o.patches or [ ]) ++ [
-      # for clown reasons this version is newer than the one in lix, we should
-      # fix this and update our nixpkgs pin
-      (prev.path + "/pkgs/tools/package-management/nix/patches/boehmgc-coroutine-sp-fallback.patch")
+  lixPackageFromSource = final.callPackage (lix + "/package.nix") ({
+    inherit versionSuffix;
+    stdenv = final.clangStdenv;
+  });
 
-      # https://github.com/ivmai/bdwgc/pull/586
-      (lix + "/boehmgc-traceable_allocator-public.diff")
+  # These packages should receive CppNix since they may link to it or otherwise
+  # cause problems (or even just silly mass-rebuilds) if we give them Lix
+  overridelist_upstream = [
+    "attic-client"
+    "devenv"
+    "nix-du"
+    "nix-init"
+    "nix-prefetch-git"
+    "nixos-option"
+    "nurl"
+    "prefetch-yarn-deps" # force these onto upstream so we are not regularly rebuilding electron
   ];
-  })
+
+  inherit (prev) lib;
+
+  csi = builtins.fromJSON ''"\u001b"'';
+  orange = "${csi}[35;1m";
+  normal = "${csi}[0m";
+  warning = ''
+    ${orange}warning${normal}: You have the lix overlay included into a nixpkgs import twice,
+    perhaps due to the NixOS module being included twice, or because of using
+    pkgs.nixos and also including it in imports, or perhaps some unknown
+    machinations of a complicated flake library.
+    This is completely harmless since we have no-op'd the second one if you are
+    seeing this message, but it would be a small style improvement to fix
+    it :)
+    P.S. If you had some hack to fix nixos-option build failures in your
+    configuration, that was caused by including an older version of the lix
+    overlay twice, which is now mitigated if you see this message, so you can
+    delete that.
+    P.P.S. This Lix has super catgirl powers.
+  '';
+  wrongMajorWarning = ''
+    ${orange}warning${normal}: This Lix NixOS module is being built against a Lix with a
+    major version (got ${lixPackageToUse.version}) other than the one the
+    module was designed for (expecting ${supportedLixMajor}). Some downstream
+    packages like nix-eval-jobs may be broken by this. Consider using a
+    matching version of the Lix NixOS module to the version of Lix you are
+    using.
+  '';
+
+  maybeWarnDuplicate = x: if final.lix-overlay-present > 1 then builtins.trace warning x else x;
+
+  versionJson = builtins.fromJSON (builtins.readFile ./version.json);
+  supportedLixMajor = lib.versions.majorMinor versionJson.version;
+  lixPackageToUse = if lix != null then lixPackageFromSource else prev.lix;
+  # Especially if using Lix from nixpkgs, it is plausible that the overlay
+  # could be used against the wrong Lix major version and cause confusing build
+  # errors. This is a simple safeguard to put in at least something that might be seen.
+  maybeWarnWrongMajor = x: if !(lib.hasPrefix supportedLixMajor lixPackageToUse.version) then builtins.trace wrongMajorWarning x else x;
+
+  # It is not enough to *just* throw whatever the default nix version is at
+  # anything in the "don't give lix" list, we have to *also* ensure that we
+  # give whatever upstream version as specified in the callPackage invocation.
+  #
+  # Unfortunately I don't think there is any actual way to directly query that,
+  # so we instead do something extremely evil and guess which version it
+  # probably was. This code is not generalizable to arbitrary derivations, so
+  # it will hopefully not make us cry, at least.
+  useCppNixOverlay =
+    lib.genAttrs overridelist_upstream (
+      name:
+      if (lib.functionArgs prev.${name}.override ? "nix") then
+        let
+          # Get the two common inputs of a derivation/package.
+          inputs = prev.${name}.buildInputs ++ prev.${name}.nativeBuildInputs;
+          nixDependency = lib.findFirst
+            (drv: (drv.pname or "") == "nix")
+            final.nixVersions.stable_upstream # default to stable nix if nix is not an input
+            inputs;
+          nixMajor = lib.versions.major (nixDependency.version or "");
+          nixMinor = lib.versions.minor (nixDependency.version or "");
+          nixAttr = "nix_${nixMajor}_${nixMinor}";
+          finalNix = final.nixVersions.${nixAttr};
+        in
+        prev.${name}.override {
+          nix = finalNix;
+        }
+      else prev.${name}
     );
+
+  overlay = useCppNixOverlay // {
+    lix-overlay-present = 1;
+    # used for things that one wouldn't necessarily want to update, but we
+    # nevertheless shove it in the overlay and fixed-point it in case one *does*
+    # want to do that.
+    lix-sources = import ./pins.nix;
+
+    lix = maybeWarnWrongMajor (maybeWarnDuplicate lixPackageToUse);
+
+    nixVersions = prev.nixVersions // {
+      stable = final.lix;
+      stable_upstream = prev.nixVersions.stable;
+    };
+
+    nix-eval-jobs = (prev.nix-eval-jobs.override {
+      # lix
+      nix = final.lix;
+    }).overrideAttrs (old:
+      let src = final.lix-sources.nix-eval-jobs;
+      in {
+        version = "2.92.0-lix-${builtins.substring 0 7 src.rev}";
+
+        # FIXME: should this be patches instead?
+        inherit src;
+
+        mesonBuildType = "debugoptimized";
+
+        ninjaFlags = old.ninjaFlags or [ ] ++ [ "-v" ];
+      }
+    );
+
+    nix-doc = prev.nix-doc.override { withPlugin = false; };
+  };
 in
-{
-  nixVersions = prev.nixVersions // rec {
-    # FIXME: do something less scuffed
-    nix_2_18 = (prev.nixVersions.nix_2_18.override { boehmgc = boehmgc-patched; }).overrideAttrs (old: {
-      src = lix;
-      version = "2.18.3-lix";
-      VERSION_SUFFIX = "-lix";
-
-      patches = [ ];
-    });
-    stable = nix_2_18;
-    nix_2_18_upstream = prev.nixVersions.nix_2_18;
-  };
-
-  # force these onto upstream so we are not regularly rebuilding electron
-  prefetch-yarn-deps = prev.prefetch-yarn-deps.override {
-    nix = final.nixVersions.nix_2_18_upstream;
-  };
-  prefetch-npm-deps = prev.prefetch-npm-deps.override {
-    nix = final.nixVersions.nix_2_18_upstream;
-  };
-  nix-prefetch-git = prev.nix-prefetch-git.override {
-    nix = final.nixVersions.nix_2_18_upstream;
-  };
-
-  nix-doc = prev.nix-doc.overrideAttrs (old: {
-    # for the purposes of nix C++ API for nix-doc, lix is Nix 2.20
-    NIX_CFLAGS_COMPILE = [ "-DNIX_2_20_0" ];
-  });
-}
+# Make the overlay idempotent, since flakes passing nixos modules around by
+  # value and many other things make it way too easy to include the overlay
+  # twice
+if (prev ? lix-overlay-present) then { lix-overlay-present = 2; } else overlay

pins.json

@@ -0,0 +1 @@
+{"nix-eval-jobs": {"kind": "tarball", "rev": "912a9d63319e71ca131e16eea3348145a255db2e", "nar_hash": "sha256-6xMxT2duVMO6fo1AXfTjqh7LW3ZmNiHw6kBaAhweLGo=", "locked_url": "https://git.lix.systems/api/v1/repos/lix-project/nix-eval-jobs/archive/912a9d63319e71ca131e16eea3348145a255db2e.tar.gz?rev=912a9d63319e71ca131e16eea3348145a255db2e", "url": "https://git.lix.systems/lix-project/nix-eval-jobs/archive/main.tar.gz"}}

pins.nix

@@ -0,0 +1,26 @@
+# this is a custom pinning tool, written because npins doesn't have narHash
+# compatible output for git inputs, and also doesn't support the Nix immutable
+# tarball protocol
+let
+  pins = builtins.fromJSON (builtins.readFile ./pins.json);
+  fetchPin = args@{ kind, ... }:
+    if kind == "git" then
+      builtins.fetchGit
+        {
+          name = "source";
+          url = args.url;
+          ref = args.ref;
+          rev = args.rev;
+          narHash = args.nar_hash;
+        }
+    else if kind == "tarball" then
+      args // {
+        outPath = builtins.fetchTarball {
+          name = "source";
+          url = args.locked_url;
+          sha256 = args.nar_hash;
+        };
+      }
+    else builtins.throw "unsupported input type ${kind}";
+in
+builtins.mapAttrs (_: fetchPin) pins

system-profile.nix

@@ -0,0 +1,10 @@
+{ pkgs, flakey-profile }:
+flakey-profile.lib.mkProfile {
+  inherit pkgs;
+  paths = with pkgs; [
+    cacert
+    nix
+  ];
+  name = "system-profile";
+  extraSwitchArgs = [ "--profile" "/nix/var/nix/profiles/default" ];
+}

test-nixos.nix

@@ -0,0 +1,32 @@
+{ pkgs, nixos, lix-module }:
+let
+  pkgs' = import pkgs.path {
+    inherit (pkgs) system;
+  };
+  configs = {
+    it-builds = nixos ({ ... }: {
+      imports = [ lix-module ];
+      documentation.enable = false;
+      fileSystems."/".device = "ignore-root-device";
+      boot.loader.grub.enable = false;
+      system.stateVersion = "24.05";
+    });
+
+    # Intentionally provoke the wrong major version.
+    # Does assume that the module is one major ahead of the release; the main
+    # purpose here is a manual testing fixture.
+    wrongMajor = pkgs'.nixos ({ ... }: {
+      imports = [ (import ./module.nix { lix = null; }) ];
+      documentation.enable = false;
+      fileSystems."/".device = "ignore-root-device";
+      boot.loader.grub.enable = false;
+      system.stateVersion = "24.05";
+    });
+  };
+in
+{
+  inherit configs;
+
+  it-builds = configs.it-builds.config.system.build.toplevel;
+  wrongMajor = configs.wrongMajor.config.system.build.toplevel;
+}

update_pins.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env nix-shell
+#!nix-shell -i python3 -p 'python3.withPackages (ps: [ ps.requests ])'
+"""
+Updates pins in this repo to their latest version.
+
+This is a custom pinning tool, written because npins doesn't have narHash
+compatible output for git inputs (it is not SRI), and also doesn't support the
+Nix immutable tarball protocol which we would like to use when we become public.
+"""
+import subprocess
+import tempfile
+from pathlib import Path
+import re
+import dataclasses
+from typing import Literal
+import urllib.parse
+import json
+
+
+# https://stackoverflow.com/a/51286749
+class DataclassJSONEncoder(json.JSONEncoder):
+
+    def default(self, o):
+        if dataclasses.is_dataclass(o):
+            return dataclasses.asdict(o)
+        return super().default(o)
+
+
+@dataclasses.dataclass
+class PinSerialized:
+    kind: str
+    rev: str | None
+    nar_hash: str
+
+
+@dataclasses.dataclass
+class GitPinSerialized(PinSerialized):
+    kind: Literal['git']
+    url: str
+    rev: str
+    ref: str
+
+
+@dataclasses.dataclass
+class TarballPinSerialized(PinSerialized):
+    kind: Literal['tarball']
+    locked_url: str
+    url: str
+
+
+class PinSpec:
+
+    def do_pin(self) -> dict[str, str]:
+        raise ValueError('unimplemented')
+
+
+@dataclasses.dataclass
+class GitPinSpec(PinSpec):
+    url: str
+    branch: str
+
+    def do_pin(self) -> GitPinSerialized:
+        return lock_git(self.url, self.branch)
+
+
+@dataclasses.dataclass
+class TarballPinSpec(PinSpec):
+    url: str
+
+    def do_pin(self) -> TarballPinSerialized:
+        return lock_tarball(self.url)
+
+
+@dataclasses.dataclass
+class LinkHeader:
+    url: str
+    rev: str | None
+
+
+LINK_HEADER_RE = re.compile(r'<(?P<url>.*)>; rel="immutable"')
+
+
+def parse_link_header(header) -> LinkHeader | None:
+    matched = LINK_HEADER_RE.match(header)
+    if not matched:
+        return None
+
+    url = matched.group('url')
+    parsed_url = urllib.parse.urlparse(url)
+    parsed_qs = urllib.parse.parse_qs(parsed_url.query)
+
+    return LinkHeader(url=url, rev=next(iter(parsed_qs.get('rev', [])), None))
+
+
+def lock_tarball(url) -> TarballPinSerialized:
+    """
+    Prefetches a tarball using the Nix immutable tarball protocol
+    """
+    import requests
+    resp = requests.get(url)
+    with tempfile.TemporaryDirectory() as td:
+        td = Path(td)
+        proc = subprocess.Popen(["tar", "-C", td, "-xvzf", "-"],
+                                stdin=subprocess.PIPE)
+        assert proc.stdin
+        for chunk in resp.iter_content(64 * 1024):
+            proc.stdin.write(chunk)
+        proc.stdin.close()
+        if proc.wait() != 0:
+            raise RuntimeError("untarring failed")
+
+        children = list(td.iterdir())
+        # FIXME: allow different tarball structures
+        assert len(children) == 1
+
+        child = children[0].rename(children[0].parent.joinpath('source'))
+        sri_hash = subprocess.check_output(
+            ["nix-hash", "--type", "sha256", "--sri", child]).decode().strip()
+        path = subprocess.check_output(
+            ["nix-store", "--add-fixed", "--recursive", "sha256",
+             child]).decode().strip()
+
+    link_info = parse_link_header(resp.headers['Link'])
+
+    print(sri_hash, path)
+    return TarballPinSerialized(kind='tarball',
+                                nar_hash=sri_hash,
+                                locked_url=link_info.url if link_info else url,
+                                rev=link_info.rev if link_info else None,
+                                url=url)
+
+
+def lock_git(url, branch) -> GitPinSerialized:
+    url_escaped = json.dumps(url)
+    ref_escaped = json.dumps(branch)
+    data = json.loads(
+        subprocess.check_output([
+            "nix", "eval", "--impure", "--json", "--expr",
+            f"builtins.removeAttrs (builtins.fetchGit {{ url = {url_escaped}; ref = {ref_escaped}; }}) [ \"outPath\" ]"
+        ]).strip())
+    return GitPinSerialized(kind='git',
+                            url=url,
+                            rev=data['rev'],
+                            ref=branch,
+                            nar_hash=data['narHash'])
+
+
+PINS = {
+    'nix-eval-jobs':
+    TarballPinSpec('https://git.lix.systems/lix-project/nix-eval-jobs/archive/main.tar.gz')
+}
+
+
+def main():
+    output = {}
+    for (name, pin) in PINS.items():
+        output[name] = pin.do_pin()
+
+    print(output)
+    with open('pins.json', 'w') as fh:
+        json.dump(output, fh, cls=DataclassJSONEncoder)
+
+
+if __name__ == '__main__':
+    main()

version.json

@@ -0,0 +1,3 @@
+{
+    "version": "2.92.0-dev"
+}