What's the thought behind this code?
Surely we want to build dynamic derivations too?
If this code has a reasonable intent, I would expect it to be usable in more places, if not already used in more places, so why isn't this a helper function?

If this code has a reasonable intent, I would expect it to be usable in more places, if not already used in more places, so why isn't this a helper function?

Where else would this be used? nix flake check seems to be the main use case I can think of.
In theory nix build could have a flag, but it doesn't seem to be a good default.

I don't understand the comment about dynamic derivations. Would dynamic derivations not also be included in the missing set?

I meant specifically the case matching on Built vs Opaque. An opaque drvPath is a normal one, whereas a Built drvPath is dynamic. In the case of dynamic we should not just realise the inner drvPath (the one that generates the derivation), but also the result. That seems to be missing.

reasonable intent

(my words)
That sounds rough? Of course your intent is good, and so is the general idea of this solution. I meant to refer to the highlighted lines, the handler for Built.
I apologize if that came across wrong.

While porting this over to Lix in https://gerrit.lix.systems/c/lix/+/3841, I did a bit of digging and it seems to me that this snippet actually hits a lot of the same beats as queryMissing() itself. Based on this, I tried just using the willBuild member of the MissingPaths struct directly, and it seems to work just as fine?

I know next to nothing about libstore though, so sorry in advance 😆

Regarding dynamic derivations: running nix --extra-experimental-features 'ca-derivations dynamic-derivations recursive-nix' --store /tmp/dyn-drvs flake check -v with the following flake.nix

{
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";

  outputs =
    { nixpkgs, ... }:

    let
      system = "x86_64-linux";
      pkgs = nixpkgs.legacyPackages.${system};
    in

    {
      checks.${system}.dyn-drv =
        pkgs.runCommand "inner.drv"
          {
            outputHashMode = "text";
            requiredSystemFeatures = [ "recursive-nix" ];
          }
          ''
            echo "let pkgs = import \"${pkgs.path}\" {};
                  in
                  pkgs.runCommand \"inner\" {} '''
                    sleep 10;
                    echo \"Hello from inner!\" > \$out
                  '''
                  " > inner.nix
            cp $(${pkgs.nix}/bin/nix-instantiate inner.nix) $out
          '';
    };
}

does seem to only build the inner drv. However, running this with Nix 2.30.2 results in the same behavior, so...I think this might be an existing bug?

This is another difference from the Determinate Nix implementation that I thought would be nice

It felt a bit confusing for Nix to report all checks were running when only a subset were actually being built. I think this makes the fact that this feature is even working much clearer, while also being more representative of what Nix is really doing

Alternatively, we could keep the total number of checks with a message like fmt("running %d/%d flake checks", toBuild.size(), drvPaths.size())