protocol

type Acceptor interface {
	// ProcessRequest decides what a server does with a request. ignored explains why
	// ingress never compares its responses. An error means the request must not be sent.
	ProcessRequest(ctx context.Context, requestID Option[RequestID], route model.Route, ignored Option[string],
		request func(ctx context.Context) (Message, error)) (Decision, error)
	// ProcessResponse reports the response to a forwarded request. The engine owns
	// response.Raw from here on.
	ProcessResponse(ctx context.Context, exchange Exchange, response Response)
	// Unable ends a forwarded request whose response cannot be compared or replayed.
	// A cancelled ctx explains the failure, so it never quarantines the candidate.
	Unable(ctx context.Context, exchange Exchange, reason error)
}

type Config struct {
	// Comparison configures the scripts that normalise, compare, and hash payloads.
	Comparison comparison.Config `embed:""`
	// MatchWindow bounds how long an unused reference stays available, and how
	// long a candidate waits for one.
	MatchWindow time.Duration `default:"5s" help:"How long reference and candidate requests wait to be paired."`
}

type Content struct {
	// Status is absent only when Failure explains why.
	Status  Option[string]
	Message Option[Message]
	Failure Option[error]
}

type Decision interface {
	// contains filtered or unexported methods
}

type DecisionForward struct {
	RequestID Option[RequestID]
	Exchange  Exchange
}

type DecisionIntercept struct{ Raw Raw }

type Declaration interface {
	// contains filtered or unexported methods
}

type DeclarationIgnore struct{ Reason string }

type DeclarationRequest struct{ Type schema.TypeRef }

type DeclarationResponse struct{ Type schema.TypeRef }

type Engine struct {
	// contains filtered or unexported fields
}

type Exchange struct {
	typeid.TypeID[exchangePrefix]
}

type Matcher interface {
	Declare(pattern string, declaration Declaration) error
}

type Message struct {
	Type  Option[schema.TypeRef]
	Value any
}

type Quarantiner interface {
	Quarantine(ctx context.Context, reason model.QuarantineReason)
}

type Raw interface {
	Release()
}

type RequestID struct {
	typeid.TypeID[requestPrefix]
}

type Response struct {
	Raw Raw
	// Latency is the time to the first response byte, or zero if unmeasured.
	Latency time.Duration
	// Decode is called only to compare, on the candidate's time rather than the
	// reference's, and while the engine still holds Raw.
	Decode func() Content
}