locks

type Backend interface {
	// Acquire attempts to take the lock. Returns the new lock ID on success.
	// On contention, returns ErrBusy with currentOwner populated.
	Acquire(ctx context.Context, resource, owner string, ttl time.Duration) (lockID string, currentOwner string, err error)

	// Release deletes the lock. Returns ErrNotFound if the lock does not
	// exist anymore (expired or already released).
	Release(ctx context.Context, lockID string) error

	// Renew extends the TTL. Returns ErrExpired if the lock no longer exists.
	Renew(ctx context.Context, lockID string, ttl time.Duration) error

	// Publish broadcasts an event to all subscribers of resource.
	Publish(ctx context.Context, resource string, t EventType, payload string) error

	// Subscribe returns a channel for all events on resource. The returned
	// cancel function must be called to release backend resources.
	Subscribe(ctx context.Context, resource string) (<-chan Event, func(), error)

	// IncrementCounter atomically adds delta to the persistent counter
	// at key and returns the new value. Missing keys are auto-initialised
	// to 0 before applying delta. Counter state is independent of the
	// lock state: same backend, separate key namespace, no TTL.
	IncrementCounter(ctx context.Context, key string, delta int64) (int64, error)

	// Close shuts the backend down — closes Redis pool, stops sweepers, etc.
	Close() error
}

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

type Dialer func(ctx context.Context) (net.Conn, error)

type Event struct {
	Resource string
	Type     EventType
	Payload  string
}

type EventType string

type Lock struct {
	ID        string
	Resource  string
	Owner     string
	ExpiresAt time.Time
}

type Locker interface {
	// Lock acquires an exclusive lock on resource for owner. ttl bounds the
	// hold time so a crashed owner cannot deadlock the system; callers must
	// Renew before expiry.
	//
	// Returns ErrBusy with the current owner captured in the returned Lock's
	// Owner field if the resource is already locked.
	Lock(ctx context.Context, resource, owner string, ttl time.Duration) (Lock, error)

	// Unlock releases a previously acquired lock by ID. Returns ErrNotFound
	// if the lock has already expired or been released.
	Unlock(ctx context.Context, lockID string) error

	// Renew extends the TTL of an existing lock. Returns ErrExpired if the
	// lock has already been reclaimed by the TTL sweeper.
	Renew(ctx context.Context, lockID string, ttl time.Duration) error

	// Subscribe returns a channel that receives every EVENT for resource.
	// The channel is closed when ctx is cancelled or the underlying
	// connection drops.
	Subscribe(ctx context.Context, resource string) (<-chan Event, error)

	// Emit publishes an event on resource. Used by writers (LMTP delivery,
	// IMAP APPEND/EXPUNGE) to notify IDLE subscribers.
	Emit(ctx context.Context, resource string, t EventType, payload string) error

	// HoldsResource reports whether this client currently holds an active
	// lock on resource. Storage backends consult it to skip re-acquiring
	// a lock they already hold via an outer scope — without this, a batch
	// operation (POP3 QUIT, IMAP-side multi-message Expunge) that takes
	// one outer X lock and then calls per-message storage methods would
	// deadlock on its own owner (yarilo-locks is non-reentrant by design).
	HoldsResource(resource string) bool

	// IncrementCounter atomically adds delta to the persistent counter
	// at key and returns the post-increment value. Used for shared
	// monotonic counters that must survive process restart and stay
	// race-free across pods — e.g. mdbox next_file_id allocation.
	//
	// Counters are independent of lock state: they share no key space
	// with Lock resources and are not affected by TTL sweeping.
	// First reference auto-initialises the counter to 0 before
	// applying delta.
	IncrementCounter(ctx context.Context, key string, delta int64) (int64, error)

	// Close terminates the underlying transport.
	Close() error
}

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

type MemoryBackendOption func(*MemoryBackend)

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

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

type RedisOption func(*RedisBackend)

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