@itsmrtr/bunkoshelf 1.11.6 → 1.12.0

package/dist/src/components/library/manga/VolumesContent.tsx

@@ -59,6 +59,9 @@ export default function VolumesContent({
   const isOneshot = series?.isOneshot === true;
   const seriesTitle = series?.title as string | undefined;
   const seriesSlug = series?.slug as string | undefined;
+  const seriesLabel = section === "others"
+    ? (intl.libraries.otherCollection as string)
+    : (intl.manga.series as string);
 
   const ageMin = ageRatingMap(meta.ageRating as string);
   const badgeClass = `text-sm uppercase rounded-md px-3 py-1 mr-2 ${
@@ -108,7 +111,7 @@ export default function VolumesContent({
                 href={`/${lang}/${section}/${seriesSlug}`}
                 className="italic hover:underline"
               >
-                {intl.manga.series as string} {(meta.series as string) || seriesTitle}
+                {seriesLabel} {(meta.series as string) || seriesTitle}
               </Link>
             </div>
           )}

package/dist/src/components/library/manga/grid/SeriesIndex.tsx

@@ -90,7 +90,9 @@ export default async function SeriesIndex({
       <div className="flex items-center mb-4">
         <h2 className="flex items-center text-base md:text-lg mr-4">
           <LibraryBigIcon size={28} className="mr-2" />
-          {intl.manga.allSeries as string}
+          {section === "others"
+            ? (intl.libraries.allOtherCollections as string)
+            : (intl.manga.allSeries as string)}
         </h2>
 
         <FiltersDrawer intl={intl} scope={scope} />
@@ -110,7 +112,7 @@ export default async function SeriesIndex({
               title={
                 isOneshot
                   ? firstVolume?.meta?.title ?? firstVolume?.title ?? entry.title
-                  : firstVolume?.meta?.series ?? entry.title
+                  : firstVolume?.meta?.series ?? firstVolume?.title ?? entry.title
               }
               href={
                 isOneshot && firstVolume
@@ -122,6 +124,7 @@ export default async function SeriesIndex({
               onGoing={!isOneshot && entry.status === "ONGOING"}
               onPause={!isOneshot && entry.status === "HIATUS"}
               volumeCount={isOneshot ? null : totalVolumes}
+              countLabel={section === "others" ? intl.libraries.otherWorks as string : undefined}
               cover={entry.coverImage}
               progressRatio={progressRatio}
               isDragging={false}

package/dist/src/components/library/manga/grid/SeriesIndexFav.tsx

@@ -122,6 +122,7 @@ export default async function SeriesIndexFav({
               onGoing={entry.status === "ONGOING"}
               onPause={entry.status === "HIATUS"}
               volumeCount={isSeries ? totalVolumes : null}
+              countLabel={section === "others" ? intl.libraries.otherWorks as string : undefined}
               cover={entry.coverImage}
               progressRatio={progressRatio}
               isDragging={false}

package/dist/src/components/library/manga/grid/VolumesIndex.tsx

@@ -73,7 +73,9 @@ export default async function VolumesIndex({
       <div className="flex items-center mb-4">
         <h2 className="flex items-center text-base md:text-lg mr-4">
           <BookCopyIcon size={28} className="mr-2" />
-          {intl.manga.allVolumes as string}
+          {section === "others"
+            ? (intl.libraries.allOtherWorks as string)
+            : (intl.manga.allVolumes as string)}
         </h2>
 
         <FiltersDrawer intl={intl} scope={scope} />
@@ -87,7 +89,7 @@ export default async function VolumesIndex({
           return (
             <MangaCard
               key={entry.title}
-              title={entry.meta?.title}
+              title={entry.meta?.title ?? entry.title}
               href={href}
               isSeries={false}
               isOneshot={entry.isOneshot}

package/dist/src/components/settings/UploadMangaForm.tsx

@@ -121,6 +121,7 @@ export default function UploadMangaForm({ intl, lang }: UploadMangaFormProps) {
 
     for (let i = 0; i < acceptedFiles.length; i++) {
       const file = acceptedFiles[i];
+      if (file.name.toLowerCase().endsWith(".epub")) continue;
       try {
         const result = await extractFromArchive(file);
 
@@ -526,6 +527,7 @@ export default function UploadMangaForm({ intl, lang }: UploadMangaFormProps) {
                 "application/pdf": [".pdf"],
                 "application/zip": [".zip", ".cbz"],
                 "application/x-rar-compressed": [".rar", ".cbr"],
+                ...(libraryType === "others" ? { "application/epub+zip": [".epub"] } : {}),
               }}
           intl={intl}
         />

package/dist/src/lib/books/epubParser.ts

@@ -24,8 +24,12 @@ function xmlText(value: XmlValue | undefined): string | null {
   return value?._?.trim() || null;
 }
 
-function attrs(value: XmlValue | undefined): Record<string, string> {
-  return typeof value === "object" && value ? value.$ ?? {} : {};
+function attrs(value: unknown): Record<string, string> {
+  if (!value || typeof value !== "object" || !("$" in value)) return {};
+  const attributes = value.$;
+  return attributes && typeof attributes === "object" && !Array.isArray(attributes)
+    ? attributes as Record<string, string>
+    : {};
 }
 
 function firstText(record: XmlRecord, name: string): string | null {
@@ -259,6 +263,7 @@ function parseMetadata(packagePath: string, parsed: Record<string, unknown>): Ep
   const namedMeta = namedMetaValues(metadata);
   const collection = parseCollection(metadata, namedMeta);
   const { title, subtitle } = parseTitles(metadata);
+  const epubVersion = attrs(pkg).version?.trim().split(".")[0];
 
   return {
     title,
@@ -270,6 +275,7 @@ function parseMetadata(packagePath: string, parsed: Record<string, unknown>): Ep
     rights: firstText(metadata, "dc:rights"),
     source: firstText(metadata, "dc:source"),
     publicationType: rendition.get("schema:bookFormat") ?? firstText(metadata, "dc:type"),
+    epubVersion: epubVersion === "2" || epubVersion === "3" ? epubVersion : null,
     ageRating: normalizeBookAgeRating(rendition.get("schema:typicalAgeRange")
       ?? rendition.get("schema:contentRating")
       ?? rendition.get("schema:audience")

package/dist/src/lib/books/indexer.ts

@@ -2,6 +2,7 @@ import path from "node:path";
 import { parseEpubBuffer } from "./epubParser";
 import { readBookFile } from "./storage";
 import { upsertBook } from "@/lib/db/books/library";
+import type { ComicMetadata } from "@/lib/types/manga";
 
 export function toBookSlug(value: string): string {
   return value.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase()
@@ -16,6 +17,7 @@ export async function indexBook(input: {
   size: number;
   mtime: Date;
   isOneshot?: boolean;
+  librarySection?: "books" | "other";
 }) {
   if (path.extname(input.filename).toLowerCase() !== ".epub") {
     throw new Error("Only .epub files are supported in Books");
@@ -24,7 +26,34 @@ export async function indexBook(input: {
   const collection = parsed.metadata.collection;
   const folderSeriesTitle = input.seriesName.replace(/\[oneshot\]/gi, "").trim();
   const seriesTitle = collection?.title || folderSeriesTitle || parsed.metadata.title;
-  return upsertBook({
+  const comicMetadata: ComicMetadata = {
+    series: seriesTitle,
+    title: parsed.metadata.title,
+    number: collection?.position ?? null,
+    count: null,
+    publisher: parsed.metadata.publisher,
+    imprint: null,
+    languageISO: parsed.metadata.language,
+    format: "EPUB",
+    ageRating: parsed.metadata.ageRating,
+    communityRating: null,
+    writer: parsed.metadata.people.filter((person) => person.kind === "creator").map((person) => person.name).join(", ") || null,
+    penciller: null,
+    inker: null,
+    colorist: null,
+    letterer: null,
+    coverArtist: null,
+    editor: null,
+    summary: parsed.metadata.description,
+    web: null,
+    pageCount: null,
+    year: parsed.metadata.publishedAt ? Number.parseInt(parsed.metadata.publishedAt, 10) || null : null,
+    month: null,
+    day: null,
+    gtin: parsed.metadata.identifiers.find((identifier) => identifier.isPrimary)?.value ?? null,
+    mangaStyle: "No",
+  };
+  const book = await upsertBook({
     seriesTitle,
     seriesPath: input.seriesPath,
     isOneshot: collection ? false : input.isOneshot ?? /\[oneshot\]/i.test(input.seriesName),
@@ -37,5 +66,7 @@ export async function indexBook(input: {
     size: input.size,
     mtime: input.mtime,
     metadata: parsed.metadata,
+    librarySection: input.librarySection ?? "books",
   });
+  return { book, comicMetadata, genres: parsed.metadata.subjects.map((subject) => subject.name) };
 }

package/dist/src/lib/books/types.ts

@@ -33,6 +33,7 @@ export interface EpubMetadata {
   rights: string | null;
   source: string | null;
   publicationType: string | null;
+  epubVersion: "2" | "3" | null;
   ageRating: string | null;
   modifiedAt: string | null;
   packagePath: string;

package/dist/src/lib/db/books/library.ts

@@ -3,6 +3,8 @@ import { buildNaturalSortKey } from "@/lib/naturalSort";
 import type { EpubMetadata } from "@/lib/books/types";
 import { execute, query, queryOne } from "../query";
 
+export type BookLibrarySection = "books" | "other";
+
 export interface BookSeries {
   id: string;
   slug: string;
@@ -11,6 +13,7 @@ export interface BookSeries {
   isOneshot: boolean;
   status: string;
   collectionType: "series" | "set" | null;
+  librarySection: BookLibrarySection;
 }
 
 export interface BookVolume {
@@ -44,6 +47,7 @@ interface BookRow {
   series_is_oneshot: boolean;
   series_status: string;
   series_collection_type: "series" | "set" | null;
+  series_library_section: BookLibrarySection;
   metadata_id: string;
   metadata_title: string;
   metadata_subtitle: string | null;
@@ -54,6 +58,7 @@ interface BookRow {
   metadata_rights: string | null;
   metadata_source: string | null;
   metadata_publication_type: string | null;
+  metadata_epub_version: "2" | "3" | null;
   metadata_age_rating: string | null;
   metadata_modified_at: string | null;
   metadata_package_path: string;
@@ -84,6 +89,7 @@ function mapBook(row: BookRow): BookVolume {
       isOneshot: row.series_is_oneshot,
       status: row.series_status,
       collectionType: row.series_collection_type,
+      librarySection: row.series_library_section,
     },
     metadata: {
       id: row.metadata_id,
@@ -96,6 +102,7 @@ function mapBook(row: BookRow): BookVolume {
       rights: row.metadata_rights,
       source: row.metadata_source,
       publicationType: row.metadata_publication_type,
+      epubVersion: row.metadata_epub_version,
       ageRating: row.metadata_age_rating,
       modifiedAt: row.metadata_modified_at,
       packagePath: row.metadata_package_path,
@@ -119,11 +126,13 @@ const BOOK_SELECT = `
     bv.size::text AS volume_size, bv.cover_image AS volume_cover_image, bv.number AS volume_number, bv.created_at AS volume_created_at,
     bs.id AS series_id, bs.slug AS series_slug, bs.title AS series_title, bs.path AS series_path,
     bs.is_oneshot AS series_is_oneshot, bs.status AS series_status, bs.collection_type AS series_collection_type,
+    bs.library_section AS series_library_section,
     bm.id AS metadata_id, bm.title AS metadata_title, bm.subtitle AS metadata_subtitle,
     bm.description AS metadata_description, bm.publisher AS metadata_publisher,
     bm.published_at AS metadata_published_at, bm.language AS metadata_language,
     bm.rights AS metadata_rights, bm.source AS metadata_source,
-    bm.publication_type AS metadata_publication_type, bm.age_rating AS metadata_age_rating,
+    bm.publication_type AS metadata_publication_type, bm.epub_version AS metadata_epub_version,
+    bm.age_rating AS metadata_age_rating,
     bm.modified_at AS metadata_modified_at,
     bm.package_path AS metadata_package_path, bm.navigation_path AS metadata_navigation_path,
     bm.cover_path AS metadata_cover_path, bm.rendition_layout AS metadata_rendition_layout,
@@ -161,14 +170,15 @@ export async function upsertBook(input: {
   size: number;
   mtime: Date;
   metadata: EpubMetadata;
+  librarySection: BookLibrarySection;
 }): Promise<BookVolume> {
   const series = await queryOne<{ id: string }>(`
-    INSERT INTO book_series (id, slug, title, sort_title, path, is_oneshot, collection_type, mtime)
-    VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+    INSERT INTO book_series (id, slug, title, sort_title, path, is_oneshot, collection_type, mtime, library_section)
+    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
     ON CONFLICT (slug) DO UPDATE SET title = EXCLUDED.title, sort_title = EXCLUDED.sort_title,
       path = EXCLUDED.path, is_oneshot = EXCLUDED.is_oneshot, collection_type = EXCLUDED.collection_type,
-      mtime = EXCLUDED.mtime, updated_at = NOW()
-    RETURNING id`, [createId(), input.seriesSlug, input.seriesTitle, buildNaturalSortKey(input.seriesTitle), input.seriesPath, input.isOneshot, input.collectionType, input.mtime]);
+      mtime = EXCLUDED.mtime, library_section = EXCLUDED.library_section, updated_at = NOW()
+    RETURNING id`, [createId(), input.seriesSlug, input.seriesTitle, buildNaturalSortKey(input.seriesTitle), input.seriesPath, input.isOneshot, input.collectionType, input.mtime, input.librarySection]);
   if (!series) throw new Error("Failed to create book series");
 
   const volume = await queryOne<{ id: string }>(`
@@ -182,18 +192,19 @@ export async function upsertBook(input: {
   if (!volume) throw new Error("Failed to create book volume");
 
   const metadata = await queryOne<{ id: string }>(`
-    INSERT INTO book_metadata (id, volume_id, title, subtitle, description, publisher, published_at, language, rights, source, publication_type, age_rating, modified_at, package_path, navigation_path, cover_path, rendition_layout, rendition_flow, rendition_orientation, rendition_spread)
-    VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20)
+    INSERT INTO book_metadata (id, volume_id, title, subtitle, description, publisher, published_at, language, rights, source, publication_type, epub_version, age_rating, modified_at, package_path, navigation_path, cover_path, rendition_layout, rendition_flow, rendition_orientation, rendition_spread)
+    VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21)
     ON CONFLICT (volume_id) DO UPDATE SET title=EXCLUDED.title, subtitle=EXCLUDED.subtitle, description=EXCLUDED.description,
       publisher=EXCLUDED.publisher, published_at=EXCLUDED.published_at, language=EXCLUDED.language, rights=EXCLUDED.rights,
-      source=EXCLUDED.source, publication_type=EXCLUDED.publication_type, age_rating=EXCLUDED.age_rating,
+      source=EXCLUDED.source, publication_type=EXCLUDED.publication_type, epub_version=EXCLUDED.epub_version,
+      age_rating=EXCLUDED.age_rating,
       modified_at=EXCLUDED.modified_at,
       package_path=EXCLUDED.package_path, navigation_path=EXCLUDED.navigation_path, cover_path=EXCLUDED.cover_path,
       rendition_layout=EXCLUDED.rendition_layout, rendition_flow=EXCLUDED.rendition_flow,
       rendition_orientation=EXCLUDED.rendition_orientation, rendition_spread=EXCLUDED.rendition_spread, updated_at=NOW()
     RETURNING id`, [createId(), volume.id, input.metadata.title, input.metadata.subtitle, input.metadata.description,
     input.metadata.publisher, input.metadata.publishedAt, input.metadata.language, input.metadata.rights, input.metadata.source,
-    input.metadata.publicationType, input.metadata.ageRating, input.metadata.modifiedAt, input.metadata.packagePath,
+    input.metadata.publicationType, input.metadata.epubVersion, input.metadata.ageRating, input.metadata.modifiedAt, input.metadata.packagePath,
     input.metadata.navigationPath, input.metadata.coverPath, input.metadata.renditionLayout, input.metadata.renditionFlow,
     input.metadata.renditionOrientation, input.metadata.renditionSpread]);
   if (!metadata) throw new Error("Failed to save book metadata");
@@ -238,10 +249,14 @@ export async function listBookVolumes(options?: {
   seriesSlug?: string;
   authorNames?: string[];
   limit?: number;
+  librarySection?: BookLibrarySection;
 }): Promise<BookVolume[]> {
   const params: unknown[] = [];
   const conditions: string[] = [];
 
+  params.push(options?.librarySection ?? "books");
+  conditions.push(`bs.library_section = $${params.length}`);
+
   if (options?.seriesSlug) {
     params.push(options.seriesSlug);
     conditions.push(`bs.slug = $${params.length}`);
@@ -282,8 +297,8 @@ export async function listBookVolumes(options?: {
   return Promise.all(rows.map((row) => hydrateMetadata(mapBook(row))));
 }
 
-export async function listRecentlyAddedBooks(limit = 8): Promise<BookVolume[]> {
-  const rows = await query<BookRow>(`${BOOK_SELECT} ORDER BY bv.created_at DESC LIMIT $1`, [limit]);
+export async function listRecentlyAddedBooks(limit = 8, librarySection: BookLibrarySection = "books"): Promise<BookVolume[]> {
+  const rows = await query<BookRow>(`${BOOK_SELECT} WHERE bs.library_section = $1 ORDER BY bv.created_at DESC LIMIT $2`, [librarySection, limit]);
   return Promise.all(rows.map((row) => hydrateMetadata(mapBook(row))));
 }
 
@@ -291,15 +306,16 @@ export async function listFavoriteBookSeries(userId: string, options: { page: nu
   const count = await queryOne<{ count: string }>(`
     SELECT COUNT(*)::text AS count
     FROM user_to_book_series ubs
-    WHERE ubs.user_id = $1 AND ubs.is_favorite = TRUE`, [userId]);
+    INNER JOIN book_series bs ON bs.id = ubs.series_id
+    WHERE ubs.user_id = $1 AND ubs.is_favorite = TRUE AND bs.library_section = 'books'`, [userId]);
   const total = Number(count?.count ?? "0");
   const offset = Math.max(0, options.page - 1) * options.pageSize;
   const series = await query<BookSeries>(`
     SELECT bs.id, bs.slug, bs.title, bs.path, bs.is_oneshot AS "isOneshot", bs.status,
-      bs.collection_type AS "collectionType"
+      bs.collection_type AS "collectionType", bs.library_section AS "librarySection"
     FROM book_series bs
     INNER JOIN user_to_book_series ubs ON ubs.series_id = bs.id
-    WHERE ubs.user_id = $1 AND ubs.is_favorite = TRUE
+    WHERE ubs.user_id = $1 AND ubs.is_favorite = TRUE AND bs.library_section = 'books'
     ORDER BY bs.sort_title
     LIMIT $2 OFFSET $3`, [userId, options.pageSize, offset]);
   const items = await Promise.all(series.map(async (entry) => ({
@@ -313,13 +329,15 @@ export async function listFavoriteBookSeries(userId: string, options: { page: nu
 export async function listFavoriteBookVolumes(userId: string, options: { page: number; pageSize: number }) {
   const count = await queryOne<{ count: string }>(`
     SELECT COUNT(*)::text AS count
-    FROM user_to_books
-    WHERE user_id = $1 AND is_favorite = TRUE`, [userId]);
+    FROM user_to_books ub
+    INNER JOIN book_volumes bv ON bv.id = ub.volume_id
+    INNER JOIN book_series bs ON bs.id = bv.series_id
+    WHERE ub.user_id = $1 AND ub.is_favorite = TRUE AND bs.library_section = 'books'`, [userId]);
   const total = Number(count?.count ?? "0");
   const offset = Math.max(0, options.page - 1) * options.pageSize;
   const rows = await query<BookRow>(`${BOOK_SELECT}
     INNER JOIN user_to_books ub ON ub.volume_id = bv.id
-    WHERE ub.user_id = $1 AND ub.is_favorite = TRUE
+    WHERE ub.user_id = $1 AND ub.is_favorite = TRUE AND bs.library_section = 'books'
     ORDER BY bs.sort_title, bv.number NULLS LAST, bv.sort_title
     LIMIT $2 OFFSET $3`, [userId, options.pageSize, offset]);
   const items = await Promise.all(rows.map((row) => hydrateMetadata(mapBook(row))));
@@ -327,12 +345,12 @@ export async function listFavoriteBookVolumes(userId: string, options: { page: n
   return { items, total, totalPages: Math.max(1, Math.ceil(total / options.pageSize)) };
 }
 
-export async function listBooksInProgress(userId: string, limit = 12): Promise<Array<BookVolume & { progression: number; lastReadAt: Date | null }>> {
+export async function listBooksInProgress(userId: string, limit = 12, librarySection: BookLibrarySection = "books"): Promise<Array<BookVolume & { progression: number; lastReadAt: Date | null }>> {
   const select = BOOK_SELECT.replace("  FROM book_volumes", "  , ub.progression, ub.last_read_at\n  FROM book_volumes");
   const rows = await query<BookRow & { progression: number; last_read_at: Date | null }>(`${select}
     INNER JOIN user_to_books ub ON ub.volume_id = bv.id
-    WHERE ub.user_id = $1 AND ub.cfi IS NOT NULL AND ub.is_read = FALSE
-    ORDER BY ub.last_read_at DESC NULLS LAST LIMIT $2`, [userId, limit]);
+    WHERE ub.user_id = $1 AND ub.cfi IS NOT NULL AND ub.is_read = FALSE AND bs.library_section = $2
+    ORDER BY ub.last_read_at DESC NULLS LAST LIMIT $3`, [userId, librarySection, limit]);
   const books = await Promise.all(rows.map((row) => hydrateMetadata(mapBook(row))));
   return books.map((book, index) => ({
     ...book,
@@ -357,13 +375,14 @@ export async function listBookProgressByIds(userId: string, volumeIds: string[])
 
 export async function getBookReaderStats(userId: string): Promise<{ totalVolumes: number; totalSeries: number; totalUnread: number }> {
   const [volumes, series, unread] = await Promise.all([
-    queryOne<{ count: string }>("SELECT COUNT(*)::text AS count FROM book_volumes"),
-    queryOne<{ count: string }>("SELECT COUNT(*)::text AS count FROM book_series WHERE is_oneshot = FALSE"),
+    queryOne<{ count: string }>("SELECT COUNT(*)::text AS count FROM book_volumes bv INNER JOIN book_series bs ON bs.id = bv.series_id WHERE bs.library_section = 'books'"),
+    queryOne<{ count: string }>("SELECT COUNT(*)::text AS count FROM book_series WHERE is_oneshot = FALSE AND library_section = 'books'"),
     queryOne<{ count: string }>(`
       SELECT COUNT(*)::text AS count
       FROM book_volumes bv
       LEFT JOIN user_to_books ub ON ub.volume_id = bv.id AND ub.user_id = $1
-      WHERE COALESCE(ub.is_read, FALSE) = FALSE`, [userId]),
+      INNER JOIN book_series bs ON bs.id = bv.series_id
+      WHERE COALESCE(ub.is_read, FALSE) = FALSE AND bs.library_section = 'books'`, [userId]),
   ]);
 
   return {
@@ -376,7 +395,7 @@ export async function getBookReaderStats(userId: string): Promise<{ totalVolumes
 export async function listRecentlyReadBooks(userId: string, limit = 12): Promise<BookVolume[]> {
   const rows = await query<BookRow>(`${BOOK_SELECT}
     INNER JOIN user_to_books ub ON ub.volume_id = bv.id
-    WHERE ub.user_id = $1 AND ub.is_read = TRUE AND ub.last_read_at IS NOT NULL
+    WHERE ub.user_id = $1 AND ub.is_read = TRUE AND ub.last_read_at IS NOT NULL AND bs.library_section = 'books'
     ORDER BY ub.last_read_at DESC LIMIT $2`, [userId, limit]);
   return Promise.all(rows.map((row) => hydrateMetadata(mapBook(row))));
 }
@@ -384,23 +403,24 @@ export async function listRecentlyReadBooks(userId: string, limit = 12): Promise
 export async function listBookSeries(): Promise<Array<BookSeries & { volumeCount: number }>> {
   return query<BookSeries & { volumeCount: number }>(`
     SELECT bs.id, bs.slug, bs.title, bs.path, bs.is_oneshot AS "isOneshot", bs.status,
-      bs.collection_type AS "collectionType",
+      bs.collection_type AS "collectionType", bs.library_section AS "librarySection",
       COUNT(bv.id)::int AS "volumeCount"
     FROM book_series bs LEFT JOIN book_volumes bv ON bv.series_id = bs.id
+    WHERE bs.library_section = 'books'
     GROUP BY bs.id ORDER BY bs.sort_title`);
 }
 
 export async function findBookSeriesBySlug(slug: string): Promise<BookSeries | null> {
   return queryOne<BookSeries>(`
     SELECT id, slug, title, path, is_oneshot AS "isOneshot", status,
-      collection_type AS "collectionType"
+      collection_type AS "collectionType", library_section AS "librarySection"
     FROM book_series WHERE slug = $1 LIMIT 1`, [slug]);
 }
 
 export async function findBookSeriesById(id: string): Promise<BookSeries | null> {
   return queryOne<BookSeries>(`
     SELECT id, slug, title, path, is_oneshot AS "isOneshot", status,
-      collection_type AS "collectionType"
+      collection_type AS "collectionType", library_section AS "librarySection"
     FROM book_series WHERE id = $1 LIMIT 1`, [id]);
 }
 

package/dist/src/lib/db/migrations/010_book_metadata_epub_version.sql

@@ -0,0 +1,2 @@
+ALTER TABLE book_metadata
+  ADD COLUMN IF NOT EXISTS epub_version TEXT;

package/dist/src/lib/db/migrations/011_book_series_library_section.sql

@@ -0,0 +1,12 @@
+ALTER TABLE book_series
+  ADD COLUMN IF NOT EXISTS library_section TEXT NOT NULL DEFAULT 'books';
+
+ALTER TABLE book_series
+  DROP CONSTRAINT IF EXISTS book_series_library_section_check;
+
+ALTER TABLE book_series
+  ADD CONSTRAINT book_series_library_section_check
+  CHECK (library_section IN ('books', 'other'));
+
+CREATE INDEX IF NOT EXISTS book_series_library_section_idx
+  ON book_series (library_section);

package/dist/src/lib/i18n/dictionaries/en/libraries.json

@@ -7,6 +7,10 @@
     "comicIssues": "Issues",
     "otherCollections": "Collections",
     "otherWorks": "Works",
+    "otherCollection": "Collection:",
+    "allOtherCollections": "Collections (All)",
+    "allOtherWorks": "Works (All)",
+    "otherCollectionWorks": "Works in the collection",
     "readList": "Read List",
     "keepReading": "Keep Reading",
     "noActiveReading": "No active reading",

package/dist/src/lib/i18n/dictionaries/es/libraries.json

@@ -7,6 +7,10 @@
     "comicIssues": "Números",
     "otherCollections": "Colecciones",
     "otherWorks": "Obras",
+    "otherCollection": "Colección:",
+    "allOtherCollections": "Colecciones (todas)",
+    "allOtherWorks": "Obras (todas)",
+    "otherCollectionWorks": "Obras de la colección",
     "readList": "Lista de lectura",
     "keepReading": "Seguir leyendo",
     "noActiveReading": "No hay lectura activa",

package/dist/src/lib/jobs/scan/books/index.ts

@@ -4,8 +4,14 @@ import { ListObjectsV2Command } from "@aws-sdk/client-s3";
 import r2Client, { R2_BUCKET } from "@/lib/r2";
 import { indexBook } from "@/lib/books/indexer";
 import { getBookChecksums, removeMissingBooks, saveBookChecksum } from "@/lib/db/books/library";
+import { indexUploadedVolume } from "@/lib/uploadIndexer";
+import { revalidateMangaLibraryCache } from "@/lib/mangaLibraryCache";
 
-const ROOT = path.resolve(process.cwd(), "../library/books");
+const LIBRARY_ROOT = path.resolve(process.cwd(), "../library");
+const SOURCES = [
+  { directory: "books", librarySection: "books" as const },
+  { directory: "others", librarySection: "other" as const },
+];
 
 export async function scanBooks(): Promise<{ indexed: number; errors: string[] }> {
   const errors: string[] = [];
@@ -13,45 +19,83 @@ export async function scanBooks(): Promise<{ indexed: number; errors: string[] }
   const knownChecksums = await getBookChecksums();
   const existingPaths = new Set<string>();
   if ((process.env.LIB_PROVIDER || "local") === "cloud") {
-    const response = await r2Client.send(new ListObjectsV2Command({ Bucket: R2_BUCKET, Prefix: "library/books/" }));
-    for (const item of response.Contents ?? []) {
-      if (!item.Key?.toLowerCase().endsWith(".epub")) continue;
-      const relative = item.Key.replace(/^library\/books\//, "");
-      const fullPath = `/${item.Key}`;
-      existingPaths.add(fullPath);
-      const checksum = `${item.ETag ?? ""}:${item.Size ?? 0}:${item.LastModified?.getTime() ?? 0}`;
-      if (knownChecksums.get(fullPath) === checksum) continue;
-      try {
-        const directory = path.posix.dirname(relative);
-        const seriesPath = directory === "." ? "/library/books" : `/library/books/${directory}`;
-        const seriesName = directory === "." ? "books" : path.posix.basename(directory);
-        await indexBook({ fullPath, filename: path.posix.basename(relative), seriesPath,
-          seriesName, size: item.Size ?? 0, mtime: item.LastModified ?? new Date() });
-        await saveBookChecksum(fullPath, checksum);
-        indexed++;
-      } catch (error) { errors.push(`${item.Key}: ${(error as Error).message}`); }
+    for (const source of SOURCES) {
+      const prefix = `library/${source.directory}/`;
+      const response = await r2Client.send(new ListObjectsV2Command({ Bucket: R2_BUCKET, Prefix: prefix }));
+      for (const item of response.Contents ?? []) {
+        if (!item.Key?.toLowerCase().endsWith(".epub")) continue;
+        const relative = item.Key.replace(prefix, "");
+        const fullPath = `/${item.Key}`;
+        existingPaths.add(fullPath);
+        const checksum = `${item.ETag ?? ""}:${item.Size ?? 0}:${item.LastModified?.getTime() ?? 0}`;
+        if (knownChecksums.get(fullPath) === checksum) continue;
+        try {
+          const directory = path.posix.dirname(relative);
+          const seriesPath = directory === "." ? `/${prefix.slice(0, -1)}` : `/${prefix}${directory}`;
+          const seriesName = directory === "." ? source.directory : path.posix.basename(directory);
+          const result = await indexBook({ fullPath, filename: path.posix.basename(relative), seriesPath,
+            seriesName, size: item.Size ?? 0, mtime: item.LastModified ?? new Date(), librarySection: source.librarySection });
+          if (source.librarySection === "other") {
+            await indexUploadedVolume({
+              fileName: path.posix.basename(relative),
+              fullPath,
+              dirName: seriesName,
+              seriesPath,
+              isOneshot: /\[oneshot\]/i.test(seriesName),
+              coverFilename: null,
+              metadata: result.comicMetadata,
+              genres: result.genres,
+              tags: [],
+              fileSize: item.Size ?? 0,
+              librarySection: "other",
+            });
+          }
+          await saveBookChecksum(fullPath, checksum);
+          indexed++;
+        } catch (error) { errors.push(`${item.Key}: ${(error as Error).message}`); }
+      }
     }
     await removeMissingBooks(existingPaths);
+    revalidateMangaLibraryCache();
     return { indexed, errors };
   }
-  await fs.mkdir(ROOT, { recursive: true });
-  const directories = await fs.readdir(ROOT, { withFileTypes: true });
-  for (const directory of directories.filter((entry) => entry.isDirectory())) {
-    const seriesPath = path.join(ROOT, directory.name);
-    const files = await fs.readdir(seriesPath, { withFileTypes: true });
-    for (const file of files.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".epub"))) {
-      const fullPath = path.join(seriesPath, file.name);
-      existingPaths.add(fullPath);
-      try {
-        const stat = await fs.stat(fullPath);
-        const checksum = `${stat.size}:${stat.mtimeMs}`;
-        if (knownChecksums.get(fullPath) === checksum) continue;
-        await indexBook({ fullPath, filename: file.name, seriesPath, seriesName: directory.name, size: stat.size, mtime: stat.mtime });
-        await saveBookChecksum(fullPath, checksum);
-        indexed++;
-      } catch (error) { errors.push(`${fullPath}: ${(error as Error).message}`); }
+  for (const source of SOURCES) {
+    const root = path.join(LIBRARY_ROOT, source.directory);
+    await fs.mkdir(root, { recursive: true });
+    const directories = await fs.readdir(root, { withFileTypes: true });
+    for (const directory of directories.filter((entry) => entry.isDirectory())) {
+      const seriesPath = path.join(root, directory.name);
+      const files = await fs.readdir(seriesPath, { withFileTypes: true });
+      for (const file of files.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".epub"))) {
+        const fullPath = path.join(seriesPath, file.name);
+        existingPaths.add(fullPath);
+        try {
+          const stat = await fs.stat(fullPath);
+          const checksum = `${stat.size}:${stat.mtimeMs}`;
+          if (knownChecksums.get(fullPath) === checksum) continue;
+          const result = await indexBook({ fullPath, filename: file.name, seriesPath, seriesName: directory.name, size: stat.size, mtime: stat.mtime, librarySection: source.librarySection });
+          if (source.librarySection === "other") {
+            await indexUploadedVolume({
+              fileName: file.name,
+              fullPath,
+              dirName: directory.name,
+              seriesPath,
+              isOneshot: /\[oneshot\]/i.test(directory.name),
+              coverFilename: null,
+              metadata: result.comicMetadata,
+              genres: result.genres,
+              tags: [],
+              fileSize: stat.size,
+              librarySection: "other",
+            });
+          }
+          await saveBookChecksum(fullPath, checksum);
+          indexed++;
+        } catch (error) { errors.push(`${fullPath}: ${(error as Error).message}`); }
+      }
     }
   }
   await removeMissingBooks(existingPaths);
+  revalidateMangaLibraryCache();
   return { indexed, errors };
 }

package/dist/src/lib/mangaCover.ts

@@ -2,6 +2,7 @@ interface MangaCoverInput {
   slug: string;
   coverImage: string | null;
   updatedAt?: Date | string | null;
+  metadataObj?: { format?: string | null } | null;
 }
 
 function getVersion(updatedAt?: Date | string | null): string | null {
@@ -23,9 +24,12 @@ export function getMangaCoverUrl({
   slug,
   coverImage,
   updatedAt,
+  metadataObj,
 }: MangaCoverInput): string | null {
   if (!coverImage) {
-    return null;
+    return metadataObj?.format === "EPUB"
+      ? `/api/library/books/cover/${encodeURIComponent(slug)}`
+      : null;
   }
 
   const version = getVersion(updatedAt);