replication

type IngestHandler interface {
	// ApplyReplicatedEntry applies a replicated entry to the local buffer
	// The entry contains msgpack-encoded records that need to be ingested
	ApplyReplicatedEntry(ctx context.Context, payload []byte) error
}

type IngestHandlerFunc func(ctx context.Context, payload []byte) error

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

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

type ReceiverConfig struct {
	// ReaderID is this reader's unique identifier
	ReaderID string

	// WriterAddr is the writer's coordinator address to connect to
	WriterAddr string

	// LocalWAL is the local WAL to write received entries (optional, for durability)
	LocalWAL WALWriter

	// IngestHandler applies entries to local buffer (optional)
	IngestHandler IngestHandler

	// ReconnectInterval is how long to wait before reconnecting after disconnect
	ReconnectInterval time.Duration

	// AckInterval is how often to send acknowledgments to the writer
	AckInterval time.Duration

	// Logger for receiver events
	Logger zerolog.Logger

	// TLSConfig for encrypted inter-node communication (nil = plain TCP)
	TLSConfig *tls.Config
}

type ReplicateAck struct {
	// LastSequence is the last successfully received and applied sequence
	LastSequence uint64 `json:"last_seq"`

	// ReaderID identifies which reader is sending the ack
	ReaderID string `json:"reader_id"`
}

type ReplicateEntry struct {
	// Sequence is a monotonically increasing number for ordering and deduplication
	Sequence uint64 `json:"seq"`

	// TimestampUS is the original entry timestamp in microseconds since epoch
	TimestampUS uint64 `json:"ts"`

	// Payload is the raw msgpack payload (zero-copy from WAL)
	Payload []byte `json:"payload"`
}

type ReplicateError struct {
	// Code is a machine-readable error code
	Code string `json:"code"`

	// Message is a human-readable error description
	Message string `json:"message"`
}

type ReplicateSync struct {
	// ReaderID identifies the reader requesting sync
	ReaderID string `json:"reader_id"`

	// LastKnownSequence is the last sequence the reader has (0 if new)
	LastKnownSequence uint64 `json:"last_known_seq"`
}

type ReplicateSyncAck struct {
	// CurrentSequence is the writer's current sequence number
	CurrentSequence uint64 `json:"current_seq"`

	// CanResume indicates if the reader can resume from LastKnownSequence
	// If false, reader needs to bootstrap from scratch (WAL was rotated)
	CanResume bool `json:"can_resume"`

	// Error contains any error message (empty if success)
	Error string `json:"error,omitempty"`
}

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

type SenderConfig struct {
	// BufferSize is the capacity of the entry buffer (default: 10000)
	BufferSize int

	// WriteTimeout is the timeout for writing to a reader connection
	WriteTimeout time.Duration

	// Logger for sender events
	Logger zerolog.Logger
}

type SimpleIngestHandler struct {
	HandleFunc func(ctx context.Context, records []map[string]interface{}) error
	Logger     zerolog.Logger
}

type WALWriter interface {
	AppendRaw(payload []byte) error
}