A thread-safe, multi-producer single-consumer bounded queue that atomically tracks rejections. The queue has a fixed capacity and a 'retire' mechanism to prevent new offers after shutdown. It uses a ConcurrentLinkedQueue for the internal buffer and AtomicInteger for rejection counting, with a non-blocking offer and a blocking drain. This is a reusable concurrency primitive for event processing pipelines.

A coroutine-based consumer that processes events from a BoundedEventQueue with a configurable timeout. It supports retirement (stop after timeout without processing new events) and resumption. The consumer is designed to be reloadable: it can be stopped and restarted, with the ability to transfer its state (registered wakelocks) across hot reloads. This pattern is useful for any system requiring graceful shutdown and state transfer between generations.

An in-memory registry for tracking active WakeLock instances and computing non-overlapping duration using a union-of-intervals approach. It is thread-safe via ConcurrentHashMap and supports state transfer (snapshot/restore) for hot reload scenarios. The registry handles acquire/release events, calculates total time across overlapping periods, and emits duration updates. This component demonstrates a practical approach to interval arithmetic and multi-threaded state management.

A data class hierarchy and serialization logic for exporting/importing app configuration as JSON using kotlinx.serialization. It defines backup structures for app info, blocking rules, and user preferences. The design is self-contained and could be adapted to any Android app needing JSON-based backup/restore of Room entities with proper schema versioning and migration.