gotthlivepb

type Ack struct {
	ServerSeq uint64 `protobuf:"varint,1,opt,name=server_seq,json=serverSeq,proto3" json:"server_seq,omitempty"`
	// contains filtered or unexported fields
}

type ClientTelemetry struct {
	PatchId     uint64 `protobuf:"varint,1,opt,name=patch_id,json=patchId,proto3" json:"patch_id,omitempty"`
	MorphMicros uint32 `protobuf:"varint,2,opt,name=morph_micros,json=morphMicros,proto3" json:"morph_micros,omitempty"`
	ApplyMicros uint32 `protobuf:"varint,3,opt,name=apply_micros,json=applyMicros,proto3" json:"apply_micros,omitempty"`
	// contains filtered or unexported fields
}

type Error struct {
	Code ErrorCode `protobuf:"varint,1,opt,name=code,proto3,enum=gotthlive.v1.ErrorCode" json:"code,omitempty"`
	// Operator-readable detail. In production this is generic; in dev mode it
	// carries the stack. It never carries a token, a cookie, an authorization
	// input, application state, or a raw frame body.
	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	// The causal identifiers of the event this error concerns, or 0 when the
	// error is not event-scoped (H-12).
	EventId   uint64 `protobuf:"varint,3,opt,name=event_id,json=eventId,proto3" json:"event_id,omitempty"`
	ClientRef uint64 `protobuf:"varint,4,opt,name=client_ref,json=clientRef,proto3" json:"client_ref,omitempty"`
	// Whether the connection is closing. A close always names a code from the
	// enumeration in docs/protocol.md §8.3; a close for an unenumerated reason
	// is a defect.
	Fatal bool `protobuf:"varint,5,opt,name=fatal,proto3" json:"fatal,omitempty"`
	// contains filtered or unexported fields
}

type ErrorCode int32

type Event struct {

	// The client's own monotonic correlation handle, from 1 per connection.
	//
	// It is not the authoritative causal identifier: the server mints that and
	// echoes this back in Origin, so no untrusted value ever enters provenance.
	// A uint64 varint costs 1-3 bytes where a 128-bit identifier would cost 18,
	// and the client runtime needs no identifier generator, which matters
	// against a 12,288-byte budget.
	ClientRef uint64 `protobuf:"varint,1,opt,name=client_ref,json=clientRef,proto3" json:"client_ref,omitempty"`
	// The registered event name. An unregistered name is rejected and counted,
	// never dispatched and never ignored.
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// The fragment whose markup raised the event.
	FragmentId string `protobuf:"bytes,3,opt,name=fragment_id,json=fragmentId,proto3" json:"fragment_id,omitempty"`
	// The sequence number of the last patch the user had applied when they
	// acted. This is the causation edge, and it is what makes a stale-view
	// conflict detectable rather than silent. It is positive because the first
	// Snapshot establishes server_seq = 1 and the client may send nothing before
	// receiving it (H-10).
	SeenServerSeq uint64 `protobuf:"varint,4,opt,name=seen_server_seq,json=seenServerSeq,proto3" json:"seen_server_seq,omitempty"`
	// Form values. A repeated message is neither refined by the generated
	// boundary nor bounded by it, so cardinality is H-4 and each element is
	// refined explicitly.
	Fields []*EventField `protobuf:"bytes,5,rep,name=fields,proto3" json:"fields,omitempty"`
	// contains filtered or unexported fields
}

type EventField struct {
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// Bounded to fail early with a field-specific error. The authoritative limit
	// on inbound size is H-5, enforced on the connection before any payload is
	// allocated; this bound is subordinate defence in depth, not a redundant
	// restatement of it, and removing it would cost the specific diagnostic.
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type FragmentUpdate struct {
	FragmentId string  `protobuf:"bytes,1,opt,name=fragment_id,json=fragmentId,proto3" json:"fragment_id,omitempty"`
	Op         PatchOp `protobuf:"varint,2,opt,name=op,proto3,enum=gotthlive.v1.PatchOp" json:"op,omitempty"`
	// Rendered markup. A string rather than bytes, so protobuf's own UTF-8
	// validation runs during Unmarshal — a free correctness check before the
	// refinement boundary is even reached.
	Html string `protobuf:"bytes,3,opt,name=html,proto3" json:"html,omitempty"`
	// contains filtered or unexported fields
}

type Frame struct {

	// Protocol version of the sender.
	//
	// The predicate rejects only the structurally impossible value. In proto3, 0
	// is indistinguishable from unset, so a frame carrying it is malformed
	// rather than merely old. There is deliberately no upper bound: a ceiling
	// here would make a client above it fail as a malformed frame instead of as
	// an unsupported version, putting the graceful path out of reach for exactly
	// the field whose job is negotiating versions. Refinements reject what
	// cannot be parsed; H-2 rejects what cannot be served, and says why.
	ProtocolVersion uint32 `protobuf:"varint,1,opt,name=protocol_version,json=protocolVersion,proto3" json:"protocol_version,omitempty"`
	// Server-minted session identifier, 16 random bytes.
	//
	// It rides every frame, in both directions, so that one patch frame captured
	// in isolation is resolvable. The width matches an OpenTelemetry trace ID.
	// It rides inbound frames too, even though the connection already determines
	// the session, because one envelope means one schema, one generated codec,
	// one refinement boundary and one audit path on both sides — and because a
	// direction-dependent predicate is inexpressible in a grammar with no free
	// variables, so the alternative costs the totality of this bound.
	SessionId []byte `protobuf:"bytes,2,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// Exactly one payload. Members are messages, never scalars, because a scalar
	// inside a oneof cannot be refined.
	//
	// Types that are valid to be assigned to Payload:
	//
	//	*Frame_Event
	//	*Frame_Ack
	//	*Frame_ClientTelemetry
	//	*Frame_ResyncRequest
	//	*Frame_Patch
	//	*Frame_Snapshot
	//	*Frame_Error
	//	*Frame_Heartbeat
	Payload isFrame_Payload `protobuf_oneof:"payload"`
	// contains filtered or unexported fields
}

type Frame_Ack struct {
	Ack *Ack `protobuf:"bytes,4,opt,name=ack,proto3,oneof"`
}

type Frame_ClientTelemetry struct {
	ClientTelemetry *ClientTelemetry `protobuf:"bytes,6,opt,name=client_telemetry,json=clientTelemetry,proto3,oneof"`
}

type Frame_Error struct {
	Error *Error `protobuf:"bytes,10,opt,name=error,proto3,oneof"`
}

type Frame_Event struct {
	// Client to server.
	Event *Event `protobuf:"bytes,3,opt,name=event,proto3,oneof"`
}

type Frame_Heartbeat struct {
	// Both directions.
	Heartbeat *Heartbeat `protobuf:"bytes,5,opt,name=heartbeat,proto3,oneof"`
}

type Frame_Patch struct {
	// Server to client.
	Patch *Patch `protobuf:"bytes,8,opt,name=patch,proto3,oneof"`
}

type Frame_ResyncRequest struct {
	ResyncRequest *ResyncRequest `protobuf:"bytes,7,opt,name=resync_request,json=resyncRequest,proto3,oneof"`
}

type Frame_Snapshot struct {
	Snapshot *Snapshot `protobuf:"bytes,9,opt,name=snapshot,proto3,oneof"`
}

type Heartbeat struct {
	Nonce      uint64 `protobuf:"varint,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	IntervalMs uint32 `protobuf:"varint,2,opt,name=interval_ms,json=intervalMs,proto3" json:"interval_ms,omitempty"`
	// contains filtered or unexported fields
}

type Origin struct {
	Kind OriginKind `protobuf:"varint,1,opt,name=kind,proto3,enum=gotthlive.v1.OriginKind" json:"kind,omitempty"`
	// The originating event, for client-caused patches. Zero for patches the
	// server started on its own — a timer, a pubsub delivery, an effect result,
	// or a mount — where `source` names the cause instead. A resync is the one
	// server-sent frame with a specific nameable client cause, so it carries the
	// request's identifiers rather than zeros. H-6 binds these two fields to the
	// kind, which no predicate can express.
	EventId   uint64 `protobuf:"varint,2,opt,name=event_id,json=eventId,proto3" json:"event_id,omitempty"`
	ClientRef uint64 `protobuf:"varint,3,opt,name=client_ref,json=clientRef,proto3" json:"client_ref,omitempty"`
	// What produced this patch, namespaced by convention: `event:<name>`,
	// `effect:<source>`, `timer:<name>`, `pubsub:<topic>`, or the bare literals
	// `mount` and `resync`.
	//
	// This is where a refinement does load-bearing product work. The requirement
	// is that no patch may carry an unknown origin; the predicate below makes an
	// origin-less patch unconstructable in Go and unparseable from the wire.
	// That is the difference between a rule and a type.
	//
	// There is no registration step — a source is whatever an effect reports —
	// so cardinality is bounded at the metric rather than at the schema: the
	// label is capped at 64 distinct values per process, after which further
	// values collapse to `other` and an overflow counter increments. Traces and
	// the provenance log carry the full value.
	Source string `protobuf:"bytes,4,opt,name=source,proto3" json:"source,omitempty"`
	// Events whose state changes this patch carries but which were not
	// individually patched, because coalescing collapsed them.
	//
	// Bounded by H-4 at 1,024. That bound is a flush trigger, never a
	// truncation: at half the ceiling the actor emits the coalesced patch
	// immediately rather than continuing to coalesce, so the list cannot
	// overflow and no contributing event is ever dropped. Truncating would make
	// the coalescing provenance property false silently, which is the worst of
	// the available failures.
	ContributingEventIds []uint64 `` /* 131-byte string literal not displayed */
	// contains filtered or unexported fields
}

type OriginKind int32

type Patch struct {
	ServerSeq    uint64            `protobuf:"varint,1,opt,name=server_seq,json=serverSeq,proto3" json:"server_seq,omitempty"`
	PatchId      uint64            `protobuf:"varint,2,opt,name=patch_id,json=patchId,proto3" json:"patch_id,omitempty"`
	TransitionId uint64            `protobuf:"varint,3,opt,name=transition_id,json=transitionId,proto3" json:"transition_id,omitempty"`
	StateVersion uint64            `protobuf:"varint,4,opt,name=state_version,json=stateVersion,proto3" json:"state_version,omitempty"`
	Origin       *Origin           `protobuf:"bytes,5,opt,name=origin,proto3" json:"origin,omitempty"`
	Updates      []*FragmentUpdate `protobuf:"bytes,6,rep,name=updates,proto3" json:"updates,omitempty"`
	// contains filtered or unexported fields
}

type PatchOp int32

type ResyncReason int32

type ResyncRequest struct {
	LastAppliedSeq uint64       `protobuf:"varint,1,opt,name=last_applied_seq,json=lastAppliedSeq,proto3" json:"last_applied_seq,omitempty"`
	Reason         ResyncReason `protobuf:"varint,2,opt,name=reason,proto3,enum=gotthlive.v1.ResyncReason" json:"reason,omitempty"`
	// contains filtered or unexported fields
}

type Snapshot struct {
	ServerSeq    uint64  `protobuf:"varint,1,opt,name=server_seq,json=serverSeq,proto3" json:"server_seq,omitempty"`
	PatchId      uint64  `protobuf:"varint,2,opt,name=patch_id,json=patchId,proto3" json:"patch_id,omitempty"`
	TransitionId uint64  `protobuf:"varint,3,opt,name=transition_id,json=transitionId,proto3" json:"transition_id,omitempty"`
	StateVersion uint64  `protobuf:"varint,4,opt,name=state_version,json=stateVersion,proto3" json:"state_version,omitempty"`
	Origin       *Origin `protobuf:"bytes,5,opt,name=origin,proto3" json:"origin,omitempty"`
	// Session parameters, sent once so the client needs no configuration.
	HeartbeatIntervalMs  uint32            `protobuf:"varint,6,opt,name=heartbeat_interval_ms,json=heartbeatIntervalMs,proto3" json:"heartbeat_interval_ms,omitempty"`
	MaxInboundFrameBytes uint32            `` /* 126-byte string literal not displayed */
	AckWindow            uint32            `protobuf:"varint,8,opt,name=ack_window,json=ackWindow,proto3" json:"ack_window,omitempty"`
	Updates              []*FragmentUpdate `protobuf:"bytes,9,rep,name=updates,proto3" json:"updates,omitempty"`
	// The supersession edge: the inclusive server_seq range this snapshot
	// replaces.
	//
	// Without it, an analyst holding a wire capture cannot say which events
	// produced the DOM the user is now looking at across a resync boundary — the
	// superseded patches were emitted and counted, then dropped, and the
	// snapshot that replaced them named none of them. A range rather than the
	// union of contributing event identifiers, because the union is unbounded
	// and would collide with H-4, while the range is two varints, is exact, and
	// is sufficient: the superseded patches are themselves in the capture, so
	// walking the range recovers the event set.
	//
	// Both are 0 on a session's first snapshot and both are non-zero on a resync
	// snapshot; the zero case is legitimate, which is why no predicate can carry
	// this and H-13 does instead.
	SupersededFromSeq    uint64 `protobuf:"varint,10,opt,name=superseded_from_seq,json=supersededFromSeq,proto3" json:"superseded_from_seq,omitempty"`
	SupersededThroughSeq uint64 `protobuf:"varint,11,opt,name=superseded_through_seq,json=supersededThroughSeq,proto3" json:"superseded_through_seq,omitempty"`
	// contains filtered or unexported fields
}