clientcodec

type Artifact struct {
	// Path is relative to the output directory and is part of the generated
	// output: gen.sh compares it, so a renamed artifact is a diff rather than
	// a silently orphaned file.
	Path string

	// Data is the file's exact bytes. Generating into memory is what makes the
	// determinism spec cheap: it generates twice and compares these.
	Data []byte
}

type Conjunct struct {
	// Text is the term's source, verbatim.
	Text string
	// Class is length, numeric or matches — the three rows of
	// docs/protocol.md §10.3's table.
	Class string
	// Enforced records whether the generated client decoder checks it. Only
	// length conjuncts on string and bytes fields are.
	Enforced bool
}

type Enum struct {
	// Name is the enum's proto name, unqualified.
	Name string

	// Values are its non-zero members in declaration order.
	Values []EnumValue
}

type EnumValue struct {
	// Name is the member's proto name, emitted verbatim.
	Name string

	// Number is the value on the wire.
	Number int32
}

type Field struct {
	// Number is the proto field number, which is what actually appears on the
	// wire and therefore what the decoder dispatches on.
	Number int
	// Kind is the single-letter wire kind the emitted table uses:
	//
	//	v  varint scalar or enum      b  bool
	//	s  string                     y  bytes
	//	m  singular message           r  repeated message
	//	p  repeated packed varint
	Kind string

	// Name is the field's proto name. The emitted JavaScript uses it verbatim,
	// so the client's object keys are the schema's names rather than a
	// camel-cased translation of them.
	Name string
	// Arg is "min:max" for s and y when a length predicate bounds them, the
	// message name for m and r, and empty otherwise.
	Arg string
}

type Message struct {
	// Name is the message's proto name, unqualified, and the identifier the
	// emitted codec's table is keyed by.
	Name string

	// Fields are its fields in declaration order, not field-number order: the
	// emitted table's order is part of the generated bytes.
	Fields []Field
}

type Predicate struct {
	// Message is the unqualified name of the message the field belongs to.
	Message string

	// Field is the field's proto name. The pair identifies the row in the
	// manifest.
	Field string

	// Expr is the predicate source text from the .proto option, verbatim. It
	// is reproduced rather than rewritten so the manifest quotes what a
	// reviewer will find in the schema.
	Expr string

	// Conjuncts is Expr split on `&&`, because enforcement is decided term by
	// term: a field can carry a length bound the client checks and a regular
	// expression it does not.
	Conjuncts []Conjunct
}

type Schema struct {
	// Messages are the wire messages, in declaration order.
	Messages []Message

	// Enums are the enumerations the client reads or writes, in declaration
	// order and without their zero members.
	Enums []Enum

	// Predicates are the refinement expressions, one per refined field, in the
	// order the fields were declared. They drive the manifest rather than the
	// codec: most of them are not enforced client-side, and the manifest is
	// where that is said out loud.
	Predicates []Predicate
}

type Vector struct {
	// Name identifies the case in the JS test's failure output.
	Name string `json:"name"`

	// Note says what the case is for, so a failure names the property rather
	// than only the vector.
	Note string `json:"note"`

	// Hex is the canonical Go encoding of Frame, hex-encoded because the
	// fixture is JSON.
	Hex string `json:"hex"`

	// Frame is the expected decoded value in JavaScript shape, read back
	// through protoreflect rather than written by hand so that it omits
	// exactly the fields proto3 omits on the wire.
	Frame map[string]any `json:"frame"`

	// Reencode asks the JS test for the harder half: encode Frame and require
	// the bytes to equal Hex. A vector without it checks only that the client
	// can read what Go writes.
	Reencode bool `json:"reencode"`
}