doctrine/default.nix

@@ -1,16 +1,12 @@
 {
-  lib ? pkgs.lib,
   pkgs,
-  prefix ? "trivium",
+  namespace,
-  namespace ? null,
 }: let
-  doctrine =
+  doctrine = {
-    {
+    lib = import ./lib {inherit lib pkgs doctrine;};
-      lib = import ./lib {inherit lib pkgs doctrine;};
+    prefix = "trivium";
-      inherit namespace prefix;
+    inherit namespace;
-    }
+  };
-    // lib.optionalAttrs (pkgs != null) {
+  inherit (pkgs) lib;
-      inherit pkgs;
-    };
 in
   doctrine

doctrine/lib/default.nix

@@ -13,11 +13,8 @@
 
   closeLib = close {inherit lib;};
   closeFull = close {inherit lib pkgs doctrine;};
-in
+in {
-  {
+  inherit close;
-    inherit close;
+  importAll = closeLib ./import-all.nix;
-    importAll = closeLib ./import-all.nix;
+  mkModule = closeFull ./mk-module.nix;
-  }
+}
-  // lib.optionalAttrs (doctrine.namespace != null) {
-    mkModule = closeFull ./mk-module.nix;
-  }

doctrine/lib/mk-module.nix

@@ -11,17 +11,14 @@
   requires ? [],
   prefix ? doctrine.prefix,
   namespace ? doctrine.namespace,
-  passthru ? {},
 }: let
-  optionsSet = import options (passthru
+  optionsSet = import options {
-    // {
+    inherit config lib pkgs cfg name doctrine;
-      inherit config lib pkgs cfg name doctrine;
+  };
-    });
 
-  configSet = import configFiles.${namespace} (passthru
+  configSet = import configFiles.${namespace} {
-    // {
+    inherit config lib pkgs doctrine cfg;
-      inherit config lib pkgs doctrine cfg;
+  };
-    });
 
   configFiles = lib.filterAttrs (k: v: v != null) {
     inherit sys hm;

flake.nix

@@ -16,24 +16,15 @@
         "${namespace}" = builtins.removeAttrs overlayPkgs ["override"];
       }
       // (overlayPkgs.override or {});
-
-    doctrineNoPkgs = self.lib.mkDoctrine {
-      lib = nixpkgs.lib;
-      pkgs = null;
-    };
   in
-    flake-utils.lib.eachDefaultSystem (system: let
+    flake-utils.lib.eachDefaultSystem (system: {
-      pkgs = import nixpkgs {inherit system;};
+      formatter = (import nixpkgs {inherit system;}).alejandra;
-    in {
-      formatter = pkgs.alejandra;
 
       packages =
         (import nixpkgs {
           inherit system;
-          overlays = [(mapOverlayOverride doctrineNoPkgs.prefix (import ./pkgs))];
+          overlays = [(mapOverlayOverride "local" (import ./pkgs))];
-        }).${
+        }).local;
-          doctrineNoPkgs.prefix
-        };
     })
     // {
       templates = let
@@ -48,37 +39,33 @@
       };
 
       overlays = let
-        overlay = mapOverlayOverride doctrineNoPkgs.prefix (import ./pkgs);
+        overlay = mapOverlayOverride "trivium" (import ./pkgs);
       in {
         default = overlay;
-        ${doctrineNoPkgs.prefix} = overlay;
+        trivium = overlay;
       };
 
       homeManagerModules.default = ./modules;
       nixosModules.default = ./modules;
 
       lib = {
-        mkDoctrine = import ./doctrine;
-
         mkSystemFlake = {
           flakes,
           system,
-          doctrinePrefix ? null,
           formatter ? "alejandra",
-          paths ? {},
+          localOverlayPath ? /. + "${flakes.self}" + /pkgs,
+          nixpkgsConfigPath ? localOverlayPath + /config,
+          nixosSourcePath ? /. + "${flakes.self}" + /sys,
+          nixosPlatformsPath ?
+            if nixosSourcePath != null
+            then nixosSourcePath + /platform
+            else null,
+          hmSourcePath ? /. + "${flakes.self}" + /home,
+          hmPlatformsPath ?
+            if hmSourcePath != null
+            then hmSourcePath + /platform
+            else null,
         }: let
-          mkDoctrine = args:
-            self.lib.mkDoctrine
-            (args
-              // optionalAttrs (doctrinePrefix != null) {
-                prefix = doctrinePrefix;
-              });
-
-          doctrineNoPkgs = mkDoctrine {
-            lib = nixpkgs.lib;
-            pkgs = null;
-          };
-
           optionalFlake = name:
             if flakes ? "${name}"
             then flakes.${name}
@@ -87,7 +74,7 @@
           requireFlake = name:
             if flakes ? "${name}"
             then flakes.${name}
-            else throw "Required flake input '${name}' is missing";
+            else throw "Required flake input '${name}' is required but was not provided";
 
           nur = optionalFlake "nur";
           nixpkgs = requireFlake "nixpkgs";
@@ -98,21 +85,13 @@
             then requireFlake "home-manager"
             else null;
 
-          pathFromSelf = path: builtins.toPath "${flakes.self}" + "/${path}";
-
-          localOverlayPath = pathFromSelf paths.localOverlay;
-          nixpkgsConfigPath = pathFromSelf paths.nixpkgsConfig;
-          nixosSourcePath = pathFromSelf paths.nixosSource;
-          nixosPlatformsPath = pathFromSelf paths.nixosPlatforms;
-          hmSourcePath = pathFromSelf paths.hmSource;
-          hmPlatformsPath = pathFromSelf paths.hmPlatforms;
-
           pkgs = importPkgs nixpkgs;
 
           importPkgs = flake:
             import flake ({
                 inherit system;
 
+                config = import ./pkgs/config nixpkgs.lib;
                 overlays = let
                   conditions = [
                     {
@@ -121,7 +100,7 @@
                     }
                     # NB: Preserve the relative order
                     {
-                      overlay = self.overlays.default;
+                      overlay = self.overlays.trivium;
                       condition = true;
                     }
                     {
@@ -132,87 +111,87 @@
                 in
                   builtins.map (cond: cond.overlay) (builtins.filter (cond: cond.condition) conditions);
               }
-              // optionalAttrs (paths ? nixpkgsConfig) {
+              // (
-                config = import nixpkgsConfigPath {inherit (nixpkgs) lib;};
+                if nixpkgsConfigPath != null
-              });
+                then {
+                  config = import nixpkgsConfigPath {inherit (nixpkgs) lib;};
+                }
+                else {}
+              ));
 
-          inherit (pkgs) lib;
+          inherit (pkgs.trivium.lib) importAll;
-          inherit (nixpkgs.lib) optionalAttrs; # Prevents infinite recursion
-          inherit (doctrineNoPkgs) prefix;
-          inherit (doctrineNoPkgs.lib) importAll;
         in
-          {
+          with pkgs.lib;
-            formatter.${system} =
+            {
-              if formatter == "alejandra"
+              formatter.${system} =
-              then pkgs.alejandra
+                if formatter == "alejandra"
-              else if formatter == "nixpkgs-fmt"
+                then pkgs.alejandra
-              then pkgs.nixpkgs-fmt
+                else if formatter == "nixpkgs-fmt"
-              else throw "Unknown formatter: '${formatter}'";
+                then pkgs.nixpkgs-fmt
+                else throw "Unknown formatter: '${formatter}'";
 
-            packages.${system} = pkgs.${prefix};
+              packages.${system} = pkgs.local;
 
-            overlays.default = final: prev: let
+              overlays.default = final: prev: let
-              overlay =
+                overlay =
-                if paths ? localOverlay
+                  if localOverlayPath != null
-                then import localOverlayPath
+                  then import localOverlayPath
-                else (final: prev: {});
+                  else (final: prev: {});
-            in
+              in
-              mapOverlayOverride prefix overlay final prev
+                mapOverlayOverride "local" overlay final prev
-              // optionalAttrs (unstable != null) {
+                // optionalAttrs (unstable != null) {
-                unstable = importPkgs unstable;
+                  unstable = importPkgs unstable;
-              };
-          }
-          // optionalAttrs (paths ? nixosSource) {
-            nixosConfigurations = let
-              nixosSystem = {modules}:
-                lib.makeOverridable nixpkgs.lib.nixosSystem {
-                  inherit modules pkgs system;
-
-                  specialArgs = {
-                    inherit flakes;
-
-                    doctrine = mkDoctrine {
-                      inherit pkgs;
-                      namespace = "sys";
-                    };
-                  };
                 };
+            }
+            // optionalAttrs (nixosSourcePath != null) {
+              nixosConfigurations = let
+                nixosSystem = {modules}:
+                  makeOverridable nixpkgs.lib.nixosSystem {
+                    inherit modules pkgs system;
 
-              hostConfig = platform:
+                    specialArgs = {
-                nixosSystem {
+                      inherit flakes;
-                  modules = [
-                    self.nixosModules.default
-                    nixosSourcePath
-                    platform
-                  ];
-                };
-            in
-              lib.mapAttrs (_: hostConfig) (importAll {root = nixosPlatformsPath;});
-          }
-          // optionalAttrs (paths ? hmSource) {
-            homeConfigurations = let
-              home = name: platform:
-                home-manager.lib.homeManagerConfiguration {
-                  inherit pkgs;
-
-                  extraSpecialArgs = {
-                    inherit flakes;
-
-                    doctrine = mkDoctrine {
-                      inherit pkgs;
-                      namespace = "hm";
                     };
                   };
 
-                  modules = [
+                hostConfig = platform:
-                    self.homeManagerModules.default
+                  nixosSystem {
-                    hmSourcePath
+                    modules = [
-                    platform
+                      self.nixosModules.default
-                  ];
+                      nixosSourcePath
+                      platform
+                    ];
+                  };
+              in
+                mapAttrs (_: hostConfig) (importAll {root = nixosPlatformsPath;});
+            }
+            // optionalAttrs (hmSourcePath != null) {
+              homeConfigurations = let
+                registry = {...}: {
+                  config.nix.registry =
+                    mapAttrs
+                    (_: value: {flake = value;})
+                    flakes;
                 };
-            in
+
-              lib.mapAttrs home (importAll {root = hmPlatformsPath;});
+                home = name: platform:
-          };
+                  home-manager.lib.homeManagerConfiguration {
+                    inherit pkgs;
+
+                    extraSpecialArgs = {
+                      inherit flakes;
+                    };
+
+                    modules = [
+                      self.homeManagerModules.default
+                      hmSourcePath
+                      platform
+                      registry
+                    ];
+                  };
+              in
+                mapAttrs home (importAll {root = hmPlatformsPath;});
+            };
       };
     };
 }

modules/nix-registry/default.nix

@@ -1,16 +0,0 @@
-{
-  config,
-  lib,
-  pkgs,
-  doctrine,
-  flakes,
-  ...
-}:
-doctrine.lib.mkModule {
-  inherit config;
-  name = "nix-registry";
-  hm = ./hm.nix;
-  options = ./options.nix;
-
-  passthru = {inherit flakes;};
-}

modules/nix-registry/hm.nix

@@ -1,23 +0,0 @@
-{
-  pkgs,
-  lib,
-  cfg,
-  flakes,
-  ...
-}: let
-  registryName = name:
-    if name == "self"
-    then cfg.renameSelf
-    else name;
-
-  registryFilter = {
-    nixpkgs = true;
-    unstable = true;
-    self = cfg.renameSelf != null;
-  };
-in {
-  nix.registry =
-    lib.mapAttrs'
-    (name: value: lib.nameValuePair (registryName name) {flake = value;})
-    (lib.filterAttrs (name: _: registryFilter.${name} or cfg.allInputs) flakes);
-}

modules/nix-registry/options.nix

@@ -1,19 +0,0 @@
-{lib, ...}:
-with lib.types; {
-  hm = {
-    allInputs = mkOption {
-      type = bool;
-      default = default;
-      description = ''
-        Include all flake inputs. If false, only 'nixpkgs' and 'unstable'
-        (if available) will be added to the flake registry by default.
-      '';
-    };
-
-    renameSelf = mkOption {
-      type = nullOr str;
-      default = "self";
-      description = "Registry name to use for the 'self' input";
-    };
-  };
-}