refactor: only support i686-linux for foundation gcc

foundation/flake.lock

@@ -3,10 +3,10 @@
     "lib": {
       "locked": {
         "dir": "lib",
-        "dirtyRev": "a707b0f06be6b36bcbfe88d0a9a5b9a803983a06-dirty",
+        "dirtyRev": "2be3111b2c0911f40b47fe0a1fb22b5f5188cf59-dirty",
-        "dirtyShortRev": "a707b0f-dirty",
+        "dirtyShortRev": "2be3111-dirty",
-        "lastModified": 1719079124,
+        "lastModified": 1719251485,
-        "narHash": "sha256-4HwA3q5f7SUBmcXX9Vz9WsA9oHBQ/GiZTwE4iSVq9s8=",
+        "narHash": "sha256-63NvfFVeTDITfNu60rmCUlaZtAeZUnvrIaOLSk9ScC8=",
         "type": "git",
         "url": "file:../?dir=lib"
       },

lib/src/options/default.nix

@@ -4,9 +4,7 @@ lib: {
       ## Merge a list of option definitions into a single value.
       ##
       ## @type Location -> List Definition -> Any
-      default =
+      default = location: definitions: let
-        location: definitions:
-        let
         values = lib.options.getDefinitionValues definitions;
         first = builtins.elemAt values 0;
         mergedFunctions = x: lib.options.mergeDefault location (builtins.map (f: f x) values);
@@ -15,35 +13,30 @@ lib: {
         mergedBools = builtins.any lib.bools.or false values;
         mergedStrings = lib.strings.concat values;
       in
-        if builtins.length values == 1 then
+        if builtins.length values == 1
-          builtins.elemAt values 0
+        then builtins.elemAt values 0
-        else if builtins.all builtins.isFunction values then
+        else if builtins.all builtins.isFunction values
-          mergedFunctions
+        then mergedFunctions
-        else if builtins.all builtins.isList values then
+        else if builtins.all builtins.isList values
-          mergedLists
+        then mergedLists
-        else if builtins.all builtins.isAttrs values then
+        else if builtins.all builtins.isAttrs values
-          mergedAttrs
+        then mergedAttrs
-        else if builtins.all builtins.isBool values then
+        else if builtins.all builtins.isBool values
-          mergedBools
+        then mergedBools
-        else if builtins.all lib.strings.isString values then
+        else if builtins.all lib.strings.isString values
-          mergedStrings
+        then mergedStrings
-        else if builtins.all builtins.isInt values && builtins.all (x: x == first) values then
+        else if builtins.all builtins.isInt values && builtins.all (x: x == first) values
-          first
+        then first
         # TODO: Improve this error message to show the location and definitions for the option.
-        else
+        else builtins.throw "Cannot merge definitions.";
-          builtins.throw "Cannot merge definitions.";
 
       ## Merge multiple option definitions together.
       ##
       ## @type Location -> Type -> List Definition
-      definitions =
+      definitions = location: type: definitions: let
-        location: type: definitions:
-        let
         identifier = lib.options.getIdentifier location;
-          resolve =
+        resolve = definition: let
-            definition:
+          properties = builtins.addErrorContext "while evaluating definitions from `${definition.__file__ or "<unknown>"}`:" (
-            let
-              properties = builtins.addErrorContext "while evaluating definitions from `${definition.__file__}`:" (
             lib.modules.apply.properties definition.value
           );
           normalize = value: {
@@ -57,27 +50,27 @@ lib: {
         overridden = lib.modules.apply.overrides resolved;
 
         values =
-            if builtins.any (definition: lib.types.is "order" definition.value) overridden.values then
+          if builtins.any (definition: lib.types.is "order" definition.value) overridden.values
-              lib.modules.apply.order overridden.values
+          then lib.modules.apply.order overridden.values
-            else
+          else overridden.values;
-              overridden.values;
 
         isDefined = values != [];
 
         invalid = builtins.filter (definition: !(type.check definition.value)) values;
 
         merged =
-            if isDefined then
+          if isDefined
-              if builtins.all (definition: type.check definition.value) values then
+          then
-                type.merge location values
+            if builtins.all (definition: type.check definition.value) values
-              else
+            then type.merge location values
-                builtins.throw "A definition for `${identifier}` is not of type `${type.description}`. Definition values:${lib.options.getDefinitions invalid}"
+            else builtins.throw "A definition for `${identifier}` is not of type `${type.description}`. Definition values:${lib.options.getDefinitions invalid}"
-            else
+          else builtins.throw "The option `${identifier}` is used but not defined.";
-              builtins.throw "The option `${identifier}` is used but not defined.";
 
-          optional = if isDefined then { value = merged; } else { };
+        optional =
-        in
+          if isDefined
-        {
+          then {value = merged;}
+          else {};
+      in {
         inherit
           isDefined
           values
@@ -94,12 +87,8 @@ lib: {
       ## Merge multiple option declarations together.
       ##
       ## @type Location -> List Option
-      declarations =
+      declarations = location: options: let
-        location: options:
+        merge = result: option: let
-        let
-          merge =
-            result: option:
-            let
           mergedType = result.type.mergeType option.options.type.functor;
           isTypeMergeable = mergedType != null;
           shared = name: option.options ? ${name} && result ? ${name};
@@ -108,14 +97,15 @@ lib: {
           serializedFiles = builtins.concatStringsSep " and " files;
           getSubModules = option.options.type.getSubModules or null;
           submodules =
-                if getSubModules != null then
+            if getSubModules != null
+            then
               builtins.map (module: {
                 __file__ = option.__file__;
                 includes = [module];
-                  }) getSubModules
+              })
+              getSubModules
               ++ result.options
-                else
+            else result.options;
-                  result.options;
         in
           if
             shared "default"
@@ -123,8 +113,7 @@ lib: {
             || shared "description"
             || shared "apply"
             || (shared "type" && !isTypeMergeable)
-            then
+          then builtins.throw "The option `${lib.options.getIdentifier location}` in `${option.__file__}` is already declared in ${serializedFiles}"
-              builtins.throw "The option `${lib.options.getIdentifier location}` in `${option.__file__}` is already declared in ${serializedFiles}"
           else
             option.options
             // result
@@ -138,50 +127,43 @@ lib: {
           inherit location;
           declarations = [];
           options = [];
-        } options;
+        }
+        options;
 
       ## Merge an option, only supporting a single unique definition.
       ##
       ## @type String -> Location -> List Definition -> Any
-      unique =
+      unique = message: location: definitions: let
-        message: location: definitions:
-        let
         identifier = lib.options.getIdentifier location;
         total = builtins.length definitions;
         first = builtins.elemAt definitions 0;
       in
-        if total == 1 then
+        if total == 1
-          first.value
+        then first.value
-        else if total == 0 then
+        else if total == 0
-          builtins.throw "Cannot merge unused option `${identifier}`.\n${message}"
+        then builtins.throw "Cannot merge unused option `${identifier}`.\n${message}"
-        else
+        else builtins.throw "The option `${identifier}` is defined multiple times, but must be unique.\n${message}\nDefinitions:${lib.options.getDefinitions definitions}";
-          builtins.throw "The option `${identifier}` is defined multiple times, but must be unique.\n${message}\nDefinitions:${lib.options.getDefinitions definitions}";
 
       ## Merge a single instance of an option.
       ##
       ## @type Location -> List Definition -> Any
       one = lib.options.merge.unique "";
 
-      equal =
+      equal = location: definitions: let
-        location: definitions:
-        let
         identifier = lib.options.getIdentifier location;
         first = builtins.elemAt definitions 0;
         rest = builtins.tail definitions;
-          merge =
+        merge = x: y:
-            x: y:
+          if x != y
-            if x != y then
+          then builtins.throw "The option `${identifier}` has conflicting definitions:${lib.options.getDefinitions definitions}"
-              builtins.throw "The option `${identifier}` has conflicting definitions:${lib.options.getDefinitions definitions}"
+          else x;
-            else
-              x;
         merged = builtins.foldl' merge first rest;
       in
-        if builtins.length definitions == 0 then
+        if builtins.length definitions == 0
-          builtins.throw "Cannot merge unused option `${identifier}`."
+        then builtins.throw "Cannot merge unused option `${identifier}`."
-        else if builtins.length definitions == 1 then
+        else if builtins.length definitions == 1
-          first.value
+        then first.value
-        else
+        else merged.value;
-          merged.value;
     };
 
     ## Check whether a value is an option.
@@ -192,8 +174,7 @@ lib: {
     ## Create an option.
     ##
     ## @type { type? :: String | Null, apply? :: (a -> b) | Null, default? :: { value :: a, text :: String }, example? :: String | Null, visible? :: Bool | Null, internal? :: Bool | Null, writable? :: Bool | Null, description? :: String | Null } -> Option a
-    create =
+    create = settings @ {
-      settings@{
       type ? lib.types.unspecified,
       apply ? null,
       default ? {},
@@ -202,8 +183,7 @@ lib: {
       internal ? null,
       writable ? null,
       description ? null,
-      }:
+    }: {
-      {
       __type__ = "option";
       inherit
         type
@@ -220,9 +200,7 @@ lib: {
     ## Create a sink option.
     ##
     ## @type @alias lib.options.create
-    sink =
+    sink = settings: let
-      settings:
-      let
       defaults = {
         internal = true;
         visible = false;
@@ -246,9 +224,7 @@ lib: {
     ## Convert a list of option identifiers into a single identifier.
     ##
     ## @type List String -> String
-    getIdentifier =
+    getIdentifier = location: let
-      location:
-      let
       special = [
         # lib.types.attrs.of (lib.types.submodule {})
         "<name>"
@@ -257,23 +233,24 @@ lib: {
         # lib.types.function
         "<function body>"
       ];
-        escape = part: if builtins.elem part special then part else lib.strings.escape.nix.identifier part;
+      escape = part:
+        if builtins.elem part special
+        then part
+        else lib.strings.escape.nix.identifier part;
     in
       lib.strings.concatMapSep "." escape location;
 
     ## Get a string message of the definitions for an option.
     ##
     ## @type List Definition -> String
-    getDefinitions =
+    getDefinitions = definitions: let
-      definitions:
+      serialize = definition: let
-      let
+        valueWithRecursionLimit =
-        serialize =
+          lib.generators.withRecursion {
-          definition:
-          let
-            valueWithRecursionLimit = lib.generators.withRecursion {
             limit = 10;
             throw = false;
-            } definition.value;
+          }
+          definition.value;
 
         eval = builtins.tryEval (lib.generators.pretty {} valueWithRecursionLimit);
 
@@ -286,27 +263,24 @@ lib: {
         value = builtins.concatStringsSep "\n    " (firstFiveLines ++ ellipsis);
 
         result =
-              if !eval.success then
+          if !eval.success
-                ""
+          then ""
-              else if linesLength > 1 then
+          else if linesLength > 1
-                ":\n    " + value
+          then ":\n    " + value
-              else
+          else ": " + value;
-                ": " + value;
+      in "\n- In `${definition.__file__}`${result}";
-          in
-          "\n- In `${definition.__file__}`${result}";
     in
       lib.strings.concatMap serialize definitions;
 
     ## Run a set of definitions, calculating the resolved value and associated information.
     ##
     ## @type Location -> Option -> List Definition -> String & { value :: Any, highestPriority :: Int, isDefined :: Bool, files :: List String, definitions :: List Any, definitionsWithLocations :: List Definition }
-    run =
+    run = location: option: definitions: let
-      location: option: definitions:
-      let
       identifier = lib.options.getIdentifier location;
 
       definitionsWithDefault =
-          if option ? default && option.default ? value then
+        if option ? default && option.default ? value
+        then
           [
             {
               __file__ = builtins.head option.declarations;
@@ -314,25 +288,28 @@ lib: {
             }
           ]
           ++ definitions
-          else
+        else definitions;
-            definitions;
 
       merged =
-          if option.writable or null == false && builtins.length definitionsWithDefault > 1 then
+        if option.writable or null == false && builtins.length definitionsWithDefault > 1
-            let
+        then let
-              separatedDefinitions = builtins.map (
+          separatedDefinitions =
+            builtins.map (
               definition:
                 definition
                 // {
                   value = (lib.options.merge.definitions location option.type [definition]).merged;
                 }
-              ) definitionsWithDefault;
+            )
+            definitionsWithDefault;
         in
           builtins.throw "The option `${identifier}` is not writable, but is set more than once:${lib.options.getDefinitions separatedDefinitions}"
-          else
+        else lib.options.merge.definitions location option.type definitionsWithDefault;
-            lib.options.merge.definitions location option.type definitionsWithDefault;
 
-        value = if option.apply or null != null then option.apply merged.merged else merged.merged;
+      value =
+        if option.apply or null != null
+        then option.apply merged.merged
+        else merged.merged;
     in
       option
       // {

lib/src/types/default.nix

@@ -1048,7 +1048,7 @@ lib: {
           merge = location: definitions: let
             process = value:
               if initial.check value
-              then (builtins.trace "transforming...") transform value
+              then  transform value
               else value;
             normalize = definition: definition // {value = process definition.value;};
             normalized = builtins.map normalize definitions;
@@ -1068,6 +1068,43 @@ 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": "a707b0f06be6b36bcbfe88d0a9a5b9a803983a06-dirty",
+        "dirtyRev": "2be3111b2c0911f40b47fe0a1fb22b5f5188cf59-dirty",
-        "dirtyShortRev": "a707b0f-dirty",
+        "dirtyShortRev": "2be3111-dirty",
-        "lastModified": 1719079124,
+        "lastModified": 1719251485,
-        "narHash": "sha256-hz9vVcHSvlq/W01UOh/GqPFUoH9DzCFB16n23oj7fnQ=",
+        "narHash": "sha256-9G1TPBdlQNXCZf6A66bCT9m2vhodkSF+rDtqOVuFteY=",
         "type": "git",
         "url": "file:../?dir=foundation"
       },
@@ -24,10 +24,10 @@
     "lib": {
       "locked": {
         "dir": "lib",
-        "dirtyRev": "a707b0f06be6b36bcbfe88d0a9a5b9a803983a06-dirty",
+        "dirtyRev": "2be3111b2c0911f40b47fe0a1fb22b5f5188cf59-dirty",
-        "dirtyShortRev": "a707b0f-dirty",
+        "dirtyShortRev": "2be3111-dirty",
-        "lastModified": 1719079124,
+        "lastModified": 1719251485,
-        "narHash": "sha256-hz9vVcHSvlq/W01UOh/GqPFUoH9DzCFB16n23oj7fnQ=",
+        "narHash": "sha256-9G1TPBdlQNXCZf6A66bCT9m2vhodkSF+rDtqOVuFteY=",
         "type": "git",
         "url": "file:../?dir=lib"
       },

tidepool/src/builders/basic.nix

@@ -83,7 +83,13 @@ in {
           }
         );
       in
-        built // {inherit (package) meta;};
+        built
+        // {
+          inherit (package) meta;
+          extras = {
+            inherit package;
+          };
+        };
     };
   };
 }

tidepool/src/export.nix

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

tidepool/src/lib/packages.nix

@@ -1,8 +1,9 @@
 {
   lib,
-  lib',
   config,
-}: {
+}: let
+  lib' = config.lib;
+in {
   config = {
     lib.packages = {
       dependencies = {
@@ -20,52 +21,70 @@
       in
         builtins.head sorted;
 
-      resolve = package:
+      resolve = alias:
-        if package ? versions
+        if alias ? versions
         then
-          package.versions.${config.preferences.packages.version}
+          alias.versions.${config.preferences.packages.version}
-          or (package.versions.${lib'.packages.getLatest package})
+          or (alias.versions.${lib'.packages.getLatest alias})
-        else package;
+        else alias;
 
-      build = package: build: host: target: let
+      build = alias: build: host: target: let
-        resolved = lib'.packages.resolve package;
+        package = lib'.packages.resolve alias;
 
         buildDependencies = build': host': target':
           builtins.mapAttrs (name: dep: lib'.packages.build dep build' host' target');
 
-        result = resolved.extend (
+        result = lib.modules.run {
+          modules =
+            package.__modules__
+            ++ [
+              lib'.types.package.children.submodule
+              (
                 {config}: {
                   config = {
+                    __modules__ = package.__modules__;
+
                     platform = {
-                build = build;
+                      build = lib.modules.overrides.force build;
-                host = host;
+                      host = lib.modules.overrides.force host;
-                target = lib.modules.override 150 target;
+                      target = lib.modules.overrides.force 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.
+        resolved =
+          result.config
+          // {
             deps = {
               build = {
-                  only = buildDependencies build build build resolved.deps.build.only;
+                only = buildDependencies build build build package.deps.build.only;
-                  build = buildDependencies build build target resolved.deps.build.build;
+                build = buildDependencies build build target package.deps.build.build;
-                  host = buildDependencies build host target resolved.deps.build.host;
+                host = buildDependencies build host target package.deps.build.host;
-                  target = buildDependencies build target target resolved.deps.build.target;
+                target = buildDependencies build target target package.deps.build.target;
               };
               host = {
-                  only = buildDependencies host host host resolved.deps.host.only;
+                only = buildDependencies host host host package.deps.host.only;
-                  host = buildDependencies host host target resolved.deps.host.host;
+                host = buildDependencies host host target package.deps.host.host;
-                  target = buildDependencies host target target resolved.deps.host.target;
+                target = buildDependencies host target target package.deps.host.target;
               };
               target = {
-                  only = buildDependencies target target target resolved.deps.target.only;
+                only = buildDependencies target target target package.deps.target.only;
-                  target = buildDependencies target target target resolved.deps.target.target;
+                target = buildDependencies target target target package.deps.target.target;
+              };
             };
           };
 
-              package = config.builder.build config;
-            };
-          }
-        );
       in
-        result;
+        resolved
+        // {
+          package = resolved.builder.build resolved;
+        };
     };
   };
 }

tidepool/src/lib/types.nix

@@ -1,8 +1,11 @@
 {
   lib,
-  lib',
   config,
-}: {
+}: let
+  inherit (config) preferences builders;
+
+  lib' = config.lib;
+in {
   config = {
     lib.types = {
       license = let
@@ -52,6 +55,12 @@
       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;
 
@@ -63,194 +72,93 @@
         };
       };
 
-      packages = lib.types.attrs.of (lib'.types.alias);
+      packages = lib.types.attrs.of (lib.types.attrs.of lib'.types.alias);
 
-      alias = lib.types.attrs.of (
+      dependencies = build: host: target: let
-        lib.types.submodule {
+        initial = lib.types.attrs.any;
-          options = {
-            versions = lib.options.create {
-              description = "All available package versions.";
-              type = lib.types.attrs.of lib'.types.package.base;
-            };
-          };
-        }
-      );
-
-      dependencies = lib.types.attrs.of (
-        lib.types.nullish (lib'.types.package.resolved)
-      );
-
-      package = {
-        resolved = let
-          initial =
-            lib.types.raw
-            // {
-              check = value:
-                !(value ? __merged__)
-                && lib.types.raw.check
-                value;
-            };
 
         transform = value: let
           package = lib'.packages.resolve value;
-            packageSubmodule = package.extend (args: {
-              options.__export__ = lib.options.create {
-                type = lib.types.raw;
-                default.value = {
-                  inherit (args) options config;
-                };
-              };
-
-              config.__export__ = {
-                inherit (args) options config;
-              };
-            });
-            type = lib'.types.package.base.withSubModules (lib'.types.package.base.getSubModules
-              ++ [
-                (args: {
-                  options.__export__ = lib.options.create {
-                    type = lib.types.raw;
-                    default.value = {
-                      inherit (args) options config;
-                    };
-                  };
-
-                  config.__export__ = {
-                    inherit (args) options config;
-                  };
-                })
-              ]);
-            typeSubmodule = lib.modules.run {
-              modules = type.getSubModules;
-              args = type.functor.payload.args;
-            };
-
-            getOptions = export: let
-              process = path: option:
-                if builtins.isAttrs option
-                then
-                  if lib.types.is "option" option
-                  then [
-                    {
-                      inherit path;
-                      option = option;
-                    }
-                  ]
-                  else
-                    builtins.concatLists (
-                      lib.attrs.mapToList
-                      (name: value: process (path ++ [name]) value)
-                      option
-                    )
-                else [];
         in
-              process [] export.options;
+        (builtins.trace "building dependency ${package.name}: build=${build.triple} host=${host.triple} target=${target.triple}")
-
+          lib'.packages.build package build host target;
-            packageOptions = getOptions packageSubmodule.__export__;
-            typeOptions = getOptions typeSubmodule.config.__export__;
-
-            customOptions =
-              builtins.filter
-              (
-                packageOption:
-                  builtins.all (typeOption: packageOption.path != typeOption.path) typeOptions
-              )
-              packageOptions;
-
-            packageOptionsIds = builtins.map (option: builtins.concatStringsSep "." option.path) packageOptions;
-            typeOptionsIds = builtins.map (option: builtins.concatStringsSep "." option.path) typeOptions;
-            customOptionsIds = builtins.map (option: builtins.concatStringsSep "." option.path) customOptions;
-
-            resolvedOptions =
-              builtins.foldl' (
-                resolved: option: let
-                  first = builtins.head option.path;
-                  generated = lib.attrs.set option.path option.option;
       in
-                  if first == "__export__" || first == "__module__" || first == "__merged__"
+        lib.types.attrs.of (lib.types.coerce initial transform lib'.types.package);
-                  then resolved
-                  else lib.attrs.mergeRecursive resolved generated
-              ) {}
-              customOptions;
-          in
-            # (builtins.trace (builtins.deepSeq packageOptionsIds packageOptionsIds))
-            # (builtins.trace (builtins.deepSeq typeOptionsIds typeOptionsIds))
-            # (builtins.trace (builtins.deepSeq customOptionsIds customOptionsIds))
-            # (builtins.trace packageSubmodule.__export__.config)
-            (args: {
-              __file__ = packageSubmodule.__export__.config.__file__ or "virtual:tidepool/src/lib/types.nix";
 
-              options =
+      alias = lib.types.submodule {
-                resolvedOptions
-                // {
-                  __merged__ = lib.options.create {
-                    type = lib.types.bool;
-                    default.value = true;
-                  };
-                };
-
-              config =
-                builtins.removeAttrs package ["extend" "package" "platform"]
-                // {
-                  platform = {
-                    build = lib.modules.overrides.default package.platform.build.triple;
-                    host = lib.modules.overrides.default package.platform.host.triple;
-                    target = lib.modules.overrides.default package.platform.target.triple;
-                  };
-                };
-              # // {
-              #   builder =
-              #     (builtins.trace "builder")
-              #     (builtins.trace (args.config ? builder))
-              #     lib.modules.alias
-              #     packageSubmodule.__export__.options.builder;
-              # };
-            });
-        in
-          lib.types.coerce initial transform lib'.types.package.base;
-
-        base = lib.types.submodule (
-          {
-            config,
-            meta,
-          }: {
         options = {
-              extend = lib.options.create {
+          stable = lib.options.create {
-                description = "Extend the package's submodules with additional configuration.";
+            description = "The stable version of the package.";
-                type = lib.types.function lib.types.raw;
+            type = lib.types.nullish lib'.types.package;
-                default.value = value: let
+          };
-                  result = meta.extend {
+
+          latest = lib.options.create {
+            description = "The latest version of the package.";
+            type = lib'.types.package;
+          };
+
+          versions = lib.options.create {
+            description = "Available versions of the package.";
+            type = lib.types.attrs.of lib'.types.package;
+            default.value = {};
+          };
+        };
+      };
+
+      package = let
+        normalize = value:
+          if builtins.isFunction value || builtins.isList value
+          then value
+          else if value ? __modules__
+          then 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 =
-                      if builtins.isAttrs value
+            lib.lists.from.any (normalize value);
-                      then [{config = value;}]
+
-                      else lib.lists.from.any value;
+          result = lib.modules.run {
+            prefix = location;
+            modules =
+              modules
+              ++ [submodule {config.__modules__ = modules;}];
           };
         in
           result.config;
-              };
 
-              name = lib.options.create {
+        final = lib.types.attrs.any;
-                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 {
+        submodule = {config}: let
-                description = "The program name for the package";
+          build = config.platform.build;
-                type = lib.types.nullish lib.types.string;
+          host = config.platform.host;
-                default.value = null;
+          target = config.platform.target;
-              };
+        in {
-
+          options = {
-              version = lib.options.create {
+            __modules__ = lib.options.create {
-                description = "The version for the package.";
+              description = "User specified modules for the package definition.";
-                type = lib.types.nullish lib.types.version;
+              type = lib.types.list.of (initial
-                default.value = null;
+                // {
+                  merge = lib.options.merge.one;
+                });
+              # writable = false;
+              internal = true;
+              default.value = [];
             };
 
             meta = {
@@ -306,57 +214,55 @@
             platform = {
               build = lib.options.create {
                 description = "The build platform for the package.";
-                  type = lib.types.string;
+                type = lib'.types.platform;
-                  default.value = "x86_64-linux";
+                default.value = lib'.systems.withBuildInfo "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;
+                type = lib'.types.platform;
-                  default.value = "x86_64-linux";
+                default.value = lib'.systems.withBuildInfo "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;
+                type = lib'.types.platform;
-                  default.value = "x86_64-linux";
+                default.value = lib'.systems.withBuildInfo "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;
               };
             };
 
+            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.either lib.types.string (lib.types.function lib.types.string));
+              type = lib.types.dag.of lib.types.string;
               default.value = {};
             };
 
@@ -366,34 +272,35 @@
               default.value = {};
             };
 
-              builder = lib.options.create {
+            package = lib.options.create {
-                description = "The builder for the package.";
+              description = "The built derivation.";
-                type = lib'.types.builder;
+              type = lib.types.derivation;
+              default.value = config.builder.build config;
             };
 
             deps = {
               build = {
                 only = lib.options.create {
                   description = "Dependencies which are only used in the build environment.";
-                    type = lib'.types.dependencies;
+                  type = lib'.types.dependencies build build build;
                   default.value = {};
                 };
 
                 build = lib.options.create {
                   description = "Dependencies which are created in the build environment and are executed in the build environment.";
-                    type = lib'.types.dependencies;
+                  type = lib'.types.dependencies build build target;
                   default.value = {};
                 };
 
                 host = lib.options.create {
                   description = "Dependencies which are created in the build environment and are executed in the host environment.";
-                    type = lib'.types.dependencies;
+                  type = lib'.types.dependencies build host target;
                   default.value = {};
                 };
 
                 target = lib.options.create {
                   description = "Dependencies which are created in the build environment and are executed in the target environment.";
-                    type = lib'.types.dependencies;
+                  type = lib'.types.dependencies build target target;
                   default.value = {};
                 };
               };
@@ -401,19 +308,19 @@
               host = {
                 only = lib.options.create {
                   description = "Dependencies which are only used in the host environment.";
-                    type = lib'.types.dependencies;
+                  type = lib'.types.dependencies host host host;
                   default.value = {};
                 };
 
                 host = lib.options.create {
                   description = "Dependencies which are executed in the host environment.";
-                    type = lib'.types.dependencies;
+                  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;
+                  type = lib'.types.dependencies host target target;
                   default.value = {};
                 };
               };
@@ -421,26 +328,34 @@
               target = {
                 only = lib.options.create {
                   description = "Dependencies which are only used in the target environment.";
-                    type = lib'.types.dependencies;
+                  type = lib'.types.dependencies target target target;
                   default.value = {};
                 };
 
                 target = lib.options.create {
                   description = "Dependencies which are executed in the target environment.";
-                    type = lib'.types.dependencies;
+                  type = lib'.types.dependencies target target target;
                   default.value = {};
                 };
               };
             };
+          };
+        };
 
-              package = lib.options.create {
+        type =
-                description = "The built derivation.";
+          (lib.types.coerceWithLocation initial transform final)
-                type = lib.types.derivation;
+          // {
-                default.value = config.builder.build config;
+            name = "Package";
+            description = "a package definition";
           };
+      in
+        type
+        // {
+          children =
+            type.children
+            // {
+              inherit submodule;
             };
-          }
-        );
         };
     };
   };

tidepool/src/packages/aux/a.nix

@@ -12,6 +12,8 @@ in {
             platforms = ["i686-linux"];
           };
 
+          name = "${config.pname}-${config.version}";
+
           pname = "a";
           version = "1.0.0";
 

tidepool/src/packages/aux/b.nix

@@ -1,15 +1,12 @@
-{
+{config}: let
-  lib',
+  inherit (config) lib builders packages;
-  config,
-}: let
-  inherit (config) builders packages;
 in {
   config.packages.aux.b = {
     versions = {
       "latest" = {config}: {
         options = {
-          custom = lib'.options.create {
+          custom = lib.options.create {
-            type = lib'.types.bool;
+            type = lib.types.bool;
           };
         };
 
@@ -18,6 +15,8 @@ in {
             platforms = ["i686-linux"];
           };
 
+          name = "${config.pname}-${config.version}";
+
           custom = true;
 
           pname = "b";

tidepool/src/packages/default.nix

@@ -1,9 +1,7 @@
-{
+{config}: let
-  lib,
+  inherit (config) lib;
-  lib',
+
-  config,
+  doubles = lib.systems.doubles.all;
-}: let
-  doubles = lib'.systems.doubles.all;
 
   packages = builtins.removeAttrs config.packages ["cross"];
 in {
@@ -17,13 +15,13 @@ in {
     packages = lib.options.create {
       description = "The package set.";
       type = lib.types.submodule {
-        freeform = lib.types.attrs.of (lib.types.submodule {freeform = lib'.types.alias;});
+        freeform = lib.types.packages;
 
         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 = {};
             }
         );
@@ -49,38 +47,48 @@ in {
           builtins.mapAttrs (
             name: alias: let
               setHost = package:
-                if package != {}
+              package // {
-                then
+                __modules__ = package.__modules__ ++ [
-                  (package.extend (
+                  {
-                    {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 package;
+              # if 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

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

@@ -1,24 +1,24 @@
 {
-  lib,
-  lib',
   config,
   options,
-}:
+}: let
-let
+  inherit
-  inherit (config)
+    (config)
+    lib
     mirrors
     builders
     # These are the upstream foundational packages exported from the Aux Foundation project.
     
     foundation
+    packages
     ;
-in
+in {
-{
   config.packages.foundation.gcc = {
     versions = {
-      "latest" =
+      "latest" = {
-        { config, meta }:
+        config,
-        {
+        meta,
+      }: {
         options = {
           src = lib.options.create {
             type = lib.types.derivation;
@@ -91,28 +91,7 @@ in
           builder = builders.basic;
 
           env = {
-              PATH =
+            PATH = lib.paths.bin [
-                let
-                  gcc =
-                    if
-                      config.platform.build.triple == config.platform.host.triple
-                    # If we're on the same system then we can use the existing GCC instance.
-                    then
-                      foundation.stage2-gcc
-                    # Otherwise we are going to need a cross-compiler.
-                    else
-                      # TODO: Create a gcc-cross package.
-                      (meta.extend (args: {
-                        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
@@ -128,13 +107,17 @@ in
             ];
           };
 
-            phases =
+          phases = let
-              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 "";
+            mbits =
-              in
+              if host.system.cpu.family == "x86"
-              {
+              then
+                if host.is64bit
+                then "-m64"
+                else "-m32"
+              else "";
+          in {
             unpack = lib.dag.entry.before ["patch"] ''
               # Unpack
               tar xf ${config.src}
@@ -158,9 +141,7 @@ in
 
             configure = lib.dag.entry.between ["build"] ["patch"] ''
               # Configure
-                  export CC="gcc -Wl,-dynamic-linker -march=${
+              export CC="gcc -Wl,-dynamic-linker -Wl,${foundation.stage1-musl}/lib/libc.so"
-                    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"