monarchic-agent-protocol 0.1.14

{
  description = "Monarchic AI protocol types and schemas";

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

  outputs = { self, nixpkgs }:
    let
      systems = [ "x86_64-linux" "aarch64-linux" "x86_64-darwin" "aarch64-darwin" ];
      forAllSystems = f: nixpkgs.lib.genAttrs systems (system: f system);
    in
    {
      packages = forAllSystems (system:
        let
          pkgs = nixpkgs.legacyPackages.${system};
        in
        {
          default = self.packages.${system}.rs-lib;
          rs-lib = pkgs.rustPlatform.buildRustPackage {
            pname = "monarchic-agent-protocol";
            version = "0.1.14";
            src = ./.;
            nativeBuildInputs = [ pkgs.protobuf ];
            cargoLock = {
              lockFile = ./Cargo.lock;
            };
            installPhase = ''
              runHook preInstall
              mkdir -p $out/lib
              cp target/*/release/deps/*.rlib $out/lib/
              cp target/*/release/deps/*.rmeta $out/lib/ || true
              runHook postInstall
            '';
          };

          rs-registry-lib = pkgs.rustPlatform.buildRustPackage {
            pname = "monarchic-agent-protocol";
            version = "0.1.14";
            src = pkgs.fetchCrate {
              pname = "monarchic-agent-protocol";
              version = "0.1.14";
              sha256 = "sha256-QKb9SOEzrBBdErov4Rm3pmm8Nlsr8pfNYw4dhHVqBv8=";
            };
            nativeBuildInputs = [ pkgs.protobuf ];
            cargoLock = {
              lockFile = ./Cargo.lock;
            };
            installPhase = ''
              runHook preInstall
              mkdir -p $out/lib
              cp target/*/release/deps/*.rlib $out/lib/
              cp target/*/release/deps/*.rmeta $out/lib/ || true
              runHook postInstall
            '';
          };

          py-lib = pkgs.python3Packages.buildPythonPackage {
            pname = "monarchic-agent-protocol";
            version = "0.1.14";
            format = "pyproject";
            src = ./.;
            nativeBuildInputs = [
              pkgs.protobuf
              pkgs.python3Packages.setuptools
              pkgs.python3Packages.wheel
            ];
            propagatedBuildInputs = [ pkgs.python3Packages.protobuf ];
            preUnpack = ''
              export PROTO_DIR="${./schemas/v1}"
            '';
            preBuild = ''
              protoc -I "$PROTO_DIR" \
                --python_out=src/python/monarchic_agent_protocol \
                "$PROTO_DIR/monarchic_agent_protocol.proto"
            '';
          };

          py-registry-lib = pkgs.python3Packages.buildPythonPackage {
            pname = "monarchic-agent-protocol";
            version = "0.1.14";
            format = "pyproject";
            src = pkgs.fetchPypi {
              pname = "monarchic_agent_protocol";
              version = "0.1.14";
              sha256 = "1h9aiybm2873fqwyh13i5bvq012mvgigpilmvc5rk3djzh9jpvba";
            };
            nativeBuildInputs = [
              pkgs.python3Packages.setuptools
              pkgs.python3Packages.wheel
            ];
            propagatedBuildInputs = [ pkgs.python3Packages.protobuf ];
            doCheck = false;
          };

          ts-lib = pkgs.buildNpmPackage {
            pname = "monarchic-agent-protocol-ts";
            version = "0.1.14";
            src = ./.;
            npmDepsHash = "sha256-kwhHd9Ad3IzuC7c1urQ01Gupayj39c+xACgAP0Oc73w=";
            npmPackFlags = [ "--ignore-scripts" ];
            forceEmptyCache = true;
            dontNpmBuild = true;
            dontNpmInstall = true;
            installPhase = ''
              runHook preInstall
              mkdir -p $out/lib/node_modules/@monarchic-ai/monarchic-agent-protocol
              cp package.json $out/lib/node_modules/@monarchic-ai/monarchic-agent-protocol/package.json
              cp -r src/ts $out/lib/node_modules/@monarchic-ai/monarchic-agent-protocol/src
              runHook postInstall
            '';
          };

          ts-registry-lib = pkgs.buildNpmPackage {
            pname = "monarchic-agent-protocol-npm";
            version = "0.1.14";
            src = pkgs.fetchurl {
              url = "https://registry.npmjs.org/@monarchic-ai/monarchic-agent-protocol/-/monarchic-agent-protocol-0.1.14.tgz";
              sha256 = "1m9najm3i0yqxs0rkanfknshlw6jvma6lizs0hpbrsmv6fprgylm";
            };
            npmDepsHash = "sha256-kwhHd9Ad3IzuC7c1urQ01Gupayj39c+xACgAP0Oc73w=";
            npmPackFlags = [ "--ignore-scripts" ];
            forceEmptyCache = true;
            dontNpmBuild = true;
            dontNpmInstall = true;
            postPatch =
              let
                npmPackageLock = pkgs.writeText "npm-package-lock.json" ''
{
  "name": "@monarchic-ai/monarchic-agent-protocol",
  "version": "0.1.14",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@monarchic-ai/monarchic-agent-protocol",
      "version": "0.1.14"
    }
  }
}
                '';
              in ''
                if [ ! -f package-lock.json ]; then
                  cp ${npmPackageLock} package-lock.json
                fi
              '';
            installPhase = ''
              runHook preInstall
              mkdir -p $out/lib/node_modules/@monarchic-ai/monarchic-agent-protocol
              tar -xzf $src -C $out/lib/node_modules/@monarchic-ai/monarchic-agent-protocol --strip-components=1
              runHook postInstall
            '';
          };

          go-lib = pkgs.buildGoModule {
            pname = "monarchic-agent-protocol-go";
            version = "0.1.14";
            src = ./.;
            modRoot = "src/go";
            vendorHash = "sha256-xj9DXJyfqpCcYXRc6Yr6X4s0F2o3mUQ3HWSNLjlKxWc=";
          };

          go-registry-lib = pkgs.buildGoModule {
            pname = "monarchic-agent-protocol-go-mod";
            version = "0.1.14";
            src = pkgs.fetchFromGitHub {
              owner = "monarchic-ai";
              repo = "monarchic-agent-protocol";
              rev = "v0.1.14";
              sha256 = "1sc6fsf2j2rmlf4aw1glbl7vlw0w4y7vi938ykpsixijqbqzcxfy";
            };
            modRoot = "src/go";
            vendorHash = "sha256-xj9DXJyfqpCcYXRc6Yr6X4s0F2o3mUQ3HWSNLjlKxWc=";
          };

          rb-lib = pkgs.buildRubyGem {
            gemName = "monarchic-agent-protocol";
            version = "0.1.14";
            src = ./.;
          };

          rb-registry-lib = pkgs.buildRubyGem {
            gemName = "monarchic-agent-protocol";
            version = "0.1.14";
            src = pkgs.fetchurl {
              url = "https://rubygems.org/downloads/monarchic-agent-protocol-0.1.14.gem";
              sha256 = "1r35nx1y2gy0z2zz8kdfckh3m3jigrk8pkmgryp31smi1yp4lzz5";
            };
          };

          rb-protobuf = pkgs.buildRubyGem {
            gemName = "google-protobuf";
            version = "3.25.3";
            hardeningDisable = [ "format" ];
            src = pkgs.fetchurl {
              url = "https://rubygems.org/downloads/google-protobuf-3.25.3.gem";
              sha256 = "sha256-Ob2Xy8djGQXnbN+PG/PdocPQUgDX4j9XWs7XiTD73dY=";
            };
          };

          java-lib =
            let
              protobufJava = pkgs.fetchurl {
                url = "https://repo1.maven.org/maven2/com/google/protobuf/protobuf-java/4.32.1/protobuf-java-4.32.1.jar";
                sha256 = "1jrjm2y2fz2ckq82b77b62bdrcxvn6lwxldin2qaz2rkf7cy96cc";
              };
            in
            pkgs.stdenv.mkDerivation {
            pname = "monarchic-agent-protocol-java";
            version = "0.1.14";
            src = ./.;
            nativeBuildInputs = [
              pkgs.jdk
            ];
            buildPhase = ''
              runHook preBuild
              mkdir -p build/classes
              ${pkgs.jdk}/bin/javac -classpath "${protobufJava}" -d build/classes $(find src/java -name '*.java')
              ${pkgs.jdk}/bin/jar cf build/monarchic-agent-protocol.jar -C build/classes .
              runHook postBuild
            '';
            installPhase = ''
              runHook preInstall
              mkdir -p $out/share/java
              cp build/monarchic-agent-protocol.jar $out/share/java/
              runHook postInstall
            '';
          };

          java-registry-lib = pkgs.fetchurl {
            url = "https://jitpack.io/com/github/monarchic-ai/monarchic-agent-protocol/v0.1.14/monarchic-agent-protocol-v0.1.14.jar";
            sha256 = "1bzb4xx1c800g06n1869mpajlszld55i4g7f1jkfkfymck8jqprz";
          };

          dart-lib = pkgs.stdenv.mkDerivation {
            pname = "monarchic-agent-protocol-dart";
            version = "0.1.14";
            src = ./.;
            installPhase = ''
              runHook preInstall
              mkdir -p $out/lib/dart
              cp -r $src/src/dart/lib $out/lib/dart/
              cp $src/pubspec.yaml $out/lib/dart/
              runHook postInstall
            '';
          };

          # TODO: pub.dev requires "domain"-based verification through the google console
          # dart-registry-lib = pkgs.fetchurl {
          #   url = "https://pub.dev/packages/monarchic_agent_protocol/versions/0.1.14.tar.gz";
          #   sha256 = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
          # };

          csharp-lib = pkgs.stdenv.mkDerivation {
            pname = "monarchic-agent-protocol-csharp";
            version = "0.1.14";
            src = builtins.path {
              path = ./.;
              name = "monarchic-agent-protocol-csharp-src";
            };
            installPhase = ''
              runHook preInstall
              mkdir -p $out/lib/csharp
              cp -r $src/src/csharp $out/lib/csharp/
              cp $src/Monarchic.AgentProtocol.csproj $out/lib/csharp/
              runHook postInstall
            '';
          };

          csharp-registry-lib = pkgs.fetchurl {
            url = "https://api.nuget.org/v3-flatcontainer/monarchic.agentprotocol/0.1.14/monarchic.agentprotocol.0.1.14.nupkg";
            sha256 = "1ij5w24pphnbpkz6i8jkgczqr7va7jyyw84rgkrz8d6019xcam10";
          };

          php-lib = pkgs.stdenv.mkDerivation {
            pname = "monarchic-agent-protocol-php";
            version = "0.1.14";
            src = builtins.path {
              path = ./.;
              name = "monarchic-agent-protocol-php-src";
            };
            installPhase = ''
              runHook preInstall
              mkdir -p $out/lib/php
              cp -r $src/src/php $out/lib/php/
              cp $src/composer.json $out/lib/php/
              runHook postInstall
            '';
          };

          php-registry-lib = pkgs.fetchFromGitHub {
            owner = "monarchic-ai";
            repo = "monarchic-agent-protocol";
            rev = "v0.1.14";
            sha256 = "1sc6fsf2j2rmlf4aw1glbl7vlw0w4y7vi938ykpsixijqbqzcxfy";
          };

          example-rust = pkgs.rustPlatform.buildRustPackage {
            pname = "example-rust";
            version = "0.1.14";
            src = pkgs.runCommand "example-rust-src" {} ''
              set -euo pipefail
              mkdir -p $out/src
              cp ${./examples/rust/task.rs} $out/src/main.rs
              cat > $out/Cargo.toml <<'EOF'
[package]
name = "example-rust"
version = "0.1.14"
edition = "2021"

[dependencies]
monarchic-agent-protocol = { path = "${self}" }
EOF
              cp ${./Cargo.lock} $out/Cargo.lock
            '';
            nativeBuildInputs = [ pkgs.protobuf ];
            cargoLock = {
              lockFile = "${self}/Cargo.lock";
            };
            doCheck = true;
            checkPhase = ''
              runHook preCheck
              ./target/*/release/example-rust >/dev/null
              runHook postCheck
            '';
          };

          example-ts = pkgs.stdenv.mkDerivation {
            pname = "example-ts";
            version = "0.1.14";
            nativeBuildInputs = [
              pkgs.nodejs
              pkgs.nodePackages.typescript
              pkgs.gnused
            ];
            dontUnpack = true;
            buildPhase = ''
              runHook preBuild
            tmp_dir="$(mktemp -d)"
            trap 'rm -rf "$tmp_dir"' EXIT
            mkdir -p "$tmp_dir/src/ts"
            cp ${./src/ts/index.ts} "$tmp_dir/src/ts/index.ts"
            cp ${./examples/ts/task.ts} "$tmp_dir/task.ts"
            ${pkgs.gnused}/bin/sed -i 's@../../src/ts/index@./src/ts/index@' "$tmp_dir/task.ts"
            ${pkgs.nodePackages.typescript}/bin/tsc --noEmit --moduleResolution node --module commonjs --target es2020 "$tmp_dir/task.ts"
              runHook postBuild
            '';
            installPhase = ''
              runHook preInstall
              mkdir -p $out
              runHook postInstall
            '';
          };

          example-python =
            let
              pythonWithProtobuf = pkgs.python3.withPackages (ps: [ ps.protobuf ]);
            in
            pkgs.python3Packages.buildPythonPackage {
              pname = "example-python";
              version = "0.1.14";
              format = "other";
              dontWrapPythonPrograms = true;
              nativeBuildInputs = [
                pkgs.protobuf
                pythonWithProtobuf
              ];
              dontUnpack = true;
              buildPhase = ''
                runHook preBuild
                set -euo pipefail
                set -x
                tmp_dir="$(mktemp -d)"
                trap 'rm -rf "$tmp_dir"' EXIT
                ${pkgs.protobuf}/bin/protoc -I ${./schemas/v1} \
                  --python_out="$tmp_dir" \
                  monarchic_agent_protocol.proto
                PYTHONPATH="$tmp_dir" ${pythonWithProtobuf}/bin/python ${./examples/proto/python/task.py}
                runHook postBuild
              '';
              installPhase = ''
                runHook preInstall
                mkdir -p $out
                runHook postInstall
              '';
            };

          example-java =
            let
              protobufJava = pkgs.fetchurl {
                url = "https://repo1.maven.org/maven2/com/google/protobuf/protobuf-java/4.32.1/protobuf-java-4.32.1.jar";
                sha256 = "1jrjm2y2fz2ckq82b77b62bdrcxvn6lwxldin2qaz2rkf7cy96cc";
              };
            in
            pkgs.stdenv.mkDerivation {
              pname = "example-java";
              version = "0.1.14";
              nativeBuildInputs = [
                pkgs.protobuf
                pkgs.jdk
              ];
              dontUnpack = true;
              buildPhase = ''
                runHook preBuild
                tmp_dir="$(mktemp -d)"
                trap 'rm -rf "$tmp_dir"' EXIT
                mkdir -p "$tmp_dir/java"
                ${pkgs.protobuf}/bin/protoc -I ${./schemas/v1} \
                  --java_out="$tmp_dir/java" \
                  monarchic_agent_protocol.proto
                cp ${./examples/proto/java/TaskExample.java} "$tmp_dir/TaskExample.java"
                mkdir -p build/classes
                ${pkgs.jdk}/bin/javac -classpath "${protobufJava}" \
                  -d build/classes \
                  $(find "$tmp_dir/java" -name '*.java') \
                  "$tmp_dir/TaskExample.java"
                ${pkgs.jdk}/bin/java -classpath "build/classes:${protobufJava}" TaskExample >/dev/null
                runHook postBuild
              '';
              installPhase = ''
                runHook preInstall
                mkdir -p $out
                runHook postInstall
              '';
            };

          example-kotlin =
            let
              protobufJava = pkgs.fetchurl {
                url = "https://repo1.maven.org/maven2/com/google/protobuf/protobuf-java/4.32.1/protobuf-java-4.32.1.jar";
                sha256 = "1jrjm2y2fz2ckq82b77b62bdrcxvn6lwxldin2qaz2rkf7cy96cc";
              };
              protobufKotlin = pkgs.fetchurl {
                url = "https://repo1.maven.org/maven2/com/google/protobuf/protobuf-kotlin/4.32.1/protobuf-kotlin-4.32.1.jar";
                sha256 = "1lafaxgnkppqxrzdzdfc3863bagmh4v15f5p70i8kfsl9lrf59sr";
              };
            in
            pkgs.stdenv.mkDerivation {
              pname = "example-kotlin";
              version = "0.1.14";
              nativeBuildInputs = [
                pkgs.protobuf
                pkgs.jdk
                pkgs.kotlin
              ];
              dontUnpack = true;
              buildPhase = ''
                runHook preBuild
                tmp_dir="$(mktemp -d)"
                trap 'rm -rf "$tmp_dir"' EXIT
                mkdir -p "$tmp_dir/kotlin" "$tmp_dir/java"
                ${pkgs.protobuf}/bin/protoc -I ${./schemas/v1} \
                  --java_out="$tmp_dir/java" \
                  --kotlin_out="$tmp_dir/kotlin" \
                  monarchic_agent_protocol.proto
                mkdir -p build/java-classes build/classes
                ${pkgs.jdk}/bin/javac -classpath "${protobufJava}" \
                  -d build/java-classes \
                  $(find "$tmp_dir/java" -name '*.java')
                gen_sources="$(find "$tmp_dir/kotlin" -name '*.kt' | tr '\n' ' ')"
                ${pkgs.kotlin}/bin/kotlinc ${./examples/proto/kotlin/TaskExample.kt} $gen_sources \
                  -classpath "${protobufJava}:${protobufKotlin}:build/java-classes" \
                  -d build/classes
                runHook postBuild
              '';
              installPhase = ''
                runHook preInstall
                mkdir -p $out
                runHook postInstall
              '';
            };

          example-cpp = pkgs.stdenv.mkDerivation {
            pname = "example-cpp";
            version = "0.1.14";
            nativeBuildInputs = [
              pkgs.protobuf
              pkgs.pkg-config
            ];
            dontUnpack = true;
            buildPhase = ''
              runHook preBuild
              tmp_dir="$(mktemp -d)"
              trap 'rm -rf "$tmp_dir"' EXIT
              mkdir -p "$tmp_dir/cpp"
              ${pkgs.protobuf}/bin/protoc -I ${./schemas/v1} \
                --cpp_out="$tmp_dir/cpp" \
                monarchic_agent_protocol.proto
              cflags="$(pkg-config --cflags protobuf)"
              libs="$(pkg-config --libs protobuf)"
              ${pkgs.stdenv.cc}/bin/g++ -std=c++17 $cflags \
                -I "$tmp_dir/cpp" \
                ${./examples/proto/cpp/task.cpp} \
                "$tmp_dir/cpp/monarchic_agent_protocol.pb.cc" \
                $libs -pthread -o example-cpp
              ./example-cpp >/dev/null
              runHook postBuild
            '';
            installPhase = ''
              runHook preInstall
              mkdir -p $out
              runHook postInstall
            '';
          };

          example-dart =
            let
              dartProtobuf = pkgs.fetchurl {
                url = "https://pub.dev/api/archives/protobuf-6.0.0.tar.gz";
                sha256 = "01mz496n153nli7drynpj720pvp41i9dsf7fg76bsl7948nj9v3m";
              };
              dartCollection = pkgs.fetchurl {
                url = "https://pub.dev/api/archives/collection-1.19.1.tar.gz";
                sha256 = "0xjf11l5h3ibbmw308f8lvc5fsq44ghb82fkgj7xsn9x9np0jmrg";
              };
              dartFixnum = pkgs.fetchurl {
                url = "https://pub.dev/api/archives/fixnum-1.1.1.tar.gz";
                sha256 = "1gjkvsbbwdywxkn8a4nswr5pmv34cw50hhziqp3lp5vcwijp1p5n";
              };
              dartMeta = pkgs.fetchurl {
                url = "https://pub.dev/api/archives/meta-1.18.1.tar.gz";
                sha256 = "0vr9kyb2mn7knc2czbpxpw6r76p9xbh1pl7064d7na7fr2ybjacz";
              };
            in
            pkgs.stdenv.mkDerivation {
              pname = "example-dart";
              version = "0.1.14";
              nativeBuildInputs = [
                pkgs.protobuf
                pkgs.protoc-gen-dart
                pkgs.dart
              ];
              dontUnpack = true;
              buildPhase = ''
                runHook preBuild
                tmp_dir="$(mktemp -d)"
                trap 'rm -rf "$tmp_dir"' EXIT
                mkdir -p "$tmp_dir/packages/protobuf"
                mkdir -p "$tmp_dir/packages/collection"
                mkdir -p "$tmp_dir/packages/fixnum"
                mkdir -p "$tmp_dir/packages/meta"
                tar -xzf "${dartProtobuf}" -C "$tmp_dir/packages/protobuf"
                tar -xzf "${dartCollection}" -C "$tmp_dir/packages/collection"
                tar -xzf "${dartFixnum}" -C "$tmp_dir/packages/fixnum"
                tar -xzf "${dartMeta}" -C "$tmp_dir/packages/meta"
                cat > "$tmp_dir/pubspec.yaml" <<'EOF'
name: monarchic_agent_protocol_example
environment:
  sdk: ">=2.17.0 <4.0.0"
dependencies:
  protobuf:
    path: packages/protobuf
dependency_overrides:
  fixnum:
    path: packages/fixnum
  collection:
    path: packages/collection
  meta:
    path: packages/meta
EOF
                (cd "$tmp_dir" && ${pkgs.dart}/bin/dart pub get --offline >/dev/null)
                ${pkgs.protobuf}/bin/protoc -I ${./schemas/v1} \
                  --plugin=protoc-gen-dart=${pkgs.protoc-gen-dart}/bin/protoc-gen-dart \
                  --dart_out="$tmp_dir" \
                  monarchic_agent_protocol.proto
                cp ${./examples/proto/dart/task.dart} "$tmp_dir/task.dart"
                (cd "$tmp_dir" && ${pkgs.dart}/bin/dart run task.dart >/dev/null)
                runHook postBuild
              '';
              installPhase = ''
                runHook preInstall
                mkdir -p $out
                runHook postInstall
              '';
            };

          example-ruby =
            let
              rubyWithProtobuf = pkgs.ruby.withPackages (_: [ self.packages.${system}.rb-protobuf ]);
            in
            pkgs.stdenv.mkDerivation {
              pname = "example-ruby";
              version = "0.1.14";
              nativeBuildInputs = [
                pkgs.protobuf
                rubyWithProtobuf
              ];
              dontUnpack = true;
              buildPhase = ''
                runHook preBuild
                tmp_dir="$(mktemp -d)"
                trap 'rm -rf "$tmp_dir"' EXIT
                mkdir -p "$tmp_dir/ruby"
                ${pkgs.protobuf}/bin/protoc -I ${./schemas/v1} \
                  --ruby_out="$tmp_dir/ruby" \
                  monarchic_agent_protocol.proto
                expected="$tmp_dir/ruby/monarchic/agent_protocol/v1/monarchic_agent_protocol_pb.rb"
                if [[ ! -f "$expected" && -f "$tmp_dir/ruby/monarchic_agent_protocol_pb.rb" ]]; then
                  mkdir -p "$(dirname "$expected")"
                  cp "$tmp_dir/ruby/monarchic_agent_protocol_pb.rb" "$expected"
                fi
                ${rubyWithProtobuf}/bin/ruby -I "$tmp_dir/ruby" ${./examples/proto/ruby/task.rb} >/dev/null
                runHook postBuild
              '';
              installPhase = ''
                runHook preInstall
                mkdir -p $out
              runHook postInstall
            '';
          };

          example-php =
            let
              protobufPhpRuntime = pkgs.fetchFromGitHub {
                owner = "protocolbuffers";
                repo = "protobuf";
                rev = "v32.1";
                sha256 = "0sl3ahj74gpy4dv8xz9sry7kapnh00kpmghz2iqnlw5j40rvbyy1";
              };
            in
            pkgs.stdenv.mkDerivation {
              pname = "example-php";
              version = "0.1.14";
              nativeBuildInputs = [
                pkgs.protobuf
                pkgs.php
              ];
              dontUnpack = true;
              buildPhase = ''
                runHook preBuild
                tmp_dir="$(mktemp -d)"
                trap 'rm -rf "$tmp_dir"' EXIT
                mkdir -p "$tmp_dir/gen" "$tmp_dir/vendor" "$tmp_dir/protobuf"
                ${pkgs.protobuf}/bin/protoc -I ${./schemas/v1} \
                  --php_out="$tmp_dir/gen" \
                  monarchic_agent_protocol.proto
                cp -r "${protobufPhpRuntime}/php/src/Google" "$tmp_dir/protobuf/"
                cp -r "${protobufPhpRuntime}/php/src/GPBMetadata" "$tmp_dir/protobuf/"
                chmod -R u+w "$tmp_dir/protobuf"
                cat > "$tmp_dir/vendor/autoload.php" <<'PHP'
<?php
spl_autoload_register(function ($class) {
  $prefixes = [
    'Google\\Protobuf\\' => __DIR__ . '/../protobuf/Google/Protobuf/',
    'GPBMetadata\\' => __DIR__ . '/../protobuf/GPBMetadata/',
    'Monarchic\\AgentProtocol\\V1\\' => __DIR__ . '/../gen/Monarchic/AgentProtocol/V1/',
  ];
  foreach ($prefixes as $prefix => $baseDir) {
    if (strncmp($class, $prefix, strlen($prefix)) !== 0) {
      continue;
    }
    $relative = substr($class, strlen($prefix));
    $file = $baseDir . str_replace('\\', '/', $relative) . '.php';
    if (file_exists($file)) {
      require_once $file;
    }
    return;
  }
});
PHP
                cp ${./examples/proto/php/task.php} "$tmp_dir/task.php"
                (cd "$tmp_dir" && ${pkgs.php}/bin/php task.php >/dev/null)
                runHook postBuild
              '';
              installPhase = ''
                runHook preInstall
                mkdir -p $out
                runHook postInstall
              '';
            };

          example-csharp = pkgs.stdenv.mkDerivation {
            pname = "example-csharp";
            version = "0.1.14";
            googleProtobufNupkg = pkgs.fetchurl {
              url = "https://www.nuget.org/api/v2/package/Google.Protobuf/3.25.3";
              sha256 = "1c8wykhwqm0wv6db159agw9hzqjl3q87rn54749im4wh7v238vmq";
            };
            nativeBuildInputs = [
              pkgs.protobuf
              pkgs.dotnet-sdk_8
            ];
            dontUnpack = true;
            buildPhase = ''
              runHook preBuild
              tmp_dir="$(mktemp -d)"
              trap 'rm -rf "$tmp_dir"' EXIT
              export HOME="$tmp_dir"
              export DOTNET_CLI_HOME="$tmp_dir/dotnet"
              mkdir -p "$tmp_dir/csharp"
              ${pkgs.protobuf}/bin/protoc -I ${./schemas/v1} \
                --csharp_out="$tmp_dir/csharp" \
                monarchic_agent_protocol.proto
              cp ${./examples/proto/csharp/TaskExample.cs} "$tmp_dir/Program.cs"
              cat > "$tmp_dir/Example.csproj" <<'XML'
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Google.Protobuf" Version="3.25.3" />
  </ItemGroup>
</Project>
XML
              mv "$tmp_dir/csharp/"*.cs "$tmp_dir/"
              rmdir "$tmp_dir/csharp"
              mkdir -p "$tmp_dir/nuget"
              cp "$googleProtobufNupkg" "$tmp_dir/nuget/Google.Protobuf.3.25.3.nupkg"
              cat > "$tmp_dir/NuGet.Config" <<EOF
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <clear />
    <add key="local" value="$tmp_dir/nuget" />
  </packageSources>
</configuration>
EOF
              ${pkgs.dotnet-sdk_8}/bin/dotnet restore "$tmp_dir/Example.csproj" \
                --configfile "$tmp_dir/NuGet.Config" \
                --packages "$tmp_dir/nuget-packages"
              ${pkgs.dotnet-sdk_8}/bin/dotnet build "$tmp_dir/Example.csproj" -c Release --no-restore
              runHook postBuild
            '';
            installPhase = ''
              runHook preInstall
              mkdir -p $out
              runHook postInstall
            '';
          };

          example-proto-rust = pkgs.rustPlatform.buildRustPackage {
            pname = "example-proto-rust";
            version = "0.1.14";
            src = pkgs.runCommand "example-proto-rust-src" {} ''
              set -euo pipefail
              mkdir -p $out/src $out/schemas/v1
              cp ${./examples/proto/rust/task.rs} $out/src/main.rs
              cp ${./schemas/v1/monarchic_agent_protocol.proto} $out/schemas/v1/monarchic_agent_protocol.proto
              cat > $out/build.rs <<'EOF'
fn main() -> Result<(), Box<dyn std::error::Error>> {
    prost_build::Config::new()
        .compile_protos(
            &["schemas/v1/monarchic_agent_protocol.proto"],
            &["schemas/v1"],
        )?;
    Ok(())
}
EOF
              cat > $out/Cargo.toml <<'EOF'
[package]
name = "example-proto-rust"
version = "0.1.14"
edition = "2021"
build = "build.rs"

[dependencies]
prost = "0.14"
prost-types = "0.14"

[build-dependencies]
prost-build = "0.14"
EOF
              cp ${./Cargo.lock} $out/Cargo.lock
            '';
            nativeBuildInputs = [ pkgs.protobuf ];
            cargoLock = {
              lockFile = "${self}/Cargo.lock";
            };
            doCheck = true;
            checkPhase = ''
              runHook preCheck
              ./target/*/release/example-proto-rust >/dev/null
              runHook postCheck
            '';
          };
        });

      apps = forAllSystems (system:
        let
          pkgs = nixpkgs.legacyPackages.${system};
          generateProto = pkgs.writeShellApplication {
            name = "generate-proto";
            meta = {
              description = "Generate language bindings from protobuf schemas.";
            };
            runtimeInputs = [
              pkgs.protobuf
              pkgs.protoc-gen-go
              pkgs.protoc-gen-dart
              pkgs.python3
              (pkgs.buildGoModule {
                pname = "protoc-gen-jsonschema";
                version = "0.5.2";
                src = pkgs.fetchFromGitHub {
                  owner = "bufbuild";
                  repo = "protoschema-plugins";
                  rev = "v0.5.2";
                  sha256 = "0h3whjflsd2pc7s075rzq4rsxgdrxnp5l2yqhpiadmssrlwy746f";
                };
                vendorHash = "sha256-bXSnunEIsxlea0+aj7MjY/TMANF3bBFmm0o0O8LjRwg=";
                subPackages = [ "cmd/protoc-gen-jsonschema" ];
              })
            ];
            text = ''
              exec ${./scripts/generate-proto.sh} "$@"
            '';
          };
          generateJsonSchema = pkgs.writeShellApplication {
            name = "generate-json-schema";
            meta = {
              description = "Generate JSON Schemas from protobuf definitions.";
            };
            runtimeInputs = [
              pkgs.protobuf
              pkgs.python3
              (pkgs.buildGoModule {
                pname = "protoc-gen-jsonschema";
                version = "0.5.2";
                src = pkgs.fetchFromGitHub {
                  owner = "bufbuild";
                  repo = "protoschema-plugins";
                  rev = "v0.5.2";
                  sha256 = "0h3whjflsd2pc7s075rzq4rsxgdrxnp5l2yqhpiadmssrlwy746f";
                };
                vendorHash = "sha256-bXSnunEIsxlea0+aj7MjY/TMANF3bBFmm0o0O8LjRwg=";
                subPackages = [ "cmd/protoc-gen-jsonschema" ];
              })
            ];
            text = ''
              exec ${builtins.path { path = ./scripts/generate-json-schema.sh; name = "generate-json-schema.sh"; }} "$@"
            '';
          };
          updateVersion = pkgs.writeShellApplication {
            name = "update-version";
            meta = {
              description = "Update versions across project files.";
            };
            runtimeInputs = [
              pkgs.python3
              pkgs.ripgrep
            ];
            text = ''
              exec ${./scripts/update-version.sh} "$@"
            '';
          };
          updateRegistryHashes = pkgs.writeShellApplication {
            name = "update-registry-hashes";
            meta = {
              description = "Update registry package hashes in flake.nix.";
            };
            runtimeInputs = [
              pkgs.nix
              pkgs.nix-prefetch-scripts
              pkgs.prefetch-npm-deps
              pkgs.python3
            ];
            text = ''
              exec ${builtins.path { path = ./scripts/update-registry-hashes.sh; name = "update-registry-hashes.sh"; }} "$@"
            '';
          };
          updateLocalHashes = pkgs.writeShellApplication {
            name = "update-local-hashes";
            meta = {
              description = "Update local build hashes in flake.nix.";
            };
            runtimeInputs = [
              pkgs.nix
              pkgs.nix-prefetch-scripts
              pkgs.python3
            ];
          text = ''
            exec ${builtins.path { path = ./scripts/update-local-hashes.sh; name = "update-local-hashes.sh"; }} "$@"
          '';
        };
        in
        {
          generate-proto = {
            type = "app";
            program = "${generateProto}/bin/generate-proto";
            meta = {
              description = "Generate language bindings from protobuf schemas.";
            };
          };
          generate-json-schema = {
            type = "app";
            program = "${generateJsonSchema}/bin/generate-json-schema";
            meta = {
              description = "Generate JSON Schemas from protobuf definitions.";
            };
          };
          update-version = {
            type = "app";
            program = "${updateVersion}/bin/update-version";
            meta = {
              description = "Update versions across project files.";
            };
          };
          update-registry-hashes = {
            type = "app";
            program = "${updateRegistryHashes}/bin/update-registry-hashes";
            meta = {
              description = "Update registry package hashes in flake.nix.";
            };
          };
          update-local-hashes = {
            type = "app";
            program = "${updateLocalHashes}/bin/update-local-hashes";
            meta = {
              description = "Update local build hashes in flake.nix.";
            };
          };
        });

      checks = forAllSystems (system:
        let
          pkgs = import nixpkgs { inherit system; };
          goRegistrySrc = pkgs.fetchFromGitHub {
            owner = "monarchic-ai";
            repo = "monarchic-agent-protocol";
            rev = "v0.1.14";
            sha256 = "1sc6fsf2j2rmlf4aw1glbl7vlw0w4y7vi938ykpsixijqbqzcxfy";
          };
          rbProtobuf = pkgs.buildRubyGem {
            gemName = "google-protobuf";
            version = "3.25.3";
            hardeningDisable = [ "format" ];
            src = pkgs.fetchurl {
              url = "https://rubygems.org/downloads/google-protobuf-3.25.3.gem";
              sha256 = "sha256-Ob2Xy8djGQXnbN+PG/PdocPQUgDX4j9XWs7XiTD73dY=";
            };
          };
        in
        {
          default = self.packages.${system}.default;
          rs-import = pkgs.rustPlatform.buildRustPackage {
            pname = "rs-import";
            version = "0.1.14";
            nativeBuildInputs = [ pkgs.protobuf ];
            src = pkgs.runCommand "rs-import-src" {} ''
              set -euo pipefail
              mkdir -p $out/src
              cat > $out/Cargo.toml <<'EOF'
[package]
name = "rs-import"
version = "0.1.14"
edition = "2021"

[dependencies]
monarchic-agent-protocol = { path = "${pkgs.fetchCrate {
  pname = "monarchic-agent-protocol";
  version = "0.1.14";
  sha256 = "sha256-QKb9SOEzrBBdErov4Rm3pmm8Nlsr8pfNYw4dhHVqBv8=";
}}" }
EOF
              cat > $out/src/main.rs <<'EOF'
use monarchic_agent_protocol::{AgentRole, Task, PROTOCOL_VERSION};

fn main() {
    let task = Task {
        version: PROTOCOL_VERSION.to_string(),
        task_id: "task-123".to_string(),
        role: AgentRole::Dev as i32,
        goal: "hello".to_string(),
        inputs: None,
        constraints: None,
        gates_required: Vec::new(),
        run_context: None,
        extensions: Default::default(),
    };
    println!("{}", task.task_id);
}
EOF
              cp ${./checks/rs-import.Cargo.lock} $out/Cargo.lock
            '';
            cargoLock = {
              lockFile = ./checks/rs-import.Cargo.lock;
            };
            doCheck = true;
            checkPhase = ''
              runHook preCheck
              ./target/*/release/rs-import >/dev/null
              runHook postCheck
            '';
          };

          test-json-schema = pkgs.runCommand "test-json-schema" {
            nativeBuildInputs = [ pkgs.bash pkgs.python3 pkgs.python3Packages.jsonschema ];
          } ''
            set -euo pipefail
            cd ${self}
            ${pkgs.bash}/bin/bash ./scripts/test-json-schema.sh
            touch $out
          '';

          test-proto = pkgs.runCommand "test-proto" {
            nativeBuildInputs = [
              pkgs.protobuf
            ];
          } ''
            set -euo pipefail
            bash ${./scripts/test-proto.sh} ${./schemas/v1/monarchic_agent_protocol.proto}
            touch $out
          '';

          example-rust = self.packages.${system}.example-rust;
          example-ts = self.packages.${system}.example-ts;
          example-python = self.packages.${system}.example-python;
          example-java = self.packages.${system}.example-java;
          example-kotlin = self.packages.${system}.example-kotlin;
          example-cpp = self.packages.${system}.example-cpp;
          example-dart = self.packages.${system}.example-dart;
          example-ruby = self.packages.${system}.example-ruby;
          example-php = self.packages.${system}.example-php;
          example-csharp = self.packages.${system}.example-csharp;
          example-proto-rust = self.packages.${system}.example-proto-rust;

          py-import = pkgs.stdenv.mkDerivation {
            pname = "py-import";
            version = "0.1.14";
            nativeBuildInputs = [
              (pkgs.python3.withPackages (ps: [ self.packages.${system}.py-registry-lib ]))
            ];
            src = pkgs.writeTextDir "py-import-check.py" ''
              import monarchic_agent_protocol
              from monarchic_agent_protocol import monarchic_agent_protocol_pb2 as pb

              task = pb.Task(version="v1", task_id="t1", role=pb.AgentRole.DEV, goal="hello")
              assert task.version == "v1"
            '';
            installPhase = ''
              runHook preInstall
              mkdir -p $out/bin
              cat > $out/bin/py-import-check <<'PY'
              #!/usr/bin/env python
              import monarchic_agent_protocol
              from monarchic_agent_protocol import monarchic_agent_protocol_pb2 as pb

              task = pb.Task(version="v1", task_id="t1", role=pb.AgentRole.DEV, goal="hello")
              assert task.version == "v1"
              PY
              chmod +x $out/bin/py-import-check
              runHook postInstall
            '';
            checkPhase = ''
              runHook preCheck
              $out/bin/py-import-check
              runHook postCheck
            '';
          };

          ts-import = pkgs.stdenv.mkDerivation {
            pname = "ts-import";
            version = "0.1.14";
            nativeBuildInputs = [
              pkgs.nodejs
              pkgs.nodePackages.typescript
            ];
            src = pkgs.writeTextDir "ts-import-check.ts" ''
              import { Task } from "@monarchic-ai/monarchic-agent-protocol";

              const task: Task = {
                version: "v1",
                task_id: "task-123",
                role: "dev",
                goal: "hello",
              };

              void task;
            '';
            installPhase = ''
              runHook preInstall
              mkdir -p $out
              runHook postInstall
            '';
            checkPhase = ''
              runHook preCheck
              mkdir -p node_modules/@monarchic-ai
              cp -r ${self.packages.${system}.ts-registry-lib}/lib/node_modules/@monarchic-ai/monarchic-agent-protocol node_modules/@monarchic-ai/monarchic-agent-protocol
              cat > tsconfig.json <<'JSON'
              {
                "compilerOptions": {
                  "target": "ES2020",
                  "module": "ESNext",
                  "moduleResolution": "Node",
                  "strict": true,
                  "noEmit": true,
                  "skipLibCheck": true
                }
              }
              JSON
              cat > index.ts <<'TS'
              import { Task } from "@monarchic-ai/monarchic-agent-protocol";

              const task: Task = {
                version: "v1",
                task_id: "task-123",
                role: "dev",
                goal: "hello",
              };

              void task;
              TS
              tsc --noEmit index.ts
              runHook postCheck
            '';
          };

          go-import = pkgs.buildGoModule
            (let
              goModImport = pkgs.runCommand "go-import-src" {} ''
                set -euo pipefail
                mkdir -p $out
                cp -r ${goRegistrySrc} $out/monarchic-agent-protocol
                cat > $out/go.mod <<'MOD'
                module go-import

                go 1.22

                require (
                  github.com/monarchic-ai/monarchic-agent-protocol/src/go v0.1.14
                  google.golang.org/protobuf v1.34.2
                )

                replace github.com/monarchic-ai/monarchic-agent-protocol/src/go => ./monarchic-agent-protocol/src/go

                MOD
                cp ${./src/go/go.sum} $out/go.sum
                cat > $out/main.go <<'GO'
                package main

                import (
                  agentprotocol "github.com/monarchic-ai/monarchic-agent-protocol/src/go/monarchic/agent_protocol/v1"
                )

                func main() {
                  _ = &agentprotocol.Task{
                    Version: "v1",
                    TaskId: "task-123",
                    Role: agentprotocol.AgentRole_DEV,
                    Goal: "hello",
                  }
                }
                GO
              '';
            in
            {
              pname = "go-import";
              version = "0.1.14";
              src = goModImport;
              vendorHash = "sha256-++bomu6mpFakJyEVZi7VY+shJF0pdvO3XVhMDdTevss=";
              subPackages = [ "." ];
              doCheck = true;
              checkPhase = ''
                runHook preCheck
                go build .
                runHook postCheck
              '';
            });

          rb-import = pkgs.stdenv.mkDerivation {
            pname = "rb-import";
            version = "0.1.14";
            nativeBuildInputs = [ pkgs.ruby ];
            buildInputs = [
              self.packages.${system}.rb-registry-lib
              rbProtobuf
            ];
            src = pkgs.writeTextDir "rb-import-check.rb" ''
              require "monarchic_agent_protocol"

              task = Monarchic::AgentProtocol::V1::Task.new(
                version: "v1",
                task_id: "task-123",
                role: Monarchic::AgentProtocol::V1::AgentRole::DEV,
                goal: "hello"
              )

              raise "unexpected task_id" unless task.task_id == "task-123"
            '';
            installPhase = ''
              runHook preInstall
              mkdir -p $out/bin
              cat > $out/bin/rb-import-check <<'RB'
              #!/usr/bin/env ruby
              require "monarchic_agent_protocol"

              task = Monarchic::AgentProtocol::V1::Task.new(
                version: "v1",
                task_id: "task-123",
                role: Monarchic::AgentProtocol::V1::AgentRole::DEV,
                goal: "hello"
              )

              raise "unexpected task_id" unless task.task_id == "task-123"
              RB
              chmod +x $out/bin/rb-import-check
              runHook postInstall
            '';
            checkPhase = ''
              runHook preCheck
              export GEM_PATH="${self.packages.${system}.rb-registry-lib}/${pkgs.ruby.gemPath}:${rbProtobuf}/${pkgs.ruby.gemPath}"
              $out/bin/rb-import-check
              runHook postCheck
            '';
          };

          java-import =
            let
              protobufJava = pkgs.fetchurl {
                url = "https://repo1.maven.org/maven2/com/google/protobuf/protobuf-java/4.32.1/protobuf-java-4.32.1.jar";
                sha256 = "1jrjm2y2fz2ckq82b77b62bdrcxvn6lwxldin2qaz2rkf7cy96cc";
              };
            in
            pkgs.stdenv.mkDerivation {
            pname = "java-import";
            version = "0.1.14";
            nativeBuildInputs = [
              pkgs.jdk
            ];
            src = pkgs.writeTextDir "java-import/Main.java" ''
              package importcheck;

              import ai.monarchic.agent_protocol.v1.Task;
              import ai.monarchic.agent_protocol.v1.AgentRole;

              public class Main {
                public static void main(String[] args) {
                  Task task = Task.newBuilder()
                    .setVersion("v1")
                    .setTaskId("task-123")
                    .setRole(AgentRole.DEV)
                    .setGoal("hello")
                    .build();
                  if (!"task-123".equals(task.getTaskId())) {
                    throw new RuntimeException("unexpected task_id");
                  }
                }
              }
            '';
            buildPhase = ''
              runHook preBuild
              mkdir -p build/classes
              ${pkgs.jdk}/bin/javac -classpath "${self.packages.${system}.java-lib}/share/java/monarchic-agent-protocol.jar:${protobufJava}" -d build/classes $(find . -name '*.java')
              runHook postBuild
            '';
            installPhase = ''
              runHook preInstall
              mkdir -p $out
              runHook postInstall
            '';
            checkPhase = ''
              runHook preCheck
              ${pkgs.jdk}/bin/java -classpath "build/classes:${self.packages.${system}.java-lib}/share/java/monarchic-agent-protocol.jar:${protobufJava}" importcheck.Main
              runHook postCheck
            '';
          };

          # TODO: pub.dev requires "domain"-based verification through the google console
          # dart-import = pkgs.runCommand "dart-import" {} ''
          #   set -euo pipefail
          #   tar -xzf ${self.packages.${system}.dart-registry-lib} -C .
          #   test -f package/lib/monarchic_agent_protocol.pb.dart
          #   rg "class Task" package/lib/monarchic_agent_protocol.pb.dart
          #   touch $out
          # '';

          csharp-import = pkgs.runCommand "csharp-import" { nativeBuildInputs = [ pkgs.unzip pkgs.ripgrep ]; } ''
            set -euo pipefail
            unzip -q ${self.packages.${system}.csharp-registry-lib} -d nupkg
            test -f nupkg/lib/netstandard2.0/Monarchic.AgentProtocol.dll
            touch $out
          '';

          php-import = pkgs.runCommand "php-import" { nativeBuildInputs = [ pkgs.ripgrep ]; } ''
            set -euo pipefail
            rg "class Task" ${self.packages.${system}.php-registry-lib}/src/php/Monarchic/AgentProtocol/V1/Task.php
            touch $out
          '';

          generate-proto-check = pkgs.runCommand "generate-proto-check" {
            nativeBuildInputs = [
              pkgs.bash
              pkgs.protobuf
              pkgs.protoc-gen-go
              pkgs.protoc-gen-dart
              pkgs.python3
              (pkgs.buildGoModule {
                pname = "protoc-gen-jsonschema";
                version = "0.5.2";
                src = pkgs.fetchFromGitHub {
                  owner = "bufbuild";
                  repo = "protoschema-plugins";
                  rev = "v0.5.2";
                  sha256 = "0h3whjflsd2pc7s075rzq4rsxgdrxnp5l2yqhpiadmssrlwy746f";
                };
                vendorHash = "sha256-bXSnunEIsxlea0+aj7MjY/TMANF3bBFmm0o0O8LjRwg=";
                subPackages = [ "cmd/protoc-gen-jsonschema" ];
              })
            ];
          } ''
            set -euo pipefail
            cp -R ${builtins.path { path = ./.; name = "repo-src"; }} repo
            chmod -R u+w repo
            cd repo
            src_dir="${builtins.path { path = ./.; name = "repo-src"; }}"
            ${pkgs.bash}/bin/bash ./scripts/generate-proto.sh
            diff -r -x result -x "result-*" schemas/v1 "$src_dir/schemas/v1"
            diff -r -x result -x "result-*" src "$src_dir/src"
            touch $out
          '';

          generate-json-schema-check = pkgs.runCommand "generate-json-schema-check" {
            nativeBuildInputs = [
              pkgs.bash
              pkgs.protobuf
              pkgs.python3
              (pkgs.buildGoModule {
                pname = "protoc-gen-jsonschema";
                version = "0.5.2";
                src = pkgs.fetchFromGitHub {
                  owner = "bufbuild";
                  repo = "protoschema-plugins";
                  rev = "v0.5.2";
                  sha256 = "0h3whjflsd2pc7s075rzq4rsxgdrxnp5l2yqhpiadmssrlwy746f";
                };
                vendorHash = "sha256-bXSnunEIsxlea0+aj7MjY/TMANF3bBFmm0o0O8LjRwg=";
                subPackages = [ "cmd/protoc-gen-jsonschema" ];
              })
            ];
          } ''
            set -euo pipefail
            cp -R ${builtins.path { path = ./.; name = "repo-src"; }} repo
            chmod -R u+w repo
            cd repo
            src_dir="${builtins.path { path = ./.; name = "repo-src"; }}"
            ${pkgs.bash}/bin/bash ./scripts/generate-json-schema.sh
            diff -r -x result -x "result-*" schemas/v1 "$src_dir/schemas/v1"
            touch $out
          '';

          update-local-hashes-check = pkgs.runCommand "update-local-hashes-check" {
            nativeBuildInputs = [
              pkgs.bash
              pkgs.nix
              pkgs.nix-prefetch-scripts
              pkgs.python3
            ];
          } ''
            set -euo pipefail
            cp -R ${self} repo
            chmod -R u+w repo
            cd repo
            export NIX_STATE_DIR="$PWD/.nix-state"
            export NIX_PROFILES_DIR="$PWD/.nix-profiles"
            export NIX_DATA_DIR="$PWD/.nix-data"
            mkdir -p "$NIX_STATE_DIR" "$NIX_PROFILES_DIR" "$NIX_DATA_DIR"
            export SKIP_NETWORK=1
            ${pkgs.bash}/bin/bash ./scripts/update-local-hashes.sh
            diff -u ${self}/flake.nix flake.nix
            touch $out
          '';

          update-registry-hashes-check = pkgs.runCommand "update-registry-hashes-check" {
            nativeBuildInputs = [
              pkgs.bash
              pkgs.nix
              pkgs.nix-prefetch-scripts
              pkgs.prefetch-npm-deps
              pkgs.python3
            ];
          } ''
            set -euo pipefail
            cp -R ${self} repo
            chmod -R u+w repo
            cd repo
            export NIX_STATE_DIR="$PWD/.nix-state"
            export NIX_PROFILES_DIR="$PWD/.nix-profiles"
            export NIX_DATA_DIR="$PWD/.nix-data"
            mkdir -p "$NIX_STATE_DIR" "$NIX_PROFILES_DIR" "$NIX_DATA_DIR"
            export SKIP_NETWORK=1
            ${pkgs.bash}/bin/bash ./scripts/update-registry-hashes.sh
            diff -u ${self}/flake.nix flake.nix
            touch $out
          '';

          update-version-check = pkgs.runCommand "update-version-check" {
            nativeBuildInputs = [
              pkgs.bash
              pkgs.python3
              pkgs.ripgrep
            ];
          } ''
            set -euo pipefail
            cp -R ${self} repo
            chmod -R u+w repo
            cd repo
            version="$(python - <<'PY'
from pathlib import Path
import tomllib

data = tomllib.loads(Path("Cargo.toml").read_text(encoding="utf-8"))
print(data["package"]["version"])
PY
)"
            ${pkgs.bash}/bin/bash ./scripts/update-version.sh "v$version"
            diff -u ${self}/Cargo.toml Cargo.toml
            diff -u ${self}/flake.nix flake.nix
            touch $out
          '';
        });

      devShells = forAllSystems (system:
        let
          pkgs = import nixpkgs { inherit system; };
        in
        {
          default = pkgs.mkShell {
            packages = [
              pkgs.cargo
              pkgs.rustc
              pkgs.rustfmt
              pkgs.protobuf
              pkgs.nodejs
              pkgs.jq
              pkgs.python3
              pkgs.python3Packages.jsonschema
            ];
          };
        });
    };
}