fix(nix): build kdist K semantics so komet-node runs

The flake built only the Python virtual environment, so running the
installed `komet-node` crashed at import time with:

    ValueError: Target undefined or not built: soroban-semantics.llvm

`komet_node` imports `komet`, whose `komet/utils.py` resolves several
kdist targets (`soroban-semantics.{llvm,llvm-tracing,llvm-library,
haskell}`) at module load. Those are compiled K semantics that must be
produced by `kompile` ahead of time; nothing in the flake built them.

Mirror upstream komet's two-derivation layout:

- nix/komet-node-pyk: the Python venv (full virtualenv, so it carries
  both the `komet-node` entrypoint and the `kdist` build tool).
- nix/komet-node: a wrapper derivation that runs
  `kdist build 'soroban-semantics.*' 'komet-node.*'` (the same targets
  as the Makefile's `kdist-build`), collects the compiled semantics into
  a `kdist` output, and wraps the binary with `--set KDIST_DIR` plus
  `k`/`which` on PATH.

The venv keeps building against nixpkgs-unstable (modern stdenv), while
the kompile wrapper builds against the RV-pinned nixpkgs (new kOverlay)
so the C/C++ toolchain matches the `k` binary. This cross-nixpkgs split
is safe because the LLVM semantics run as a subprocess (KRun), not
loaded in-process.

Cap kdist concurrency at -j2 (matching the Makefile): each LLVM/Haskell
kompile job peaks at several GB, so an unbounded -j$NIX_BUILD_CORES can
OOM the builder on high-core, limited-memory machines.

Verified: `nix build .#komet-node` succeeds and `komet-node --help`
runs cleanly.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: RaoulSchaffranek

flake.nix

@@ -33,18 +33,45 @@
       uvOverlay = final: prev: {
         uv = uv2nix.packages.${final.system}.uv-bin;
       };
-      komet-nodeOverlay = final: prev: {
-        komet-node = final.callPackage ./nix/komet-node {
+      # The k-framework overlay also pulls in a lot of unrelated packages, so we
+      # only expose the `k` binary that we actually consume.
+      kOverlay = final: prev: {
+        k = k-framework.packages.${final.system}.k;
+      };
+      komet-nodeOverlay = final: prev:
+      let
+        # The Python virtual environment, built against a modern stdenv from
+        # nixpkgs-unstable (see below). It carries the `komet-node` entrypoint
+        # together with the `kdist` tool and the K sources for every kdist target.
+        komet-node-pyk = pkgs.callPackage ./nix/komet-node-pyk {
           inherit pyproject-nix pyproject-build-systems uv2nix;
-          python = final."python${pythonVer}";
+          python = pkgs."python${pythonVer}";
+        };
+      in {
+        # Build the wrapper against `nixpkgs` (the RV-pinned package set that the K
+        # toolchain is built and tested against) rather than nixpkgs-unstable, so
+        # the C/C++ toolchain that kompiles the LLVM semantics matches `k`. The
+        # compiled semantics run as a subprocess (krun), so there is no ABI
+        # coupling with the nixpkgs-unstable Python environment.
+        komet-node = final.callPackage ./nix/komet-node {
+          inherit komet-node-pyk;
+          rev = self.rev or null;
         };
       };
-      # Use nixpkgs-unstable for the package set so the Python environment is
-      # built against a modern stdenv on all platforms.
+      # Use nixpkgs-unstable for the Python package set so the Python environment
+      # is built against a modern stdenv on all platforms.
       pkgs = import nixpkgs-unstable {
         inherit system;
         overlays = [
           uvOverlay
+        ];
+      };
+      # The native toolchain for kompiling the K semantics comes from the RV-pinned
+      # nixpkgs so it matches the `k` binary.
+      pkgsK = import nixpkgs {
+        inherit system;
+        overlays = [
+          kOverlay
           komet-nodeOverlay
         ];
       };
@@ -70,7 +97,7 @@
         '';
       };
       packages = rec {
-        inherit (pkgs) komet-node;
+        inherit (pkgsK) komet-node;
         default = komet-node;
       };
     }) // {

nix/komet-node-pyk/default.nix

@@ -0,0 +1,55 @@
+{
+  lib,
+  callPackage,
+  nix-gitignore,
+
+  pyproject-nix,
+  pyproject-build-systems,
+  uv2nix,
+
+  python
+}:
+let
+  pyproject-packages = callPackage pyproject-nix.build.packages {
+    inherit python;
+  };
+
+  # load a uv workspace from a workspace root
+  workspace = uv2nix.lib.workspace.loadWorkspace {
+    workspaceRoot = lib.cleanSource (nix-gitignore.gitignoreSourcePure [
+        ../../.gitignore
+        ".github/"
+        "result*"
+        # do not include submodule directories that might be initilized empty or non-existent due to nix/git
+        # otherwise cachix build might not match the version that is requested by `kup`
+        # TODO: for new projects, add your submodule directories that are not required for nix builds here!
+        # e.g., `"/docs/external-computation"` with `external-computation` being a git submodule directory
+        # "/docs/external-computation"
+      ] ../..
+    );
+  };
+
+  # create overlay
+  lockFileOverlay = workspace.mkPyprojectOverlay {
+    # prefer "wheel" over "sdist" due to maintance overhead
+    # there is no bundled set of overlays for "sdist" in uv2nix, in contrast to poetry2nix
+    sourcePreference = "wheel";
+  };
+
+  buildSystemsOverlay = import ../komet-node/build-systems-overlay.nix;
+
+  # construct package set
+  pythonSet = pyproject-packages.overrideScope (lib.composeManyExtensions [
+    # make build tools available by default as these are not necessarily specified in python lock files
+    pyproject-build-systems.overlays.default
+    # include all packages from the python lock file
+    lockFileOverlay
+    # add build system overrides to certain python packages
+    buildSystemsOverlay
+  ]);
+in
+  # Expose the full virtual environment (not `mkApplication`): the `komet-node`
+  # wrapper needs both the `komet-node` entrypoint AND the `kdist` tool (provided
+  # by the kframework dependency) to build the K semantics. `workspace.deps.default`
+  # excludes the dev dependency groups, so this is only the runtime closure.
+  pythonSet.mkVirtualEnv "komet-node-env" workspace.deps.default

nix/komet-node/default.nix

@@ -1,55 +1,95 @@
 {
   lib,
-  callPackage,
-  nix-gitignore,
+  stdenv,
+  makeWrapper,
 
-  pyproject-nix,
-  pyproject-build-systems,
-  uv2nix,
+  clang,
+  cmake,
+  git,
+  k,
+  boost,
+  mpfr,
+  openssl,
+  gmp,
+  secp256k1,
+  which,
 
-  python
+  komet-node-pyk,
+  rev ? null
 }:
-let
-  pyproject-util = callPackage pyproject-nix.build.util {};
-  pyproject-packages = callPackage pyproject-nix.build.packages {
-    inherit python;
-  };
+stdenv.mkDerivation {
+  pname = "komet-node";
+  version = if (rev != null) then rev else "dirty";
 
-  # load a uv workspace from a workspace root
-  workspace = uv2nix.lib.workspace.loadWorkspace {
-    workspaceRoot = lib.cleanSource (nix-gitignore.gitignoreSourcePure [
-        ../../.gitignore
-        ".github/"
-        "result*"
-        # do not include submodule directories that might be initilized empty or non-existent due to nix/git
-        # otherwise cachix build might not match the version that is requested by `kup`
-        # TODO: for new projects, add your submodule directories that are not required for nix builds here!
-        # e.g., `"/docs/external-computation"` with `external-computation` being a git submodule directory
-        # "/docs/external-computation"
-      ] ../..
-    );
-  };
+  outputs = [
+    "bin"
+    # contains kdist artifacts (the compiled K semantics)
+    "out"
+    # this empty `dev` output is required as we otherwise get cyclic dependencies between `bin` and `out`
+    # this is due to a setup-hook creating references in a new directory `nix-support` in either `out` or `dev`
+    "dev"
+  ];
 
-  # create overlay
-  lockFileOverlay = workspace.mkPyprojectOverlay {
-    # prefer "wheel" over "sdist" due to maintance overhead
-    # there is no bundled set of overlays for "sdist" in uv2nix, in contrast to poetry2nix
-    sourcePreference = "wheel";
-  };
+  # The K sources for every kdist target (`soroban-semantics.*` from the `komet`
+  # dependency and `komet-node.*` from this project) ship inside `komet-node-pyk`,
+  # so there are no sources to unpack here; the build only needs a working
+  # directory to place the kdist output into.
+  dontUnpack = true;
+
+  buildInputs = [
+    clang
+    cmake
+    git
+    boost
+    mpfr
+    openssl
+    gmp
+    secp256k1
+    komet-node-pyk
+    k
+  ];
+
+  nativeBuildInputs = [ makeWrapper ];
+
+  dontUseCmakeConfigure = true;
 
-  buildSystemsOverlay = import ./build-systems-overlay.nix;
-
-  # construct package set
-  pythonSet = pyproject-packages.overrideScope (lib.composeManyExtensions [
-    # make build tools available by default as these are not necessarily specified in python lock files
-    pyproject-build-systems.overlays.default
-    # include all packages from the python lock file
-    lockFileOverlay
-    # add build system overrides to certain python packages
-    buildSystemsOverlay
-  ]);
-in pyproject-util.mkApplication {
-  # default dependancy group enables no optional dependencies and no dependency-groups
-  venv = pythonSet.mkVirtualEnv "komet-node-env" workspace.deps.default;
-  package = pythonSet.komet-node;
+  enableParallelBuilding = true;
+
+  # `kdist` writes the compiled semantics under `$XDG_CACHE_HOME/kdist-<hash>/`.
+  # Build the same targets the Makefile's `kdist-build` does. The `komet-node.*`
+  # targets pull in `soroban-semantics.source` as a dependency automatically.
+  #
+  # Cap concurrency at 2 (matching the Makefile's `kdist-build`): each LLVM/Haskell
+  # `kompile` job links a large generated interpreter and peaks at several GB of
+  # RAM, so an unbounded `-j$NIX_BUILD_CORES` can OOM the builder on machines with
+  # many cores but limited memory.
+  buildPhase = ''
+    runHook preBuild
+    XDG_CACHE_HOME=$(pwd) ${
+      lib.optionalString
+      (stdenv.isAarch64 && stdenv.isDarwin)
+      "APPLE_SILICON=true"
+    } kdist -v build -j2 'soroban-semantics.*' 'komet-node.*'
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+    mkdir -p $bin/bin
+    mkdir -p $out/kdist
+
+    cp -r ./kdist-*/* $out/kdist/
+
+    # Wrap the `komet-node` entrypoint so that, at runtime, it finds the compiled
+    # semantics via `KDIST_DIR` and the K tools (krun/kore) via `PATH`.
+    makeWrapper ${komet-node-pyk}/bin/komet-node $bin/bin/komet-node \
+      --prefix PATH : ${lib.makeBinPath [ which k ]} \
+      --set KDIST_DIR $out/kdist
+    runHook postInstall
+  '';
+
+  meta = {
+    description = "Local development testnet for Stellar based on K semantics";
+    mainProgram = "komet-node";
+  };
 }