buffa-build: expose the parsed FileDescriptorSet for runtime use

[christopherwxyz]

Context

buffa-build already parses .proto files into a FileDescriptorSet internally — either via protoc (default), buf (Config::use_buf()), or a pre-built file (Config::descriptor_set(path)). The bytes then flow into buffa-codegen for Rust generation.

Those descriptor bytes aren't exposed to the build-time consumer. There's only an input descriptor_set(path) method.

Use case

Implementing gRPC Server Reflection v1 (grpc.reflection.v1.ServerReflection) requires the server to serve raw FileDescriptorProto bytes back to clients like grpcurl. The natural place to obtain those is from the same codegen pipeline that emits the message types — a single descriptor set covers the whole service surface.

This came up while writing a generic ServerReflection handler over connectrpc. The straightforward expectation was something like:

// build.rs
buffa_build::Config::new()
    .files(&["proto/myservice.proto"])
    .includes(&["proto/"])
    .emit_descriptor_set("myservice_descriptor.bin")  // <-- desired
    .compile()?;

// src/lib.rs
pub const FILE_DESCRIPTOR_SET: &[u8] =
    include_bytes!(concat!(env!("OUT_DIR"), "/myservice_descriptor.bin"));

Workaround today

Invoke protoc a second time directly from build.rs, separate from buffa-build:

let _ = Command::new("protoc")
    .arg(format!("--descriptor_set_out={}", out.join("descriptor.bin").display()))
    .arg("--include_imports")
    .arg(format!("-I{}", proto_dir.display()))
    .arg(&proto_file)
    .status()?;

This works but:

• Runs protoc twice over the same files
• Diverges from Config::use_buf() (the workaround hard-codes protoc)
• Requires every consumer to re-derive the include paths

Proposal

Add Config::emit_descriptor_set(name: impl Into<String>) -> Self that writes the internally-parsed FileDescriptorSet bytes to <out_dir>/<name>. Internally a one-liner since the parsed set is already on the stack — at minimum:

let bytes = parsed_descriptor_set.encode_to_vec();
std::fs::write(out_dir.join(&name), bytes)?;

Flag with --include_imports semantics (transitive closure) by default, matching what reflection clients need; an opt-out toggle could be added if needed.

The same opportunity applies symmetrically to connectrpc-build, which wraps buffa-build and would naturally surface the option as Config::emit_descriptor_set(...) too.

Why this matters

Without runtime FileDescriptorSet access, the grpcreflect story for the buffa + connectrpc stack requires a parallel protoc invocation in every consumer's build.rs. Closing the gap inside buffa-build makes server reflection a 1-line opt-in instead of a per-project recipe.

[iainmcgin]

[claude code] This is now solvable through the runtime reflection support that landed across #128–#141, just via a DescriptorPool rather than raw FileDescriptorSet bytes.

Enabling reflection in build.rs:

// build.rs
buffa_build::Config::new()
    .files(&["proto/myservice.proto"])
    .includes(&["proto/"])
    .generate_reflection(true)   // emits the descriptor pool
    .compile()?;

Codegen then emits your_crate::your_pkg::descriptor_pool(), which returns a DescriptorPool built from a FileDescriptorSet embedded in the generated code. That pool is exactly what a grpc.reflection.v1.ServerReflection handler needs:

• pool.files() -> &[FileDescriptorProto] — the raw descriptors to serve back to grpcurl (re-encode with Message::encode_to_vec for the FileDescriptorResponse bytes).
• pool.file_by_name(name) — FindFileByName.
• pool.file_containing_symbol(fqn) — FindFileContainingSymbol, resolving messages, enums, services, methods, and extensions (added in descriptor: custom options, Any pack/unpack, and symbol-to-file lookup #140).
• pool.file_containing_extension(...) style lookups via pool.extension_for(extendee, number).

The consuming crate needs buffa-descriptor with the reflect feature (and std). This covers the original use case — serving the service's descriptor surface from the same codegen pipeline that emits the message types — so I'm closing this out.

The literal request here was a buffa-build emit_descriptor_set() that writes the FDS bytes for include_bytes!. We went with the embedded-pool approach instead because it gives consumers the linked, queryable descriptor surface directly rather than raw bytes they'd have to parse themselves. If you specifically need the standalone .bin for tooling outside the Rust build, please reopen or file a follow-up and we can add a descriptor-set emit option.

[christopherwxyz]

Thanks, @iainmcgin!