feat: inital support for x86_64-linux

README.md

@@ -26,7 +26,6 @@ may collaborate.
 ## Experiments
 
 | Name                           | Phase     | Description                                                                |
-| ------------------------------ | --------- | ------------------------------------------------------------------------------------ |
+| ------------------------------ | --------- | -------------------------------------------------------------------------- |
 | [Aux Lib](./lib)               | Iteration | A library of common functions used in the Aux ecosystem.                   |
 | [Aux Foundation](./foundation) | Iteration | Foundational packages which allow for bootstrapping a greater package set. |
-| [Aux Tidepool](./tidepool)     | Idea      | An initial package set built on top of Aux Foundation using Aux Lib's module system. |

foundation/src/stages/stage0/phases/phase00.nix

@@ -91,9 +91,9 @@ in {
 
       hash = lib.modules.overrides.default (
         if system == "x86_64-linux"
-        then "sha256-RCgK9oZRDQUiWLVkcIBSR2HeoB+Bh0czthrpjFEkCaY="
-        else if system == "aarch64-linux"
         then "sha256-XTPsoKeI6wTZAF0UwEJPzuHelWOJe//wXg4HYO0dEJo="
+        else if system == "aarch64-linux"
+        then "sha256-RCgK9oZRDQUiWLVkcIBSR2HeoB+Bh0czthrpjFEkCaY="
         else if system == "i686-linux"
         then "sha256-QU3RPGy51W7M2xnfFY1IqruKzusrSLU+L190ztN6JW8="
         else null

foundation/src/stages/stage2/bash/default.nix

@@ -79,7 +79,6 @@ in {
         deps.build.host = [
           stage1.gcc.package
           stage1.musl.package
-          stage1.coreutils.package
           stage1.binutils.package
           stage1.gnumake.package
           stage1.gnupatch.package
@@ -114,7 +113,6 @@ in {
           make -j $NIX_BUILD_CORES install-strip
           rm $out/bin/bashbug
 
-          ln -s $out/bin/bash $out/bin/sh
         '';
       };
     };

lib/src/dag/default.nix

@@ -58,10 +58,6 @@ lib: {
         else sorted;
     };
 
-    apply = {
-      # defaults = graph: defaults:
-    };
-
     ## Map over the entries in a DAG and modify their values.
     ##
     ## @type (String -> a -> b) -> Dag a -> Dag b

lib/src/modules/default.nix

@@ -317,20 +317,6 @@ lib: {
       vm = lib.modules.override 10;
     };
 
-    ## Create alias definitions for a given option.
-    ##
-    ## @type Option -> Attrs
-    alias = lib.modules.aliasWith lib.fp.id;
-
-    ## Create alias definitions for a given option.
-    ##
-    ## @type (Attrs -> Attrs) -> Option -> Attrs
-    aliasWith = f: option: let
-      exists = lib.types.is "option" option && option.isDefined;
-      value = f (lib.modules.merge option.definitions);
-    in
-      lib.modules.when exists value;
-
     ## Combine multiple modules together.
     ##
     ## @type List String -> List Module -> { matched :: Attrs, unmatched :: List Definition }
@@ -358,7 +344,7 @@ lib: {
               in
                 if builtins.isAttrs subtree
                 then builtins.mapAttrs (name: f module) subtree
-                else builtins.throw "Value for `${builtins.concatStringsSep "." prefix}` is of type `${builtins.typeOf subtree}` but an attribute set was expected."
+                else builtins.throw "Value for `${builtins.concatStringsSep "." prefix} is of type `${builtins.typeOf subtree}` but an attribute set was expected."
             )
             modules);
 

lib/src/modules/default.test.nix

@@ -454,262 +454,5 @@ in {
       };
     in
       evaluated.config.aux.x.message == expected;
-
-    "submodules without shorthand" = let
-      expected = "Hello, World!";
-      evaluated = lib.modules.run {
-        modules = [
-          {
-            options = {
-              aux = lib.options.create {
-                type = lib.types.submodules.of {
-                  shorthand = false;
-                  modules = [
-                    {
-                      options.message = lib.options.create {
-                        type = lib.types.string;
-                      };
-                    }
-                  ];
-                };
-              };
-            };
-            config = {
-              aux = {
-                options = {
-                  message2 = lib.options.create {
-                    type = lib.types.string;
-                  };
-                };
-
-                config = {
-                  message = expected;
-                  message2 = expected;
-                };
-              };
-            };
-          }
-        ];
-      };
-    in
-      evaluated.config.aux.message == evaluated.config.aux.message2;
-
-    "function submodules" = let
-      expected = "Hello, World!";
-      evaluated = lib.modules.run {
-        modules = [
-          {
-            options = {
-              aux = lib.options.create {
-                type = lib.types.submodules.of {
-                  shorthand = false;
-                  modules = [
-                    {
-                      options.message = lib.options.create {
-                        type = lib.types.string;
-                      };
-                    }
-                  ];
-                };
-              };
-            };
-            config = {
-              aux = args: {
-                config.message = expected;
-              };
-            };
-          }
-        ];
-      };
-    in
-      evaluated.config.aux.message == expected;
-
-    "merges submodules" = let
-      expected = "Hello, World!";
-      evaluated = lib.modules.run {
-        modules = [
-          {
-            options = {
-              aux = lib.options.create {
-                type = lib.types.submodules.of {
-                  shorthand = false;
-                  modules = [
-                    {
-                      options.message = lib.options.create {
-                        type = lib.types.string;
-                      };
-                    }
-                  ];
-                };
-              };
-            };
-            config = {
-              aux = args: {
-                options.message2 = lib.options.create {
-                  type = lib.types.string;
-                };
-
-                config.message = expected;
-              };
-            };
-          }
-          {
-            config = {
-              aux.config.message2 = expected;
-            };
-          }
-        ];
-      };
-    in
-      evaluated.config.aux.message == evaluated.config.aux.message2;
-
-    "flexible shorthand" = let
-      expected = "Hello, World!";
-      evaluated = lib.modules.run {
-        modules = [
-          {
-            options = {
-              aux = lib.options.create {
-                type = lib.types.submodules.of {
-                  shorthand = true;
-                  modules = [
-                    {
-                      options.message = lib.options.create {
-                        type = lib.types.string;
-                      };
-                    }
-                  ];
-                };
-              };
-            };
-            config = {
-              aux = args: {
-                options.message2 = lib.options.create {
-                  type = lib.types.string;
-                };
-
-                config.message = expected;
-              };
-            };
-          }
-          {
-            config = {
-              aux.message2 = expected;
-            };
-          }
-        ];
-      };
-    in
-      evaluated.config.aux.message == evaluated.config.aux.message2;
-
-    "base level submodule" = let
-      expected = "Hello, World!";
-      evaluated = lib.modules.run {
-        modules = [
-          {
-            options = {
-              aux = lib.options.create {
-                type = lib.types.submodule {
-                  options.message = lib.options.create {
-                    type = lib.types.string;
-                  };
-                };
-              };
-            };
-            config = {
-              aux = args: {
-                options.message2 = lib.options.create {
-                  type = lib.types.string;
-                };
-
-                config.message = expected;
-              };
-            };
-          }
-          {
-            config = {
-              aux.message2 = expected;
-            };
-          }
-        ];
-      };
-    in
-      evaluated.config.aux.message == evaluated.config.aux.message2;
-
-    "base level submodule (freeform)" = let
-      expected = "Hello, World!";
-      evaluated = lib.modules.run {
-        modules = [
-          {
-            options = {
-              aux = lib.options.create {
-                type = lib.types.submodule {
-                  freeform = lib.types.any;
-
-                  options.message = lib.options.create {
-                    type = lib.types.string;
-                  };
-                };
-              };
-            };
-            config = {
-              aux = args: {
-                options.message2 = lib.options.create {
-                  type = lib.types.string;
-                };
-
-                config.message = expected;
-              };
-            };
-          }
-          {
-            config = {
-              aux.exists = true;
-              aux.message2 = expected;
-            };
-          }
-        ];
-      };
-    in
-      (evaluated.config.aux.message == evaluated.config.aux.message2)
-      && evaluated.config.aux.exists;
-
-    "nested submodules" = let
-      expected = "Hello, World!";
-      evaluated = lib.modules.run {
-        modules = [
-          {
-            options = {
-              aux = lib.options.create {
-                type = lib.types.submodule {
-                  freeform = lib.types.any;
-
-                  options.message = lib.options.create {
-                    type = lib.types.string;
-                  };
-                };
-              };
-            };
-            config = {
-              aux = args: {
-                options.message2 = lib.options.create {
-                  type = lib.types.string;
-                };
-
-                config.message = expected;
-              };
-            };
-          }
-          {
-            config = {
-              aux.exists = true;
-              aux.message2 = expected;
-            };
-          }
-        ];
-      };
-    in
-      (evaluated.config.aux.message == evaluated.config.aux.message2)
-      && evaluated.config.aux.exists;
   };
 }

lib/src/options/default.nix

@@ -94,7 +94,7 @@ lib: {
           typeSet = lib.attrs.when ((shared "type") && isTypeMergeable) {
             type = mergedType;
           };
-          files = result.declarations;
+          files = builtins.map lib.modules.getFiles result.declarations;
           serializedFiles = builtins.concatStringsSep " and " files;
           getSubModules = option.options.type.getSubModules or null;
           submodules =

lib/src/types/default.nix

@@ -360,19 +360,6 @@ lib: {
     ## @type Attrs
     port = lib.types.ints.u16;
 
-    ## A type that allows a string value specifying a version number.
-    ##
-    ## @type Attrs
-    version = lib.types.create {
-      name = "Version";
-      description = "version";
-      check = value: let
-        parts = builtins.splitVersion value;
-      in
-        builtins.isString value && builtins.length parts > 0;
-      merge = lib.options.merge.equal;
-    };
-
     ## A type that allows a string value. The merged definitions must all be
     ## the same.
     ##
@@ -756,38 +743,18 @@ lib: {
       ## with helpers like `lib.types.attrs.of` in order to produce more complex,
       ## dynamic types.
       ##
-      ## @type { modules :: List Module, args? :: Attrs, description? :: String | Null, shorthand? :: Bool } -> Attrs
+      ## @type { modules :: List Module, args? :: Attrs, description? :: String | Null } -> Attrs
       of = settings @ {
         modules,
         args ? {},
         description ? null,
-        shorthand ? true,
       }: let
         getModules = builtins.map (
           definition:
-            if shorthand && builtins.isAttrs definition.value
+            if builtins.isAttrs definition
-            then let
+            then {
-              # TODO: Figure out if we can apply additional attributes to the generated module.
-              # Currently this causes issues to do with redefined options.
-              rest =
-                builtins.removeAttrs
-                (lib.attrs.filter (name: value: builtins.elem name lib.modules.VALID_KEYS) definition.value)
-                ["freeform"];
-            in
-              if definition.value ? config
-              then
-                rest
-                // {
               __file__ = definition.__file__;
-                  config = definition.value.config;
+              config = definition.value;
-                }
-              else let
-                config = builtins.removeAttrs definition.value lib.modules.VALID_KEYS;
-              in
-                rest
-                // {
-                  __file__ = definition.__file__;
-                  config = config;
             }
             else {
               __file__ = definition.__file__;
@@ -836,7 +803,7 @@ lib: {
           getSubModules = modules;
           withSubModules = modules:
             lib.types.submodules.of {
-              inherit args description modules shorthand;
+              inherit args description modules;
             };
           children = lib.attrs.when (freeform != null) {
             inherit freeform;
@@ -846,7 +813,7 @@ lib: {
             // {
               type = lib.types.submodules.of;
               payload = {
-                inherit modules args description shorthand;
+                inherit modules args description;
               };
               merge = x: y: {
                 modules = x.modules ++ y.modules;
@@ -1071,6 +1038,7 @@ lib: {
             inherit initial final;
           };
         };
+  };
 
   dag = {
     ## Create a type that allows a DAG (Directed Acyclic Graph) of a given type.
@@ -1138,5 +1106,4 @@ lib: {
           );
       };
   };
-  };
 }

potluck/default.nix

@@ -0,0 +1,33 @@
+{
+  lib ? import ./../lib,
+  foundation ? import ./../foundation {system = "i686-linux";},
+}: let
+  modules = import ./src/modules.nix;
+
+  result = lib.modules.run {
+    modules =
+      (builtins.attrValues modules)
+      ++ [
+        ./src/export.nix
+        {
+          __file__ = "broken";
+
+          # options.foundation = lib.options.create {
+          #   type = lib.types.attrs.of lib.types.derivation;
+          # };
+
+          # config.foundation = foundation;
+          config.packages.foundation =
+            builtins.mapAttrs (name: package: {
+              name = package.name;
+
+              inherit package;
+
+              meta = package.meta;
+            })
+            foundation;
+        }
+      ];
+  };
+in
+  result.config

potluck/flake.lock

@@ -8,10 +8,10 @@
       },
       "locked": {
         "dir": "foundation",
-        "dirtyRev": "0312e3c4cc261e2384fcf372c766a0cf245f3213-dirty",
+        "dirtyRev": "9c29945531c58ad81f05cd1f4958c8894a733216-dirty",
-        "dirtyShortRev": "0312e3c-dirty",
+        "dirtyShortRev": "9c29945-dirty",
-        "lastModified": 1718460525,
+        "lastModified": 1718255029,
-        "narHash": "sha256-+ToaXY8ISWLx9AtO/CjfY/6SGuKu8A/d9ncqE4h2H20=",
+        "narHash": "sha256-fmrDe4GfvVfXZ9lzaOt+tgBUMFCsyKr0Dlnm8aQwAXs=",
         "type": "git",
         "url": "file:../?dir=foundation"
       },
@@ -24,10 +24,10 @@
     "lib": {
       "locked": {
         "dir": "lib",
-        "dirtyRev": "0312e3c4cc261e2384fcf372c766a0cf245f3213-dirty",
+        "dirtyRev": "9c29945531c58ad81f05cd1f4958c8894a733216-dirty",
-        "dirtyShortRev": "0312e3c-dirty",
+        "dirtyShortRev": "9c29945-dirty",
-        "lastModified": 1718460525,
+        "lastModified": 1718255029,
-        "narHash": "sha256-+ToaXY8ISWLx9AtO/CjfY/6SGuKu8A/d9ncqE4h2H20=",
+        "narHash": "sha256-fmrDe4GfvVfXZ9lzaOt+tgBUMFCsyKr0Dlnm8aQwAXs=",
         "type": "git",
         "url": "file:../?dir=lib"
       },

potluck/src/export.nix

@@ -0,0 +1,14 @@
+# This file handles creating all of the exports for this project and is not
+# exported itself.
+{
+  lib,
+  config,
+}: let
+in {
+  config = {
+    exports = {
+      lib = config.lib;
+      modules = import ./modules.nix;
+    };
+  };
+}

potluck/src/exports/lib.nix

@@ -1,6 +1,6 @@
 {
-  lib,
   config,
+  lib,
 }: let
 in {
   options = {

potluck/src/exports/packages.nix

@@ -0,0 +1,22 @@
+{
+  config,
+  lib,
+}: let
+  lib' = config.lib;
+in {
+  options = {
+    exports.packages = lib.options.create {
+      default.value = {};
+    };
+
+    exported.packages = lib.options.create {
+      default.value = {};
+    };
+  };
+
+  config = {
+    exported.packages = {
+      # i686-linux = config.packages.foundation;
+    };
+  };
+}

potluck/src/lib/default.nix

@@ -6,7 +6,6 @@
 in {
   includes = [
     ./options.nix
-    ./packages.nix
     ./systems.nix
     ./types.nix
   ];
@@ -19,8 +18,4 @@ in {
       apply = value: lib.extend (final: prev: prev.attrs.mergeRecursive prev value);
     };
   };
-
-  config = {
-    __module__.args.dynamic.lib' = config.lib;
-  };
 }

potluck/src/lib/systems.nix

@@ -1460,8 +1460,8 @@ in {
             lib.strings.when
             (kernel.name == "netbsd" && netbsdExec != kernel.exec)
             kernel.exec.name;
-          abi' = lib.strings.when (abi != types.abis.unknown) "-${abi.name}";
+          abi = lib.strings.when (abi != types.abis.unknown) "-${abi.name}";
-        in "${cpu.name}-${vendor.name}-${kernelName}${exec}${abi'}";
+        in "${cpu.name}-${vendor.name}-${kernelName}${exec}${abi}";
       };
 
       create = components:
@@ -1909,26 +1909,28 @@ in {
           then {system = args;}
           else args;
 
-        resolved =
+        matchers = builtins.mapAttrs (name: match: match resolved.system) lib'.systems.match;
+        validators = builtins.mapAttrs (name: validate: validate (resolved.gcc.arch or "default")) lib'.systems.match.architecture;
+
+        platformInfo =
           {
+            linux-kernel = settings.linux-kernel or {};
+            gcc = settings.gcc or {};
+            rustc = settings.rustc or {};
+          }
+          // lib'.systems.platforms.select resolved;
+
+        resolved =
+          matchers
+          // validators
+          // platformInfo
+          // {
             system = lib'.systems.from.string (
               if settings ? triple
               then settings.triple
               else settings.system
             );
 
-            inherit
-              ({
-                  linux-kernel = settings.linux-kernel or {};
-                  gcc = settings.gcc or {};
-                  rustc = settings.rustc or {};
-                }
-                // lib'.systems.platforms.select resolved)
-              linux-kernel
-              gcc
-              rust
-              ;
-
             double = lib'.systems.into.double resolved.system;
             triple = lib'.systems.into.triple resolved.system;
 
@@ -2160,8 +2162,6 @@ in {
               };
             };
           }
-          // builtins.mapAttrs (name: match: match resolved.system) lib'.systems.match
-          // builtins.mapAttrs (name: validate: validate (resolved.gcc.arch or "default")) lib'.systems.validate.architecture
           // settings;
 
         assertions =
@@ -2178,7 +2178,7 @@ in {
           true
           (resolved.system.abi.assertions or []);
       in
-        assert resolved.useAndroidPrebuilt -> resolved.isAndroid;
+        assert resolved.useAndroidPrebuild -> resolved.isAndroid;
         assert assertions;
         # And finally, return the generated system info.
           resolved;

potluck/src/lib/types.nix

@@ -0,0 +1,471 @@
+{
+  lib,
+  config,
+}: let
+  lib' = config.lib;
+in {
+  config = {
+    lib.types = {
+      license = let
+        type = lib.types.submodule ({config}: {
+          options = {
+            name = {
+              full = lib.options.create {
+                type = lib.types.string;
+                description = "The full name of the license.";
+              };
+
+              short = lib.options.create {
+                type = lib.types.string;
+                description = "The short name of the license.";
+              };
+            };
+
+            spdx = lib.options.create {
+              type = lib.types.nullish lib.types.string;
+              default.value = null;
+              description = "The SPDX identifier for the license.";
+            };
+
+            url = lib.options.create {
+              type = lib.types.nullish lib.types.string;
+              description = "The URL for the license.";
+            };
+
+            free = lib.options.create {
+              type = lib.types.bool;
+              default.value = true;
+              description = "Whether the license is free.";
+            };
+
+            redistributable = lib.options.create {
+              type = lib.types.bool;
+              default = {
+                text = "config.free";
+                value = config.free;
+              };
+              description = "Whether the license is allows redistribution.";
+            };
+          };
+        });
+      in
+        lib.types.either type (lib.types.list.of type);
+
+      meta = lib.types.submodule {
+        options = {
+          name = lib.options.create {
+            type = lib.types.string;
+            description = "The name of the package.";
+          };
+
+          description = lib.options.create {
+            type = lib.types.nullish lib.types.string;
+            default.value = null;
+            description = "The description for the package.";
+          };
+
+          homepage = lib.options.create {
+            type = lib.types.nullish lib.types.string;
+            default.value = null;
+            description = "The homepage for the package.";
+          };
+
+          license = lib.options.create {
+            type = config.lib.types.license;
+            description = "The license for the package.";
+          };
+
+          free = lib.options.create {
+            type = lib.types.bool;
+            default.value = true;
+            description = "Whether the package is free.";
+          };
+
+          insecure = lib.options.create {
+            type = lib.types.bool;
+            default.value = false;
+            description = "Whether the package is insecure.";
+          };
+
+          broken = lib.options.create {
+            type = lib.types.bool;
+            default.value = false;
+            description = "Whether the package is broken.";
+          };
+
+          main = lib.options.create {
+            type = lib.types.nullish lib.types.string;
+            default.value = null;
+            description = "The main entry point for the package.";
+          };
+
+          platforms = lib.options.create {
+            type = lib.types.list.of lib.types.string;
+            default.value = [];
+            description = "The platforms the package supports.";
+          };
+        };
+      };
+
+      package = {
+        base = lib.types.submodule ({config}: {
+          freeform = lib.types.any;
+
+          options = {
+            name = lib.options.create {
+              type = lib.types.string;
+              default = {
+                value = "${config.pname}-${config.version or "unknown"}";
+                text = "\${config.pname}-\${config.version}";
+              };
+              description = "The name of the package.";
+            };
+
+            pname = lib.options.create {
+              type = lib.types.nullish lib.types.string;
+              default.value = null;
+              description = "The name of the package.";
+            };
+
+            version = lib.options.create {
+              type = lib.types.nullish lib.types.string;
+              default.value = null;
+              description = "The version of the package.";
+            };
+
+            meta = lib.options.create {
+              type = lib'.types.meta;
+              default = {
+                text = "{ name = <package>.pname; }";
+                value = {
+                  name = config.pname;
+                };
+              };
+              description = "The metadata for the package.";
+            };
+
+            env = lib.options.create {
+              type = lib.types.attrs.of lib.types.string;
+              default.value = {};
+              description = "Environment variables for the package's builder to use.";
+            };
+
+            phases = lib.options.create {
+              type = lib.types.dag.of (
+                lib.types.either
+                lib.types.string
+                (lib.types.function lib.types.string)
+              );
+              default.value = {};
+              description = "Phases for the package's builder to use.";
+            };
+
+            platform = {
+              build = lib.options.create {
+                type = lib.types.nullish lib.types.string;
+                default.value = null;
+                description = "The platform the package is built on.";
+              };
+
+              host = lib.options.create {
+                type = lib.types.nullish lib.types.string;
+                default.value = null;
+                description = "The platform the package is run on.";
+              };
+
+              target = lib.options.create {
+                type = lib.types.nullish lib.types.string;
+                default.value = null;
+                description = "The platform the package generates code for.";
+              };
+            };
+
+            builder = lib.options.create {
+              type = lib'.types.builder;
+              description = "The builder for the package.";
+            };
+
+            package = lib.options.create {
+              type = lib.types.derivation;
+              default = {
+                value = config.builder.build config.builder config;
+                text = "<derivation>";
+              };
+              description = "The package derivation.";
+            };
+
+            deps = {
+              build = {
+                only = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are only used in the build environment.";
+                };
+
+                build = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are created in the build environment and are run in the build environment.";
+                };
+
+                host = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are created in the build environment and are run in the host environment.";
+                };
+
+                target = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are created in the build environment and are run in the target environment.";
+                };
+              };
+
+              host = {
+                only = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are only used in the host environment.";
+                };
+
+                host = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are run in the host environment.";
+                };
+
+                target = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are run in the host environment which produces code for the target environment.";
+                };
+              };
+
+              target = {
+                only = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are only used in the target environment.";
+                };
+
+                target = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are run in the target environment.";
+                };
+              };
+            };
+
+            versions = lib.options.create {
+              type = lib.types.attrs.of lib'.types.package;
+              default.value = {};
+              description = "Available versions of the package.";
+            };
+          };
+        });
+
+        targeted = lib.types.submodule ({config}: {
+          freeform = lib.types.any;
+
+          options = {
+            name = lib.options.create {
+              type = lib.types.string;
+              default = {
+                value = "${config.pname}-${config.version or "unknown"}";
+                text = "\${config.pname}-\${config.version}";
+              };
+              description = "The name of the package.";
+            };
+
+            pname = lib.options.create {
+              type = lib.types.nullish lib.types.string;
+              default.value = null;
+              description = "The name of the package.";
+            };
+
+            version = lib.options.create {
+              type = lib.types.nullish lib.types.string;
+              default.value = null;
+              description = "The version of the package.";
+            };
+
+            meta = lib.options.create {
+              type = lib'.types.meta;
+              default = {
+                text = "{ name = <package>.pname; }";
+                value = {
+                  name = config.pname;
+                };
+              };
+              description = "The metadata for the package.";
+            };
+
+            env = lib.options.create {
+              type = lib.types.attrs.of lib.types.string;
+              default.value = {};
+              description = "Environment variables for the package's builder to use.";
+            };
+
+            phases = lib.options.create {
+              type = lib.types.dag.of (
+                lib.types.either
+                lib.types.string
+                (lib.types.function lib.types.string)
+              );
+              default.value = {};
+              description = "Phases for the package's builder to use.";
+            };
+
+            platform = {
+              build = lib.options.create {
+                type = lib.types.string;
+                description = "The platform the package is built on.";
+              };
+
+              host = lib.options.create {
+                type = lib.types.string;
+                description = "The platform the package is run on.";
+              };
+
+              target = lib.options.create {
+                type = lib.types.string;
+                description = "The platform the package generates code for.";
+              };
+            };
+
+            builder = lib.options.create {
+              type = lib'.types.builder;
+              description = "The builder for the package.";
+            };
+
+            package = lib.options.create {
+              type = lib.types.derivation;
+              default = {
+                value = config.builder.build config.builder config;
+                text = "<derivation>";
+              };
+              description = "The package derivation.";
+            };
+
+            deps = {
+              build = {
+                only = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are only used in the build environment.";
+                };
+
+                build = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are created in the build environment and are run in the build environment.";
+                };
+
+                host = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are created in the build environment and are run in the host environment.";
+                };
+
+                target = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are created in the build environment and are run in the target environment.";
+                };
+              };
+
+              host = {
+                only = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are only used in the host environment.";
+                };
+
+                host = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are run in the host environment.";
+                };
+
+                target = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are run in the host environment which produces code for the target environment.";
+                };
+              };
+
+              target = {
+                only = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are only used in the target environment.";
+                };
+
+                target = lib.options.create {
+                  type = lib'.types.dependencies;
+                  default.value = {};
+                  description = "Dependencies which are run in the target environment.";
+                };
+              };
+            };
+
+            versions = lib.options.create {
+              type = lib.types.attrs.of lib'.types.package;
+              default.value = {};
+              description = "Available versions of the package.";
+            };
+          };
+        });
+      };
+
+      dependencies = lib.types.attrs.of (lib.types.nullish lib'.types.package);
+
+      packages = {
+        base = lib.types.attrs.of (lib.types.submodule {
+          freeform = lib'.types.package.base;
+
+          # options =
+          #   builtins.foldl' (result: system: {
+          #     "${system}" = lib.options.create {
+          #       type = lib'.types.packages.targeted;
+          #       default.value = {};
+          #       description = "Packages for the architecture `${system}`";
+          #     };
+          #   }) {}
+          #   lib'.systems.doubles.all;
+        });
+
+        targeted = lib.types.attrs.of (lib.types.submodule {
+          freeform = lib.types.nullish lib'.types.package.targeted;
+
+          options = {
+            cross = lib.options.create {
+              type = lib'.types.packages.cross;
+              default.value = {};
+              description = "Cross-compiled packages targeting another architecture.";
+            };
+          };
+        });
+
+        # Cross-compiled packages are accessed via
+        # packages.cross.<platform>.<namespace>.<name>
+        cross = lib.types.attrs.of (lib.types.submodule {
+          freeform = lib.types.attrs.of (lib.types.submodule {
+            freeform = lib.types.nullish lib'.types.package.targeted;
+          });
+        });
+      };
+
+      builder = lib.types.submodule {
+        freeform = lib.types.any;
+
+        options = {
+          build = lib.options.create {
+            type = lib.types.function lib.types.derivation;
+            description = "The function that creates the package derivation.";
+          };
+        };
+      };
+    };
+  };
+}

potluck/src/modules.nix

@@ -1,7 +1,5 @@
 {
-  builders = ./builders;
   exports = ./exports;
   lib = ./lib;
-  mirrors = ./mirrors;
   packages = ./packages;
 }

potluck/src/packages/default.nix

@@ -0,0 +1,27 @@
+{
+  lib,
+  config,
+}: let
+  lib' = config.lib;
+
+  doubles = lib'.systems.doubles.all;
+
+  generic = builtins.removeAttrs config.packages ["targeted"];
+in {
+  includes = [
+    # ./aux/foundation.nix
+  ];
+
+  options = {
+    packages = lib.options.create {
+      default.value = {};
+      type = lib.types.attrs.of (lib.types.submodule {
+        freeform = lib.types.any;
+      });
+    };
+  };
+
+  config = {
+    packages.targeted.i686-linux = generic;
+  };
+}

tidepool/README.md

@@ -1,28 +0,0 @@
-# Aux Tidepool
-
-Aux Tidepool is an initial package set built on top of [Aux Foundation](../foundation). Packages
-are created and managed using [Aux Lib](../lib)'s module system to allow for highly dynamic and
-extensible configuration.
-
-## Usage
-
-Packages can be imported both with and without Nix Flakes. To import them using Nix Flakes,
-add this repository as an input.
-
-```nix
-inputs.tidepool.url = "https://git.auxolotl.org/auxolotl/labs/archive/main.tar.gz?dir=tidepool";
-```
-
-To import this library without using Nix Flakes, you will need to use `fetchTarball` and
-import the library entrypoint.
-
-```nix
-let
-    labs = builtins.fetchTarball {
-        url = "https://git.auxolotl.org/auxolotl/labs/archive/main.tar.gz";
-        sha256 = "<sha256>";
-    };
-    tidepool = import "${labs}/tidepool" {};
-in
-    # ...
-```

tidepool/default.nix

@@ -1,27 +0,0 @@
-{
-  lib ? import ./../lib,
-  foundation ? import ./../foundation {system = "i686-linux";},
-}: let
-  modules = import ./src/modules.nix;
-
-  result = lib.modules.run {
-    modules =
-      (builtins.attrValues modules)
-      ++ [
-        ./src/export.nix
-        {
-          __file__ = ./default.nix;
-
-          options.foundation = lib.options.create {
-            type = lib.types.attrs.of lib.types.derivation;
-          };
-
-          config.foundation = foundation;
-        }
-      ];
-  };
-in
-  result.config.exported
-  // {
-    inherit (result) config;
-  }

tidepool/src/builders/basic.nix

@@ -1,80 +0,0 @@
-{
-  lib,
-  config,
-}: let
-  cfg = config.builders.basic;
-
-  lib' = config.lib;
-
-  inherit (config) foundation;
-in {
-  config.builders = {
-    basic = {
-      executable = "${foundation.stage2-bash}/bin/bash";
-
-      build = package: let
-        phases = package.phases;
-        sorted = lib.dag.sort.topographic phases;
-
-        script =
-          lib.strings.concatMapSep "\n" (
-            entry:
-              if builtins.isFunction entry.value
-              then entry.value package
-              else entry.value
-          )
-          sorted.result;
-
-        system = package.platform.build.double;
-
-        built = builtins.derivation (
-          package.env
-          // {
-            inherit (package) name;
-            inherit script system;
-
-            passAsFile = ["script"];
-
-            SHELL = cfg.executable;
-
-            PATH = let
-              bins = lib.paths.bin (
-                (lib'.packages.dependencies.getPackages package.deps.build.host)
-                ++ [
-                  foundation.stage2-bash
-                  foundation.stage2-coreutils
-                ]
-              );
-            in
-              builtins.concatStringsSep ":" ([bins] ++ (lib.lists.when (package.env ? PATH) [package.env.PATH]));
-
-            builder = cfg.executable;
-
-            args = [
-              "-e"
-              (builtins.toFile "bash-builder.sh" ''
-                export CONFIG_SHELL=$SHELL
-
-                # Normalize the NIX_BUILD_CORES variable. The value might be 0, which
-                # means that we're supposed to try and auto-detect the number of
-                # available CPU cores at run-time.
-                NIX_BUILD_CORES="''${NIX_BUILD_CORES:-1}"
-                if ((NIX_BUILD_CORES <= 0)); then
-                  guess=$(nproc 2>/dev/null || true)
-                  ((NIX_BUILD_CORES = guess <= 0 ? 1 : guess))
-                fi
-                export NIX_BUILD_CORES
-
-                bash -eux $scriptPath
-              '')
-            ];
-          }
-        );
-      in
-        built
-        // {
-          inherit (package) meta;
-        };
-    };
-  };
-}

tidepool/src/builders/default.nix

@@ -1,18 +0,0 @@
-{
-  lib,
-  config,
-}: let
-  lib' = config.lib;
-in {
-  includes = [
-    ./basic.nix
-  ];
-
-  options = {
-    builders = lib.options.create {
-      description = "A set of builders that can be used to build packages.";
-      type = lib.types.attrs.of lib'.types.builder;
-      default.value = {};
-    };
-  };
-}

tidepool/src/export.nix

@@ -1,34 +0,0 @@
-# This file handles creating all of the exports for this project and is not
-# exported itself.
-{
-  lib,
-  config,
-}: let
-  lib' = config.lib;
-in {
-  freeform = lib.types.any;
-
-  config = {
-    exports = {
-      lib = config.lib;
-      modules = import ./modules.nix;
-
-      packages = {
-        # foundation-gcc-x86_64 =
-        # (config.packages.foundation.gcc.versions."13.2.0".extend (args: {
-        #   config = {
-        #     platform = {
-        #       target = lib.modules.overrides.force "x86_64-linux";
-        #     };
-        #   };
-        # }))
-        # .config;
-        foundation-gcc = config.packages.foundation.gcc;
-        # example-x = config.packages.example.x;
-        # cross-example-x-x86_64-linux = config.packages.cross.x86_64-linux.example.x;
-      };
-    };
-
-    # exported.packages.i686-linux.cross-foundation-gcc-x86_64-linux = config.packages.cross.x86_64-linux.foundation.gcc.package;
-  };
-}

tidepool/src/exports/packages.nix

@@ -1,53 +0,0 @@
-{
-  config,
-  lib,
-}: let
-  lib' = config.lib;
-in {
-  options = {
-    exports.packages = lib.options.create {
-      type = lib.types.attrs.of (lib'.types.raw);
-      default.value = {};
-    };
-
-    exported.packages = lib.options.create {
-      type = lib.types.attrs.of (lib.types.attrs.of lib.types.derivation);
-      default.value = {};
-    };
-  };
-
-  config = {
-    exported.packages = let
-      all = lib.attrs.generate lib'.systems.doubles.all (
-        system: let
-          all =
-            builtins.mapAttrs
-            (
-              name: package: let
-                result = lib'.packages.build package system system;
-              in
-                result
-            )
-            config.exports.packages;
-
-          available =
-            lib.attrs.filter
-            (name: package: builtins.elem system package.meta.platforms)
-            all;
-
-          packages =
-            builtins.mapAttrs
-            (name: package: package.package)
-            available;
-        in
-          packages
-      );
-
-      available =
-        lib.attrs.filter
-        (system: packages: builtins.length (builtins.attrNames packages) != 0)
-        all;
-    in
-      available;
-  };
-}

tidepool/src/lib/packages.nix

@@ -1,65 +0,0 @@
-{
-  lib,
-  lib',
-  config,
-}: {
-  config = {
-    lib.packages = {
-      dependencies = {
-        getPackages = dependencies: let
-          available =
-            builtins.filter
-            (dependency: !(builtins.isNull dependency))
-            (builtins.attrValues dependencies);
-        in
-          builtins.map (dependency: dependency.package) available;
-      };
-
-      getLatest = alias: let
-        versions = builtins.attrNames alias.versions;
-        sorted = builtins.sort (lib.versions.gte) versions;
-      in
-        builtins.head sorted;
-
-      build = package: system: cross: let
-        resolved =
-          if package ? versions
-          then package.versions.${config.preferences.packages.version} or (package.versions.${lib'.packages.getLatest package})
-          else package;
-
-        buildDependencies = builtins.mapAttrs (name: dep: lib'.packages.build dep system cross);
-
-        result = resolved.extend ({config}: {
-          config = {
-            platform = {
-              build = system;
-              host = cross;
-              target = lib.modules.override 150 cross;
-            };
-
-            deps = {
-              build = {
-                only = buildDependencies resolved.deps.build.only;
-                build = buildDependencies resolved.deps.build.build;
-                host = buildDependencies resolved.deps.build.host;
-                target = buildDependencies resolved.deps.build.target;
-              };
-              host = {
-                only = buildDependencies resolved.deps.host.only;
-                host = buildDependencies resolved.deps.host.host;
-                target = buildDependencies resolved.deps.host.target;
-              };
-              target = {
-                only = buildDependencies resolved.deps.target.only;
-                target = buildDependencies resolved.deps.target.target;
-              };
-            };
-
-            package = config.builder.build config;
-          };
-        });
-      in
-        result.config;
-    };
-  };
-}

tidepool/src/lib/types.nix

@@ -1,304 +0,0 @@
-{
-  lib,
-  lib',
-  config,
-}: {
-  config = {
-    lib.types = {
-      license = let
-        type = lib.types.submodule ({config}: {
-          options = {
-            name = {
-              full = lib.options.create {
-                description = "The full name of the license.";
-                type = lib.types.string;
-              };
-
-              short = lib.options.create {
-                description = "The short name of the license.";
-                type = lib.types.string;
-              };
-            };
-
-            spdx = lib.options.create {
-              description = "The SPDX identifier for the license.";
-              type = lib.types.nullish lib.types.string;
-              default.value = null;
-            };
-
-            url = lib.options.create {
-              description = "The URL for the license.";
-              type = lib.types.nullish lib.types.string;
-            };
-
-            free = lib.options.create {
-              description = "Whether the license is free.";
-              type = lib.types.bool;
-              default.value = true;
-            };
-
-            redistributable = lib.options.create {
-              description = "Whether the license is allows redistribution.";
-              type = lib.types.bool;
-              default = {
-                text = "config.free";
-                value = config.free;
-              };
-            };
-          };
-        });
-      in
-        lib.types.either type (lib.types.list.of type);
-
-      builder = lib.types.submodule {
-        freeform = lib.types.any;
-
-        options = {
-          build = lib.options.create {
-            description = "The build function which takes a package definition and creates a derivation.";
-            type = lib.types.function lib.types.derivation;
-          };
-        };
-      };
-
-      packages = lib.types.attrs.of (lib'.types.alias);
-
-      alias = lib.types.attrs.of (lib.types.submodule {
-        options = {
-          versions = lib.options.create {
-            description = "All available package versions.";
-            type = lib.types.attrs.of lib'.types.package;
-          };
-        };
-      });
-
-      dependencies = lib.types.attrs.of (lib.types.nullish (lib.types.either lib'.types.alias lib'.types.package));
-
-      package = lib.types.submodule ({
-        config,
-        meta,
-      }: {
-        options = {
-          extend = lib.options.create {
-            description = "Extend the package's submodules with additional configuration.";
-            type = lib.types.function lib.types.raw;
-            default.value = value:
-              meta.extend {
-                modules =
-                  if builtins.isAttrs value
-                  then [{config = value;}]
-                  else lib.lists.from.any value;
-              };
-          };
-
-          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;
-          };
-
-          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.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;
-              };
-            };
-
-            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;
-              };
-            };
-
-            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;
-              };
-            };
-          };
-
-          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 = {};
-              };
-
-              build = lib.options.create {
-                description = "Dependencies which are created in the build environment and are executed in the build environment.";
-                type = lib'.types.dependencies;
-                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;
-                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;
-                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 = {};
-              };
-            };
-          };
-
-          package = lib.options.create {
-            description = "The built derivation.";
-            type = lib.types.derivation;
-            default.value = config.builder.build config;
-          };
-        };
-      });
-    };
-  };
-}

tidepool/src/mirrors/default.nix

@@ -1,5 +0,0 @@
-{
-  includes = [
-    ./gnu.nix
-  ];
-}

tidepool/src/mirrors/gnu.nix

@@ -1,9 +0,0 @@
-{lib}: {
-  options.mirrors = {
-    gnu = lib.options.create {
-      description = "The GNU mirror to use";
-      type = lib.types.string;
-      default.value = "https://ftp.gnu.org/gnu";
-    };
-  };
-}

tidepool/src/packages/default.nix

@@ -1,92 +0,0 @@
-{
-  lib,
-  lib',
-  config,
-}: let
-  doubles = lib'.systems.doubles.all;
-
-  packages = builtins.removeAttrs config.packages ["cross"];
-in {
-  includes = [
-    ./foundation
-  ];
-
-  options = {
-    packages = lib.options.create {
-      description = "The package set.";
-      type = lib.types.submodule {
-        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;
-            default = {};
-          });
-      };
-    };
-
-    preferences.packages = {
-      version = lib.options.create {
-        description = "The preferred package version when using aliases.";
-        type = lib.types.enum ["latest" "stable"];
-        default.value = "latest";
-      };
-    };
-  };
-
-  config.packages.cross = lib.attrs.generate doubles (
-    system:
-      builtins.mapAttrs
-      (
-        namespace:
-          builtins.mapAttrs
-          (name: alias: let
-            setHost = 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
-              // {
-                versions =
-                  builtins.mapAttrs
-                  (version: package: setHost package)
-                  alias.versions;
-              };
-          in
-            updated)
-      )
-      packages
-  );
-}

tidepool/src/packages/foundation/default.nix

@@ -1,43 +0,0 @@
-{
-  lib,
-  lib',
-  config,
-  options,
-}: {
-  includes = [
-    ./gcc
-  ];
-
-  config = {
-    packages = {
-      # example = {
-      #   x = {
-      #     versions = {
-      #       "latest" = {config}: {
-      #         config = {
-      #           meta = {
-      #             platforms = ["i686-linux" "x86_64-linux"];
-      #           };
-
-      #           pname = "x";
-      #           version = "1.0.0";
-
-      #           builder = builders.basic;
-
-      #           phases = {
-      #             build = ''
-      #               make --build ${config.platform.build.double} --host ${config.platform.host.double}
-      #             '';
-
-      #             install = lib.dag.entry.after ["build"] ''
-      #               make install DESTDIR=$out
-      #             '';
-      #           };
-      #         };
-      #       };
-      #     };
-      #   };
-      # };
-    };
-  };
-}

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

@@ -1,226 +0,0 @@
-{
-  lib,
-  lib',
-  config,
-  options,
-}: let
-  inherit
-    (config)
-    mirrors
-    builders
-    # These are the upstream foundational packages exported from the Aux Foundation project.
-    
-    foundation
-    ;
-in {
-  config.packages.foundation.gcc = {
-    versions = {
-      "13.2.0" = {
-        config,
-        meta,
-      }: {
-        options = {
-          src = lib.options.create {
-            type = lib.types.derivation;
-            description = "Source for the package.";
-          };
-
-          cc = {
-            src = lib.options.create {
-              type = lib.types.derivation;
-              description = "The cc source for the package.";
-            };
-          };
-
-          gmp = {
-            src = lib.options.create {
-              type = lib.types.derivation;
-              description = "The gmp source for the package.";
-            };
-
-            version = lib.options.create {
-              type = lib.types.string;
-              description = "Version of gmp.";
-            };
-          };
-
-          mpfr = {
-            src = lib.options.create {
-              type = lib.types.derivation;
-              description = "The mpfr source for the package.";
-            };
-
-            version = lib.options.create {
-              type = lib.types.string;
-              description = "Version of mpfr.";
-            };
-          };
-
-          mpc = {
-            src = lib.options.create {
-              type = lib.types.derivation;
-              description = "The mpc source for the package.";
-            };
-
-            version = lib.options.create {
-              type = lib.types.string;
-              description = "Version of mpc.";
-            };
-          };
-
-          isl = {
-            src = lib.options.create {
-              type = lib.types.derivation;
-              description = "The isl source for the package.";
-            };
-            version = lib.options.create {
-              type = lib.types.string;
-              description = "Version of isl.";
-            };
-          };
-        };
-
-        config = {
-          meta = {
-            platforms = ["i686-linux"];
-          };
-
-          pname = "gcc";
-          version = "13.2.0";
-
-          builder = builders.basic;
-
-          env = {
-            PATH = 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
-                  (meta.extend (args: {
-                    config = {
-                      platform = {
-                        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;
-          in {
-            unpack = lib.dag.entry.before ["patch"] ''
-              # Unpack
-              tar xf ${config.src}
-              tar xf ${config.gmp.src}
-              tar xf ${config.mpfr.src}
-              tar xf ${config.mpc.src}
-              tar xf ${config.isl.src}
-              cd gcc-${config.version}
-
-              ln -s ../gmp-${config.gmp.version} gmp
-              ln -s ../mpfr-${config.mpfr.version} mpfr
-              ln -s ../mpc-${config.mpc.version} mpc
-              ln -s ../isl-${config.isl.version} isl
-            '';
-
-            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 = lib.dag.entry.between ["build"] ["patch"] ''
-              # Configure
-              export CC="gcc -Wl,-dynamic-linker -march=${host.gcc.arch or host.system.cpu.arch} -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"
-
-              bash ./configure \
-                --prefix=$out \
-                --build=${config.platform.build.triple} \
-                --host=${config.platform.host.triple} \
-                --target=${config.platform.target.triple} \
-                --with-native-system-header-dir=/include \
-                --with-sysroot=${foundation.stage1-musl} \
-                --enable-languages=c,c++ \
-                --disable-bootstrap \
-                --disable-libsanitizer \
-                --disable-lto \
-                --disable-multilib \
-                --disable-plugin \
-                CFLAGS=-static \
-                CXXFLAGS=-static
-            '';
-
-            build = lib.dag.entry.between ["install"] ["configure"] ''
-              # Build
-              make -j $NIX_BUILD_CORES
-            '';
-
-            install = lib.dag.entry.after ["build"] ''
-              # Install
-              make -j $NIX_BUILD_CORES install-strip
-            '';
-          };
-
-          src = builtins.fetchurl {
-            url = "${mirrors.gnu}/gcc/gcc-${config.version}/gcc-${config.version}.tar.xz";
-            sha256 = "4nXnZEKmBnNBon8Exca4PYYTFEAEwEE1KIY9xrXHQ9o=";
-          };
-
-          gmp = {
-            version = "6.3.0";
-            src = builtins.fetchurl {
-              url = "${mirrors.gnu}/gmp/gmp-${config.gmp.version}.tar.xz";
-              sha256 = "o8K4AgG4nmhhb0rTC8Zq7kknw85Q4zkpyoGdXENTiJg=";
-            };
-          };
-
-          mpfr = {
-            version = "4.2.1";
-            src = builtins.fetchurl {
-              url = "${mirrors.gnu}/mpfr/mpfr-${config.mpfr.version}.tar.xz";
-              sha256 = "J3gHNTpnJpeJlpRa8T5Sgp46vXqaW3+yeTiU4Y8fy7I=";
-            };
-          };
-
-          mpc = {
-            version = "1.3.1";
-            src = builtins.fetchurl {
-              url = "${mirrors.gnu}/mpc/mpc-${config.mpc.version}.tar.gz";
-              sha256 = "q2QkkvXPiCt0qgy3MM1BCoHtzb7IlRg86TDnBsHHWbg=";
-            };
-          };
-
-          isl = {
-            version = "0.24";
-            src = builtins.fetchurl {
-              url = "https://gcc.gnu.org/pub/gcc/infrastructure/isl-${config.isl.version}.tar.bz2";
-              sha256 = "/PeN2WVsEOuM+fvV9ZoLawE4YgX+GTSzsoegoYmBRcA=";
-            };
-          };
-        };
-      };
-    };
-  };
-}