anchor.diff:        if pathContent == null then
           builtins.throw "Attribute path `${path}` does not exists."
         else
  -        packagesWithPath prefix (relativePath: pkg: builtins.hasAttr "updateScript" pkg)
  +        packagesWithPath prefix (path: pkg: builtins.hasAttr "updateScript" pkg)
                          pathContent;
   
  -  packageByName = name:
  -    let
  -        package = lib.attrByPath (lib.splitString "." name) null pkgs;
  +  /* Find a package under `path` in `pkgs` and require that it has an updateScript.
  +   */
  +  packageByName = path: pkgs:
  +    let
  +        package = lib.attrByPath (lib.splitString "." path) null pkgs;
       in
         if package == null then
  -        builtins.throw "Package with an attribute name `${name}` does not exists."
  +        builtins.throw "Package with an attribute name `${path}` does not exists."
         else if ! builtins.hasAttr "updateScript" package then
  -        builtins.throw "Package with an attribute name `${name}` does not have a `passthru.updateScript` attribute defined."
  +        builtins.throw "Package with an attribute name `${path}` does not have a `passthru.updateScript` attribute defined."
         else
  -        { attrPath = name; inherit package; };
  -
  +        { attrPath = path; inherit package; };
  +
  +  /* List of packages matched based on the CLI arguments.
  +   */
     packages =
       if package != null then
  -      [ (packageByName package) ]
  +      [ (packageByName package pkgs) ]
       else if maintainer != null then
  -      packagesWithUpdateScriptAndMaintainer maintainer
  +      packagesWithUpdateScriptAndMaintainer maintainer pkgs
       else if path != null then
  -      packagesWithUpdateScript path
  +      packagesWithUpdateScript path pkgs
       else
         builtins.throw "No arguments provided.\n\n${helpText}";
   
  
positive.code:         in
            if result.success then
              let
                pathContent = result.value;
              in
                if lib.isDerivation pathContent then
                  lib.optional (cond relativePath pathContent) { attrPath = lib.concatStringsSep "." relativePath; package = pathContent; }
                else if lib.isAttrs pathContent then
                  # If user explicitly points to an attrSet or it is marked for recursion, we recur.
                  if relativePath == rootPath || pathContent.recurseForDerivations or false || pathContent.recurseForRelease or false then
                    dedupResults (lib.mapAttrsToList (name: elem: packagesWithPathInner (relativePath ++ [name]) elem) pathContent)
                  else []
                else if lib.isList pathContent then
                  dedupResults (lib.imap0 (i: elem: packagesWithPathInner (relativePath ++ [i]) elem) pathContent)
                else []
            else [];
      in
        packagesWithPathInner rootPath pkgs;
  
    packagesWith = packagesWithPath [];
  
    packagesWithUpdateScriptAndMaintainer = maintainer':
      let
        maintainer =
  
negative.code:         else
            builtins.getAttr maintainer' lib.maintainers;
      in
        packagesWith (path: pkg: builtins.hasAttr "updateScript" pkg &&
                           (if builtins.hasAttr "maintainers" pkg.meta
                             then (if builtins.isList pkg.meta.maintainers
                                     then builtins.elem maintainer pkg.meta.maintainers
                                     else maintainer == pkg.meta.maintainers
                                  )
                             else false
                           )
                     );
  
    /* Recursively find all packages under `path` in `pkgs` with updateScript.
     */
    packagesWithUpdateScript = path: pkgs:
      let
        prefix = lib.splitString "." path;
        pathContent = lib.attrByPath prefix null pkgs;
  