Decode payloads against a schema

[mgravell]

The site has had both halves of this since it was written: a parser that turns .proto into a descriptor, and a walker that turns bytes into a tree. They had never met. The decode view now takes an optional schema, works out which message the payload is, and uses it.

With one, every field carries its name and declared type, sub-messages are decomposed as the type they actually are, enum values are named, packed repeated fields are read as their element type, and map entries come through as key and value. No more ranking a string reading against a sub-message reading and hoping.

#1 name   : string                  = Ada Lovelace
#2 id     : int32                   = 1815
#4 phones : repeated Person.PhoneNumber
   #1 number : string               = 555-4816
   #2 type   : Person.PhoneType     = PHONE_TYPE_MOBILE = 1
#9 (not in the schema)              = abc

Without one, nothing changes: the panel is shut by default and the existing heuristics are untouched.

Working out which message it is

Nothing in a payload names its type, so the tool reads it once as every message the schema declares and compares the results. The scoring rule is the part that is easy to get wrong:

Only agreement counts. A message scores on how many fields it recognises, and fields it has never heard of are not held against it. Unknown fields are the normal condition of protobuf — they are what a service that has moved on from the schema you have to hand sends, and they are meant to survive a round trip untouched. Scoring on the share of fields recognised would punish the right message for exactly that, and would invert on nesting: a message that decomposes a sub-message which is itself newer than the schema would rank below one that writes the same bytes off as opaque bytes.

Contradictions are close to disqualifying. A schema declaring field 3 a string cannot be what wrote a varint there — reusing a field number with an incompatible type is the one thing the compatibility rules forbid, which is what reserved exists to prevent. But a message that contradicts nothing because it declares nothing the payload contains is the worst answer available, not the safest, so recognising something and disagreeing about a corner still beats recognising nothing.

Ties go to declaration order, which is why the candidate list is now in declaration order with your own file ahead of its imports rather than alphabetised — a .proto's first message is usually its point. A tie settled that way is then said out loud: ⚠ in the panel header, a warning above the tree naming what else fits, picker one click away.

Everything inferred is labelled rootGuessed all the way to the screen. An inferred type that happens to be wrong is the most misleading thing this view can produce, so it never reads like a choice someone made — and only an explicit selection pins it, so editing the schema is free to arrive at a different answer.

Ranking is skipped above 48 messages or 128 KB, where it costs more than the guess is worth; the note says that happened rather than implying anything was measured.

The rest of the shape

WireWalker still knows nothing about .proto text and the parser still knows nothing about payloads; Decoder.cs is the only file that knows both. SchemaIndex flattens the descriptor into the two lookups a walk needs — field number to declared type, enum number to name — and SchemaSource remembers the last schema it parsed, so typing in the payload box does not reparse the schema beside it.

On the WASM boundary, Decode takes JSON alongside the bytes rather than a bool (omitting the root type is what asks for inference), and a new SchemaTypes lists a schema's messages for the picker. Both go through that same remembered parse.

Tests

The walker had none, which was tolerable while it only ever guessed and is not now that it will be trusted. src/ProtoGen.Wasm.Tests covers naming, enums, maps, groups, extensions, packed and unpacked repeated fields, every way the bytes and the schema can disagree, and the ranking rules above — including the skew case that the share-of-fields scoring got backwards, and the vacuous-non-contradiction ordering, which took a failing test to notice. It compiles the engine sources in rather than referencing the project, because a browser-targeted assembly full of [JSExport] will not load in a test host, and it hand-writes its payloads, because a serializer would refuse to produce most of what needs covering. dotnet test runs as its own CI step, before the build that produces web/dist.

Verified end to end by hosting the published runtime under Node and calling the exports directly, since the interesting failure mode here is the JS boundary rather than the C#.