ipc

type Cancel struct {
	ID     string
	Reason CancelReason
}

type CancelReason int

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

type Config struct {
	// Tags are the handler tags this process serves, declared in the handshake
	// and checked against the blueprint by the runtime.
	Tags []string
	// Reconcile is given what the blueprint declares, before this process
	// declares itself, and returns the tags to declare.
	//
	// It is how a handler whose tag is not knowable from code alone settles it:
	// a WebSocket route keyed by something the API states, or a handler that
	// stated only its name and takes its routing from the blueprint. Returning
	// an error fails the handshake, which is the right outcome for a handler
	// that could never be dispatched to. Optional.
	Reconcile func(blueprint []HandlerConfig) ([]string, error)
	// Resolve returns the pipeline for a tag.
	Resolve func(tag string) (layer.Next, bool)
	// Concurrency is the worker pool size, and the initial credit.
	Concurrency int
	// Limits caps individual tags within the credit window, so one slow handler
	// cannot consume the whole of it.
	//
	// A function rather than a map because it is read after Reconcile which can
	// change a tag to the one the blueprint declares, and a cap keyed by the
	// tag built beforehand would name a handler the runtime does not know.
	// Optional.
	Limits     func() map[string]int
	SDKVersion string
}

type CreditGrant struct {
	Additional uint32
}

type DialConfig struct {
	// Socket is the Unix socket path, which is the normal case.
	Socket string
	// FallbackEnabled reports that the runtime could not bind a socket and is
	// serving over loopback TCP instead.
	//
	// The SDK uses the fallback only when the runtime says it did. Falling back
	// on its own would widen who may register as a handler from the one user the
	// socket's permissions allow to any process that can reach loopback.
	FallbackEnabled bool
	FallbackPort    int

	// Retry bounds how long dialling is retried. A handler process is commonly
	// started alongside the runtime, so losing the race to its listener is
	// ordinary rather than fatal.
	RetryFor time.Duration
}

type Drain struct {
	Deadline time.Time
}

type Draining struct {
	Deadline time.Time
}

type FromRuntime struct {
	Config   *RuntimeConfig
	ReadyAck *ReadyAck
	Dispatch *handler.Event
	Cancel   *Cancel
	Drain    *Drain
	WsAck    *WsSendAck
}

type HandlerConfig struct {
	HandlerName    string
	HandlerTag     string
	Timeout        time.Duration
	TracingEnabled bool
	// PublishedName is the name the blueprint publishes this handler under,
	// empty when it sets none.
	PublishedName string
}

type HandlerLimit struct {
	HandlerTag    string
	MaxConcurrent uint32
}

type Outbound struct {
	handler.OutboundMessage
	IsBinary bool
}

type ProtocolVersion struct {
	Major uint32
	Minor uint32
}

type ProtocolVersionError struct {
	// Declared is what this SDK was built against.
	Declared ProtocolVersion
	// Served is what the runtime sent with its configuration, which is the
	// zero value if it sent none.
	Served ProtocolVersion
}

type Ready struct {
	HandlerTags []string
	// InitialCredit is the total events the runtime may have in flight to this
	// process across all tags, which is the SDK's worker pool size.
	InitialCredit uint32
	SDKVersion    string
	// Limits cap individual tags so one slow tag cannot consume the whole
	// credit window and starve the others.
	Limits []HandlerLimit
	// Protocol is the contract version this SDK was built against.
	// This is required, the runtime refuses a handler that declares none,
	// rather than assuming it speaks the current one.
	Protocol ProtocolVersion
}

type ReadyAck struct {
	Accepted bool
	// UnknownTags are registered by the handler but absent from the blueprint.
	UnknownTags []string
	// UnhandledTags are in the blueprint but not registered by the handler.
	UnhandledTags []string
	// Reason says which check refused this handler. The tag lists alone cannot
	// tell a version refusal from an accepted handler with nothing to report.
	Reason RefusedReason
}

type RefusedReason int

type Result struct {
	Outcome *handler.Result
	// CreditGrant is normally 1. Zero withholds, telling the runtime to stop
	// dispatching to this stream until a later [CreditGrant] frame.
	CreditGrant uint32
}

type RuntimeConfig struct {
	TracingEnabled bool
	MetricsEnabled bool
	Handlers       []HandlerConfig
	// Protocol is the contract version the runtime serves, sent before this
	// handler is asked for anything.
	Protocol ProtocolVersion
}

type TagMismatchError struct {
	Unknown   []string
	Unhandled []string
}

type ToRuntime struct {
	Ready    *Ready
	Result   *Result
	Credit   *CreditGrant
	WsSend   *WsSend
	Draining *Draining
}

type Transport interface {
	Send(*ToRuntime) error
	Recv() (*FromRuntime, error)
	Close() error
}

type WsSend struct {
	CorrelationID string
	Messages      []Outbound
}

type WsSendAck struct {
	CorrelationID string
	Success       bool
	Failures      []handler.SendFailure
}