feat: streaming files endpoint + reader pages + chapter pages metadata

Backend:
- Migration 0003_pages.sql adds a `pages` table (id, chapter_id,
  page_number, storage_key, content_type) with a unique (chapter_id,
  page_number). New table because chapter pages can have different MIME
  types per page; reconstructing keys from a single template would
  break the moment a chapter mixes png and jpg pages.
- `domain::Page` + `repo::page` (create + list_for_chapter).
- The chapter upload handler now inserts one page row per part as it
  writes the bytes to storage.
- GET /api/v1/mangas/{id}/chapters/{n}/pages returns `{pages: [...]}`
  with the storage_key clients need to construct image URLs. 404 if
  the manga or chapter doesn't exist; reads are public.

Storage trait grows `get_stream(&str) -> StreamingFile` returning a
`Pin<Box<dyn Stream<Item = io::Result<Bytes>> + Send>>` + size. The
local backend implements via `tokio::fs::File` + `tokio_util::io::
ReaderStream` with a 64 KiB chunk size. GET /api/v1/files/*key now
streams via `axum::body::Body::from_stream` instead of buffering — the
test asserts a 200 KiB file emits >1 frame end-to-end through the
router.

Frontend:
- lib/api/client.ts gains `fileUrl(key)` so components don't
  reconstruct the `/api/v1/files/...` path manually.
- lib/api/chapters.ts gains `ChapterPage` type + `getChapterPages` (the
  type is named ChapterPage to avoid colliding with `Page` from
  client.ts, which is the pagination envelope).
- /manga/[id]/+page.svelte: overview with cover, title, author,
  description, chapter list, and a disabled bookmark control (real
  bookmarking lands in feat/bookmarks). Responsive at 640 px.
- /manga/[id]/chapter/[n]/+page.svelte: paginated reader. Current page
  loads eagerly; next page is preloaded in a hidden img so navigation
  feels instant. Keyboard handler maps ArrowRight/j/Space → next,
  ArrowLeft/k → prev, Home/End → first/last; skips when the user is
  typing in an input. Focus ring on the prev/next buttons.
- SSR is disabled on both routes via `export const ssr = false` so the
  client-only fetch flow doesn't need to be replicated server-side; the
  routes are interactive features, not SEO surfaces.
- E2E (e2e/reader.spec.ts): overview shows the title/cover/chapter
  list; reader pages through three pages via ArrowRight, j, k, and
  ArrowLeft, and the preload img holds the page-2 src on initial load.

Lockstep version bump to 0.6.0.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

backend/src/storage/local.rs

@@ -2,8 +2,9 @@ use std::path::{Path, PathBuf};
 
 use async_trait::async_trait;
 use tokio::fs;
+use tokio_util::io::ReaderStream;
 
-use super::{Storage, StorageError};
+use super::{Storage, StorageError, StreamingFile};
 
 pub struct LocalStorage {
     root: PathBuf,
@@ -46,6 +47,25 @@ impl Storage for LocalStorage {
         }
     }
 
+    async fn get_stream(&self, key: &str) -> Result<StreamingFile, StorageError> {
+        let path = self.resolve(key)?;
+        let file = match fs::File::open(&path).await {
+            Ok(f) => f,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+                return Err(StorageError::NotFound)
+            }
+            Err(e) => return Err(e.into()),
+        };
+        let size_bytes = file.metadata().await?.len();
+        // 64 KiB chunks: small enough that a few-MB page emits many frames
+        // (so streaming is observable), large enough to keep syscalls cheap.
+        let stream = ReaderStream::with_capacity(file, 64 * 1024);
+        Ok(StreamingFile {
+            stream: Box::pin(stream),
+            size_bytes,
+        })
+    }
+
     async fn delete(&self, key: &str) -> Result<(), StorageError> {
         let path = self.resolve(key)?;
         match fs::remove_file(&path).await {
@@ -93,5 +113,33 @@ mod tests {
         let s = LocalStorage::new(dir.path());
         assert!(matches!(s.get("nope").await, Err(StorageError::NotFound)));
         assert!(matches!(s.delete("nope").await, Err(StorageError::NotFound)));
+        assert!(matches!(
+            s.get_stream("nope").await.err(),
+            Some(StorageError::NotFound)
+        ));
+    }
+
+    #[tokio::test]
+    async fn get_stream_emits_multiple_chunks_for_large_files() {
+        use futures_util::StreamExt as _;
+
+        let dir = tempdir().unwrap();
+        let s = LocalStorage::new(dir.path());
+        // 256 KiB blob → at 64 KiB chunks should emit ~4 chunks.
+        let big = vec![7u8; 256 * 1024];
+        s.put("big.bin", &big).await.unwrap();
+
+        let StreamingFile { mut stream, size_bytes } = s.get_stream("big.bin").await.unwrap();
+        assert_eq!(size_bytes, big.len() as u64);
+
+        let mut chunks = 0usize;
+        let mut total = 0usize;
+        while let Some(frame) = stream.next().await {
+            let bytes = frame.unwrap();
+            chunks += 1;
+            total += bytes.len();
+        }
+        assert_eq!(total, big.len());
+        assert!(chunks > 1, "expected >1 chunk, got {chunks}");
     }
 }

backend/src/storage/mod.rs

@@ -7,8 +7,11 @@
 mod local;
 
 use std::io;
+use std::pin::Pin;
 
 use async_trait::async_trait;
+use bytes::Bytes;
+use futures_core::Stream;
 
 pub use local::LocalStorage;
 
@@ -22,10 +25,23 @@ pub enum StorageError {
     BadKey,
 }
 
+/// Boxed byte stream returned by `Storage::get_stream` so the trait stays
+/// object-safe regardless of the concrete reader behind it.
+pub type ByteStream = Pin<Box<dyn Stream<Item = io::Result<Bytes>> + Send>>;
+
+pub struct StreamingFile {
+    pub stream: ByteStream,
+    pub size_bytes: u64,
+}
+
 #[async_trait]
 pub trait Storage: Send + Sync {
     async fn put(&self, key: &str, bytes: &[u8]) -> Result<(), StorageError>;
+    /// Reads the entire blob into memory. Convenient for small assets
+    /// (covers, thumbnails). For pages and other large blobs, use
+    /// `get_stream` so axum can pipe bytes straight to the client.
     async fn get(&self, key: &str) -> Result<Vec<u8>, StorageError>;
+    async fn get_stream(&self, key: &str) -> Result<StreamingFile, StorageError>;
     async fn delete(&self, key: &str) -> Result<(), StorageError>;
     async fn exists(&self, key: &str) -> Result<bool, StorageError>;
 }