{
  description = "Metanix static flake: meta.nix → addressing, deploy-rs, disko, nixos-anywhere";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";
    deploy-rs.url = "github:serokell/deploy-rs";
    disko.url = "github:nix-community/disko";
    nixos-anywhere.url = "github:numtide/nixos-anywhere";
  };

  outputs = { self, nixpkgs, deploy-rs, disko, nixos-anywhere, ... }:
    let
      # Default architecture if meta.nix doesn't say otherwise
      system = "x86_64-linux";

      pkgs = import nixpkgs {
        inherit system;
      };

      lib = pkgs.lib;

      # Your mkIp / mkHostsFromSpec / mkSubnetsFromSpec, etc.
      # This expects: lib/addressing/default.nix
      addressing = import ./lib/addressing {
        inherit lib;
      };

      # User-provided world model.
      meta = import ./meta.nix;

      # Uses your rewritten mkNetworkFromSpec that understands meta.nix shape.
      network = addressing.mkNetworkFromSpec meta;

      # Optional: meta.systems = { hostName = { system = "..."; modules = [ ... ]; ... }; ...; }
      systemsFromMeta = meta.systems or { };
    in
    {
      #######################
      # Library-style exports
      #######################
      lib = {
        metanix = {
          inherit meta network addressing;
        };
      };

      #############################
      # Per-host NixOS configs
      #
      # Driven by meta.systems if present. Shape example:
      # meta.systems = {
      #   deimos = {
      #     system = "x86_64-linux";
      #     modules = [ ./hosts/deimos.nix ];
      #     diskoConfig = ./disko/deimos.nix;  # optional
      #     deployHost = "deimos.kasear.net";  # optional
      #     deployUser = "root";               # optional
      #   };
      # };
      #############################
      nixosConfigurations =
        lib.mapAttrs
          (name: sysCfg:
            let
              systemForHost = sysCfg.system or system;

              pkgsForHost = import nixpkgs {
                inherit systemForHost;
              };

              hostLib = pkgsForHost.lib;

              # Optional disko module wiring if sysCfg.diskoConfig exists.
              diskoModule =
                if sysCfg ? diskoConfig then
                  { imports = [ disko.nixosModules.disko sysCfg.diskoConfig ]; }
                else
                  { };
            in
            hostLib.nixosSystem {
              system = systemForHost;
              modules =
                (sysCfg.modules or [ ]) ++ [
                  diskoModule
                  ({ ... }: {
                    _module.args = {
                      inherit meta network addressing;
                      hostName = name;
                    };
                  })
                ];
            })
          systemsFromMeta;

      ########################################
      # deploy-rs integration
      #
      # Builds deploy.nodes using meta.systems + addressing.
      ########################################
      deploy = {
        nodes =
          lib.mapAttrs
            (name: sysCfg:
              let
                hasNetworkHost = builtins.hasAttr name network.hosts;
                hostInfo = if hasNetworkHost then network.hosts.${name} else null;

                defaultHostname =
                  if hasNetworkHost then hostInfo.fqdn else "${name}.${meta.domain}";
              in
              {
                hostname = sysCfg.deployHost or defaultHostname;

                profiles.system = {
                  user = sysCfg.deployUser or "root";
                  path =
                    deploy-rs.lib.${system}.activate.nixos
                      self.nixosConfigurations.${name};
                };
              })
            systemsFromMeta;
      };

      ########################################
      # deploy-rs sanity checks
      ########################################
      checks.${system}.deploy =
        deploy-rs.lib.${system}.deployChecks self.deploy;

      ########################################
      # nixos-anywhere convenience app
      ########################################
      apps.${system}.nixos-anywhere = {
        type = "app";
        program =
          "${nixos-anywhere.packages.${system}.nixos-anywhere}/bin/nixos-anywhere";
      };
    };
}