foundation/flake.lock

@@ -3,10 +3,10 @@
     "lib": {
       "locked": {
         "dir": "lib",
-        "dirtyRev": "2be3111b2c0911f40b47fe0a1fb22b5f5188cf59-dirty",
+        "dirtyRev": "9850da8aa9dc9be22e237c9b424a18e801e53ecb-dirty",
-        "dirtyShortRev": "2be3111-dirty",
+        "dirtyShortRev": "9850da8-dirty",
-        "lastModified": 1719251485,
+        "lastModified": 1718529861,
-        "narHash": "sha256-63NvfFVeTDITfNu60rmCUlaZtAeZUnvrIaOLSk9ScC8=",
+        "narHash": "sha256-tv/0C7ixH+9Ij+r+5nua48OlXXXnbdEsnenxX4eG/Sk=",
         "type": "git",
         "url": "file:../?dir=lib"
       },

lib/src/options/default.nix

@@ -43,7 +43,7 @@ lib: {
           resolve =
             definition:
             let
-              properties = builtins.addErrorContext "while evaluating definitions from `${definition.__file__ or "<unknown>"}`:" (
+              properties = builtins.addErrorContext "while evaluating definitions from `${definition.__file__}`:" (
                 lib.modules.apply.properties definition.value
               );
               normalize = value: {

lib/src/types/default.nix

@@ -1100,43 +1100,6 @@ lib: {
           };
         };
 
-    ## Create a type that allows a value which is either the final type or is transformable
-    ## to the final type.
-    ##
-    ## @type Attrs -> (Any -> Any) -> Attrs -> Attrs
-    coerceWithLocation =
-      initial: transform: final:
-      let
-      in
-      if initial.getSubModules != null then
-        builtins.throw "lib.types.coerceWithLocation's first argument may not have submodules, but got ${initial.description}"
-      else
-        lib.types.create {
-          name = "Coerce";
-          description = "${initial.description} that is transformed to ${final.description}";
-          fallback = final.fallback;
-          check = value: final.check value || (initial.check value && final.check (transform [ ] value));
-          merge =
-            location: definitions:
-            let
-              process = value: if initial.check value then transform location value else value;
-              normalize = definition: definition // { value = process definition.value; };
-              normalized = builtins.map normalize definitions;
-            in
-            final.merge location normalized;
-          getSubOptions = final.getSubOptions;
-          getSubModules = final.getSubModules;
-          withSubModules =
-            modules: lib.types.coerceWithLocation initial transform (final.withSubModules modules);
-          mergeType = x: y: null;
-          functor = lib.types.functor "coerceWithLocation" // {
-            wrapped = final;
-          };
-          children = {
-            inherit initial final;
-          };
-        };
-
     dag = {
       ## Create a type that allows a DAG (Directed Acyclic Graph) of a given type.
       ##

tidepool/flake.lock

@@ -8,10 +8,10 @@
       },
       "locked": {
         "dir": "foundation",
-        "dirtyRev": "2be3111b2c0911f40b47fe0a1fb22b5f5188cf59-dirty",
+        "dirtyRev": "9850da8aa9dc9be22e237c9b424a18e801e53ecb-dirty",
-        "dirtyShortRev": "2be3111-dirty",
+        "dirtyShortRev": "9850da8-dirty",
-        "lastModified": 1719251485,
+        "lastModified": 1718529861,
-        "narHash": "sha256-9G1TPBdlQNXCZf6A66bCT9m2vhodkSF+rDtqOVuFteY=",
+        "narHash": "sha256-X1Wd6mDz8GTaoxt1ylkvZfrJOcZtspJrEjXMtJ2ZyG0=",
         "type": "git",
         "url": "file:../?dir=foundation"
       },
@@ -24,10 +24,10 @@
     "lib": {
       "locked": {
         "dir": "lib",
-        "dirtyRev": "2be3111b2c0911f40b47fe0a1fb22b5f5188cf59-dirty",
+        "dirtyRev": "9850da8aa9dc9be22e237c9b424a18e801e53ecb-dirty",
-        "dirtyShortRev": "2be3111-dirty",
+        "dirtyShortRev": "9850da8-dirty",
-        "lastModified": 1719251485,
+        "lastModified": 1718529861,
-        "narHash": "sha256-9G1TPBdlQNXCZf6A66bCT9m2vhodkSF+rDtqOVuFteY=",
+        "narHash": "sha256-X1Wd6mDz8GTaoxt1ylkvZfrJOcZtspJrEjXMtJ2ZyG0=",
         "type": "git",
         "url": "file:../?dir=lib"
       },

tidepool/src/builders/basic.nix

@@ -14,18 +14,8 @@ in
       build =
         package:
         let
-          phases = lib.dag.apply.defaults package.phases {
+          phases = package.phases;
-            unpack = lib.dag.entry.before [ "patch" ] "";
+          sorted = lib.dag.sort.topological phases;
-
-            patch = lib.dag.entry.between [ "configure" ] [ "unpack" ] "";
-
-            configure = lib.dag.entry.between [ "build" ] [ "patch" ] "";
-
-            build = lib.dag.entry.between [ "install" ] [ "configure" ] "";
-
-            install = lib.dag.entry.after [ "build" ] "";
-          };
-          sorted = lib.dag.sort.topographic phases;
 
           script = lib.strings.concatMapSep "\n" (
             entry: if builtins.isFunction entry.value then entry.value package else entry.value
@@ -80,13 +70,7 @@ in
             }
           );
         in
-        built
+        built // { inherit (package) meta; };
-        // {
-          inherit (package) meta;
-          extras = {
-            inherit package;
-          };
-        };
     };
   };
 }

tidepool/src/export.nix

@@ -1,20 +1,18 @@
 # This file handles creating all of the exports for this project and is not
 # exported itself.
-{ config }:
+{ lib, config }:
 let
-  inherit (config) lib;
+  lib' = config.lib;
 in
 {
-  # freeform = lib.types.any;
+  freeform = lib.types.any;
 
   config = {
     exports = {
-      inherit lib;
+      lib = config.lib;
       modules = import ./modules.nix;
 
       packages = {
-        aux-a = config.packages.aux.a;
-
         # foundation-gcc-x86_64 =
         # (config.packages.foundation.gcc.versions."13.2.0".extend (args: {
         #   config = {
@@ -26,13 +24,11 @@ in
         # .config;
         foundation-gcc = config.packages.foundation.gcc;
         foundation-binutils = config.packages.foundation.binutils;
-        foundation-linux-headers = config.packages.foundation.linux-headers;
+        foundation-linux-headers = config.packages.foundation.linux-headers.versions.latest.extend {
-        # foundation-linux-headers = config.packages.foundation.linux-headers.versions.latest.extend {
+          platform.host = lib.modules.overrides.force "x86_64-linux";
-        #   platform.host = lib.modules.overrides.force "x86_64-linux";
+        };
-        # };
         # example-x = config.packages.example.x;
-        cross-aux-a-x86_64-linux = config.packages.cross.x86_64-linux.aux.a;
+        # cross-example-x-x86_64-linux = config.packages.cross.x86_64-linux.example.x;
-        cross-foundation-gcc-x86_64-linux = config.packages.cross.x86_64-linux.foundation.gcc;
       };
     };
 

tidepool/src/lib/options.nix

@@ -5,7 +5,7 @@ in
   config = {
     lib.options = {
       package = lib.options.create {
-        type = config.lib.types.package.base;
+        type = config.lib.types.package;
         description = "A package definition.";
       };
     };

tidepool/src/lib/packages.nix

@@ -1,7 +1,8 @@
-{ lib, config }:
+{
-let
+  lib,
-  lib' = config.lib;
+  lib',
-in
+  config,
+}:
 {
   config = {
     lib.packages = {
@@ -14,10 +15,6 @@ in
             );
           in
           builtins.map (dependency: dependency.package) available;
-
-        build =
-          build': host': target':
-          builtins.mapAttrs (name: dep: lib'.packages.build dep build' host' target');
       };
 
       getLatest =
@@ -28,89 +25,54 @@ in
         in
         builtins.head sorted;
 
-      resolve =
-        alias:
-        if alias ? versions then
-          alias.versions.${config.preferences.packages.version}
-            or (alias.versions.${lib'.packages.getLatest alias})
-        else
-          alias;
-
       build =
-        alias: build: host: target:
+        package: build: host: target:
         let
-          package = lib'.packages.resolve alias;
+          resolved =
+            if package ? versions then
+              package.versions.${config.preferences.packages.version}
+                or (package.versions.${lib'.packages.getLatest package})
+            else
+              package;
 
           buildDependencies =
             build': host': target':
             builtins.mapAttrs (name: dep: lib'.packages.build dep build' host' target');
 
-          platform = {
+          result = resolved.extend (
-            build = lib.modules.overrides.force build;
+            { config }:
-            host = lib.modules.overrides.force host;
+            {
-            target = lib.modules.overrides.force target;
+              config = {
-          };
+                platform = {
+                  build = build;
+                  host = host;
+                  target = lib.modules.override 150 target;
+                };
 
-          withPlatform = lib.modules.run {
+                deps = {
-            modules = package.__modules__ ++ [
+                  build = {
-              lib'.types.package.children.submodule
+                    only = buildDependencies build build build resolved.deps.build.only;
-              (
+                    build = buildDependencies build build target resolved.deps.build.build;
-                { config }:
+                    host = buildDependencies build host target resolved.deps.build.host;
-                {
+                    target = buildDependencies build target target resolved.deps.build.target;
-                  config = {
-                    __modules__ = package.__modules__;
-
-                    inherit platform;
                   };
-                }
+                  host = {
-              )
+                    only = buildDependencies host host host resolved.deps.host.only;
-            ];
+                    host = buildDependencies host host target resolved.deps.host.host;
-          };
+                    target = buildDependencies host target target resolved.deps.host.target;
-
-          # Not all platform information can be effectively handled via submodules. To handle
-          # the case where a user copies the resolved config over we need to ensure that
-          # dependencies are appropriately updated.
-          withDeps = withPlatform.config // {
-            deps = {
-              build = {
-                only = buildDependencies build build build withPlatform.config.deps.build.only;
-                build = buildDependencies build build target withPlatform.config.deps.build.build;
-                host = buildDependencies build host target withPlatform.config.deps.build.host;
-                target = buildDependencies build target target withPlatform.config.deps.build.target;
-              };
-              host = {
-                only = buildDependencies host host host withPlatform.config.deps.host.only;
-                host = buildDependencies host host target withPlatform.config.deps.host.host;
-                target = buildDependencies host target target withPlatform.config.deps.host.target;
-              };
-              target = {
-                only = buildDependencies target target target withPlatform.config.deps.target.only;
-                target = buildDependencies target target target withPlatform.config.deps.target.target;
-              };
-            };
-          };
-
-          withPackage = lib.modules.run {
-            modules = package.__modules__ ++ [
-              lib'.types.package.children.submodule
-              (
-                { config }:
-                {
-                  config = {
-                    __modules__ = package.__modules__;
-
-                    inherit platform;
-
-                    deps = lib.modules.overrides.force withDeps.deps;
-
-                    package = lib.modules.overrides.force (withDeps.builder.build withDeps);
                   };
-                }
+                  target = {
-              )
+                    only = buildDependencies target target target resolved.deps.target.only;
-            ];
+                    target = buildDependencies target target target resolved.deps.target.target;
-          };
+                  };
+                };
+
+                package = config.builder.build config;
+              };
+            }
+          );
         in
-        withPackage.config;
+        result;
     };
   };
 }

tidepool/src/lib/systems.nix

@@ -1220,7 +1220,6 @@ in
               vendor,
               kernel,
               abi,
-              ...
             }:
             types.cpu.check cpu
             && types.vendor.check vendor
@@ -1228,17 +1227,6 @@ in
             && types.abi.check abi;
         };
 
-        platformWithBuildInfo = lib.types.create {
-          name = "systemWithBuildInfo";
-          description = "fully parsed representation of llvm- or nix-style platform tuple with build information";
-          merge = lib.options.merge.one;
-          check =
-            value:
-            lib.types.is "systemWithBuildInfo" value
-            && value ? system
-            && lib'.systems.types.platform.check value.system;
-        };
-
         endian = lib.types.enum (builtins.attrValues types.endians);
 
         endians = setTypes types.generic.endian {
@@ -2804,7 +2792,7 @@ in
         assert resolved.useAndroidPrebuilt -> resolved.isAndroid;
         assert assertions;
         # And finally, return the generated system info.
-        lib.types.set "systemWithBuildInfo" resolved;
+        resolved;
     };
   };
 }

tidepool/src/lib/types.nix

@@ -1,9 +1,8 @@
-{ lib, config }:
+{
-let
+  lib,
-  inherit (config) preferences builders;
+  lib',
-
+  config,
-  lib' = config.lib;
+}:
-in
 {
   config = {
     lib.types = {
@@ -56,10 +55,6 @@ in
         in
         lib.types.either type (lib.types.list.of type);
 
-      platform =
-        lib.types.coerce lib.types.string lib'.systems.withBuildInfo
-          lib'.systems.types.platformWithBuildInfo;
-
       builder = lib.types.submodule {
         freeform = lib.types.any;
 
@@ -71,316 +66,256 @@ in
         };
       };
 
-      packages = lib.types.attrs.of (lib.types.attrs.of lib'.types.alias);
+      packages = lib.types.attrs.of (lib'.types.alias);
 
-      dependencies =
+      alias = lib.types.attrs.of (
-        build: host: target:
+        lib.types.submodule {
-        let
+          options = {
-          initial = lib.types.raw;
+            versions = lib.options.create {
-
+              description = "All available package versions.";
-          transform =
+              type = lib.types.attrs.of lib'.types.package;
-            value:
+            };
-            let
-              package = lib'.packages.resolve value;
-            in
-            lib'.packages.build package build host target;
-        in
-        lib.types.attrs.of (lib.types.coerce initial transform lib'.types.package);
-
-      alias = lib.types.submodule {
-        options = {
-          stable = lib.options.create {
-            description = "The stable version of the package.";
-            type = lib.types.nullish lib'.types.package;
           };
+        }
+      );
 
-          latest = lib.options.create {
+      dependencies = lib.types.attrs.of (
-            description = "The latest version of the package.";
+        lib.types.nullish (lib.types.either lib'.types.alias lib'.types.package)
-            type = lib'.types.package;
+      );
-          };
 
-          versions = lib.options.create {
+      package = lib.types.submodule (
-            description = "Available versions of the package.";
+        { config, meta }:
-            type = lib.types.attrs.of lib'.types.package;
+        {
-            default.value = { };
+          options = {
-          };
+            extend = lib.options.create {
-        };
+              description = "Extend the package's submodules with additional configuration.";
-      };
+              type = lib.types.function lib.types.raw;
+              default.value =
+                value:
+                let
+                  result = meta.extend {
+                    modules = if builtins.isAttrs value then [ { config = value; } ] else lib.lists.from.any value;
+                  };
+                in
+                result.config;
+            };
 
-      package =
+            name = lib.options.create {
-        let
+              description = "The name of the package.";
-          normalize =
+              type = lib.types.string;
-            value:
+              default = {
-            if builtins.isFunction value || builtins.isList value then
+                text = "\${config.pname}-\${config.version}";
-              value
+                value =
-            else if value ? __modules__ then
+                  if config.pname != null && config.version != null then "${config.pname}-${config.version}" else "";
-              value.__modules__
-            else
-              { config = value; };
-
-          initial = lib.types.create {
-            name = "PackageConfig";
-            description = "configuration for a package";
-            check = value: builtins.isFunction value || builtins.isAttrs value || builtins.isList value;
-            merge =
-              location: definitions:
-              let
-                normalized = builtins.map (definition: lib.lists.from.any (normalize definition.value)) definitions;
-              in
-              builtins.concatLists normalized;
-          };
-
-          transform =
-            location: value:
-            let
-              modules = lib.lists.from.any (normalize value);
-
-              result = lib.modules.run {
-                prefix = location;
-                modules = modules ++ [
-                  submodule
-                  { config.__modules__ = modules; }
-                ];
               };
-            in
+            };
-            result.config;
 
-          final = lib.types.raw;
+            pname = lib.options.create {
+              description = "The program name for the package";
+              type = lib.types.nullish lib.types.string;
+              default.value = null;
+            };
 
-          deps =
+            version = lib.options.create {
-            build: host: target:
+              description = "The version for the package.";
-            lib.types.submodule {
+              type = lib.types.nullish lib.types.version;
-              options = {
+              default.value = null;
-                build = {
+            };
-                  only = lib.options.create {
-                    description = "Dependencies which are only used in the build environment.";
-                    type = lib'.types.dependencies build build build;
-                    default.value = { };
-                  };
 
-                  build = lib.options.create {
+            meta = {
-                    description = "Dependencies which are created in the build environment and are executed in the build environment.";
+              description = lib.options.create {
-                    type = lib'.types.dependencies build build target;
+                description = "The description for the package.";
-                    default.value = { };
+                type = lib.types.nullish lib.types.string;
-                  };
+                default.value = null;
+              };
 
-                  host = lib.options.create {
+              homepage = lib.options.create {
-                    description = "Dependencies which are created in the build environment and are executed in the host environment.";
+                description = "The homepage for the package.";
-                    type = lib'.types.dependencies build host target;
+                type = lib.types.nullish lib.types.string;
-                    default.value = { };
+                default.value = null;
-                  };
+              };
 
-                  target = lib.options.create {
+              license = lib.options.create {
-                    description = "Dependencies which are created in the build environment and are executed in the target environment.";
+                description = "The license for the package.";
-                    type = lib'.types.dependencies build target target;
+                type = lib.types.nullish lib'.types.license;
-                    default.value = { };
+                default.value = null;
-                  };
+              };
+
+              free = lib.options.create {
+                description = "Whether the package is free.";
+                type = lib.types.bool;
+                default.value = true;
+              };
+
+              insecure = lib.options.create {
+                description = "Whether the package is insecure.";
+                type = lib.types.bool;
+                default.value = false;
+              };
+
+              broken = lib.options.create {
+                description = "Whether the package is broken.";
+                type = lib.types.bool;
+                default.value = false;
+              };
+
+              main = lib.options.create {
+                description = "The main entry point for the package.";
+                type = lib.types.nullish lib.types.string;
+                default.value = null;
+              };
+
+              platforms = lib.options.create {
+                description = "The platforms the package supports.";
+                type = lib.types.list.of lib.types.string;
+                default.value = [ ];
+              };
+            };
+
+            platform = {
+              build = lib.options.create {
+                description = "The build platform for the package.";
+                type = lib.types.string;
+                default.value = "x86_64-linux";
+                apply =
+                  raw:
+                  let
+                    system = lib'.systems.from.string raw;
+                    x = lib'.systems.withBuildInfo raw;
+                  in
+                  x;
+              };
+
+              host = lib.options.create {
+                description = "The host platform for the package.";
+                type = lib.types.string;
+                default.value = "x86_64-linux";
+                # apply = raw: let
+                #   system = lib'.systems.from.string raw;
+                # in {
+                #   inherit raw system;
+
+                #   double = lib'.systems.into.double system;
+                #   triple = lib'.systems.into.triple system;
+                # };
+                apply =
+                  raw:
+                  let
+                    system = lib'.systems.from.string raw;
+                    x = lib'.systems.withBuildInfo raw;
+                  in
+                  x;
+              };
+
+              target = lib.options.create {
+                description = "The target platform for the package.";
+                type = lib.types.string;
+                default.value = "x86_64-linux";
+                # apply = raw: let
+                #   system = lib'.systems.from.string raw;
+                # in {
+                #   inherit raw system;
+
+                #   double = lib'.systems.into.double system;
+                #   triple = lib'.systems.into.triple system;
+                # };
+                apply =
+                  raw:
+                  let
+                    system = lib'.systems.from.string raw;
+                    x = lib'.systems.withBuildInfo raw;
+                  in
+                  x;
+              };
+            };
+
+            phases = lib.options.create {
+              description = "The phases for the package.";
+              type = lib.types.dag.of (lib.types.either lib.types.string (lib.types.function lib.types.string));
+              default.value = { };
+            };
+
+            env = lib.options.create {
+              description = "The environment for the package.";
+              type = lib.types.attrs.of lib.types.string;
+              default.value = { };
+            };
+
+            builder = lib.options.create {
+              description = "The builder for the package.";
+              type = lib'.types.builder;
+            };
+
+            deps = {
+              build = {
+                only = lib.options.create {
+                  description = "Dependencies which are only used in the build environment.";
+                  type = lib'.types.dependencies;
+                  default.value = { };
                 };
 
-                host = {
+                build = lib.options.create {
-                  only = lib.options.create {
+                  description = "Dependencies which are created in the build environment and are executed in the build environment.";
-                    description = "Dependencies which are only used in the host environment.";
+                  type = lib'.types.dependencies;
-                    type = lib'.types.dependencies host host host;
+                  default.value = { };
-                    default.value = { };
-                  };
-
-                  host = lib.options.create {
-                    description = "Dependencies which are executed in the host environment.";
-                    type = lib'.types.dependencies host host target;
-                    default.value = { };
-                  };
-
-                  target = lib.options.create {
-                    description = "Dependencies which are executed in the host environment which produces code for the target environment.";
-                    type = lib'.types.dependencies host target target;
-                    default.value = { };
-                  };
                 };
 
-                target = {
+                host = lib.options.create {
-                  only = lib.options.create {
+                  description = "Dependencies which are created in the build environment and are executed in the host environment.";
-                    description = "Dependencies which are only used in the target environment.";
+                  type = lib'.types.dependencies;
-                    type = lib'.types.dependencies target target target;
+                  default.value = { };
-                    default.value = { };
+                };
-                  };
 
-                  target = lib.options.create {
+                target = lib.options.create {
-                    description = "Dependencies which are executed in the target environment.";
+                  description = "Dependencies which are created in the build environment and are executed in the target environment.";
-                    type = lib'.types.dependencies target target target;
+                  type = lib'.types.dependencies;
-                    default.value = { };
+                  default.value = { };
-                  };
+                };
+              };
+
+              host = {
+                only = lib.options.create {
+                  description = "Dependencies which are only used in the host environment.";
+                  type = lib'.types.dependencies;
+                  default.value = { };
+                };
+
+                host = lib.options.create {
+                  description = "Dependencies which are executed in the host environment.";
+                  type = lib'.types.dependencies;
+                  default.value = { };
+                };
+
+                target = lib.options.create {
+                  description = "Dependencies which are executed in the host environment which produces code for the target environment.";
+                  type = lib'.types.dependencies;
+                  default.value = { };
+                };
+              };
+
+              target = {
+                only = lib.options.create {
+                  description = "Dependencies which are only used in the target environment.";
+                  type = lib'.types.dependencies;
+                  default.value = { };
+                };
+
+                target = lib.options.create {
+                  description = "Dependencies which are executed in the target environment.";
+                  type = lib'.types.dependencies;
+                  default.value = { };
                 };
               };
             };
 
-          submodule =
+            package = lib.options.create {
-            { config }:
+              description = "The built derivation.";
-            let
+              type = lib.types.derivation;
-              build = config.platform.build;
+              default.value = config.builder.build config;
-              host = config.platform.host;
-              target = config.platform.target;
-            in
-            {
-              options = {
-                __modules__ = lib.options.create {
-                  description = "User specified modules for the package definition.";
-                  type = lib.types.list.of (initial // { merge = lib.options.merge.one; });
-                  # writable = false;
-                  internal = true;
-                  default.value = [ ];
-                };
-
-                meta = {
-                  description = lib.options.create {
-                    description = "The description for the package.";
-                    type = lib.types.nullish lib.types.string;
-                    default.value = null;
-                  };
-
-                  homepage = lib.options.create {
-                    description = "The homepage for the package.";
-                    type = lib.types.nullish lib.types.string;
-                    default.value = null;
-                  };
-
-                  license = lib.options.create {
-                    description = "The license for the package.";
-                    type = lib.types.nullish lib'.types.license;
-                    default.value = null;
-                  };
-
-                  free = lib.options.create {
-                    description = "Whether the package is free.";
-                    type = lib.types.bool;
-                    default.value = true;
-                  };
-
-                  insecure = lib.options.create {
-                    description = "Whether the package is insecure.";
-                    type = lib.types.bool;
-                    default.value = false;
-                  };
-
-                  broken = lib.options.create {
-                    description = "Whether the package is broken.";
-                    type = lib.types.bool;
-                    default.value = false;
-                  };
-
-                  main = lib.options.create {
-                    description = "The main entry point for the package.";
-                    type = lib.types.nullish lib.types.string;
-                    default.value = null;
-                  };
-
-                  platforms = lib.options.create {
-                    description = "The platforms the package supports.";
-                    type = lib.types.list.of lib.types.string;
-                    default.value = [ ];
-                  };
-                };
-
-                platform = {
-                  build = lib.options.create {
-                    description = "The build platform for the package.";
-                    type = lib'.types.platform;
-                    default.value = lib'.systems.withBuildInfo "x86_64-linux";
-                  };
-
-                  host = lib.options.create {
-                    description = "The host platform for the package.";
-                    type = lib'.types.platform;
-                    default.value = lib'.systems.withBuildInfo "x86_64-linux";
-                  };
-
-                  target = lib.options.create {
-                    description = "The target platform for the package.";
-                    type = lib'.types.platform;
-                    default.value = lib'.systems.withBuildInfo "x86_64-linux";
-                  };
-                };
-
-                name = lib.options.create {
-                  description = "The name of the package.";
-                  type = lib.types.string;
-                  default = {
-                    text = "\${config.pname}-\${config.version}";
-                    value =
-                      if config.pname != null && config.version != null then "${config.pname}-${config.version}" else "";
-                  };
-                };
-
-                pname = lib.options.create {
-                  description = "The program name for the package";
-                  type = lib.types.nullish lib.types.string;
-                  default.value = null;
-                };
-
-                version = lib.options.create {
-                  description = "The version for the package.";
-                  type = lib.types.nullish lib.types.version;
-                  default.value = null;
-                };
-
-                builder = lib.options.create {
-                  description = "The builder for the package.";
-                  type = lib'.types.builder;
-                };
-
-                phases = lib.options.create {
-                  description = "The phases for the package.";
-                  type = lib.types.dag.of lib.types.string;
-                  default.value = { };
-                };
-
-                env = lib.options.create {
-                  description = "The environment for the package.";
-                  type = lib.types.attrs.of lib.types.string;
-                  default.value = { };
-                };
-
-                package = lib.options.create {
-                  description = "The built derivation.";
-                  type = lib.types.derivation;
-                  default.value = config.builder.build config;
-                };
-
-                deps = lib.options.create {
-                  description = "The dependencies for the package.";
-                  type = deps build host target;
-                  default.value = { };
-                  apply = value: {
-                    build = {
-                      only = lib'.packages.dependencies.build build build build value.build.only;
-                      build = lib'.packages.dependencies.build build build target value.build.build;
-                      host = lib'.packages.dependencies.build build host target value.build.host;
-                      target = lib'.packages.dependencies.build build target target value.build.target;
-                    };
-                    host = {
-                      only = lib'.packages.dependencies.build host host host value.host.only;
-                      host = lib'.packages.dependencies.build host host target value.host.host;
-                      target = lib'.packages.dependencies.build host target target value.host.target;
-                    };
-                    target = {
-                      only = lib'.packages.dependencies.build target target target value.target.only;
-                      target = lib'.packages.dependencies.build target target target value.target.target;
-                    };
-                  };
-                };
-              };
             };
-
-          type = (lib.types.coerceWithLocation initial transform final) // {
-            name = "Package";
-            description = "a package definition";
           };
-        in
+        }
-        type
+      );
-        // {
-          children = type.children // {
-            inherit submodule;
-          };
-        };
     };
   };
 }

tidepool/src/packages/aux/a.nix

@@ -1,36 +0,0 @@
-{ lib', config }:
-let
-  inherit (config) builders packages;
-in
-{
-  config.packages.aux.a = {
-    versions = {
-      "latest" =
-        { config }:
-        {
-          config = {
-            meta = {
-              platforms = [ "i686-linux" ];
-            };
-
-            name = "${config.pname}-${config.version}";
-
-            pname = "a";
-            version = "1.0.0";
-
-            builder = builders.basic;
-
-            deps.build.host = {
-              inherit (packages.aux) b;
-            };
-
-            phases = {
-              install = ''
-                echo "a with b: ${config.deps.build.host.b.package.system}" > $out
-              '';
-            };
-          };
-        };
-    };
-  };
-}

tidepool/src/packages/aux/b.nix

@@ -1,38 +0,0 @@
-{ config }:
-let
-  inherit (config) lib builders packages;
-in
-{
-  config.packages.aux.b = {
-    versions = {
-      "latest" =
-        { config }:
-        {
-          options = {
-            custom = lib.options.create { type = lib.types.bool; };
-          };
-
-          config = {
-            meta = {
-              platforms = [ "i686-linux" ];
-            };
-
-            name = "${config.pname}-${config.version}";
-
-            custom = true;
-
-            pname = "b";
-            version = "1.0.0";
-
-            builder = builders.basic;
-
-            phases = {
-              install = ''
-                echo "b" > $out
-              '';
-            };
-          };
-        };
-    };
-  };
-}

tidepool/src/packages/default.nix

@@ -1,29 +1,27 @@
-{ config }:
+{
+  lib,
+  lib',
+  config,
+}:
 let
-  inherit (config) lib;
+  doubles = lib'.systems.doubles.all;
-
-  doubles = lib.systems.doubles.all;
 
   packages = builtins.removeAttrs config.packages [ "cross" ];
 in
 {
-  includes = [
+  includes = [ ./foundation ];
-    ./foundation
-    ./aux/a.nix
-    ./aux/b.nix
-  ];
 
   options = {
     packages = lib.options.create {
       description = "The package set.";
       type = lib.types.submodule {
-        freeform = lib.types.packages;
+        freeform = lib.types.attrs.of (lib.types.submodule { freeform = lib'.types.alias; });
 
         options.cross = lib.attrs.generate doubles (
           system:
           lib.options.create {
             description = "The cross-compiled package set for the ${system} target.";
-            type = lib.types.packages;
+            type = lib'.types.packages;
             default = { };
           }
         );
@@ -51,49 +49,38 @@ in
         let
           setHost =
             package:
-            package
+            if package != { } then
-            // {
+              (package.extend (
-              __modules__ = package.__modules__ ++ [
+                { config }:
                 {
-                  config.platform = {
+                  config = {
-                    host = lib.modules.override 5 system;
+                    platform = {
-                    target = lib.modules.override 5 system;
+                      host = lib.modules.overrides.force system;
+                      target = lib.modules.overrides.default system;
+                    };
+
+                    deps = {
+                      build = {
+                        only = setHost package.deps.build.only;
+                        build = setHost package.deps.build.build;
+                        host = setHost package.deps.build.host;
+                        target = setHost package.deps.build.target;
+                      };
+                      host = {
+                        only = setHost package.deps.host.only;
+                        host = setHost package.deps.host.host;
+                        target = setHost package.deps.host.target;
+                      };
+                      target = {
+                        only = setHost package.deps.target.only;
+                        target = setHost package.deps.target.target;
+                      };
+                    };
                   };
                 }
-              ];
+              )).config
-            };
+            else
-          # if package != {}
+              package;
-          # then
-          #   (package.extend (
-          #     {config}: {
-          #       config = {
-          #         platform = {
-          #           host = lib.modules.overrides.force system;
-          #           target = lib.modules.overrides.default system;
-          #         };
-
-          #         deps = {
-          #           build = {
-          #             only = setHost package.deps.build.only;
-          #             build = setHost package.deps.build.build;
-          #             host = setHost package.deps.build.host;
-          #             target = setHost package.deps.build.target;
-          #           };
-          #           host = {
-          #             only = setHost package.deps.host.only;
-          #             host = setHost package.deps.host.host;
-          #             target = setHost package.deps.host.target;
-          #           };
-          #           target = {
-          #             only = setHost package.deps.target.only;
-          #             target = setHost package.deps.target.target;
-          #           };
-          #         };
-          #       };
-          #     }
-          #   ))
-          #   .config
-          # else package;
 
           updated = alias // {
             versions = builtins.mapAttrs (version: package: setHost package) alias.versions;

tidepool/src/packages/foundation/binutils/default.nix

@@ -11,14 +11,13 @@ let
     # These are the upstream foundational packages exported from the Aux Foundation project.
 
     foundation
-    packages
     ;
 in
 {
   config.packages.foundation.binutils = {
     versions = {
       "latest" =
-        { config }:
+        { config, meta }:
         {
           options = {
             src = lib.options.create {
@@ -37,17 +36,9 @@ in
 
             builder = builders.basic;
 
-            deps = {
-              build = {
-                host = {
-                  inherit (packages.foundation) gcc;
-                };
-              };
-            };
-
             env = {
               PATH = lib.paths.bin [
-                # foundation.stage2-gcc
+                foundation.stage2-gcc
                 foundation.stage2-binutils
                 foundation.stage2-gnumake
                 foundation.stage2-gnupatch
@@ -95,24 +86,24 @@ in
                 ];
               in
               {
-                unpack = ''
+                unpack = lib.dag.entry.before [ "patch" ] ''
                   tar xf ${config.src}
                   cd binutils-${config.version}
                 '';
 
-                patch = ''
+                patch = lib.dag.entry.between [ "configure" ] [ "unpack" ] ''
                   ${lib.strings.concatMapSep "\n" (file: "patch -Np1 -i ${file}") patches}
                 '';
 
-                configure = ''
+                configure = lib.dag.entry.between [ "build" ] [ "patch" ] ''
                   bash ./configure ${builtins.concatStringsSep " " configureFlags}
                 '';
 
-                build = ''
+                build = lib.dag.entry.between [ "install" ] [ "configure" ] ''
                   make -j $NIX_BUILD_CORES
                 '';
 
-                install = ''
+                install = lib.dag.entry.after [ "build" ] ''
                   make -j $NIX_BUILD_CORES install-strip
                 '';
               };

tidepool/src/packages/foundation/default.nix

@@ -9,8 +9,6 @@
     ./gcc
     ./binutils
     ./linux-headers
-    ./glibc
-    # ./xz
   ];
 
   config = {

tidepool/src/packages/foundation/gcc/default.nix

@@ -1,13 +1,16 @@
-{ config, options }:
+{
+  lib,
+  lib',
+  config,
+  options,
+}:
 let
   inherit (config)
-    lib
     mirrors
     builders
     # These are the upstream foundational packages exported from the Aux Foundation project.
 
     foundation
-    packages
     ;
 in
 {
@@ -88,30 +91,51 @@ in
             builder = builders.basic;
 
             env = {
-              PATH = lib.paths.bin [
+              PATH =
-                foundation.stage2-gcc
+                let
-                foundation.stage2-binutils
+                  gcc =
-                foundation.stage2-gnumake
+                    if
-                foundation.stage2-gnused
+                      config.platform.build.triple == config.platform.host.triple
-                foundation.stage2-gnugrep
+                    # If we're on the same system then we can use the existing GCC instance.
-                foundation.stage2-gawk
+                    then
-                foundation.stage2-diffutils
+                      foundation.stage2-gcc
-                foundation.stage2-findutils
+                    # Otherwise we are going to need a cross-compiler.
-                foundation.stage2-gnutar
+                    else
-                foundation.stage2-gzip
+                      # TODO: Create a gcc-cross package.
-                foundation.stage2-bzip2
+                      (meta.extend (args: {
-                foundation.stage1-xz
+                        config = {
-              ];
+                          platform = {
+                            build = config.platform.build.triple;
+                            host = config.platform.build.triple;
+                            target = lib.modules.override.force config.platform.host.triple;
+                          };
+                        };
+                      })).config.package;
+                in
+                lib.paths.bin [
+                  foundation.stage2-gcc
+                  foundation.stage2-binutils
+                  foundation.stage2-gnumake
+                  foundation.stage2-gnused
+                  foundation.stage2-gnugrep
+                  foundation.stage2-gawk
+                  foundation.stage2-diffutils
+                  foundation.stage2-findutils
+                  foundation.stage2-gnutar
+                  foundation.stage2-gzip
+                  foundation.stage2-bzip2
+                  foundation.stage1-xz
+                ];
             };
 
             phases =
               let
-                host = lib.systems.withBuildInfo config.platform.host;
+                host = lib'.systems.withBuildInfo config.platform.host;
 
                 mbits = if host.system.cpu.family == "x86" then if host.is64bit then "-m64" else "-m32" else "";
               in
               {
-                unpack = ''
+                unpack = lib.dag.entry.before [ "patch" ] ''
                   # Unpack
                   tar xf ${config.src}
                   tar xf ${config.gmp.src}
@@ -126,15 +150,17 @@ in
                   ln -s ../isl-${config.isl.version} isl
                 '';
 
-                patch = ''
+                patch = lib.dag.entry.between [ "configure" ] [ "unpack" ] ''
                   # Patch
                   # force musl even if host triple is gnu
                   sed -i 's|"os/gnu-linux"|"os/generic"|' libstdc++-v3/configure.host
                 '';
 
-                configure = ''
+                configure = lib.dag.entry.between [ "build" ] [ "patch" ] ''
                   # Configure
-                  export CC="gcc -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
+                  export CC="gcc -Wl,-dynamic-linker -march=${
+                    host.gcc.arch or host.system.cpu.family
+                  } ${mbits} -Wl,${foundation.stage1-musl}/lib/libc.so"
                   export CXX="g++ -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
                   export CFLAGS_FOR_TARGET="-Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
                   export LIBRARY_PATH="${foundation.stage1-musl}/lib"
@@ -156,12 +182,12 @@ in
                     CXXFLAGS=-static
                 '';
 
-                build = ''
+                build = lib.dag.entry.between [ "install" ] [ "configure" ] ''
                   # Build
                   make -j $NIX_BUILD_CORES
                 '';
 
-                install = ''
+                install = lib.dag.entry.after [ "build" ] ''
                   # Install
                   make -j $NIX_BUILD_CORES install-strip
                 '';

tidepool/src/packages/foundation/linux-headers/default.nix

@@ -54,16 +54,20 @@ in
             };
 
             phases = {
-              unpack = ''
+              unpack = lib.dag.entry.before [ "patch" ] ''
                 tar xf ${config.src}
                 cd linux-${config.version}
               '';
 
-              build = ''
+              patch = lib.dag.entry.between [ "configure" ] [ "unpack" ] '''';
+
+              configure = lib.dag.entry.between [ "build" ] [ "patch" ] '''';
+
+              build = lib.dag.entry.between [ "install" ] [ "configure" ] ''
                 make -j $NIX_BUILD_CORES CC=musl-gcc HOSTCC=musl-gcc ARCH=${config.platform.host.linux.arch} headers
               '';
 
-              install = ''
+              install = lib.dag.entry.after [ "build" ] ''
                 find usr/include -name '.*' -exec rm {} +
                 mkdir -p $out
                 cp -rv usr/include $out/