[HACK] simplify out requests arg to make test pass

`mapAttrs'` takes two args rather than a set, whereas if only the val
changes `mapAttrs (_: v: ...)` should do

default.nix

@@ -9,6 +9,8 @@ let
     git-hooks
     gitignore
     ;
+  inherit (import sources.flake-inputs) import-flake;
+  inputs = (import-flake { src = ./.; }).inputs;
   inherit (pkgs) lib;
   pre-commit-check =
     (import "${git-hooks}/nix" {
@@ -67,6 +69,7 @@ in
   # re-export inputs so they can be overridden granularly
   # (they can't be accessed from the outside any other way)
   inherit
+    inputs
     sources
     system
     pkgs

deployment/data-model-test.nix

@@ -1,45 +1,196 @@
 let
-  inherit (import ../default.nix { }) pkgs;
+  inherit (import ../default.nix { }) pkgs inputs;
   inherit (pkgs) lib;
+  inherit (lib) mkOption types;
   eval =
     module:
     (lib.evalModules {
+      specialArgs = {
+        inherit inputs;
+        # to be passed to nixops4Deployment
+        resourceProviderSystem = builtins.currentSystem;
+      };
       modules = [
         module
         ./data-model.nix
       ];
     }).config;
+  nixops4Deployment = import ./deployment.nix { inherit lib inputs; };
 in
 {
   test-eval = {
     expr =
       let
-        example = eval {
+        fediversity = eval (
-          runtime-environments.bar.nixos = {
+          { config, ... }:
-            module =
+          {
-              { ... }:
+            _class = "fediversity-settings";
-              {
+            config = {
-                system.stateVersion = "25.05";
+              resources.nixos-configuration = {
+                description = "An entire NixOS configuration";
+                request =
+                  { ... }:
+                  {
+                    _class = "fediversity-resource-request";
+                    options.config = mkOption {
+                      description = "Any options from NixOS";
+                    };
+                  };
+
+                policy =
+                  { config, ... }:
+                  {
+                    _class = "fediversity-resource-policy";
+
+                    options = {
+                      extra-config = mkOption {
+                        description = "Any options from NixOS";
+                      };
+                      apply = mkOption {
+                        type = with types; functionTo raw;
+                        default = requests: lib.mkMerge (requests ++ [ config.extra-config ]);
+                      };
+                    };
+                  };
               };
-          };
+              resources.login-shell = {
-          applications.foo = {
+                _class = "fediversity-resource";
-            module =
+                description = "The operator needs to be able to log into the shell";
-              { pkgs, ... }:
+                request =
-              {
+                  { ... }:
-                environment.systemPackages = [
+                  {
-                  pkgs.hello
+                    _class = "fediversity-resource-request";
-                ];
+                    options = {
+                      wheel = mkOption {
+                        description = "Whether the login user needs root permissions";
+                        type = types.bool;
+                        default = false;
+                      };
+                      packages = mkOption {
+                        description = "Packages that need to be available in the user environment";
+                        type = with types; attrsOf package;
+                      };
+                    };
+                  };
+                policy =
+                  { config, ... }:
+                  {
+                    _class = "fediversity-resource-policy";
+                    options = {
+                      username = mkOption {
+                        description = "Username for the operator";
+                        type = types.str; # TODO: use the proper constraints from NixOS
+                      };
+                      wheel = mkOption {
+                        description = "Whether to allow login with root permissions";
+                        type = types.bool;
+                        default = false;
+                      };
+                      apply = mkOption {
+                        type = with types; functionTo raw; # TODO: splice out the user type from NixOS
+                        default =
+                          requests:
+                          let
+                            # Filter out requests that need wheel if policy doesn't allow it
+                            validRequests = lib.filterAttrs (_name: req: !req.wheel || config.wheel) requests;
+                          in
+                          lib.optionalAttrs (validRequests != { }) {
+                            ${config.username} = {
+                              isNormalUser = true;
+                              packages = with lib; concatMapAttrs (_name: request: attrValues request.packages) validRequests;
+                              extraGroups = lib.optional config.wheel "wheel";
+                            };
+                          };
+                      };
+                    };
+                  };
               };
-          };
+              applications.hello =
-        };
+                { ... }:
+                {
+                  _class = "fediversity-application";
+                  description = ''Command-line tool that will print "Hello, world!" on the terminal'';
+                  module =
+                    { ... }:
+                    {
+                      _class = "fediversity-application-config";
+                      options = {
+                        enable = lib.mkEnableOption "Hello in the shell";
+                      };
+                    };
+                  implementation =
+                    cfg:
+                    lib.optionalAttrs cfg.enable {
+                      _class = "fediversity-application-requirements";
+                      dummy.login-shell.packages.hello = pkgs.hello;
+                    };
+                };
+              environments.single-nixos-vm =
+                { config, ... }:
+                {
+                  _class = "fediversity-environment";
+                  resources.shell.login-shell.username = "operator";
+                  implementation =
+                    { ... }:
+                    # { providers, ... }:
+                    {
+                      # _class = "nixops4Deployment";
+                      # providers = {
+                      #   inherit (inputs.nixops4.modules.nixops4Provider) local;
+                      # };
+                      resources.the-machine = {
+                        _class = "nixops4Resource";
+                        # type = providers.local.exec;
+                        imports = [
+                          inputs.nixops4-nixos.modules.nixops4Resource.nixos
+                        ];
+                        nixos.module =
+                          { ... }:
+                          {
+                            _class = "nixos";
+                            users.users = config.resources.shell.login-shell.apply (
+                              # lib.filterAttrs (_name: value: value ? login-shell) requests
+                              lib.filterAttrs (_name: value: value ? login-shell) { }
+                            );
+                          };
+                      };
+                    };
+                };
+            };
+            options = {
+              example-configuration = mkOption {
+                type = config.configuration;
+                readOnly = true;
+                default = {
+                  _class = "fediversity-configuration";
+                  enable = true;
+                  applications.hello.enable = true;
+                };
+              };
+              example-deployment = mkOption {
+                type = types.submoduleWith {
+                  class = "nixops4Deployment";
+                  modules = [ nixops4Deployment ];
+                };
+                readOnly = true;
+                default = config.environments.single-nixos-vm.deployment config.example-configuration;
+              };
+            };
+          }
+        );
       in
       {
-        has-runtime = lib.isAttrs example.runtime-environments.bar.nixos.module;
+        inherit (fediversity)
-        has-application = lib.isAttrs example.applications.foo.module;
+          example-configuration
+          ;
+        has-deployment = lib.isAttrs fediversity.example-deployment.resources.the-machine;
       };
     expected = {
-      has-runtime = true;
+      example-configuration = {
-      has-application = true;
+        enable = true;
+        applications.hello.enable = true;
+      };
+      has-deployment = true;
     };
   };
 }

deployment/data-model.nix

@@ -1,43 +1,199 @@
 {
   lib,
+  config,
+  inputs,
   ...
 }:
 let
-  inherit (lib) types mkOption;
+  inherit (lib) mkOption types;
+  inherit (lib.types)
+    attrsOf
+    attrTag
+    deferredModuleWith
+    submoduleWith
+    optionType
+    functionTo
+    ;
+
+  functionType = import ./function.nix;
+  application-requirements = {
+    _class = "fediversity-application-requirements";
+    options.resources = mkOption {
+      # TODO: maybe transpose, and group the resources by type instead
+      type = attrsOf (
+        attrTag (lib.mapAttrs (_name: resource: mkOption { type = resource.request; }) config.resources)
+      );
+    };
+  };
+  nixops4Deployment = import ./deployment.nix { inherit lib inputs; };
 in
-with types;
 {
+  _class = "fediversity-settings";
   options = {
-    runtime-environments = mkOption {
+    resources = mkOption {
-      description = "Collection of runtime environments into which applications can be deployed";
+      description = "Collection of deployment resources that can be required by applications and policed by hosting providers";
-      type = attrsOf (attrTag {
+      type = attrsOf (submoduleWith {
-        nixos = mkOption {
+        class = "fediversity-resource";
-          description = "A single NixOS machine";
+        modules = [
-          type = submodule {
+          (
-            options = {
+            { ... }:
-              module = mkOption {
+            {
-                description = "The NixOS module describing the base configuration for that machine";
+              options = {
-                type = deferredModule;
+                description = mkOption {
+                  description = "Description of the resource to help application module authors and hosting providers to work with it";
+                  type = types.str;
+                };
+                request = mkOption {
+                  description = "Options for declaring resource requirements by an application, a description of how the resource is consumed or accessed";
+                  type = deferredModuleWith { staticModules = [ { _class = "fediversity-resource-request"; } ]; };
+                };
+                policy = mkOption {
+                  description = "Options for configuring the resource policy for the hosting provider, a description of how the resource is made available";
+                  type = submoduleWith {
+                    class = "fediversity-resource-policy";
+                    modules = [
+                      {
+                        options.apply = mkOption {
+                          description = "Apply the policy to a request";
+                        };
+                      }
+                    ];
+                  };
+                };
               };
-            };
+            }
-          };
+          )
-        };
+        ];
       });
     };
     applications = mkOption {
       description = "Collection of Fediversity applications";
       type = attrsOf (submoduleWith {
+        class = "fediversity-application";
         modules = [
-          {
+          (application: {
             options = {
+              description = mkOption {
+                description = "Description to be shown in the application overview";
+                type = types.str;
+              };
               module = mkOption {
-                description = "The NixOS module for that application, for configuring that application";
+                description = "Operator-facing configuration options for the application";
-                type = deferredModule;
+                type = deferredModuleWith { staticModules = [ { _class = "fediversity-application-config"; } ]; };
+              };
+              implementation = mkOption {
+                description = "Mapping of application configuration to deployment resources, a description of what an application needs to run";
+                type = application.config.config-mapping.function-type;
+              };
+              resources = mkOption {
+                description = "Compute resources required by an application";
+                type = functionTo application.config.config-mapping.output-type;
+                readOnly = true;
+                default = input: (application.config.implementation input).output;
+              };
+              config-mapping = mkOption {
+                description = "Function type for the mapping from application configuration to required resources";
+                type = submoduleWith {
+                  class = "module-function";
+                  modules = [ functionType ];
+                };
+                readOnly = true;
+                default = {
+                  input-type = application.config.module;
+                  output-type = application-requirements;
+                };
               };
             };
-          }
+          })
         ];
       });
     };
+    environments = mkOption {
+      description = "Run-time environments for Fediversity applications to be deployed to";
+      type = attrsOf (submoduleWith {
+        class = "fediversity-environment";
+        modules = [
+          (environment: {
+            options = {
+              resources = mkOption {
+                description = ''
+                  Resources made available by the hosting provider, and their policies.
+
+                  Setting this is optional, but provides a place to declare that information for programmatic use in the resource mapping.
+                '';
+                # TODO: maybe transpose, and group the resources by type instead
+                type = attrsOf (
+                  attrTag (
+                    lib.mapAttrs (
+                      _name: resource:
+                      mkOption {
+                        type = submoduleWith {
+                          class = "fediversity-resource-policy";
+                          modules = [ resource.policy ];
+                        };
+                      }
+                    ) config.resources
+                  )
+                );
+              };
+              implementation = mkOption {
+                description = "Mapping of resources required by applications to available resources; the result can be deployed";
+                # type = environment.config.resource-mapping.output-type;
+              };
+              resource-mapping = mkOption {
+                description = "Function type for the mapping from resources to a (NixOps4) deployment";
+                type = submoduleWith {
+                  class = "module-function";
+                  modules = [ functionType ];
+                };
+                readOnly = true;
+                default = {
+                  input-type = application-requirements;
+                  output-type = nixops4Deployment;
+                };
+              };
+              deployment = mkOption {
+                description = "Generate a deployment from a configuration";
+                type = functionTo (submoduleWith {
+                  class = "nixops4Deployment";
+                  modules = [ environment.config.resource-mapping.output-type ];
+                });
+                readOnly = true;
+                default = _cfg: environment.config.implementation;
+
+              };
+            };
+          })
+        ];
+      });
+    };
+    configuration = mkOption {
+      description = "Configuration type declaring options to be set by operators";
+      type = optionType;
+      readOnly = true;
+      default = submoduleWith {
+        class = "fediversity-configuration";
+        modules = [
+          {
+            options = {
+              enable = lib.mkEnableOption {
+                description = "your Fediversity configuration";
+              };
+              applications = lib.mapAttrs (
+                _name: application:
+                mkOption {
+                  description = application.description;
+                  type = submoduleWith {
+                    class = "fediversity-application-config";
+                    modules = [ application.module ];
+                  };
+                  default = { };
+                }
+              ) config.applications;
+            };
+          }
+        ];
+      };
+    };
   };
 }

deployment/deployment.nix

@@ -0,0 +1,34 @@
+{
+  lib,
+  # inputs,
+  ...
+}:
+# let
+#   nixops4 = inputs.nixops4.outPath;
+# in
+
+# inputs.nixops4.modules.nixops4Deployment.default
+
+# import inputs.nixops4.modules.nixops4Deployment.default
+
+# resources: import inputs.nixops4.modules.nixops4Deployment.default {
+#   inherit lib config resources;
+#   # config = {
+#   #   type providers provider inputs outputsSkeleton resourceType
+#   # };
+# }
+
+# {
+#   imports = [
+#     "${nixops4}/nix/deployment/providers.nix"
+#     "${nixops4}/nix/deployment/resources.nix"
+#   ];
+# };
+
+# "${nixops4}/nix/deployment/resources.nix"
+
+{
+  options.resources = lib.mkOption {
+    type = lib.types.attrs;
+  };
+}

deployment/function.nix

@@ -0,0 +1,38 @@
+/**
+  Modular function type
+*/
+{ config, lib, ... }:
+let
+  inherit (lib) mkOption types;
+  inherit (types)
+    deferredModule
+    submodule
+    functionTo
+    optionType
+    ;
+in
+{
+  options = {
+    _class = "module-function";
+    input-type = mkOption {
+      type = deferredModule;
+    };
+    output-type = mkOption {
+      type = deferredModule;
+    };
+    function-type = mkOption {
+      type = optionType;
+      readOnly = true;
+      default = functionTo (submodule {
+        options = {
+          input = mkOption {
+            type = submodule config.input-type;
+          };
+          output = mkOption {
+            type = submodule config.output-type;
+          };
+        };
+      });
+    };
+  };
+}