flake: move old let block to config.flake scope

grrr why do people always insist on dumping options into the main block
of the module

flake.nix

@@ -1,3 +1,4 @@
+# vim: set foldmethod=marker:
 {
   description = "NixOS Configuration";
 
@@ -109,454 +110,471 @@
     flake-parts,
     ...
   } @ inputs:
-    flake-parts.lib.mkFlake {inherit inputs;} ({
+    flake-parts.lib.mkFlake {inherit inputs;} (
+      {
         inputs,
         self,
+        config,
+        lib,
         ...
-      } @ flakeArgs: let
+      } @ flakeArgs: {
-        inherit (inputs) nixpkgs nixpkgs-unstable;
+        # flake-parts imports
-        inherit (self) outputs;
+        imports = [
-        # inputs is already defined
+          ./flake
-        lib = nixpkgs.lib;
-        systems = ["x86_64-linux" "aarch64-linux"];
-
-        overlays = let
-          nix-minecraft-patched-overlay = let
-            normal = inputs.nix-minecraft-upstream.overlays.default;
-            quilt = inputs.nix-minecraft.overlays.default;
-          in
-            lib.composeExtensions
-            normal
-            (final: prev: let
-              x = quilt final prev;
-            in {
-              inherit (x) quiltServers quilt-server;
-              minecraftServers = prev.minecraftServers // x.quiltServers;
-            });
-        in [
-          (final: prev: let
-            packages = import ./pkgs {inherit (prev) pkgs;};
-          in {
-            inherit (packages) mopidy-autoplay google-fonts;
-            atool-wrapped = packages.atool;
-          })
-
-          # various temporary fixes that automatically revert
-          self.overlays.mitigations
-
-          # auto backports from nixpkgs unstable
-          self.overlays.backports
-
-          # modpacks (keeps modpack version in sync between hosts so i can reverse
-          # proxy create track map because it's broken)
-          self.overlays.modpacks
-
-          inputs.hyprwm-contrib.overlays.default
-          inputs.rust-overlay.overlays.default
-          inputs.nixfiles-assets.overlays.default
-          nix-minecraft-patched-overlay
         ];
 
-        ### Configuration
+        config = {
-        # My username
+          # flake-parts systems (still uses nix-systems)
-        username = "nullbite";
+          systems = import inputs.systems;
-        # My current timezone for any mobile devices (i.e., my laptop)
-        mobileTimeZone = "Europe/Amsterdam";
 
-        # Variables to be passed to NixOS modules in the vars attrset
+          debug = lib.mkDefault true;
-        vars = {
-          inherit username mobileTimeZone self;
-        };
 
-        # funciton to generate packages for each system
+          flake = let
-        eachSystem = lib.genAttrs (import inputs.systems);
+            # {{{
+            inherit (inputs) nixpkgs nixpkgs-unstable;
+            inherit (self) outputs;
+            # inputs is already defined
+            lib = nixpkgs.lib;
+            systems = ["x86_64-linux" "aarch64-linux"];
 
-        # This function produces a module that adds the home-manager module to the
+            overlays = let
-        # system and configures the given module to the user's Home Manager
+              nix-minecraft-patched-overlay = let
-        # configuration
+                normal = inputs.nix-minecraft-upstream.overlays.default;
-        homeManagerInit = let
+                quilt = inputs.nix-minecraft.overlays.default;
-          _username = username;
+              in
-          _nixpkgs = nixpkgs;
+                lib.composeExtensions
-        in
+                normal
-          {
+                (final: prev: let
-            system,
+                  x = quilt final prev;
-            nixpkgs ? _nixpkgs, # this is so modules can know which flake the system is using
+                in {
-            home-manager ? inputs.home-manager,
+                  inherit (x) quiltServers quilt-server;
-            username ? _username,
+                  minecraftServers = prev.minecraftServers // x.quiltServers;
-            module ? _: {},
+                });
-            rootModule ? (import ./home/root.nix),
+            in [
-            userModules ? {
+              (final: prev: let
-              ${username} = [module];
+                packages = import ./pkgs {inherit (prev) pkgs;};
-              root = [rootModule];
+              in {
-            },
+                inherit (packages) mopidy-autoplay google-fonts;
-            stateVersion,
+                atool-wrapped = packages.atool;
-          }: {
+              })
-            config,
+
-            lib,
+              # various temporary fixes that automatically revert
-            pkgs,
+              self.overlays.mitigations
-            ...
+
-          }: let
+              # auto backports from nixpkgs unstable
-            mapUserModules = lib.attrsets.mapAttrs (user: modules: {...}: {
+              self.overlays.backports
-              imports =
+
-                [
+              # modpacks (keeps modpack version in sync between hosts so i can reverse
-                  ./home
+              # proxy create track map because it's broken)
-                ]
+              self.overlays.modpacks
-                ++ modules;
+
-              config = {
+              inputs.hyprwm-contrib.overlays.default
-                home = {inherit stateVersion;};
+              inputs.rust-overlay.overlays.default
-              };
+              inputs.nixfiles-assets.overlays.default
-            });
+              nix-minecraft-patched-overlay
-            users = mapUserModules userModules;
-          in {
-            imports = [
-              home-manager.nixosModules.home-manager
             ];
 
-            home-manager = {
+            ### Configuration
-              useGlobalPkgs = true;
+            # My username
-              useUserPackages = true;
+            username = "nullbite";
-              backupFileExtension = "hm.bak";
+            # My current timezone for any mobile devices (i.e., my laptop)
-              inherit users;
+            mobileTimeZone = "Europe/Amsterdam";
-              extraSpecialArgs = {
-                inherit inputs outputs vars nixpkgs home-manager;
-              };
-            };
-          };
 
-        # TODO rewrite this so it follows the same wrapper pattern as mkHome
+            # Variables to be passed to NixOS modules in the vars attrset
-        # This function produces a nixosSystem which imports configuration.nix and
+            vars = {
-        # a Home Manager home.nix for the given user from ./hosts/${hostname}/
+              inherit username mobileTimeZone self;
-        mkSystemN = let
-          _username = username;
-          _overlays = overlays;
-        in
-          {
-            nixpkgs ? inputs.nixpkgs,
-            home-manager ? inputs.home-manager,
-            username ? _username,
-            entrypoint ? ./system,
-            modules ? [],
-            stateVersion ? null,
-            config ? {},
-            overlays ? _overlays,
-            system,
-            ...
-          } @ args: let
-            _modules =
-              [entrypoint config]
-              ++ modules
-              ++ [
-                {
-                  nixpkgs.config = {
-                    inherit overlays;
-                    allowUnfree = true;
-                  };
-                }
-              ]
-              ++ lib.optional (args ? stateVersion) {config.system.stateVersion = stateVersion;};
-          in
-            nixpkgs.lib.nixosSystem {
             };
-        mkSystem = let
+
-          _username = username;
+            # funciton to generate packages for each system
-          _overlays = overlays;
+            eachSystem = lib.genAttrs (import inputs.systems);
-          _nixpkgs = nixpkgs;
+
-        in
+            # This function produces a module that adds the home-manager module to the
-          {
+            # system and configures the given module to the user's Home Manager
-            system,
+            # configuration
-            nixpkgs ? _nixpkgs,
+            homeManagerInit = let
-            home-manager ? inputs.home-manager,
+              _username = username;
-            overlays ? _overlays,
+              _nixpkgs = nixpkgs;
-            hostname,
+            in
-            username ? _username,
+              {
-            stateVersion,
+                system,
-            extraModules ? [],
+                nixpkgs ? _nixpkgs, # this is so modules can know which flake the system is using
-          }:
+                home-manager ? inputs.home-manager,
-            nixpkgs.lib.nixosSystem {
+                username ? _username,
-              inherit system;
+                module ? _: {},
-              modules =
+                rootModule ? (import ./home/root.nix),
-                [
+                userModules ? {
-                  ./system
+                  ${username} = [module];
-                  ({
+                  root = [rootModule];
-                      pkgs,
+                },
-                      config,
+                stateVersion,
-                      lib,
+              }: {
-                      ...
+                config,
-                    } @ args: {
+                lib,
-                      # Values for every single system that would not conceivably need
+                pkgs,
-                      # to be made modular
+                ...
-                      system.stateVersion = stateVersion;
+              }: let
-                      nixpkgs = {
+                mapUserModules = lib.attrsets.mapAttrs (user: modules: {...}: {
+                  imports =
+                    [
+                      ./home
+                    ]
+                    ++ modules;
+                  config = {
+                    home = {inherit stateVersion;};
+                  };
+                });
+                users = mapUserModules userModules;
+              in {
+                imports = [
+                  home-manager.nixosModules.home-manager
+                ];
+
+                home-manager = {
+                  useGlobalPkgs = true;
+                  useUserPackages = true;
+                  backupFileExtension = "hm.bak";
+                  inherit users;
+                  extraSpecialArgs = {
+                    inherit inputs outputs vars nixpkgs home-manager;
+                  };
+                };
+              };
+
+            # TODO rewrite this so it follows the same wrapper pattern as mkHome
+            # This function produces a nixosSystem which imports configuration.nix and
+            # a Home Manager home.nix for the given user from ./hosts/${hostname}/
+            mkSystemN = let
+              _username = username;
+              _overlays = overlays;
+            in
+              {
+                nixpkgs ? inputs.nixpkgs,
+                home-manager ? inputs.home-manager,
+                username ? _username,
+                entrypoint ? ./system,
+                modules ? [],
+                stateVersion ? null,
+                config ? {},
+                overlays ? _overlays,
+                system,
+                ...
+              } @ args: let
+                _modules =
+                  [entrypoint config]
+                  ++ modules
+                  ++ [
+                    {
+                      nixpkgs.config = {
                         inherit overlays;
-                        config = {
+                        allowUnfree = true;
-                          # not having the freedom to install unfree programs is unfree
+                      };
+                    }
+                  ]
+                  ++ lib.optional (args ? stateVersion) {config.system.stateVersion = stateVersion;};
+              in
+                nixpkgs.lib.nixosSystem {
+                };
+            mkSystem = let
+              _username = username;
+              _overlays = overlays;
+              _nixpkgs = nixpkgs;
+            in
+              {
+                system,
+                nixpkgs ? _nixpkgs,
+                home-manager ? inputs.home-manager,
+                overlays ? _overlays,
+                hostname,
+                username ? _username,
+                stateVersion,
+                extraModules ? [],
+              }:
+                nixpkgs.lib.nixosSystem {
+                  inherit system;
+                  modules =
+                    [
+                      ./system
+                      ({
+                          pkgs,
+                          config,
+                          lib,
+                          ...
+                        } @ args: {
+                          # Values for every single system that would not conceivably need
+                          # to be made modular
+                          system.stateVersion = stateVersion;
+                          nixpkgs = {
+                            inherit overlays;
+                            config = {
+                              # not having the freedom to install unfree programs is unfree
+                              allowUnfree = true;
+                            };
+                          };
+                          nix.settings.experimental-features = ["nix-command" "flakes"];
+                        })
+                      ./hosts/${hostname}/configuration.nix
+                      (homeManagerInit {
+                        inherit nixpkgs home-manager;
+                        module = import ./hosts/${hostname}/home.nix;
+                        inherit username system stateVersion;
+                      })
+                    ]
+                    ++ extraModules;
+                  specialArgs = {
+                    inherit inputs outputs vars nixpkgs home-manager;
+                  };
+                };
+
+            mkWSLSystem = let
+              _username = username;
+            in
+              {
+                username ? _username,
+                extraModules ? [],
+                ...
+              } @ args: let
+                WSLModule = {...}: {
+                  imports = [
+                    inputs.nix-wsl.nixosModules.wsl
+                  ];
+                  wsl.enable = true;
+                  wsl.defaultUser = username;
+                };
+                override = {extraModules = extraModules ++ [WSLModule];};
+              in
+                mkSystem (args // override);
+
+            mkISOSystem = system:
+              inputs.nixpkgs-unstable.lib.nixosSystem {
+                inherit system;
+                modules = [
+                  "${inputs.nixpkgs-unstable}/nixos/modules/installer/cd-dvd/installation-cd-minimal-new-kernel-no-zfs.nix"
+                  ({
+                    config,
+                    pkgs,
+                    lib,
+                    ...
+                  }: {
+                    environment.systemPackages = with pkgs; [
+                      neovim
+                      gparted
+                    ];
+                  })
+                ];
+              };
+
+            # values to be passed to nixosModules and homeManagerModules wrappers
+            moduleInputs = {
+            };
+
+            # Make a home-manager standalone configuration. This implementation is
+            # better than mkSystem because it extends homeManagerConfiguration.
+            mkHome = let
+              _home-manager = inputs.home-manager;
+              _nixpkgs = inputs.nixpkgs;
+              _username = username;
+            in
+              {
+                home-manager ? _home-manager,
+                nixpkgs ? _nixpkgs,
+                username ? _username,
+                homeDirectory ? "/home/${username}",
+                entrypoint ? ./home/standalone.nix,
+                modules ? [],
+                stateVersion ? null,
+                config ? {},
+                system,
+                ...
+              } @ args: let
+                _modules =
+                  [entrypoint]
+                  ++ modules
+                  ++ [config]
+                  ++ [
+                    {
+                      config = {
+                        home = {
+                          inherit username homeDirectory;
+                        };
+                        nixpkgs.config = {
                           allowUnfree = true;
                         };
                       };
-                      nix.settings.experimental-features = ["nix-command" "flakes"];
+                    }
-                    })
+                  ]
-                  ./hosts/${hostname}/configuration.nix
+                  ++ lib.optional (args ? stateVersion) {config.home.stateVersion = stateVersion;};
-                  (homeManagerInit {
+              in
-                    inherit nixpkgs home-manager;
+                home-manager.lib.homeManagerConfiguration ({
-                    module = import ./hosts/${hostname}/home.nix;
+                    modules = _modules;
-                    inherit username system stateVersion;
+                    pkgs = import nixpkgs {inherit system overlays;};
-                  })
-                ]
-                ++ extraModules;
-              specialArgs = {
-                inherit inputs outputs vars nixpkgs home-manager;
-              };
-            };
 
-        mkWSLSystem = let
+                    extraSpecialArgs = {
-          _username = username;
+                      inherit inputs outputs vars nixpkgs home-manager;
-        in
-          {
-            username ? _username,
-            extraModules ? [],
-            ...
-          } @ args: let
-            WSLModule = {...}: {
-              imports = [
-                inputs.nix-wsl.nixosModules.wsl
-              ];
-              wsl.enable = true;
-              wsl.defaultUser = username;
-            };
-            override = {extraModules = extraModules ++ [WSLModule];};
-          in
-            mkSystem (args // override);
 
-        mkISOSystem = system:
+                      # this is needed because modules don't use the default arg for some reason???
-          inputs.nixpkgs-unstable.lib.nixosSystem {
+                      osConfig = {};
-            inherit system;
-            modules = [
-              "${inputs.nixpkgs-unstable}/nixos/modules/installer/cd-dvd/installation-cd-minimal-new-kernel-no-zfs.nix"
-              ({
-                config,
-                pkgs,
-                lib,
-                ...
-              }: {
-                environment.systemPackages = with pkgs; [
-                  neovim
-                  gparted
-                ];
-              })
-            ];
-          };
-
-        # values to be passed to nixosModules and homeManagerModules wrappers
-        moduleInputs = {
-        };
-
-        # Make a home-manager standalone configuration. This implementation is
-        # better than mkSystem because it extends homeManagerConfiguration.
-        mkHome = let
-          _home-manager = inputs.home-manager;
-          _nixpkgs = inputs.nixpkgs;
-          _username = username;
-        in
-          {
-            home-manager ? _home-manager,
-            nixpkgs ? _nixpkgs,
-            username ? _username,
-            homeDirectory ? "/home/${username}",
-            entrypoint ? ./home/standalone.nix,
-            modules ? [],
-            stateVersion ? null,
-            config ? {},
-            system,
-            ...
-          } @ args: let
-            _modules =
-              [entrypoint]
-              ++ modules
-              ++ [config]
-              ++ [
-                {
-                  config = {
-                    home = {
-                      inherit username homeDirectory;
                     };
-                    nixpkgs.config = {
+                  }
-                      allowUnfree = true;
+                  // builtins.removeAttrs args
-                    };
+                  ["system" "nixpkgs" "home-manager" "modules" "username" "homeDirectory" "stateVersion" "entrypoint" "config"]);
-                  };
+            # }}}
-                }
-              ]
-              ++ lib.optional (args ? stateVersion) {config.home.stateVersion = stateVersion;};
-          in
-            home-manager.lib.homeManagerConfiguration ({
-                modules = _modules;
-                pkgs = import nixpkgs {inherit system overlays;};
-
-                extraSpecialArgs = {
-                  inherit inputs outputs vars nixpkgs home-manager;
-
-                  # this is needed because modules don't use the default arg for some reason???
-                  osConfig = {};
-                };
-              }
-              // builtins.removeAttrs args
-              ["system" "nixpkgs" "home-manager" "modules" "username" "homeDirectory" "stateVersion" "entrypoint" "config"]);
-      in {
-        flake = {
-          # for repl debugging via :lf .
-          inherit inputs vars;
-
-          devShells = eachSystem (system: let
-            pkgs = import nixpkgs-unstable {inherit system;};
           in {
-            ci = pkgs.mkShell {
+            # for repl debugging via :lf .
-              buildInputs = with pkgs; [
+            inherit inputs vars;
-                nix-update
-                nix-fast-build
-              ];
-            };
-            default = pkgs.mkShell {
-              buildInputs = with pkgs; [
-                nix-update
-                inputs.agenix.packages.${system}.default
-              ];
-            };
-          });
 
-          # nix flake modules are meant to be portable so we cannot rely on
+            devShells = eachSystem (system: let
-          # (extraS|s)pecialArgs to pass variables
-          nixosModules = (import ./modules/nixos) moduleInputs;
-          homeManagerModules = (import ./modules/home-manager) moduleInputs;
-          packages = eachSystem (
-            system: let
               pkgs = import nixpkgs-unstable {inherit system;};
-            in
+            in {
-              (
+              ci = pkgs.mkShell {
-                import ./pkgs {inherit pkgs;}
+                buildInputs = with pkgs; [
-              )
+                  nix-update
-              // {
+                  nix-fast-build
-                iso = let
+                ];
-                  isoSystem = mkISOSystem system;
+              };
-                in
+              default = pkgs.mkShell {
-                  isoSystem.config.system.build.isoImage;
+                buildInputs = with pkgs; [
-              }
+                  nix-update
-          );
+                  inputs.agenix.packages.${system}.default
-          apps = eachSystem (system:
+                ];
-            import ./pkgs/apps.nix
+              };
-            {
-              inherit (self.outputs) packages;
-              inherit system;
             });
 
-          overlays = import ./overlays self;
+            # nix flake modules are meant to be portable so we cannot rely on
-
+            # (extraS|s)pecialArgs to pass variables
-          nixosConfigurations = {
+            nixosModules = (import ./modules/nixos) moduleInputs;
-            iso = mkISOSystem "x86_64-linux";
+            homeManagerModules = (import ./modules/home-manager) moduleInputs;
-            slab = mkSystem {
+            packages = eachSystem (
-              nixpkgs = inputs.nixpkgs-unstable;
+              system: let
-              home-manager = inputs.home-manager-unstable;
+                pkgs = import nixpkgs-unstable {inherit system;};
-              system = "x86_64-linux";
+              in
-              hostname = "slab";
+                (
-              stateVersion = "23.11";
+                  import ./pkgs {inherit pkgs;}
-            };
+                )
-
+                // {
-            nullbox = mkSystem {
+                  iso = let
-              nixpkgs = inputs.nixpkgs-unstable;
+                    isoSystem = mkISOSystem system;
-              home-manager = inputs.home-manager-unstable;
+                  in
-              system = "x86_64-linux";
+                    isoSystem.config.system.build.isoImage;
-              hostname = "nullbox";
-              stateVersion = "23.11";
-            };
-
-            nixos-wsl = mkWSLSystem {
-              nixpkgs = inputs.nixpkgs-unstable;
-              home-manager = inputs.home-manager-unstable;
-              system = "x86_64-linux";
-              stateVersion = "23.11";
-              hostname = "nixos-wsl";
-            };
-
-            # for eval testing
-            rpi4-x86_64 = mkSystem {
-              nixpkgs = inputs.nixpkgs-unstable;
-              home-manager = inputs.home-manager-unstable;
-              system = "x86_64-linux";
-              stateVersion = "24.11";
-              hostname = "rpi4";
-              extraModules = [
-                {
-                  nixpkgs.hostPlatform = "x86_64-linux";
                 }
-              ];
+            );
-            };
+            apps = eachSystem (system:
+              import ./pkgs/apps.nix
+              {
+                inherit (self.outputs) packages;
+                inherit system;
+              });
 
-            rpi4 = mkSystem {
+            overlays = import ./overlays self;
-              nixpkgs = inputs.nixpkgs-unstable;
-              home-manager = inputs.home-manager-unstable;
-              system = "aarch64-linux";
-              stateVersion = "24.11";
-              hostname = "rpi4";
-            };
-          }; # end nixosConfigurations
 
-          homeConfigurations = {
+            nixosConfigurations = {
-            # minimal root config
+              iso = mkISOSystem "x86_64-linux";
-            "root@rpi4" = mkHome {
+              slab = mkSystem {
-              system = "aarch64-linux";
+                nixpkgs = inputs.nixpkgs-unstable;
-              stateVersion = "23.11";
+                home-manager = inputs.home-manager-unstable;
-              username = "root";
+                system = "x86_64-linux";
-              homeDirectory = "/root";
+                hostname = "slab";
-              config = {pkgs, ...}: {
+                stateVersion = "23.11";
-                programs.bash.enable = true;
-
-                # update nix system-wide since it's installed via root profile
-                home.packages = with pkgs; [btdu nix];
               };
-              nixpkgs = inputs.nixpkgs-unstable;
-              home-manager = inputs.home-manager-unstable;
-            };
 
-            "nullbite@rpi4" = mkHome {
+              nullbox = mkSystem {
-              system = "aarch64-linux";
+                nixpkgs = inputs.nixpkgs-unstable;
-              stateVersion = "23.11";
+                home-manager = inputs.home-manager-unstable;
-              config = {pkgs, ...}: {
+                system = "x86_64-linux";
-                programs = {
+                hostname = "nullbox";
-                  zsh.enable = false;
+                stateVersion = "23.11";
-                  keychain.enable = false;
+              };
+
+              nixos-wsl = mkWSLSystem {
+                nixpkgs = inputs.nixpkgs-unstable;
+                home-manager = inputs.home-manager-unstable;
+                system = "x86_64-linux";
+                stateVersion = "23.11";
+                hostname = "nixos-wsl";
+              };
+
+              # for eval testing
+              rpi4-x86_64 = mkSystem {
+                nixpkgs = inputs.nixpkgs-unstable;
+                home-manager = inputs.home-manager-unstable;
+                system = "x86_64-linux";
+                stateVersion = "24.11";
+                hostname = "rpi4";
+                extraModules = [
+                  {
+                    nixpkgs.hostPlatform = "x86_64-linux";
+                  }
+                ];
+              };
+
+              rpi4 = mkSystem {
+                nixpkgs = inputs.nixpkgs-unstable;
+                home-manager = inputs.home-manager-unstable;
+                system = "aarch64-linux";
+                stateVersion = "24.11";
+                hostname = "rpi4";
+              };
+            }; # end nixosConfigurations
+
+            homeConfigurations = {
+              # minimal root config
+              "root@rpi4" = mkHome {
+                system = "aarch64-linux";
+                stateVersion = "23.11";
+                username = "root";
+                homeDirectory = "/root";
+                config = {pkgs, ...}: {
+                  programs.bash.enable = true;
+
+                  # update nix system-wide since it's installed via root profile
+                  home.packages = with pkgs; [btdu nix];
                 };
-                home.packages = with pkgs; [btdu];
+                nixpkgs = inputs.nixpkgs-unstable;
+                home-manager = inputs.home-manager-unstable;
+              };
+
+              "nullbite@rpi4" = mkHome {
+                system = "aarch64-linux";
+                stateVersion = "23.11";
+                config = {pkgs, ...}: {
+                  programs = {
+                    zsh.enable = false;
+                    keychain.enable = false;
+                  };
+                  home.packages = with pkgs; [btdu];
+                };
+                nixpkgs = inputs.nixpkgs-unstable;
+                home-manager = inputs.home-manager-unstable;
+              };
+              "deck" = mkHome {
+                system = "x86_64-linux";
+                stateVersion = "23.11";
+                username = "deck";
+                modules = [./users/deck/home.nix];
+                nixpkgs = inputs.nixpkgs-unstable;
+                home-manager = inputs.home-manager-unstable;
+              };
+              "testuser" = mkHome {
+                username = "testuser";
+                system = "x86_64-linux";
+                modules = [./users/testuser/home.nix];
+                stateVersion = "23.11";
+                nixpkgs = inputs.nixpkgs-unstable;
+                home-manager = inputs.home-manager-unstable;
+              };
+              "nix-on-droid" = mkHome {
+                username = "nix-on-droid";
+                homeDirectory = "/data/data/com.termux.nix/files/home";
+                modules = [./users/nix-on-droid/home.nix];
+                system = "aarch64-linux";
+                stateVersion = "23.11";
+                nixpkgs = inputs.nixpkgs-unstable;
+                home-manager = inputs.home-manager-unstable;
               };
-              nixpkgs = inputs.nixpkgs-unstable;
-              home-manager = inputs.home-manager-unstable;
-            };
-            "deck" = mkHome {
-              system = "x86_64-linux";
-              stateVersion = "23.11";
-              username = "deck";
-              modules = [./users/deck/home.nix];
-              nixpkgs = inputs.nixpkgs-unstable;
-              home-manager = inputs.home-manager-unstable;
-            };
-            "testuser" = mkHome {
-              username = "testuser";
-              system = "x86_64-linux";
-              modules = [./users/testuser/home.nix];
-              stateVersion = "23.11";
-              nixpkgs = inputs.nixpkgs-unstable;
-              home-manager = inputs.home-manager-unstable;
-            };
-            "nix-on-droid" = mkHome {
-              username = "nix-on-droid";
-              homeDirectory = "/data/data/com.termux.nix/files/home";
-              modules = [./users/nix-on-droid/home.nix];
-              system = "aarch64-linux";
-              stateVersion = "23.11";
-              nixpkgs = inputs.nixpkgs-unstable;
-              home-manager = inputs.home-manager-unstable;
             };
           };
         };
-        systems = (import inputs.systems);
+      }
-      }); # end outputs
+    ); # end outputs
 }
 # end flake
 

flake/default.nix

@@ -0,0 +1,6 @@
+{ ... }:
+{
+  imports = [
+    ./packages.nix
+  ];
+}

flake/packages.nix

@@ -0,0 +1,2 @@
+{ ... }: {
+}