feat(herdr): enable kitty graphics

docs/dictionary.md

@@ -51,9 +51,9 @@ Use the simplest accurate word when a term is not listed.
 | forge | Git | A web service that hosts Git repositories, pull requests, issues, and code review comments. Use when the exact provider does not matter. |
 | flake | Nix | A Nix project with pinned inputs and declared outputs. Use for the repository-level build unit defined by `flake.nix`. |
 | assembly file | Nix | A Nix file under `flake/` that constructs flake outputs or arguments passed to NixOS modules. |
-| assembly function | Nix | A project function exposed under `flake` because it creates modules, systems, or assembly values. |
+| assembly function | Nix | A project function in `flake/` that creates modules, systems, or output values. |
 | library file | Nix | A Nix file that defines reusable project functions instead of a NixOS module or flake output. |
-| library function | Nix | A pure project function exposed under `flake.util`. |
+| library function | Nix | A pure project function exposed under `util`. |
 | NixOS module | Nix | A Nix file evaluated by `nixosSystem` for a NixOS configuration. |
 | overlay | Nix | A function that modifies a Nix package set by adding or replacing packages. |
 | workspace | Window management | A named or numbered group of windows in a graphical session. Some desktop environments call this a virtual desktop. |

docs/nix.md

@@ -10,8 +10,8 @@ Read this document with `docs/dictionary.md`.
 
 Use `lib` only for the base `nixpkgs.lib` value.
 Do not use `lib` for project functions.
-Use `flake.util` for library functions passed through module arguments.
-Use `flake.mk<Name>` for assembly functions passed through module arguments.
+Use `util` for library functions passed through module arguments.
+Use `flake.mk<Name>` for assembly functions used by flake outputs.
 
 Avoid:
 
@@ -25,39 +25,39 @@ Use:
 
 ```nix
 specialArgs = {
-  inherit flake;
+  inherit util;
 };
 ```
 
-Then call project functions through `flake` inside modules:
+Then call library functions through `util` inside modules:
 
 ```nix
 {
-  flake,
   lib,
+  util,
   ...
 }:
 {
-  networking.networkmanager.unmanaged = [ "interface-name:${flake.util.bridgeName 10}" ];
+  networking.networkmanager.unmanaged = [ "interface-name:${util.bridgeName 10}" ];
 }
 ```
 
 ### Name project function namespaces by role
 
-Put pure project functions under `flake.util`.
-Put functions that create modules, systems, or assembly values under `flake`.
+Put pure project functions under `util`.
+Put functions that create systems or output values under `flake`.
 This keeps data-only functions separate from functions that carry flake context.
 
 Avoid:
 
 ```nix
-flake.util.mkGuest { name = "sample"; }
+util.mkHosts { root = self + "/hosts"; }
 ```
 
 Use:
 
 ```nix
-flake.mkGuest { name = "sample"; }
+flake.mkHosts { root = self + "/hosts"; }
 ```
 
 ## File Placement
@@ -112,15 +112,15 @@ flake/default.nix  # defines mkHost
 Use:
 
 ```text
-flake/default.nix  # imports ./hosts.nix
-flake/hosts.nix    # defines mkHosts
+flake/default.nix  # imports ./host.nix
+flake/host.nix     # defines mkHosts
 ```
 
 ### Keep assembly files focused on one concept
 
 Give each assembly file under `flake/` one top-level concept.
 Keep helper functions private to that file when no other file needs them.
-Export the constructor for the concept when the concept has one.
+Export the constructor for the concept when another assembly file needs it.
 Name that constructor `mk<Concept>`.
 
 Avoid:

flake.lock

@@ -404,6 +404,21 @@
         "type": "github"
       }
     },
+    "monorepo": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2"
+      },
+      "locked": {
+        "lastModified": 1788059616,
+        "narHash": "sha256-HBYT3h0vXRsvmgPOhUW3kgPTkgdl73PEwRTJQ5X48aM=",
+        "path": "/home/alexion/dev",
+        "type": "path"
+      },
+      "original": {
+        "path": "/home/alexion/dev",
+        "type": "path"
+      }
+    },
     "nixos-hardware": {
       "inputs": {
         "nixpkgs": [
@@ -542,8 +557,12 @@
         "firefox-addons": "firefox-addons",
         "gitea-axi": "gitea-axi",
         "home-manager": "home-manager_3",
+        "monorepo": "monorepo",
         "nixos-hardware": "nixos-hardware",
-        "nixpkgs": "nixpkgs_2",
+        "nixpkgs": [
+          "monorepo",
+          "nixpkgs"
+        ],
         "nixpkgs-stable": "nixpkgs-stable",
         "nixpkgs-unstable": "nixpkgs-unstable",
         "nixvim": "nixvim",

flake.nix

@@ -2,8 +2,10 @@
   description = "Alexion's NixOS configuration — one flake for every host";
 
   inputs = {
-    # Base channel.
-    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+    monorepo.url = "path:/home/alexion/dev";
+
+    # Base package set shared with the monorepo.
+    nixpkgs.follows = "monorepo/nixpkgs";
 
     # Fresher packages, reachable per-package as `unstable.<name>`.
     nixpkgs-unstable.url = "github:nixos/nixpkgs/nixpkgs-unstable";
@@ -76,13 +78,9 @@
     { self, nixpkgs, ... }@inputs:
     let
       inherit (nixpkgs) lib;
-      flake = import ./flake { inherit lib inputs self; };
     in
     {
-      # Every host under hosts/ is discovered and built.
-      nixosConfigurations = flake.mkHosts {
-        root = self + "/hosts";
-      };
+      inherit (import ./flake { inherit lib inputs self; }) nixosConfigurations;
 
       # A project shell for agent-local resources that should travel with this
       # checkout rather than the operator's global profile.

flake/default.nix

@@ -4,58 +4,50 @@
   self,
 }:
 let
-  # TODO: refactor the registry code
-  registryAssembly = import ./registry.nix { inherit lib self; };
-
   util = import ../lib { inherit lib; };
-  mkModules = import ./module.nix { inherit util; };
 
-  modules = mkModules {
+  registry = import ./registry.nix {
+    inherit lib;
+    hosts = self.nixosConfigurations;
+    root = self + "/registry";
+  };
+
+  modules = import ./module.nix {
+    inherit util;
     root = self + "/modules";
   };
 
-  #----------------------------------------------------------
-  guestFiles = util.collectNixFiles (self + "/guests");
-
-  collectedRegistry = registryAssembly.collect { hosts = self.nixosConfigurations; };
-
-  specialArgs = {
-    inherit
-      flake
-      inputs
-      self
-      ;
-    registry = collectedRegistry;
-  };
-
-  flake = {
-    inherit (hosts) mkHosts;
-    inherit (guests) mkGuest;
-
-    inherit util;
-  };
-
-  guests = import ./guest.nix {
+  guestModules = import ./guest.nix {
     inherit
       inputs
       lib
-      self
+      registry
       specialArgs
-      registryAssembly
       util
       ;
     repositoryModules = modules;
+    root = self + "/guests";
   };
 
-  hosts = import ./host.nix {
+  specialArgs = {
+    inherit
+      inputs
+      self
+      util
+      ;
+    registry = registry.collected;
+  };
+in
+{
+  nixosConfigurations = import ./host.nix {
     inherit
       inputs
       lib
       specialArgs
-      guestFiles
-      registryAssembly
+      guestModules
       ;
+    registryModule = registry.module;
     repositoryModules = modules;
+    root = self + "/hosts";
   };
-in
-flake
+}

flake/guest.nix

@@ -1,116 +1,56 @@
 {
   inputs,
   lib,
-  self,
+  root,
   specialArgs,
   repositoryModules,
-  registryAssembly,
+  registry,
   util,
 }:
 let
   mkGuest =
-    {
-      name,
-      interior ? { },
-    }:
+    name:
     { config, lib, ... }:
     let
-      optionPath = [ "guests" ] ++ lib.splitString "." name;
-      cfg = lib.getAttrFromPath optionPath config;
-      machineName = lib.replaceStrings [ "." ] [ "-" ] name;
+      cfg = config.guests.${name};
 
-      networked = cfg.vlan != null;
+      directoryMounts = lib.filterAttrs (_: mount: mount.directory != null) cfg.mounts;
 
-      userMounts = lib.mapAttrs (_guestPath: m: {
-        inherit (m) hostPath;
-        isReadOnly = m.readOnly;
-      }) cfg.mounts;
-
-      secretMounts = lib.listToAttrs (
-        map (
-          name:
-          let
-            path = config.sops.secrets.${name}.path;
-          in
-          lib.nameValuePair path {
-            hostPath = path;
-            isReadOnly = true;
-          }
-        ) cfg.secrets
-      );
-
-      mountCollisions = lib.attrNames (builtins.intersectAttrs userMounts secretMounts);
-
-      limitConfig = lib.filterAttrs (_: v: v != null) {
-        MemoryMax = cfg.limits.memory;
-        CPUQuota = cfg.limits.cpu;
-        TasksMax = cfg.limits.tasksMax;
-      };
-
-      createdMounts = lib.filterAttrs (_guestPath: m: m.create != null) cfg.mounts;
-      mountCreateScript = lib.concatStringsSep "\n" (
+      directoryScript = lib.concatStringsSep "\n" (
         lib.mapAttrsToList (
-          _guestPath: m:
-          let
-            create = m.create;
-          in
+          _: mount:
           ''
-            ${config.system.path}/bin/install -d -o ${lib.escapeShellArg (toString create.owner)} -g ${lib.escapeShellArg create.group} -m ${lib.escapeShellArg create.mode} ${lib.escapeShellArg m.hostPath}
+            ${config.system.path}/bin/install -d \
+              ${lib.optionalString (mount.owner != null) "-o ${lib.escapeShellArg (toString mount.owner)}"} \
+              ${lib.optionalString (mount.group != null) "-g ${lib.escapeShellArg mount.group}"} \
+              ${lib.optionalString (mount.mode != null) "-m ${lib.escapeShellArg mount.mode}"} \
+              ${lib.escapeShellArg mount.directory}
           ''
-        ) createdMounts
+        ) directoryMounts
       );
-
-      guestNet =
-        { lib, ... }:
-        {
-          config = lib.mkIf networked {
-            networking.useNetworkd = true;
-            networking.useHostResolvConf = false;
-
-            systemd.network.networks."20-eth0" = {
-              matchConfig.Name = "eth0";
-              linkConfig.MACAddress = cfg.mac;
-              networkConfig.DHCP = "yes";
-            };
-          };
-        };
     in
     {
-      options = lib.setAttrByPath optionPath {
+      options.guests.${name} = {
         enable = lib.mkEnableOption "the ${name} guest, run in its own nested container";
-        backend = lib.mkOption {
-          type = lib.types.enum [
-            "container"
-            "microvm"
-          ];
-          default = "container";
-          description = ''
-            How the guest is realized. `container` runs the guest as a
-            systemd-nspawn nested container. `microvm` is reserved for a future
-            hard-isolation backend and is not built yet.
-          '';
-        };
         vlan = lib.mkOption {
-          type = lib.types.nullOr (lib.types.ints.between 1 4094);
-          default = null;
+          type = lib.types.ints.between 1 4094;
           example = 10;
           description = ''
             The tagged VLAN this guest lives on. The guest attaches to its host's
-            `br-vlan<id>` bridge for that VLAN. Left null, the guest keeps a
-            private network with no bridge attachment. The id must be one of the
-            host's `modules.network.vlans.ids`.
+            `br-vlan<id>` bridge for that VLAN. The id must be one of the host's
+            `modules.network.vlans.ids`.
           '';
         };
         mac = lib.mkOption {
           type = lib.types.str;
-          default = util.deriveMac name;
-          defaultText = lib.literalMD "a stable address derived from the guest's namespace path";
+          default = util.deriveMac "${config.networking.hostName}.${name}";
+          defaultText = lib.literalMD "a stable address derived from the host name and guest option path";
           example = "bc:24:11:00:00:01";
           description = ''
             The guest's MAC address on its VLAN, pinned inside the guest by its
             own networkd. Set it to reuse an existing address so a router's DHCP
             reservation keeps working. Left unset, a stable address is derived
-            from the guest's namespace path in the locally-administered range.
+            from the host name and guest option path in the locally-administered range.
           '';
         };
         address = lib.mkOption {
@@ -126,7 +66,7 @@ let
           enable = lib.mkEnableOption "a reverse-proxy route for this guest";
 
           route = lib.mkOption {
-            type = registryAssembly.definitions.route.type;
+            type = registry.types.route;
             description = "Route registry entry published for this guest.";
           };
         };
@@ -134,51 +74,43 @@ let
           type = lib.types.attrsOf (
             lib.types.submodule {
               options = {
-                hostPath = lib.mkOption {
-                  type = lib.types.str;
+                directory = lib.mkOption {
+                  type = lib.types.nullOr lib.types.str;
+                  default = null;
                   example = "/srv/media";
-                  description = "The path on the host bind-mounted into the guest.";
+                  description = "Host directory bind-mounted into the guest.";
+                };
+                file = lib.mkOption {
+                  type = lib.types.nullOr lib.types.str;
+                  default = null;
+                  example = "/run/secrets/service-password";
+                  description = "Host file bind-mounted into the guest.";
                 };
                 readOnly = lib.mkOption {
                   type = lib.types.bool;
                   default = false;
-                  description = ''
-                    Mount the path read-only. Read-write by default, since a
-                    service must write to the pool data it owns.
-                  '';
+                  description = "Mount the host path read-only inside the guest.";
                 };
-                create = lib.mkOption {
-                  type = lib.types.nullOr (lib.types.submodule {
-                    options = {
-                      type = lib.mkOption {
-                        type = lib.types.enum [ "directory" ];
-                        default = "directory";
-                        description = "Host path type to create before the guest starts.";
-                      };
-                      owner = lib.mkOption {
-                        type = lib.types.oneOf [
-                          lib.types.str
-                          lib.types.ints.positive
-                        ];
-                        description = "Owner assigned to the created host path.";
-                      };
-                      group = lib.mkOption {
-                        type = lib.types.str;
-                        description = "Group assigned to the created host path.";
-                      };
-                      mode = lib.mkOption {
-                        type = lib.types.str;
-                        example = "0770";
-                        description = "Mode assigned to the created host path.";
-                      };
-                    };
-                  });
+                owner = lib.mkOption {
+                  type = lib.types.nullOr (
+                    lib.types.oneOf [
+                      lib.types.str
+                      lib.types.ints.positive
+                    ]
+                  );
                   default = null;
-                  description = ''
-                    Opt-in host path creation before the guest starts. Existing
-                    paths are left enabled unless this is set, so served storage
-                    roots can still be required to exist explicitly.
-                  '';
+                  description = "Owner assigned to the host directory before the guest starts.";
+                };
+                group = lib.mkOption {
+                  type = lib.types.nullOr lib.types.str;
+                  default = null;
+                  description = "Group assigned to the host directory before the guest starts.";
+                };
+                mode = lib.mkOption {
+                  type = lib.types.nullOr lib.types.str;
+                  default = null;
+                  example = "0770";
+                  description = "Mode assigned to the host directory before the guest starts.";
                 };
               };
             }
@@ -186,35 +118,21 @@ let
           default = { };
           example = lib.literalExpression ''
             {
-              "/data/media" = { hostPath = "/srv/media"; };
-              "/data/config" = {
-                hostPath = "/srv/config/jellyfin";
-                readOnly = true;
-              };
+              "/data/media" = { directory = "/srv/media"; };
+              "/data/config" = { directory = "/srv/config/jellyfin"; };
             }
           '';
           description = ''
             Host paths bind-mounted into the guest, keyed by the path they appear
             at inside the guest, so a guest sees exactly the data it should at any
-            granularity — a single folder or a whole pool. Each mount is
-            read-write unless `readOnly` is set.
+            granularity — a single folder, a whole pool, or a decrypted secret.
+            Mounts are read-write unless `readOnly` is set.
           '';
         };
-        secrets = lib.mkOption {
-          type = lib.types.listOf lib.types.str;
-          default = [ ];
-          example = [ "jellyfin-api-key" ];
-          description = ''
-            Names of the secrets this guest needs. The host is the sole
-            decryptor: it decrypts each named secret from its own sops files and
-            bind-mounts the plaintext file into the guest read-only at
-            `/run/secrets/<name>`, the same path it would occupy on a host, so a
-            service reads its credentials at a predictable location. The guest
-            names the files it wants and receives exactly those. It holds no age
-            key and decrypts nothing itself. Ownership carries across unchanged,
-            since the container maps ids one to one, so a secret owned by a uid on
-            the host is owned by that same uid inside the guest.
-          '';
+        interior = lib.mkOption {
+          type = lib.types.deferredModule;
+          default = { };
+          description = "NixOS module imported into the guest interior.";
         };
         limits = {
           memory = lib.mkOption {
@@ -247,116 +165,115 @@ let
             '';
           };
         };
-        nesting = lib.mkOption {
-          type = lib.types.bool;
-          default = false;
-          description = ''
-            Grant the guest's interior the prerequisites to run Podman or other
-            OCI containers of its own. Off by default, so a guest cannot nest
-            containers. On, the guest's container gains the network-administration
-            capability its container runtime uses to build bridges and firewall
-            rules, along with the tun and fuse device nodes such a runtime reaches
-            for, so the interior's `virtualisation.oci-containers` works with
-            Podman as its default runtime.
-          '';
-        };
-        autoStart = lib.mkOption {
-          type = lib.types.bool;
-          default = true;
-          description = ''
-            Start the guest at boot. On by default. Disabled, the guest stays
-            defined and can be started on demand, but does not come up at boot.
-          '';
-        };
       };
 
       config = lib.mkIf cfg.enable {
-        sops.secrets = lib.genAttrs cfg.secrets (_: { });
-
-        registry.address.${config.networking.hostName}.${machineName} = lib.mkIf (cfg.address != null) cfg.address;
-
-        registry.route.${config.networking.hostName}.${machineName} = lib.mkIf cfg.reverseProxy.enable cfg.reverseProxy.route;
-
-        assertions = [
-          {
-            assertion = mountCollisions == [ ];
-            message = ''
-              guests.${name} maps a mount at ${lib.concatStringsSep ", " mountCollisions}, colliding with a secret bind-mounted at the same path. Rename the mount or the secret so each in-guest path is used once.
-            '';
-          }
-          {
-            assertion = cfg.backend == "container";
-            message = ''
-              guests.${name}.backend = "${cfg.backend}" is not implemented. Only the "container" backend is built; "microvm" is reserved for future work.
-            '';
-          }
-          {
-            assertion = !networked || lib.elem cfg.vlan config.modules.network.vlans.ids;
-            message = ''
-              guests.${name}.vlan = ${toString cfg.vlan} is not among its host's modules.network.vlans.ids (${lib.concatMapStringsSep ", " toString config.modules.network.vlans.ids}). Declare the VLAN on the host or correct the guest's placement.
-            '';
-          }
-        ];
-
-        systemd.services."container@${machineName}" = lib.mkIf (cfg.backend == "container") (
-          lib.mkMerge [
+        assertions =
+          let
+            hasDirectorySettings = mount: mount.owner != null || mount.group != null || mount.mode != null;
+            hasCompleteDirectorySettings = mount: mount.owner != null && mount.group != null && mount.mode != null;
+            hasOneSource = mount: (mount.directory != null) != (mount.file != null);
+            mountsWithInvalidSource = lib.attrNames (lib.filterAttrs (_: mount: !hasOneSource mount) cfg.mounts);
+            fileMountsWithHostSettings = lib.attrNames (
+              lib.filterAttrs (_: mount: mount.file != null && hasDirectorySettings mount) cfg.mounts
+            );
+            directoryMountsWithPartialHostSettings = lib.attrNames (
+              lib.filterAttrs (_: mount: mount.directory != null && hasDirectorySettings mount && !hasCompleteDirectorySettings mount) cfg.mounts
+            );
+          in
+          [
             {
-              serviceConfig = limitConfig;
-              preStart = lib.mkIf (createdMounts != { }) mountCreateScript;
-            }
-            (lib.mkIf networked (
-              let
-                bridgeDevice = "sys-subsystem-net-devices-${lib.replaceStrings [ "-" ] [ "\\x2d" ] (util.bridgeName cfg.vlan)}.device";
-              in
-              {
-                after = [ bridgeDevice ];
-                wants = [ bridgeDevice ];
-              }
-            ))
-          ]
-        );
-
-        containers.${machineName} = lib.mkIf (cfg.backend == "container") {
-          autoStart = cfg.autoStart;
-          privateNetwork = lib.mkDefault true;
-          hostBridge = lib.mkIf networked (util.bridgeName cfg.vlan);
-          privateUsers = lib.mkDefault "no";
-          additionalCapabilities = lib.optionals cfg.nesting [ "CAP_NET_ADMIN" ];
-          allowedDevices = lib.optionals cfg.nesting [
-            {
-              node = "/dev/net/tun";
-              modifier = "rwm";
+              assertion = mountsWithInvalidSource == [ ];
+              message = ''
+                guests.${name} mounts ${lib.concatStringsSep ", " mountsWithInvalidSource} must set exactly one of `directory` or `file`.
+              '';
             }
             {
-              node = "/dev/fuse";
-              modifier = "rwm";
+              assertion = fileMountsWithHostSettings == [ ];
+              message = ''
+                guests.${name} file mounts ${lib.concatStringsSep ", " fileMountsWithHostSettings} must not set `owner`, `group`, or `mode`.
+              '';
+            }
+            {
+              assertion = directoryMountsWithPartialHostSettings == [ ];
+              message = ''
+                guests.${name} directory mounts ${lib.concatStringsSep ", " directoryMountsWithPartialHostSettings} must set `owner`, `group`, and `mode` together.
+              '';
+            }
+            {
+              assertion = lib.elem cfg.vlan config.modules.network.vlans.ids;
+              message = ''
+                guests.${name}.vlan = ${toString cfg.vlan} is not among its host's modules.network.vlans.ids (${lib.concatMapStringsSep ", " toString config.modules.network.vlans.ids}). Declare the VLAN on the host or correct the guest's placement.
+              '';
             }
           ];
 
-          bindMounts = userMounts // secretMounts;
+        registry.address.${config.networking.hostName}.${name} =
+          lib.mkIf (cfg.address != null) cfg.address;
+
+        registry.route.${config.networking.hostName}.${name} =
+          lib.mkIf cfg.reverseProxy.enable cfg.reverseProxy.route;
+
+        systemd.services."container@${name}" =
+          let
+            bridgeDevice = "sys-subsystem-net-devices-${lib.replaceStrings [ "-" ] [ "\\x2d" ] (util.bridgeName cfg.vlan)}.device";
+          in
+          {
+            after = [ bridgeDevice ];
+            wants = [ bridgeDevice ];
+
+            serviceConfig = lib.filterAttrs (_: v: v != null) {
+              MemoryMax = cfg.limits.memory;
+              CPUQuota = cfg.limits.cpu;
+              TasksMax = cfg.limits.tasksMax;
+            };
+            preStart = lib.mkIf (directoryMounts != { }) directoryScript;
+          };
+
+        containers.${name} = {
+          autoStart = true;
+          privateNetwork = lib.mkDefault true;
+          hostBridge = util.bridgeName cfg.vlan;
+          privateUsers = lib.mkDefault "no";
+          bindMounts = lib.mapAttrs (_: mount: {
+            hostPath = if mount.directory != null then mount.directory else mount.file;
+            isReadOnly = mount.readOnly;
+          }) cfg.mounts;
 
           inherit specialArgs;
 
           config = {
-            imports =
-              [
-                repositoryModules
-              ]
-              ++ [
-                registryAssembly.module
-                inputs.sops-nix.nixosModules.sops
-                inputs.stylix.nixosModules.stylix
-                {
-                  modules.guest.enable = true;
-                }
-                guestNet
-                interior
-              ];
+            imports = [
+              inputs.sops-nix.nixosModules.sops
+              inputs.stylix.nixosModules.stylix
+
+              repositoryModules
+              registry.module
+              cfg.interior
+
+              {
+                modules.guest.enable = true;
+
+                networking.useNetworkd = true;
+                networking.useHostResolvConf = false;
+
+                systemd.network.networks."20-eth0" = {
+                  matchConfig.Name = "eth0";
+                  linkConfig.MACAddress = cfg.mac;
+                  networkConfig.DHCP = "yes";
+                };
+              }
+            ];
           };
         };
       };
     };
 in
+let
+  files = util.collectNixFiles root;
+  guestFiles = lib.filterAttrs (file: type: type == "regular" && lib.hasSuffix ".nix" file) (builtins.readDir root);
+  names = map (file: lib.removeSuffix ".nix" file) (lib.attrNames guestFiles);
+in
 {
-  inherit mkGuest;
+  imports = files ++ map mkGuest names;
 }

flake/host.nix

@@ -1,13 +1,12 @@
 {
   inputs,
   lib,
+  root,
   specialArgs,
   repositoryModules,
 
-  # TODO refactor guests
-  guestFiles,
-  # TODO refactor registry
-  registryAssembly,
+  guestModules,
+  registryModule,
 }:
 let
   mkHost =
@@ -17,35 +16,30 @@ let
     }:
     lib.nixosSystem {
       inherit specialArgs;
-      modules =
-        guestFiles
-        ++ [
-          inputs.chaotic.nixosModules.default
-          inputs.disko.nixosModules.disko
-          inputs.sops-nix.nixosModules.sops
-          inputs.stylix.nixosModules.stylix
+      modules = [
+        inputs.chaotic.nixosModules.default
+        inputs.disko.nixosModules.disko
+        inputs.sops-nix.nixosModules.sops
+        inputs.stylix.nixosModules.stylix
 
-          repositoryModules
+        repositoryModules
+        guestModules
 
-          # TODO: refactor
-          registryAssembly.module (root + "/${name}")
+        # TODO: refactor
+        registryModule (root + "/${name}")
 
-          {
-            networking.hostName = name;
-            modules.host.enable = true;
-          }
-        ];
+        {
+          networking.hostName = name;
+          modules.host.enable = true;
+        }
+      ];
     };
 in
-{
-  mkHosts =
-    { root }:
-    let
-      directories = lib.filterAttrs (_name: type: type == "directory") (builtins.readDir root);
-      names = lib.attrNames directories;
-    in
-    lib.genAttrs names (
-      name:
-      mkHost { inherit root name; }
-    );
-}
+let
+  directories = lib.filterAttrs (_name: type: type == "directory") (builtins.readDir root);
+  names = lib.attrNames directories;
+in
+lib.genAttrs names (
+  name:
+  mkHost { inherit root name; }
+)

flake/module.nix

@@ -1,5 +1,7 @@
-{ util }:
-{ root }:
+{
+  root,
+  util,
+}:
 {
   imports = util.collectNixFiles root;
 }

flake/registry.nix

@@ -1,35 +1,16 @@
-{ lib, self }:
+{ hosts, lib, root }:
 let
-  inherit (lib)
-    all
-    concatLists
-    concatMapStringsSep
-    filter
-    filterAttrs
-    foldl'
-    hasAttr
-    hasSuffix
-    mapAttrs
-    mapAttrs'
-    mapAttrsToList
-    mkOption
-    nameValuePair
-    removeSuffix
-    types
-    unique
-    ;
-
-  checkType = types.submodule {
+  checkType = lib.types.submodule {
     options = {
-      assertion = mkOption {
-        type = types.functionTo types.bool;
+      assertion = lib.mkOption {
+        type = lib.types.functionTo lib.types.bool;
         description = ''
           Predicate run against this registry's flattened collected entries.
         '';
       };
 
-      message = mkOption {
-        type = types.str;
+      message = lib.mkOption {
+        type = lib.types.str;
         description = ''
           Error message shown when this registry validation check fails.
         '';
@@ -38,7 +19,7 @@ let
   };
 
   predicates = {
-    uniqueValue = value: entries: builtins.length (unique (map value entries)) == builtins.length entries;
+    uniqueValue = value: entries: builtins.length (lib.unique (map value entries)) == builtins.length entries;
   };
 
   registryLib = lib // {
@@ -49,23 +30,23 @@ let
 
   registryDefinitionModule = {
     options = {
-      type = mkOption {
-        type = types.raw;
+      type = lib.mkOption {
+        type = lib.types.raw;
         description = ''
           NixOS option type for one registry entry.
         '';
       };
 
-      replicate = mkOption {
-        type = types.bool;
+      replicate = lib.mkOption {
+        type = lib.types.bool;
         default = false;
         description = ''
           Whether collected entries are merged and published under every host key.
         '';
       };
 
-      checks = mkOption {
-        type = types.listOf checkType;
+      checks = lib.mkOption {
+        type = lib.types.listOf checkType;
         default = [ ];
         description = ''
           Validation checks for this registry's flattened collected entries.
@@ -74,10 +55,10 @@ let
     };
   };
 
-  registryName = fileName: removeSuffix ".nix" fileName;
+  registryName = fileName: lib.removeSuffix ".nix" fileName;
 
-  registryOption = registry: mkOption {
-    type = types.attrsOf (types.attrsOf registry.type);
+  registryOption = registry: lib.mkOption {
+    type = lib.types.attrsOf (lib.types.attrsOf registry.type);
     default = { };
     description = ''
       Lazily collected fleet-visible registry entries, nested by host and entry name.
@@ -98,19 +79,19 @@ let
       inherit (evaluated.config) type replicate checks;
     };
 
-  definitions = mapAttrs' (
+  definitions = lib.mapAttrs' (
     name: type:
     let
-      path = self + "/registry/${name}";
+      path = root + "/${name}";
     in
-    nameValuePair (registryName name) (mkRegistry path)
-  ) (filterAttrs (name: type: type == "regular" && hasSuffix ".nix" name) (builtins.readDir (self + "/registry")));
+    lib.nameValuePair (registryName name) (mkRegistry path)
+  ) (lib.filterAttrs (name: type: type == "regular" && lib.hasSuffix ".nix" name) (builtins.readDir root));
 
   flattenRegistryEntries = registryName: data:
-    concatLists (
-      mapAttrsToList (
+    lib.concatLists (
+      lib.mapAttrsToList (
         host: entries:
-        mapAttrsToList (entry: value: {
+        lib.mapAttrsToList (entry: value: {
           path = "registry.${registryName}.${host}.${entry}";
           inherit host entry value;
         }) entries
@@ -118,17 +99,17 @@ let
     );
 
   rawDeclarations = registryName: hosts:
-    mapAttrs (_hostName: host: host.config.registry.${registryName} or { }) hosts;
+    lib.mapAttrs (_hostName: host: host.config.registry.${registryName} or { }) hosts;
 
   replicatedEntries = registryName: raw:
     let
-      entries = concatLists (
-        concatLists (
-          mapAttrsToList (
+      entries = lib.concatLists (
+        lib.concatLists (
+          lib.mapAttrsToList (
             _evalHost: hostDeclarations:
-            mapAttrsToList (
+            lib.mapAttrsToList (
               hostName: declarations:
-              mapAttrsToList (entryName: value: {
+              lib.mapAttrsToList (entryName: value: {
                 path = "registry.${registryName}.${hostName}.${entryName}";
                 inherit entryName value;
               }) declarations
@@ -137,9 +118,9 @@ let
         )
       );
     in
-    foldl' (
+    lib.foldl' (
       acc: entry:
-      if hasAttr entry.entryName acc then
+      if lib.hasAttr entry.entryName acc then
         if acc.${entry.entryName}.value == entry.value then
           acc
         else
@@ -152,13 +133,13 @@ let
 
   replicatedData = registryName: hosts: raw:
     let
-      entries = mapAttrs (_entryName: entry: entry.value) (replicatedEntries registryName raw);
+      entries = lib.mapAttrs (_entryName: entry: entry.value) (replicatedEntries registryName raw);
     in
-    mapAttrs (_hostName: _host: entries) hosts;
+    lib.mapAttrs (_hostName: _host: entries) hosts;
 
   validationAssertions = data:
-    concatLists (
-      mapAttrsToList (
+    lib.concatLists (
+      lib.mapAttrsToList (
         registryName: registry:
         let
           entries = flattenRegistryEntries registryName data.${registryName};
@@ -173,28 +154,28 @@ let
   assertValid = data:
     let
       assertions = validationAssertions data;
-      failures = filter (assertion: !assertion.assertion) assertions;
+      failures = lib.filter (assertion: !assertion.assertion) assertions;
     in
-    assert lib.assertMsg (all (assertion: assertion.assertion) assertions) (
-      concatMapStringsSep "\n" (assertion: assertion.message) failures
+    assert lib.assertMsg (lib.all (assertion: assertion.assertion) assertions) (
+      lib.concatMapStringsSep "\n" (assertion: assertion.message) failures
     );
     data;
 
   join = registry: host: entry:
-    filterAttrs (_name: value: value != null) (
-      mapAttrs (registryName: _registry: (registry.${registryName}.${host} or { }).${entry} or null) definitions
+    lib.filterAttrs (_name: value: value != null) (
+      lib.mapAttrs (registryName: _registry: (registry.${registryName}.${host} or { }).${entry} or null) definitions
     );
 
   collectData =
     { hosts }:
     let
-      raw = mapAttrs (registryName: _registry: rawDeclarations registryName hosts) definitions;
-      data = mapAttrs (
+      raw = lib.mapAttrs (registryName: _registry: rawDeclarations registryName hosts) definitions;
+      data = lib.mapAttrs (
         registryName: registry:
         if registry.replicate or false then
           replicatedData registryName hosts raw.${registryName}
         else
-          mapAttrs (hostName: host: host.config.registry.${registryName}.${hostName} or { }) hosts
+          lib.mapAttrs (hostName: host: host.config.registry.${registryName}.${hostName} or { }) hosts
       ) definitions;
     in
     assertValid data;
@@ -206,11 +187,11 @@ let
     };
 in
 {
-  inherit definitions predicates;
+  types = lib.mapAttrs (_name: definition: definition.type) definitions;
 
   module = {
-    options.registry = mapAttrs (_name: registry: registryOption registry) definitions;
+    options.registry = lib.mapAttrs (_name: registry: registryOption registry) definitions;
   };
 
-  collect = args: withOperations (collectData args);
+  collected = withOperations (collectData { inherit hosts; });
 }

guests/actualbudget.nix

@@ -1,7 +1,6 @@
 {
   config,
   lib,
-  flake,
   ...
 }:
 let
@@ -9,18 +8,6 @@ let
   dataDir = "/data";
 in
 {
-  imports = [
-    (flake.mkGuest {
-      name = "actualbudget";
-      interior = {
-        modules.services.actualbudget = {
-          enable = true;
-          inherit dataDir;
-        };
-      };
-    })
-  ];
-
   options.guests.actualbudget = {
     dataPath = lib.mkOption {
       type = lib.types.nullOr lib.types.str;
@@ -39,7 +26,13 @@ in
     ];
 
     guests.actualbudget = {
-      mounts.${dataDir}.hostPath = cfg.dataPath;
+      interior = {
+        modules.services.actualbudget = {
+          enable = true;
+          inherit dataDir;
+        };
+      };
+      mounts.${dataDir}.directory = cfg.dataPath;
       limits = {
         memory = lib.mkDefault "2G";
         cpu = lib.mkDefault "200%";

guests/copyparty.nix

@@ -1,7 +1,6 @@
 {
   config,
   lib,
-  flake,
   ...
 }:
 let
@@ -34,26 +33,6 @@ let
   };
 in
 {
-  imports = [
-    (flake.mkGuest {
-      name = "copyparty";
-      interior = {
-        modules.services.copyparty = {
-          enable = true;
-          inherit (cfg) accountName stateDir;
-          passwordFile = "/run/secrets/${cfg.passwordSecret}";
-          reverseProxy = {
-            enable = cfg.reverseProxy.enable;
-            inherit (cfg.reverseProxy) trustedSources;
-          };
-          volumes = lib.mapAttrs (_urlPath: volume: {
-            inherit (volume) path access flags;
-          }) cfg.volumes;
-        };
-      };
-    })
-  ];
-
   options.guests.copyparty = {
     accountName = lib.mkOption {
       type = lib.types.str;
@@ -106,19 +85,33 @@ in
     ];
 
     guests.copyparty = {
-      secrets = [ cfg.passwordSecret ];
+      interior.modules.services.copyparty = {
+        enable = true;
+        inherit (cfg) accountName stateDir;
+        passwordFile = "/run/secrets/${cfg.passwordSecret}";
+        reverseProxy = {
+          enable = cfg.reverseProxy.enable;
+          inherit (cfg.reverseProxy) trustedSources;
+        };
+        volumes = lib.mapAttrs (_urlPath: volume: {
+          inherit (volume) path access flags;
+        }) cfg.volumes;
+      };
+
       mounts =
         {
           ${cfg.stateDir} = {
-            hostPath = cfg.statePath;
-            create = {
-              owner = config.registry."stable-uid".${config.networking.hostName}.copyparty;
-              group = "storage";
-              mode = "0770";
-            };
+            directory = cfg.statePath;
+            owner = config.registry."stable-uid".${config.networking.hostName}.copyparty;
+            group = "storage";
+            mode = "0770";
+          };
+          ${"/run/secrets/${cfg.passwordSecret}"} = {
+            file = config.sops.secrets.${cfg.passwordSecret}.path;
+            readOnly = true;
           };
         }
-        // lib.mapAttrs' (_urlPath: volume: lib.nameValuePair volume.path { inherit (volume) hostPath; }) cfg.volumes;
+        // lib.mapAttrs' (_urlPath: volume: lib.nameValuePair volume.path { directory = volume.hostPath; }) cfg.volumes;
       limits = {
         memory = lib.mkDefault "2G";
         cpu = lib.mkDefault "200%";

guests/nesting-sample.nix

@@ -1,11 +0,0 @@
-args@{ flake, ... }:
-# A sample guest whose interior runs an OCI container on Podman.
-# The image is pulled at runtime, so the guest builds with no build-time fetch.
-flake.mkGuest {
-  name = "nesting-sample";
-  interior = {
-    virtualisation.oci-containers.containers.hello = {
-      image = "docker.io/library/hello-world";
-    };
-  };
-} args

guests/reverse-proxy.nix

@@ -1,16 +1,14 @@
 {
   config,
   lib,
-  flake,
   ...
 }:
 let
   giteaSshBackend = "10.23.20.45:2022";
 in
 {
-  imports = [
-    (flake.mkGuest {
-      name = "reverse-proxy";
+  config = lib.mkIf config.guests.reverse-proxy.enable {
+    guests.reverse-proxy = {
       interior = {
         modules.services.reverse-proxy.enable = true;
 
@@ -66,11 +64,7 @@ in
           }
         '';
       };
-    })
-  ];
 
-  config = lib.mkIf config.guests.reverse-proxy.enable {
-    guests.reverse-proxy = {
       limits = {
         memory = lib.mkDefault "1G";
         cpu = lib.mkDefault "100%";

guests/sample.nix

@@ -1,5 +0,0 @@
-args@{ flake, ... }:
-# The tracer-bullet guest: the thinnest complete path from discovery to a
-# running nested container. Its interior is just the guest-base — the baseline
-# toolset and SSH access — so it proves the concept without carrying a service.
-flake.mkGuest { name = "sample"; } args

hosts/neogaia/default.nix

@@ -40,26 +40,6 @@
   modules.network.ssh.hostKeys.sopsFile = ../../secrets/neogaia.yaml;
   modules.network.ssh.userKey.sopsFile = ../../secrets/neogaia.yaml;
 
-  # The walking-skeleton guest, enabled like any module: proves the guest path
-  # end to end through this host's `nix flake check`.
-  # Modest caps keep the skeleton guest from starving the laptop.
-  guests.sample.enable = true;
-  guests.sample.limits = {
-    memory = "1G";
-    cpu = "100%";
-    tasksMax = 512;
-  };
-
-  # The nesting guest, run with `nesting` on: proves an interior OCI container
-  # on Podman builds end to end through this host's `nix flake check`.
-  guests.nesting-sample.enable = true;
-  guests.nesting-sample.nesting = true;
-  guests.nesting-sample.limits = {
-    memory = "1G";
-    cpu = "100%";
-    tasksMax = 512;
-  };
-
   modules.shell.herdr.enable = true;
   modules.agents.tools.gitea-axi.enable = true;
   modules.agents.pi.enable = true;

modules/default.nix

@@ -1,7 +1,6 @@
 {
   config,
   lib,
-  flake,
   pkgs,
   inputs,
   ...
@@ -64,7 +63,7 @@ in
       useGlobalPkgs = true;
       useUserPackages = true;
       extraSpecialArgs = {
-        inherit flake inputs;
+        inherit inputs;
       };
       users.${user.name} = {
         home.username = user.name;
@@ -122,5 +121,6 @@ in
     modules.shell.nvim.enable = lib.mkDefault true;
     modules.shell.git.enable = lib.mkDefault true;
     modules.shell.direnv.enable = lib.mkDefault true;
+    modules.shell.yazi.enable = lib.mkDefault true;
   };
 }

modules/desktop/apps/ghostty.nix

@@ -0,0 +1,18 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
+# Ghostty as the desktop terminal.
+let
+  cfg = config.modules.desktop.apps.ghostty;
+  user = config.user.name;
+in
+{
+  options.modules.desktop.apps.ghostty.enable = lib.mkEnableOption "Ghostty as the desktop terminal";
+
+  config = lib.mkIf cfg.enable {
+    home-manager.users.${user}.home.packages = [ pkgs.ghostty ];
+  };
+}

modules/desktop/default.nix

@@ -9,8 +9,8 @@ in
   # Each piece is turned on at default priority, so a host can still override
   # any one of them while the single flag above enables the whole desktop.
   config = lib.mkIf cfg.enable {
-    modules.desktop.apps.alacritty.enable = lib.mkDefault true;
     modules.desktop.apps.firefox.enable = lib.mkDefault true;
+    modules.desktop.apps.ghostty.enable = lib.mkDefault true;
     modules.desktop.session.hyprland.enable = lib.mkDefault true;
     modules.desktop.session.hyprland.hypridle.enable = lib.mkDefault true;
     modules.desktop.session.hyprland.hyprlock.enable = lib.mkDefault true;

modules/desktop/session/hyprland/default.nix

@@ -61,7 +61,7 @@ in
 
       settings = {
         "$mod" = "SUPER";
-        "$terminal" = "alacritty";
+        "$terminal" = "ghostty";
 
         # Session variables handed to the compositor directly.
         # UWSM launches the session without the shell profile that would carry

modules/desktop/session/waybar.nix

@@ -89,6 +89,7 @@ in
           window-rewrite-default = g "f2d0";
           window-rewrite = {
             "class<Alacritty>" = g "f120";
+            "class<com.mitchellh.ghostty>" = g "f120";
             "class<.*[Ff]irefox.*>" = g "f269";
             "class<chromium.*>" = g "f268";
             "class<[Cc]ode>" = g "f121";

modules/network/vlans.nix

@@ -1,14 +1,14 @@
 {
   config,
   lib,
-  flake,
+  util,
   ...
 }:
 # The host networking foundation: per-VLAN bridges over a tagged trunk.
 let
   cfg = config.modules.network.vlans;
 
-  inherit (flake.util) bridgeName;
+  inherit (util) bridgeName;
 
   vlanName = id: "${cfg.trunk}.${toString id}";
 in

modules/shell/direnv/default.nix

@@ -20,6 +20,7 @@ in
       # nix-direnv caches the evaluated shell so re-entering a directory is instant
       # instead of re-running `nix develop`, and adds the `use flake` stdlib helper.
       nix-direnv.enable = true;
+      stdlib = builtins.readFile ./repo-flake.sh;
     };
   };
 }

modules/shell/direnv/repo-flake.sh

@@ -0,0 +1,33 @@
+if declare -f use_flake >/dev/null; then
+  __dotfiles_use_flake_definition="$(declare -f use_flake)"
+  eval "${__dotfiles_use_flake_definition/use_flake/__dotfiles_nix_direnv_use_flake}"
+  unset __dotfiles_use_flake_definition
+
+  use_flake() {
+    local flake_expr="${1:-.}"
+
+    if [[ "$flake_expr" == //* ]]; then
+      local git_root
+      if ! git_root="$(git rev-parse --show-toplevel 2>/dev/null)"; then
+        log_error 'use flake // requires a Git repository'
+        return 1
+      fi
+
+      local flake_suffix="${flake_expr#//}"
+      if [[ -n "$flake_suffix" && "$flake_suffix" != \#* && "$flake_suffix" != /* ]]; then
+        flake_expr="path:${git_root}/${flake_suffix}"
+      else
+        flake_expr="path:${git_root}${flake_suffix}"
+      fi
+
+      shift
+      __dotfiles_nix_direnv_use_flake "$flake_expr" "$@"
+      return
+    fi
+
+    __dotfiles_nix_direnv_use_flake "$@"
+  }
+else
+  log_error 'nix-direnv must define use_flake before the // wrapper loads'
+  return 1
+fi

modules/shell/herdr.nix

@@ -38,6 +38,9 @@ in
 
         [ui]
         prompt_new_tab_name = false
+
+        [experimental]
+        kitty_graphics = true
       '';
     };
   };

modules/shell/nvim/config.lua

@@ -16,6 +16,16 @@ vim.api.nvim_create_autocmd("FileType", {
   end,
 })
 
+-- Soft-wrap prose buffers without inserting line breaks.
+vim.api.nvim_create_autocmd("FileType", {
+  pattern = { "gitcommit", "markdown", "text" },
+  callback = function()
+    vim.opt_local.wrap = true
+    vim.opt_local.linebreak = true
+    vim.opt_local.breakindent = true
+  end,
+})
+
 -- Turn line blame off again once the Neogit status buffer is closed.
 vim.api.nvim_create_autocmd("BufUnload", {
   callback = function(args)

modules/shell/nvim/default.nix

@@ -92,6 +92,18 @@ in
             action = "<cmd>nohlsearch<CR>";
             options.desc = "Clear search highlight";
           }
+          {
+            mode = "n";
+            key = "j";
+            action = "gj";
+            options.desc = "Move down by display line";
+          }
+          {
+            mode = "n";
+            key = "k";
+            action = "gk";
+            options.desc = "Move up by display line";
+          }
           {
             mode = "n";
             key = "<leader>e";

modules/shell/yazi.nix

@@ -0,0 +1,32 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
+# Yazi, a terminal file manager.
+let
+  cfg = config.modules.shell.yazi;
+  user = config.user.name;
+in
+{
+  options.modules.shell.yazi.enable = lib.mkEnableOption "Yazi, a terminal file manager";
+
+  config = lib.mkIf cfg.enable {
+    home-manager.users.${user}.programs.yazi = {
+      enable = true;
+      enableFishIntegration = true;
+      extraPackages = with pkgs; [
+        fd
+        ffmpegthumbnailer
+        fzf
+        imagemagick
+        jq
+        poppler
+        ripgrep
+        unar
+        zoxide
+      ];
+    };
+  };
+}