gotson/komga

This system is a self-hosted media server for managing digital comic and ebook libraries, providing robust backend services for content analysis, metadata extraction, and format conversion. It exposes a comprehensive REST API supporting standard protocols like OPDS and Kobo Sync, enabling integration with various e-reader devices and applications. The platform features multiple frontend interfaces, including a modern Vue.js web UI and a desktop tray application, which allow users to browse, organize, and read their collections with real-time updates and granular access controls.

47 changes.

This period focused on a comprehensive architectural refactoring, migrating the database from H2 to SQLite with jOOQ, and restructuring the backend with a new domain service layer and custom persistence interfaces. Simultaneously, the project replaced the legacy frontend with a modern Vue.js-based web UI, introducing a new plugin architecture, TypeScript typing, and a feature-rich reading experience.

56 changes.

This period focused on expanding metadata ingestion by adding support for ISBN barcodes, ComicRack, and Mylar sources, while significantly enhancing the OPDS interface with v2 support and standardized manifests. The backend underwent substantial architectural improvements, including a migration to JOOQ for database access, the introduction of real-time Server-Sent Events, and the implementation of OAuth2 authentication. Additionally, the codebase introduced native parsing for EPUB and RAR archives, established a desktop tray application, and added comprehensive benchmarking and test coverage for these new features.

64 changes.

This period focused on building the next-generation Vue-based frontend (next-ui), establishing its component library, state management, and core pages for library and book management. Simultaneously, the backend expanded device compatibility by implementing Kobo Sync and KOReader Sync APIs, including on-the-fly KEPUB conversion and reading progress synchronization.

New data-transfer objects (AgeRating, Book, ComicInfo, Manga, ReadingList, YesNo) have been added to the ComicRack metadata infrastructure to support parsing ComicInfo.xml files and ComicRack reading lists. These DTOs enable the import of additional metadata fields such as translator, tags, story arc number, GTIN (as ISBN), and age ratings, as well as the creation of read lists from ComicRack list structures.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/comicrack/dto · high confidence

Komga now supports importing metadata from EPUB files. The new EpubMetadataProvider extracts book-level details such as title, description, release date, ISBN, and authors (including roles like translator, colorist, and penciller via MARC relators). It also retrieves series-level information including the series title, publisher, language, genres, and reading direction. Library settings control whether EPUB book and series metadata are imported independently.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/epub · high confidence

This change introduces a new REST API controller at \/koreader\ that enables synchronization of reading progress between Komga and the KOReader application. The implementation handles user authentication, retrieves current reading progress for books (supporting PDF, CBZ, and EPUB formats with specific location parsing for EPUBs), and updates progress back to Komga. It includes DTOs for document progress and user authentication, allowing KOReader clients to sync their state with the library.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/kosync · high confidence

This change introduces a new Kobo Sync infrastructure that allows Komga to act as a proxy for the Kobo store API, enabling Kobo devices and apps to sync reading progress and library data with Komga. It includes a KepubConverter component that uses the external 'kepubify' tool to convert EPUB books to KEPUB format on the fly, ensuring compatibility with Kobo devices. The KoboProxy component handles request forwarding, header management (including sync tokens), and error handling, while the KomgaSyncTokenGenerator manages the translation between Komga's internal sync tokens and the raw Kobo store tokens required for synchronization.

komga/src/main/kotlin/org/gotson/komga/infrastructure/kobo · high confidence

Added Kotlin data classes (AgeRating, MylarMetadata, Series, Status) to parse Mylar's series.json metadata, including field aliases for compatibility with both 'cid' and 'comicId' identifiers and support for Mylar version 1.0.1 format changes.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/mylar/dto · high confidence

This change introduces the OPDS v2 interface, adding a new controller and associated DTOs for catalog browsing, search, and authentication flows (Basic, OAuth2 Implicit, OAuth2 Password). Users can now access their library via the OPDS v2 standard, with support for navigation, facets, and restricted content access enforced through the new authentication document structure.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v2 · high confidence

The web UI now supports Progressive Web App (PWA) features, allowing users to add the application to their home screen on mobile devices. This includes a new manifest.json file defining app metadata and icons, along with updated HTML meta tags for iOS and Android compatibility, proper favicon handling, and configuration for standalone display mode.

komga-webui/public · high confidence

The API now supports the Readium Web Publication Manifest and OPDS 2.0 standards by introducing new data transfer objects. This includes \WPPublicationDto\ and related classes to structure publication metadata, links, and resources according to the Web Publication specification, as well as constants for OPDS media types (JSON, Publication, Authentication) and link relations (search, cover, acquisition, auth). These changes enable clients like Aldiko and Cantook to consume standardized metadata and progression data.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/dto · high confidence

The \next-ui/src/components/book/compare\ directory now includes a suite of Vue components that enable side-by-side comparison of two books during the import process. The main \Compare\ component orchestrates three tabs: General (displaying metadata like filename, file size, and page count with 'more/less' indicators for upgrades), Pages (a table listing page-by-page details with clickable rows), and Visual (a side-by-side image viewer with synchronized page steppers). Supporting components include \Info\ for metadata rows, \Pages\ for the comparison table, \Visual\ for the image viewer, and \page/Stepper\ for page navigation controls. Storybook stories are provided for all components to facilitate development and testing.

next-ui/src/components/book/compare · high confidence

Introduces three new tables for managing duplicate pages: KnownTable for known duplicates with action toggles (Delete Auto, Delete Manual, Ignore), UnknownTable for unclassified duplicates with bulk selection and marking, and MatchTable for viewing specific matches of a duplicate hash. Includes Storybook stories and documentation for all three components.

next-ui/src/components/pageHash · high confidence

This change introduces two new UI components to support editing book metadata. The \AddRole\ component provides a dropdown menu to select from existing contributor roles or define a custom role via a dialog, emitting the selected role to parent components. The \Links\ component allows users to add, edit, and remove URL links associated with a book, featuring validation for required fields and valid URL formats, along with a lock mechanism to control editability.

next-ui/src/components/btn, next-ui/src/components/item/form · high confidence

A new \v-ktooltip\ directive has been introduced in the \next-ui\ library, providing a Vue directive wrapper around the \KTooltip\ component. This allows developers to attach tooltips to elements using the \v-ktooltip\ syntax, supporting various binding modes such as simple text strings, object configurations for advanced options (like \scrim\ or \openOnClick\), and boolean toggles. The directive handles mounting, updating, and unmounting of the tooltip overlay, ensuring proper cleanup and integration with the application's app context.

next-ui/src/directives · high confidence

Introduced a new benchmarking module using JMH to measure application performance. This includes an abstract base class that configures and executes JMH runners with specific settings (warmup/measurement iterations, result formats like CSV/JSON, and single-threaded execution) and a Spring Boot configuration properties class to externalize benchmark parameters such as result folder paths and performance modes.

komga/src/benchmark/kotlin/org/gotson/komga/benchmark · high confidence

The benchmark module now includes specific configuration files to define its execution environment. The new \application-benchmark.yml\ sets up the application version, benchmark measurement parameters (iterations, warmup, mode), and points the database and Lucene data directories to a dedicated workspace folder. Additionally, \junit-platform.properties\ configures JUnit to use a per-class test instance lifecycle, which is typically used to optimize performance in benchmarking scenarios by reducing setup overhead.

komga/src/benchmark/resources · high confidence

A new TransientBookCache service has been introduced in the infrastructure layer to cache transient book data. This implementation uses Caffeine with a one-hour access-based expiration to store and retrieve transient book entities, optimizing performance for lookups and saves of temporary book metadata.

komga/src/main/kotlin/org/gotson/komga/infrastructure/cache · high confidence

The Komga tray application now supports multiple languages for its system tray menu and startup error dialogs. New resource files (messages\\.properties) provide translations for menu actions such as opening the main interface, opening the NextUI interface, showing the configuration directory, viewing logs, and quitting the application. Additionally, error messages displayed when the application fails to start (e.g., port in use or unexpected errors) are now localized, improving the user experience for non-English speakers.

komga-tray/src/main/resources/org · high confidence

Admins can now edit and delete read lists directly from the action menu. The edit action opens a dialog that allows updating the read list's name, order, and summary, as well as managing posters (uploading new ones, selecting a primary poster, or deleting existing ones). The delete action triggers a confirmation dialog before removing the read list, with success or error notifications displayed via snackbar messages.

next-ui/src/composables/readlist · high confidence

The background task system has been refactored to allow users to configure the number of threads used for processing tasks, enabling faster parallel execution for operations like library scans, book analysis, and metadata refreshes. Tasks are now assigned explicit priority levels (e.g., HIGH, DEFAULT, LOW), ensuring that critical operations like imports or scans are processed before lower-priority background maintenance tasks. This change improves overall system responsiveness and allows users to tune performance based on their hardware capabilities.

komga/src/main/kotlin/org/gotson/komga/application/tasks · high confidence

The desktop application now includes a system tray icon with a menu that allows users to open the main Komga interface, open the NextUI interface, locate the log file, locate the configuration directory, and quit the application. Additionally, if the application fails to start, a detailed error dialog is displayed to the user, providing the error message and an optional stack trace that can be copied to the clipboard.

komga-tray/src/main/kotlin/org/gotson/komga/application · high confidence

The application now includes an auto-generated HTTP client (via @hey-api/openapi-ts) in next-ui/src/generated, providing type-safe access to the Komga backend. This adds support for all API endpoints, including the new 'add to collection' and 'add to read list' actions, and enables features like Server-Sent Events (SSE) for streaming updates.

next-ui/src/generated · high confidence

Komga can now automatically detect and extract ISBNs from book pages by scanning barcodes. This new capability is provided by the IsbnBarcodeProvider, which analyzes specific pages of a book to find valid ISBN-13 barcodes and applies the found ISBN to the book's metadata. This feature is controlled by the library-level 'importBarcodeIsbn' setting, allowing users to enable or disable automatic ISBN extraction per library.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/barcode · high confidence

Komga now parses ComicInfo.xml files embedded in comic archives to populate book and series metadata, including authors, tags, ISBNs (from GTIN), web links, and reading direction. It also supports importing ComicRack .cbl read lists, matching series with or without volume numbers in brackets, and can append the ComicInfo volume to the series title if the library option is enabled.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/comicrack · high confidence

Komga now supports importing metadata for comic series from Mylar's series.json files. When enabled in library settings, the system reads series title, status, description, publisher, age rating, and total book count from these files, allowing users to leverage their existing Mylar metadata within Komga.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/mylar · high confidence

Komga now implements the Kobo Store API, allowing Kobo e-readers to sync with your library. This new \KoboController\ and its associated DTOs handle device authentication, library synchronization (including metadata, reading progress, and tags), and book downloads. The implementation supports on-the-fly conversion of books to KEPUB format for better rendering on Kobo devices and ensures that reading states and content restrictions are properly synchronized.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/kobo · high confidence

The Storybook environment for next-ui has been established with a new configuration that supports internationalization (including RTL locales), theme switching between light and dark modes, and responsive viewport testing. The setup integrates Vuetify, Vue Router (using memory history to bypass auth guards), Pinia with Colada for data fetching, and MSW for mocking API responses, providing a complete isolated environment for developing and testing UI components.

next-ui/.storybook · high confidence

The web interface now initializes via a structured plugin system in \komga-webui/src/plugins\. This includes an HTTP client plugin that automatically converts ISO date strings to JavaScript Date objects, a Vuetify theme plugin defining light and dark palettes, and a persisted state module that saves user preferences (such as reader settings, library filters, and theme) to local storage. Additionally, dedicated plugins wire up frontend services for core features including libraries, books, series, collections, read lists, users, OAuth2, and server metrics, making them available throughout the application.

komga-webui/src/plugins · high confidence

The komga-webui module is introduced as a new Vue.js frontend, replacing previous implementations. This change adds support for user-facing translations (i18n) via Vue I18n configuration and includes a new Epub reader component. The frontend is configured to run on a development server at port 8081, connecting to the API at localhost:8080, and includes specific build rules to handle CSS resources for the Epub reader libraries (Readium and r2d2bc).

komga-webui · high confidence

The web interface has been rewritten from scratch using Vue.js, Vuetify, and Vuex, replacing the previous implementation. This new frontend introduces a modern, responsive design with a sidebar navigation structure, replacing the old tab-based layout. Key user-facing capabilities include dynamic theme switching (supporting dark mode and system preference), multi-language support with specific pluralization rules (e.g., for Polish), and OAuth2 login integration. The UI now features a comprehensive settings dashboard for server administration, user management, and media analysis, along with improved library browsing, read list management, and a new web reader. Session handling has been updated to automatically log out users when sessions expire, and the application now supports running behind a base URL path.

komga-webui/src · high confidence

The application now features a completely new user interface built with Vue 3, Vuetify, and Pinia Colada for data management. This release introduces a redesigned layout with a new app bar and drawer, global state management for themes and authentication, and a comprehensive set of components for managing books, series, collections, and libraries. Key new capabilities include a detailed book view with tabbed navigation for general info, pages, and visual inspection, infinite-scrolling comboboxes for filtering by contributors, genres, tags, and sharing labels, and a new tooltip component optimized for mobile long-press interactions. The UI also supports book comparison, import workflows for books and readlists, and history tracking, all wrapped in a new responsive design.

next-ui/src · high confidence

This change introduces the first beta version of the new Next UI, a Vue 3 frontend built with Vuetify, TypeScript, and Vite. It establishes the complete development environment, including ESLint and Prettier configurations, Storybook for component testing, and Vitest for unit and browser tests. The UI integrates with the backend via an auto-generated OpenAPI client (using @hey-api/openapi-ts) and Pinia Colada for state management, while handling internationalization through FormatJS and dynamic asset paths for server deployment.

next-ui · high confidence

Adds the ItemCard component to the next-ui library, providing a flexible card layout for displaying entity information with a poster image, title, and multiple subtitle lines. The component supports various interaction states including selection (with pre-selection and hover indicators), floating action buttons (FABs), quick actions, and menu icons that appear on hover. It also includes features for displaying progress bars, top-right icons or counts, and handles image loading states with placeholders and error handling. Storybook stories are included to demonstrate different configurations such as long text wrapping, empty lines, landscape orientation, and loading states.

next-ui/src/components/item/card · high confidence

The next-ui application now uses Pinia stores to manage reactive state, replacing the previous approach. This introduces centralized stores for application settings (such as theme, drawer state, and browsing preferences), dialog handling, image cache busting, message notifications, item selection across books and series, and task queue tracking. User preferences like theme and browsing page size are persisted locally via the Pinia persisted-state plugin, ensuring settings survive page reloads.

next-ui/src/stores · high confidence

Added a new set of Kotlin classes in the EPUB infrastructure package to handle the parsing and extraction of EPUB files. This includes logic to read the OPF manifest, process navigation documents (both EPUB 2 NCX and EPUB 3 NAV), extract table of contents entries, and identify book covers and page resources. The implementation uses Jsoup for XML parsing and handles URL decoding and path normalization to ensure robust access to content within the EPUB zip archive.

komga/src/main/kotlin/org/gotson/komga/infrastructure/mediacontainer/epub · high confidence

This change introduces the initial beta version of the new 'next-ui' interface, adding the foundational application shell (default and single layouts), a new library menu system for managing libraries and collections, and reusable UI components including a wide item card, deletion warnings, and a multi-state sort list. It also establishes the development infrastructure with Storybook stories for the new components, CSS layer definitions for styling, and a new logging service using Logtape.

(repo-wide) · high confidence

The media container infrastructure now uses Apache Tika to detect media types from file paths and input streams, replacing previous detection logic. This change adds a new ContentDetector service and TikaConfiguration bean to handle MIME type identification, enabling more robust support for various image formats (including JPEG XL) and archive files within the library.

komga/src/main/kotlin/org/gotson/komga/infrastructure/mediacontainer · high confidence

This change establishes the foundational type system for the new NextUI by adding a suite of TypeScript definitions in \next-ui/src/types\. It introduces domain models for book and readlist imports (\BookImport\, \ReadListImportEntry\), UI configuration for cards and dialogs (\ItemCard\, \dialog\), and pagination handling (\PageRequest\). It also defines enums with i18n message descriptors for core entities such as media status, series status, reading direction, and user roles, alongside Valibot schemas for validating filter criteria and client settings.

next-ui/src/types · high confidence

This change introduces a comprehensive set of new domain model classes in the \komga/src/main/kotlin/org/gotson/komga/domain/model\ package. Key additions include \KomgaUser\ for user accounts with role-based access and library sharing, \ContentRestrictions\ and \AgeRestriction\ for filtering content by age and labels, and a new \SearchCondition\ DSL for advanced series and book filtering. The diff also adds models for API key authentication (\ApiKey\), authentication activity logging (\AuthenticationActivity\), and various media-related structures like \Media\, \BookPage\, and \R2Locator\ for Readium progression support.

komga/src/main/kotlin/org/gotson/komga/domain/model · high confidence

The web UI now defines keyboard shortcuts for navigating and configuring the book, continuous, and EPUB readers. Users can switch reading directions (left-to-right, right-to-left, vertical, webtoon), cycle page layouts, adjust side padding and page margins, toggle toolbars/settings/thumbnails, and use fullscreen mode. EPUB-specific shortcuts include page navigation, layout toggling, theme cycling, and font size adjustment, with arrow keys adapting to the current reading direction.

komga-webui/src/functions/shortcuts · high confidence

The system now supports configuring periodic library scans at the individual library level. A new LibraryScanScheduler service manages these schedules, allowing users to set scan intervals (such as hourly, daily, or weekly) per library. The scheduler automatically handles the timing and execution of library scans based on these configured intervals, replacing any previous global or manual scanning mechanisms for these specific libraries.

komga/src/main/kotlin/org/gotson/komga/application/scheduler · high confidence

Introduces the BookCard component, which displays book details including read progress, media status (error, unsupported, unknown), and series information. The component now conditionally renders edit and menu actions (pencil icon and dots menu) only for users with admin privileges, aligning with the fix to restrict select actions to required contexts. It also includes Storybook stories covering various states such as unread, in-progress, oneshot, deleted, and media errors.

next-ui/src/components/book/card · high confidence

Users can now manage accounts directly via the command line. A new --list-users flag displays all registered user emails, while --reset and --newpassword flags allow administrators to reset passwords for specific users. These features are implemented as ApplicationRunners that execute at startup when the corresponding arguments are provided.

komga/src/main/kotlin/org/gotson/komga/interfaces/apprunner · high confidence

The security infrastructure now includes a configurable CORS policy that allows administrators to define allowed origins via the \komga.cors.allowed-origins\ property, enabling controlled cross-origin access for web clients. Additionally, a new API key authentication mechanism has been introduced, allowing users to authenticate REST API requests using a unique key sent via the \X-API-Key\ header or embedded in the request URI, with the system automatically hashing and storing these keys securely. This change also refactors the security configuration to use Spring Security 6 standards, replacing deprecated adapters and introducing specific filters for API key validation alongside existing OAuth2 and session-based authentication.

komga/src/main/kotlin/org/gotson/komga/infrastructure/security · high confidence

The History view now uses a new server-side data table that displays historical events with columns for event type, series, book, and timestamp. Users can expand rows to see detailed information specific to each event type, such as file names and reasons for deletion, or before/after states for conversions. The Series and Book columns now display clickable links to the respective items when available, rather than just showing IDs.

next-ui/src/components/history · high confidence

The application now supports extracting content from RAR (including RAR4 and RAR5) and ZIP archives through new dedicated extractor services. This change introduces a unified extraction interface and specific implementations that handle archive entry enumeration, media type detection, and image dimension analysis, enabling users to browse and read comics stored within these compressed formats.

komga/src/main/kotlin/org/gotson/komga/infrastructure/mediacontainer/divina · high confidence

This change introduces several new API endpoints to the REST interface. The Client Settings API allows administrators and users to manage global and per-user configuration settings via dedicated endpoints. A new History endpoint provides administrators with a paginated list of historical system events. Additionally, an Announcements endpoint enables the retrieval and marking of read status for website announcements, while the Claim endpoint exposes server claim status and creation. These additions expand the programmatic control over application settings, audit trails, and initial server setup.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/rest · high confidence

Added new Vue components for the Read List entity view: ReadlistView.vue renders the list's poster, name, and ordering status (manual vs. automatic) using a responsive layout, while Actions.vue provides a toolbar for list-specific actions (such as opening the reader or editing the list) with a dropdown menu for additional options. These components introduce the UI structure for displaying and interacting with individual read lists.

next-ui/src/components/readlist/view · high confidence

A new Server Settings form component has been added to the UI, allowing users to configure poster generation options (size and regeneration), scan behavior (deleting empty collections/read lists), task pool size, and 'remember me' duration. The component includes Storybook stories and documentation for the new interface.

next-ui/src/components/server · high confidence

The web interface introduces a suite of new components to enhance content discovery and management. LibraryNavigation provides a dedicated toolbar for browsing series, books, collections, and readlists within a library, including a new 'Recommended' tab. AlphabeticalNavigation adds a quick-jump bar for libraries. Filtering is handled by FilterDrawer, FilterPanels, and FilterList, allowing users to sort and filter content with support for 'any/all' logic. Item browsing is powered by ItemBrowser and ItemCard, which display content in a grid with support for selection, dragging, and context-specific action menus. Additional components like HorizontalScroller, CollectionsExpansionPanels, and EmptyState support the new layout and interaction patterns.

komga-webui/src/components · high confidence

The web UI now provides dedicated context menus for Books, Series, Oneshots, Collections, Read Lists, and Libraries. These menus expose item-specific actions such as analyzing, refreshing metadata, marking as read/unread, adding to collections or read lists, and deleting. Library-level menus additionally support scanning (including deep scan), emptying the trash, and reordering libraries, with confirmation dialogs added for destructive operations like analysis and metadata refresh.

komga-webui/src/components/menus · high confidence

The web UI now includes an ApiKeyAddDialog for generating and copying API keys, a BulkEditBooksDialog for mass-editing book metadata with lock controls, and new CollectionAddToDialog and CollectionEditDialog components for managing collections. These changes also introduce a reusable ConfirmationDialog for user prompts and a BookPickerDialog for selecting books, replacing or supplementing previous dialog implementations.

komga-webui/src/components/dialogs · high confidence

The announcement UI now uses a new Card component that displays the announcement title as a clickable link to the external source, accompanied by an external link icon. The card also includes the modification date, the HTML content of the announcement, and a 'Mark as read' button that is disabled if the announcement has already been read. Storybook stories have been added to demonstrate both unread and read states of the card.

next-ui/src/components/announcement, next-ui/src/components/release · high confidence

Administrators can now import content via two new pages: a book import page that scans a specified directory to display and fine-tune a table of detected books, and a read list (CBL) import page that accepts a single .cbl file upload to match and display potential matches. Both interfaces are restricted to the ADMIN role and include Storybook documentation and test stories covering default, loading, and various error states (such as unsupported file types or empty results).

next-ui/src/pages/import · high confidence

A new book detail page has been introduced that displays book information and, specifically for oneshot titles, includes series attributes in the view. The page utilizes a new query-based data fetching approach and integrates a dedicated book view component to present this metadata.

next-ui/src/pages/book · high confidence

The book import workflow now uses a new UI flow starting with a directory selection component that allows users to browse or input a path to scan for books. The resulting transient books are displayed in a table that automatically analyzes unknown books, fetches series details, and attempts to auto-match existing series books for upgrades. Users can manually select series for unmatched books, view comparison details for matched upgrades, and see status indicators for analysis progress and errors.

next-ui/src/components/import/books · high confidence

The book view now supports several new user actions and information displays. Users can add books to read lists and collections, with corresponding confirmation dialogs and notifications. The book details dialog provides a dedicated view for book information, while the import table allows comparing books. Additionally, the UI now displays the specific file format (e.g., PDF, EPUB, CBR, CBZ) in the book view, and the edit metadata dialog has been enhanced to handle oneshot books by allowing edits to series fields.

next-ui/src/composables/book · high confidence

The book view page now uses a new \BookView.vue\ component that displays the book poster, series title, page count, and release date. It includes a new \Actions.vue\ component for handling user interactions like marking as read or editing, with a bottom sheet for additional actions. The view also shows alerts for media status (error, unsupported, outdated) and deletion state.

next-ui/src/components/book/view · high confidence

Added composable logic to enable editing and deleting collections. The new \useCollectionActions\ composable exposes Edit and Delete actions (admin-only) that trigger dedicated dialogs. The \useEditCollectionDialog\ composable handles the edit workflow, allowing users to update collection metadata (name, ordering) and manage posters (upload, select, delete), with success/error feedback via snackbar notifications. The delete action presents a confirmation dialog with a warning component before permanently removing the collection.

next-ui/src/composables/collection · high confidence

This change introduces a new set of UI components for managing collections, including the ability to add items to collections, edit collection metadata, and view collection details. The new components include AddTo, DeletionWarning, CollectionCard, Edit, General, Sheet, Actions, and CollectionView. These components provide a more intuitive and user-friendly way to manage collections within the application.

next-ui/src/components/collection, next-ui/src/components/series · high confidence

The next-ui/src/composables directory now includes a suite of new composables to support the new UI beta. This adds \useSSE\ for handling real-time server-sent events with multi-tab synchronization, \useAuthWatcher\ for automatic login redirection, and \useAppReleasesEnriched\ for detailed version checking. Library management is handled by \useUserLibraries\ and \useGetLibrariesByViewId\, while \useFilters\ and \useFilterContributors\ provide robust route-based filtering. Additional utilities include \usePagination\ for synchronized page tracking, \useOverviewSection\ for generating query options for various content sections, \useEntitiesActions\ for bulk operations like marking read or deleting, and helpers for form validation (\useFieldValidity\), image prefetching, and internationalized error/sort formatting.

next-ui/src/composables · high confidence

The web UI now includes dedicated Vue components for reading books: ContinuousReader.vue handles vertical scrolling (webtoon style) with configurable page margins, side padding, and scale types (width-fit or original), while PagedReader.vue manages discrete page navigation using a carousel, supporting various layouts (single/double page) and reading directions (left-to-right, right-to-left, vertical). These components replace or supplement previous reader implementations, providing a more structured and feature-rich reading experience with keyboard navigation, touch/swipe support, and pre-rendering capabilities.

komga-webui/src/components/readers · high confidence

The \next-ui/src/colada\ directory now provides a comprehensive set of composable functions for fetching and mutating data, replacing previous patterns with a standardized approach using \@pinia/colada\. This layer introduces typed queries and mutations for all core entities—including books, series, collections, read lists, libraries, users, and settings—along with specialized utilities for cache invalidation and error handling. Users benefit from consistent data synchronization, automatic cache management, and robust handling of server-side states across the new interface.

next-ui/src/colada · high confidence

The dialog component library now includes dedicated pickers for books, series, and file names, alongside reusable confirmation and simple dialog wrappers. The BookPicker dialog allows users to search and select a book from a provided list with filtering and sorting capabilities. The SeriesPicker dialog enables searching for series by name, displaying results with cover art and library context, and supports debounced search input. The FileNamePicker dialog helps users rename series books by displaying existing filenames and allowing selection or manual entry. Additionally, the Confirm dialog provides configurable confirmation modes (click, checkbox, or text validation), while ConfirmEdit and DialogSimple offer structured wrappers for edit forms and simple informational messages, all integrated with a centralized dialog store for instance management.

next-ui/src/components/dialog · high confidence

The application introduces a dedicated domain service layer in \komga/src/main/kotlin/org/gotson/komga/domain/service\ to manage the core book lifecycle. This includes \BookAnalyzer\ for detecting media types and extracting page metadata, \BookConverter\ for converting archives to CBZ, \BookImporter\ for handling file imports and sidecars, \BookLifecycle\ for managing read progress and thumbnails, \BookPageEditor\ for removing duplicate pages, and \LibraryContentLifecycle\ for scanning and organizing library content. These services centralize the logic previously scattered across the codebase, providing a structured foundation for book management operations.

komga/src/main/kotlin/org/gotson/komga/domain/service · high confidence

This change introduces a new set of filter UI components in \next-ui/src/components/filter\, including \AnyAll\, \ChipCount\, \ExpansionPanel\, \FilterButton\, \IncludeExclude\, \List\, \SearchList\, \SelectRange\, and \TriState\, along with their corresponding Storybook stories. It also adds specific filter implementations under \by/\ for attributes such as Age Rating, Author, Genre, Language, Library, Media Profile, Media Status, Publisher, Read Status, Release Year, Series Status, and Sharing Label. These components provide the building blocks for filtering content, featuring capabilities like tri-state selection (include/exclude), search with infinite scrolling, range sliders, and mode selectors (any/all).

next-ui/src/components/filter · high confidence

Added a new hashing infrastructure in the \infrastructure.hash\ package to support duplicate page detection and KOReader synchronization. The \Hasher\ component now uses the XXH3\_128 algorithm with a fixed seed to compute full-file hashes, enabling efficient identification of duplicate content. Additionally, a new \KoreaderHasher\ component implements a partial MD5 hashing strategy compatible with KOReader's file identification method, allowing seamless sync integration. These changes provide the underlying capability for features like duplicate detection and KOReader sync, though the specific API endpoints or UI integrations for these features are handled in other parts of the codebase.

komga/src/main/kotlin/org/gotson/komga/infrastructure/hash · high confidence

The Next UI introduces a new internationalization system that lazy-loads translation files per locale to improve performance. It automatically detects the user's preferred language from the browser or saved settings, falling back to English if needed. The system also supports Right-to-Left (RTL) locales, enabling proper display for languages like Arabic or Hebrew. Additionally, it provides a comprehensive set of translated messages for common UI elements, error codes, background tasks, and series editing forms.

next-ui/src/utils/i18n · high confidence

Users can now import reading lists via a new data table interface that automatically matches series and books based on server-provided identifiers. The table displays import entries and uses an internal watcher to fetch series books and auto-select the correct book number when a series is picked. It supports filtering, manual selection of series and books via dialogs, and displays status icons for duplicates or errors. A bottom form allows users to name and summarize the new read list before creation, with validation and loading states handled via Vuetify components.

next-ui/src/components/import/readlist · high confidence

Added three new Vue components to the item display layer: Browser.vue provides a paginated or infinite-scroll grid/list view using Vuetify's data iterator; Poster.vue renders media cards with optional top-right badges, progress bars, and lazy loading; and Scroller.vue implements a horizontal slide-group carousel with navigation arrows and touch-device chevron indicators. These components introduce the foundational UI structure for item presentation in the new UI beta, supporting selection states, RTL layouts, and responsive pagination.

next-ui/src/components/item · high confidence

This change introduces three new Vue components in the item menu area: ItemMenu, ItemMenuBottomSheet, and Sheet. ItemMenu provides a dropdown menu with support for RTL locales (adjusting icons based on direction) and ensures menus close properly after an action is selected. ItemMenuBottomSheet offers a bottom-sheet alternative for displaying actions. The Sheet component acts as a wrapper that conditionally renders either the dropdown or the bottom-sheet based on whether the device is touch-primary, ensuring an appropriate UI for both desktop and mobile contexts.

next-ui/src/components/item/menu · high confidence

The library section now includes a new tab-based navigation system that dynamically displays routes for Overview, Series, Books, Collections, and Read Lists based on available data, with responsive behavior for mobile and desktop views. A new header component provides library context and admin menu access, while a deletion warning component alerts users that deleting a library removes series, books, metadata, and read progress (though media files remain on disk). Storybook stories and documentation have been added for these new components to support development and testing.

next-ui/src/components/library · high confidence

The web interface now includes a dedicated multi-select bar component that appears when items are selected, enabling bulk operations directly from the UI. This toolbar supports actions such as marking items as read or unread, adding them to collections or read lists, bulk editing metadata, and deleting items. It also features select-all and deselect-all controls, with specific buttons appearing based on the item type (books, series, collections, or read lists) and user permissions.

komga-webui/src/components/bars · high confidence

The library creation and editing interface has been restructured into a four-step wizard (General, Scanner, Options, Metadata) using Vuetify tabs, replacing the previous single-page layout. This change introduces dedicated form steps for configuring library basics, scanning schedules and exclusions, file processing options, and metadata import sources, along with corresponding Storybook stories and documentation for each component.

next-ui/src/components/library/form · high confidence

The layout area now includes a new app bar (\Bar.vue\) and navigation drawer (\Drawer.vue\) with associated sub-components. The app bar features a mobile-optimized menu icon that toggles the drawer, along with improved tooltips for sidebar actions. The drawer provides a structured menu for Libraries, Import, Media, History, Server, and Account sections, including a new drag-and-drop interface for reordering pinned and unpinned libraries. A new \BarHolder.vue\ component manages the top bar visibility, displaying a warning banner when the realtime server connection is unavailable.

next-ui/src/components/layout · high confidence

This change introduces the first beta version of the new next-ui component library, adding a comprehensive set of UI components to the application. The new components include presentation controls (PresentationSelector, PagingSelector, PageSizeSelector, PosterSizeSlider), data display utilities (SimpleDataTable, OverviewSection, RemoteFileList, ReadMore), and user feedback elements (SnackQueue, TaskIndicator, LockIcon). It also adds internationalization support via LocaleSelector and FormattedMessage, along with various empty states and utility components like BuildCommit and BuildVersion to display server status.

next-ui/src/components · high confidence

The \next-ui/src/pages\ directory now includes the core entry-point and authentication views for the new UI. This adds a Login page (with Remember Me persistence and password recovery link), a Claim Server page (for initial user creation on unclaimed servers), a Startup page (handling authentication checks and redirection), and Error/Not-Found pages (displaying user-friendly messages and retry options). Storybook stories and documentation are also provided for these components.

next-ui/src/pages · high confidence

The read list section now includes an 'Add to' dialog (AddTo.vue) that lets users search existing read lists, create new ones, and add books or series to them, complete with duplicate name validation and infinite scroll. A 'Deletion Warning' component (DeletionWarning.vue) is also introduced to inform users that deleting a read list is irreversible and will not affect the underlying series or books. Storybook stories are provided for both components to demonstrate their behavior.

next-ui/src/components/readlist · high confidence

The selection interface now includes new components (Bar, BarActions, Footer) that display contextual actions and item counts. The Bar component uses tooltips for action buttons, addressing mobile usability, while the Footer component features a primary-colored design with a slide-group for action buttons. A Storybook story has been added for the Bar component to facilitate testing and visualization.

next-ui/src/components/selection · high confidence

A new series detail page has been introduced, providing users with a comprehensive view of a series' contents. The interface includes a toolbar for adjusting presentation modes (grid/list), page sizes, and paging controls. Users can now apply granular filters via a drawer, including read status, one-shot/unavailable flags, media profile, media status, tags, and contributor roles, along with sorting options. The main content area displays series information and a browsable list of books with selection capabilities, featuring loading states and error handling.

next-ui/src/pages/series · high confidence

The series UI now supports adding series to collections and read lists, as well as editing series metadata. This change introduces composable hooks that wire up the 'Add to Collection' and 'Add to Read List' dialogs, which provide user feedback via notifications upon creation or addition. It also adds a dedicated dialog for editing series metadata, handling poster uploads, deletions, and metadata updates with appropriate error handling and success notifications. Additionally, a new composable provides computed properties for series status (read/unread/in-progress) and access permissions, supporting the action menu's logic for displaying and enabling these new features.

next-ui/src/composables/library, next-ui/src/composables/series · high confidence

This change introduces a suite of new pages for the server and account sections of the UI. Server-side features include an Announcements page (with bulk read marking), a Settings page (with thumbnail regeneration), an Updates page (displaying release status), and a Users page (supporting create, edit, delete, and password change operations). Account-side pages include Activity, API Keys (with force-sync and deletion), and Details (with password change). Several pages (Server Metrics, Server UI, Account UI) are currently placeholders showing a construction state.

next-ui/src/pages/server · high confidence

The sidecar infrastructure now exposes two new interfaces, SidecarBookConsumer and SidecarSeriesConsumer, which define how the system identifies and matches sidecar files for individual books and entire series respectively. These interfaces allow the scanning process to detect changes in sidecar files by specifying the sidecar type, pre-filtering patterns for books, and matching logic for both book and series sidecar filenames.

komga/src/main/kotlin/org/gotson/komga/infrastructure/sidecar · high confidence

The user management section now features a comprehensive set of new components built on Vuetify. Administrators can view a paginated, sortable table of users with actions to change passwords, edit, or delete accounts (excluding the current user). A dedicated authentication activity table allows tracking of login attempts, IP addresses, and user agents, with an option to filter for the current user's own activity. User creation and editing are handled via a unified form supporting role assignment, library sharing configuration, and age restrictions. Additionally, a warning dialog is displayed before account deletion to confirm the permanent loss of read progress and authentication history.

next-ui/src/components/user · high confidence

The web UI now includes a dedicated set of helper functions in \komga-webui/src/functions\ to manage core display and interaction logic. This introduces specific capabilities for handling book formats (CBR, CBZ, PDF, EPUB, KEPUB, RAR5) and determining the correct reader route, calculating read progress and pages remaining, and building page spreads for single and double-page layouts. It also adds support for detecting browser capabilities for modern image formats like JPEG XL and WebP, managing URL generation for API resources, and handling UI-specific tasks such as image resizing for posters, sorting/filtering parameters, and accent-insensitive search.

komga-webui/src/functions · high confidence

The web UI now includes a comprehensive set of TypeScript service classes in the \komga-webui/src/services\ directory to handle all communication with the backend API. These services provide structured wrappers for interacting with endpoints covering books, series, collections, read lists, libraries, users, and settings, as well as specialized services for server actuator controls, announcements, OAuth2 login, page hashing, and real-time updates via Server-Sent Events (SSE). This change establishes the foundational client-side architecture required for the new dynamic UI features.

komga-webui/src/services · high confidence

The web interface now includes dedicated views for managing user accounts (AccountView), viewing server announcements (AnnouncementsView), and managing API keys (ApiKeys). Additionally, comprehensive browsing and management screens have been added for all media types: BrowseBooks, BrowseLibraries, BrowseSeries, BrowseCollections, BrowseReadLists, and BrowseOneshot. These views provide users with the ability to filter, sort, and paginate through their libraries, series, books, collections, and read lists, supporting multi-select actions and detailed item navigation.

komga-webui/src/views · high confidence

Users can now log in to Komga using external OAuth2 providers (starting with GitHub) and OIDC identity providers. The system automatically creates a new Komga account upon first successful login if the 'oauth2AccountCreation' configuration option is enabled; otherwise, the login fails if the user does not already exist. For GitHub logins, the service fetches the user's verified email address if it is not provided in the initial token response. For OIDC logins, the system enforces email verification requirements based on the 'oidcEmailVerification' setting, rejecting logins from unverified or missing email claims.

komga/src/main/kotlin/org/gotson/komga/infrastructure/security/oauth2 · high confidence

The poster management area now includes a new upload interface (PosterUpload) that allows users to add local image files via drag-and-drop or by pasting images from the clipboard (Cmd+V). This component integrates with the existing PosterCard to display a unified list of remote and local posters, enabling selection, deletion, and undo actions for both types of assets.

next-ui/src/components/poster · high confidence

The web UI now receives live notifications for library changes (additions, updates, deletions), series and book status changes, read progress updates, thumbnail modifications, and task queue status. It also notifies users when their session expires or is deleted, allowing the interface to react immediately to backend events without manual refresh.

komga/src/main/kotlin/org/gotson/komga/interfaces/sse · high confidence

The repository has been initialized with essential configuration files, including an EditorConfig for consistent code formatting, a .gitignore tailored for the project's build artifacts and IDE files, and a .gitattributes for text handling. Build and release infrastructure is established via Gradle wrapper scripts, Conveyor configuration files for desktop application packaging (Windows and macOS), and a conventional commit configuration to automate versioning and changelog generation. Documentation files such as README, CONTRIBUTING, DEVELOPING, SECURITY, and PRIVACY policies are also added to guide users and contributors.

(repo-wide) · high confidence

Users can now provide custom cover images for series and books by placing local image files (PNG, JPEG, JPG, TBN, WebP, GIF) in the library directories, with the system automatically detecting and using them as thumbnails. Additionally, metadata for oneshot series is now automatically populated from the single book's metadata, ensuring consistent information display for single-issue content.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/localartwork · high confidence

The Swagger 2 configuration file has been removed from the codebase. This eliminates the manual setup for Swagger 2 documentation, which previously ignored specific authentication principal parameters. This change aligns with the project's migration to OpenAPI 3, as the legacy Swagger 2 infrastructure is no longer required.

komga/src/main/kotlin/org/gotson/komga/infrastructure/swagger · high confidence

The legacy REST controller for managing series and books (SerieController.kt) has been removed. This eliminates the previous API endpoints for listing series, retrieving individual series, fetching books within a series, and accessing book content files. Users relying on these specific endpoints for series and book data retrieval will need to migrate to the updated API structure provided by the current version.

komga/src/main/kotlin/org/gotson/komga/interfaces/web · high confidence

The REST API data structures have been completely redefined to support new features and stricter validation. Users can now manage API keys, view authentication activity logs, and configure granular library settings (such as scan intervals, directory exclusions, and hashing options) via the API. The API exposes new endpoints and DTOs for managing alternate series titles, book links, and sharing labels. Duplicate page detection is now exposed via page hash DTOs, and read progress synchronization has been enhanced with new Tachiyomi V2 DTOs. Additionally, the API now supports client-side settings, server configuration (port, context path), and fetching Komga release announcements via a JSON feed.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/rest/dto · high confidence

The database access layer for the main data source has been restructured into a set of dedicated, split read/write DAOs (e.g., \AuthenticationActivityDao\, \BookDao\, \BookDtoDao\, \KomgaUserDao\) using JOOQ. This change introduces a clear separation between read operations (using a read-only \dslContextRO\) and write operations (using a write \dslRW\), which improves performance and concurrency. The new implementation includes optimized queries for features like 'On Deck' books using materialized CTEs, support for Kobo sync metadata, and enhanced search capabilities with temporary tables for large result sets.

komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main · high confidence

The web UI now uses a dedicated set of TypeScript interfaces and enums in the \komga-webui/src/types\ directory to strongly type all data models and configuration options. This covers domain entities such as books, series, libraries, collections, and read lists, as well as reader settings (scale types, layouts), user roles, and server settings. It also defines types for event-driven updates via Server-Sent Events (SSE), search conditions, and pagination, providing a consistent and type-safe foundation for the frontend components.

komga-webui/src/types · high confidence

This update applies several database migrations to improve data integrity and structure. Thumbnails are moved from the MEDIA table to a dedicated THUMBNAIL\_BOOK table with generated IDs. Series metadata (age rating, publisher, reading direction) is aggregated from books to the series level, and missing series metadata is auto-generated for existing series. Incorrect BCP47 language codes in series metadata are normalized. Additionally, read progress locators are corrected to fix compatibility issues, and missing series metadata entries are created for series that lacked them.

komga/src/flyway/kotlin · high confidence

The application's database schema has evolved significantly to support new features and performance improvements while migrating to SQLite. Key changes include the introduction of read lists, series sharing labels, and oneshot directory support, alongside enhanced metadata capabilities like full-text search (later removed), alternate titles, and ISBN tracking. The schema now stores authentication activity, historical events, and user content restrictions, while also optimizing performance through various database indices and aggregating book metadata at the series level. Library configuration has expanded to include options for scanning intervals, file type exclusions, automatic trash emptying, and local artwork import.

komga/src/flyway/resources/db · high confidence

The application now uses Spring's built-in event multicaster with a dedicated task executor for publishing domain events, replacing the previous Artemis-based messaging system. This configuration is active in all non-test profiles, ensuring that event listeners are executed asynchronously to improve responsiveness, while tests continue to use synchronous event processing for reliability.

komga/src/main/kotlin/org/gotson/komga/application/events · high confidence

The application now includes an in-memory repository for tracking HTTP exchanges, allowing users to inspect request and response details via Spring Boot Actuator endpoints. This replaces the previous HttpTrace mechanism with the newer HttpExchange infrastructure provided by Spring Boot.

komga/src/main/kotlin/org/gotson/komga/infrastructure/httpexchange · high confidence

The API now consistently enforces user-specific content restrictions (such as age ratings and label-based filters) for all book and series access points. A new ContentRestrictionChecker component centralizes this logic, ensuring that restrictions are applied not only to standard book pages and metadata but also to thumbnails, OPDS feeds, and WebPub manifests (EPUB, PDF, and Divina profiles). Users with restricted access will now receive forbidden errors when attempting to view content they are not permitted to see, closing previous gaps where restrictions were bypassed in specific endpoints.

komga/src/main/kotlin/org/gotson/komga/interfaces/api · high confidence

This update introduces several improvements to the web layer: the server port and context path can now be explicitly configured via settings; ETag caching is enabled for API, OPDS, and Kobo endpoints (excluding file downloads) to improve performance; query parameters using square brackets (e.g., \author\[\]\) are now correctly parsed and merged; the Kobo Sync feature now handles missing port information in forwarded headers more robustly; and static web resources (including favicons and CSS layers) are properly served with appropriate cache controls.

komga/src/main/kotlin/org/gotson/komga/infrastructure/web · high confidence

The OpenAPI specification now includes the /actuator/info endpoint for retrieving server information. Additionally, the generated schema for sealed classes (such as SearchOperator and SearchCondition) is flattened to remove unnecessary inheritance wrappers, resulting in cleaner and more accurate API documentation for clients.

komga/src/main/kotlin/org/gotson/komga/infrastructure/openapi · high confidence

Komga now validates that the system's temporary directory exists and is writable at startup, preventing runtime failures caused by missing or inaccessible temp paths. Additionally, ZIP file handling has been optimized for speed by reading only the central directory record first, falling back to a full scan only when necessary, which improves performance when extracting entries from archives.

komga/src/main/kotlin/org/gotson/komga/infrastructure/util · high confidence

The application now includes a dedicated styles directory with global and settings files. Users will see that links on touch devices no longer display underlines by default, while desktop users still see underlines on hover. Additionally, a new utility class is available to enforce line-clamping on text elements, and the SASS settings file is prepared for Vuetify configuration.

next-ui/src/styles · high confidence

The OPDS v1 API now uses a dedicated set of data-transfer objects (OpdsAuthor, OpdsEntry, OpdsFeed, OpdsLink, OpenSearchDescription) to serialize its Atom XML responses. A key behavioral change is the use of static XML namespace prefixes (e.g., 'pse' for OPDS Page Streaming Extension) defined in XmlNamespaces.kt, ensuring consistent and predictable XML output for clients consuming the catalog, navigation, and acquisition feeds.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v1/dto · high confidence

The komga-tray module now includes a new DesktopApplication entry point that validates the temporary directory is accessible on startup and provides a user-friendly error dialog if the application fails to launch (e.g., due to port conflicts). It also adds internationalized resource loading (RB.kt) and utility functions for opening URLs and file explorers, including a specific Windows workaround for opening file directories.

komga-tray/src/main/kotlin/org/gotson/komga · high confidence

The next-ui application now uses a dedicated API client setup in next-ui/src/api that centralizes the base URL configuration (supporting both environment variables and window globals) and configures the OpenAPI-generated client with session cookie support and XMLHttpRequest headers to prevent browser auth popups. This change also adds interceptors that parse Spring-style API errors (extracting detail or message fields from the response body) and attach them to thrown errors, while providing helper functions to construct URLs for series, book, and collection posters, file downloads, and the book reader interface.

next-ui/src/api · high confidence

A new \TransactionConfiguration\ class has been added to the infrastructure layer to provide a Spring-managed \TransactionTemplate\ bean. This change establishes a centralized configuration for transaction management, allowing other components to utilize a consistent template for executing database operations.

komga/src/main/kotlin/org/gotson/komga/infrastructure/transaction · high confidence

The application's data access implementation has been replaced with jOOQ, introducing new configuration classes for read/write and read-only DSL contexts, helper classes for generating search conditions, and utilities for handling SQLite-specific features like temporary tables and accent-insensitive collations. This change underpins improved search capabilities, including better full-text search, accent-insensitive queries, and support for new search criteria such as isNull/isNotNull operators and poster-based book searches.

komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq · high confidence

The Docker build process now uses a multi-stage template (Dockerfile.tpl) that upgrades the base image to Ubuntu 26.04 for amd64 and arm64 architectures and bundles the kepubify tool for enhanced ebook support. The image also installs native libraries for JPEG-XL, HEIF, and WebP, adds curl and wget, and configures proper locale support. The container now exposes port 25600 by default and uses the Spring Boot jar tools to extract layers.

komga/docker · high confidence

The web interface now includes dedicated styles for enhanced user interactions and content display. Tabbed dialogs on extra-small screens are adjusted to use full viewport height with scrolling, while list items now feature distinct hover states for warning and danger actions. Popovers and popups have been restyled with smooth fade-in animations and scroll indicators. Additionally, the e-book reader (Readium) styling is introduced, supporting pagination, scrolling, and various reading modes with customizable fonts and colors.

komga-webui/src/styles · high confidence

The book and readlist components now use dedicated bottom-sheet menus (Sheet.vue) that display actions in 'main' and 'management' groups. A key behavioral change is that the 'Select' action is only shown in these menus when the selection store is empty and the device uses touch input, controlled by the new \addSelectAction\ prop passed from the ReadlistCard. This ensures the selection option appears contextually rather than always, improving the interface for single-item interactions on touch devices.

next-ui/src/components/book/menu, next-ui/src/components/readlist/card, next-ui/src/components/readlist/menu · high confidence

The application now includes a new \ConfigurationChecker\ component that validates database storage paths at startup, blocking operation if the files reside on remote filesystems like CIFS or NFS to prevent data corruption. Additionally, the \KomgaProperties\ class has been significantly expanded to support SQLite-specific settings (such as WAL mode and connection pooling), Lucene search analyzer tuning, Kobo sync options, and CORS configuration, while ensuring necessary database directories are created automatically.

komga/src/main/kotlin/org/gotson/komga/infrastructure/configuration · high confidence

A new database table named TASK has been added to the SQLite schema to support the new background task handling system. This table stores task details including ID, priority, group ID, class, simple type, payload, owner, and timestamps, along with an index on the owner and group ID columns to optimize queries for task retrieval.

komga/src/flyway/resources/tasks · high confidence

The system now uses a new \TasksDao\ component to manage background tasks via the database instead of the previous in-memory or alternative mechanism. This implementation introduces a dedicated \TASK\ table schema and utilizes separate read/write DSL contexts to optimize performance. It supports batched saves, priority-based task retrieval, and owner-based locking to ensure tasks are processed exactly once, replacing the prior task handling logic.

komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/tasks · high confidence

The image processing layer has been restructured with new components: ImageAnalyzer extracts dimensions from image streams, ImageConverter handles format conversion (including WebP support via NightMonkeys) and resizing with upscaling prevention, and MosaicGenerator creates composite thumbnails using configured quality settings. These changes enable more robust image handling, including proper alpha channel management and support for additional image formats.

komga/src/main/kotlin/org/gotson/komga/infrastructure/image · high confidence

The library section now features a redesigned user interface with dedicated pages for browsing books, series, collections, and readlists. Users can filter and sort content using a new drawer-based filter panel, adjust poster sizes, and switch between paged and infinite scroll modes. The overview page allows users to configure and reorder content sections, while the library creation flow has been updated to guide users through setting up their first library.

next-ui/src/pages/libraries · high confidence

The application now uses a centralized plugin registration system in \next-ui/src/plugins\ that initializes several key services. Vuetify has been upgraded to version 4.2.0 and configured with the MD3 blueprint, including specific light and dark theme colors and custom validation rules for ISBNs, URLs, and language codes. The UI now supports Right-to-Left (RTL) locales by dynamically loading the correct Vuetify locale and setting the RTL flag based on the current language. Additionally, the app integrates \@unhead/vue\ for head management and \vue-intl\ for internationalization, ensuring that locale-specific messages are loaded efficiently. Navigation guards for login, roles, and scroll behavior are also registered through this new plugin structure.

next-ui/src/plugins · high confidence

The read list editing experience now uses a dedicated dialog component featuring two tabs: 'General' for editing the name, summary, and ordering settings, and 'Poster' for managing cover images. A key usability improvement is the display of validation error counts directly on the tab headers, allowing users to quickly identify which section contains issues. The form also automatically resets to the General tab upon a failed submission attempt.

next-ui/src/components/readlist/form · high confidence

The router module has been rewritten to use Pinia Colada's query cache for authentication and navigation guards, replacing previous reactive query patterns. This change introduces dedicated guards for login, role-based access, claim status, and library view redirection, all of which now fetch user and library state via the shared query cache. Additionally, scroll position is now persisted per route path and restored on popstate navigation to prevent page jumping during filter or tab interactions, while a workaround for Vite dynamic import errors has been added to the router initialization.

next-ui/src/router · high confidence

The book editing interface has been replaced with a new tabbed form (Edit.vue) that organizes editing into General, Contributors, Tags, Links, and Poster tabs, with an additional Sharing tab for series. The General tab now conditionally displays fields based on whether the book is a 'oneshot': oneshots show a 'Title Sort' field and hide the 'Number' and 'Sort number' fields, while regular books show the number fields. The Contributors tab (Contributors.vue) allows dynamic management of author roles, including adding custom roles, and the Tags tab (Tags.vue) exposes genre selection for oneshots.

next-ui/src/components/book/form · high confidence

The \next-ui/src/functions\ directory now contains a collection of new utility modules that centralize common logic for the interface. These include entity type guards (\entity.ts\) and poster resolution helpers (\poster.ts\) to distinguish between books, series, collections, and readlists, as well as selection logic (\selection.ts\) to determine available actions for mixed entity types. Data handling is supported by array utilities (\array.ts\), file size formatting with locale awareness (\filesize.ts\), and comprehensive filter-to-condition converters (\filter.ts\) for the API. Additional helpers cover library state management (\libraries.ts\), series metadata updates (\series.ts\), custom sorting (\sort.ts\), user settings parsing (\user-settings.ts\), and clipboard image extraction (\clipboard.ts\).

next-ui/src/functions · high confidence

Added new custom validation annotations (BCP47, Blank, NullOrBlankOrBCP47, NullOrBlankOrISBN, NullOrNotBlank, NullOrNotEmpty) to the validation infrastructure. These annotations provide stricter and more specific validation rules for metadata fields, such as ensuring language tags are valid BCP 47 formats and ISBNs are valid ISBN-13, while also allowing null or blank values where appropriate. This enhances data integrity for metadata updates.

komga/src/main/kotlin/org/gotson/komga/infrastructure/validation · high confidence

The XML serialization infrastructure for OPDS v1 has been updated to enforce static namespace prefixes in the generated XML output. This change is implemented via a new \NamespaceXmlFactory\ and a corresponding Spring configuration bean that maps specific prefixes to their namespaces, ensuring consistent and predictable XML structure for OPDS clients.

komga/src/main/kotlin/org/gotson/komga/infrastructure/xml · high confidence

The OPDS v1.2 catalog endpoint now presents a reorganized navigation structure, introducing dedicated entries for 'Keep Reading' and 'On Deck' alongside existing 'All series' and 'Latest series' views. Additionally, the root catalog feed now includes an alternate link pointing to the OPDS v2 catalog, facilitating easier discovery and migration for clients supporting the newer protocol version.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v1 · high confidence

The PDF extraction logic in the \PdfExtractor\ service has been rewritten to use Apache PDFBox 3.0.1, replacing the previous implementation. This change updates how PDF pages are loaded, rendered as images, and extracted as individual PDF files, ensuring compatibility with the newer library version and potentially improving performance or stability for PDF media handling.

komga/src/main/kotlin/org/gotson/komga/infrastructure/mediacontainer/pdf · high confidence

The persistence layer for books, series, and related entities has been refactored from standard Spring Data JPA repositories to custom repository interfaces. This change replaces the previous \JpaRepository\ implementations with explicit method definitions for data access, introducing support for advanced search conditions, context-aware filtering, and specific operations like page hashing and thumbnail management. Users benefit from improved data retrieval capabilities and better integration with the application's search and synchronization features.

komga/src/main/kotlin/org/gotson/komga/domain/persistence · high confidence

The metadata infrastructure has been refactored to introduce distinct interfaces for book and series metadata providers. Book metadata is now handled via \BookMetadataProvider\, which exposes capabilities as a set and retrieves patches from \BookWithMedia\ objects. Series metadata is split into \SeriesMetadataProvider\ for general series data and \SeriesMetadataFromBookProvider\, which adds support for appending volume information to series titles. All providers now implement a common \MetadataProvider\ base interface that allows checking if a library handles specific metadata patch targets.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata · high confidence

The scheduler package has been refactored to use @Component instead of @Controller, and the legacy RootScannerController has been removed. New scheduled tasks have been added: AuthenticationActivityCleanupController now automatically deletes authentication activity records older than one month; InitialUserController creates default admin/user accounts on first startup in development mode; MetricsPublisherController publishes library, series, book, and task metrics to Micrometer; PeriodicScannerController handles library scans on startup and schedules periodic scans; and SearchIndexController manages Lucene index creation and upgrades on startup.

komga/src/main/kotlin/org/gotson/komga/interfaces/scheduler · high confidence

The application has migrated its underlying database from H2 to SQLite, introducing configurable connection pooling via HikariCP and allowing users to tune pool sizes and SQLite pragmas (such as journal mode and busy timeout) through configuration. This change also enables the separation of read and write connections when Write-Ahead Logging (WAL) is active to improve performance. Additionally, the new SQLite integration includes custom user-defined functions and collations to support accent-insensitive searching and improved Unicode sorting for library items.

komga/src/main/kotlin/org/gotson/komga/infrastructure/datasource · high confidence

The search infrastructure now includes ReadList entities in the Lucene index, ensuring that changes to readlists trigger an index rebuild so they become searchable. Additionally, the indexing process has been updated to use n-gram analysis, which allows users to find series and books by typing partial words or fragments rather than requiring exact full-word matches.

komga/src/main/kotlin/org/gotson/komga/infrastructure/search · high confidence

The system no longer strips accents from input data, which fixes an issue where series titles containing accented characters were not sorting correctly. By preserving the original Unicode characters, titles are now ordered according to proper Unicode collation rules, ensuring that items with diacritics appear in the expected position within lists.

komga/src/main/kotlin/org/gotson/komga/language · high confidence

The application now verifies that the temporary directory exists and is writable before starting, preventing runtime errors caused by missing or inaccessible temp paths. Additionally, jOOQ's startup logo and tips are suppressed in the logs to reduce visual noise.

komga/src/main/kotlin/org/gotson/komga · high confidence

The web interface now supports serving both the main and next UI versions. An IndexController has been added to handle root and next-page routes, explicitly passing the servlet context path as the base URL to ensure assets and links resolve correctly when the application is deployed under a custom base path. Additionally, a ResourceNotFoundController was introduced to intercept 404 errors, forwarding non-API requests to the index page to enable client-side routing while preserving standard 404 responses for API endpoints.

komga/src/main/kotlin/org/gotson/komga/interfaces/mvc · high confidence

Session handling is now centralized in a new configuration that replaces the previous custom session-timeout setting with the standard Spring Boot server.servlet.session.timeout property, allowing users to control session duration via a familiar configuration key. The system now supports both cookie-based and header-based (X-Auth-Token) authentication through a smart resolver, enabling more flexible integration for API clients. Additionally, session events are now logged for debugging purposes, and the session cookie is named KOMGA-SESSION for clarity.

komga/src/main/kotlin/org/gotson/komga/infrastructure/security/session · high confidence

3 commits adding/updating tests in komga/src/test/resources/archives; Added EPUB test fixtures for metadata parsing edge cases; Added REST API benchmark suite; Added architecture and coding rules tests; Added test utility for temporal assertions; Added tests for ComicInfo and ReadingList XML deserialization; Added tests for ComicRack metadata and read list providers; Added tests for EPUB metadata extraction; Added tests for ISBN barcode provider; Added tests for KOReader Sync API endpoints; Added tests for Kobo Sync API endpoints; Added tests for Kobo sync token generation and KEPUB conversion; Added tests for Mylar series.json DTO deserialization; Added tests for ResourceNotFoundController; Added tests for Unicode collation behavior; Added tests for background task processing and priority handling; Added tests for bracket parameter handling in request wrapper; Added tests for datasource configuration in WAL and memory modes; Added tests for local artwork provider thumbnail selection; Added tests for multi-datasource autowiring; Added tests for multilingual search analyzers and index lifecycle; Added tests for session and authentication cookie handling; Added unit tests for Mylar series metadata provider; Added unit tests for book spreads, TOC flattening, and page loading; Added unit tests for domain model classes; Added unit tests for domain service layer; Added unit tests for media container extractors and EPUB navigation parsing; Added unit tests for the JOOQ data access layer; Comprehensive MSW API mock suite for Next.js UI development; Expanded REST API test coverage.

The Gradle wrapper has been updated from version 5.5 to 9.6.1, requiring a download of the new distribution. Additionally, new configuration properties have been added to the wrapper settings: networkTimeout is set to 10000ms, retries are disabled (0), retryBackOffMs is set to 500ms, and URL validation is enabled via validateDistributionUrl=true.

gradle · high confidence

The project has restructured its build configuration by introducing a Gradle version catalog (gradle/libs.versions.toml) to centralize dependency management, replacing the previous inline version declarations. This change upgrades the core build tooling to Gradle 9.6.1 and Kotlin 2.4.10, while updating the Spring Boot framework to version 3.5.16. Additionally, the desktop application module (komga-tray) is now configured using the new catalog and JetBrains Compose 1.11.1, and the web UI packages (komga-webui and next-ui) have been initialized with their respective dependency manifests.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 53 → 55 (+2.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 80 → 79 (-0.9)
• Architecture 97 → 78 (-18.3)
• Maturity 64 → 67 (+2.7)
• Readiness 46 → 54 (+8.8)
• Security 52 → 57 (+5.2)
• Domain Modelling 70 → 70 (+0.0)
• Accessibility 62 → 50 (-12.0)

• Change coupling clique: BookDao.kt, SeriesDao.kt, SidecarDao.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/BookDao.kt)
• Change coupling clique: LibraryDao.kt, LibraryCreationDto.kt, LibraryDto.kt, LibraryUpdateDto.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/LibraryDao.kt)
• Change coupling: UsersList.vue ↔ komga-users.service.ts (komga-webui/src/components/UsersList.vue)
• Change coupling: router.ts ↔ StartupView.vue (komga-webui/src/router.ts)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (komga-webui/package-lock.json)
• Critical CVE: [GHSA redacted] (komga-webui/package-lock.json)
• Critical CVE: [GHSA redacted] (komga-webui/package-lock.json)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (komga/src/main/kotlin/org/gotson/komga/domain/service/BookConverter.kt)
• Duplicated block (10 lines × 2) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/BookDtoDao.kt)
• Duplicated block (10 lines × 2) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/BookDtoDao.kt)
• Duplicated block (10 lines × 2) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/HistoricalEventDtoDao.kt)
• Duplicated block (10 lines × 2) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/SeriesDtoDao.kt)
• Duplicated block (10 lines × 2) (komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v1/OpdsController.kt)
• Duplicated block (10 lines × 2) (komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v1/OpdsController.kt)
• Duplicated block (10 lines × 2) (komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v2/Opds2Controller.kt)
• Duplicated block (11 lines × 2) (komga/src/main/kotlin/org/gotson/komga/interfaces/api/kobo/KoboController.kt)
• Duplicated block (11 lines × 2) (komga/src/main/kotlin/org/gotson/komga/interfaces/api/kosync/KoreaderSyncController.kt)
• Duplicated block (11 lines × 2) (komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v1/OpdsController.kt)
• …and 113 more

• Change coupling: BookDao.kt ↔ SeriesDao.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/BookDao.kt)
• Change coupling: BookLifecycle.kt ↔ ThumbnailBookDao.kt (komga/src/main/kotlin/org/gotson/komga/domain/service/BookLifecycle.kt)
• Change coupling: ComicInfoProvider.kt ↔ EpubMetadataProvider.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/comicrack/ComicInfoProvider.kt)
• Change coupling: LibraryNavigation.vue ↔ router.ts (komga-webui/src/components/LibraryNavigation.vue)
• Change coupling: ReferentialDao.kt ↔ ReferentialV1Controller.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/ReferentialDao.kt)
• Change coupling: SeriesCollectionRepository.kt ↔ ReadListDao.kt (komga/src/main/kotlin/org/gotson/komga/domain/persistence/SeriesCollectionRepository.kt)
• Change coupling: ThumbnailBookDao.kt ↔ BookController.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/ThumbnailBookDao.kt)
• Change coupling: Utils.kt ↔ BookDtoDao.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/Utils.kt)
• Change coupling: Utils.kt ↔ SeriesDtoDao.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/Utils.kt)
• Change coupling: komga-referential.service.ts ↔ BrowseLibraries.vue (komga-webui/src/services/komga-referential.service.ts)
• Change coupling: komga-series.service.ts ↔ BrowseLibraries.vue (komga-webui/src/services/komga-series.service.ts)
• ClassTooLong: BookController (komga/src/main/kotlin/org/gotson/komga/interfaces/api/rest/BookController.kt)
• ClassTooLong: BookDtoDao (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/BookDtoDao.kt)
• ClassTooLong: KoboController (komga/src/main/kotlin/org/gotson/komga/interfaces/api/kobo/KoboController.kt)
• ClassTooLong: Opds2Controller (komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v2/Opds2Controller.kt)
• ClassTooLong: OpdsController (komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v1/OpdsController.kt)
• ClassTooLong: ReferentialDao (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/ReferentialDao.kt)
• ClassTooLong: SeriesController (komga/src/main/kotlin/org/gotson/komga/interfaces/api/rest/SeriesController.kt)
• ClassTooLong: SyncPointDao (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/SyncPointDao.kt)
• Coverage not measured — JavaScript/TypeScript suite
• …and 224 more

• 225 commits — 182 feature/other, 43 fixes

• next-ui/src — 78 commits
• next-ui/i18n — 35 commits
• komga-webui/src — 20 commits
• komga/src — 15 commits
• (root) — 14 commits
• .github/workflows — 13 commits
• komga/build.gradle.kts — 12 commits
• komga-webui/package-lock.json — 10 commits
• komga-tray/src — 7 commits
• next-ui/package-lock.json — 6 commits
• gradle/libs.versions.toml — 2 commits
• komga-tray/build.gradle.kts — 2 commits
• next-ui/.storybook — 2 commits
• next-ui/openapi-ts.config.ts — 2 commits
• .github/ISSUE_TEMPLATE — 1 commit
• komga-tray/AGENTS.md — 1 commit
• komga-tray/conveyor — 1 commit
• next-ui/.prettierignore — 1 commit
• next-ui/AGENTS.md — 1 commit
• next-ui/i18n-clean-empty.config.ts — 1 commit

• fix: build: fix gradle warning
• fix: fix(api): add missing restrictions checks
• fix: fix(api): missing restrictions on some readlist endpoints
• fix: fix(kobo): allow proxy requests without raw sync token
• fix: fix(kobo): prevent Kobo from re-downloading books if the metadata changed
• fix: fix(komga): epub with images in svg not detected as divina
• fix: fix(komga): missing nextui css layers when serving from tomcat
• fix: fix(nextui): better handling of dialog callback
• fix: fix(nextui): better justify poster on entity view page
• fix: fix(nextui): better tooltips on mobile
• fix: fix(nextui): card text would be cut off short
• fix: fix(nextui): change color of selection footer
• fix: fix(nextui): change label for directory browser confirmation button
• fix: fix(nextui): correct toolbar alignment
• fix: fix(nextui): disable selection for already updated unknown page hash
• fix: fix(nextui): disallow book upgrade selection for oneshot series
• fix: fix(nextui): display file format in book view
• fix: fix(nextui): display sharing labels in Book and Series view
• fix: fix(nextui): do not prepend on deck book number with # on series view
• fix: fix(nextui): don't show perpetual loading after assigning an action to an unknown page hash
• …and 205 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

gotson/komga was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.