cyreader 0.1.1 → 0.1.2

package/bundle/server/dist/config/paths.js

@@ -16,3 +16,6 @@ export function getRecentFilePath() {
 export function getProgressFilePath() {
     return path.join(getConfigDir(), 'progress.json');
 }
+export function getLibraryCacheFilePath() {
+    return path.join(getConfigDir(), 'library-cache.json');
+}

package/bundle/server/dist/library/cache.js

@@ -0,0 +1,70 @@
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { z } from 'zod';
+import { getConfigDir, getLibraryCacheFilePath } from '../config/paths.js';
+const comicPageSchema = z.object({
+    filename: z.string().min(1),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+});
+const novelCacheItemSchema = z.object({
+    id: z.string().min(1),
+    type: z.literal('novel'),
+    title: z.string(),
+    path: z.string().min(1),
+    addedAt: z.string().datetime(),
+    directoryId: z.string().min(1),
+    filename: z.string().min(1),
+});
+const comicCacheItemSchema = z.object({
+    id: z.string().min(1),
+    type: z.literal('comic'),
+    title: z.string(),
+    path: z.string().min(1),
+    addedAt: z.string().datetime(),
+    directoryId: z.string().min(1),
+    pages: z.array(comicPageSchema),
+    coverFilename: z.string().nullable(),
+});
+const libraryCacheSchema = z.object({
+    items: z.array(z.discriminatedUnion('type', [novelCacheItemSchema, comicCacheItemSchema])),
+});
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function createEmptyLibraryScanCache() {
+    return { items: [] };
+}
+export function parseLibraryScanCache(data) {
+    const parsed = libraryCacheSchema.safeParse(data);
+    if (!parsed.success) {
+        return createEmptyLibraryScanCache();
+    }
+    return { items: parsed.data.items };
+}
+export async function readLibraryScanCache() {
+    const cacheFile = getLibraryCacheFilePath();
+    if (!(await fileExists(cacheFile))) {
+        return createEmptyLibraryScanCache();
+    }
+    let data;
+    try {
+        data = JSON.parse(await readFile(cacheFile, 'utf-8'));
+    }
+    catch {
+        return createEmptyLibraryScanCache();
+    }
+    return parseLibraryScanCache(data);
+}
+export async function writeLibraryScanCache(cache) {
+    const configDir = getConfigDir();
+    const cacheFile = getLibraryCacheFilePath();
+    const normalized = parseLibraryScanCache(cache);
+    await mkdir(configDir, { recursive: true });
+    await writeFile(cacheFile, `${JSON.stringify(normalized, null, 2)}\n`, 'utf-8');
+}

package/bundle/server/dist/library/scan.js

@@ -1,5 +1,7 @@
 import { readFile, readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
+import sharp from 'sharp';
+import { readLibraryScanCache, writeLibraryScanCache } from './cache.js';
 import { generateComicCoverIfMissing, resolveComicCoverFilename } from './cover.js';
 import { isComicCoverFile, isHiddenName, isImageFile, isTxtFile, sortByNaturalName, } from './files.js';
 import { makeLocalItemId } from './id.js';
@@ -44,7 +46,7 @@ async function shouldIncludeNovel(childPath, gbkNovelHandling) {
         return false;
     }
 }
-async function scanNovelsInDirectory(directoryId, root, gbkNovelHandling) {
+async function scanNovelsInDirectory(directoryId, root, gbkNovelHandling, cacheByPath) {
     const children = await listDirectChildren(root);
     const stats = await Promise.all(children.map(async (childPath) => ({
         childPath,
@@ -56,11 +58,21 @@ async function scanNovelsInDirectory(directoryId, root, gbkNovelHandling) {
         }
         return isTxtFile(path.basename(childPath));
     });
-    const inclusion = await Promise.all(txtFiles.map(async ({ childPath }) => ({
+    const cachedNovels = [];
+    const uncachedTxtFiles = [];
+    for (const entry of txtFiles) {
+        const cached = cacheByPath.get(entry.childPath);
+        if (cached?.type === 'novel') {
+            cachedNovels.push({ ...cached, directoryId });
+            continue;
+        }
+        uncachedTxtFiles.push(entry);
+    }
+    const inclusion = await Promise.all(uncachedTxtFiles.map(async ({ childPath }) => ({
         childPath,
         include: await shouldIncludeNovel(childPath, gbkNovelHandling),
     })));
-    return inclusion
+    const scannedNovels = inclusion
         .filter((entry) => entry.include)
         .map(({ childPath }) => {
         const name = path.basename(childPath);
@@ -70,10 +82,12 @@ async function scanNovelsInDirectory(directoryId, root, gbkNovelHandling) {
             type: 'novel',
             title,
             path: childPath,
+            addedAt: new Date().toISOString(),
             directoryId,
             filename: name,
         };
     });
+    return [...cachedNovels, ...scannedNovels];
 }
 async function listDirectImageFiles(dir) {
     const children = await listDirectChildren(dir);
@@ -94,7 +108,26 @@ async function listDirectImageFiles(dir) {
     }
     return sortByNaturalName(images);
 }
-async function scanComicsInDirectory(directoryId, root) {
+async function resolveComicPage(imagePath) {
+    try {
+        const metadata = await sharp(imagePath).metadata();
+        const width = metadata.width;
+        const height = metadata.height;
+        if (!width || !height) {
+            return null;
+        }
+        return {
+            filename: path.basename(imagePath),
+            width,
+            height,
+        };
+    }
+    catch (error) {
+        console.error(`Failed to read comic page metadata: ${imagePath}`, error);
+        return null;
+    }
+}
+async function scanComicsInDirectory(directoryId, root, cacheByPath) {
     const children = await listDirectChildren(root);
     const stats = await Promise.all(children.map(async (childPath) => ({
         childPath,
@@ -104,10 +137,18 @@ async function scanComicsInDirectory(directoryId, root) {
         .filter(({ childStat }) => childStat?.isDirectory())
         .map(({ childPath }) => childPath);
     const comics = await Promise.all(comicDirs.map(async (childPath) => {
+        const cached = cacheByPath.get(childPath);
+        if (cached?.type === 'comic') {
+            return Object.assign({}, cached, { directoryId });
+        }
         const images = await listDirectImageFiles(childPath);
         if (images.length === 0) {
             return null;
         }
+        const pages = (await Promise.all(images.map((imagePath) => resolveComicPage(imagePath)))).filter((page) => page !== null);
+        if (pages.length === 0) {
+            return null;
+        }
         await generateComicCoverIfMissing(childPath, images[0]);
         const coverFilename = await resolveComicCoverFilename(childPath);
         return {
@@ -115,17 +156,22 @@ async function scanComicsInDirectory(directoryId, root) {
             type: 'comic',
             title: path.basename(childPath),
             path: childPath,
+            addedAt: new Date().toISOString(),
             directoryId,
-            pages: images.map((imagePath) => path.basename(imagePath)),
+            pages,
             coverFilename,
         };
     }));
     return comics.filter((comic) => comic !== null);
 }
 export async function scanLibrary(config) {
-    const novelResults = await Promise.all(config.novelDirectories.map((directory) => scanNovelsInDirectory(directory.id, directory.path, config.gbkNovelHandling)));
-    const comicResults = await Promise.all(config.comicDirectories.map((directory) => scanComicsInDirectory(directory.id, directory.path)));
-    return [...novelResults.flat(), ...comicResults.flat()];
+    const cache = await readLibraryScanCache();
+    const cacheByPath = new Map(cache.items.map((item) => [item.path, item]));
+    const novelResults = await Promise.all(config.novelDirectories.map((directory) => scanNovelsInDirectory(directory.id, directory.path, config.gbkNovelHandling, cacheByPath)));
+    const comicResults = await Promise.all(config.comicDirectories.map((directory) => scanComicsInDirectory(directory.id, directory.path, cacheByPath)));
+    const items = [...novelResults.flat(), ...comicResults.flat()];
+    await writeLibraryScanCache({ items });
+    return items;
 }
 export async function listComicPages(comicDir) {
     return listDirectImageFiles(comicDir);

package/bundle/server/dist/library/scan.test.js

@@ -3,15 +3,25 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import sharp from 'sharp';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { getLibraryCacheFilePath } from '../config/paths.js';
 import { COMIC_COVER_FILENAME } from './files.js';
 import { listComicPages, scanLibrary } from './scan.js';
 import { writeTestImage } from './test-images.js';
 describe('scanLibrary', () => {
     let tempDir;
+    let previousConfigDir;
     beforeEach(async () => {
+        previousConfigDir = process.env.CYREADER_CONFIG_DIR;
         tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-scan-'));
+        process.env.CYREADER_CONFIG_DIR = tempDir;
     });
     afterEach(async () => {
+        if (previousConfigDir === undefined) {
+            delete process.env.CYREADER_CONFIG_DIR;
+        }
+        else {
+            process.env.CYREADER_CONFIG_DIR = previousConfigDir;
+        }
         await rm(tempDir, { recursive: true, force: true });
     });
     it('ignores GBK txt files when gbkNovelHandling is undefined', async () => {
@@ -97,10 +107,10 @@ describe('scanLibrary', () => {
         const mangaDir = path.join(comicRoot, 'manga-a');
         const nested = path.join(mangaDir, 'chapter');
         await mkdir(nested, { recursive: true });
-        await writeFile(path.join(mangaDir, '10.jpg'), '');
-        await writeFile(path.join(mangaDir, '2.png'), '');
-        await writeFile(path.join(mangaDir, '1.webp'), '');
-        await writeFile(path.join(nested, 'ignored.jpeg'), '');
+        await writeTestImage(path.join(mangaDir, '10.jpg'), 1000, 1200);
+        await writeTestImage(path.join(mangaDir, '2.png'), 200, 300);
+        await writeTestImage(path.join(mangaDir, '1.webp'), 100, 150);
+        await writeTestImage(path.join(nested, 'ignored.jpeg'), 50, 50);
         const items = await scanLibrary({
             novelDirectories: [],
             comicDirectories: [{ id: 'comic-root', path: comicRoot }],
@@ -111,8 +121,13 @@ describe('scanLibrary', () => {
             type: 'comic',
             title: 'manga-a',
             directoryId: 'comic-root',
-            pages: ['1.webp', '2.png', '10.jpg'],
-            coverFilename: null,
+            pages: [
+                { filename: '1.webp', width: 100, height: 150 },
+                { filename: '2.png', width: 200, height: 300 },
+                { filename: '10.jpg', width: 1000, height: 1200 },
+            ],
+            coverFilename: COMIC_COVER_FILENAME,
+            addedAt: expect.any(String),
         });
     });
     it('ignores root-level images and folders without direct images', async () => {
@@ -149,7 +164,10 @@ describe('scanLibrary', () => {
         expect(items[0]).toMatchObject({
             type: 'comic',
             title: 'manga-cover',
-            pages: ['1.jpg', '2.jpg'],
+            pages: [
+                { filename: '1.jpg', width: 300, height: 399 },
+                { filename: '2.jpg', width: 301, height: 400 },
+            ],
             coverFilename: COMIC_COVER_FILENAME,
         });
     });
@@ -182,11 +200,14 @@ describe('scanLibrary', () => {
         });
         expect(items[0]).toMatchObject({
             type: 'comic',
-            pages: ['1.jpg', '2.jpg'],
+            pages: [
+                { filename: '1.jpg', width: 300, height: 300 },
+                { filename: '2.jpg', width: 300, height: 300 },
+            ],
             coverFilename: COMIC_COVER_FILENAME,
         });
     });
-    it('keeps scanning comics when cover generation fails', async () => {
+    it('skips comic images when metadata cannot be read', async () => {
         const comicRoot = path.join(tempDir, 'comics');
         const mangaDir = path.join(comicRoot, 'manga-invalid');
         await mkdir(mangaDir, { recursive: true });
@@ -196,20 +217,14 @@ describe('scanLibrary', () => {
             comicDirectories: [{ id: 'comic-root', path: comicRoot }],
             gbkNovelHandling: 'ignore',
         });
-        expect(items).toHaveLength(1);
-        expect(items[0]).toMatchObject({
-            type: 'comic',
-            title: 'manga-invalid',
-            pages: ['1.jpg'],
-            coverFilename: null,
-        });
+        expect(items).toHaveLength(0);
         await expect(access(path.join(mangaDir, COMIC_COVER_FILENAME))).rejects.toThrow();
     });
     it('supports jpeg extension for comic cover', async () => {
         const comicRoot = path.join(tempDir, 'comics');
         const mangaDir = path.join(comicRoot, 'manga-b');
         await mkdir(mangaDir, { recursive: true });
-        await writeFile(path.join(mangaDir, 'cover.jpeg'), '');
+        await writeTestImage(path.join(mangaDir, 'cover.jpeg'), 320, 480);
         const items = await scanLibrary({
             novelDirectories: [],
             comicDirectories: [{ id: 'comic-root', path: comicRoot }],
@@ -219,8 +234,74 @@ describe('scanLibrary', () => {
         expect(items[0]).toMatchObject({
             type: 'comic',
             directoryId: 'comic-root',
-            pages: ['cover.jpeg'],
+            pages: [{ filename: 'cover.jpeg', width: 320, height: 480 }],
+        });
+    });
+    it('writes cache with comic page dimensions and reuses cached comic directories', async () => {
+        const comicRoot = path.join(tempDir, 'comics');
+        const mangaDir = path.join(comicRoot, 'manga-cached');
+        await mkdir(mangaDir, { recursive: true });
+        await writeTestImage(path.join(mangaDir, '1.jpg'), 300, 450);
+        const first = await scanLibrary({
+            novelDirectories: [],
+            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(first[0]).toMatchObject({
+            type: 'comic',
+            pages: [{ filename: '1.jpg', width: 300, height: 450 }],
+            coverFilename: COMIC_COVER_FILENAME,
+            addedAt: expect.any(String),
+        });
+        await rm(path.join(mangaDir, '1.jpg'));
+        await rm(path.join(mangaDir, COMIC_COVER_FILENAME));
+        const second = await scanLibrary({
+            novelDirectories: [],
+            comicDirectories: [{ id: 'comic-root', path: comicRoot }],
+            gbkNovelHandling: 'ignore',
         });
+        expect(second).toEqual(first);
+        await expect(access(path.join(mangaDir, COMIC_COVER_FILENAME))).rejects.toThrow();
+        const cache = JSON.parse(await readFile(getLibraryCacheFilePath(), 'utf-8'));
+        expect(cache.items).toHaveLength(1);
+    });
+    it('reuses cached novels without rechecking encoding', async () => {
+        const novelRoot = path.join(tempDir, 'novels');
+        const filePath = path.join(novelRoot, 'book.txt');
+        await mkdir(novelRoot);
+        await writeFile(filePath, 'content');
+        const first = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+        await writeFile(filePath, Buffer.from([0xd6, 0xd0, 0xce, 0xc4]));
+        const second = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+        expect(second).toEqual(first);
+    });
+    it('removes deleted entries from cache after scanning', async () => {
+        const novelRoot = path.join(tempDir, 'novels');
+        const filePath = path.join(novelRoot, 'book.txt');
+        await mkdir(novelRoot);
+        await writeFile(filePath, 'content');
+        await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+        await rm(filePath);
+        const items = await scanLibrary({
+            novelDirectories: [{ id: 'novel-root', path: novelRoot }],
+            comicDirectories: [],
+            gbkNovelHandling: 'ignore',
+        });
+        const cache = JSON.parse(await readFile(getLibraryCacheFilePath(), 'utf-8'));
+        expect(items).toHaveLength(0);
+        expect(cache.items).toHaveLength(0);
     });
 });
 describe('listComicPages', () => {

package/bundle/server/dist/library/service.js

@@ -8,13 +8,15 @@ export function toListItemBase(item) {
             id: item.id,
             type: 'novel',
             title: item.title,
+            addedAt: item.addedAt,
         };
     }
-    const coverPage = item.coverFilename ?? item.pages[0];
+    const coverPage = item.coverFilename ?? item.pages[0]?.filename;
     return {
         id: item.id,
         type: 'comic',
         title: item.title,
+        addedAt: item.addedAt,
         cover: coverPage ? buildComicImageUrl(item.directoryId, item.title, coverPage) : '',
         pageCount: item.pages.length,
     };
@@ -25,6 +27,7 @@ function toItemDetailBase(item) {
             id: item.id,
             type: 'novel',
             title: item.title,
+            addedAt: item.addedAt,
             directoryId: item.directoryId,
             filename: item.filename,
         };
@@ -33,6 +36,7 @@ function toItemDetailBase(item) {
         id: item.id,
         type: 'comic',
         title: item.title,
+        addedAt: item.addedAt,
         directoryId: item.directoryId,
         pages: item.pages,
     };

package/bundle/server/dist/library/service.test.js

@@ -7,10 +7,13 @@ import { LibraryService } from './service.js';
 import { writeTestImage } from './test-images.js';
 describe('LibraryService', () => {
     let tempDir;
+    let previousConfigDir;
     let novelRoot;
     let comicRoot;
     beforeEach(async () => {
+        previousConfigDir = process.env.CYREADER_CONFIG_DIR;
         tempDir = await mkdtemp(path.join(tmpdir(), 'cyreader-service-'));
+        process.env.CYREADER_CONFIG_DIR = tempDir;
         novelRoot = path.join(tempDir, 'novels');
         comicRoot = path.join(tempDir, 'comics');
         await mkdir(novelRoot);
@@ -18,6 +21,12 @@ describe('LibraryService', () => {
         await writeFile(path.join(novelRoot, 'book.txt'), 'content');
     });
     afterEach(async () => {
+        if (previousConfigDir === undefined) {
+            delete process.env.CYREADER_CONFIG_DIR;
+        }
+        else {
+            process.env.CYREADER_CONFIG_DIR = previousConfigDir;
+        }
         await rm(tempDir, { recursive: true, force: true });
     });
     function createService() {
@@ -37,6 +46,7 @@ describe('LibraryService', () => {
                     id: expect.any(String),
                     type: 'novel',
                     title: 'book',
+                    addedAt: expect.any(String),
                     progress: null,
                 },
             ],
@@ -56,6 +66,7 @@ describe('LibraryService', () => {
             id: novel.id,
             type: 'novel',
             title: 'book',
+            addedAt: expect.any(String),
             directoryId: 'novel-root',
             filename: 'book.txt',
             progress: null,
@@ -74,8 +85,12 @@ describe('LibraryService', () => {
             id: comic.id,
             type: 'comic',
             title: 'manga',
+            addedAt: expect.any(String),
             directoryId: 'comic-root',
-            pages: ['1.jpg', '2.jpg'],
+            pages: [
+                { filename: '1.jpg', width: 300, height: 400 },
+                { filename: '2.jpg', width: 300, height: 400 },
+            ],
             progress: null,
         });
         expect(comic).toMatchObject({

package/bundle/server/dist/reading/progress/merge.js

@@ -1,8 +1,9 @@
+import { normalizeComicProgress } from './schema.js';
 function novelProgress(entry) {
     return entry?.type === 'novel' ? entry : null;
 }
-function comicProgress(entry) {
-    return entry?.type === 'comic' ? entry : null;
+function comicProgress(entry, pageCount) {
+    return normalizeComicProgress(entry, pageCount);
 }
 export function attachProgressToListItem(item, progressMap) {
     const entry = progressMap[item.id] ?? null;
@@ -14,7 +15,7 @@ export function attachProgressToListItem(item, progressMap) {
     }
     return {
         ...item,
-        progress: comicProgress(entry),
+        progress: comicProgress(entry, item.pageCount),
     };
 }
 export function attachProgressToDetail(detail, progressMap) {
@@ -27,6 +28,6 @@ export function attachProgressToDetail(detail, progressMap) {
     }
     return {
         ...detail,
-        progress: comicProgress(entry),
+        progress: comicProgress(entry, detail.pages.length),
     };
 }

package/bundle/server/dist/reading/progress/schema.js

@@ -1,5 +1,11 @@
 import { z } from 'zod';
 const comicProgressSchema = z.object({
+    type: z.literal('comic'),
+    scrollRatio: z.number().min(0).max(1),
+    updatedAt: z.string().datetime(),
+    completedAt: z.string().datetime().nullable().optional(),
+});
+const legacyComicProgressSchema = z.object({
     type: z.literal('comic'),
     pageIndex: z.number().int().min(0),
     updatedAt: z.string().datetime(),
@@ -18,16 +24,21 @@ const novelProgressSchema = z.object({
         .optional(),
     completedAt: z.string().datetime().nullable().optional(),
 });
+const storedProgressEntrySchema = z.union([
+    comicProgressSchema,
+    legacyComicProgressSchema,
+    novelProgressSchema,
+]);
 export const progressEntrySchema = z.discriminatedUnion('type', [
     comicProgressSchema,
     novelProgressSchema,
 ]);
 const progressStoreSchema = z.object({
-    items: z.record(z.string(), progressEntrySchema),
+    items: z.record(z.string(), storedProgressEntrySchema),
 });
 export const comicProgressInputSchema = z.object({
     type: z.literal('comic'),
-    pageIndex: z.number().int().min(0),
+    scrollRatio: z.number().min(0).max(1),
     completedAt: z.string().datetime().nullable().optional(),
 });
 export const novelProgressInputSchema = z.object({
@@ -46,6 +57,27 @@ export const progressInputSchema = z.discriminatedUnion('type', [
     comicProgressInputSchema,
     novelProgressInputSchema,
 ]);
+export function migratePageIndexToScrollRatio(pageIndex, pageCount) {
+    if (pageCount <= 1) {
+        return 0;
+    }
+    const clamped = Math.min(Math.max(pageIndex, 0), pageCount - 1);
+    return clamped / (pageCount - 1);
+}
+export function normalizeComicProgress(entry, pageCount) {
+    if (!entry || entry.type !== 'comic') {
+        return null;
+    }
+    if ('scrollRatio' in entry) {
+        return entry;
+    }
+    return {
+        type: 'comic',
+        scrollRatio: migratePageIndexToScrollRatio(entry.pageIndex, pageCount),
+        updatedAt: entry.updatedAt,
+        ...(entry.completedAt !== undefined ? { completedAt: entry.completedAt } : {}),
+    };
+}
 export function createEmptyProgressStore() {
     return { items: {} };
 }
@@ -62,5 +94,9 @@ export function parseProgressStore(data) {
     if (!parsed.success) {
         return createEmptyProgressStore();
     }
-    return parsed.data;
+    const items = {};
+    for (const [itemId, entry] of Object.entries(parsed.data.items)) {
+        items[itemId] = entry;
+    }
+    return { items };
 }

package/bundle/server/dist/reading/progress/schema.test.js

@@ -1,12 +1,12 @@
 import { describe, expect, it } from 'vitest';
-import { parseProgressStore, progressInputSchema } from './schema.js';
+import { migratePageIndexToScrollRatio, normalizeComicProgress, parseProgressStore, progressInputSchema, } from './schema.js';
 describe('progress schema', () => {
     it('parses comic and novel entries', () => {
         const store = parseProgressStore({
             items: {
                 comic1: {
                     type: 'comic',
-                    pageIndex: 2,
+                    scrollRatio: 0.5,
                     updatedAt: '2026-01-01T00:00:00.000Z',
                 },
                 novel1: {
@@ -21,6 +21,39 @@ describe('progress schema', () => {
         expect(store.items.comic1?.type).toBe('comic');
         expect(store.items.novel1?.type === 'novel' ? store.items.novel1.paragraphIndex : null).toBe(10);
     });
+    it('parses legacy comic entries with pageIndex', () => {
+        const store = parseProgressStore({
+            items: {
+                comic1: {
+                    type: 'comic',
+                    pageIndex: 2,
+                    updatedAt: '2026-01-01T00:00:00.000Z',
+                },
+            },
+        });
+        expect(store.items.comic1).toEqual({
+            type: 'comic',
+            pageIndex: 2,
+            updatedAt: '2026-01-01T00:00:00.000Z',
+        });
+    });
+    it('normalizes legacy comic progress', () => {
+        expect(normalizeComicProgress({
+            type: 'comic',
+            pageIndex: 2,
+            updatedAt: '2026-01-01T00:00:00.000Z',
+        }, 5)).toEqual({
+            type: 'comic',
+            scrollRatio: 0.5,
+            updatedAt: '2026-01-01T00:00:00.000Z',
+        });
+    });
+    it('migrates page index to scroll ratio', () => {
+        expect(migratePageIndexToScrollRatio(0, 5)).toBe(0);
+        expect(migratePageIndexToScrollRatio(4, 5)).toBe(1);
+        expect(migratePageIndexToScrollRatio(2, 5)).toBe(0.5);
+        expect(migratePageIndexToScrollRatio(0, 1)).toBe(0);
+    });
     it('treats missing items as an empty store', () => {
         expect(parseProgressStore({})).toEqual({ items: {} });
         expect(parseProgressStore(null)).toEqual({ items: {} });
@@ -28,7 +61,7 @@ describe('progress schema', () => {
     it('validates progress input', () => {
         expect(progressInputSchema.safeParse({
             type: 'comic',
-            pageIndex: 0,
+            scrollRatio: 0.25,
             completedAt: null,
         }).success).toBe(true);
         expect(progressInputSchema.safeParse({

package/bundle/server/dist/reading/progress/service.js

@@ -59,11 +59,10 @@ export class ProgressService {
             if (detail.type !== 'comic') {
                 throw new TypeError('Progress type does not match library item type');
             }
-            const pageCount = detail.pages.length;
-            const pageIndex = pageCount === 0 ? 0 : Math.min(input.pageIndex, pageCount - 1);
+            const scrollRatio = Math.min(Math.max(input.scrollRatio, 0), 1);
             return {
                 type: 'comic',
-                pageIndex,
+                scrollRatio,
                 updatedAt,
                 ...(input.completedAt !== undefined ? { completedAt: input.completedAt } : {}),
             };