{
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
    crane.url = "github:TheNeikos/crane/fix/use_unsafe";
    crane.inputs.nixpkgs.follows = "nixpkgs";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs = inputs@{ self, nixpkgs, flake-utils, crane, ... }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        craneLib = crane.lib.${system};
        pkgs = import nixpkgs { inherit system; };
      in
      {
        lib = rec {
          officialComponents = [
            (mkThinEdgeComponent { src = ../../plugins/plugin_avg; pluginBuilderPath = "plugin_avg::AvgPluginBuilder"; })
          ];

          mkThinEdgeComponent =
            attrs@{ name ? null
            , version ? null
            , nativeBuildInputs ? [ ]
            , buildInputs ? [ ]
            , src
            , pluginBuilderPath
            ,
            }:
            let
              crateInfo = craneLib.crateNameFromCargoToml {
                cargoToml = "${src}/Cargo.toml";
              };
            in
            {
              name =
                if builtins.isNull name
                then crateInfo.pname
                else name;

              version =
                if builtins.isNull version
                then crateInfo.version
                else version;

              inherit src pluginBuilderPath nativeBuildInputs buildInputs;
            };

          mkThinEdgeCrateSource =
            attrs@{ defaultComponents ? officialComponents
            , extraComponents ? [ ]
            ,
            }:
            let
              allComponents = defaultComponents ++ extraComponents;

              writeCargoToml = import ./writeCargoToml.nix;
              writeSrcMainRs = import ./writeSrcMainRs.nix;
              writeCargoRegistry = import ./writeCargoRegistry.nix;

              cargoToml = writeCargoToml {
                inherit pkgs craneLib;
                components = allComponents;
              };

              srcmainrs = writeSrcMainRs {
                inherit pkgs craneLib;
                components = allComponents;
              };

              cargoConfig = writeCargoRegistry {
                inherit pkgs craneLib;
              };

              thinEdgeLockFile = pkgs.runCommand "buildThinEdgeLockFile" { } ''
                mkdir -p src
                mkdir -p .cargo
                mkdir -p home
                HOME=$(pwd)/home
                cp -v "${cargoToml}" Cargo.toml
                cp -v "${cargoConfig}" .cargo/config.toml
                cp -v "${srcmainrs}" src/main.rs
                ${pkgs.cargo}/bin/cargo -v generate-lockfile --offline
                cp Cargo.lock $out
              '';

              thinEdgeCrateSrc = pkgs.runCommand "buildThinEdgeCrateSrc" { } ''
                mkdir -p $out/src
                mkdir -p $out/.cargo
                mkdir -p $out/home
                cp -v "${cargoToml}" $out/Cargo.toml
                cp -v "${thinEdgeLockFile}" $out/Cargo.lock
                cp -v "${srcmainrs}" $out/src/main.rs
              '';
            in
            thinEdgeCrateSrc;

          mkThinEdge =
            attrs@{ defaultComponents ? officialComponents
            , extraComponents ? [ ]
            }:
            let
              thinEdgeCrateSrc = mkThinEdgeCrateSource {
                inherit defaultComponents extraComponents;
              };
              collectedInputs = {
                buildInputs = pkgs.lib.lists.concatMap (comp: comp.buildInputs) extraComponents;
                nativeBuildInputs = pkgs.lib.lists.concatMap (comp: comp.nativeBuildInputs) extraComponents;
              };


              builtPackage = craneLib.buildPackage {
                pname = "thin-edge";
                version = "0.1.0";
                src = thinEdgeCrateSrc;
                buildInputs = collectedInputs.buildInputs;
                nativeBuildInputs = collectedInputs.nativeBuildInputs;
              };
            in
            builtPackage;
        };
      });
}