tangled.org init

LICENSE

···
 MIT License
 
-Copyright (c) 2023 siluam
+Copyright (c) 2023 simple
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

···
-# siluam
+# simple
+
+This allows users to import flakes using `import <path to flake>`,
+or import them using a local fork of `simple` using `import <path to flake> <path to local fork>`
+or `import <path to local fork> <path to flake>`.
 
 ```nix
 let
-  siluam = ssrc:
-    import (let
-      lock = if (builtins.pathExists ./flake.lock) then
-        (builtins.fromJSON (builtins.readFile ./flake.lock))
-      else
-        { };
-      locked = lock.nodes.siluam.locked or { rev = "main"; };
-      url = locked.url or "https://github.com/siluam/siluam/archive/${
-          locked.rev or "main"
-        }.tar.gz";
-    in if ((ssrc != ./.) && (builtins.pathExists ssrc)) then
-      ssrc
-    else if (builtins ? getFlake) then
-      (builtins.getFlake url)
-    else
-      (fetchTarball {
-        inherit url;
-        ${if (locked ? narHash) then "sha256" else null} = locked.narHash;
-      }));
-in (siluam ./. ./.) // { __functor = self: ssrc: siluam ssrc ./.; }
+  nodes = if (builtins.pathExists ./flake.lock) then
+    (builtins.fromJSON (builtins.readFile ./flake.lock))
+  else {
+    root.inputs.simple = "simple";
+    simple.locked.rev = "main";
+  };
+  inherit (nodes.${nodes.root.inputs.simple}) locked;
+  url =
+    locked.url or "https://tangled.org/@syvl.org/simple/archive/${locked.rev}";
+  simple = if (builtins ? getFlake) then
+    (builtins.getFlake url)
+  else
+    (import (fetchTarball {
+      inherit url;
+      ${if (locked ? narHash) then "sha256" else null} = locked.narHash;
+    }));
+in (builtins.getFlake or simple) (toString ./.)
 ```

default.nix

···
 let
-  siluam = src:
-    with import ./lib.nix;
-    let
-      self = mkFlake { src = ./.; };
-      flake = if (src == ./.) then
-        self
-      else
-        (mkFlake {
-          inherit src;
-          inherit (self) flake-compat;
-        });
-      nixpkgs = flake.inputs.nixpkgs or self.inputs.nixpkgs;
-      inherit (nixpkgs) lib legacyPackages;
-      flakeAttrs = lib.filterAttrs (n: isAttrsOnly) flake;
-      swap = system: builtins.mapAttrs (n: builtins.getAttr system) flakeAttrs;
-      assign = system:
-        builtins.mapAttrs (n: v: v // { currentSystem = v.${system}; })
-        (lib.filterAttrs (n: builtins.hasAttr system) flakeAttrs);
-      assignPkgs = current: attrs:
-        (genAttrs [ "legacyPackages" "pkgs" ] (pkgs:
-          if current then
-            legacyPackages.${builtins.currentSystem}
-          else
-            (legacyPackages // {
-              currentSystem = legacyPackages.${builtins.currentSystem};
-            }))) // attrs;
-    in {
-      inherit lib;
-    } // flake // {
-      currentSystem = assignPkgs true
-        (flake.${builtins.currentSystem} or (swap builtins.currentSystem));
-    } // (assignPkgs false (assign builtins.currentSystem));
-in (siluam ./.) // { __functor = self: siluam; }
+  inherit (builtins.fromJSON (builtins.readFile ./flake.lock)) nodes;
+  inherit (nodes.${nodes.root.inputs.flake-compat}) locked;
+in if (builtins ? getFlake) then
+  (builtins.getFlake (toString ./.))
+else
+  ((import builtins.fetchTarball {
+    url =
+      locked.url or "https://github.com/edolstra/flake-compat/archive/${locked.rev}.tar.gz";
+    sha256 = locked.narHash;
+  }) { src = ./.; }).defaultNix

flake.lock

···
         "type": "github"
       }
     },
-    "nixpkgs": {
+    "nixpkgs-lib": {
       "locked": {
-        "lastModified": 1753115646,
-        "narHash": "sha256-yLuz5cz5Z+sn8DRAfNkrd2Z1cV6DaYO9JMrEz4KZo/c=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "92c2e04a475523e723c67ef872d8037379073681",
+        "lastModified": 1754788789,
+        "narHash": "sha256-x2rJ+Ovzq0sCMpgfgGaaqgBSwY+LST+WbZ6TytnT9Rk=",
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "rev": "a73b9c743612e4244d865a2fdee11865283c04e6",
         "type": "github"
       },
       "original": {
-        "owner": "nixos",
-        "ref": "nixos-25.05",
-        "repo": "nixpkgs",
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
         "type": "github"
       }
     },
     "root": {
       "inputs": {
         "flake-compat": "flake-compat",
-        "nixpkgs": "nixpkgs"
+        "nixpkgs-lib": "nixpkgs-lib"
       }
     }
   },

flake.nix

···
 {
   inputs.flake-compat.url = "github:edolstra/flake-compat";
   inputs.flake-compat.flake = false;
-  inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-25.05";
-  outputs = { ... }:
+  inputs.nixpkgs-lib.url = "github:nix-community/nixpkgs.lib";
+  outputs = inputs@{ flake-compat, nixpkgs-lib, ... }:
     let
-      siluam = {
-        lib = import ./lib.nix;
-        # TODO: Add the legacyPackages and pkgs here
-      };
-    in { __functor = self: import ./.; } // siluam;
+      lib = nixpkgs-lib.lib.extend
+        (import ./lib { system = builtins.currentSystem or "x86_64-linux"; });
+      inherit (lib.syvl) mk getFlake;
+    in mk {
+      inherit inputs;
+      outputs = [
+        (top@{ system, ... }: { packages.hello = null; })
+        {
+          inherit mk;
+          __functor = self: src:
+            if ((builtins.isAttrs src) || (lib.isFunction src)) then
+              (mk src)
+            else
+              (getFlake { inherit src flake-compat; });
+        }
+      ];
+    };
 }

lib.nix

···
-rec {
-  inherit (builtins) trace;
-  traceVal = value: trace value value;
-  traceValSeq = value: trace (builtins.deepSeq value value) value;
-
-  optionalAttrs = cond: attrs: if cond then attrs else { };
-  optionalString = cond: string: if cond then string else "";
-
-  stringToCharacters = s:
-    builtins.genList (p: builtins.substring p 1 s) (builtins.stringLength s);
-  lowerChars = stringToCharacters "abcdefghijklmnopqrstuvwxyz";
-  upperChars = stringToCharacters "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  toLower = builtins.replaceStrings upperChars lowerChars;
-  toUpper = builtins.replaceStrings lowerChars upperChars;
-
-  # Taken From: https://github.com/NixOS/nixpkgs/blob/master/lib/attrsets.nix#L747C1-L762C56
-  /* Generate an attribute set by mapping a function over a list of
-     attribute names.
-
-     Example:
-       genAttrs [ "foo" "bar" ] (name: "x_" + name)
-       => { foo = "x_foo"; bar = "x_bar"; }
-
-     Type:
-       genAttrs :: [ String ] -> (String -> Any) -> AttrSet
-  */
-  genAttrs =
-    # Names of values in the resulting attribute set.
-    names:
-    # A function, given the name of the attribute, returns the attribute's value.
-    f:
-    builtins.listToAttrs (map (name: {
-      inherit name;
-      value = f name;
-    }) names);
-
-  # Taken From: https://github.com/NixOS/nixpkgs/blob/master/lib/lists.nix#L856C1-L864C73
-  /* Remove duplicate elements from the list. O(n^2) complexity.
-
-     Type: unique :: [a] -> [a]
-
-     Example:
-       unique [ 3 2 3 4 ]
-       => [ 3 2 4 ]
-  */
-  unique =
-    builtins.foldl' (acc: e: if builtins.elem e acc then acc else acc ++ [ e ])
-    [ ];
-
-  # Taken From: https://github.com/NixOS/nixpkgs/blob/master/lib/lists.nix#L866C1-L876C59
-  /* Check if list contains only unique elements. O(n^2) complexity.
-
-     Type: allUnique :: [a] -> bool
-
-     Example:
-       allUnique [ 3 2 3 4 ]
-       => false
-       allUnique [ 3 2 4 1 ]
-       => true
-  */
-  allUnique = list: (builtins.length (unique list) == builtins.length list);
-
-  # Taken From: https://github.com/NixOS/nixpkgs/blob/master/lib/strings.nix#L259C1-L284C53
-  /* Determine whether a string has given prefix.
-
-     Type: hasPrefix :: string -> string -> bool
-
-     Example:
-       hasPrefix "foo" "foobar"
-       => true
-       hasPrefix "foo" "barfoo"
-       => false
-  */
-  hasPrefix =
-    # Prefix to check for
-    pref:
-    # Input string
-    str:
-    # Before 23.05, paths would be copied to the store before converting them
-    # to strings and comparing. This was surprising and confusing.
-    if (builtins.isPath pref) then
-      abort ''
-        lib.strings.hasPrefix: The first argument (${
-          toString pref
-        }) is a path value, but only strings are supported.
-            There is almost certainly a bug in the calling code, since this function always returns `false` in such a case.
-            This function also copies the path to the Nix store, which may not be what you want.
-            This behavior is deprecated.
-            You might want to use `lib.path.hasPrefix` instead, which correctly supports paths.''
-    else
-      (builtins.substring 0 (builtins.stringLength pref) str == pref);
-
-  # Taken From: https://github.com/NixOS/nixpkgs/blob/master/lib/attrsets.nix#L616C1-L633C66
-  /* Like `mapAttrs`, but allows the name of each attribute to be
-     changed in addition to the value.  The applied function should
-     return both the new name and value as a `nameValuePair`.
-
-     Example:
-       mapAttrs' (name: value: nameValuePair ("foo_" + name) ("bar-" + value))
-          { x = "a"; y = "b"; }
-       => { foo_x = "bar-a"; foo_y = "bar-b"; }
-
-     Type:
-       mapAttrs' :: (String -> Any -> { name :: String; value :: Any; }) -> AttrSet -> AttrSet
-  */
-  mapAttrs' =
-    # A function, given an attribute's name and value, returns a new `nameValuePair`.
-    f:
-    # Attribute set to map over.
-    set:
-    builtins.listToAttrs
-    (map (attr: f attr set.${attr}) (builtins.attrNames set));
-
-  mapAttrNames = f:
-    mapAttrs' (name: value: {
-      name = f name value;
-      inherit value;
-    });
-
-  # Taken From: https://github.com/NixOS/nixpkgs/blob/master/lib/attrsets.nix#L636C1-L653C56
-  /* Call a function for each attribute in the given set and return
-     the result in a list.
-
-     Example:
-       mapAttrsToList (name: value: name + value)
-          { x = "a"; y = "b"; }
-       => [ "xa" "yb" ]
-
-     Type:
-       mapAttrsToList :: (String -> a -> b) -> AttrSet -> [b]
-  */
-  mapAttrsToList =
-    # A function, given an attribute's name and value, returns a new value.
-    f:
-    # Attribute set to map over.
-    attrs:
-    map (name: f name attrs.${name}) (builtins.attrNames attrs);
-
-  # Taken From: https://github.com/NixOS/nixpkgs/blob/master/lib/attrsets.nix#L765C1-L780C47
-  /* Check whether the argument is a derivation. Any set with
-     `{ type = "derivation"; }` counts as a derivation.
-
-     Example:
-       nixpkgs = import <nixpkgs> {}
-       isDerivation nixpkgs.ruby
-       => true
-       isDerivation "foobar"
-       => false
-
-     Type:
-       isDerivation :: Any -> Bool
-  */
-  isDerivation =
-    # Value to check.
-    value:
-    value.type or null == "derivation";
-
-  isAttrsOnly = value: (builtins.isAttrs value) && (!(isDerivation value));
-
-  processInputs = inputs:
-    builtins.mapAttrs (n: sourceInfo: rec {
-      inherit sourceInfo;
-      inherit (sourceInfo) outPath;
-      _type = toLower (sourceInfo.repository.type or sourceInfo.type);
-      inputs = { };
-      outputs = { };
-      lastModified = 0;
-      lastModifiedDate = "";
-      rev = sourceInfo.revision or sourceInfo.rev;
-      shortRev = builtins.substring 0 7 rev;
-    }) inputs;
-
-  mkOutPath = args@{ src, owner ? "", repo ? "", rev ? "master", ... }:
-    let
-      name = args.name or repo;
-      flakeLock = let path = src + "/flake.lock";
-      in optionalAttrs (builtins.pathExists path)
-      (builtins.fromJSON (builtins.readFile path));
-      nivLock = let path = src + "/nix/sources.nix";
-      in optionalAttrs (builtins.pathExists path) (import path);
-      npinsLock = let path = src + "/npins";
-      in optionalAttrs (builtins.pathExists path) (import path);
-      lock = flakeLock.nodes.${name}.locked or { inherit rev; };
-    in if (name != "") then
-      (nivLock.${name} or npinsLock.${name} or {
-        outPath = if ((owner != "") && (repo != "")) then
-          (fetchTarball {
-            url =
-              lock.url or "https://github.com/${owner}/${repo}/archive/${lock.rev}.tar.gz";
-            ${if (lock ? narHash) then "sha256" else null} = lock.narHash;
-          })
-        else
-          src;
-      }).outPath
-    else
-      src;
-
-  mkFlake = args@{ src, shell ? false, ... }:
-    let
-      srcString = toString src;
-      flake = if (builtins ? getFlake) then
-        (builtins.getFlake srcString)
-      else
-        (let
-          flake-compat = args.flake-compat or (import (mkOutPath {
-            inherit src;
-            owner = "edolstra";
-            repo = "flake-compat";
-          }) src);
-          outPath = let path = mkOutPath args;
-          in if (srcString == (toString path)) then
-            src
-          else
-            (builtins.unsafeDiscardStringContext path);
-        in flake-compat { src = outPath; }).${
-          if shell then "shellNix" else "defaultNix"
-        };
-    in flake // {
-      inputs = mkInputs {
-        inherit src;
-        inherit (flake) inputs;
-      };
-    };
-
-  # TODO: Remove the tryEval from here
-  # recursiveUpdateAll' = delim: a: b:
-  #   let a-names = attrNames a;
-  #   in (mapAttrs (n: v:
-  #     let e = tryEval v;
-  #     in if (e.success && (isAttrsOnly v)) then
-  #       (if (any (attr:
-  #         let g = tryEval attr;
-  #         in g.success
-  #         && ((isAttrsOnly attr) || (isList attr) || (isString attr)))
-  #         (attrValues v)) then
-  #         (recursiveUpdateAll' delim v (b.${n} or { }))
-  #       else
-  #         (v // (b.${n} or { })))
-  #     else if (isList v) then
-  #       (v ++ (b.${n} or [ ]))
-  #     else if ((delim != null) && (isString v)) then
-  #       (if (hasAttr n b) then (v + delim + b.${n}) else v)
-  #     else
-  #       (b.${n} or v)) a) // (removeAttrs b a-names);
-  recursiveUpdateAll' = delim: a: b:
-    let a-names = builtins.attrNames a;
-    in (builtins.mapAttrs (n: v:
-
-      # TODO: Is this `tryEval' necessary?
-      let e = builtins.tryEval v;
-      in if (e.success && (builtins.any (x: x) [ (isAttrsOnly v) ])) then
-
-      # TODO: Need this to merge mkShells
-      # in if (e.success && ((isAttrsOnly v) || (v ? shellHook))) then
-
-      # (if (any (attr: (isAttrs attr) || (isList attr) || (isString attr))
-      #   (attrValues v)) then
-      #   (recursiveUpdateAll' delim v (b.${n} or { }))
-      # else
-      #   (v // (b.${n} or { })))
-        (recursiveUpdateAll' delim v (b.${n} or { }))
-      else if (e.success && (isDerivation v)
-        && (b.${n}.__append__ or false)) then
-        (recursiveUpdateAll' delim v (removeAttrs b.${n} [ "__append__" ]))
-      else if (builtins.isList v) then
-        (v ++ (b.${n} or [ ]))
-      else if ((delim != null) && (builtins.isString v)) then
-        (if (builtins.hasAttr n b) then (v + delim + b.${n}) else v)
-      else
-        (b.${n} or (if (n == "overridePythonAttrs") then "" else v))) a)
-    // (removeAttrs b a-names);
-  recursiveUpdateAll = recursiveUpdateAll' null;
-
-  mkInputs =
-    args@{ src, inputs ? { }, niv ? true, npins ? true, overrides ? { }, ... }:
-    let
-      mkFlakes = default: manager:
-        let
-          managerIsString = builtins.isString manager;
-          bool = managerIsString || ((builtins.isBool manager) && manager);
-          path =
-            optionalString bool (if managerIsString then manager else default);
-          rootPath = src + "/${path}";
-        in optionalAttrs (bool && (builtins.pathExists rootPath))
-        (builtins.mapAttrs (name: v:
-          let
-            outPath = if (hasPrefix "/" v.outPath) then
-              (builtins.unsafeDiscardStringContext v.outPath)
-            else
-              (src + "/${v.outPath}");
-            flakePath = outPath + "/flake.nix";
-          in if (builtins.pathExists flakePath) then
-            (mkFlake {
-              inherit name;
-              src = outPath;
-              owner = v.repository.owner or v.owner;
-              repo = v.repository.repo or v.repo;
-              inherit (v) rev;
-            })
-          else
-            (processInputs v)) (import rootPath));
-    in builtins.foldl' (a: b: a // b) inputs (mapAttrsToList mkFlakes {
-      "nix/sources.nix" = niv;
-      npins = npins;
-    });
-}

lib/default.nix

···
+inheritance@{ system, ... }:
+final: prev:
+with final;
+let
+  silicon = rec {
+    _name = "syvl";
+    isAttrsOnly = value: (builtins.isAttrs value) && (!(isDerivation value));
+
+    # TODO: Remove the tryEval from here
+    # recursiveUpdateAll' = delim: a: b:
+    #   let a-names = attrNames a;
+    #   in (mapAttrs (n: v:
+    #     let e = tryEval v;
+    #     in if (e.success && (isAttrsOnly v)) then
+    #       (if (any (attr:
+    #         let g = tryEval attr;
+    #         in g.success
+    #         && ((isAttrsOnly attr) || (isList attr) || (isString attr)))
+    #         (attrValues v)) then
+    #         (recursiveUpdateAll' delim v (b.${n} or { }))
+    #       else
+    #         (v // (b.${n} or { })))
+    #     else if (isList v) then
+    #       (v ++ (b.${n} or [ ]))
+    #     else if ((delim != null) && (isString v)) then
+    #       (if (hasAttr n b) then (v + delim + b.${n}) else v)
+    #     else
+    #       (b.${n} or v)) a) // (builtins.removeAttrs b a-names);
+    recursiveUpdateAll' = delim: a: b:
+      let a-names = builtins.attrNames a;
+      in (builtins.mapAttrs (n: v:
+
+        # TODO: Is this `tryEval' necessary?
+        let e = builtins.tryEval v;
+        in if (e.success && (builtins.any (x: x) [ (isAttrsOnly v) ])) then
+
+        # TODO: Need this to merge mkShells
+        # in if (e.success && ((isAttrsOnly v) || (v ? shellHook))) then
+
+        # (if (any (attr: (isAttrs attr) || (isList attr) || (isString attr))
+        #   (attrValues v)) then
+        #   (recursiveUpdateAll' delim v (b.${n} or { }))
+        # else
+        #   (v // (b.${n} or { })))
+          (recursiveUpdateAll' delim v (b.${n} or { }))
+        else if (e.success && (isDerivation v)
+          && (b.${n}.__append__ or false)) then
+          (recursiveUpdateAll' delim v
+            (builtins.removeAttrs b.${n} [ "__append__" ]))
+        else if (builtins.isList v) then
+          (v ++ (b.${n} or [ ]))
+        else if ((delim != null) && (builtins.isString v)) then
+          (if (builtins.hasAttr n b) then (v + delim + b.${n}) else v)
+        else
+          (b.${n} or (if (n == "overridePythonAttrs") then "" else v))) a)
+      // (builtins.removeAttrs b a-names);
+    recursiveUpdateAll = recursiveUpdateAll' null;
+
+    # Adapted From: https://github.com/NixOS/nixpkgs/blob/master/lib/fixed-points.nix#L40
+    mergeExtends = f: rattrs: self:
+      let super = rattrs self;
+      in (recursiveUpdateAll super (f self super));
+
+    # Adapted From: https://github.com/NixOS/nixpkgs/blob/master/lib/fixed-points.nix#L107
+    mkMergeExtensibleWithCustomName = extenderName: rattrs:
+      fix' (self:
+        (rattrs self) // {
+          ${extenderName} = f:
+            mkMergeExtensibleWithCustomName extenderName
+            (mergeExtends f rattrs);
+        });
+
+    # Adapted From: https://github.com/NixOS/nixpkgs/blob/master/lib/fixed-points.nix#L89
+    mkMergeExtensible = mkMergeExtensibleWithCustomName "extend";
+
+    tracer = items: compose (map (item: builtins.trace item) items);
+    deepSeqVal = value: builtins.deepSeq value value;
+
+    import = {
+      can = f:
+        let fString = toString f;
+        in ((isString f) || (isPath f)) && ((hasSuffix ".nix" fString)
+          || ((builtins.readDir fString) ? "default.nix"));
+      should = f:
+        let
+          should_import = silicon.import.can f;
+          should_return = builtins.isAttrs f || builtins.isFunction f;
+        in {
+          success = should_import || should_return;
+          value = if should_import then
+            (builtins.import f)
+          else if should_return then
+            f
+          else
+            false;
+        };
+      # TODO: Use an args set of includes and ignores
+      all = rec {
+        named = _dir:
+          { ignores ? "default", recurse ? false }:
+          let
+            dir = toString _dir;
+            removeNix = removeSuffix ".nix";
+          in if (builtins.pathExists dir) then
+            (if recurse then
+              (builtins.listToAttrs (map (file:
+                nameValuePair (builtins.baseNameOf (removeNix file))
+                (builtins.import file)) filesystem.listFilesRecursive))
+            else
+              (pipe dir [
+                builtins.readDir
+                (filterAttrs (n: v:
+                  (!(elem (removeNix n) (toList ignores)))
+                  && (!(hasPrefix "_" n)) && (let isDir = v == "directory";
+                  in (isDir
+                    && ((builtins.readDir "${dir}/${n}") ? "default.nix"))
+                  || (!isDir))))
+                (mapAttrs' (n: v:
+                  nameValuePair (removeNix n) (builtins.import "${dir}/${n}")))
+              ]))
+          else
+            { };
+        __functor = self: _dir: ignores:
+          builtins.attrValues (named _dir ignores);
+      };
+    };
+
+    intersectArgs = f: with builtins; intersectAttrs (functionArgs f);
+
+    callFunction = f: args: f (intersectArgs f args);
+    callFunction' = f: args: functionArgs: f (intersectAttrs functionArgs args);
+
+    compose = flip pipe;
+
+    callLib = final: prev: self: super: inheritance: file:
+      let
+        args = {
+          inherit final prev;
+          self = final.syvl;
+          super = prev.syvl;
+          lib = final;
+          inherit (final) syvl;
+          inherit silicon;
+        } // inheritance;
+        ifile = builtins.import file;
+      in if (isAttrs file) then
+        file
+      else if (isFunction file) then
+        (callFunction file args)
+      else if (isAttrs ifile) then
+        ifile
+      else
+        (callFunction ifile args);
+
+    mks = {
+      call = final: prev: self: super: inheritance: f:
+        let
+          apply = callLib final prev self super inheritance;
+          e = silicon.import.should f;
+        in if e.success then
+          (apply e.value)
+        else if (isList f) then
+          (map apply f)
+        else
+          (map apply (silicon.import.all f { }));
+
+      extend = name: final: prev: inheritance: f:
+        let
+          update = silicon: self: super:
+            let extension = mks.call final prev self super inheritance f;
+            in if (isAttrs extension) then
+              (recursiveUpdateAll silicon extension)
+            else
+              (foldl' recursiveUpdateAll silicon extension);
+        in if (hasAttr name prev) then
+          (prev.${name}.extend (update { }))
+        else
+          (mkMergeExtensible (self: update silicon self { }));
+
+      # `final` is the final state of `lib`
+      # `prev` is the original state of `lib`
+      # `self` is the final state of `syvl`
+      # `super` is the original state of `syvl`
+      lib = name: lib: inheritance: f:
+        lib.extend
+        (final: prev: { ${name} = mks.extend name final prev inheritance f; });
+
+      "${_name}lib" = mks.lib _name;
+
+      libs = lib: inheritances: fs:
+        lib.extend (final: prev:
+          mapAttrs
+          (name: mks.extend name final prev (inheritances.${name} or { })) fs);
+
+    };
+    __functor = _: mks.lib _name;
+  };
+in with silicon; {
+  ${_name} =
+    mks.extend _name final prev inheritance (silicon.import.all ./. { });
+}

lib/flake.nix

···
+{ lib, prev, silicon, system }:
+with lib;
+with silicon; rec {
+  getFlake = args@{ src, ... }:
+    let
+      yesFlake = builtins ? getFlake;
+      flake = if yesFlake then
+        (builtins.getFlake (toString src))
+      else
+        (let
+          nodes = if (builtins.pathExists ./flake.lock) then
+            (builtins.fromJSON (builtins.readFile ./flake.lock))
+          else {
+            root.inputs.flake-compat = "flake-compat";
+            flake-compat.locked.rev = "master";
+          };
+          inherit (nodes.${nodes.root.inputs.flake-compat}) locked;
+          url =
+            locked.url or "https://github.com/edolstra/flake-compat/archive/${locked.rev}.tar.gz";
+          flake-compat = args.flake-compat or (if yesFlake then
+            (builtins.getFlake url)
+          else
+            (builtins.import (fetchTarball {
+              inherit url;
+              ${if (locked ? narHash) then "sha256" else null} = locked.narHash;
+            })));
+
+          # builtins.unsafeDiscardStringContext
+        in flake-compat { inherit src; }).defaultNix;
+
+    in formatOutputs flake;
+
+  isLambda = f: (!(isAttrs f)) && (isFunction f);
+  isFunctor = f: (isAttrs f) && (isFunction f);
+  isCoerced = f: (f ? __functionArgs) && (f ? __functor);
+  isCoercedLambda = f: (isLambda f) || (isCoerced f);
+
+  mk = {
+    # Adapted From: https://github.com/hercules-ci/flake-parts/blob/4524271976b625a4a605beefd893f270620fd751/lib.nix#L72C5-L125C11
+    __functor = self: mk.simple;
+    simple = let
+      strPath = with types; either str path;
+      extraLibType = with types;
+        oneOf [ str path attrs list (functionTo attrs) ];
+    in module:
+    formatOutputs (lib.evalModules {
+      class = "flake";
+      modules = [
+        ({ config, options, ... }: {
+          options = {
+            src = mkOption {
+              type = strPath;
+              default =
+                dirOf (unsafeGetAttrPos (head (attrNames module)) module).file;
+              apply = toString;
+            };
+            sources = mkOption {
+              type = with types;
+                coercedTo (either strPath (listOf strPath)) (compose [
+                  toList
+                  (map (src: config.src + "/" + src))
+                  (filter pathExists)
+                ]) (listOf strPath);
+            };
+            self = mkOption {
+              type = types.attrs;
+              default = config.inputs.self;
+            };
+            inputs = mkOption {
+              type = types.attrs;
+              apply = mapAttrs
+                (n: v: if (isAttrsOnly v) then (formatOutputs v) else v);
+            };
+            ${_name} = mkOption {
+              type = extraLibType;
+              default = { };
+            };
+            lib = mkOption {
+              type = types.attrs;
+              default = lib;
+              apply = lib:
+                if (config.libs == { }) then
+                  lib
+                else
+                  (mks.libs lib config.inheritances config.libs);
+            };
+            inheritance = mkOption {
+              type = types.attrs;
+              default = { };
+            };
+            inheritances = mkOption {
+              type = types.attrs;
+              default = { };
+            };
+            libs = mkOption {
+              type = types.attrsOf extraLibType;
+              default = { };
+            };
+
+            # TODO: Convert this to a nixpkgs settings submodule,
+            #       using the `functionArgs' of `config.nixpkgs`.
+            settings = mkOption {
+              type = with types;
+                submodule ({ name, config, ... }: {
+                  options = {
+                    config = mkOption {
+                      type = attrs;
+                      default = { };
+                    };
+                    overlays = mkOption {
+                      type = attrsOf (functionArgsTo 2 attrs);
+                      default = { };
+                    };
+                  };
+                });
+            };
+            nixpkgs = mkOption {
+              type = types.attrs;
+              default = let
+                nixpkgs = attrValues
+                  (filterAttrs (n: v: hasPrefix "nixpkgs" n) config.inputs);
+              in if (nixpkgs == [ ]) then { } else (head nixpkgs);
+            };
+
+            specialArgs = mkOption { type = types.attrs; };
+            flake = mkOption {
+              type = types.attrs;
+              default = { };
+            };
+
+            # TODO: Make `outputs' a submodule, and everything extra
+            #       will be in a separate attrset that will be merged into the outputs
+            #       at the end.
+            outputs = mkOption {
+              type = with types;
+                let
+                  attrTypes = either attrs (functionTo attrs);
+                  outputTypes = oneOf [ str path attrTypes ];
+                in coercedTo (either outputTypes (listOf outputTypes))
+                (compose [
+                  toList
+                  (map (f:
+                    let e = silicon.import.should f;
+                    in syvl.mif.null e.success e.value))
+                  (remove null)
+                ]) (listOf attrTypes);
+            };
+
+            systems = mkOption {
+              type = with types;
+                let systemType = enum lib.systems.flakeExposed;
+                in coercedTo (either systemType (listOf systemType)) toList
+                (listOf systemType);
+              default = [ system ];
+            };
+            makers = mkOption {
+              type = with types; attrsOf (optionTypes.functionArgsTo 2 attrs);
+            };
+            maker = mkOption {
+              type = with types;
+                either (functionTo (either attrs (functionTo attrs)))
+                (enum (builtins.attrNames config.makers));
+              default = "default";
+            };
+          };
+          _file = toString ./flake.nix;
+          config = let extraLib = !(elem config.${_name} [ { } [ ] ]);
+          in {
+            libs = mkIf extraLib { ${_name} = config.${_name}; };
+            inheritances = mkIf extraLib { ${_name} = config.inheritance; };
+
+            sources = [ "nix/sources.nix" "npins" ];
+            inputs = mkMerge (map builtins.import config.sources);
+
+            specialArgs = {
+              # inherit (config) self inputs lib pkgs;
+            };
+
+            outputs = let srcDir = builtins.readDir config.src;
+            in [
+
+              (let outputs = config.src + "/outputs.nix";
+              in syvl.mif.null
+              ((srcDir."outputs.nix" or "directory") != "directory") outputs)
+
+              (let outputs = config.src + "/outputs";
+              in syvl.mif.null (((srcDir.outputs or "file") == "directory")
+                && ((builtins.readDir outputs) ? "default.nix")) outputs)
+
+            ];
+
+            makers = {
+              default = outputs: inputs:
+                if (isCoercedLambda outputs) then
+                  (let
+                    functionArgs =
+                      outputs.__functionArgs or (builtins.functionArgs outputs);
+                  in if (functionArgs ? system) then
+                    (mkMerge (map (system:
+                      mapAttrs (n: v: { ${system} = v; }) (callFunction' outputs
+                        (inputs // {
+                          inherit system;
+                          pkgs = import config.nixpkgs
+                            ((removeAttrs config.settings [ "overlays" ]) // {
+                              inherit system;
+                              hostPlatform = system;
+                              overlays = attrValues config.settings.overlays;
+                            });
+                        }) functionArgs)) config.systems))
+                  else
+                    (callFunction' outputs inputs functionArgs))
+                else
+                  outputs;
+              flake-parts = outputs:
+                inputs@{ flake-parts, ... }:
+                flake-parts.lib.mkFlake { inherit inputs; }
+                (if (isFunction outputs) then
+                  outputs
+                else
+                  ({ inherit (config) systems; } // outputs));
+            };
+
+            flake = mkMerge ([{
+              inherit config;
+              simpleflake = true;
+            }] ++ (map (flip config.makers.${config.maker} ({
+              inherit (config) lib; # pkgs;
+            } // config.inputs)) (unique config.outputs)));
+          };
+        })
+
+        # Adapted From: https://github.com/NixOS/nixpkgs/blob/df3de70468b743b371a7191ea61d1040fe3bf399/lib/modules.nix#L567-L570
+        ({ config, ... }: {
+          imports = let moduleLocation = "${config.src}/flake.nix";
+          in [{
+            _file = moduleLocation;
+            _module.args = { inherit moduleLocation; } // config.specialArgs;
+            imports = [ module ];
+          }];
+        })
+
+      ];
+    }).config.flake;
+  };
+
+  optionTypes.functionArgsTo = argNumber:
+    compose (replicate argNumber types.functionTo);
+
+  formatOutputs = _flake:
+    let
+      systemsList = builtins.attrNames
+        (_flake.checks or _flake.packages or _flake.apps or _flake.formatter or _flake.devShells or _flake.legacyPackages or {
+          ${system} = null;
+        });
+      flake = {
+        lib = lib.genAttrs systemsList
+          (system: lib.extend (builtins.import ./. { inherit system; }));
+      } // _flake;
+      systems = let
+        allSystems = lib.genAttrs systemsList
+          (system: lib.mapAttrs (n: v: v.${system} or v) flake);
+      in allSystems // { currentSystem = allSystems.${system}; };
+    in {
+      inherit systems;
+    } // (lib.mapAttrs (n: v:
+      if ((isAttrsOnly v) && (builtins.hasAttr system v)) then
+        (v // { currentSystem = systems.currentSystem.${n}; })
+      else
+        v) flake) // {
+          inputs = let
+            simpleflake = flake.simpleflake or false;
+            inputs = if simpleflake then
+              flake.config.inputs
+            else
+              (flake.inputs or { });
+          in if simpleflake then
+            inputs
+          else
+            (mapAttrs (n: v: if (isAttrsOnly v) then (formatOutputs v) else v)
+              inputs);
+        };
+}

lib/optionals.nix

···
+{ lib }:
+with lib; {
+  optionalName = condition: name: if condition then name else null;
+  mif = {
+    list = optionals;
+    list' = optional;
+    attrs = optionalAttrs;
+    num = condition: value: if condition then value else 0;
+    null = syvl.optionalName;
+    str = optionalString;
+    True = condition: value: if condition then value else true;
+    False = condition: value: if condition then value else false;
+    fn = condition: fn: value: if condition then (fn value) else value;
+  };
+  mifNotNull = {
+    __functor = self: a: b: if (a != null) then a else b;
+    list = a: optionals (a != null);
+    list' = a: optional (a != null);
+    attrs = a: optionalAttrs (a != null);
+    num = a: b: if (a != null) then b else 0;
+    null = a: b: if (a != null) then b else null;
+    nullb = a: b: c: if (a != null) then b else c;
+    str = a: optionalString (a != null);
+    True = a: b: if (a != null) then b else true;
+    False = a: b: if (a != null) then b else false;
+  };
+}

shell.nix

···
-let siluam = toString ./.;
-in with (import siluam).legacyPackages.currentSystem;
-mkShell {
-  buildInputs = [ git just nixfmt ];
-  shellHook = ''
-    nixfmt ${siluam}
-    git -C ${siluam} add .
-    nix flake update ${siluam}
-    exec nix repl -L --show-trace --expr "{ siluam = import ${siluam}; }"
-  '';
-}
+let
+  inherit (builtins.fromJSON (builtins.readFile ./flake.lock)) nodes;
+  inherit (nodes.${nodes.root.inputs.flake-compat}) locked;
+in if (builtins ? getFlake) then
+  (builtins.getFlake (toString ./.))
+else
+  ((import builtins.fetchTarball {
+    url =
+      locked.url or "https://github.com/edolstra/flake-compat/archive/${locked.rev}.tar.gz";
+    sha256 = locked.narHash;
+  }) { src = ./.; }).shellNix