fix: use correct path for xcodegen in fastlane

Extract currentTime/duration/isPlaying into a separate PlaybackProgress
ObservableObject so the 0.5s time-observer ticks only invalidate the seek
bar and play-pause button subviews, not the entire FullPlayerView or
MiniPlayerView. Menus no longer blink or lose their checkmarks during
playback.

Also fix chapter list selection in FullPlayerView to call audioPlayer.load()
directly instead of relying on skip notifications (which only worked when
ChapterReaderView was open).

.gitea/workflows/ci-scraper.yaml

@@ -2,19 +2,19 @@ name: CI / Scraper
 
 on:
   push:
-    branches: ["main", "master"]
+    branches: ["main", "master", "v2"]
     paths:
       - "scraper/**"
       - ".gitea/workflows/ci-scraper.yaml"
   pull_request:
-    branches: ["main", "master"]
+    branches: ["main", "master", "v2"]
     paths:
       - "scraper/**"
       - ".gitea/workflows/ci-scraper.yaml"
 
-defaults:
-  run:
-    working-directory: scraper
+concurrency:
+  group: ${{ gitea.workflow }}-${{ gitea.ref }}
+  cancel-in-progress: true
 
 jobs:
   # ── lint & vet ───────────────────────────────────────────────────────────────
@@ -30,10 +30,10 @@ jobs:
           cache-dependency-path: scraper/go.sum
 
       - name: go vet
-        run: go vet ./...
-
-      - name: staticcheck
-        run: go tool staticcheck ./...
+        working-directory: scraper
+        run: |
+          go vet ./...
+          go vet -tags integration ./...
 
   # ── tests ────────────────────────────────────────────────────────────────────
   test:
@@ -48,29 +48,29 @@ jobs:
           cache-dependency-path: scraper/go.sum
 
       - name: Run tests
-        run: go test -race -count=1 -timeout=60s ./...
+        working-directory: scraper
+        run: go test -short -race -count=1 -timeout=60s ./...
 
-  # ── build binary ─────────────────────────────────────────────────────────────
-  build:
-    name: Build
+  # ── push to Docker Hub ───────────────────────────────────────────────────────
+  docker:
+    name: Docker Push
     runs-on: ubuntu-latest
     needs: [lint, test]
+    if: gitea.event_name == 'push'
     steps:
       - uses: actions/checkout@v4
 
-      - uses: actions/setup-go@v5
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
         with:
-          go-version-file: scraper/go.mod
-          cache-dependency-path: scraper/go.sum
+          username: ${{ secrets.DOCKER_USER }}
+          password: ${{ secrets.DOCKER_TOKEN }}
 
-      - name: Build binary
-        run: |
-          CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
-            go build -ldflags="-s -w" -o bin/scraper ./cmd/scraper
-
-      - name: Upload binary artifact
-        uses: actions/upload-artifact@v3
+      - name: Build and push
+        uses: docker/build-push-action@v6
         with:
-          name: scraper-linux-amd64
-          path: scraper/bin/scraper
-          retention-days: 7
+          context: scraper
+          push: true
+          tags: |
+            ${{ secrets.DOCKER_USER }}/libnovel-scraper:latest
+            ${{ secrets.DOCKER_USER }}/libnovel-scraper:${{ gitea.sha }}

.gitea/workflows/ci-ui.yaml

@@ -2,25 +2,28 @@ name: CI / UI
 
 on:
   push:
-    branches: ["main", "master"]
+    branches: ["main", "master", "v2"]
     paths:
       - "ui/**"
       - ".gitea/workflows/ci-ui.yaml"
   pull_request:
-    branches: ["main", "master"]
+    branches: ["main", "master", "v2"]
     paths:
       - "ui/**"
       - ".gitea/workflows/ci-ui.yaml"
 
-defaults:
-  run:
-    working-directory: ui
+concurrency:
+  group: ${{ gitea.workflow }}-${{ gitea.ref }}
+  cancel-in-progress: true
 
 jobs:
   # ── type-check & build ───────────────────────────────────────────────────────
   build:
     name: Build
     runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ui
     steps:
       - uses: actions/checkout@v4
 
@@ -38,3 +41,27 @@ jobs:
 
       - name: Build
         run: npm run build
+
+  # ── push to Docker Hub ───────────────────────────────────────────────────────
+  docker:
+    name: Docker Push
+    runs-on: ubuntu-latest
+    needs: build
+    if: gitea.event_name == 'push'
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USER }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: ui
+          push: true
+          tags: |
+            ${{ secrets.DOCKER_USER }}/libnovel-ui:latest
+            ${{ secrets.DOCKER_USER }}/libnovel-ui:${{ gitea.sha }}

.gitea/workflows/deploy.yaml.disabled

@@ -19,14 +19,18 @@ on:
 #              Header: x-api-key: <token>
 #   Response on success: HTTP 200, body: [{"result":{"data":{"json":{...}}}}]
 
+concurrency:
+  group: ${{ gitea.workflow }}-${{ gitea.ref }}
+  cancel-in-progress: true
+
 jobs:
   # ── production deploy (main/master only) ─────────────────────────────────────
   deploy-production:
     name: Deploy Production
     runs-on: ubuntu-latest
     if: >
-      github.event_name == 'push' &&
-      (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master')
+      gitea.event_name == 'push' &&
+      (gitea.ref == 'refs/heads/main' || gitea.ref == 'refs/heads/master')
     steps:
       - name: Redeploy production stack
         run: |
@@ -46,15 +50,15 @@ jobs:
     name: Deploy Preview
     runs-on: ubuntu-latest
     if: >
-      github.event_name == 'push' &&
-      github.ref != 'refs/heads/main' &&
-      github.ref != 'refs/heads/master'
+      gitea.event_name == 'push' &&
+      gitea.ref != 'refs/heads/main' &&
+      gitea.ref != 'refs/heads/master'
     steps:
       - name: Sanitize branch name
         id: branch
         run: |
           # Lowercase, replace non-alphanumeric with dashes, strip trailing dashes, max 20 chars
-          SUFFIX=$(echo "${{ github.ref_name }}" \
+          SUFFIX=$(echo "${{ gitea.ref_name }}" \
             | tr '[:upper:]' '[:lower:]' \
             | sed 's/[^a-z0-9]/-/g' \
             | cut -c1-20 \
@@ -81,12 +85,12 @@ jobs:
   cleanup-preview:
     name: Cleanup Preview
     runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request' && github.event.action == 'closed'
+    if: gitea.event_name == 'pull_request' && gitea.event.action == 'closed'
     steps:
       - name: Sanitize branch name
         id: branch
         run: |
-          SUFFIX=$(echo "${{ github.head_ref }}" \
+          SUFFIX=$(echo "${{ gitea.head_ref }}" \
             | tr '[:upper:]' '[:lower:]' \
             | sed 's/[^a-z0-9]/-/g' \
             | cut -c1-20 \

.gitea/workflows/ios-release.yaml

@@ -0,0 +1,96 @@
+name: iOS Release
+
+on:
+  push:
+    tags:
+      - "ios-v*"
+
+concurrency:
+  group: ios-macos-runner
+  cancel-in-progress: false
+
+jobs:
+  # ── archive & release to TestFlight ──────────────────────────────────────
+  # Triggered only on ios-v* tags (e.g. ios-v1.0.0).
+  # Required secrets:
+  #   APPLE_CERTIFICATE_BASE64          - Distribution certificate (.p12) base64-encoded
+  #   APPLE_CERTIFICATE_PASSWORD        - Password for the .p12 file
+  #   APPLE_PROVISIONING_PROFILE_BASE64 - App Store distribution profile base64-encoded
+  #   KEYCHAIN_PASSWORD                 - Temporary keychain password (any random string)
+  #   ASC_KEY_ID                        - App Store Connect API key ID
+  #   ASC_ISSUER_ID                     - App Store Connect issuer ID
+  #   ASC_PRIVATE_KEY                   - Contents of the .p8 private key file
+  #   APPLE_TEAM_ID                     - 10-character Apple Developer team ID (GHZXC6FVMU)
+  release:
+    name: Release to TestFlight
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Ruby with rbenv
+        run: |
+          # Install rbenv and ruby-build if not already installed
+          brew install rbenv ruby-build || true
+          
+          # Install Ruby 3.2.2
+          rbenv install 3.2.2 --skip-existing
+          rbenv global 3.2.2
+          
+          # Add rbenv to PATH for subsequent steps
+          echo "$(rbenv root)/shims" >> $GITHUB_PATH
+          
+          # Verify Ruby version
+          eval "$(rbenv init -)"
+          ruby --version
+
+      - name: Install dependencies
+        working-directory: ios/LibNovel
+        run: |
+          eval "$(rbenv init -)"
+          gem install bundler
+          bundle install
+
+      - name: Import signing certificate
+        env:
+          CERTIFICATE_BASE64: ${{ secrets.APPLE_CERTIFICATE_BASE64 }}
+          CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
+        run: |
+          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
+          security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+          security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
+          security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+          echo "$CERTIFICATE_BASE64" | base64 --decode > $RUNNER_TEMP/cert.p12
+          security import $RUNNER_TEMP/cert.p12 \
+            -P "$CERTIFICATE_PASSWORD" \
+            -A -t cert -f pkcs12 \
+            -k $KEYCHAIN_PATH
+          security list-keychain -d user -s $KEYCHAIN_PATH $(security list-keychains -d user | tr -d '"' | xargs)
+          security set-key-partition-list -S apple-tool:,apple: -s -k "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+
+      - name: Import provisioning profile
+        env:
+          PROFILE_BASE64: ${{ secrets.APPLE_PROVISIONING_PROFILE_BASE64 }}
+        run: |
+          PP_PATH=$RUNNER_TEMP/profile.mobileprovision
+          echo "$PROFILE_BASE64" | base64 --decode > $PP_PATH
+          UUID=$(security cms -D -i "$PP_PATH" | plutil -extract UUID raw -)
+          mkdir -p ~/Library/MobileDevice/Provisioning\ Profiles
+          cp $PP_PATH ~/Library/MobileDevice/Provisioning\ Profiles/$UUID.mobileprovision
+
+      - name: Build and upload to TestFlight
+        env:
+          APPLE_KEY_ID: ${{ secrets.ASC_KEY_ID }}
+          APPLE_ISSUER_ID: ${{ secrets.ASC_ISSUER_ID }}
+          APPLE_KEY_CONTENT: ${{ secrets.ASC_PRIVATE_KEY }}
+          BUILD_NUMBER: ${{ gitea.run_number }}
+          PROVISIONING_PROFILE_NAME: LibNovel Distribution
+        working-directory: ios/LibNovel
+        run: |
+          eval "$(rbenv init -)"
+          bundle exec fastlane beta
+
+      - name: Cleanup keychain
+        if: always()
+        run: security delete-keychain $RUNNER_TEMP/app-signing.keychain-db

.gitea/workflows/ios.yaml

@@ -0,0 +1,63 @@
+name: iOS CI
+
+on:
+  push:
+    branches: ["v2", "main"]
+    paths:
+      - "ios/**"
+      - "justfile"
+      - ".gitea/workflows/ios.yaml"
+      - ".gitea/workflows/ios-release.yaml"
+  pull_request:
+    branches: ["v2", "main"]
+    paths:
+      - "ios/**"
+      - "justfile"
+      - ".gitea/workflows/ios.yaml"
+      - ".gitea/workflows/ios-release.yaml"
+
+concurrency:
+  group: ios-macos-runner
+  cancel-in-progress: true
+
+jobs:
+  # ── build (simulator) ─────────────────────────────────────────────────────
+  build:
+    name: Build
+    runs-on: macos-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install just
+        run: command -v just || brew install just
+
+      - name: Build (simulator)
+        env:
+          USER: runner
+        run: just ios-build
+
+  # ── unit tests ────────────────────────────────────────────────────────────
+  test:
+    name: Test
+    runs-on: macos-latest
+    needs: build
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install just
+        run: command -v just || brew install just
+
+      - name: Run unit tests
+        env:
+          USER: runner
+        run: just ios-test
+
+      - name: Upload test results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results
+          path: ios/LibNovel/test-results.xml
+          retention-days: 7

.gitea/workflows/release-ui.yaml

@@ -5,15 +5,18 @@ on:
     tags:
       - "v*"
 
-defaults:
-  run:
-    working-directory: ui
+concurrency:
+  group: ${{ gitea.workflow }}-${{ gitea.ref }}
+  cancel-in-progress: true
 
 jobs:
   # ── type-check & build ───────────────────────────────────────────────────────
   build:
     name: Build
     runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ui
     steps:
       - uses: actions/checkout@v4
 
@@ -37,33 +40,29 @@ jobs:
     name: Docker
     runs-on: ubuntu-latest
     needs: [build]
-    defaults:
-      run:
-        working-directory: .
     steps:
       - uses: actions/checkout@v4
 
-      - name: Log in to Gitea registry
+      - name: Log in to Docker Hub
         uses: docker/login-action@v3
         with:
-          registry: gitea.kalekber.cc
-          username: ${{ secrets.REGISTRY_USER }}
-          password: ${{ secrets.REGISTRY_TOKEN }}
+          username: ${{ secrets.DOCKER_USER }}
+          password: ${{ secrets.DOCKER_TOKEN }}
 
       - name: Docker meta
         id: meta
         uses: docker/metadata-action@v5
         with:
-          images: gitea.kalekber.cc/kamil/libnovel-ui
+          images: ${{ secrets.DOCKER_USER }}/libnovel-ui
           tags: |
             type=semver,pattern={{version}}
             type=semver,pattern={{major}}.{{minor}}
             type=raw,value=latest
 
       - name: Build and push
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v6
         with:
-          context: ./ui
+          context: ui
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}

ios/.gitignore

@@ -0,0 +1,14 @@
+# Xcode build artifacts — regenerate with: xcodegen generate --spec project.yml
+xcuserdata/
+*.xcuserstate
+*.xcworkspace/xcuserdata/
+DerivedData/
+build/
+
+# Swift Package Manager — resolved by Xcode on first open
+LibNovel.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/
+.build/
+# Package.resolved is committed so SPM builds are reproducible
+
+# OS
+.DS_Store

ios/LibNovel/.gitignore

@@ -0,0 +1,10 @@
+# Fastlane
+fastlane/report.xml
+fastlane/Preview.html
+fastlane/screenshots/**/*.png
+fastlane/test_output
+fastlane/README.md
+
+# Bundler
+.bundle
+vendor/bundle

ios/LibNovel/ExportOptions.plist

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>method</key>
+	<string>app-store-connect</string>
+	<key>teamID</key>
+	<string>$(DEVELOPMENT_TEAM)</string>
+	<key>uploadBitcode</key>
+	<false/>
+	<key>uploadSymbols</key>
+	<true/>
+	<key>signingStyle</key>
+	<string>manual</string>
+	<key>provisioningProfiles</key>
+	<dict>
+		<key>com.kalekber.LibNovel</key>
+		<string>LibNovel Distribution</string>
+	</dict>
+</dict>
+</plist>

ios/LibNovel/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem "fastlane"

ios/LibNovel/LibNovel.xcodeproj/project.pbxproj

@@ -0,0 +1,680 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 77;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		032E049A4BB3CF0EA990C0CD /* LibNovelApp.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4F56C8E2BC3614530B81569D /* LibNovelApp.swift */; };
+		08DFB5F626BA769556C8D145 /* BrowseView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1FA3F0FCA383180EE4C93BBA /* BrowseView.swift */; };
+		0A52BC1CE71BED9E75D20D35 /* Models.swift in Sources */ = {isa = PBXBuildFile; fileRef = 762E378B9BC2161A7AA2CC36 /* Models.swift */; };
+		2790B8C051BE389D83645047 /* BrowseViewModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9812F5FE30ED657FB40ABD7A /* BrowseViewModel.swift */; };
+		2A15157AD2AE2271675C3485 /* ChapterReaderViewModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8995E667B3DD9CFCAD8A91D7 /* ChapterReaderViewModel.swift */; };
+		3521DFD5FCBBED7B90368829 /* LibraryViewModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = FC338B05EA6DB22900712000 /* LibraryViewModel.swift */; };
+		367C88FFC11701D2BAD8CCD0 /* RootTabView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 2D5C115992F1CE2326236765 /* RootTabView.swift */; };
+		4BB2C76262D5BD5DAD0D5D28 /* LibNovelTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B4C918833E173D6B44D06955 /* LibNovelTests.swift */; };
+		58E440CE4360D755401D1672 /* ProfileViewModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 937A589F84FD412BBB6FBC45 /* ProfileViewModel.swift */; };
+		5D8D783259EF54C773788AAB /* AuthStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = F219788AE5ACBD6F240674F5 /* AuthStore.swift */; };
+		64D80AACB8E1967B17921EE3 /* ProfileView.swift in Sources */ = {isa = PBXBuildFile; fileRef = C0B17D50389C6C98FC78BDBC /* ProfileView.swift */; };
+		749292A18C57FA41EC88A30B /* BookDetailView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 39DE056C37FBC5EED8771821 /* BookDetailView.swift */; };
+		7C74C10317D389121922A5E3 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 5A776719B77EDDB5E44743B0 /* Assets.xcassets */; };
+		7D81DEB2EEFF9CA5079AEEF7 /* BookDetailViewModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 837F83AA12B59924FDF16617 /* BookDetailViewModel.swift */; };
+		94D0C4B15734B4056BF3B127 /* ContentView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4B820081FA4817765A39939A /* ContentView.swift */; };
+		9B2D6F241E707312AB80DC31 /* AuthView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7CEF6782A2A28B2A485CBD48 /* AuthView.swift */; };
+		A9B95BAD7CE2DCD1DDDABD4C /* AudioPlayerService.swift in Sources */ = {isa = PBXBuildFile; fileRef = DB13E89E50529E3081533A66 /* AudioPlayerService.swift */; };
+		BE7805A4E78037A82B12AE56 /* PlayerViews.swift in Sources */ = {isa = PBXBuildFile; fileRef = DF49C3AEF9D010F9FEDAB1FC /* PlayerViews.swift */; };
+		C807AD8D627CF6BED47D517C /* HomeViewModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3AB2E843D93461074A89A171 /* HomeViewModel.swift */; };
+		CFDAA4776344B075A1E3CD6B /* Kingfisher in Frameworks */ = {isa = PBXBuildFile; productRef = 09584EAB68A07B47F876A062 /* Kingfisher */; };
+		E1F564399D1325F6A1B2B84F /* LibraryView.swift in Sources */ = {isa = PBXBuildFile; fileRef = C21107BECA55C07416E0CB8B /* LibraryView.swift */; };
+		E2572692178FD17145FDAF77 /* Color+App.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9D83BB88C4306BE7A4F947CB /* Color+App.swift */; };
+		A1B2C3D4E5F6789012345678 /* String+App.swift in Sources */ = {isa = PBXBuildFile; fileRef = B2C3D4E5F67890123456789A /* String+App.swift */; };
+		EF3C57C400BF05CBEAC1F7FE /* HomeView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6268D60803940CBD38FB921 /* HomeView.swift */; };
+		F2AF05B9C8C23132A73ACDD3 /* CommonViews.swift in Sources */ = {isa = PBXBuildFile; fileRef = 8E89FD8F46747CA653C5203D /* CommonViews.swift */; };
+		F4FDA3C44752EB979235C042 /* NavDestination.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7CAFB96D2500F34F0B0C860C /* NavDestination.swift */; };
+		FB32F3772CA09684F00497F3 /* APIClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = B593F179EC3E9112126B540B /* APIClient.swift */; };
+		FEFB5FDC2424D22914458001 /* ChapterReaderView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 81E3939152E23B4985FAF7E2 /* ChapterReaderView.swift */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		698AC3AA533BC05C985595D0 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = A10A669C0C8B43078C0FEE9F /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = D039EDECDE3998D8534BB680;
+			remoteInfo = LibNovel;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXFileReference section */
+		1B8BF3DB582A658386E402C7 /* LibNovel.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = LibNovel.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		1FA3F0FCA383180EE4C93BBA /* BrowseView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BrowseView.swift; sourceTree = "<group>"; };
+		235967A21B386BE13F56F3F8 /* LibNovelTests.xctest */ = {isa = PBXFileReference; includeInIndex = 0; lastKnownFileType = wrapper.cfbundle; path = LibNovelTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+		2D5C115992F1CE2326236765 /* RootTabView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RootTabView.swift; sourceTree = "<group>"; };
+		39DE056C37FBC5EED8771821 /* BookDetailView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BookDetailView.swift; sourceTree = "<group>"; };
+		3AB2E843D93461074A89A171 /* HomeViewModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HomeViewModel.swift; sourceTree = "<group>"; };
+		4B820081FA4817765A39939A /* ContentView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ContentView.swift; sourceTree = "<group>"; };
+		4F56C8E2BC3614530B81569D /* LibNovelApp.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LibNovelApp.swift; sourceTree = "<group>"; };
+		5A776719B77EDDB5E44743B0 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		762E378B9BC2161A7AA2CC36 /* Models.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Models.swift; sourceTree = "<group>"; };
+		7CAFB96D2500F34F0B0C860C /* NavDestination.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NavDestination.swift; sourceTree = "<group>"; };
+		7CEF6782A2A28B2A485CBD48 /* AuthView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AuthView.swift; sourceTree = "<group>"; };
+		81E3939152E23B4985FAF7E2 /* ChapterReaderView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChapterReaderView.swift; sourceTree = "<group>"; };
+		837F83AA12B59924FDF16617 /* BookDetailViewModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BookDetailViewModel.swift; sourceTree = "<group>"; };
+		8995E667B3DD9CFCAD8A91D7 /* ChapterReaderViewModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChapterReaderViewModel.swift; sourceTree = "<group>"; };
+		8E89FD8F46747CA653C5203D /* CommonViews.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CommonViews.swift; sourceTree = "<group>"; };
+		937A589F84FD412BBB6FBC45 /* ProfileViewModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ProfileViewModel.swift; sourceTree = "<group>"; };
+		9812F5FE30ED657FB40ABD7A /* BrowseViewModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BrowseViewModel.swift; sourceTree = "<group>"; };
+		9D83BB88C4306BE7A4F947CB /* Color+App.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Color+App.swift"; sourceTree = "<group>"; };
+		B2C3D4E5F67890123456789A /* String+App.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "String+App.swift"; sourceTree = "<group>"; };
+		B4C918833E173D6B44D06955 /* LibNovelTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LibNovelTests.swift; sourceTree = "<group>"; };
+		B593F179EC3E9112126B540B /* APIClient.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = APIClient.swift; sourceTree = "<group>"; };
+		C0B17D50389C6C98FC78BDBC /* ProfileView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ProfileView.swift; sourceTree = "<group>"; };
+		C21107BECA55C07416E0CB8B /* LibraryView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LibraryView.swift; sourceTree = "<group>"; };
+		D6268D60803940CBD38FB921 /* HomeView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HomeView.swift; sourceTree = "<group>"; };
+		DB13E89E50529E3081533A66 /* AudioPlayerService.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AudioPlayerService.swift; sourceTree = "<group>"; };
+		DF49C3AEF9D010F9FEDAB1FC /* PlayerViews.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PlayerViews.swift; sourceTree = "<group>"; };
+		F219788AE5ACBD6F240674F5 /* AuthStore.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AuthStore.swift; sourceTree = "<group>"; };
+		FC338B05EA6DB22900712000 /* LibraryViewModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LibraryViewModel.swift; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		EFE3211B202EDF04EB141EFB /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				CFDAA4776344B075A1E3CD6B /* Kingfisher in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		2C0FB0EDFF9B3E24B97F4214 /* Resources */ = {
+			isa = PBXGroup;
+			children = (
+				5A776719B77EDDB5E44743B0 /* Assets.xcassets */,
+			);
+			path = Resources;
+			sourceTree = "<group>";
+		};
+		2C57B93EAF19A3B18E7B7E87 /* Views */ = {
+			isa = PBXGroup;
+			children = (
+				2F18D1275D6022B9847E310E /* Auth */,
+				FB5C0D4925633786D28C6DE3 /* BookDetail */,
+				8E8AAA58A33084ADB8AEA80C /* Browse */,
+				4EAB87A1ED4943A311F26F84 /* ChapterReader */,
+				5D5809803A3D74FAE19DB218 /* Common */,
+				811FC0F6B9C209D6EC8543BD /* Home */,
+				FA994FD601E79EC811D822A4 /* Library */,
+				89F2CB14192E7D7565A588E0 /* Player */,
+				3DB66C5703A4CCAFFA1B7AFE /* Profile */,
+			);
+			path = Views;
+			sourceTree = "<group>";
+		};
+		2F18D1275D6022B9847E310E /* Auth */ = {
+			isa = PBXGroup;
+			children = (
+				7CEF6782A2A28B2A485CBD48 /* AuthView.swift */,
+			);
+			path = Auth;
+			sourceTree = "<group>";
+		};
+		3DB66C5703A4CCAFFA1B7AFE /* Profile */ = {
+			isa = PBXGroup;
+			children = (
+				C0B17D50389C6C98FC78BDBC /* ProfileView.swift */,
+			);
+			path = Profile;
+			sourceTree = "<group>";
+		};
+		426F7C5465758645B93A1AB1 /* Networking */ = {
+			isa = PBXGroup;
+			children = (
+				B593F179EC3E9112126B540B /* APIClient.swift */,
+			);
+			path = Networking;
+			sourceTree = "<group>";
+		};
+		4EAB87A1ED4943A311F26F84 /* ChapterReader */ = {
+			isa = PBXGroup;
+			children = (
+				81E3939152E23B4985FAF7E2 /* ChapterReaderView.swift */,
+			);
+			path = ChapterReader;
+			sourceTree = "<group>";
+		};
+		5D5809803A3D74FAE19DB218 /* Common */ = {
+			isa = PBXGroup;
+			children = (
+				8E89FD8F46747CA653C5203D /* CommonViews.swift */,
+			);
+			path = Common;
+			sourceTree = "<group>";
+		};
+		6318D3C6F0DC6C8E2C377103 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				1B8BF3DB582A658386E402C7 /* LibNovel.app */,
+				235967A21B386BE13F56F3F8 /* LibNovelTests.xctest */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		646952B9CE927F8038FF0A13 /* LibNovelTests */ = {
+			isa = PBXGroup;
+			children = (
+				B4C918833E173D6B44D06955 /* LibNovelTests.swift */,
+			);
+			path = LibNovelTests;
+			sourceTree = "<group>";
+		};
+		80148B5E27BD0A3DEDB3ADAA /* Models */ = {
+			isa = PBXGroup;
+			children = (
+				762E378B9BC2161A7AA2CC36 /* Models.swift */,
+			);
+			path = Models;
+			sourceTree = "<group>";
+		};
+		811FC0F6B9C209D6EC8543BD /* Home */ = {
+			isa = PBXGroup;
+			children = (
+				D6268D60803940CBD38FB921 /* HomeView.swift */,
+			);
+			path = Home;
+			sourceTree = "<group>";
+		};
+		89F2CB14192E7D7565A588E0 /* Player */ = {
+			isa = PBXGroup;
+			children = (
+				DF49C3AEF9D010F9FEDAB1FC /* PlayerViews.swift */,
+			);
+			path = Player;
+			sourceTree = "<group>";
+		};
+		8E8AAA58A33084ADB8AEA80C /* Browse */ = {
+			isa = PBXGroup;
+			children = (
+				1FA3F0FCA383180EE4C93BBA /* BrowseView.swift */,
+			);
+			path = Browse;
+			sourceTree = "<group>";
+		};
+		9AF55E5D62F980C72431782A = {
+			isa = PBXGroup;
+			children = (
+				A28A184E73B15138A4D13F31 /* LibNovel */,
+				646952B9CE927F8038FF0A13 /* LibNovelTests */,
+				6318D3C6F0DC6C8E2C377103 /* Products */,
+			);
+			indentWidth = 4;
+			sourceTree = "<group>";
+			tabWidth = 4;
+			usesTabs = 0;
+		};
+		A28A184E73B15138A4D13F31 /* LibNovel */ = {
+			isa = PBXGroup;
+			children = (
+				FE92158CC5DA9AD446062724 /* App */,
+				FD5EDEE9747643D45CA6423E /* Extensions */,
+				80148B5E27BD0A3DEDB3ADAA /* Models */,
+				426F7C5465758645B93A1AB1 /* Networking */,
+				2C0FB0EDFF9B3E24B97F4214 /* Resources */,
+				DA6F6F625578875F3E74F1D3 /* Services */,
+				B6916C5C762A37AB1279DF44 /* ViewModels */,
+				2C57B93EAF19A3B18E7B7E87 /* Views */,
+			);
+			path = LibNovel;
+			sourceTree = "<group>";
+		};
+		B6916C5C762A37AB1279DF44 /* ViewModels */ = {
+			isa = PBXGroup;
+			children = (
+				837F83AA12B59924FDF16617 /* BookDetailViewModel.swift */,
+				9812F5FE30ED657FB40ABD7A /* BrowseViewModel.swift */,
+				8995E667B3DD9CFCAD8A91D7 /* ChapterReaderViewModel.swift */,
+				3AB2E843D93461074A89A171 /* HomeViewModel.swift */,
+				FC338B05EA6DB22900712000 /* LibraryViewModel.swift */,
+				937A589F84FD412BBB6FBC45 /* ProfileViewModel.swift */,
+			);
+			path = ViewModels;
+			sourceTree = "<group>";
+		};
+		DA6F6F625578875F3E74F1D3 /* Services */ = {
+			isa = PBXGroup;
+			children = (
+				DB13E89E50529E3081533A66 /* AudioPlayerService.swift */,
+				F219788AE5ACBD6F240674F5 /* AuthStore.swift */,
+			);
+			path = Services;
+			sourceTree = "<group>";
+		};
+		FA994FD601E79EC811D822A4 /* Library */ = {
+			isa = PBXGroup;
+			children = (
+				C21107BECA55C07416E0CB8B /* LibraryView.swift */,
+			);
+			path = Library;
+			sourceTree = "<group>";
+		};
+		FB5C0D4925633786D28C6DE3 /* BookDetail */ = {
+			isa = PBXGroup;
+			children = (
+				39DE056C37FBC5EED8771821 /* BookDetailView.swift */,
+			);
+			path = BookDetail;
+			sourceTree = "<group>";
+		};
+		FD5EDEE9747643D45CA6423E /* Extensions */ = {
+			isa = PBXGroup;
+			children = (
+				9D83BB88C4306BE7A4F947CB /* Color+App.swift */,
+				7CAFB96D2500F34F0B0C860C /* NavDestination.swift */,
+				B2C3D4E5F67890123456789A /* String+App.swift */,
+			);
+			path = Extensions;
+			sourceTree = "<group>";
+		};
+		FE92158CC5DA9AD446062724 /* App */ = {
+			isa = PBXGroup;
+			children = (
+				4B820081FA4817765A39939A /* ContentView.swift */,
+				4F56C8E2BC3614530B81569D /* LibNovelApp.swift */,
+				2D5C115992F1CE2326236765 /* RootTabView.swift */,
+			);
+			path = App;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		5E6D3E8266BFCF0AAF5EC79D /* LibNovelTests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 964FF85B62FA35E819BE7661 /* Build configuration list for PBXNativeTarget "LibNovelTests" */;
+			buildPhases = (
+				247D45B3DB26CAC41FA78A0B /* Sources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				9FD4A50EB175FC09D6BFD28D /* PBXTargetDependency */,
+			);
+			name = LibNovelTests;
+			packageProductDependencies = (
+			);
+			productName = LibNovelTests;
+			productReference = 235967A21B386BE13F56F3F8 /* LibNovelTests.xctest */;
+			productType = "com.apple.product-type.bundle.unit-test";
+		};
+		D039EDECDE3998D8534BB680 /* LibNovel */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 29B2DE7267A3A4B2D89B32DA /* Build configuration list for PBXNativeTarget "LibNovel" */;
+			buildPhases = (
+				48661ADCA15B54E048CF694C /* Sources */,
+				27446CA4728C022832398376 /* Resources */,
+				EFE3211B202EDF04EB141EFB /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = LibNovel;
+			packageProductDependencies = (
+				09584EAB68A07B47F876A062 /* Kingfisher */,
+			);
+			productName = LibNovel;
+			productReference = 1B8BF3DB582A658386E402C7 /* LibNovel.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		A10A669C0C8B43078C0FEE9F /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				BuildIndependentTargetsInParallel = YES;
+				LastUpgradeCheck = 1600;
+			};
+			buildConfigurationList = D27899EE96A9AFCBBE62EA3C /* Build configuration list for PBXProject "LibNovel" */;
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				Base,
+				en,
+			);
+			mainGroup = 9AF55E5D62F980C72431782A;
+			minimizedProjectReferenceProxies = 1;
+			packageReferences = (
+				AFEF7128801A76181793EA9C /* XCRemoteSwiftPackageReference "Kingfisher" */,
+			);
+			preferredProjectObjectVersion = 77;
+			productRefGroup = 6318D3C6F0DC6C8E2C377103 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				D039EDECDE3998D8534BB680 /* LibNovel */,
+				5E6D3E8266BFCF0AAF5EC79D /* LibNovelTests */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		27446CA4728C022832398376 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				7C74C10317D389121922A5E3 /* Assets.xcassets in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		247D45B3DB26CAC41FA78A0B /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				4BB2C76262D5BD5DAD0D5D28 /* LibNovelTests.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		48661ADCA15B54E048CF694C /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				FB32F3772CA09684F00497F3 /* APIClient.swift in Sources */,
+				A9B95BAD7CE2DCD1DDDABD4C /* AudioPlayerService.swift in Sources */,
+				5D8D783259EF54C773788AAB /* AuthStore.swift in Sources */,
+				9B2D6F241E707312AB80DC31 /* AuthView.swift in Sources */,
+				749292A18C57FA41EC88A30B /* BookDetailView.swift in Sources */,
+				7D81DEB2EEFF9CA5079AEEF7 /* BookDetailViewModel.swift in Sources */,
+				08DFB5F626BA769556C8D145 /* BrowseView.swift in Sources */,
+				2790B8C051BE389D83645047 /* BrowseViewModel.swift in Sources */,
+				FEFB5FDC2424D22914458001 /* ChapterReaderView.swift in Sources */,
+				2A15157AD2AE2271675C3485 /* ChapterReaderViewModel.swift in Sources */,
+				E2572692178FD17145FDAF77 /* Color+App.swift in Sources */,
+				A1B2C3D4E5F6789012345678 /* String+App.swift in Sources */,
+				F2AF05B9C8C23132A73ACDD3 /* CommonViews.swift in Sources */,
+				94D0C4B15734B4056BF3B127 /* ContentView.swift in Sources */,
+				EF3C57C400BF05CBEAC1F7FE /* HomeView.swift in Sources */,
+				C807AD8D627CF6BED47D517C /* HomeViewModel.swift in Sources */,
+				032E049A4BB3CF0EA990C0CD /* LibNovelApp.swift in Sources */,
+				E1F564399D1325F6A1B2B84F /* LibraryView.swift in Sources */,
+				3521DFD5FCBBED7B90368829 /* LibraryViewModel.swift in Sources */,
+				0A52BC1CE71BED9E75D20D35 /* Models.swift in Sources */,
+				F4FDA3C44752EB979235C042 /* NavDestination.swift in Sources */,
+				BE7805A4E78037A82B12AE56 /* PlayerViews.swift in Sources */,
+				64D80AACB8E1967B17921EE3 /* ProfileView.swift in Sources */,
+				58E440CE4360D755401D1672 /* ProfileViewModel.swift in Sources */,
+				367C88FFC11701D2BAD8CCD0 /* RootTabView.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		9FD4A50EB175FC09D6BFD28D /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = D039EDECDE3998D8534BB680 /* LibNovel */;
+			targetProxy = 698AC3AA533BC05C985595D0 /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin XCBuildConfiguration section */
+		428871329DC9E7B31FA1664B /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+					"@loader_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = cc.kalekber.libnovel.tests;
+				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/LibNovel.app/LibNovel";
+			};
+			name = Release;
+		};
+		49CBF0D367E562629E002A4B /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+					"@loader_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = cc.kalekber.libnovel.tests;
+				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/LibNovel.app/LibNovel";
+			};
+			name = Debug;
+		};
+		8098D4A97F989064EC71E5A1 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CODE_SIGN_IDENTITY = "iPhone Developer";
+				DEVELOPMENT_TEAM = GHZXC6FVMU;
+				GENERATE_INFOPLIST_FILE = NO;
+				INFOPLIST_FILE = LibNovel/Resources/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = cc.kalekber.libnovel;
+				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		9C182367114E72FF84D54A2F /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				CURRENT_PROJECT_VERSION = 1;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_PREVIEWS = YES;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"$(inherited)",
+					"DEBUG=1",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
+				LIBNOVEL_BASE_URL = "https://v2.libnovel.kalekber.cc";
+				MARKETING_VERSION = 1.0.0;
+				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
+				MTL_FAST_MATH = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = iphoneos;
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.10;
+			};
+			name = Debug;
+		};
+		D9977A0FA70F052FD0C126D3 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CODE_SIGN_IDENTITY = "iPhone Developer";
+				DEVELOPMENT_TEAM = GHZXC6FVMU;
+				GENERATE_INFOPLIST_FILE = NO;
+				INFOPLIST_FILE = LibNovel/Resources/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = cc.kalekber.libnovel;
+				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Release;
+		};
+		F9ED141CFB1E2EC6F5E9F089 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				CURRENT_PROJECT_VERSION = 1;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_PREVIEWS = YES;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
+				LIBNOVEL_BASE_URL = "https://v2.libnovel.kalekber.cc";
+				MARKETING_VERSION = 1.0.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				MTL_FAST_MATH = YES;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = iphoneos;
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = "";
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				SWIFT_VERSION = 5.10;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		29B2DE7267A3A4B2D89B32DA /* Build configuration list for PBXNativeTarget "LibNovel" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				8098D4A97F989064EC71E5A1 /* Debug */,
+				D9977A0FA70F052FD0C126D3 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+		964FF85B62FA35E819BE7661 /* Build configuration list for PBXNativeTarget "LibNovelTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				49CBF0D367E562629E002A4B /* Debug */,
+				428871329DC9E7B31FA1664B /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+		D27899EE96A9AFCBBE62EA3C /* Build configuration list for PBXProject "LibNovel" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				9C182367114E72FF84D54A2F /* Debug */,
+				F9ED141CFB1E2EC6F5E9F089 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+/* End XCConfigurationList section */
+
+/* Begin XCRemoteSwiftPackageReference section */
+		AFEF7128801A76181793EA9C /* XCRemoteSwiftPackageReference "Kingfisher" */ = {
+			isa = XCRemoteSwiftPackageReference;
+			repositoryURL = "https://github.com/onevcat/Kingfisher";
+			requirement = {
+				kind = upToNextMajorVersion;
+				minimumVersion = 8.0.0;
+			};
+		};
+/* End XCRemoteSwiftPackageReference section */
+
+/* Begin XCSwiftPackageProductDependency section */
+		09584EAB68A07B47F876A062 /* Kingfisher */ = {
+			isa = XCSwiftPackageProductDependency;
+			package = AFEF7128801A76181793EA9C /* XCRemoteSwiftPackageReference "Kingfisher" */;
+			productName = Kingfisher;
+		};
+/* End XCSwiftPackageProductDependency section */
+	};
+	rootObject = A10A669C0C8B43078C0FEE9F /* Project object */;
+}

ios/LibNovel/LibNovel.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>

ios/LibNovel/LibNovel.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -0,0 +1,15 @@
+{
+  "originHash" : "18350c2bfa3935125b6f4e9817e7ed4508588c07142d420b8b8ee00640a57853",
+  "pins" : [
+    {
+      "identity" : "kingfisher",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/onevcat/Kingfisher",
+      "state" : {
+        "revision" : "c92b84898e34ab46ff0dad86c02a0acbe2d87008",
+        "version" : "8.8.0"
+      }
+    }
+  ],
+  "version" : 3
+}

ios/LibNovel/LibNovel.xcodeproj/xcshareddata/xcschemes/LibNovel.xcscheme

@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1600"
+   version = "1.7">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES"
+      runPostActionsOnFailure = "NO">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "D039EDECDE3998D8534BB680"
+               BuildableName = "LibNovel.app"
+               BlueprintName = "LibNovel"
+               ReferencedContainer = "container:LibNovel.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      onlyGenerateCoverageForSpecifiedTargets = "NO">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "D039EDECDE3998D8534BB680"
+            BuildableName = "LibNovel.app"
+            BlueprintName = "LibNovel"
+            ReferencedContainer = "container:LibNovel.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <Testables>
+         <TestableReference
+            skipped = "NO"
+            parallelizable = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "5E6D3E8266BFCF0AAF5EC79D"
+               BuildableName = "LibNovelTests.xctest"
+               BlueprintName = "LibNovelTests"
+               ReferencedContainer = "container:LibNovel.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+      <CommandLineArguments>
+      </CommandLineArguments>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "D039EDECDE3998D8534BB680"
+            BuildableName = "LibNovel.app"
+            BlueprintName = "LibNovel"
+            ReferencedContainer = "container:LibNovel.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+      <CommandLineArguments>
+      </CommandLineArguments>
+      <EnvironmentVariables>
+         <EnvironmentVariable
+            key = "LIBNOVEL_BASE_URL"
+            value = "[&quot;isEnabled&quot;: true, &quot;value&quot;: &quot;https://v2.libnovel.kalekber.cc&quot;]"
+            isEnabled = "YES">
+         </EnvironmentVariable>
+      </EnvironmentVariables>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "D039EDECDE3998D8534BB680"
+            BuildableName = "LibNovel.app"
+            BlueprintName = "LibNovel"
+            ReferencedContainer = "container:LibNovel.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+      <CommandLineArguments>
+      </CommandLineArguments>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

ios/LibNovel/LibNovel/App/ContentView.swift

@@ -0,0 +1,16 @@
+import SwiftUI
+
+struct ContentView: View {
+    @EnvironmentObject var authStore: AuthStore
+    @EnvironmentObject var audioPlayer: AudioPlayerService
+
+    var body: some View {
+        Group {
+            if authStore.isAuthenticated {
+                RootTabView()
+            } else {
+                AuthView()
+            }
+        }
+    }
+}

ios/LibNovel/LibNovel/App/LibNovelApp.swift

@@ -0,0 +1,15 @@
+import SwiftUI
+
+@main
+struct LibNovelApp: App {
+    @StateObject private var authStore = AuthStore()
+    @StateObject private var audioPlayer = AudioPlayerService()
+
+    var body: some Scene {
+        WindowGroup {
+            ContentView()
+                .environmentObject(authStore)
+                .environmentObject(audioPlayer)
+        }
+    }
+}

ios/LibNovel/LibNovel/App/RootTabView.swift

@@ -0,0 +1,105 @@
+import SwiftUI
+
+// MARK: - Root tab container with persistent mini-player overlay
+
+struct RootTabView: View {
+    @EnvironmentObject var authStore: AuthStore
+    @EnvironmentObject var audioPlayer: AudioPlayerService
+
+    @State private var selectedTab: Tab = .home
+    @State private var showFullPlayer: Bool = false
+
+    /// Live drag offset while the user is dragging the full player down.
+    @State private var fullPlayerDragOffset: CGFloat = 0
+
+    enum Tab: Hashable {
+        case home, library, browse, profile
+    }
+
+    /// Height of the mini player bar (progress line 2pt + vertical padding 20pt + content ~44pt)
+    private let miniPlayerBarHeight: CGFloat = AppLayout.miniPlayerBarHeight
+
+    var body: some View {
+        ZStack(alignment: .bottom) {
+            TabView(selection: $selectedTab) {
+                HomeView()
+                    .tabItem { Label("Home", systemImage: "house.fill") }
+                    .tag(Tab.home)
+
+                LibraryView()
+                    .tabItem { Label("Library", systemImage: "book.pages.fill") }
+                    .tag(Tab.library)
+
+                BrowseView()
+                    .tabItem { Label("Discover", systemImage: "sparkles") }
+                    .tag(Tab.browse)
+
+                ProfileView()
+                    .tabItem { Label("Profile", systemImage: "gear") }
+                    .tag(Tab.profile)
+            }
+            // Reserve space for the mini-player above the tab bar so scroll content
+            // never slides beneath it.
+            .safeAreaInset(edge: .bottom) {
+                if audioPlayer.isActive {
+                    Color.clear.frame(height: miniPlayerBarHeight)
+                }
+            }
+
+            // Mini-player pinned above the tab bar (hidden while full player is open)
+            if audioPlayer.isActive && !showFullPlayer {
+                MiniPlayerView(showFullPlayer: $showFullPlayer)
+                    .padding(.bottom, tabBarHeight)
+                    .transition(.move(edge: .bottom).combined(with: .opacity))
+                    .animation(.spring(response: 0.35, dampingFraction: 0.8), value: audioPlayer.isActive)
+            }
+
+            // Full player — slides up from the bottom as a custom overlay (not a sheet)
+            // so it feels physically connected to the mini player bar.
+            if showFullPlayer {
+                FullPlayerView(onDismiss: {
+                    withAnimation(.spring(response: 0.4, dampingFraction: 0.85)) {
+                        showFullPlayer = false
+                        fullPlayerDragOffset = 0
+                    }
+                })
+                .offset(y: max(fullPlayerDragOffset, 0))
+                .gesture(
+                    DragGesture(minimumDistance: 10)
+                        .onChanged { value in
+                            if value.translation.height > 0 {
+                                // Rubberband slightly so it doesn't feel locked
+                                fullPlayerDragOffset = value.translation.height
+                            }
+                        }
+                        .onEnded { value in
+                            let velocity = value.predictedEndTranslation.height - value.translation.height
+                            if value.translation.height > 120 || velocity > 400 {
+                                withAnimation(.spring(response: 0.4, dampingFraction: 0.85)) {
+                                    showFullPlayer = false
+                                    fullPlayerDragOffset = 0
+                                }
+                            } else {
+                                withAnimation(.spring(response: 0.35, dampingFraction: 0.8)) {
+                                    fullPlayerDragOffset = 0
+                                }
+                            }
+                        }
+                )
+                .transition(.move(edge: .bottom))
+                .animation(.spring(response: 0.45, dampingFraction: 0.85), value: showFullPlayer)
+                .ignoresSafeArea()
+            }
+        }
+        .animation(.spring(response: 0.45, dampingFraction: 0.85), value: showFullPlayer)
+    }
+
+    // Approximate safe-area-aware tab bar height
+    private var tabBarHeight: CGFloat {
+        let window = UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .first?.windows.first(where: \.isKeyWindow)
+        let bottomInset = window?.safeAreaInsets.bottom ?? 0
+        return 49 + bottomInset   // 49pt is the standard iOS tab bar height
+    }
+}

ios/LibNovel/LibNovel/Extensions/Color+App.swift

@@ -0,0 +1,10 @@
+import SwiftUI
+
+// MARK: - App accent color (amber — mirrors Tailwind amber-500 #f59e0b)
+extension Color {
+    static let amber = Color(red: 0.96, green: 0.62, blue: 0.04)
+}
+
+extension ShapeStyle where Self == Color {
+    static var amber: Color { .amber }
+}

ios/LibNovel/LibNovel/Extensions/NavDestination.swift

@@ -0,0 +1,36 @@
+import SwiftUI
+
+// MARK: - Navigation destination enum used across all tabs
+
+enum NavDestination: Hashable {
+    case book(String)               // slug
+    case chapter(String, Int)       // slug + chapter number
+}
+
+// MARK: - View extensions for shared navigation + error alert patterns
+
+extension View {
+    /// Registers the app-wide navigation destinations for NavDestination values.
+    /// Apply once per NavigationStack instead of repeating the switch in every tab.
+    func appNavigationDestination() -> some View {
+        navigationDestination(for: NavDestination.self) { dest in
+            switch dest {
+            case .book(let slug): BookDetailView(slug: slug)
+            case .chapter(let slug, let n): ChapterReaderView(slug: slug, chapterNumber: n)
+            }
+        }
+    }
+
+    /// Presents a standard "Error" alert driven by an optional String binding.
+    /// Dismissing the alert sets the binding back to nil.
+    func errorAlert(_ error: Binding<String?>) -> some View {
+        alert("Error", isPresented: Binding(
+            get: { error.wrappedValue != nil },
+            set: { if !$0 { error.wrappedValue = nil } }
+        )) {
+            Button("OK") { error.wrappedValue = nil }
+        } message: {
+            Text(error.wrappedValue ?? "")
+        }
+    }
+}

ios/LibNovel/LibNovel/Extensions/String+App.swift

@@ -0,0 +1,49 @@
+import Foundation
+
+// MARK: - String helpers for display purposes
+
+extension String {
+    /// Strips trailing relative-date suffixes (e.g. "2 years ago", "3 days ago",
+    /// or "(One)4 years ago" where the number is attached without a preceding space).
+    func strippingTrailingDate() -> String {
+        let units = ["second", "minute", "hour", "day", "week", "month", "year"]
+        let lower = self.lowercased()
+        for unit in units {
+            for suffix in [unit + "s ago", unit + " ago"] {
+                guard let suffixRange = lower.range(of: suffix, options: .backwards) else { continue }
+                // Everything before the suffix
+                let before = String(self[self.startIndex ..< suffixRange.lowerBound])
+                let trimmed = before.trimmingCharacters(in: .whitespaces)
+                // Strip trailing digits (the numeric count, which may be attached without a space)
+                var result = trimmed
+                while let last = result.last, last.isNumber {
+                    result.removeLast()
+                }
+                result = result.trimmingCharacters(in: .whitespaces)
+                if result != trimmed {
+                    // We actually stripped some digits — return cleaned result
+                    return result
+                }
+                // Fallback: number preceded by space
+                if let spaceIdx = trimmed.lastIndex(of: " ") {
+                    let potentialNum = String(trimmed[trimmed.index(after: spaceIdx)...])
+                    if Int(potentialNum) != nil {
+                        return String(trimmed[trimmed.startIndex ..< spaceIdx])
+                            .trimmingCharacters(in: .whitespaces)
+                    }
+                } else if Int(trimmed) != nil {
+                    return ""
+                }
+            }
+        }
+        return self
+    }
+}
+
+// MARK: - App-wide layout constants
+
+enum AppLayout {
+    /// Height of the persistent mini-player bar:
+    /// 12pt vertical padding (top) + 56pt cover height + 12pt vertical padding (bottom) + 12pt horizontal margin.
+    static let miniPlayerBarHeight: CGFloat = 92
+}

ios/LibNovel/LibNovel/Models/Models.swift

@@ -0,0 +1,212 @@
+import Foundation
+
+// MARK: - Book
+
+struct Book: Identifiable, Codable, Hashable {
+    let id: String
+    let slug: String
+    let title: String
+    let author: String
+    let cover: String
+    let status: String
+    let genres: [String]
+    let summary: String
+    let totalChapters: Int
+    let sourceURL: String
+    let ranking: Int
+    let metaUpdated: String
+
+    enum CodingKeys: String, CodingKey {
+        case id, slug, title, author, cover, status, genres, summary
+        case totalChapters = "total_chapters"
+        case sourceURL = "source_url"
+        case ranking
+        case metaUpdated = "meta_updated"
+    }
+
+    // PocketBase returns genres as either a JSON string array or a real array
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        id = try container.decode(String.self, forKey: .id)
+        slug = try container.decode(String.self, forKey: .slug)
+        title = try container.decode(String.self, forKey: .title)
+        author = try container.decode(String.self, forKey: .author)
+        cover = try container.decodeIfPresent(String.self, forKey: .cover) ?? ""
+        status = try container.decodeIfPresent(String.self, forKey: .status) ?? ""
+        totalChapters = try container.decodeIfPresent(Int.self, forKey: .totalChapters) ?? 0
+        sourceURL = try container.decodeIfPresent(String.self, forKey: .sourceURL) ?? ""
+        ranking = try container.decodeIfPresent(Int.self, forKey: .ranking) ?? 0
+        metaUpdated = try container.decodeIfPresent(String.self, forKey: .metaUpdated) ?? ""
+        summary = try container.decodeIfPresent(String.self, forKey: .summary) ?? ""
+
+        // genres is sometimes a JSON-encoded string, sometimes a real array
+        if let arr = try? container.decode([String].self, forKey: .genres) {
+            genres = arr
+        } else if let str = try? container.decode(String.self, forKey: .genres),
+                  let data = str.data(using: .utf8),
+                  let arr = try? JSONDecoder().decode([String].self, from: data) {
+            genres = arr
+        } else {
+            genres = []
+        }
+    }
+}
+
+// MARK: - ChapterIndex
+
+struct ChapterIndex: Identifiable, Codable, Hashable {
+    let id: String
+    let slug: String
+    let number: Int
+    let title: String
+    let dateLabel: String
+
+    enum CodingKeys: String, CodingKey {
+        case id, slug, number, title
+        case dateLabel = "date_label"
+    }
+}
+
+struct ChapterIndexBrief: Codable, Hashable {
+    let number: Int
+    let title: String
+}
+
+// MARK: - Progress
+
+struct ReadingProgress: Codable {
+    var id: String?
+    let sessionId: String
+    var userId: String?
+    let slug: String
+    var chapter: Int
+    var audioTime: Double?
+    let updated: String
+
+    enum CodingKeys: String, CodingKey {
+        case id
+        case sessionId = "session_id"
+        case userId = "user_id"
+        case slug, chapter
+        case audioTime = "audio_time"
+        case updated
+    }
+}
+
+// MARK: - User Settings
+
+struct UserSettings: Codable {
+    var id: String?
+    var autoNext: Bool
+    var voice: String
+    var speed: Double
+
+    // Server sends/expects camelCase: { autoNext, voice, speed }
+    // (No CodingKeys needed — Swift synthesises the same names by default)
+
+    static let `default` = UserSettings(id: nil, autoNext: false, voice: "af_bella", speed: 1.0)
+}
+
+// MARK: - User
+
+struct AppUser: Codable, Identifiable {
+    let id: String
+    let username: String
+    let role: String
+    let created: String
+
+    var isAdmin: Bool { role == "admin" }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        id       = try c.decode(String.self, forKey: .id)
+        username = try c.decode(String.self, forKey: .username)
+        role     = try c.decodeIfPresent(String.self, forKey: .role) ?? "user"
+        created  = try c.decodeIfPresent(String.self, forKey: .created) ?? ""
+    }
+}
+
+// MARK: - Ranking
+
+struct RankingItem: Codable, Identifiable {
+    var id: String { slug }
+    let rank: Int
+    let slug: String
+    let title: String
+    let author: String
+    let cover: String
+    let status: String
+    let genres: [String]
+    let sourceURL: String
+
+    enum CodingKeys: String, CodingKey {
+        case rank, slug, title, author, cover, status, genres
+        case sourceURL = "source_url"
+    }
+}
+
+// MARK: - Home
+
+struct HomeData {
+    let continueReading: [ContinueReadingItem]
+    let recentlyUpdated: [Book]
+    let stats: HomeStats
+}
+
+struct ContinueReadingItem: Identifiable {
+    var id: String { book.id }
+    let book: Book
+    let chapter: Int
+}
+
+struct HomeStats: Codable {
+    let totalBooks: Int
+    let totalChapters: Int
+    let booksInProgress: Int
+}
+
+// MARK: - Session
+
+struct UserSession: Codable, Identifiable {
+    let id: String
+    let userAgent: String
+    let ip: String
+    let createdAt: String
+    let lastSeen: String
+    var isCurrent: Bool
+
+    enum CodingKeys: String, CodingKey {
+        case id
+        case userAgent = "user_agent"
+        case ip
+        case createdAt = "created_at"
+        case lastSeen = "last_seen"
+        case isCurrent = "is_current"
+    }
+}
+
+struct PreviewChapter: Codable, Identifiable {
+    var id: Int { number }
+    let number: Int
+    let title: String
+    let url: String
+}
+
+struct BookBrief: Codable {
+    let slug: String
+    let title: String
+    let cover: String
+}
+
+// MARK: - Audio
+
+enum NextPrefetchStatus {
+    case none, prefetching, prefetched, failed
+}
+
+// MARK: - PocketBase list response
+
+struct PBList<T: Codable>: Codable {
+    let items: [T]
+    let totalItems: Int
+}

ios/LibNovel/LibNovel/Networking/APIClient.swift

@@ -0,0 +1,468 @@
+import Foundation
+
+// MARK: - API Client
+// Communicates with the SvelteKit UI server (not directly with the Go scraper).
+// The SvelteKit layer handles auth, PocketBase queries, and MinIO presigning.
+// For the iOS app we talk to the same /api/* endpoints the web UI uses,
+// so we reuse the exact same HMAC-cookie auth flow.
+
+actor APIClient {
+    static let shared = APIClient()
+
+    var baseURL: URL
+    private var authCookie: String?     // raw "libnovel_auth=<token>" header value
+    private var sessionId: String?      // anon session id (UUID)
+
+    // URLSession with persistent cookie storage
+    private let session: URLSession = {
+        let config = URLSessionConfiguration.default
+        config.httpCookieAcceptPolicy = .always
+        config.httpShouldSetCookies = true
+        config.httpCookieStorage = HTTPCookieStorage.shared
+        return URLSession(configuration: config)
+    }()
+
+    private init() {
+        // Default: point at the UI server. Override via Settings bundle or compile flag.
+        let urlString = Bundle.main.object(forInfoDictionaryKey: "LIBNOVEL_BASE_URL") as? String
+                        ?? "https://v2.libnovel.kalekber.cc"
+        baseURL = URL(string: urlString)!
+    }
+
+    // MARK: - Auth cookie management
+
+    func setAuthCookie(_ value: String?) {
+        authCookie = value
+        if let value {
+            // Also inject into shared cookie storage so redirects carry the cookie
+            let cookieProps: [HTTPCookiePropertyKey: Any] = [
+                .name: "libnovel_auth",
+                .value: value,
+                .domain: baseURL.host ?? "localhost",
+                .path: "/"
+            ]
+            if let cookie = HTTPCookie(properties: cookieProps) {
+                HTTPCookieStorage.shared.setCookie(cookie)
+            }
+        } else {
+            // Clear
+            let cookieStorage = HTTPCookieStorage.shared
+            cookieStorage.cookies(for: baseURL)?.forEach { cookieStorage.deleteCookie($0) }
+        }
+    }
+
+    func setSessionId(_ id: String) {
+        sessionId = id
+    }
+
+    // MARK: - Low-level request builder
+
+    private func makeRequest(_ path: String, method: String = "GET", body: Encodable? = nil) throws -> URLRequest {
+        // Build URL by appending the path string directly to the base URL string.
+        // appendingPathComponent() percent-encodes slashes, which breaks multi-segment
+        // paths like /api/chapter/slug/1. URL(string:) preserves slashes correctly.
+        let urlString = baseURL.absoluteString.trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+            + "/" + path.trimmingCharacters(in: CharacterSet(charactersIn: "/"))
+        guard let url = URL(string: urlString) else {
+            throw APIError.invalidResponse
+        }
+        var req = URLRequest(url: url)
+        req.httpMethod = method
+        req.setValue("application/json", forHTTPHeaderField: "Accept")
+        if let body {
+            req.setValue("application/json", forHTTPHeaderField: "Content-Type")
+            req.httpBody = try JSONEncoder().encode(body)
+        }
+        return req
+    }
+
+    // MARK: - Generic fetch
+
+    func fetch<T: Decodable>(_ path: String, method: String = "GET", body: Encodable? = nil) async throws -> T {
+        let req = try makeRequest(path, method: method, body: body)
+        let (data, response) = try await session.data(for: req)
+        guard let http = response as? HTTPURLResponse else {
+            throw APIError.invalidResponse
+        }
+        let rawBody = String(data: data, encoding: .utf8) ?? "<non-utf8 data, \(data.count) bytes>"
+        guard (200..<300).contains(http.statusCode) else {
+            throw APIError.httpError(http.statusCode, rawBody)
+        }
+        do {
+            return try JSONDecoder.iso8601.decode(T.self, from: data)
+        } catch {
+            throw APIError.decodingError(error)
+        }
+    }
+
+    func fetchRaw(_ path: String, method: String = "GET", body: Encodable? = nil) async throws -> (Data, HTTPURLResponse) {
+        let req = try makeRequest(path, method: method, body: body)
+        let (data, response) = try await session.data(for: req)
+        guard let http = response as? HTTPURLResponse else { throw APIError.invalidResponse }
+        return (data, http)
+    }
+
+    // MARK: - Auth
+
+    struct LoginRequest: Encodable {
+        let username: String
+        let password: String
+    }
+
+    struct LoginResponse: Decodable {
+        let token: String
+        let user: AppUser
+    }
+
+    func login(username: String, password: String) async throws -> LoginResponse {
+        try await fetch("/api/auth/login", method: "POST",
+                        body: LoginRequest(username: username, password: password))
+    }
+
+    func register(username: String, password: String) async throws -> LoginResponse {
+        try await fetch("/api/auth/register", method: "POST",
+                        body: LoginRequest(username: username, password: password))
+    }
+
+    func logout() async throws {
+        let (_, _) = try await fetchRaw("/api/auth/logout", method: "POST")
+        await setAuthCookie(nil)
+    }
+
+    // MARK: - Home
+
+    func homeData() async throws -> HomeDataResponse {
+        try await fetch("/api/home")
+    }
+
+    // MARK: - Library
+
+    func library() async throws -> [LibraryItem] {
+        try await fetch("/api/library")
+    }
+
+    func saveBook(slug: String) async throws {
+        let _: EmptyResponse = try await fetch("/api/library/\(slug)", method: "POST")
+    }
+
+    func unsaveBook(slug: String) async throws {
+        let _: EmptyResponse = try await fetch("/api/library/\(slug)", method: "DELETE")
+    }
+
+    // MARK: - Book Detail
+
+    func bookDetail(slug: String) async throws -> BookDetailResponse {
+        try await fetch("/api/book/\(slug)")
+    }
+
+    // MARK: - Chapter
+
+    func chapterContent(slug: String, chapter: Int) async throws -> ChapterResponse {
+        try await fetch("/api/chapter/\(slug)/\(chapter)")
+    }
+
+    // MARK: - Browse
+
+    struct BrowseParams: Encodable {
+        let page: Int
+        let genre: String
+        let sort: String
+        let status: String
+    }
+
+    func browse(page: Int, genre: String = "all", sort: String = "popular", status: String = "all") async throws -> BrowseResponse {
+        let query = "?page=\(page)&genre=\(genre)&sort=\(sort)&status=\(status)"
+        return try await fetch("/api/browse-page\(query)")
+    }
+
+    func search(query: String) async throws -> SearchResponse {
+        let encoded = query.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? query
+        return try await fetch("/api/search?q=\(encoded)")
+    }
+
+    func ranking() async throws -> [RankingItem] {
+        try await fetch("/api/ranking")
+    }
+
+    // MARK: - Progress
+
+    func progress() async throws -> [ProgressEntry] {
+        try await fetch("/api/progress")
+    }
+
+    func setProgress(slug: String, chapter: Int) async throws {
+        struct Body: Encodable { let chapter: Int }
+        let _: EmptyResponse = try await fetch("/api/progress/\(slug)", method: "POST", body: Body(chapter: chapter))
+    }
+
+    func audioTime(slug: String, chapter: Int) async throws -> Double? {
+        struct Response: Decodable { let audioTime: Double?; enum CodingKeys: String, CodingKey { case audioTime = "audio_time" } }
+        let r: Response = try await fetch("/api/progress/audio-time?slug=\(slug)&chapter=\(chapter)")
+        return r.audioTime
+    }
+
+    func setAudioTime(slug: String, chapter: Int, time: Double) async throws {
+        struct Body: Encodable { let slug: String; let chapter: Int; let audioTime: Double; enum CodingKeys: String, CodingKey { case slug, chapter; case audioTime = "audio_time" } }
+        let _: EmptyResponse = try await fetch("/api/progress/audio-time", method: "PATCH", body: Body(slug: slug, chapter: chapter, audioTime: time))
+    }
+
+    // MARK: - Audio
+
+    func triggerAudio(slug: String, chapter: Int, voice: String, speed: Double) async throws -> AudioTriggerResponse {
+        struct Body: Encodable { let voice: String; let speed: Double }
+        return try await fetch("/api/audio/\(slug)/\(chapter)", method: "POST", body: Body(voice: voice, speed: speed))
+    }
+
+    /// Poll GET /api/audio/status/{slug}/{n}?voice=... until the job is done or failed.
+    /// Returns the presigned/proxy URL on success, throws on failure or cancellation.
+    func pollAudioStatus(slug: String, chapter: Int, voice: String) async throws -> String {
+        let path = "/api/audio/status/\(slug)/\(chapter)?voice=\(voice)"
+        struct StatusResponse: Decodable {
+            let status: String
+            let url: String?
+            let error: String?
+        }
+        while true {
+            try Task.checkCancellation()
+            let r: StatusResponse = try await fetch(path)
+            switch r.status {
+            case "done":
+                guard let url = r.url, !url.isEmpty else {
+                    throw URLError(.badServerResponse)
+                }
+                return url
+            case "failed":
+                throw NSError(
+                    domain: "AudioGeneration",
+                    code: 0,
+                    userInfo: [NSLocalizedDescriptionKey: r.error ?? "Audio generation failed"]
+                )
+            default:
+                // pending / generating / idle — keep polling
+                try await Task.sleep(nanoseconds: 2_000_000_000) // 2 s
+            }
+        }
+    }
+
+    func presignAudio(slug: String, chapter: Int, voice: String) async throws -> String {
+        struct Response: Decodable { let url: String }
+        let r: Response = try await fetch("/api/presign/audio?slug=\(slug)&chapter=\(chapter)&voice=\(voice)")
+        return r.url
+    }
+
+    func presignVoiceSample(voice: String) async throws -> String {
+        struct Response: Decodable { let url: String }
+        let r: Response = try await fetch("/api/presign/voice-sample?voice=\(voice)")
+        return r.url
+    }
+
+    func voices() async throws -> [String] {
+        struct Response: Decodable { let voices: [String] }
+        let r: Response = try await fetch("/api/voices")
+        return r.voices
+    }
+
+    // MARK: - Settings
+
+    func settings() async throws -> UserSettings {
+        try await fetch("/api/settings")
+    }
+
+    func updateSettings(_ settings: UserSettings) async throws {
+        let _: EmptyResponse = try await fetch("/api/settings", method: "PUT", body: settings)
+    }
+
+    // MARK: - Sessions
+
+    func sessions() async throws -> [UserSession] {
+        struct Response: Decodable { let sessions: [UserSession] }
+        let r: Response = try await fetch("/api/sessions")
+        return r.sessions
+    }
+
+    func revokeSession(id: String) async throws {
+        let _: EmptyResponse = try await fetch("/api/sessions/\(id)", method: "DELETE")
+    }
+}
+
+// MARK: - Response types
+
+struct HomeDataResponse: Decodable {
+    struct ContinueItem: Decodable {
+        let book: Book
+        let chapter: Int
+    }
+    let continueReading: [ContinueItem]
+    let recentlyUpdated: [Book]
+    let stats: HomeStats
+
+    enum CodingKeys: String, CodingKey {
+        case continueReading = "continue_reading"
+        case recentlyUpdated = "recently_updated"
+        case stats
+    }
+}
+
+struct LibraryItem: Decodable, Identifiable {
+    var id: String { book.id }
+    let book: Book
+    let savedAt: String
+    let lastChapter: Int?
+
+    enum CodingKeys: String, CodingKey {
+        case book
+        case savedAt = "saved_at"
+        case lastChapter = "last_chapter"
+    }
+}
+
+struct BookDetailResponse: Decodable {
+    let book: Book
+    let chapters: [ChapterIndex]
+    let previewChapters: [PreviewChapter]?
+    let inLib: Bool
+    let saved: Bool
+    let lastChapter: Int?
+
+    enum CodingKeys: String, CodingKey {
+        case book, chapters
+        case previewChapters = "preview_chapters"
+        case inLib = "in_lib"
+        case saved
+        case lastChapter = "last_chapter"
+    }
+}
+
+struct ChapterResponse: Decodable {
+    let book: BookBrief
+    let chapter: ChapterIndex
+    let html: String
+    let voices: [String]
+    let prev: Int?
+    let next: Int?
+    let chapters: [ChapterIndexBrief]
+    let isPreview: Bool
+
+    enum CodingKeys: String, CodingKey {
+        case book, chapter, html, voices, prev, next, chapters
+        case isPreview = "is_preview"
+    }
+}
+
+struct BrowseResponse: Decodable {
+    let novels: [BrowseNovel]
+    let page: Int
+    let hasNext: Bool
+
+    enum CodingKeys: String, CodingKey {
+        case novels, page
+        case hasNext = "hasNext"
+    }
+}
+
+struct BrowseNovel: Decodable, Identifiable, Hashable {
+    var id: String { slug.isEmpty ? url : slug }
+    let slug: String
+    let title: String
+    let cover: String
+    let rank: String
+    let rating: String
+    let chapters: String
+    let url: String
+    let author: String
+    let status: String
+    let genres: [String]
+
+    enum CodingKeys: String, CodingKey {
+        case slug, title, cover, rank, rating, chapters, url, author, status, genres
+    }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        slug    = try c.decodeIfPresent(String.self, forKey: .slug) ?? ""
+        title   = try c.decode(String.self, forKey: .title)
+        cover   = try c.decodeIfPresent(String.self, forKey: .cover) ?? ""
+        rank    = try c.decodeIfPresent(String.self, forKey: .rank) ?? ""
+        rating  = try c.decodeIfPresent(String.self, forKey: .rating) ?? ""
+        chapters = try c.decodeIfPresent(String.self, forKey: .chapters) ?? ""
+        url     = try c.decodeIfPresent(String.self, forKey: .url) ?? ""
+        author  = try c.decodeIfPresent(String.self, forKey: .author) ?? ""
+        status  = try c.decodeIfPresent(String.self, forKey: .status) ?? ""
+        genres  = try c.decodeIfPresent([String].self, forKey: .genres) ?? []
+    }
+}
+
+struct SearchResponse: Decodable {
+    let results: [BrowseNovel]
+    let localCount: Int
+    let remoteCount: Int
+
+    enum CodingKeys: String, CodingKey {
+        case results
+        case localCount = "local_count"
+        case remoteCount = "remote_count"
+    }
+}
+
+/// Returned by POST /api/audio/{slug}/{n}.
+/// - 202 Accepted: job enqueued → poll via pollAudioStatus()
+/// - 200 OK: audio already cached → url is ready to play
+struct AudioTriggerResponse: Decodable {
+    let jobId: String?   // present on 202
+    let status: String?  // present on 202: "pending" | "generating"
+    let url: String?     // present on 200: proxy URL ready to play
+    let filename: String? // present on 200
+
+    enum CodingKeys: String, CodingKey {
+        case jobId = "job_id"
+        case status, url, filename
+    }
+
+    /// True when the server accepted the request and created an async job.
+    var isAsync: Bool { jobId != nil }
+}
+
+struct ProgressEntry: Decodable, Identifiable {
+    var id: String { slug }
+    let slug: String
+    let chapter: Int
+    let audioTime: Double?
+    let updated: String
+
+    enum CodingKeys: String, CodingKey {
+        case slug, chapter, updated
+        case audioTime = "audio_time"
+    }
+}
+
+struct EmptyResponse: Decodable {}
+
+// MARK: - API Error
+
+enum APIError: LocalizedError {
+    case invalidResponse
+    case httpError(Int, String)
+    case decodingError(Error)
+    case unauthorized
+    case networkError(Error)
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidResponse: return "Invalid server response"
+        case .httpError(let code, let msg): return "HTTP \(code): \(msg)"
+        case .decodingError(let e): return "Decode error: \(e.localizedDescription)"
+        case .unauthorized: return "Not authenticated"
+        case .networkError(let e): return e.localizedDescription
+        }
+    }
+}
+
+// MARK: - JSONDecoder helper
+
+extension JSONDecoder {
+    static let iso8601: JSONDecoder = {
+        let d = JSONDecoder()
+        d.dateDecodingStrategy = .iso8601
+        return d
+    }()
+}

ios/LibNovel/LibNovel/Resources/Assets.xcassets/AccentColor.colorset/Contents.json

@@ -0,0 +1,12 @@
+{
+  "colors": [
+    {
+      "color": {
+        "color-space": "srgb",
+        "components": { "alpha": "1.000", "blue": "0.040", "green": "0.620", "red": "0.960" }
+      },
+      "idiom": "universal"
+    }
+  ],
+  "info": { "author": "xcode", "version": 1 }
+}

ios/LibNovel/LibNovel/Resources/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,14 @@
+{
+  "images" : [
+    {
+      "filename" : "icon-1024.png",
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

ios/LibNovel/LibNovel/Resources/Assets.xcassets/Contents.json

@@ -0,0 +1,3 @@
+{
+  "info": { "author": "xcode", "version": 1 }
+}

ios/LibNovel/LibNovel/Resources/Info.plist

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleName</key>
+	<string>LibNovel</string>
+	<key>CFBundleDisplayName</key>
+	<string>LibNovel</string>
+	<key>CFBundleIdentifier</key>
+	<string>cc.kalekber.libnovel</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>$(MARKETING_VERSION)</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UISupportedInterfaceOrientations~ipad</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UILaunchScreen</key>
+	<dict/>
+	<key>UIBackgroundModes</key>
+	<array>
+		<string>audio</string>
+	</array>
+	<key>LIBNOVEL_BASE_URL</key>
+	<string>$(LIBNOVEL_BASE_URL)</string>
+</dict>
+</plist>

ios/LibNovel/LibNovel/Services/AudioPlayerService.swift

@@ -0,0 +1,576 @@
+import Foundation
+import AVFoundation
+import MediaPlayer
+import Combine
+
+// MARK: - PlaybackProgress
+// Isolated ObservableObject for high-frequency playback state (currentTime,
+// duration, isPlaying). Keeping these separate from AudioPlayerService means
+// the 0.5-second time-observer ticks only invalidate views that explicitly
+// observe PlaybackProgress — menus and other stable UI are unaffected.
+
+@MainActor
+final class PlaybackProgress: ObservableObject {
+    @Published var currentTime: Double = 0
+    @Published var duration: Double = 0
+    @Published var isPlaying: Bool = false
+}
+
+// MARK: - AudioPlayerService
+// Central singleton that owns AVPlayer, drives audio state, handles lock-screen
+// controls (NowPlayingInfoCenter + MPRemoteCommandCenter), and pre-fetches the
+// next chapter audio.
+
+@MainActor
+final class AudioPlayerService: ObservableObject {
+
+    // MARK: - Published state
+
+    @Published var slug: String = ""
+    @Published var chapter: Int = 0
+    @Published var chapterTitle: String = ""
+    @Published var bookTitle: String = ""
+    @Published var coverURL: String = ""
+    @Published var voice: String = "af_bella"
+    @Published var speed: Double = 1.0
+    @Published var chapters: [ChapterIndexBrief] = []
+
+    @Published var status: AudioPlayerStatus = .idle
+    @Published var audioURL: String = ""
+    @Published var errorMessage: String = ""
+    @Published var generationProgress: Double = 0
+
+    /// High-frequency playback state (currentTime / duration / isPlaying).
+    /// Views that only need the seek bar or play-pause button should observe
+    /// this directly so they don't trigger re-renders of menu-bearing parents.
+    let progress = PlaybackProgress()
+
+    // Convenience forwarders so non-view call sites keep compiling unchanged.
+    var currentTime: Double {
+        get { progress.currentTime }
+        set { progress.currentTime = newValue }
+    }
+    var duration: Double {
+        get { progress.duration }
+        set { progress.duration = newValue }
+    }
+    var isPlaying: Bool {
+        get { progress.isPlaying }
+        set { progress.isPlaying = newValue }
+    }
+
+    @Published var autoNext: Bool = false
+    @Published var nextChapter: Int? = nil
+    @Published var prevChapter: Int? = nil
+    
+    @Published var sleepTimer: SleepTimerOption? = nil
+
+    @Published var nextPrefetchStatus: NextPrefetchStatus = .none
+    @Published var nextAudioURL: String = ""
+    @Published var nextPrefetchedChapter: Int? = nil
+
+    var isActive: Bool {
+        switch status {
+        case .idle: return false
+        default: return true
+        }
+    }
+    
+    /// Absolute previous chapter number (current - 1), or nil if at first chapter
+    var absolutePrevChapter: Int? {
+        guard chapter > 1 else { return nil }
+        return chapter - 1
+    }
+    
+    /// Absolute next chapter number (current + 1), or nil if at last chapter
+    var absoluteNextChapter: Int? {
+        guard !chapters.isEmpty else { return nil }
+        let maxChapter = chapters.map(\.number).max() ?? chapter
+        guard chapter < maxChapter else { return nil }
+        return chapter + 1
+    }
+
+    // MARK: - Private
+
+    private var player: AVPlayer?
+    private var playerItem: AVPlayerItem?
+    private var timeObserver: Any?
+    private var statusObserver: AnyCancellable?
+    private var durationObserver: AnyCancellable?
+    private var finishObserver: AnyCancellable?
+    private var generationTask: Task<Void, Never>?
+    private var prefetchTask: Task<Void, Never>?
+
+    // Cached cover image — downloaded once per chapter load, reused on every
+    // updateNowPlaying() call so we don't re-download on every play/pause/seek.
+    private var cachedCoverArtwork: MPMediaItemArtwork?
+    private var cachedCoverURL: String = ""
+    
+    // Sleep timer tracking
+    private var sleepTimerTask: Task<Void, Never>?
+    private var sleepTimerStartChapter: Int = 0
+
+    // MARK: - Init
+
+    init() {
+        configureAudioSession()
+        setupRemoteCommandCenter()
+    }
+
+    // MARK: - Public API
+
+    /// Load audio for a specific chapter. Triggers TTS generation if not cached.
+    func load(slug: String, chapter: Int, chapterTitle: String,
+              bookTitle: String, coverURL: String, voice: String, speed: Double,
+              chapters: [ChapterIndexBrief], nextChapter: Int?, prevChapter: Int?) {
+        generationTask?.cancel()
+        prefetchTask?.cancel()
+        stop()
+
+        self.slug = slug
+        self.chapter = chapter
+        self.chapterTitle = chapterTitle
+        self.bookTitle = bookTitle
+        self.coverURL = coverURL
+        self.voice = voice
+        self.speed = speed
+        self.chapters = chapters
+        self.nextChapter = nextChapter
+        self.prevChapter = prevChapter
+        self.nextPrefetchStatus = .none
+        self.nextAudioURL = ""
+        self.nextPrefetchedChapter = nil
+        
+        // Reset sleep timer start chapter if it's a chapter-based timer
+        if case .chapters = sleepTimer {
+            sleepTimerStartChapter = chapter
+        }
+
+        status = .generating
+        generationProgress = 0
+
+        // Invalidate cover cache if the book changed.
+        if coverURL != cachedCoverURL {
+            cachedCoverArtwork = nil
+            cachedCoverURL = coverURL
+            prefetchCoverArtwork(from: coverURL)
+        }
+
+        generationTask = Task { await generateAudio() }
+    }
+
+    func play() {
+        player?.play()
+        player?.rate = Float(speed)
+        isPlaying = true
+        updateNowPlaying()
+    }
+
+    func pause() {
+        player?.pause()
+        isPlaying = false
+        updateNowPlaying()
+    }
+
+    func togglePlayPause() {
+        isPlaying ? pause() : play()
+    }
+
+    func seek(to seconds: Double) {
+        let time = CMTime(seconds: seconds, preferredTimescale: 600)
+        currentTime = seconds   // optimistic UI update
+        player?.seek(to: time, toleranceBefore: .zero, toleranceAfter: .zero) { [weak self] _ in
+            guard let self else { return }
+            Task { @MainActor in self.updateNowPlaying() }
+        }
+    }
+
+    func skip(by seconds: Double) {
+        seek(to: max(0, min(currentTime + seconds, duration)))
+    }
+
+    func setSpeed(_ newSpeed: Double) {
+        speed = newSpeed
+        if isPlaying { player?.rate = Float(newSpeed) }
+        updateNowPlaying()
+    }
+    
+    func setSleepTimer(_ option: SleepTimerOption?) {
+        // Cancel existing timer
+        sleepTimerTask?.cancel()
+        sleepTimerTask = nil
+        
+        sleepTimer = option
+        
+        guard let option else { return }
+        
+        // Start timer based on option
+        switch option {
+        case .chapters(let count):
+            sleepTimerStartChapter = chapter
+            // Monitor chapter changes in handlePlaybackFinished
+            
+        case .minutes(let minutes):
+            sleepTimerTask = Task { [weak self] in
+                try? await Task.sleep(nanoseconds: UInt64(minutes) * 60 * 1_000_000_000)
+                guard let self, !Task.isCancelled else { return }
+                await MainActor.run {
+                    self.stop()
+                    self.sleepTimer = nil
+                }
+            }
+        }
+    }
+
+    func stop() {
+        player?.pause()
+        teardownPlayer()
+        isPlaying = false
+        currentTime = 0
+        duration = 0
+        audioURL = ""
+        status = .idle
+        
+        // Cancel sleep timer
+        sleepTimerTask?.cancel()
+        sleepTimerTask = nil
+        sleepTimer = nil
+    }
+
+    // MARK: - Audio generation
+
+    private func generateAudio() async {
+        guard !slug.isEmpty, chapter > 0 else { return }
+        do {
+            // Fast path: audio already in MinIO — get a presigned URL and play immediately.
+            if let presignedURL = try? await APIClient.shared.presignAudio(slug: slug, chapter: chapter, voice: voice) {
+                audioURL = presignedURL
+                status = .ready
+                generationProgress = 100
+                await playURL(presignedURL)
+                await prefetchNext()
+                return
+            }
+
+            // Slow path: trigger TTS generation (async — returns 202 immediately).
+            status = .generating
+            generationProgress = 10
+            let trigger = try await APIClient.shared.triggerAudio(slug: slug, chapter: chapter, voice: voice, speed: speed)
+
+            let playableURL: String
+            if trigger.isAsync {
+                // 202 Accepted: poll until done.
+                generationProgress = 30
+                playableURL = try await APIClient.shared.pollAudioStatus(slug: slug, chapter: chapter, voice: voice)
+            } else {
+                // 200: already cached URL returned inline.
+                guard let url = trigger.url, !url.isEmpty else {
+                    throw URLError(.badServerResponse)
+                }
+                playableURL = url
+            }
+
+            audioURL = playableURL
+            status = .ready
+            generationProgress = 100
+            await playURL(playableURL)
+            await prefetchNext()
+        } catch is CancellationError {
+            // Cancelled — no-op
+        } catch {
+            status = .error(error.localizedDescription)
+            errorMessage = error.localizedDescription
+        }
+    }
+
+    // MARK: - Prefetch next chapter
+    // Always prefetch regardless of autoNext — faster playback when the user
+    // manually navigates forward. autoNext only controls whether we auto-navigate.
+
+    private func prefetchNext() async {
+        guard let next = nextChapter, !Task.isCancelled else { return }
+        nextPrefetchStatus = .prefetching
+        nextPrefetchedChapter = next
+        do {
+            // Fast path: already in MinIO.
+            if let presignedURL = try? await APIClient.shared.presignAudio(slug: slug, chapter: next, voice: voice) {
+                nextAudioURL = presignedURL
+                nextPrefetchStatus = .prefetched
+                return
+            }
+            // Slow path: trigger generation; poll until done (background — won't block playback).
+            let trigger = try await APIClient.shared.triggerAudio(slug: slug, chapter: next, voice: voice, speed: speed)
+            let url: String
+            if trigger.isAsync {
+                url = try await APIClient.shared.pollAudioStatus(slug: slug, chapter: next, voice: voice)
+            } else {
+                guard let u = trigger.url, !u.isEmpty else { throw URLError(.badServerResponse) }
+                url = u
+            }
+            nextAudioURL = url
+            nextPrefetchStatus = .prefetched
+        } catch {
+            nextPrefetchStatus = .failed
+        }
+    }
+
+    // MARK: - AVPlayer management
+
+    private func playURL(_ urlString: String) async {
+        // Resolve relative paths (e.g. "/api/audio/...") to absolute URLs.
+        let resolved: URL?
+        if urlString.hasPrefix("http://") || urlString.hasPrefix("https://") {
+            resolved = URL(string: urlString)
+        } else {
+            resolved = URL(string: urlString, relativeTo: await APIClient.shared.baseURL)?.absoluteURL
+        }
+        guard let url = resolved else { return }
+        teardownPlayer()
+        let item = AVPlayerItem(url: url)
+        playerItem = item
+        player = AVPlayer(playerItem: item)
+
+        // KVO: update duration as soon as asset metadata is loaded.
+        durationObserver = item.publisher(for: \.duration)
+            .receive(on: RunLoop.main)
+            .sink { [weak self] dur in
+                guard let self else { return }
+                let secs = dur.seconds
+                if secs.isFinite && secs > 0 {
+                    self.duration = secs
+                    self.updateNowPlaying()
+                }
+            }
+
+        // KVO: set playback rate once the item is ready.
+        // Do NOT call player?.play() unconditionally — let readyToPlay trigger it
+        // so we don't race between AVPlayer's internal buffering and our call.
+        statusObserver = item.publisher(for: \.status)
+            .receive(on: RunLoop.main)
+            .sink { [weak self] itemStatus in
+                guard let self else { return }
+                if itemStatus == .readyToPlay {
+                    self.player?.rate = Float(self.speed)
+                    self.isPlaying = true
+                    self.updateNowPlaying()
+                } else if itemStatus == .failed {
+                    self.status = .error(item.error?.localizedDescription ?? "Playback failed")
+                    self.errorMessage = item.error?.localizedDescription ?? "Playback failed"
+                }
+            }
+
+        // Periodic time observer for seek bar position.
+        timeObserver = player?.addPeriodicTimeObserver(
+            forInterval: CMTime(seconds: 0.5, preferredTimescale: 600),
+            queue: .main
+        ) { [weak self] time in
+            guard let self else { return }
+            Task { @MainActor in
+                let secs = time.seconds
+                if secs.isFinite && secs >= 0 {
+                    self.currentTime = secs
+                }
+            }
+        }
+
+        // Observe when playback ends.
+        finishObserver = NotificationCenter.default
+            .publisher(for: AVPlayerItem.didPlayToEndTimeNotification, object: item)
+            .sink { [weak self] _ in
+                Task { @MainActor in
+                    self?.handlePlaybackFinished()
+                }
+            }
+
+        // Kick off buffering — actual playback starts via statusObserver above.
+        player?.play()
+    }
+
+    private func teardownPlayer() {
+        if let observer = timeObserver { player?.removeTimeObserver(observer) }
+        timeObserver = nil
+        statusObserver = nil
+        durationObserver = nil
+        finishObserver = nil
+        player = nil
+        playerItem = nil
+    }
+
+    private func handlePlaybackFinished() {
+        isPlaying = false
+
+        guard let next = nextChapter else { return }
+        
+        // Check chapter-based sleep timer
+        if case .chapters(let count) = sleepTimer {
+            let chaptersPlayed = chapter - sleepTimerStartChapter + 1
+            if chaptersPlayed >= count {
+                stop()
+                return
+            }
+        }
+
+        // Always notify the view that the chapter finished (it may update UI).
+        NotificationCenter.default.post(
+            name: .audioDidFinishChapter,
+            object: nil,
+            userInfo: ["next": next, "autoNext": autoNext]
+        )
+
+        // If autoNext is on, load the next chapter internally right away.
+        // We already have the metadata in `chapters`, so we can reconstruct
+        // everything without waiting for the view to navigate.
+        guard autoNext else { return }
+
+        let nextTitle = chapters.first(where: { $0.number == next })?.title ?? ""
+        let nextNextChapter = chapters.first(where: { $0.number > next })?.number
+        let nextPrevChapter: Int? = chapter  // Current chapter becomes previous for the next one
+
+        // If we already prefetched a URL for the next chapter, skip straight to
+        // playback and kick off generation in the background for the one after.
+        if nextPrefetchStatus == .prefetched, !nextAudioURL.isEmpty {
+            let url = nextAudioURL
+
+            // Advance state before tearing down the current player.
+            chapter = next
+            chapterTitle = nextTitle
+            nextChapter = nextNextChapter
+            prevChapter = nextPrevChapter
+            nextPrefetchStatus = .none
+            nextAudioURL = ""
+            nextPrefetchedChapter = nil
+            audioURL = url
+            status = .ready
+            generationProgress = 100
+            
+            // Update sleep timer start chapter if using chapter-based timer
+            if case .chapters = sleepTimer {
+                sleepTimerStartChapter = next
+            }
+
+            generationTask = Task {
+                await playURL(url)
+                await prefetchNext()
+            }
+        } else {
+            // No prefetch available — do a full load.
+            load(
+                slug: slug,
+                chapter: next,
+                chapterTitle: nextTitle,
+                bookTitle: bookTitle,
+                coverURL: coverURL,
+                voice: voice,
+                speed: speed,
+                chapters: chapters,
+                nextChapter: nextNextChapter,
+                prevChapter: nextPrevChapter
+            )
+        }
+    }
+
+    // MARK: - Cover art prefetch
+
+    private func prefetchCoverArtwork(from urlString: String) {
+        guard !urlString.isEmpty, let url = URL(string: urlString) else { return }
+        URLSession.shared.dataTask(with: url) { [weak self] data, _, _ in
+            guard let self, let data, let image = UIImage(data: data) else { return }
+            let artwork = MPMediaItemArtwork(boundsSize: image.size) { _ in image }
+            Task { @MainActor in
+                self.cachedCoverArtwork = artwork
+                self.updateNowPlaying()
+            }
+        }.resume()
+    }
+
+    // MARK: - Audio Session
+
+    private func configureAudioSession() {
+        do {
+            try AVAudioSession.sharedInstance().setCategory(.playback, mode: .spokenAudio)
+            try AVAudioSession.sharedInstance().setActive(true)
+        } catch {
+            // Non-fatal
+        }
+    }
+
+    // MARK: - Lock Screen / Control Center
+
+    private func setupRemoteCommandCenter() {
+        let center = MPRemoteCommandCenter.shared()
+        center.playCommand.addTarget { [weak self] _ in
+            self?.play()
+            return .success
+        }
+        center.pauseCommand.addTarget { [weak self] _ in
+            self?.pause()
+            return .success
+        }
+        center.togglePlayPauseCommand.addTarget { [weak self] _ in
+            self?.togglePlayPause()
+            return .success
+        }
+        center.skipForwardCommand.preferredIntervals = [15]
+        center.skipForwardCommand.addTarget { [weak self] _ in
+            self?.skip(by: 15)
+            return .success
+        }
+        center.skipBackwardCommand.preferredIntervals = [15]
+        center.skipBackwardCommand.addTarget { [weak self] _ in
+            self?.skip(by: -15)
+            return .success
+        }
+        center.changePlaybackPositionCommand.addTarget { [weak self] event in
+            if let e = event as? MPChangePlaybackPositionCommandEvent {
+                self?.seek(to: e.positionTime)
+            }
+            return .success
+        }
+    }
+
+    private func updateNowPlaying() {
+        var info: [String: Any] = [
+            MPMediaItemPropertyTitle: chapterTitle.isEmpty ? "Chapter \(chapter)" : chapterTitle,
+            MPMediaItemPropertyArtist: bookTitle,
+            MPNowPlayingInfoPropertyElapsedPlaybackTime: currentTime,
+            MPMediaItemPropertyPlaybackDuration: duration,
+            MPNowPlayingInfoPropertyPlaybackRate: isPlaying ? speed : 0.0
+        ]
+        // Use cached artwork — downloaded once in prefetchCoverArtwork().
+        if let artwork = cachedCoverArtwork {
+            info[MPMediaItemPropertyArtwork] = artwork
+        }
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = info
+    }
+}
+
+// MARK: - Supporting types
+
+enum AudioPlayerStatus: Equatable {
+    case idle
+    case generating   // covers both "loading" and "generating TTS" phases
+    case ready
+    case error(String)
+
+    static func == (lhs: AudioPlayerStatus, rhs: AudioPlayerStatus) -> Bool {
+        switch (lhs, rhs) {
+        case (.idle, .idle), (.generating, .generating), (.ready, .ready):
+            return true
+        case (.error(let a), .error(let b)):
+            return a == b
+        default:
+            return false
+        }
+    }
+}
+
+enum SleepTimerOption: Equatable {
+    case chapters(Int)  // Stop after N chapters
+    case minutes(Int)   // Stop after N minutes
+}
+
+extension Notification.Name {
+    static let audioDidFinishChapter = Notification.Name("audioDidFinishChapter")
+    static let skipToNextChapter = Notification.Name("skipToNextChapter")
+    static let skipToPrevChapter = Notification.Name("skipToPrevChapter")
+}

ios/LibNovel/LibNovel/Services/AuthStore.swift

@@ -0,0 +1,139 @@
+import Foundation
+import Combine
+
+// MARK: - AuthStore
+// Owns the authenticated user, the HMAC auth token, and user settings.
+// Persists the token to Keychain so the user stays logged in across launches.
+
+@MainActor
+final class AuthStore: ObservableObject {
+    @Published var user: AppUser?
+    @Published var settings: UserSettings = .default
+    @Published var isLoading: Bool = false
+    @Published var error: String?
+
+    var isAuthenticated: Bool { user != nil }
+
+    private let keychainKey = "libnovel_auth_token"
+
+    init() {
+        // Restore token from Keychain and validate it on launch
+        if let token = loadToken() {
+            Task { await validateToken(token) }
+        }
+    }
+
+    // MARK: - Login / Register
+
+    func login(username: String, password: String) async {
+        isLoading = true
+        error = nil
+        do {
+            let response = try await APIClient.shared.login(username: username, password: password)
+            await APIClient.shared.setAuthCookie(response.token)
+            saveToken(response.token)
+            user = response.user
+            await loadSettings()
+        } catch {
+            self.error = error.localizedDescription
+        }
+        isLoading = false
+    }
+
+    func register(username: String, password: String) async {
+        isLoading = true
+        error = nil
+        do {
+            let response = try await APIClient.shared.register(username: username, password: password)
+            await APIClient.shared.setAuthCookie(response.token)
+            saveToken(response.token)
+            user = response.user
+            await loadSettings()
+        } catch {
+            self.error = error.localizedDescription
+        }
+        isLoading = false
+    }
+
+    func logout() async {
+        do {
+            try await APIClient.shared.logout()
+        } catch {
+            // Best-effort; clear local state regardless
+        }
+        clearToken()
+        user = nil
+        settings = .default
+    }
+
+    // MARK: - Settings
+
+    func loadSettings() async {
+        do {
+            settings = try await APIClient.shared.settings()
+        } catch {
+            // Use defaults if settings endpoint fails
+        }
+    }
+
+    func saveSettings(_ updated: UserSettings) async {
+        do {
+            try await APIClient.shared.updateSettings(updated)
+            settings = updated
+        } catch {
+            self.error = error.localizedDescription
+        }
+    }
+
+    // MARK: - Token validation (on cold launch)
+
+    private func validateToken(_ token: String) async {
+        await APIClient.shared.setAuthCookie(token)
+        // Use /api/auth/me to restore the user record and confirm the token is still valid
+        do {
+            async let me: AppUser = APIClient.shared.fetch("/api/auth/me")
+            async let s: UserSettings = APIClient.shared.settings()
+            let (restoredUser, restoredSettings) = try await (me, s)
+            user = restoredUser
+            settings = restoredSettings
+        } catch let e as APIError {
+            if case .httpError(let code, _) = e, code == 401 {
+                clearToken()
+            }
+        } catch {}
+    }
+
+    // MARK: - Keychain helpers
+
+    private func saveToken(_ token: String) {
+        let data = Data(token.utf8)
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: keychainKey,
+            kSecValueData as String: data
+        ]
+        SecItemDelete(query as CFDictionary)
+        SecItemAdd(query as CFDictionary, nil)
+    }
+
+    private func loadToken() -> String? {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: keychainKey,
+            kSecReturnData as String: true,
+            kSecMatchLimit as String: kSecMatchLimitOne
+        ]
+        var item: CFTypeRef?
+        guard SecItemCopyMatching(query as CFDictionary, &item) == errSecSuccess,
+              let data = item as? Data else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    private func clearToken() {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: keychainKey
+        ]
+        SecItemDelete(query as CFDictionary)
+    }
+}

ios/LibNovel/LibNovel/ViewModels/BookDetailViewModel.swift

@@ -0,0 +1,48 @@
+import Foundation
+
+@MainActor
+final class BookDetailViewModel: ObservableObject {
+    let slug: String
+
+    @Published var book: Book?
+    @Published var chapters: [ChapterIndex] = []
+    @Published var saved: Bool = false
+    @Published var lastChapter: Int?
+    @Published var isLoading = false
+    @Published var chaptersLoading = false
+    @Published var error: String?
+
+    init(slug: String) {
+        self.slug = slug
+    }
+
+    func load() async {
+        isLoading = true
+        error = nil
+        do {
+            let detail = try await APIClient.shared.bookDetail(slug: slug)
+            book = detail.book
+            chapters = detail.chapters
+            saved = detail.saved
+            lastChapter = detail.lastChapter
+        } catch {
+            if !(error is CancellationError) {
+                self.error = error.localizedDescription
+            }
+        }
+        isLoading = false
+    }
+
+    func toggleSaved() async {
+        do {
+            if saved {
+                try await APIClient.shared.unsaveBook(slug: slug)
+            } else {
+                try await APIClient.shared.saveBook(slug: slug)
+            }
+            saved.toggle()
+        } catch {
+            self.error = error.localizedDescription
+        }
+    }
+}

ios/LibNovel/LibNovel/ViewModels/BrowseViewModel.swift

@@ -0,0 +1,73 @@
+import Foundation
+
+@MainActor
+final class BrowseViewModel: ObservableObject {
+    @Published var novels: [BrowseNovel] = []
+    @Published var sort: String = "popular"
+    @Published var genre: String = "all"
+    @Published var status: String = "all"
+    @Published var searchQuery: String = ""
+    @Published var isLoading = false
+    @Published var hasNext = false
+    @Published var error: String?
+
+    private var currentPage = 1
+    private var isSearchMode = false
+
+    func loadFirstPage() async {
+        currentPage = 1
+        novels = []
+        isSearchMode = false
+        await loadPage(1)
+    }
+
+    func loadNextPage() async {
+        guard hasNext, !isLoading else { return }
+        await loadPage(currentPage + 1)
+    }
+
+    func search() async {
+        guard !searchQuery.isEmpty else { await loadFirstPage(); return }
+        isLoading = true
+        isSearchMode = true
+        novels = []
+        error = nil
+        do {
+            let result = try await APIClient.shared.search(query: searchQuery)
+            novels = result.results
+            hasNext = false
+        } catch {
+            if !(error is CancellationError) {
+                self.error = error.localizedDescription
+            }
+        }
+        isLoading = false
+    }
+
+    func clearSearch() {
+        searchQuery = ""
+        Task { await loadFirstPage() }
+    }
+
+    private func loadPage(_ page: Int) async {
+        isLoading = true
+        error = nil
+        do {
+            let result = try await APIClient.shared.browse(
+                page: page, genre: genre, sort: sort, status: status
+            )
+            if page == 1 {
+                novels = result.novels
+            } else {
+                novels.append(contentsOf: result.novels)
+            }
+            hasNext = result.hasNext
+            currentPage = page
+        } catch {
+            if !(error is CancellationError) {
+                self.error = error.localizedDescription
+            }
+        }
+        isLoading = false
+    }
+}

ios/LibNovel/LibNovel/ViewModels/ChapterReaderViewModel.swift

@@ -0,0 +1,69 @@
+import Foundation
+
+@MainActor
+final class ChapterReaderViewModel: ObservableObject {
+    let slug: String
+    private(set) var chapter: Int
+
+    @Published var content: ChapterResponse?
+    @Published var isLoading = false
+    @Published var error: String?
+
+    init(slug: String, chapter: Int) {
+        self.slug = slug
+        self.chapter = chapter
+    }
+
+    /// Switch to a different chapter in-place: resets state and updates `chapter`
+    /// so that `.task(id: currentChapter)` in the View re-fires `load()`.
+    func switchChapter(to newChapter: Int) {
+        guard newChapter != chapter else { return }
+        chapter = newChapter
+        content = nil
+        error = nil
+    }
+
+    func load() async {
+        isLoading = true
+        error = nil
+        do {
+            content = try await APIClient.shared.chapterContent(slug: slug, chapter: chapter)
+            // Record reading progress
+            try? await APIClient.shared.setProgress(slug: slug, chapter: chapter)
+        } catch {
+            if !(error is CancellationError) {
+                self.error = error.localizedDescription
+            }
+        }
+        isLoading = false
+    }
+
+    func toggleAudio(audioPlayer: AudioPlayerService, settings: UserSettings) {
+        guard let content else { return }
+
+        // Only treat as "current" if the player is active (not idle/stopped).
+        // If the user stopped playback, isActive is false — we must re-load.
+        let isCurrent = audioPlayer.isActive &&
+                        audioPlayer.slug == slug &&
+                        audioPlayer.chapter == chapter
+
+        if isCurrent {
+            audioPlayer.togglePlayPause()
+        } else {
+            let nextChapter: Int? = content.next
+            let prevChapter: Int? = content.prev
+            audioPlayer.load(
+                slug: slug,
+                chapter: chapter,
+                chapterTitle: content.chapter.title,
+                bookTitle: content.book.title,
+                coverURL: content.book.cover,
+                voice: settings.voice,
+                speed: settings.speed,
+                chapters: content.chapters,
+                nextChapter: nextChapter,
+                prevChapter: prevChapter
+            )
+        }
+    }
+}

ios/LibNovel/LibNovel/ViewModels/HomeViewModel.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+@MainActor
+final class HomeViewModel: ObservableObject {
+    @Published var continueReading: [ContinueReadingItem] = []
+    @Published var recentlyUpdated: [Book] = []
+    @Published var stats: HomeStats?
+    @Published var isLoading = false
+    @Published var error: String?
+
+    func load() async {
+        isLoading = true
+        error = nil
+        do {
+            let data = try await APIClient.shared.homeData()
+            continueReading = data.continueReading.map {
+                ContinueReadingItem(book: $0.book, chapter: $0.chapter)
+            }
+            recentlyUpdated = data.recentlyUpdated
+            stats = data.stats
+        } catch {
+            if !(error is CancellationError) {
+                self.error = error.localizedDescription
+            }
+        }
+        isLoading = false
+    }
+}

ios/LibNovel/LibNovel/ViewModels/LibraryViewModel.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+@MainActor
+final class LibraryViewModel: ObservableObject {
+    @Published var items: [LibraryItem] = []
+    @Published var isLoading = false
+    @Published var error: String?
+
+    func load() async {
+        isLoading = true
+        error = nil
+        do {
+            items = try await APIClient.shared.library()
+        } catch {
+            if !(error is CancellationError) {
+                self.error = error.localizedDescription
+            }
+        }
+        isLoading = false
+    }
+}

ios/LibNovel/LibNovel/ViewModels/ProfileViewModel.swift

@@ -0,0 +1,40 @@
+import Foundation
+
+@MainActor
+final class ProfileViewModel: ObservableObject {
+    @Published var sessions: [UserSession] = []
+    @Published var voices: [String] = []
+    @Published var sessionsLoading = false
+    @Published var error: String?
+
+    func loadSessions() async {
+        sessionsLoading = true
+        do {
+            sessions = try await APIClient.shared.sessions()
+        } catch {
+            self.error = error.localizedDescription
+        }
+        sessionsLoading = false
+    }
+
+    func loadVoices() async {
+        guard voices.isEmpty else { return }
+        do {
+            voices = try await APIClient.shared.voices()
+        } catch {
+            // Use hardcoded fallback — same as Go server helpers.go
+            voices = ["af_bella", "af_sky", "af_sarah", "af_nicole",
+                      "am_adam", "am_michael", "bf_emma", "bf_isabella",
+                      "bm_george", "bm_lewis"]
+        }
+    }
+
+    func revokeSession(id: String) async {
+        do {
+            try await APIClient.shared.revokeSession(id: id)
+            sessions.removeAll { $0.id == id }
+        } catch {
+            self.error = error.localizedDescription
+        }
+    }
+}

ios/LibNovel/LibNovel/Views/Auth/AuthView.swift

@@ -0,0 +1,123 @@
+import SwiftUI
+
+struct AuthView: View {
+    @EnvironmentObject var authStore: AuthStore
+    @State private var mode: Mode = .login
+    @State private var username: String = ""
+    @State private var password: String = ""
+    @State private var confirmPassword: String = ""
+    @FocusState private var focusedField: Field?
+
+    enum Mode { case login, register }
+    enum Field { case username, password, confirmPassword }
+
+    var body: some View {
+        NavigationStack {
+            VStack(spacing: 0) {
+                // Logo / header
+                VStack(spacing: 8) {
+                    Image(systemName: "books.vertical.fill")
+                        .font(.system(size: 56))
+                        .foregroundStyle(.amber)
+                    Text("LibNovel")
+                        .font(.largeTitle.bold())
+                }
+                .padding(.top, 60)
+                .padding(.bottom, 40)
+
+                // Tab switcher
+                Picker("Mode", selection: $mode) {
+                    Text("Sign In").tag(Mode.login)
+                    Text("Create Account").tag(Mode.register)
+                }
+                .pickerStyle(.segmented)
+                .padding(.horizontal, 24)
+                .padding(.bottom, 32)
+
+                // Form
+                VStack(spacing: 16) {
+                    TextField("Username", text: $username)
+                        .textFieldStyle(.roundedBorder)
+                        .textInputAutocapitalization(.never)
+                        .autocorrectionDisabled()
+                        .focused($focusedField, equals: .username)
+                        .submitLabel(.next)
+                        .onSubmit { focusedField = .password }
+
+                    SecureField("Password", text: $password)
+                        .textFieldStyle(.roundedBorder)
+                        .focused($focusedField, equals: .password)
+                        .submitLabel(mode == .register ? .next : .go)
+                        .onSubmit {
+                            if mode == .register { focusedField = .confirmPassword }
+                            else { submit() }
+                        }
+
+                    if mode == .register {
+                        SecureField("Confirm Password", text: $confirmPassword)
+                            .textFieldStyle(.roundedBorder)
+                            .focused($focusedField, equals: .confirmPassword)
+                            .submitLabel(.go)
+                            .onSubmit { submit() }
+                            .transition(.opacity.combined(with: .move(edge: .top)))
+                    }
+                }
+                .padding(.horizontal, 24)
+                .animation(.easeInOut(duration: 0.2), value: mode)
+
+                if let error = authStore.error {
+                    Text(error)
+                        .font(.footnote)
+                        .foregroundStyle(.red)
+                        .multilineTextAlignment(.center)
+                        .padding(.horizontal, 24)
+                        .padding(.top, 8)
+                }
+
+                Button(action: submit) {
+                    Group {
+                        if authStore.isLoading {
+                            ProgressView()
+                                .progressViewStyle(.circular)
+                                .tint(.white)
+                        } else {
+                            Text(mode == .login ? "Sign In" : "Create Account")
+                                .fontWeight(.semibold)
+                        }
+                    }
+                    .frame(maxWidth: .infinity)
+                    .frame(height: 50)
+                }
+                .buttonStyle(.borderedProminent)
+                .tint(.amber)
+                .padding(.horizontal, 24)
+                .padding(.top, 24)
+                .disabled(authStore.isLoading || !formIsValid)
+
+                Spacer()
+            }
+            .navigationBarHidden(true)
+        }
+        .onChange(of: mode) { _, _ in
+            authStore.error = nil
+            confirmPassword = ""
+        }
+    }
+
+    private var formIsValid: Bool {
+        let base = !username.isEmpty && password.count >= 4
+        if mode == .register { return base && password == confirmPassword }
+        return base
+    }
+
+    private func submit() {
+        focusedField = nil
+        Task {
+            if mode == .login {
+                await authStore.login(username: username, password: password)
+            } else {
+                await authStore.register(username: username, password: password)
+            }
+        }
+    }
+}

ios/LibNovel/LibNovel/Views/BookDetail/BookDetailView.swift

@@ -0,0 +1,222 @@
+import SwiftUI
+
+struct BookDetailView: View {
+    let slug: String
+    @StateObject private var vm: BookDetailViewModel
+    @EnvironmentObject var authStore: AuthStore
+    @EnvironmentObject var audioPlayer: AudioPlayerService
+    @State private var summaryExpanded = false
+    @State private var chapterPage = 0
+    private let pageSize = 50
+
+    init(slug: String) {
+        self.slug = slug
+        _vm = StateObject(wrappedValue: BookDetailViewModel(slug: slug))
+    }
+
+    var body: some View {
+        ScrollView {
+            if vm.isLoading {
+                ProgressView().frame(maxWidth: .infinity).padding(.top, 80)
+            } else if let book = vm.book {
+                VStack(alignment: .leading, spacing: 0) {
+                    heroSection(book: book)
+                    Divider().padding(.vertical, 8)
+                    chapterSection(book: book)
+                }
+            }
+        }
+        .navigationTitle("")
+        .navigationBarTitleDisplayMode(.inline)
+        .toolbar { bookmarkButton }
+        .task { await vm.load() }
+        .errorAlert($vm.error)
+    }
+
+    // MARK: - Hero
+
+    @ViewBuilder
+    private func heroSection(book: Book) -> some View {
+        ZStack(alignment: .bottom) {
+            // Blurred cover background — use plain colour placeholder to avoid
+            // the rounded-rect loading indicator showing through the blur.
+            AsyncCoverImage(url: book.cover, isBackground: true)
+                .frame(maxWidth: .infinity)
+                .frame(height: 260)
+                .blur(radius: 20)
+                .clipped()
+                .overlay(Color.black.opacity(0.45))
+
+            HStack(alignment: .bottom, spacing: 14) {
+                AsyncCoverImage(url: book.cover)
+                    .frame(width: 110, height: 160)
+                    .clipShape(RoundedRectangle(cornerRadius: 10))
+                    .shadow(radius: 8)
+
+                VStack(alignment: .leading, spacing: 6) {
+                    Text(book.title)
+                        .font(.headline)
+                        .foregroundStyle(.white)
+                        .lineLimit(3)
+                    Text(book.author)
+                        .font(.subheadline)
+                        .foregroundStyle(.white.opacity(0.8))
+                    HStack {
+//                        TagChip(label: book.status).colorScheme(.dark)
+                        ForEach(book.genres.prefix(2), id: \.self) {
+                            TagChip(label: $0).colorScheme(.dark)
+                        }
+                    }
+                }
+                Spacer(minLength: 0)
+            }
+            .padding(.horizontal)
+            .padding(.bottom, 16)
+        }
+
+        // Summary
+        VStack(alignment: .leading, spacing: 8) {
+            Text(book.summary)
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+                .lineLimit(summaryExpanded ? nil : 4)
+            if book.summary.count > 200 {
+                Button(summaryExpanded ? "Less" : "More") {
+                    withAnimation { summaryExpanded.toggle() }
+                }
+                .font(.caption.bold()) 
+                .foregroundStyle(.amber)
+            }
+        }
+        .padding()
+
+        // CTA buttons
+        HStack(spacing: 10) {
+            if let last = vm.lastChapter, last > 0 {
+                NavigationLink(value: NavDestination.chapter(slug, last)) {
+                    Label("Continue Ch.\(last)", systemImage: "play.fill")
+                        .frame(maxWidth: .infinity)
+                }
+                .buttonStyle(.borderedProminent)
+                .tint(.amber)
+
+                NavigationLink(value: NavDestination.chapter(slug, 1)) {
+                    Label("From Ch.1", systemImage: "arrow.counterclockwise")
+                        .frame(maxWidth: .infinity)
+                }
+                .buttonStyle(.bordered)
+                .tint(.secondary)
+            } else {
+                NavigationLink(value: NavDestination.chapter(slug, 1)) {
+                    Label("Start Reading", systemImage: "book.fill")
+                        .frame(maxWidth: .infinity)
+                }
+                .buttonStyle(.borderedProminent)
+                .tint(.amber)
+            }
+        }
+        .padding(.horizontal)
+        .padding(.bottom, 8)
+    }
+
+    // MARK: - Chapter list
+
+    @ViewBuilder
+    private func chapterSection(book: Book) -> some View {
+        let chapters = vm.chapters
+        let total = chapters.count
+        let start = chapterPage * pageSize
+        let end = min(start + pageSize, total)
+        let pageChapters = Array(chapters[start..<end])
+
+        VStack(alignment: .leading, spacing: 0) {
+            HStack {
+                Text("Chapters")
+                    .font(.title3.bold())
+                Spacer()
+                if total > 0 {
+                    Text("\(start + 1)–\(end) of \(total)")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
+            }
+            .padding(.horizontal)
+            .padding(.vertical, 10)
+
+            if vm.chaptersLoading {
+                ProgressView().frame(maxWidth: .infinity).padding()
+            } else {
+                ForEach(pageChapters) { ch in
+                    NavigationLink(value: NavDestination.chapter(slug, ch.number)) {
+                        ChapterRow(chapter: ch, isCurrent: ch.number == vm.lastChapter)
+                    }
+                    .buttonStyle(.plain)
+                    Divider().padding(.leading)
+                }
+            }
+
+            // Pagination
+            if total > pageSize {
+                HStack {
+                    Button("Previous") { chapterPage -= 1 }
+                        .disabled(chapterPage == 0)
+                    Spacer()
+                    Button("Next") { chapterPage += 1 }
+                        .disabled(end >= total)
+                }
+                .buttonStyle(.bordered)
+                .padding()
+            }
+        }
+    }
+
+    // MARK: - Toolbar bookmark
+
+    @ToolbarContentBuilder
+    private var bookmarkButton: some ToolbarContent {
+        ToolbarItem(placement: .topBarTrailing) {
+            Button {
+                Task { await vm.toggleSaved() }
+            } label: {
+                Image(systemName: vm.saved ? "bookmark.fill" : "bookmark")
+                    .foregroundStyle(vm.saved ? .amber : .primary)
+            }
+        }
+    }
+}
+
+private struct ChapterRow: View {
+    let chapter: ChapterIndex
+    let isCurrent: Bool
+    var body: some View {
+        HStack(spacing: 8) {
+            VStack(alignment: .leading, spacing: 2) {
+                Text("Chapter \(chapter.number)")
+                    .font(.subheadline)
+                    .fontWeight(isCurrent ? .bold : .regular)
+                    .foregroundStyle(isCurrent ? .amber : .primary)
+                if !chapter.title.isEmpty && chapter.title != "Chapter \(chapter.number)" {
+                    Text(chapter.title)
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                        .lineLimit(1)
+                }
+            }
+            Spacer(minLength: 12)
+            HStack(spacing: 6) {
+                if !chapter.dateLabel.isEmpty {
+                    Text(chapter.dateLabel)
+                        .font(.caption2)
+                        .foregroundStyle(.tertiary)
+                        .fixedSize()
+                }
+                Image(systemName: "chevron.right")
+                    .font(.caption2)
+                    .foregroundStyle(.tertiary)
+            }
+        }
+        .padding(.horizontal)
+        .padding(.vertical, 10)
+        .contentShape(Rectangle())
+    }
+}

ios/LibNovel/LibNovel/Views/Browse/BrowseView.swift

@@ -0,0 +1,210 @@
+import SwiftUI
+
+struct BrowseView: View {
+    @StateObject private var vm = BrowseViewModel()
+    @State private var showFilters = false
+
+    var body: some View {
+        NavigationStack {
+            VStack(spacing: 0) {
+                // Search bar
+                HStack {
+                    Image(systemName: "magnifyingglass").foregroundStyle(.secondary)
+                    TextField("Search novels...", text: $vm.searchQuery)
+                        .textInputAutocapitalization(.never)
+                        .autocorrectionDisabled()
+                        .submitLabel(.search)
+                        .onSubmit { Task { await vm.search() } }
+                    if !vm.searchQuery.isEmpty {
+                        Button { vm.clearSearch() } label: {
+                            Image(systemName: "xmark.circle.fill").foregroundStyle(.secondary)
+                        }
+                    }
+                }
+                .padding(10)
+                .background(Color(.systemGray6), in: RoundedRectangle(cornerRadius: 10))
+                .padding(.horizontal)
+                .padding(.vertical, 8)
+
+                // Filter chips row
+                ScrollView(.horizontal, showsIndicators: false) {
+                    HStack(spacing: 8) {
+                        FilterChip(label: "Sort: \(vm.sort.capitalized)", isActive: vm.sort != "popular") {
+                            showFilters = true
+                        }
+                        FilterChip(label: "Genre: \(vm.genre == "all" ? "All" : vm.genre.capitalized)", isActive: vm.genre != "all") {
+                            showFilters = true
+                        }
+                        FilterChip(label: "Status: \(vm.status == "all" ? "All" : vm.status.capitalized)", isActive: vm.status != "all") {
+                            showFilters = true
+                        }
+                    }
+                    .padding(.horizontal)
+                }
+                .padding(.bottom, 4)
+
+                Divider()
+
+                // Results
+                if vm.isLoading && vm.novels.isEmpty {
+                    ProgressView().frame(maxWidth: .infinity, maxHeight: .infinity)
+                } else if vm.novels.isEmpty && !vm.isLoading {
+                    VStack(spacing: 16) {
+                        if let errMsg = vm.error {
+                            Image(systemName: "wifi.slash")
+                                .font(.largeTitle)
+                                .foregroundStyle(.secondary)
+                            Text(errMsg)
+                                .multilineTextAlignment(.center)
+                                .foregroundStyle(.secondary)
+                                .padding(.horizontal)
+                            Button("Retry") { Task { await vm.loadFirstPage() } }
+                                .buttonStyle(.borderedProminent)
+                                .tint(.amber)
+                        } else {
+                            EmptyStateView(icon: "magnifyingglass", title: "No results", message: "Try a different search or filter.")
+                        }
+                    }
+                    .frame(maxWidth: .infinity, maxHeight: .infinity)
+                } else {
+                    ScrollView {
+                        LazyVGrid(columns: [GridItem(.adaptive(minimum: 150), spacing: 12)], spacing: 16) {
+                            ForEach(vm.novels) { novel in
+                                NavigationLink(value: NavDestination.book(novel.slug)) {
+                                    BrowseCard(novel: novel)
+                                }
+                                .buttonStyle(.plain)
+                            }
+
+                            // Infinite scroll trigger
+                            if vm.hasNext {
+                                ProgressView()
+                                    .frame(maxWidth: .infinity)
+                                    .padding()
+                                    .onAppear { Task { await vm.loadNextPage() } }
+                            }
+                        }
+                        .padding()
+                    }
+                    .refreshable { await vm.loadFirstPage() }
+                }
+            }
+            .navigationTitle("Discover")
+            .appNavigationDestination()
+            .sheet(isPresented: $showFilters) {
+                BrowseFiltersView(vm: vm)
+            }
+            .task { await vm.loadFirstPage() }
+            .onChange(of: vm.sort) { _, _ in Task { await vm.loadFirstPage() } }
+            .onChange(of: vm.genre) { _, _ in Task { await vm.loadFirstPage() } }
+            .onChange(of: vm.status) { _, _ in Task { await vm.loadFirstPage() } }
+        }
+    }
+}
+
+// MARK: - Filter chip
+
+private struct FilterChip: View {
+    let label: String
+    let isActive: Bool
+    let action: () -> Void
+    var body: some View {
+        Button(action: action) {
+            Text(label)
+                .font(.caption.bold())
+                .padding(.horizontal, 10)
+                .padding(.vertical, 6)
+                .background(isActive ? Color.amber.opacity(0.15) : Color(.systemGray6), in: Capsule())
+                .foregroundStyle(isActive ? .amber : .primary)
+                .overlay(Capsule().strokeBorder(isActive ? Color.amber : .clear, lineWidth: 1))
+        }
+    }
+}
+
+// MARK: - Browse card
+
+private struct BrowseCard: View {
+    let novel: BrowseNovel
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            ZStack(alignment: .topLeading) {
+                AsyncCoverImage(url: novel.cover)
+                    .frame(height: 200)
+                    .clipShape(RoundedRectangle(cornerRadius: 10))
+                if !novel.rank.isEmpty {
+                    Text(novel.rank)
+                        .font(.caption2.bold())
+                        .padding(.horizontal, 6).padding(.vertical, 3)
+                        .background(.ultraThinMaterial, in: Capsule())
+                        .padding(6)
+                }
+            }
+            Text(novel.title)
+                .font(.caption.bold()).lineLimit(2)
+            if !novel.chapters.isEmpty {
+                Text(novel.chapters).font(.caption2).foregroundStyle(.secondary)
+            }
+        }
+    }
+}
+
+// MARK: - Filters sheet
+
+struct BrowseFiltersView: View {
+    @ObservedObject var vm: BrowseViewModel
+    @Environment(\.dismiss) private var dismiss
+
+    let sortOptions = ["popular", "new", "updated", "rating", "rank"]
+    let genreOptions = ["all", "action", "fantasy", "romance", "sci-fi", "mystery",
+                        "horror", "comedy", "drama", "adventure", "martial arts",
+                        "cultivation", "magic", "supernatural", "historical", "slice of life"]
+    let statusOptions = ["all", "ongoing", "completed"]
+
+    var body: some View {
+        NavigationStack {
+            Form {
+                Section("Sort") {
+                    ForEach(sortOptions, id: \.self) { opt in
+                        HStack {
+                            Text(opt.capitalized)
+                            Spacer()
+                            if vm.sort == opt { Image(systemName: "checkmark").foregroundStyle(.amber) }
+                        }
+                        .contentShape(Rectangle())
+                        .onTapGesture { vm.sort = opt; dismiss() }
+                    }
+                }
+                Section("Genre") {
+                    ForEach(genreOptions, id: \.self) { opt in
+                        HStack {
+                            Text(opt == "all" ? "All Genres" : opt.capitalized)
+                            Spacer()
+                            if vm.genre == opt { Image(systemName: "checkmark").foregroundStyle(.amber) }
+                        }
+                        .contentShape(Rectangle())
+                        .onTapGesture { vm.genre = opt; dismiss() }
+                    }
+                }
+                Section("Status") {
+                    ForEach(statusOptions, id: \.self) { opt in
+                        HStack {
+                            Text(opt.capitalized)
+                            Spacer()
+                            if vm.status == opt { Image(systemName: "checkmark").foregroundStyle(.amber) }
+                        }
+                        .contentShape(Rectangle())
+                        .onTapGesture { vm.status = opt; dismiss() }
+                    }
+                }
+            }
+            .navigationTitle("Filters")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    Button("Done") { dismiss() }
+                }
+            }
+        }
+        .presentationDetents([.medium, .large])
+    }
+}

ios/LibNovel/LibNovel/Views/ChapterReader/ChapterReaderView.swift

@@ -0,0 +1,242 @@
+import SwiftUI
+import WebKit
+
+// MARK: - Chapter Reader
+
+struct ChapterReaderView: View {
+    let slug: String
+    let chapterNumber: Int
+
+    /// Tracks the currently displayed chapter — updated in-place by skip/auto-next
+    /// so we never accumulate stale listeners on the navigation stack.
+    @State private var currentChapter: Int
+    @StateObject private var vm: ChapterReaderViewModel
+    @EnvironmentObject var audioPlayer: AudioPlayerService
+    @EnvironmentObject var authStore: AuthStore
+
+    init(slug: String, chapterNumber: Int) {
+        self.slug = slug
+        self.chapterNumber = chapterNumber
+        _currentChapter = State(initialValue: chapterNumber)
+        _vm = StateObject(wrappedValue: ChapterReaderViewModel(slug: slug, chapter: chapterNumber))
+    }
+
+    var body: some View {
+        Group {
+            if vm.isLoading {
+                ProgressView().frame(maxWidth: .infinity, maxHeight: .infinity)
+            } else if let content = vm.content {
+                readerContent(content)
+            } else if let errMsg = vm.error {
+                VStack(spacing: 16) {
+                    Image(systemName: "exclamationmark.triangle")
+                        .font(.largeTitle)
+                        .foregroundStyle(.orange)
+                    Text(errMsg)
+                        .multilineTextAlignment(.center)
+                        .foregroundStyle(.secondary)
+                        .padding(.horizontal)
+                    Button("Retry") { Task { await vm.load() } }
+                        .buttonStyle(.borderedProminent)
+                        .tint(.amber)
+                }
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
+            } else {
+                Color.clear
+            }
+        }
+        .navigationTitle(vm.content.map { "Ch.\($0.chapter.number)" } ?? "")
+        .navigationBarTitleDisplayMode(.inline)
+        .overlay(alignment: .bottomTrailing) {
+            // Floating audio button when player is not active
+            if !audioPlayer.isActive {
+                floatingAudioButton
+            }
+        }
+        .task(id: currentChapter) {
+            await vm.load()
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .audioDidFinishChapter)) { note in
+            guard let next = note.userInfo?["next"] as? Int else { return }
+            let shouldAutoNavigate = note.userInfo?["autoNext"] as? Bool ?? false
+            // Only handle if this is the top-most (currently active) chapter view
+            guard shouldAutoNavigate, currentChapter == audioPlayer.chapter else { return }
+            navigateToChapter(next)
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .skipToNextChapter)) { note in
+            guard let next = note.userInfo?["next"] as? Int else { return }
+            // Only the view whose chapter matches the currently playing chapter should handle this
+            guard currentChapter == audioPlayer.chapter else { return }
+            navigateToChapter(next)
+        }
+        .onReceive(NotificationCenter.default.publisher(for: .skipToPrevChapter)) { note in
+            guard let prev = note.userInfo?["prev"] as? Int else { return }
+            guard currentChapter == audioPlayer.chapter else { return }
+            navigateToChapter(prev)
+        }
+    }
+
+    /// Navigate to a chapter in-place: reloads content without pushing to the navigation stack.
+    /// Back button always returns to BookDetailView regardless of how many chapters were visited.
+    private func navigateToChapter(_ chapter: Int) {
+        vm.switchChapter(to: chapter)
+        currentChapter = chapter
+    }
+
+    // MARK: - Content
+
+    @State private var webHeight: CGFloat = 800
+
+    @ViewBuilder
+    private func readerContent(_ content: ChapterResponse) -> some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 16) {
+                // Header
+                VStack(alignment: .leading, spacing: 4) {
+                    Text(content.chapter.title.strippingTrailingDate())
+                        .font(.title2.bold())
+                    if !content.chapter.dateLabel.isEmpty {
+                        Text(content.chapter.dateLabel)
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                    }
+                }
+                .padding(.horizontal)
+
+                Divider()
+
+                // Chapter body
+                HTMLContentView(html: content.html, height: $webHeight)
+                    .frame(height: webHeight)
+                    .padding(.horizontal)
+
+                Divider()
+
+                // Prev / Next navigation — in-place swap so back button always returns to book
+                HStack(spacing: 12) {
+                    if let prev = content.prev {
+                        Button {
+                            navigateToChapter(prev)
+                        } label: {
+                            Label("Ch.\(prev)", systemImage: "chevron.left")
+                                .frame(maxWidth: .infinity)
+                        }
+                        .buttonStyle(.bordered)
+                    }
+                    if let next = content.next {
+                        Button {
+                            navigateToChapter(next)
+                        } label: {
+                            Label("Ch.\(next)", systemImage: "chevron.right")
+                                .labelStyle(ReverseLabelStyle())
+                                .frame(maxWidth: .infinity)
+                        }
+                        .buttonStyle(.borderedProminent)
+                        .tint(.amber)
+                    }
+                }
+                .padding()
+            }
+            .padding(.vertical)
+        }
+        // Ensure the Prev/Next buttons clear the mini-player bar when it is visible.
+        .safeAreaInset(edge: .bottom) {
+            if audioPlayer.isActive {
+                Color.clear.frame(height: AppLayout.miniPlayerBarHeight)
+            }
+        }
+    }
+
+    // MARK: - Floating audio button
+
+    @ViewBuilder
+    private var floatingAudioButton: some View {
+        Button {
+            vm.toggleAudio(audioPlayer: audioPlayer, settings: authStore.settings)
+        } label: {
+            HStack(spacing: 8) {
+                Image(systemName: "play.circle.fill")
+                    .font(.system(size: 22))
+                Text("Listen")
+                    .font(.subheadline.weight(.semibold))
+            }
+            .foregroundStyle(.white)
+            .padding(.horizontal, 20)
+            .padding(.vertical, 12)
+            .background(
+                Capsule()
+                    .fill(Color.amber)
+                    .shadow(color: .black.opacity(0.25), radius: 8, y: 4)
+            )
+        }
+        .buttonStyle(.plain)
+        .padding(.trailing, 20)
+        .padding(.bottom, 20)
+    }
+}
+
+// MARK: - HTML content renderer using WKWebView
+
+struct HTMLContentView: UIViewRepresentable {
+    let html: String
+    @Binding var height: CGFloat
+
+    func makeCoordinator() -> Coordinator { Coordinator(self) }
+
+    func makeUIView(context: Context) -> WKWebView {
+        let wv = WKWebView()
+        wv.scrollView.isScrollEnabled = false
+        wv.isOpaque = false
+        wv.backgroundColor = .clear
+        wv.scrollView.backgroundColor = .clear
+        wv.navigationDelegate = context.coordinator
+        return wv
+    }
+
+    func updateUIView(_ uiView: WKWebView, context: Context) {
+        let isDark = UITraitCollection.current.userInterfaceStyle == .dark
+        let textColor = isDark ? "#e5e5e5" : "#1a1a1a"
+        let css = """
+        body {
+            font-family: -apple-system, Georgia, serif;
+            font-size: 17px;
+            line-height: 1.7;
+            color: \(textColor);
+            background: transparent;
+            margin: 0; padding: 0;
+            word-break: break-word;
+        }
+        p { margin: 0 0 1em 0; }
+        """
+        let wrapped = "<html><head><style>\(css)</style><meta name='viewport' content='width=device-width, initial-scale=1'></head><body>\(html)</body></html>"
+        uiView.loadHTMLString(wrapped, baseURL: nil)
+    }
+
+    class Coordinator: NSObject, WKNavigationDelegate {
+        var parent: HTMLContentView
+        init(_ parent: HTMLContentView) { self.parent = parent }
+
+        func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
+            webView.evaluateJavaScript("document.body.scrollHeight") { result, error in
+                DispatchQueue.main.async {
+                    if let h = result as? CGFloat, h > 0 {
+                        self.parent.height = h
+                    } else if let h = result as? Double, h > 0 {
+                        self.parent.height = CGFloat(h)
+                    }
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Reverse label style (icon on right)
+
+struct ReverseLabelStyle: LabelStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        HStack {
+            configuration.title
+            configuration.icon
+        }
+    }
+}

ios/LibNovel/LibNovel/Views/Common/CommonViews.swift

@@ -0,0 +1,82 @@
+import SwiftUI
+import Kingfisher
+
+// MARK: - Empty state placeholder used across all screens
+
+struct EmptyStateView: View {
+    let icon: String
+    let title: String
+    let message: String
+
+    var body: some View {
+        VStack(spacing: 14) {
+            Image(systemName: icon)
+                .font(.system(size: 48))
+                .foregroundStyle(.tertiary)
+            Text(title)
+                .font(.headline)
+            Text(message)
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+                .multilineTextAlignment(.center)
+                .padding(.horizontal, 40)
+        }
+    }
+}
+
+// MARK: - Cover image card reused across screens
+
+struct BookCard: View {
+    let book: Book
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            AsyncCoverImage(url: book.cover)
+                .frame(height: 200)
+                .clipShape(RoundedRectangle(cornerRadius: 10))
+            Text(book.title)
+                .font(.caption.bold())
+                .lineLimit(2)
+            Text(book.author)
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+                .lineLimit(1)
+        }
+    }
+}
+
+// MARK: - Async cover image with disk/memory caching via Kingfisher
+
+struct AsyncCoverImage: View {
+    let url: String
+    /// When true the placeholder is a plain colour fill — used for blurred hero backgrounds
+    /// so the rounded-rect loading indicator doesn't bleed through.
+    var isBackground: Bool = false
+
+    var body: some View {
+        KFImage(URL(string: url))
+            .resizable()
+            .placeholder {
+                if isBackground {
+                    Color(.systemGray6)
+                } else {
+                    RoundedRectangle(cornerRadius: 10)
+                        .fill(Color(.systemGray5))
+                        .overlay(Image(systemName: "book.closed").foregroundStyle(.secondary))
+                }
+            }
+            .scaledToFill()
+    }
+}
+
+// MARK: - Tag chip
+
+struct TagChip: View {
+    let label: String
+    var body: some View {
+        Text(label)
+            .font(.caption2.bold())
+            .padding(.horizontal, 8)
+            .padding(.vertical, 4)
+            .background(Color(.systemGray5), in: Capsule())
+    }
+}

ios/LibNovel/LibNovel/Views/Home/HomeView.swift

@@ -0,0 +1,139 @@
+import SwiftUI
+import Kingfisher
+
+struct HomeView: View {
+    @StateObject private var vm = HomeViewModel()
+    @EnvironmentObject var authStore: AuthStore
+
+    var body: some View {
+        NavigationStack {
+            ScrollView {
+                VStack(alignment: .leading, spacing: 28) {
+
+                    // Stats bar
+                    if let stats = vm.stats {
+                        HStack(spacing: 0) {
+                            StatCell(value: "\(stats.totalBooks)", label: "Books")
+                            Divider().frame(height: 32)
+                            StatCell(value: "\(stats.totalChapters)", label: "Chapters")
+                            Divider().frame(height: 32)
+                            StatCell(value: "\(stats.booksInProgress)", label: "In Progress")
+                        }
+                        .frame(maxWidth: .infinity)
+                        .padding(.vertical, 16)
+                        .background(.ultraThinMaterial, in: RoundedRectangle(cornerRadius: 14))
+                        .padding(.horizontal)
+                    }
+
+                    // Continue reading
+                    if !vm.continueReading.isEmpty {
+                        SectionHeader(title: "Continue Reading")
+                    ScrollView(.horizontal, showsIndicators: false) {
+                        HStack(alignment: .top, spacing: 12) {
+                            ForEach(vm.continueReading) { item in
+                                NavigationLink(value: NavDestination.book(item.book.slug)) {
+                                    ContinueReadingCard(item: item)
+                                }
+                                .buttonStyle(.plain)
+                            }
+                        }
+                        .padding(.horizontal)
+                    }
+                    }
+
+                    // Recently updated
+                    if !vm.recentlyUpdated.isEmpty {
+                        SectionHeader(title: "Recently Updated")
+                        LazyVGrid(columns: [GridItem(.adaptive(minimum: 150), spacing: 12)], spacing: 16) {
+                            ForEach(vm.recentlyUpdated) { book in
+                                NavigationLink(value: NavDestination.book(book.slug)) {
+                                    BookCard(book: book)
+                                }
+                                .buttonStyle(.plain)
+                            }
+                        }
+                        .padding(.horizontal)
+                    }
+
+                    // Empty state
+                    if vm.continueReading.isEmpty && vm.recentlyUpdated.isEmpty && !vm.isLoading {
+                        EmptyStateView(
+                            icon: "books.vertical",
+                            title: "Your library is empty",
+                            message: "Head to Discover to find novels to read."
+                        )
+                        .frame(maxWidth: .infinity)
+                        .padding(.top, 60)
+                    }
+
+                    if vm.isLoading {
+                        ProgressView()
+                            .frame(maxWidth: .infinity)
+                            .padding(.top, 60)
+                    }
+                }
+                .padding(.vertical)
+            }
+            .navigationTitle("Home")
+            .appNavigationDestination()
+            .refreshable { await vm.load() }
+            .task { await vm.load() }
+            .errorAlert($vm.error)
+        }
+    }
+}
+
+// MARK: - Supporting components
+
+private struct StatCell: View {
+    let value: String
+    let label: String
+    var body: some View {
+        VStack(spacing: 2) {
+            Text(value).font(.title2.bold()).foregroundStyle(.primary)
+            Text(label).font(.caption).foregroundStyle(.secondary)
+        }
+        .frame(maxWidth: .infinity)
+    }
+}
+
+private struct SectionHeader: View {
+    let title: String
+    var body: some View {
+        Text(title)
+            .font(.title3.bold())
+            .padding(.horizontal)
+    }
+}
+
+private struct ContinueReadingCard: View {
+    let item: ContinueReadingItem
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            KFImage(URL(string: item.book.cover))
+                .resizable()
+                .placeholder { coverPlaceholder }
+                .scaledToFill()
+                .frame(width: 120, height: 170)
+                .clipShape(RoundedRectangle(cornerRadius: 10))
+                .overlay(alignment: .bottomTrailing) {
+                    Text("Ch.\(item.chapter)")
+                        .font(.caption2.bold())
+                        .padding(.horizontal, 6)
+                        .padding(.vertical, 3)
+                        .background(.ultraThinMaterial, in: Capsule())
+                        .padding(6)
+                }
+            Text(item.book.title)
+                .font(.caption.bold())
+                .lineLimit(2)
+                .frame(width: 120, alignment: .leading)
+        }
+    }
+    private var coverPlaceholder: some View {
+        RoundedRectangle(cornerRadius: 10)
+            .fill(Color(.systemGray5))
+            .frame(width: 120, height: 170)
+            .overlay(Image(systemName: "book.closed").foregroundStyle(.secondary))
+    }
+}

ios/LibNovel/LibNovel/Views/Library/LibraryView.swift

@@ -0,0 +1,79 @@
+import SwiftUI
+import Kingfisher
+
+struct LibraryView: View {
+    @StateObject private var vm = LibraryViewModel()
+
+    var body: some View {
+        NavigationStack {
+            Group {
+                if vm.isLoading && vm.items.isEmpty {
+                    ProgressView()
+                        .frame(maxWidth: .infinity, maxHeight: .infinity)
+                } else if vm.items.isEmpty {
+                    EmptyStateView(
+                        icon: "bookmark",
+                        title: "No saved books",
+                        message: "Books you save or start reading will appear here."
+                    )
+                } else {
+                    ScrollView {
+                        LazyVGrid(
+                            columns: [GridItem(.adaptive(minimum: 150), spacing: 12)],
+                            spacing: 16
+                        ) {
+                            ForEach(vm.items) { item in
+                                NavigationLink(value: NavDestination.book(item.book.slug)) {
+                                    LibraryCard(item: item)
+                                }
+                                .buttonStyle(.plain)
+                            }
+                        }
+                        .padding()
+                    }
+                }
+            }
+            .navigationTitle("Library")
+            .appNavigationDestination()
+            .refreshable { await vm.load() }
+            .task { await vm.load() }
+            .errorAlert($vm.error)
+        }
+    }
+}
+
+private struct LibraryCard: View {
+    let item: LibraryItem
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            ZStack(alignment: .bottomTrailing) {
+                KFImage(URL(string: item.book.cover))
+                    .resizable()
+                    .placeholder {
+                        RoundedRectangle(cornerRadius: 10)
+                            .fill(Color(.systemGray5))
+                            .overlay(Image(systemName: "book.closed").foregroundStyle(.secondary))
+                    }
+                    .scaledToFill()
+                    .frame(height: 200)
+                    .clipShape(RoundedRectangle(cornerRadius: 10))
+
+                if let ch = item.lastChapter {
+                    Text("Ch.\(ch)")
+                        .font(.caption2.bold())
+                        .padding(.horizontal, 6)
+                        .padding(.vertical, 3)
+                        .background(.ultraThinMaterial, in: Capsule())
+                        .padding(6)
+                }
+            }
+            Text(item.book.title)
+                .font(.caption.bold())
+                .lineLimit(2)
+            Text(item.book.author)
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+                .lineLimit(1)
+        }
+    }
+}

ios/LibNovel/LibNovel/Views/Player/PlayerViews.swift

@@ -0,0 +1,939 @@
+import SwiftUI
+import Kingfisher  // used directly for blurred background in FullPlayerView
+import AVKit       // for AVRoutePickerView (AirPlay)
+
+// MARK: - Mini player bar (pinned above tab bar)
+
+struct MiniPlayerView: View {
+    @Binding var showFullPlayer: Bool
+    @EnvironmentObject var audioPlayer: AudioPlayerService
+
+    /// Live drag offset while the user is swiping up/down (negative = moving up).
+    @State private var dragOffset: CGFloat = 0
+
+    var body: some View {
+        ZStack {
+            // Static progress bar as background (full bleed behind content)
+            MiniPlayerProgressBar(progress: audioPlayer.progress)
+
+            // Content layer
+            HStack(spacing: 16) {
+                // Cover thumbnail with rounded corners
+                Button { showFullPlayer = true } label: {
+                    AsyncCoverImage(url: audioPlayer.coverURL)
+                        .frame(width: 56, height: 56)
+                        .clipShape(RoundedRectangle(cornerRadius: 40))
+                }
+                .buttonStyle(.plain)
+
+                // Track info
+                VStack(alignment: .leading, spacing: 4) {
+                    Text(chapterLabel)
+                        .font(.subheadline.weight(.semibold))
+                        .lineLimit(1)
+                        .foregroundStyle(.primary)
+                    Text(audioPlayer.bookTitle)
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                        .lineLimit(1)
+                }
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .onTapGesture { showFullPlayer = true }
+
+                Spacer(minLength: 8)
+
+                // Control buttons - compact group
+                HStack(spacing: 12) {
+                    // Previous chapter button
+                    if audioPlayer.status == .ready {
+                        Button { 
+                            if let prev = audioPlayer.absolutePrevChapter {
+                                NotificationCenter.default.post(
+                                    name: .skipToPrevChapter,
+                                    object: nil,
+                                    userInfo: ["prev": prev]
+                                )
+                            }
+                        } label: {
+                            Image(systemName: "backward.end.fill")
+                                .font(.system(size: 20, weight: .semibold))
+                                .foregroundStyle(.white)
+                                .frame(width: 40, height: 40)
+                                .contentShape(Rectangle())
+                        }
+                        .buttonStyle(.plain)
+                        .disabled(audioPlayer.absolutePrevChapter == nil)
+                        .opacity(audioPlayer.absolutePrevChapter == nil ? 0.4 : 1.0)
+                    }
+                    
+                    // Status indicator or play/pause control
+                    Group {
+                        switch audioPlayer.status {
+                        case .generating:
+                            ProgressView()
+                                .tint(.white)
+                                .scaleEffect(1.0)
+                                .frame(width: 44, height: 44)
+                        case .ready:
+                            MiniPlayerPlayPauseButton(
+                                progress: audioPlayer.progress,
+                                onToggle: { audioPlayer.togglePlayPause() }
+                            )
+                        case .error:
+                            Image(systemName: "exclamationmark.circle.fill")
+                                .font(.system(size: 24))
+                                .foregroundStyle(.red)
+                                .frame(width: 44, height: 44)
+                        default:
+                            EmptyView()
+                        }
+                    }
+
+                    // Next chapter button
+                    if audioPlayer.status == .ready {
+                        Button { 
+                            if let next = audioPlayer.absoluteNextChapter {
+                                NotificationCenter.default.post(
+                                    name: .skipToNextChapter,
+                                    object: nil,
+                                    userInfo: ["next": next]
+                                )
+                            }
+                        } label: {
+                            ZStack {
+                                Image(systemName: "forward.end.fill")
+                                    .font(.system(size: 20, weight: .semibold))
+                                    .foregroundStyle(.white)
+                                
+                                // Show small loading indicator if next chapter is being prefetched
+                                if audioPlayer.nextPrefetchStatus == .prefetching {
+                                    VStack {
+                                        Spacer()
+                                        HStack {
+                                            Spacer()
+                                            ProgressView()
+                                                .scaleEffect(0.5)
+                                                .tint(.amber)
+                                                .padding(2)
+                                                .background(Circle().fill(.black.opacity(0.6)))
+                                        }
+                                    }
+                                }
+                            }
+                            .frame(width: 40, height: 40)
+                            .contentShape(Rectangle())
+                        }
+                        .buttonStyle(.plain)
+                        .disabled(audioPlayer.absoluteNextChapter == nil)
+                        .opacity(audioPlayer.absoluteNextChapter == nil ? 0.4 : 1.0)
+                    }
+                }
+            }
+            .padding(.horizontal, 20)
+            .padding(.vertical, 12)
+        }
+        .background(
+            // Dark rounded background (pill-shaped with full circular ends)
+            RoundedRectangle(cornerRadius: 40)
+                .fill(.ultraThinMaterial)
+                .overlay(
+                    RoundedRectangle(cornerRadius: 40)
+                        .fill(Color.black.opacity(0.3))
+                )
+        )
+        .frame(height: 20)
+        .shadow(color: .black.opacity(0.3), radius: 12, y: 4)
+        // Follow finger in both directions while dragging vertically
+        .offset(y: dragOffset)
+        // Visual feedback: fade out and scale down slightly when dragging down to dismiss
+        .opacity(dragOffset > 0 ? max(0.3, 1.0 - (dragOffset / 200)) : 1.0)
+        .scaleEffect(dragOffset > 0 ? max(0.95, 1.0 - (dragOffset / 800)) : 1.0)
+        .simultaneousGesture(
+            DragGesture(minimumDistance: 10, coordinateSpace: .local)
+                .onChanged { value in
+                    // Only handle vertical drags (not horizontal seeks)
+                    if abs(value.translation.height) > abs(value.translation.width) {
+                        if value.translation.height < 0 {
+                            // Upward swipe: rubberband resistance (opens full player)
+                            dragOffset = value.translation.height * 0.4
+                        } else {
+                            // Downward swipe: less resistance for easier dismiss
+                            dragOffset = value.translation.height * 0.8
+                        }
+                    }
+                }
+                .onEnded { value in
+                    let velocity = value.predictedEndTranslation.height - value.translation.height
+                    if value.translation.height < -40 || velocity < -200 {
+                        // Swipe up: open full player
+                        withAnimation(.spring(response: 0.35, dampingFraction: 0.75)) {
+                            dragOffset = 0
+                        }
+                        showFullPlayer = true
+                    } else if value.translation.height > 60 || velocity > 200 {
+                        // Swipe down: dismiss with animation
+                        withAnimation(.spring(response: 0.4, dampingFraction: 0.8)) {
+                            dragOffset = 300 // Slide out completely
+                        }
+                        // Stop audio after animation starts
+                        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+                            audioPlayer.stop()
+                        }
+                    } else {
+                        // Not enough distance: spring back
+                        withAnimation(.spring(response: 0.35, dampingFraction: 0.75)) {
+                            dragOffset = 0
+                        }
+                    }
+                }
+        )
+    }
+
+    private var chapterLabel: String {
+        let raw = audioPlayer.chapterTitle.isEmpty
+            ? "Chapter \(audioPlayer.chapter)"
+            : audioPlayer.chapterTitle
+        return raw.strippingTrailingDate()
+    }
+}
+
+// MARK: - Full player sheet
+
+struct FullPlayerView: View {
+    @EnvironmentObject var audioPlayer: AudioPlayerService
+    /// Called when the view wants to close itself (Done button or drag-to-dismiss).
+    var onDismiss: () -> Void = {}
+    
+    @State private var showingSpeedMenu = false
+    @State private var showingChaptersList = false
+    @State private var showingSleepTimer = false
+
+    var body: some View {
+        ZStack {
+            // ── Background: blurred cover art ──────────────────────────────
+            GeometryReader { geo in
+                KFImage(URL(string: audioPlayer.coverURL))
+                    .resizable()
+                    .scaledToFill()
+                    .frame(width: geo.size.width, height: geo.size.height)
+                    .clipped()
+                    .blur(radius: 40, opaque: true)
+                    .overlay(Color.black.opacity(0.55))
+                    .ignoresSafeArea()
+            }
+            .ignoresSafeArea()
+
+            // ── Content ────────────────────────────────────────────────────
+            VStack(spacing: 0) {
+                // Drag handle pill — visual cue that you can swipe down to close
+                Capsule()
+                    .fill(Color.white.opacity(0.35))
+                    .frame(width: 36, height: 4)
+                    .padding(.top, 12)
+                    .padding(.bottom, 16)
+
+                // Cover art with watermark
+                ZStack(alignment: .bottomLeading) {
+                    KFImage(URL(string: audioPlayer.coverURL))
+                        .resizable()
+                        .placeholder {
+                            RoundedRectangle(cornerRadius: 18)
+                                .fill(.white.opacity(0.1))
+                                .overlay(
+                                    Image(systemName: "book.closed")
+                                        .font(.system(size: 48))
+                                        .foregroundStyle(.white.opacity(0.4))
+                                )
+                        }
+                        .scaledToFill()
+                        .frame(width: 240, height: 240)
+                        .clipShape(RoundedRectangle(cornerRadius: 18))
+                        .shadow(color: .black.opacity(0.5), radius: 24, y: 12)
+                    
+                    // Watermark (voice name from audio player)
+                    Text(voiceName)
+                        .font(.custom("Snell Roundhand", size: 20))
+                        .foregroundStyle(.white.opacity(0.7))
+                        .shadow(color: .black.opacity(0.4), radius: 2)
+                        .padding(14)
+                }
+                .padding(.horizontal, 48)
+
+                // Title block
+                VStack(spacing: 4) {
+                    Text((audioPlayer.chapterTitle.isEmpty ? "Chapter \(audioPlayer.chapter)" : audioPlayer.chapterTitle).strippingTrailingDate())
+                        .font(.title3.weight(.bold))
+                        .foregroundStyle(.white)
+                        .multilineTextAlignment(.center)
+                        .lineLimit(2)
+                    Text(audioPlayer.bookTitle)
+                        .font(.subheadline)
+                        .foregroundStyle(.white.opacity(0.65))
+                        .lineLimit(1)
+                }
+                .padding(.horizontal, 32)
+                .padding(.top, 20)
+
+                // Action buttons row + metadata inline
+                HStack(spacing: 0) {
+                    Spacer()
+                    
+                    // Metadata pill (only when ready)
+                    if audioPlayer.status != .generating {
+                        Text("\(yearText) · \(cacheStatusText) · OPUS")
+                            .font(.caption2)
+                            .foregroundStyle(.white.opacity(0.35))
+                            .padding(.horizontal, 8)
+                    }
+                    
+                    Menu {
+                        Button {
+                            audioPlayer.autoNext.toggle()
+                        } label: {
+                            Label(
+                                audioPlayer.autoNext ? "Disable Auto-next" : "Enable Auto-next",
+                                systemImage: audioPlayer.autoNext ? "checkmark" : ""
+                            )
+                        }
+                    } label: {
+                        Image(systemName: "ellipsis.circle")
+                            .font(.system(size: 22))
+                            .foregroundStyle(.white.opacity(0.6))
+                            .frame(width: 40, height: 40)
+                    }
+                    .buttonStyle(.plain)
+                    
+                    Spacer()
+                }
+                .padding(.top, 10)
+
+                // Seek bar — hidden while generating
+                if audioPlayer.status != .generating {
+                    PlayerProgressSection(
+                        progress: audioPlayer.progress,
+                        onSeek: { audioPlayer.seek(to: $0) }
+                    )
+                } else {
+                    // Generating state: compact progress indicator with label
+                    VStack(spacing: 8) {
+                        ProgressView()
+                            .tint(.white.opacity(0.7))
+                            .scaleEffect(1.1)
+                        Text("Generating audio…")
+                            .font(.caption)
+                            .foregroundStyle(.white.opacity(0.5))
+                    }
+                    .frame(maxWidth: .infinity)
+                    .padding(.top, 20)
+                    .padding(.bottom, 4)
+                }
+
+                // Controls
+                HStack(spacing: 0) {
+                    // ← skip back 15s
+                    Button { audioPlayer.skip(by: -15) } label: {
+                        Image(systemName: "gobackward.15")
+                            .font(.system(size: 22, weight: .regular))
+                            .foregroundStyle(.white.opacity(audioPlayer.status == .generating ? 0.3 : 0.9))
+                            .frame(maxWidth: .infinity)
+                    }
+                    .buttonStyle(.plain)
+                    .disabled(audioPlayer.status == .generating)
+                    
+                    // ← previous chapter
+                    Button {
+                        if let prev = audioPlayer.absolutePrevChapter {
+                            onDismiss()
+                            NotificationCenter.default.post(
+                                name: .skipToPrevChapter,
+                                object: nil,
+                                userInfo: ["prev": prev]
+                            )
+                        }
+                    } label: {
+                        Image(systemName: "backward.end.fill")
+                            .font(.system(size: 28, weight: .regular))
+                            .foregroundStyle(.white.opacity(0.9))
+                            .frame(maxWidth: .infinity)
+                    }
+                    .buttonStyle(.plain)
+                    .disabled(audioPlayer.absolutePrevChapter == nil)
+                    .opacity(audioPlayer.absolutePrevChapter == nil ? 0.4 : 1.0)
+
+                    // play / pause — large circle button
+                    PlayerPlayPauseButton(
+                        progress: audioPlayer.progress,
+                        isGenerating: audioPlayer.status == .generating,
+                        onToggle: { audioPlayer.togglePlayPause() }
+                    )
+
+                    // → next chapter
+                    Button {
+                        if let next = audioPlayer.absoluteNextChapter {
+                            onDismiss()
+                            NotificationCenter.default.post(
+                                name: .skipToNextChapter,
+                                object: nil,
+                                userInfo: ["next": next]
+                            )
+                        }
+                    } label: {
+                        ZStack {
+                            Image(systemName: "forward.end.fill")
+                                .font(.system(size: 28, weight: .regular))
+                                .foregroundStyle(.white.opacity(0.9))
+                            
+                            if audioPlayer.nextPrefetchStatus == .prefetching {
+                                VStack {
+                                    Spacer()
+                                    HStack {
+                                        Spacer()
+                                        ProgressView()
+                                            .scaleEffect(0.55)
+                                            .tint(.amber)
+                                            .padding(3)
+                                            .background(Circle().fill(.black.opacity(0.6)))
+                                    }
+                                }
+                            }
+                        }
+                        .frame(maxWidth: .infinity)
+                    }
+                    .buttonStyle(.plain)
+                    .disabled(audioPlayer.absoluteNextChapter == nil)
+                    .opacity(audioPlayer.absoluteNextChapter == nil ? 0.4 : 1.0)
+                    
+                    // → skip forward 15s
+                    Button { audioPlayer.skip(by: 15) } label: {
+                        Image(systemName: "goforward.15")
+                            .font(.system(size: 22, weight: .regular))
+                            .foregroundStyle(.white.opacity(audioPlayer.status == .generating ? 0.3 : 0.9))
+                            .frame(maxWidth: .infinity)
+                    }
+                    .buttonStyle(.plain)
+                    .disabled(audioPlayer.status == .generating)
+                }
+                .padding(.horizontal, 20)
+                .padding(.top, 20)
+                .padding(.bottom, 20)
+
+                // Bottom toolbar
+                HStack(spacing: 0) {
+                    // AirPlay
+                    AirPlayButton()
+                        .frame(width: 22, height: 22)
+                        .frame(maxWidth: .infinity)
+                    
+                    // Speed control
+                    Menu {
+                        ForEach([0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0], id: \.self) { s in
+                            Button {
+                                audioPlayer.setSpeed(s)
+                            } label: {
+                                if s == audioPlayer.speed {
+                                    Label("\(s, specifier: "%.2g")×", systemImage: "checkmark")
+                                } else {
+                                    Text("\(s, specifier: "%.2g")×")
+                                }
+                            }
+                        }
+                    } label: {
+                        // Show current speed as a badge instead of gear icon
+                        Text("\(audioPlayer.speed, specifier: "%.2g")×")
+                            .font(.system(size: 14, weight: .semibold))
+                            .foregroundStyle(.white.opacity(0.7))
+                            .frame(maxWidth: .infinity)
+                    }
+                    .buttonStyle(.plain)
+                    
+                    // Collapse
+                    Button { onDismiss() } label: {
+                        Image(systemName: "chevron.down")
+                            .font(.system(size: 22, weight: .semibold))
+                            .foregroundStyle(.white.opacity(0.7))
+                            .frame(maxWidth: .infinity)
+                    }
+                    .buttonStyle(.plain)
+                    
+                    // Queue (show chapters list)
+                    Button { showingChaptersList = true } label: {
+                        Image(systemName: "list.bullet")
+                            .font(.system(size: 22))
+                            .foregroundStyle(.white.opacity(0.7))
+                            .frame(maxWidth: .infinity)
+                    }
+                    .buttonStyle(.plain)
+                    
+                    // Sleep timer
+                    Button { showingSleepTimer = true } label: {
+                        Image(systemName: sleepTimerIcon)
+                            .font(.system(size: 22))
+                            .foregroundStyle(audioPlayer.sleepTimer != nil ? .amber : .white.opacity(0.7))
+                            .frame(maxWidth: .infinity)
+                    }
+                    .buttonStyle(.plain)
+                }
+                .padding(.horizontal, 16)
+                .padding(.bottom, 12)
+            }
+            .ignoresSafeArea(edges: .bottom)
+        }
+        .sheet(isPresented: $showingChaptersList) {
+            ChaptersListSheet(
+                chapters: audioPlayer.chapters,
+                currentChapter: audioPlayer.chapter,
+                onChapterSelect: { selectedChapter in
+                    showingChaptersList = false
+                    guard selectedChapter != audioPlayer.chapter else { return }
+                    let currentAudioChapter = audioPlayer.chapter
+
+                    // Find the chapter metadata from the loaded list
+                    let chapterTitle = audioPlayer.chapters
+                        .first(where: { $0.number == selectedChapter })?.title ?? ""
+                    let nextChapter = audioPlayer.chapters
+                        .filter({ $0.number > selectedChapter })
+                        .min(by: { $0.number < $1.number })?.number
+                    let prevChapter: Int? = selectedChapter > 1 ? selectedChapter - 1 : nil
+
+                    // Load & start playing the selected chapter directly
+                    audioPlayer.load(
+                        slug: audioPlayer.slug,
+                        chapter: selectedChapter,
+                        chapterTitle: chapterTitle,
+                        bookTitle: audioPlayer.bookTitle,
+                        coverURL: audioPlayer.coverURL,
+                        voice: audioPlayer.voice,
+                        speed: audioPlayer.speed,
+                        chapters: audioPlayer.chapters,
+                        nextChapter: nextChapter,
+                        prevChapter: prevChapter
+                    )
+
+                    // Also navigate the text reader if it's open
+                    let notifName: Notification.Name = selectedChapter > currentAudioChapter
+                        ? .skipToNextChapter
+                        : .skipToPrevChapter
+                    let key = selectedChapter > currentAudioChapter ? "next" : "prev"
+                    NotificationCenter.default.post(
+                        name: notifName,
+                        object: nil,
+                        userInfo: [key: selectedChapter]
+                    )
+                }
+            )
+            .presentationDetents([.medium, .large])
+            .presentationDragIndicator(.visible)
+        }
+        .sheet(isPresented: $showingSleepTimer) {
+            SleepTimerSheet(audioPlayer: audioPlayer)
+                .presentationDetents([.height(500)])
+                .presentationDragIndicator(.visible)
+        }
+    }
+
+    private var voiceName: String {
+        // Extract voice name from audioPlayer.voice (e.g., "af_bella" -> "Bella")
+        let components = audioPlayer.voice.split(separator: "_")
+        if components.count > 1 {
+            return String(components[1]).capitalized
+        }
+        return audioPlayer.voice.capitalized
+    }
+    
+    private var cacheStatusText: String {
+        switch audioPlayer.status {
+        case .ready:
+            return "Cache"
+        case .generating:
+            return "Generating"
+        default:
+            return "Unknown"
+        }
+    }
+    
+    private static let yearFormatter: DateFormatter = {
+        let f = DateFormatter()
+        f.dateFormat = "yyyy"
+        return f
+    }()
+
+    private var yearText: String {
+        // TODO: Could fetch actual publication year from book metadata
+        // For now, return current year or placeholder
+        return Self.yearFormatter.string(from: Date())
+    }
+    
+    private var sleepTimerIcon: String {
+        audioPlayer.sleepTimer != nil ? "moon.zzz.fill" : "moon.zzz"
+    }
+}
+
+// MARK: - AirPlay Button
+
+struct AirPlayButton: UIViewControllerRepresentable {
+    func makeUIViewController(context: Context) -> UIViewController {
+        let vc = UIViewController()
+        vc.view.backgroundColor = .clear
+
+        let picker = AVRoutePickerView()
+        picker.tintColor = UIColor.white.withAlphaComponent(0.7)
+        picker.activeTintColor = UIColor(named: "AccentColor") ?? UIColor.systemOrange
+        picker.prioritizesVideoDevices = false
+        picker.translatesAutoresizingMaskIntoConstraints = false
+
+        vc.view.addSubview(picker)
+        NSLayoutConstraint.activate([
+            picker.leadingAnchor.constraint(equalTo: vc.view.leadingAnchor),
+            picker.trailingAnchor.constraint(equalTo: vc.view.trailingAnchor),
+            picker.topAnchor.constraint(equalTo: vc.view.topAnchor),
+            picker.bottomAnchor.constraint(equalTo: vc.view.bottomAnchor),
+        ])
+        return vc
+    }
+
+    func updateUIViewController(_ uiViewController: UIViewController, context: Context) {}
+}
+
+// MARK: - Sleep Timer Sheet
+
+struct SleepTimerSheet: View {
+    @ObservedObject var audioPlayer: AudioPlayerService
+    @Environment(\.dismiss) private var dismiss
+    
+    var body: some View {
+        NavigationStack {
+            List {
+                Section {
+                    Button {
+                        audioPlayer.setSleepTimer(nil)
+                        dismiss()
+                    } label: {
+                        HStack {
+                            Text("Off")
+                                .foregroundStyle(.primary)
+                            Spacer()
+                            if audioPlayer.sleepTimer == nil {
+                                Image(systemName: "checkmark")
+                                    .foregroundStyle(.amber)
+                            }
+                        }
+                    }
+                } header: {
+                    Text("Chapter-based")
+                }
+                
+                Section {
+                    ForEach([1, 2, 3, 4], id: \.self) { count in
+                        Button {
+                            audioPlayer.setSleepTimer(.chapters(count))
+                            dismiss()
+                        } label: {
+                            HStack {
+                                Text("\(count) \(count == 1 ? "chapter" : "chapters")")
+                                    .foregroundStyle(.primary)
+                                Spacer()
+                                if case .chapters(let c) = audioPlayer.sleepTimer, c == count {
+                                    Image(systemName: "checkmark")
+                                        .foregroundStyle(.amber)
+                                }
+                            }
+                        }
+                    }
+                }
+                
+                Section {
+                    ForEach([20, 40, 60, 120], id: \.self) { minutes in
+                        Button {
+                            audioPlayer.setSleepTimer(.minutes(minutes))
+                            dismiss()
+                        } label: {
+                            HStack {
+                                Text(formatTimerOption(minutes))
+                                    .foregroundStyle(.primary)
+                                Spacer()
+                                if case .minutes(let m) = audioPlayer.sleepTimer, m == minutes {
+                                    Image(systemName: "checkmark")
+                                        .foregroundStyle(.amber)
+                                }
+                            }
+                        }
+                    }
+                } header: {
+                    Text("Time-based")
+                }
+            }
+            .navigationTitle("Sleep Timer")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    Button("Done") {
+                        dismiss()
+                    }
+                    .fontWeight(.semibold)
+                }
+            }
+        }
+    }
+    
+    private func formatTimerOption(_ minutes: Int) -> String {
+        if minutes < 60 {
+            return "\(minutes) mins"
+        } else {
+            let hours = minutes / 60
+            return "\(hours) \(hours == 1 ? "hour" : "hours")"
+        }
+    }
+}
+
+// MARK: - Chapters List Sheet
+
+struct ChaptersListSheet: View {
+    let chapters: [ChapterIndexBrief]
+    let currentChapter: Int
+    let onChapterSelect: (Int) -> Void
+    
+    @Environment(\.dismiss) private var dismiss
+    
+    // Initialize scroll position to current chapter immediately (before view appears)
+    init(chapters: [ChapterIndexBrief], currentChapter: Int, onChapterSelect: @escaping (Int) -> Void) {
+        self.chapters = chapters
+        self.currentChapter = currentChapter
+        self.onChapterSelect = onChapterSelect
+        // Set initial scroll position state before view renders
+        _scrollPosition = State(initialValue: currentChapter)
+    }
+    
+    @State private var scrollPosition: Int?
+    
+    var body: some View {
+        NavigationStack {
+            List {
+                ForEach(chapters, id: \.number) { chapter in
+                    Button {
+                        onChapterSelect(chapter.number)
+                    } label: {
+                        HStack(spacing: 12) {
+                            // Chapter number badge
+                            Text("\(chapter.number)")
+                                .font(.caption.bold())
+                                .foregroundStyle(chapter.number == currentChapter ? .white : .secondary)
+                                .frame(width: 44, height: 44)
+                                .background(
+                                    Circle()
+                                        .fill(chapter.number == currentChapter ? Color.amber : Color.gray.opacity(0.2))
+                                )
+                            
+                            // Chapter title
+                            VStack(alignment: .leading, spacing: 4) {
+                                Text(chapter.title.strippingTrailingDate())
+                                    .font(.subheadline.weight(chapter.number == currentChapter ? .semibold : .regular))
+                                    .foregroundStyle(chapter.number == currentChapter ? .primary : .primary)
+                                    .lineLimit(2)
+                                
+                                if chapter.number == currentChapter {
+                                    Text("Now Playing")
+                                        .font(.caption2)
+                                        .foregroundStyle(.amber)
+                                }
+                            }
+                            
+                            Spacer()
+                            
+                            // Checkmark for current chapter
+                            if chapter.number == currentChapter {
+                                Image(systemName: "checkmark")
+                                    .font(.caption.bold())
+                                    .foregroundStyle(.amber)
+                            }
+                        }
+                        .padding(.vertical, 8)
+                    }
+                    .buttonStyle(.plain)
+                    .listRowBackground(
+                        chapter.number == currentChapter
+                            ? Color.amber.opacity(0.1)
+                            : Color.clear
+                    )
+                    .id(chapter.number)
+                }
+            }
+            .listStyle(.plain)
+            .scrollPosition(id: $scrollPosition, anchor: .center)
+            .navigationTitle("Chapters")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    Button("Done") {
+                        dismiss()
+                    }
+                    .fontWeight(.semibold)
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Custom seek slider
+// A thicker, rounded-thumb slider that matches the amber design language.
+
+struct PlayerSlider: View {
+    @Binding var value: Double
+    let range: ClosedRange<Double>
+
+    @State private var isDragging = false
+
+    var body: some View {
+        GeometryReader { geo in
+            let width = geo.size.width
+            let fraction = (value - range.lowerBound) / (range.upperBound - range.lowerBound)
+            let clampedFraction = max(0, min(1, fraction))
+            let filled = width * clampedFraction
+            let thumbSize: CGFloat = isDragging ? 22 : 22
+            let trackHeight: CGFloat = isDragging ? 5 : 4
+
+            ZStack(alignment: .leading) {
+                // Track
+                Capsule()
+                    .fill(Color.white.opacity(0.2))
+                    .frame(height: trackHeight)
+
+                // Fill
+                Capsule()
+                    .fill(Color.amber)
+                    .frame(width: max(filled, thumbSize / 2), height: trackHeight)
+
+                // Thumb
+                Circle()
+                    .fill(Color.white)
+                    .frame(width: thumbSize, height: thumbSize)
+                    .shadow(color: .black.opacity(0.25), radius: 3, y: 1)
+                    .offset(x: max(0, filled - thumbSize / 2))
+                    .animation(.spring(response: 0.2), value: isDragging)
+            }
+            .frame(height: 28) // generous touch target
+            .contentShape(Rectangle())
+            .gesture(
+                DragGesture(minimumDistance: 0)
+                    .onChanged { drag in
+                        isDragging = true
+                        let raw = drag.location.x / width
+                        let clamped = max(0, min(1, raw))
+                        value = range.lowerBound + clamped * (range.upperBound - range.lowerBound)
+                    }
+                    .onEnded { _ in
+                        isDragging = false
+                    }
+            )
+        }
+        .frame(height: 28)
+    }
+}
+
+// MARK: - Isolated mini-player progress bar background
+
+private struct MiniPlayerProgressBar: View {
+    @ObservedObject var progress: PlaybackProgress
+
+    var body: some View {
+        GeometryReader { geo in
+            ZStack(alignment: .leading) {
+                RoundedRectangle(cornerRadius: 40)
+                    .fill(Color.white.opacity(0.2))
+                RoundedRectangle(cornerRadius: 6)
+                    .fill(Color.amber.opacity(0.3))
+                    .frame(width: max(0, geo.size.width * fraction))
+            }
+            .clipShape(RoundedRectangle(cornerRadius: 40))
+        }
+    }
+
+    private var fraction: CGFloat {
+        guard progress.duration > 0 else { return 0 }
+        return CGFloat(progress.currentTime / progress.duration)
+    }
+}
+
+// MARK: - Isolated progress section (seek bar + timestamps)
+// Observes PlaybackProgress directly so the 0.5-second time ticks only
+// invalidate this small view — not the menus or controls around it.
+
+private struct PlayerProgressSection: View {
+    @ObservedObject var progress: PlaybackProgress
+    let onSeek: (Double) -> Void
+
+    var body: some View {
+        VStack(spacing: 4) {
+            PlayerSlider(
+                value: Binding(
+                    get: { progress.currentTime },
+                    set: { onSeek($0) }
+                ),
+                range: 0...max(progress.duration, 1)
+            )
+            HStack {
+                Text(formatTime(progress.currentTime))
+                Spacer()
+                Text("-" + formatTime(progress.duration - progress.currentTime))
+            }
+            .font(.caption.monospacedDigit())
+            .foregroundStyle(.white.opacity(0.5))
+        }
+        .padding(.horizontal, 28)
+    }
+
+    private func formatTime(_ seconds: Double) -> String {
+        guard seconds.isFinite, seconds >= 0 else { return "0:00" }
+        let s = Int(seconds)
+        return "\(s / 60):\(String(format: "%02d", s % 60))"
+    }
+}
+
+// MARK: - Isolated play/pause button
+// Observes PlaybackProgress so isPlaying changes only re-render this button.
+
+private struct PlayerPlayPauseButton: View {
+    @ObservedObject var progress: PlaybackProgress
+    let isGenerating: Bool
+    let onToggle: () -> Void
+
+    var body: some View {
+        Button { onToggle() } label: {
+            ZStack {
+                Circle()
+                    .fill(.white.opacity(0.15))
+                    .frame(width: 64, height: 64)
+                if isGenerating {
+                    ProgressView()
+                        .tint(.white)
+                        .scaleEffect(1.2)
+                } else {
+                    Image(systemName: progress.isPlaying ? "pause.fill" : "play.fill")
+                        .font(.system(size: 30, weight: .bold))
+                        .foregroundStyle(.white)
+                        .offset(x: progress.isPlaying ? 0 : 2)
+                }
+            }
+            .frame(maxWidth: .infinity)
+        }
+        .buttonStyle(.plain)
+        .disabled(isGenerating)
+    }
+}
+
+// MARK: - Isolated mini-player play/pause button
+
+private struct MiniPlayerPlayPauseButton: View {
+    @ObservedObject var progress: PlaybackProgress
+    let onToggle: () -> Void
+
+    var body: some View {
+        Button { onToggle() } label: {
+            Image(systemName: progress.isPlaying ? "pause.fill" : "play.fill")
+                .font(.system(size: 24, weight: .semibold))
+                .foregroundStyle(.white)
+                .frame(width: 44, height: 44)
+                .contentShape(Rectangle())
+        }
+        .buttonStyle(.plain)
+    }
+}

ios/LibNovel/LibNovel/Views/Profile/ProfileView.swift

@@ -0,0 +1,217 @@
+import SwiftUI
+
+struct ProfileView: View {
+    @EnvironmentObject var authStore: AuthStore
+    @StateObject private var vm = ProfileViewModel()
+    @State private var showChangePassword = false
+
+    var body: some View {
+        NavigationStack {
+            List {
+                // User header
+                Section {
+                    HStack(spacing: 14) {
+                        Image(systemName: "person.circle.fill")
+                            .font(.system(size: 48))
+                            .foregroundStyle(.amber)
+                        VStack(alignment: .leading, spacing: 2) {
+                            Text(authStore.user?.username ?? "")
+                                .font(.headline)
+                            Text(authStore.user?.role.capitalized ?? "")
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                        }
+                    }
+                    .padding(.vertical, 6)
+                }
+
+                // Reading settings
+                Section("Reading Settings") {
+                    voicePicker
+                    speedSlider
+                    Toggle("Auto-advance chapter", isOn: Binding(
+                        get: { authStore.settings.autoNext },
+                        set: { newVal in
+                            Task {
+                                var s = authStore.settings
+                                s.autoNext = newVal
+                                await authStore.saveSettings(s)
+                            }
+                        }
+                    ))
+                    .tint(.amber)
+                }
+
+                // Sessions
+                Section("Active Sessions") {
+                    if vm.sessionsLoading {
+                        ProgressView()
+                    } else {
+                        ForEach(vm.sessions) { session in
+                            SessionRow(session: session) {
+                                Task { await vm.revokeSession(id: session.id) }
+                            }
+                        }
+                    }
+                }
+
+                // Account
+                Section("Account") {
+                    Button("Change Password") { showChangePassword = true }
+                    Button("Sign Out", role: .destructive) {
+                        Task { await authStore.logout() }
+                    }
+                }
+            }
+            .navigationTitle("Profile")
+            .task { await vm.loadSessions() }
+            .sheet(isPresented: $showChangePassword) {
+                ChangePasswordView()
+            }
+            .errorAlert($vm.error)
+        }
+    }
+
+    // MARK: - Voice picker
+
+    @ViewBuilder
+    private var voicePicker: some View {
+        Picker("TTS Voice", selection: Binding(
+            get: { authStore.settings.voice },
+            set: { newVoice in
+                Task {
+                    var s = authStore.settings
+                    s.voice = newVoice
+                    await authStore.saveSettings(s)
+                }
+            }
+        )) {
+            if vm.voices.isEmpty {
+                Text("Default").tag("af_bella")
+            } else {
+                ForEach(vm.voices, id: \.self) { v in
+                    Text(v).tag(v)
+                }
+            }
+        }
+        .task { await vm.loadVoices() }
+    }
+
+    // MARK: - Speed slider
+
+    @ViewBuilder
+    private var speedSlider: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            HStack {
+                Text("Playback Speed")
+                Spacer()
+                Text("\(authStore.settings.speed, specifier: "%.1f")×")
+                    .foregroundStyle(.secondary)
+            }
+            Slider(
+                value: Binding(
+                    get: { authStore.settings.speed },
+                    set: { newSpeed in
+                        Task {
+                            var s = authStore.settings
+                            s.speed = newSpeed
+                            await authStore.saveSettings(s)
+                        }
+                    }
+                ),
+                in: 0.5...2.0, step: 0.25
+            )
+            .tint(.amber)
+        }
+    }
+}
+
+// MARK: - Session row
+
+private struct SessionRow: View {
+    let session: UserSession
+    let onRevoke: () -> Void
+    var body: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            HStack {
+                Image(systemName: "iphone")
+                Text(session.userAgent.isEmpty ? "Unknown device" : session.userAgent)
+                    .font(.subheadline)
+                    .lineLimit(1)
+                Spacer()
+                if session.isCurrent {
+                    Text("This device")
+                        .font(.caption2.bold())
+                        .foregroundStyle(.amber)
+                } else {
+                    Button("Revoke", role: .destructive, action: onRevoke)
+                        .font(.caption)
+                }
+            }
+            Text("Last seen: \(session.lastSeen.prefix(10))")
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+        }
+    }
+}
+
+// MARK: - Change password sheet
+
+struct ChangePasswordView: View {
+    @Environment(\.dismiss) private var dismiss
+    @EnvironmentObject var authStore: AuthStore
+    @State private var current = ""
+    @State private var newPwd = ""
+    @State private var confirm = ""
+    @State private var isLoading = false
+    @State private var error: String?
+    @State private var success = false
+
+    var body: some View {
+        NavigationStack {
+            Form {
+                Section {
+                    SecureField("Current password", text: $current)
+                    SecureField("New password", text: $newPwd)
+                    SecureField("Confirm new password", text: $confirm)
+                }
+                if let error {
+                    Text(error).foregroundStyle(.red).font(.caption)
+                }
+                if success {
+                    Text("Password changed successfully").foregroundStyle(.green).font(.caption)
+                }
+            }
+            .navigationTitle("Change Password")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .topBarLeading) { Button("Cancel") { dismiss() } }
+                ToolbarItem(placement: .topBarTrailing) {
+                    Button("Save") { save() }
+                        .disabled(isLoading || newPwd.count < 4 || newPwd != confirm)
+                }
+            }
+        }
+    }
+
+    private func save() {
+        guard newPwd == confirm else { error = "Passwords do not match"; return }
+        isLoading = true
+        error = nil
+        Task {
+            do {
+                struct Body: Encodable { let currentPassword, newPassword: String }
+                let _: EmptyResponse = try await APIClient.shared.fetch(
+                    "/api/auth/change-password", method: "POST",
+                    body: Body(currentPassword: current, newPassword: newPwd)
+                )
+                success = true
+                try? await Task.sleep(nanoseconds: 1_200_000_000)
+                dismiss()
+            } catch {
+                self.error = error.localizedDescription
+            }
+            isLoading = false
+        }
+    }
+}

ios/LibNovel/LibNovelTests/LibNovelTests.swift

@@ -0,0 +1,9 @@
+import XCTest
+@testable import LibNovel
+
+final class LibNovelTests: XCTestCase {
+    func testExample() throws {
+        // Placeholder — add real tests here
+        XCTAssert(true)
+    }
+}

ios/LibNovel/fastlane/Fastfile

@@ -0,0 +1,32 @@
+default_platform(:ios)
+
+platform :ios do
+  desc "Build and upload to TestFlight"
+  lane :beta do
+    # Generate Xcode project from project.yml (one level up from fastlane/)
+    sh("cd .. && xcodegen generate --spec project.yml --project .")
+
+    # Set build number from CI run number (passed as env var)
+    increment_build_number(
+      build_number: ENV["BUILD_NUMBER"] || "1",
+      xcodeproj: "LibNovel.xcodeproj"
+    )
+
+    # Build the app
+    build_app(
+      scheme: "LibNovel",
+      export_method: "app-store",
+      clean: true,
+      export_options: {
+        provisioningProfiles: {
+          "com.kalekber.LibNovel" => ENV["PROVISIONING_PROFILE_NAME"] || "LibNovel Distribution"
+        }
+      }
+    )
+
+    # Upload to TestFlight
+    upload_to_testflight(
+      skip_waiting_for_build_processing: true
+    )
+  end
+end

ios/LibNovel/project.yml

@@ -0,0 +1,89 @@
+name: LibNovel
+options:
+  bundleIdPrefix: com.kalekber
+  deploymentTarget:
+    iOS: "17.0"
+  xcodeVersion: "16.0"
+  generateEmptyDirectories: true
+  indentWidth: 4
+  tabWidth: 4
+  usesTabs: false
+
+settings:
+  base:
+    SWIFT_VERSION: "5.10"
+    ENABLE_PREVIEWS: YES
+    MARKETING_VERSION: "1.0.0"
+    CURRENT_PROJECT_VERSION: "1"
+    LIBNOVEL_BASE_URL: "https://v2.libnovel.kalekber.cc"
+  configs:
+    Debug:
+      SWIFT_ACTIVE_COMPILATION_CONDITIONS: DEBUG
+    Release:
+      SWIFT_ACTIVE_COMPILATION_CONDITIONS: ""
+
+packages:
+  # Async image loading with caching
+  Kingfisher:
+    url: https://github.com/onevcat/Kingfisher
+    from: "8.0.0"
+
+targets:
+  LibNovel:
+    type: application
+    platform: iOS
+    deploymentTarget: "17.0"
+    sources:
+      - path: LibNovel
+        excludes:
+          - "**/.DS_Store"
+          - "Resources/Info.plist"
+    resources:
+      - path: LibNovel/Resources/Assets.xcassets
+    dependencies:
+      - package: Kingfisher
+    settings:
+      base:
+        PRODUCT_BUNDLE_IDENTIFIER: com.kalekber.LibNovel
+        ASSETCATALOG_COMPILER_APPICON_NAME: AppIcon
+        TARGETED_DEVICE_FAMILY: "1,2"   # iPhone + iPad
+        GENERATE_INFOPLIST_FILE: NO
+        INFOPLIST_FILE: LibNovel/Resources/Info.plist
+      configs:
+        Release:
+          CODE_SIGN_STYLE: Manual
+          DEVELOPMENT_TEAM: GHZXC6FVMU
+
+  LibNovelTests:
+    type: bundle.unit-test
+    platform: iOS
+    deploymentTarget: "17.0"
+    sources:
+      - path: LibNovelTests
+    dependencies:
+      - target: LibNovel
+    settings:
+      base:
+        PRODUCT_BUNDLE_IDENTIFIER: com.kalekber.LibNovel.tests
+
+schemes:
+  LibNovel:
+    build:
+      targets:
+        LibNovel: all
+    run:
+      config: Debug
+      environmentVariables:
+        LIBNOVEL_BASE_URL:
+          value: "https://v2.libnovel.kalekber.cc"
+          isEnabled: true
+    test:
+      config: Debug
+      targets:
+        - LibNovelTests
+    profile:
+      config: Release
+    analyze:
+      config: Debug
+    archive:
+      config: Release

justfile

@@ -1,8 +1,13 @@
 # justfile — libnovel-v2 task runner
 # Install just: https://just.systems
 
-scraper_dir := "scraper"
-ui_dir      := "ui"
+scraper_dir  := "scraper"
+ui_dir       := "ui"
+ios_dir      := "ios/LibNovel"
+ios_scheme   := "LibNovel"
+ios_sim      := "platform=iOS Simulator,name=iPhone 17"
+ios_spm      := ".spm-cache"
+runner_temp  := env_var_or_default("RUNNER_TEMP", "/tmp")
 
 # ─── Build ────────────────────────────────────────────────────────────────────
 
@@ -18,7 +23,7 @@ build-all:
 
 # Run unit tests only (no integration services required)
 test:
-    cd {{scraper_dir}} && go test ./...
+    cd {{scraper_dir}} && go test -race -count=1 -timeout=60s ./...
 
 # Run integration tests (requires MinIO, PocketBase, optional Browserless)
 # Override env vars as needed, e.g.:
@@ -78,6 +83,92 @@ ui-install:
 ui-build:
     cd {{ui_dir}} && npm run build
 
+# ─── iOS ──────────────────────────────────────────────────────────────────────
+
+# Regenerate LibNovel.xcodeproj from project.yml (run after structural changes)
+ios-gen:
+    cd {{ios_dir}} && xcodegen generate --spec project.yml --project .
+
+# Resolve SPM package dependencies (cached to {{ios_spm}})
+ios-resolve:
+    cd {{ios_dir}} && xcodebuild \
+        -project {{ios_scheme}}.xcodeproj \
+        -scheme {{ios_scheme}} \
+        -resolvePackageDependencies \
+        -clonedSourcePackagesDirPath {{ios_spm}}
+
+# Build the iOS app for the simulator (no signing required)
+# Runs ios-gen first to ensure the project is up to date.
+ios-build: ios-gen ios-resolve
+    cd {{ios_dir}} && set -o pipefail && xcodebuild \
+        -project {{ios_scheme}}.xcodeproj \
+        -scheme {{ios_scheme}} \
+        -configuration Debug \
+        -destination 'generic/platform=iOS Simulator' \
+        -clonedSourcePackagesDirPath {{ios_spm}} \
+        CODE_SIGNING_ALLOWED=NO \
+        | xcpretty || xcodebuild \
+            -project {{ios_scheme}}.xcodeproj \
+            -scheme {{ios_scheme}} \
+            -configuration Debug \
+            -destination 'generic/platform=iOS Simulator' \
+            -clonedSourcePackagesDirPath {{ios_spm}} \
+            CODE_SIGNING_ALLOWED=NO
+
+# Run unit tests on the simulator
+# Runs ios-gen first to ensure the project is up to date.
+ios-test: ios-gen ios-resolve
+    cd {{ios_dir}} && set -o pipefail && xcodebuild test \
+        -project {{ios_scheme}}.xcodeproj \
+        -scheme {{ios_scheme}} \
+        -configuration Debug \
+        -destination '{{ios_sim}}' \
+        -clonedSourcePackagesDirPath {{ios_spm}} \
+        CODE_SIGNING_ALLOWED=NO \
+        | xcpretty --report junit --output test-results.xml || true
+
+# Archive a signed Release build (requires valid signing identity in keychain).
+# Output: {{runner_temp}}/LibNovel.xcarchive
+# Typically called from CI after importing certificate + provisioning profile.
+# Usage: just ios-archive <team-id> <profile-uuid>
+ios-archive team_id profile_uuid: ios-gen ios-resolve
+    cd {{ios_dir}} && xcodebuild archive \
+        -project {{ios_scheme}}.xcodeproj \
+        -scheme {{ios_scheme}} \
+        -configuration Release \
+        -destination 'generic/platform=iOS' \
+        -clonedSourcePackagesDirPath {{ios_spm}} \
+        -archivePath {{runner_temp}}/LibNovel.xcarchive \
+        CODE_SIGN_IDENTITY="Apple Distribution" \
+        "PROVISIONING_PROFILE[sdk=iphoneos*]={{profile_uuid}}" \
+        DEVELOPMENT_TEAM="{{team_id}}"
+
+# Export an IPA from the archive produced by ios-archive.
+# Requires ios/LibNovel/ExportOptions.plist.
+# Output: {{runner_temp}}/ipa/LibNovel.ipa
+ios-export:
+    cd {{ios_dir}} && xcodebuild -exportArchive \
+        -archivePath {{runner_temp}}/LibNovel.xcarchive \
+        -exportPath {{runner_temp}}/ipa \
+        -exportOptionsPlist ExportOptions.plist
+
+# Set the build number (CFBundleVersion) in project.yml before archiving.
+# Usage: just ios-set-build-number 42
+ios-set-build-number number:
+    cd {{ios_dir}} && sed -i '' \
+        's/CURRENT_PROJECT_VERSION: .*/CURRENT_PROJECT_VERSION: {{number}}/' \
+        project.yml
+
+# Upload the exported IPA to TestFlight via App Store Connect API.
+# Requires env vars: ASC_KEY_ID, ASC_ISSUER_ID, ASC_PRIVATE_KEY_PATH
+# The private key (.p8 file) must be present at ASC_PRIVATE_KEY_PATH.
+ios-upload:
+    xcrun altool --upload-app \
+        --type ios \
+        --file {{runner_temp}}/ipa/LibNovel.ipa \
+        --apiKey "$ASC_KEY_ID" \
+        --apiIssuer "$ASC_ISSUER_ID"
+
 # ─── Docker Compose ───────────────────────────────────────────────────────────
 
 # Start all services (browserless, kokoro, scraper, minio, pocketbase)

scraper/internal/e2e/e2e_test.go

@@ -101,7 +101,7 @@ func newE2EFixture(t *testing.T) *e2eFixture {
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
-	hs, err := storage.NewHybridStore(ctx, pbCfg, minioCfg)
+	hs, err := storage.NewHybridStore(ctx, pbCfg, minioCfg, slog.Default())
 	if err != nil {
 		t.Fatalf("NewHybridStore: %v", err)
 	}

scraper/internal/orchestrator/orchestrator_test.go

@@ -155,8 +155,9 @@ func (s *mockStore) SaveBrowsePage(_ context.Context, _, _ string) error { retur
 func (s *mockStore) GetBrowsePage(_ context.Context, _ string) (string, bool, error) {
 	return "", false, nil
 }
-func (s *mockStore) BrowseHTMLKey(_ string, _ int) string { return "" }
-func (s *mockStore) BrowseCoverKey(_, _ string) string    { return "" }
+func (s *mockStore) BrowseHTMLKey(_ string, _ int) string                         { return "" }
+func (s *mockStore) BrowseFilteredHTMLKey(_ string, _ int, _, _, _ string) string { return "" }
+func (s *mockStore) BrowseCoverKey(_, _ string) string                            { return "" }
 func (s *mockStore) SaveBrowseAsset(_ context.Context, _ string, _ []byte, _ string) error {
 	return nil
 }
@@ -172,6 +173,18 @@ func (s *mockStore) UpdateScrapeTask(_ context.Context, _ string, _ storage.Scra
 func (s *mockStore) ListScrapeTasks(_ context.Context) ([]storage.ScrapeTask, error) {
 	return nil, nil
 }
+func (s *mockStore) CreateAudioJob(_ context.Context, _ string, _ int, _ string) (string, error) {
+	return "audio-job-id", nil
+}
+func (s *mockStore) UpdateAudioJob(_ context.Context, _, _, _ string, _ time.Time) error {
+	return nil
+}
+func (s *mockStore) GetAudioJob(_ context.Context, _ string) (storage.AudioJob, bool, error) {
+	return storage.AudioJob{}, false, nil
+}
+func (s *mockStore) ListAudioJobs(_ context.Context) ([]storage.AudioJob, error) {
+	return nil, nil
+}
 
 // ── helpers ───────────────────────────────────────────────────────────────────
 

scraper/internal/server/handlers_audio.go

@@ -16,17 +16,15 @@ import (
 //
 // handleAudioGenerate handles POST /api/audio/{slug}/{n}.
 //
-// It calls Kokoro's POST /v1/audio/speech with return_download_link=true.
-// Kokoro generates the audio, saves it to its own temp storage, and returns
-// the download filename in the X-Download-Path response header.
-// We cache that filename (in memory, keyed by slug/chapter/voice) and
-// return a proxy URL that the browser sets as audio.src.
+// The handler is non-blocking: it creates an audio_jobs record in PocketBase
+// with status="pending", then fires a background goroutine to call Kokoro.
+// The caller should poll GET /api/audio/status/{slug}/{n} to track progress.
 //
-// TTS is always generated at speed 1.0; playback speed is controlled
-// client-side via the <audio> element's playbackRate.
+// If audio is already cached (audio_cache hit) the handler returns
+// status=200 with the proxy URL immediately — no job is created.
 //
-// On a cache hit the proxy URL is returned immediately without re-generating.
-// Concurrent requests for the same key are deduplicated.
+// Concurrent requests for the same key are deduplicated via audioJobIDs:
+// the second caller gets a 202 with the existing job_id immediately.
 func (s *Server) handleAudioGenerate(w http.ResponseWriter, r *http.Request) {
 	slug := r.PathValue("slug")
 	n, err := strconv.Atoi(r.PathValue("n"))
@@ -35,8 +33,7 @@ func (s *Server) handleAudioGenerate(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// Parse optional voice from JSON body. Speed is intentionally ignored —
-	// TTS is always generated at 1.0; playback speed is applied client-side.
+	// Parse optional voice from JSON body.
 	voice := s.kokoroVoice
 	var body struct {
 		Voice    string `json:"voice"`
@@ -58,84 +55,197 @@ func (s *Server) handleAudioGenerate(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Deduplicate concurrent generation for the same key.
+	// If a goroutine is already running for this key, return the existing job_id.
 	s.audioMu.Lock()
-	if ch, ok := s.audioInFlight[cacheKey]; ok {
+	if jobID, ok := s.audioJobIDs[cacheKey]; ok {
 		s.audioMu.Unlock()
-		select {
-		case <-ch:
-		case <-r.Context().Done():
-			http.Error(w, `{"error":"request cancelled"}`, http.StatusServiceUnavailable)
-			return
-		}
-		// Check store again after waiting.
-		if filename, ok := s.store.GetAudioCache(r.Context(), cacheKey); ok {
-			s.writeAudioResponse(w, slug, n, voice, filename)
-		} else {
-			http.Error(w, `{"error":"audio generation failed"}`, http.StatusInternalServerError)
-		}
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusAccepted)
+		_ = json.NewEncoder(w).Encode(map[string]string{"job_id": jobID, "status": "generating"})
 		return
 	}
-	ch := make(chan struct{})
-	s.audioInFlight[cacheKey] = ch
+
+	// Create the PocketBase job record.
+	jobID, createErr := s.store.CreateAudioJob(r.Context(), slug, n, voice)
+	if createErr != nil {
+		s.audioMu.Unlock()
+		s.log.Warn("audio: failed to create job record", "slug", slug, "chapter", n, "err", createErr)
+		// Non-fatal: still proceed, just won't have a persistent job record.
+		jobID = ""
+	}
+
+	s.audioJobIDs[cacheKey] = jobID
 	s.audioMu.Unlock()
 
-	defer func() {
-		s.audioMu.Lock()
-		delete(s.audioInFlight, cacheKey)
-		s.audioMu.Unlock()
-		close(ch)
+	// Fire background goroutine — request context must NOT be used here since
+	// the handler returns immediately.
+	maxChars := body.MaxChars
+	go func() {
+		defer func() {
+			s.audioMu.Lock()
+			delete(s.audioJobIDs, cacheKey)
+			s.audioMu.Unlock()
+		}()
+
+		bgCtx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
+		defer cancel()
+
+		s.runAudioGeneration(bgCtx, jobID, slug, n, voice, maxChars, cacheKey)
 	}()
 
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusAccepted)
+	_ = json.NewEncoder(w).Encode(map[string]string{"job_id": jobID, "status": "pending"})
+}
+
+// runAudioGeneration performs the actual Kokoro TTS work in a goroutine.
+// It updates the audio_jobs record as it progresses and writes to audio_cache
+// and MinIO on success.
+func (s *Server) runAudioGeneration(ctx context.Context, jobID, slug string, n int, voice string, maxChars int, cacheKey string) {
+	markFailed := func(msg string) {
+		if jobID == "" {
+			return
+		}
+		if err := s.store.UpdateAudioJob(ctx, jobID, "failed", msg, time.Now()); err != nil {
+			s.log.Warn("audio: failed to update job to failed", "job_id", jobID, "err", err)
+		}
+	}
+
+	// Transition to "generating".
+	if jobID != "" {
+		if err := s.store.UpdateAudioJob(ctx, jobID, "generating", "", time.Time{}); err != nil {
+			s.log.Warn("audio: failed to mark job generating", "job_id", jobID, "err", err)
+		}
+	}
+
 	// Load and validate chapter text.
-	raw, err := s.store.ReadChapter(r.Context(), slug, n)
+	raw, err := s.store.ReadChapter(ctx, slug, n)
 	if err != nil {
-		http.Error(w, `{"error":"chapter not found"}`, http.StatusNotFound)
+		s.log.Error("audio: chapter not found", "slug", slug, "chapter", n, "err", err)
+		markFailed("chapter not found")
 		return
 	}
 	text := stripMarkdown(raw)
 	if text == "" {
-		http.Error(w, `{"error":"chapter text is empty"}`, http.StatusUnprocessableEntity)
+		markFailed("chapter text is empty")
 		return
 	}
-	if body.MaxChars > 0 && len([]rune(text)) > body.MaxChars {
-		text = string([]rune(text)[:body.MaxChars])
+	if maxChars > 0 && len([]rune(text)) > maxChars {
+		text = string([]rune(text)[:maxChars])
 	}
 	if s.kokoroURL == "" {
-		http.Error(w, `{"error":"kokoro not configured"}`, http.StatusServiceUnavailable)
+		markFailed("kokoro not configured")
 		return
 	}
 
-	// Call Kokoro POST /v1/audio/speech at speed 1.0.
-	// Kokoro saves the generated audio to its own temp storage and returns the
-	// download path in the X-Download-Path response header.
-	filename, err := s.generateSpeech(r.Context(), text, voice, 1.0)
+	// Call Kokoro.
+	filename, err := s.generateSpeech(ctx, text, voice, 1.0)
 	if err != nil {
-		s.log.Error("kokoro speech generation failed", "slug", slug, "chapter", n, "err", err)
-		http.Error(w, `{"error":"speech generation failed"}`, http.StatusBadGateway)
+		s.log.Error("audio: kokoro speech generation failed", "slug", slug, "chapter", n, "err", err)
+		markFailed(err.Error())
 		return
 	}
 
-	if err := s.store.SetAudioCache(r.Context(), cacheKey, filename); err != nil {
-		s.log.Warn("audio cache write failed", "slug", slug, "chapter", n, "cache_key", cacheKey, "err", err)
+	if err := s.store.SetAudioCache(ctx, cacheKey, filename); err != nil {
+		s.log.Warn("audio: cache write failed", "slug", slug, "chapter", n, "err", err)
 	}
 
-	// Download generated audio from Kokoro and persist to MinIO synchronously
-	// so that the presigned URL returned to the client is immediately valid.
+	// Download from Kokoro and persist to MinIO.
 	minioKey := s.store.AudioObjectKey(slug, n, voice)
-	audioData, dlErr := s.downloadFromKokoro(r.Context(), filename)
+	audioData, dlErr := s.downloadFromKokoro(ctx, filename)
 	if dlErr != nil {
-		s.log.Warn("audio MinIO upload skipped: kokoro download failed",
+		s.log.Warn("audio: MinIO upload skipped: kokoro download failed",
 			"slug", slug, "chapter", n, "filename", filename, "err", dlErr)
-	} else if putErr := s.store.PutAudio(r.Context(), minioKey, audioData); putErr != nil {
-		s.log.Warn("audio MinIO upload failed",
+	} else if putErr := s.store.PutAudio(ctx, minioKey, audioData); putErr != nil {
+		s.log.Warn("audio: MinIO upload failed",
 			"slug", slug, "chapter", n, "key", minioKey, "err", putErr)
-		// upload failure is non-fatal; the client can still stream via Kokoro proxy
 	} else {
-		s.log.Info("audio uploaded to MinIO", "slug", slug, "chapter", n, "key", minioKey)
+		s.log.Info("audio: uploaded to MinIO", "slug", slug, "chapter", n, "key", minioKey)
 	}
 
-	s.log.Info("audio generated", "slug", slug, "chapter", n, "filename", filename)
-	s.writeAudioResponse(w, slug, n, voice, filename)
+	// Mark job done.
+	if jobID != "" {
+		if err := s.store.UpdateAudioJob(ctx, jobID, "done", "", time.Now()); err != nil {
+			s.log.Warn("audio: failed to mark job done", "job_id", jobID, "err", err)
+		}
+	}
+	s.log.Info("audio: generation complete", "slug", slug, "chapter", n, "filename", filename)
+}
+
+// handleAudioStatus handles GET /api/audio/status/{slug}/{n}.
+// Returns the current generation status for the given chapter + voice.
+//
+// Query params: voice (optional, defaults to server default).
+//
+// Possible responses:
+//   - 200 {"status":"done","url":"/api/audio-proxy/..."}    — audio ready
+//   - 200 {"status":"pending"|"generating","job_id":"..."}  — in progress
+//   - 200 {"status":"idle"}                                 — no job yet
+//   - 200 {"status":"failed","error":"..."}                 — last job failed
+func (s *Server) handleAudioStatus(w http.ResponseWriter, r *http.Request) {
+	slug := r.PathValue("slug")
+	n, err := strconv.Atoi(r.PathValue("n"))
+	if err != nil || n < 1 || slug == "" {
+		http.Error(w, `{"error":"invalid params"}`, http.StatusBadRequest)
+		return
+	}
+
+	voice := r.URL.Query().Get("voice")
+	if voice == "" {
+		voice = s.kokoroVoice
+	}
+
+	cacheKey := fmt.Sprintf("%s/%d/%s", slug, n, voice)
+
+	w.Header().Set("Content-Type", "application/json")
+
+	// Fast path: audio already in audio_cache → done.
+	if filename, ok := s.store.GetAudioCache(r.Context(), cacheKey); ok {
+		proxyURL := fmt.Sprintf("/api/audio-proxy/%s/%d?voice=%s", slug, n, voice)
+		_ = json.NewEncoder(w).Encode(map[string]string{
+			"status":   "done",
+			"url":      proxyURL,
+			"filename": filename,
+		})
+		return
+	}
+
+	// Check in-flight map for live job ID.
+	s.audioMu.Lock()
+	liveJobID, inFlight := s.audioJobIDs[cacheKey]
+	s.audioMu.Unlock()
+
+	if inFlight {
+		// Look up persistent record for richer status.
+		if job, ok, _ := s.store.GetAudioJob(r.Context(), cacheKey); ok {
+			_ = json.NewEncoder(w).Encode(map[string]string{
+				"status": job.Status,
+				"job_id": liveJobID,
+			})
+			return
+		}
+		_ = json.NewEncoder(w).Encode(map[string]string{
+			"status": "generating",
+			"job_id": liveJobID,
+		})
+		return
+	}
+
+	// Not in-flight: check persistent record for last known result.
+	job, ok, _ := s.store.GetAudioJob(r.Context(), cacheKey)
+	if !ok {
+		_ = json.NewEncoder(w).Encode(map[string]string{"status": "idle"})
+		return
+	}
+
+	resp := map[string]string{
+		"status": job.Status,
+		"job_id": job.ID,
+	}
+	if job.Status == "failed" && job.ErrorMessage != "" {
+		resp["error"] = job.ErrorMessage
+	}
+	_ = json.NewEncoder(w).Encode(resp)
 }
 
 // generateSpeech calls POST /v1/audio/speech on Kokoro with return_download_link=true
@@ -210,7 +320,7 @@ func (s *Server) downloadFromKokoro(ctx context.Context, filename string) ([]byt
 	return data, nil
 }
 
-// writeAudioResponse writes the JSON response for a generated audio chapter.
+// writeAudioResponse writes the JSON response for an already-cached audio chapter.
 // The URL points to our proxy handler GET /api/audio-proxy/{slug}/{n}.
 func (s *Server) writeAudioResponse(w http.ResponseWriter, slug string, n int, voice string, filename string) {
 	proxyURL := fmt.Sprintf("/api/audio-proxy/%s/%d?voice=%s", slug, n, voice)

scraper/internal/server/handlers_browse.go

@@ -80,7 +80,7 @@ func (s *Server) handleBrowse(w http.ResponseWriter, r *http.Request) {
 	defer cancel()
 
 	// ── Cache-first: try MinIO snapshot (new key layout) ─────────────────
-	cacheKey := s.store.BrowseHTMLKey(novelFireDomain, pageNum)
+	cacheKey := s.store.BrowseFilteredHTMLKey(novelFireDomain, pageNum, sortBy, genre, status)
 	if html, ok, err := s.store.GetBrowsePage(ctx, cacheKey); err == nil && ok && len(html) > 0 {
 		novels, hasNext := parseBrowsePage(strings.NewReader(html))
 		s.log.Debug("browse: served from cache", "key", cacheKey)

scraper/internal/server/integration_test.go

@@ -70,7 +70,7 @@ func newTestStore(t *testing.T) *storage.HybridStore {
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
-	hs, err := storage.NewHybridStore(ctx, pbCfg, minioCfg)
+	hs, err := storage.NewHybridStore(ctx, pbCfg, minioCfg, slog.Default())
 	if err != nil {
 		t.Fatalf("NewHybridStore: %v", err)
 	}

scraper/internal/server/server.go

@@ -11,7 +11,8 @@
 //	GET  /api/presign/chapter/{slug}/{n}  — presigned MinIO URL for chapter markdown
 //	GET  /api/presign/audio/{slug}/{n}    — presigned MinIO URL for chapter audio
 //	GET  /api/chapter-text/{slug}/{n}     — plain text of chapter (markdown stripped)
-//	POST /api/audio/{slug}/{n}            — trigger Kokoro audio generation
+//	POST /api/audio/{slug}/{n}            — trigger Kokoro audio generation (async, returns 202)
+//	GET  /api/audio/status/{slug}/{n}     — poll audio generation job status
 //	GET  /api/audio-proxy/{slug}/{n}      — proxy generated audio from Kokoro
 package server
 
@@ -47,11 +48,11 @@ type Server struct {
 	voiceMu      sync.RWMutex
 	cachedVoices []string // populated on first request from Kokoro /v1/audio/voices
 
-	// audioMu guards audioInFlight only.
+	// audioMu guards audioJobIDs only.
 	// Completed audio filenames are persisted to the Store (PocketBase).
-	// audioInFlight deduplicates concurrent generation requests for the same key.
-	audioMu       sync.Mutex
-	audioInFlight map[string]chan struct{} // cacheKey → closed when done
+	// audioJobIDs deduplicates concurrent generation requests for the same key.
+	audioMu     sync.Mutex
+	audioJobIDs map[string]string // cacheKey → PocketBase job ID (empty string if record creation failed)
 
 	// browseMu guards browseInFlight — keys currently being refreshed
 	// in the background.
@@ -82,7 +83,7 @@ func New(addr string, oCfg orchestrator.Config, novel scraper.NovelScraper, log
 		store:          store,
 		kokoroURL:      kokoroURL,
 		kokoroVoice:    kokoroVoice,
-		audioInFlight:  make(map[string]chan struct{}),
+		audioJobIDs:    make(map[string]string),
 		browseInFlight: make(map[string]struct{}),
 		browseMemCache: make(map[string]browseCacheEntry),
 	}
@@ -177,13 +178,11 @@ func (s *Server) ListenAndServe(ctx context.Context) error {
 	)
 	mux.Handle("POST /api/audio/voice-samples", voiceSampleHandler)
 	// Server-side audio generation via Kokoro /v1/audio/speech.
-	// Generation can take several minutes, so wrap in its own timeout handler.
-	audioGenHandler := http.TimeoutHandler(
-		http.HandlerFunc(s.handleAudioGenerate),
-		10*time.Minute,
-		`{"error":"audio generation timed out"}`,
-	)
-	mux.Handle("POST /api/audio/{slug}/{n}", audioGenHandler)
+	// POST returns 202 immediately and starts a background goroutine;
+	// poll GET /api/audio/status/{slug}/{n} to track progress.
+	mux.HandleFunc("POST /api/audio/{slug}/{n}", s.handleAudioGenerate)
+	// Audio job status polling endpoint.
+	mux.HandleFunc("GET /api/audio/status/{slug}/{n}", s.handleAudioStatus)
 	// Proxy route: fetches the generated file from Kokoro /v1/download/{filename}.
 	mux.HandleFunc("GET /api/audio-proxy/{slug}/{n}", s.handleAudioProxy)
 

scraper/internal/storage/hybrid.go

@@ -330,6 +330,10 @@ func (h *HybridStore) BrowseHTMLKey(domain string, page int) string {
 	return BrowseHTMLKey(domain, page)
 }
 
+func (h *HybridStore) BrowseFilteredHTMLKey(domain string, page int, sort, genre, status string) string {
+	return BrowseFilteredHTMLKey(domain, page, sort, genre, status)
+}
+
 func (h *HybridStore) BrowseCoverKey(domain, slug string) string {
 	return BrowseCoverKey(domain, slug)
 }
@@ -392,6 +396,66 @@ func (h *HybridStore) ListScrapeTasks(ctx context.Context) ([]ScrapeTask, error)
 	return tasks, nil
 }
 
+// ─── Audio jobs ───────────────────────────────────────────────────────────────
+
+func (h *HybridStore) CreateAudioJob(ctx context.Context, slug string, chapter int, voice string) (string, error) {
+	return h.pb.CreateAudioJob(ctx, slug, chapter, voice)
+}
+
+func (h *HybridStore) UpdateAudioJob(ctx context.Context, id, status, errMsg string, finished time.Time) error {
+	return h.pb.UpdateAudioJob(ctx, id, status, errMsg, finished)
+}
+
+func (h *HybridStore) GetAudioJob(ctx context.Context, cacheKey string) (AudioJob, bool, error) {
+	rec, ok, err := h.pb.GetAudioJob(ctx, cacheKey)
+	if err != nil || !ok {
+		return AudioJob{}, ok, err
+	}
+	job := AudioJob{
+		ID:           strVal(rec, "id"),
+		CacheKey:     strVal(rec, "cache_key"),
+		Slug:         strVal(rec, "slug"),
+		Chapter:      int(floatVal(rec, "chapter")),
+		Voice:        strVal(rec, "voice"),
+		Status:       strVal(rec, "status"),
+		ErrorMessage: strVal(rec, "error_message"),
+	}
+	if ts, ok := rec["started"].(string); ok {
+		job.Started, _ = time.Parse(time.RFC3339, ts)
+	}
+	if ts, ok := rec["finished"].(string); ok && ts != "" {
+		job.Finished, _ = time.Parse(time.RFC3339, ts)
+	}
+	return job, true, nil
+}
+
+func (h *HybridStore) ListAudioJobs(ctx context.Context) ([]AudioJob, error) {
+	rows, err := h.pb.ListAudioJobs(ctx)
+	if err != nil {
+		return nil, err
+	}
+	jobs := make([]AudioJob, 0, len(rows))
+	for _, r := range rows {
+		job := AudioJob{
+			ID:           strVal(r, "id"),
+			CacheKey:     strVal(r, "cache_key"),
+			Slug:         strVal(r, "slug"),
+			Chapter:      int(floatVal(r, "chapter")),
+			Voice:        strVal(r, "voice"),
+			Status:       strVal(r, "status"),
+			ErrorMessage: strVal(r, "error_message"),
+		}
+		if ts, ok := r["started"].(string); ok {
+			job.Started, _ = time.Parse(time.RFC3339, ts)
+		}
+		if ts, ok := r["finished"].(string); ok && ts != "" {
+			job.Finished, _ = time.Parse(time.RFC3339, ts)
+		}
+		jobs = append(jobs, job)
+	}
+	return jobs, nil
+}
+
 // ─── helpers ──────────────────────────────────────────────────────────────────
 
 func recToBookMeta(rec map[string]interface{}) scraper.BookMeta {

scraper/internal/storage/minio.go

@@ -223,10 +223,33 @@ func (m *MinioClient) PresignAudio(ctx context.Context, key string, expires time
 
 // BrowseHTMLKey returns the MinIO object key for a SingleFile HTML snapshot.
 // Layout: {domain}/html/page-{n}.html
+// This uses the default (popular/all/all) filter combination.
 func BrowseHTMLKey(domain string, page int) string {
 	return fmt.Sprintf("%s/html/page-%d.html", domain, page)
 }
 
+// BrowseFilteredHTMLKey returns the MinIO object key for a browse page snapshot
+// that includes filter parameters (sort, genre, status) in the key so that
+// different filter combinations are cached independently.
+// Layout: {domain}/html/{sort}-{genre}-{status}/page-{n}.html
+// Falls back to BrowseHTMLKey when all filters are at their default values
+// (sort=popular, genre=all, status=all) for cache compatibility.
+func BrowseFilteredHTMLKey(domain string, page int, sort, genre, status string) string {
+	if (sort == "" || sort == "popular") && (genre == "" || genre == "all") && (status == "" || status == "all") {
+		return BrowseHTMLKey(domain, page)
+	}
+	if sort == "" {
+		sort = "popular"
+	}
+	if genre == "" {
+		genre = "all"
+	}
+	if status == "" {
+		status = "all"
+	}
+	return fmt.Sprintf("%s/html/%s-%s-%s/page-%d.html", domain, sort, genre, status, page)
+}
+
 // BrowseCoverKey returns the MinIO object key for a cached book cover image.
 // Layout: {domain}/assets/book-covers/{slug}.jpg
 func BrowseCoverKey(domain, slug string) string {

scraper/internal/storage/pocketbase.go

@@ -14,6 +14,8 @@
 //	                 books_found(number), chapters_scraped(number),
 //	                 chapters_skipped(number), errors(number),
 //	                 started(date), finished(date), error_message(text)
+//	user_sessions  — user_id(text), session_id(text,unique), user_agent(text),
+//	                 ip(text), created_at(date), last_seen(date)
 package storage
 
 import (
@@ -394,6 +396,32 @@ func (s *PocketBaseStore) EnsureCollections(ctx context.Context) error {
 				{"name": "error_message", "type": "text"},
 			},
 		},
+		{
+			"name": "audio_jobs",
+			"type": "base",
+			"fields": []map[string]interface{}{
+				{"name": "cache_key", "type": "text", "required": true}, // "slug/chapter/voice"
+				{"name": "slug", "type": "text", "required": true},
+				{"name": "chapter", "type": "number"},
+				{"name": "voice", "type": "text"},
+				{"name": "status", "type": "text", "required": true}, // "pending" | "generating" | "done" | "failed"
+				{"name": "error_message", "type": "text"},
+				{"name": "started", "type": "date"},
+				{"name": "finished", "type": "date"},
+			},
+		},
+		{
+			"name": "user_sessions",
+			"type": "base",
+			"fields": []map[string]interface{}{
+				{"name": "user_id", "type": "text", "required": true},
+				{"name": "session_id", "type": "text", "required": true}, // random ID embedded in auth token
+				{"name": "user_agent", "type": "text"},
+				{"name": "ip", "type": "text"},
+				{"name": "created_at", "type": "date"},
+				{"name": "last_seen", "type": "date"},
+			},
+		},
 	}
 	for _, col := range collections {
 		name, _ := col["name"].(string)
@@ -784,6 +812,76 @@ func (s *PocketBaseStore) ListScrapingTasks(ctx context.Context) ([]map[string]i
 	return s.pb.listAll(ctx, "scraping_tasks", "", "-started")
 }
 
+// ─── Audio jobs ───────────────────────────────────────────────────────────────
+
+// CreateAudioJob inserts a new audio_jobs record with status="pending".
+func (s *PocketBaseStore) CreateAudioJob(ctx context.Context, slug string, chapter int, voice string) (string, error) {
+	cacheKey := fmt.Sprintf("%s/%d/%s", slug, chapter, voice)
+	data := map[string]interface{}{
+		"cache_key": cacheKey,
+		"slug":      slug,
+		"chapter":   chapter,
+		"voice":     voice,
+		"status":    "pending",
+		"started":   time.Now().UTC().Format(time.RFC3339),
+	}
+	resp, err := s.pb.do(ctx, http.MethodPost, "/api/collections/audio_jobs/records", data)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	b, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		return "", fmt.Errorf("pocketbase: CreateAudioJob: status %d: %s", resp.StatusCode, b)
+	}
+	var rec map[string]interface{}
+	if err := json.Unmarshal(b, &rec); err != nil {
+		return "", fmt.Errorf("pocketbase: CreateAudioJob: decode: %w", err)
+	}
+	id, _ := rec["id"].(string)
+	return id, nil
+}
+
+// UpdateAudioJob patches status, error_message, and optionally finished on an audio_jobs record.
+func (s *PocketBaseStore) UpdateAudioJob(ctx context.Context, id, status, errMsg string, finished time.Time) error {
+	data := map[string]interface{}{
+		"status":        status,
+		"error_message": errMsg,
+	}
+	if !finished.IsZero() {
+		data["finished"] = finished.UTC().Format(time.RFC3339)
+	}
+	resp, err := s.pb.do(ctx, http.MethodPatch,
+		fmt.Sprintf("/api/collections/audio_jobs/records/%s", id), data)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		b, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("pocketbase: UpdateAudioJob id=%s: status %d: %s", id, resp.StatusCode, b)
+	}
+	return nil
+}
+
+// GetAudioJob returns the most recent audio_jobs record for the given cache key.
+func (s *PocketBaseStore) GetAudioJob(ctx context.Context, cacheKey string) (map[string]interface{}, bool, error) {
+	rec, err := s.pb.listOne(ctx, "audio_jobs",
+		fmt.Sprintf(`cache_key="%s"`, pbEsc(cacheKey)))
+	if err != nil {
+		return nil, false, err
+	}
+	if rec == nil {
+		return nil, false, nil
+	}
+	return rec, true, nil
+}
+
+// ListAudioJobs returns all audio_jobs sorted by started descending.
+func (s *PocketBaseStore) ListAudioJobs(ctx context.Context) ([]map[string]interface{}, error) {
+	return s.pb.listAll(ctx, "audio_jobs", "", "-started")
+}
+
 // ─── helpers ──────────────────────────────────────────────────────────────────
 
 // pbEsc escapes a string for use in a PocketBase filter expression.

scraper/internal/storage/store.go

@@ -30,6 +30,20 @@ type ReadingProgress struct {
 	UpdatedAt time.Time `json:"updated_at"`
 }
 
+// AudioJob represents a single audio-generation job record from the
+// audio_jobs collection.
+type AudioJob struct {
+	ID           string    `json:"id"`
+	CacheKey     string    `json:"cache_key"` // "slug/chapter/voice"
+	Slug         string    `json:"slug"`
+	Chapter      int       `json:"chapter"`
+	Voice        string    `json:"voice"`
+	Status       string    `json:"status"` // "pending" | "generating" | "done" | "failed"
+	ErrorMessage string    `json:"error_message,omitempty"`
+	Started      time.Time `json:"started"`
+	Finished     time.Time `json:"finished,omitempty"`
+}
+
 // ScrapeTask represents a single scraping job record from the scraping_tasks
 // collection.
 type ScrapeTask struct {
@@ -156,6 +170,9 @@ type Store interface {
 	// BrowseHTMLKey returns the MinIO object key for a SingleFile HTML snapshot.
 	// Layout: {domain}/html/page-{n}.html
 	BrowseHTMLKey(domain string, page int) string
+	// BrowseFilteredHTMLKey returns the MinIO object key for a browse page snapshot
+	// that incorporates sort/genre/status so different filter combos are cached separately.
+	BrowseFilteredHTMLKey(domain string, page int, sort, genre, status string) string
 	// BrowseCoverKey returns the MinIO object key for a cached book cover image.
 	// Layout: {domain}/assets/book-covers/{slug}.jpg
 	BrowseCoverKey(domain, slug string) string
@@ -174,4 +191,17 @@ type Store interface {
 	UpdateScrapeTask(ctx context.Context, id string, u ScrapeTaskUpdate) error
 	// ListScrapeTasks returns all tasks sorted by started descending.
 	ListScrapeTasks(ctx context.Context) ([]ScrapeTask, error)
+
+	// ── Audio jobs ─────────────────────────────────────────────────────────
+
+	// CreateAudioJob inserts a new audio_jobs record with status="pending"
+	// and returns the assigned ID.
+	CreateAudioJob(ctx context.Context, slug string, chapter int, voice string) (string, error)
+	// UpdateAudioJob patches an existing audio job record (status, error, finished).
+	UpdateAudioJob(ctx context.Context, id, status, errMsg string, finished time.Time) error
+	// GetAudioJob returns the most recent audio job for the given cache key,
+	// or (zero, false, nil) if none exists.
+	GetAudioJob(ctx context.Context, cacheKey string) (AudioJob, bool, error)
+	// ListAudioJobs returns all audio jobs sorted by started descending.
+	ListAudioJobs(ctx context.Context) ([]AudioJob, error)
 }

scripts/runner-config-mac.yaml

@@ -0,0 +1,39 @@
+log:
+  level: info
+
+runner:
+  file: .runner
+  capacity: 1
+  envs: {}
+  env_file: .env
+  timeout: 3h
+  shutdown_timeout: 0s
+  insecure: false
+  fetch_timeout: 5s
+  fetch_interval: 2s
+  github_mirror: ''
+  labels:
+    - "macos-latest:host"
+    - "macos-14:host"
+
+cache:
+  enabled: true
+  dir: ""
+  host: "__HOST_IP__"
+  port: 8088
+  external_server: ""
+
+container:
+  network: ""
+  privileged: false
+  options: ""
+  workdir_parent: ""
+  valid_volumes: []
+  docker_host: ""
+  force_pull: false
+  force_rebuild: false
+  require_docker: false
+  docker_timeout: 0s
+
+host:
+  workdir_parent: ""

scripts/setup_runner_mac.sh

@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ── setup_runner_mac.sh ───────────────────────────────────────────────────────
+# Sets up act_runner as a host-mode runner on macOS for iOS CI/CD.
+# Installs the binary, generates a config, registers against Gitea,
+# and installs a LaunchDaemon so the runner starts at boot.
+#
+# Usage: sudo ./setup_runner_mac.sh <runner-name>
+# Example: sudo ./setup_runner_mac.sh mac-runner-1
+# ─────────────────────────────────────────────────────────────────────────────
+
+usage() {
+  echo "Usage: sudo $0 <runner-name>"
+  exit 1
+}
+
+[[ $# -ne 1 ]] && usage
+[[ "$EUID" -ne 0 ]] && { echo "ERROR: run with sudo"; exit 1; }
+
+RUNNER_NAME="$1"
+GITEA_URL="https://gitea.kalekber.cc/"
+REGISTRATION_TOKEN="AboxpDKWx7gizwJ9xeheHVqKjj9J9N9BgyX96wvu"
+CACHE_PORT=8088
+INSTALL_DIR="/usr/local/bin"
+WORK_DIR="/var/lib/act_runner"
+CONFIG_PATH="/etc/act_runner/config.yaml"
+LAUNCHDAEMON_PLIST="/Library/LaunchDaemons/com.gitea.act_runner.plist"
+
+# ── detect Mac LAN IP ─────────────────────────────────────────────────────────
+HOST_IP=$(ipconfig getifaddr en0 2>/dev/null || ipconfig getifaddr en1 2>/dev/null || echo "")
+if [[ -z "$HOST_IP" ]]; then
+  echo "ERROR: could not detect LAN IP via en0/en1. Set cache.host manually in $CONFIG_PATH"
+  HOST_IP="127.0.0.1"
+fi
+echo "Host LAN IP: $HOST_IP"
+
+# ── download act_runner binary ────────────────────────────────────────────────
+ARCH=$(uname -m)
+if [[ "$ARCH" == "arm64" ]]; then
+  BINARY_URL="https://gitea.com/gitea/act_runner/releases/download/v0.3.0/act_runner-0.3.0-darwin-arm64"
+else
+  BINARY_URL="https://gitea.com/gitea/act_runner/releases/download/v0.3.0/act_runner-0.3.0-darwin-amd64"
+fi
+
+echo "Downloading act_runner for $ARCH..."
+curl -fsSL "$BINARY_URL" -o "$INSTALL_DIR/act_runner"
+chmod +x "$INSTALL_DIR/act_runner"
+echo "Installed: $("$INSTALL_DIR/act_runner" --version)"
+
+# ── create working directory ──────────────────────────────────────────────────
+mkdir -p "$WORK_DIR"
+mkdir -p "$(dirname "$CONFIG_PATH")"
+
+# ── install config ────────────────────────────────────────────────────────────
+# Use the checked-in static config and substitute the LAN IP placeholder.
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+sed "s/__HOST_IP__/$HOST_IP/" "$SCRIPT_DIR/runner-config-mac.yaml" > "$CONFIG_PATH"
+echo "Config written: labels=macos-latest:host, cache=$HOST_IP:$CACHE_PORT"
+
+# ── register runner ───────────────────────────────────────────────────────────
+echo "Registering runner '$RUNNER_NAME'..."
+"$INSTALL_DIR/act_runner" register \
+  --no-interactive \
+  --config "$CONFIG_PATH" \
+  --instance "$GITEA_URL" \
+  --token "$REGISTRATION_TOKEN" \
+  --name "$RUNNER_NAME" \
+  --labels "macos-latest:host,macos-14:host"
+
+# Copy .runner file to work dir if it was created in cwd
+[[ -f ".runner" ]] && cp .runner "$WORK_DIR/.runner"
+
+# ── install LaunchDaemon ──────────────────────────────────────────────────────
+# PATH must include Homebrew + Xcode tools so xcodebuild, xcrun, npm, etc. are found.
+HOMEBREW_PREFIX=$([ "$ARCH" = "arm64" ] && echo "/opt/homebrew" || echo "/usr/local")
+
+cat > "$LAUNCHDAEMON_PLIST" <<PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.gitea.act_runner</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${INSTALL_DIR}/act_runner</string>
+        <string>daemon</string>
+        <string>--config</string>
+        <string>${CONFIG_PATH}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>WorkingDirectory</key>
+    <string>${WORK_DIR}</string>
+    <key>StandardOutPath</key>
+    <string>${WORK_DIR}/act_runner.log</string>
+    <key>StandardErrorPath</key>
+    <string>${WORK_DIR}/act_runner.err</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${HOMEBREW_PREFIX}/bin:${HOMEBREW_PREFIX}/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Applications/Xcode.app/Contents/Developer/usr/bin</string>
+        <key>HOME</key>
+        <string>${WORK_DIR}</string>
+    </dict>
+</dict>
+</plist>
+PLIST
+
+echo "LaunchDaemon written to $LAUNCHDAEMON_PLIST"
+
+# ── load the daemon ───────────────────────────────────────────────────────────
+launchctl unload "$LAUNCHDAEMON_PLIST" 2>/dev/null || true
+launchctl load "$LAUNCHDAEMON_PLIST"
+echo "Runner '$RUNNER_NAME' started via LaunchDaemon"
+echo ""
+echo "Useful commands:"
+echo "  View logs:    tail -f $WORK_DIR/act_runner.log"
+echo "  Stop runner:  sudo launchctl unload $LAUNCHDAEMON_PLIST"
+echo "  Start runner: sudo launchctl load $LAUNCHDAEMON_PLIST"

ui/src/app.d.ts

@@ -5,10 +5,10 @@ declare global {
 		// interface Error {}
 		interface Locals {
 			sessionId: string;
-			user: { id: string; username: string; role: string } | null;
+			user: { id: string; username: string; role: string; authSessionId: string } | null;
 		}
 		interface PageData {
-			user?: { id: string; username: string; role: string } | null;
+			user?: { id: string; username: string; role: string; authSessionId: string } | null;
 		}
 		// interface PageState {}
 		// interface Platform {}

ui/src/app.html

@@ -3,6 +3,12 @@
 	<head>
 		<meta charset="utf-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<link rel="icon" href="/favicon.ico" sizes="16x16 32x32" />
+		<link rel="icon" type="image/png" href="/favicon-32.png" sizes="32x32" />
+		<link rel="icon" type="image/png" href="/favicon-16.png" sizes="16x16" />
+		<link rel="apple-touch-icon" href="/apple-touch-icon.png" />
+		<link rel="icon" type="image/png" href="/icon-192.png" sizes="192x192" />
+		<link rel="icon" type="image/png" href="/icon-512.png" sizes="512x512" />
 		%sveltekit.head%
 	</head>
 	<body data-sveltekit-preload-data="hover">

ui/src/hooks.server.ts

@@ -2,6 +2,7 @@ import type { Handle } from '@sveltejs/kit';
 import { randomBytes, createHmac } from 'node:crypto';
 import { env } from '$env/dynamic/private';
 import { log } from '$lib/server/logger';
+import { createUserSession, touchUserSession, isSessionRevoked } from '$lib/server/pocketbase';
 
 const SESSION_COOKIE = 'libnovel_session';
 const AUTH_COOKIE = 'libnovel_auth';
@@ -40,27 +41,30 @@ export function verifyToken(token: string): string | null {
 
 /**
  * Create a signed auth token for a user.
- * Payload format: "<userId>:<username>:<role>"
+ * Payload format: "<userId>:<username>:<role>:<authSessionId>"
+ * authSessionId uniquely identifies this login session (for revocation).
  */
-export function createAuthToken(userId: string, username: string, role: string): string {
-	return signToken(`${userId}:${username}:${role}`);
+export function createAuthToken(userId: string, username: string, role: string, authSessionId: string): string {
+	return signToken(`${userId}:${username}:${role}:${authSessionId}`);
 }
 
 /**
  * Parse a verified auth token into user data. Returns null if invalid.
+ * Supports both old format (3 segments) and new format (4 segments).
  */
-export function parseAuthToken(token: string): { id: string; username: string; role: string } | null {
+export function parseAuthToken(token: string): { id: string; username: string; role: string; authSessionId: string } | null {
 	const payload = verifyToken(token);
 	if (!payload) return null;
-	const firstColon = payload.indexOf(':');
-	if (firstColon < 0) return null;
-	const secondColon = payload.indexOf(':', firstColon + 1);
-	if (secondColon < 0) return null;
-	const id = payload.slice(0, firstColon);
-	const username = payload.slice(firstColon + 1, secondColon);
-	const role = payload.slice(secondColon + 1);
+	const parts = payload.split(':');
+	// New format: userId:username:role:authSessionId (4 parts)
+	// Old format: userId:username:role (3 parts — legacy tokens before session tracking)
+	if (parts.length < 3) return null;
+	const id = parts[0];
+	const username = parts[1];
+	const role = parts[2];
+	const authSessionId = parts[3] ?? ''; // empty string for legacy tokens
 	if (!id || !username) return null;
-	return { id, username, role };
+	return { id, username, role, authSessionId };
 }
 
 // ─── Hook ─────────────────────────────────────────────────────────────────────
@@ -85,8 +89,32 @@ export const handle: Handle = async ({ event, resolve }) => {
 		const user = parseAuthToken(authToken);
 		if (!user) {
 			log.warn('auth', 'auth cookie present but failed to parse (malformed or tampered)');
+			event.locals.user = null;
+		} else {
+			// Validate session against DB (only for new-format tokens with authSessionId)
+			let sessionValid = true;
+			if (user.authSessionId) {
+				try {
+					const revoked = await isSessionRevoked(user.authSessionId);
+					if (revoked) {
+						log.info('auth', 'auth cookie references revoked session', {
+							userId: user.id,
+							authSessionId: user.authSessionId
+						});
+						sessionValid = false;
+						// Clear the invalid cookie
+						event.cookies.delete(AUTH_COOKIE, { path: '/' });
+					} else {
+						// Best-effort: update last_seen in the background
+						touchUserSession(user.authSessionId).catch(() => {});
+					}
+				} catch (err) {
+					// DB error — fail open to avoid locking everyone out
+					log.warn('auth', 'session check failed (fail open)', { err: String(err) });
+				}
+			}
+			event.locals.user = sessionValid ? user : null;
 		}
-		event.locals.user = user;
 	} else {
 		event.locals.user = null;
 	}

ui/src/lib/audio.svelte.ts

@@ -44,6 +44,12 @@ class AudioStore {
 	voice = $state('af_bella');
 	speed = $state(1.0);
 
+	/** Cover image URL for the currently loaded book. */
+	cover = $state('');
+
+	/** Full chapter list for the currently loaded book (number + title). */
+	chapters = $state<{ number: number; title: string }[]>([]);
+
 	// ── Loading/generation state ────────────────────────────────────────────
 	status = $state<AudioStatus>('idle');
 	audioUrl = $state('');

ui/src/lib/components/AudioPlayer.svelte

@@ -59,6 +59,8 @@
 		cover?: string;
 		/** Next chapter number, or null/undefined if this is the last chapter. */
 		nextChapter?: number | null;
+		/** Full chapter list for the book (number + title). Written into the store. */
+		chapters?: { number: number; title: string }[];
 		/** List of available voices from the Kokoro API. */
 		voices?: string[];
 	}
@@ -70,6 +72,7 @@
 		bookTitle = '',
 		cover = '',
 		nextChapter = null,
+		chapters = [],
 		voices = []
 	}: Props = $props();
 
@@ -328,6 +331,51 @@
 		return data.url;
 	}
 
+	type AudioStatusResponse =
+		| { status: 'done'; url: string; filename: string }
+		| { status: 'pending' | 'generating'; job_id: string }
+		| { status: 'idle' }
+		| { status: 'failed'; error?: string };
+
+	/**
+	 * Poll GET /api/audio/status/[slug]/[n]?voice=... every `intervalMs` ms
+	 * until status is "done" or "failed" (or the caller cancels via signal).
+	 *
+	 * Returns the final status response, or throws on network error / cancellation.
+	 */
+	async function pollAudioStatus(
+		targetSlug: string,
+		targetChapter: number,
+		targetVoice: string,
+		intervalMs = 2000,
+		signal?: AbortSignal
+	): Promise<AudioStatusResponse> {
+		const qs = new URLSearchParams();
+		if (targetVoice) qs.set('voice', targetVoice);
+		const url = `/api/audio/status/${targetSlug}/${targetChapter}?${qs.toString()}`;
+
+		while (true) {
+			if (signal?.aborted) throw new DOMException('Aborted', 'AbortError');
+
+			const res = await fetch(url, { signal });
+			if (!res.ok) throw new Error(`Status poll HTTP ${res.status}`);
+			const data = (await res.json()) as AudioStatusResponse;
+
+			if (data.status === 'done' || data.status === 'failed') {
+				return data;
+			}
+
+			// Still pending/generating — wait then retry.
+			await new Promise<void>((resolve, reject) => {
+				const timer = setTimeout(resolve, intervalMs);
+				signal?.addEventListener('abort', () => {
+					clearTimeout(timer);
+					reject(new DOMException('Aborted', 'AbortError'));
+				});
+			});
+		}
+	}
+
 	// ── Pre-fetch next chapter ─────────────────────────────────────────────────
 
 	async function prefetchNext() {
@@ -351,7 +399,7 @@
 				return;
 			}
 
-			// Slow path: trigger Kokoro generation in background
+			// Slow path: trigger Kokoro generation (non-blocking POST), then poll.
 			const res = await fetch(`/api/audio/${slug}/${nextChapter}`, {
 				method: 'POST',
 				headers: { 'Content-Type': 'application/json' },
@@ -359,13 +407,31 @@
 			});
 			if (!res.ok) throw new Error(`Prefetch generation failed: HTTP ${res.status}`);
 
+			// If the scraper returned cached audio immediately (200), use the url.
+			if (res.status === 200) {
+				const cached = (await res.json()) as { url: string };
+				stopNextProgress();
+				audioStore.nextProgress = 100;
+				audioStore.nextAudioUrl = cached.url;
+				audioStore.nextStatus = 'prefetched';
+				return;
+			}
+
+			// 202: poll until done.
+			const final = await pollAudioStatus(slug, nextChapter, voice);
 			stopNextProgress();
 			audioStore.nextProgress = 100;
 
-			const url2 = await tryPresign(slug, nextChapter, voice);
-			if (!url2) throw new Error('Prefetch: audio generated but presign returned 404');
+			if (final.status === 'failed') {
+				throw new Error(`Prefetch failed: ${(final as { error?: string }).error ?? 'unknown'}`);
+			}
 
-			audioStore.nextAudioUrl = url2;
+			// Use the URL from the status response, or fall back to presign.
+			const doneUrl =
+				(final as { url?: string }).url ?? (await tryPresign(slug, nextChapter, voice));
+			if (!doneUrl) throw new Error('Prefetch: audio done but no URL available');
+
+			audioStore.nextAudioUrl = doneUrl;
 			audioStore.nextStatus = 'prefetched';
 		} catch {
 			stopNextProgress();
@@ -405,6 +471,8 @@
 		audioStore.chapter = chapter;
 		audioStore.chapterTitle = chapterTitle;
 		audioStore.bookTitle = bookTitle;
+		audioStore.cover = cover;
+		audioStore.chapters = chapters;
 
 		// Update OS media session (lock screen / notification center).
 		setMediaSession();
@@ -442,7 +510,7 @@
 				return;
 			}
 
-			// Slow path: trigger Kokoro generation.
+			// Slow path: trigger Kokoro generation (non-blocking POST), then poll.
 			audioStore.status = 'generating';
 			startProgress();
 
@@ -453,11 +521,32 @@
 			});
 			if (!res.ok) throw new Error(`Generation failed: HTTP ${res.status}`);
 
+			// If the scraper returned cached audio immediately (200), use the url.
+			if (res.status === 200) {
+				const cached = (await res.json()) as { url: string };
+				await finishProgress();
+				audioStore.audioUrl = cached.url;
+				audioStore.status = 'ready';
+				maybeStartPrefetch();
+				return;
+			}
+
+			// 202: poll until done.
+			const final = await pollAudioStatus(slug, chapter, voice);
+
+			if (final.status === 'failed') {
+				throw new Error(
+					`Generation failed: ${(final as { error?: string }).error ?? 'unknown error'}`
+				);
+			}
+
 			await finishProgress();
 
-			const url2 = await tryPresign(slug, chapter, voice);
-			if (!url2) throw new Error('Audio generated but presign returned 404');
-			audioStore.audioUrl = url2;
+			// Use the URL from the status response, or fall back to presign.
+			const doneUrl =
+				(final as { url?: string }).url ?? (await tryPresign(slug, chapter, voice));
+			if (!doneUrl) throw new Error('Audio generated but no URL available');
+			audioStore.audioUrl = doneUrl;
 			audioStore.status = 'ready';
 			// Don't restore time for freshly generated audio — position is 0
 			// Immediately start pre-generating the next chapter in background.

ui/src/lib/server/pocketbase.ts

@@ -657,6 +657,24 @@ export async function listScrapingTasks(): Promise<ScrapingTask[]> {
 	return listAll<ScrapingTask>('scraping_tasks', '', '-started');
 }
 
+// ─── Audio jobs ───────────────────────────────────────────────────────────────
+
+export interface AudioJob {
+	id: string;
+	cache_key: string; // "slug/chapter/voice"
+	slug: string;
+	chapter: number;
+	voice: string;
+	status: string; // "pending" | "generating" | "done" | "failed"
+	error_message: string;
+	started: string;
+	finished: string;
+}
+
+export async function listAudioJobs(): Promise<AudioJob[]> {
+	return listAll<AudioJob>('audio_jobs', '', '-started');
+}
+
 export async function getAudioTime(
 	sessionId: string,
 	slug: string,
@@ -667,3 +685,112 @@ export async function getAudioTime(
 	if (!row || !row.audio_time) return null;
 	return row.audio_time;
 }
+
+// ─── User sessions ────────────────────────────────────────────────────────────
+
+export interface UserSession {
+	id: string;
+	user_id: string;
+	session_id: string; // the auth session ID embedded in the token
+	user_agent: string;
+	ip: string;
+	created_at: string;
+	last_seen: string;
+}
+
+/**
+ * Create a new session record on login. Returns the record ID.
+ */
+export async function createUserSession(
+	userId: string,
+	authSessionId: string,
+	userAgent: string,
+	ip: string
+): Promise<string> {
+	const now = new Date().toISOString();
+	const res = await pbPost('/api/collections/user_sessions/records', {
+		user_id: userId,
+		session_id: authSessionId,
+		user_agent: userAgent,
+		ip,
+		created_at: now,
+		last_seen: now
+	});
+	if (!res.ok) {
+		const body = await res.text().catch(() => '');
+		log.error('pocketbase', 'createUserSession POST failed', { userId, status: res.status, body });
+		throw new Error(`Failed to create session: ${res.status}`);
+	}
+	const rec = (await res.json()) as { id: string };
+	return rec.id;
+}
+
+/**
+ * Update last_seen on a session (best-effort, non-fatal if it fails).
+ */
+export async function touchUserSession(authSessionId: string): Promise<void> {
+	const row = await listOne<UserSession & { id: string }>(
+		'user_sessions',
+		`session_id="${authSessionId}"`
+	);
+	if (!row) return;
+	const token = await getToken();
+	await fetch(`${PB_URL}/api/collections/user_sessions/records/${row.id}`, {
+		method: 'PATCH',
+		headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+		body: JSON.stringify({ last_seen: new Date().toISOString() })
+	});
+}
+
+/**
+ * Check whether a session has been revoked (i.e., not present in DB).
+ * Returns true if revoked/missing, false if valid.
+ */
+export async function isSessionRevoked(authSessionId: string): Promise<boolean> {
+	const row = await listOne<UserSession>('user_sessions', `session_id="${authSessionId}"`);
+	return row === null;
+}
+
+/**
+ * List all active sessions for a user.
+ */
+export async function listUserSessions(userId: string): Promise<UserSession[]> {
+	return listAll<UserSession>('user_sessions', `user_id="${userId}"`, '-last_seen');
+}
+
+/**
+ * Revoke (delete) a specific session by its PocketBase record ID.
+ * Only allows deletion if the session belongs to the given userId.
+ */
+export async function revokeUserSession(recordId: string, userId: string): Promise<boolean> {
+	// Verify ownership before deleting
+	const token = await getToken();
+	const res = await fetch(`${PB_URL}/api/collections/user_sessions/records/${recordId}`, {
+		headers: { Authorization: `Bearer ${token}` }
+	});
+	if (!res.ok) return false;
+	const rec = (await res.json()) as UserSession;
+	if (rec.user_id !== userId) return false;
+
+	const del = await fetch(`${PB_URL}/api/collections/user_sessions/records/${recordId}`, {
+		method: 'DELETE',
+		headers: { Authorization: `Bearer ${token}` }
+	});
+	return del.ok || del.status === 204;
+}
+
+/**
+ * Revoke all sessions for a user (used on password change etc).
+ */
+export async function revokeAllUserSessions(userId: string): Promise<void> {
+	const sessions = await listUserSessions(userId);
+	const token = await getToken();
+	await Promise.all(
+		sessions.map((s) =>
+			fetch(`${PB_URL}/api/collections/user_sessions/records/${s.id}`, {
+				method: 'DELETE',
+				headers: { Authorization: `Bearer ${token}` }
+			}).catch(() => {})
+		)
+	);
+}

ui/src/routes/+layout.svelte

@@ -11,6 +11,9 @@
 	// Mobile nav drawer state
 	let menuOpen = $state(false);
 
+	// Chapter list drawer state for the mini-player
+	let chapterDrawerOpen = $state(false);
+
 	// The single <audio> element that persists across navigations.
 	// AudioPlayer components in chapter pages control it via audioStore.
 	let audioEl = $state<HTMLAudioElement | null>(null);
@@ -208,10 +211,16 @@
 	{/if}
 	<header class="border-b border-zinc-700 bg-zinc-900 sticky top-0 z-50">
 		<nav class="max-w-6xl mx-auto px-4 h-14 flex items-center gap-6">
-			<a href="/" class="text-amber-400 font-bold text-lg tracking-tight hover:text-amber-300">
+			<a href="/" class="text-amber-400 font-bold text-lg tracking-tight hover:text-amber-300 shrink-0">
 				libnovel
 			</a>
 
+			{#if page.data.book?.title && /\/books\/[^/]+\/chapters\//.test(page.url.pathname)}
+				<span class="text-zinc-400 text-sm truncate min-w-0 flex-1 sm:flex-none sm:max-w-xs">
+					{page.data.book.title}
+				</span>
+			{/if}
+
 			{#if data.user}
 				<!-- Desktop nav links (hidden on mobile) -->
 				<a
@@ -238,10 +247,16 @@
 						</a>
 						<a
 							href="/admin/audio"
-							class="hidden sm:block text-sm transition-colors {page.url.pathname.startsWith('/admin/audio') ? 'text-zinc-100 font-medium' : 'text-zinc-400 hover:text-zinc-100'}"
+							class="hidden sm:block text-sm transition-colors {page.url.pathname === '/admin/audio' ? 'text-zinc-100 font-medium' : 'text-zinc-400 hover:text-zinc-100'}"
 						>
 							Audio cache
 						</a>
+						<a
+							href="/admin/audio-jobs"
+							class="hidden sm:block text-sm transition-colors {page.url.pathname.startsWith('/admin/audio-jobs') ? 'text-zinc-100 font-medium' : 'text-zinc-400 hover:text-zinc-100'}"
+						>
+							Audio jobs
+						</a>
 					{/if}
 					<a
 						href="/profile"
@@ -324,10 +339,17 @@
 					<a
 						href="/admin/audio"
 						onclick={() => (menuOpen = false)}
-						class="px-3 py-2.5 rounded-lg text-sm font-medium transition-colors {page.url.pathname.startsWith('/admin/audio') ? 'bg-zinc-800 text-zinc-100' : 'text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100'}"
+						class="px-3 py-2.5 rounded-lg text-sm font-medium transition-colors {page.url.pathname === '/admin/audio' ? 'bg-zinc-800 text-zinc-100' : 'text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100'}"
 					>
 						Audio cache
 					</a>
+					<a
+						href="/admin/audio-jobs"
+						onclick={() => (menuOpen = false)}
+						class="px-3 py-2.5 rounded-lg text-sm font-medium transition-colors {page.url.pathname.startsWith('/admin/audio-jobs') ? 'bg-zinc-800 text-zinc-100' : 'text-zinc-400 hover:bg-zinc-800 hover:text-zinc-100'}"
+					>
+						Audio jobs
+					</a>
 				{/if}
 				<div class="my-1 border-t border-zinc-700/60"></div>
 				<form method="POST" action="/logout">
@@ -349,9 +371,9 @@
 	</main>
 
 	<footer class="border-t border-zinc-800 mt-auto">
-		<div class="max-w-6xl mx-auto px-4 py-5 flex flex-col sm:flex-row items-center justify-between gap-3">
-			<span class="text-zinc-500 text-sm font-semibold tracking-tight">libnovel</span>
-			<nav class="flex items-center gap-5 text-xs text-zinc-600">
+		<div class="max-w-6xl mx-auto px-4 py-6 flex flex-col items-center gap-4 text-xs text-zinc-600">
+			<!-- Top row: site links -->
+			<nav class="flex flex-wrap items-center justify-center gap-x-5 gap-y-2">
 				<a href="/books" class="hover:text-zinc-400 transition-colors">Library</a>
 				<a href="/browse" class="hover:text-zinc-400 transition-colors">Discover</a>
 				<a
@@ -367,6 +389,13 @@
 					</svg>
 				</a>
 			</nav>
+			<!-- Bottom row: legal links + copyright -->
+			<div class="flex flex-wrap items-center justify-center gap-x-5 gap-y-2 text-zinc-700">
+				<a href="/disclaimer" class="hover:text-zinc-500 transition-colors">Disclaimer</a>
+				<a href="/privacy" class="hover:text-zinc-500 transition-colors">Privacy</a>
+				<a href="/dmca" class="hover:text-zinc-500 transition-colors">DMCA</a>
+				<span>&copy; {new Date().getFullYear()} libnovel</span>
+			</div>
 		</div>
 	</footer>
 </div>
@@ -375,6 +404,45 @@
 {#if audioStore.active}
 	<div class="fixed bottom-0 left-0 right-0 z-50 bg-zinc-900 border-t border-zinc-700 shadow-2xl">
 
+		<!-- Chapter list drawer (slides up above the mini-bar) -->
+		{#if chapterDrawerOpen && audioStore.chapters.length > 0}
+			<div class="border-b border-zinc-700 bg-zinc-900 max-h-[32rem] overflow-y-auto">
+				<div class="max-w-6xl mx-auto px-4">
+					<div class="flex items-center justify-between py-2 border-b border-zinc-800 sticky top-0 bg-zinc-900">
+						<span class="text-xs font-semibold text-zinc-400 uppercase tracking-wider">Chapters</span>
+						<button
+							onclick={() => (chapterDrawerOpen = false)}
+							class="text-zinc-600 hover:text-zinc-300 transition-colors p-1"
+							aria-label="Close chapter list"
+						>
+							<svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+								<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"/>
+							</svg>
+						</button>
+					</div>
+					{#each audioStore.chapters as ch (ch.number)}
+						<a
+							href="/books/{audioStore.slug}/chapters/{ch.number}"
+							onclick={() => (chapterDrawerOpen = false)}
+							class="flex items-center gap-2 py-2 text-xs transition-colors hover:text-zinc-100 {ch.number === audioStore.chapter
+								? 'text-amber-400 font-semibold'
+								: 'text-zinc-400'}"
+						>
+							<span class="tabular-nums text-zinc-600 w-8 shrink-0 text-right">
+								{ch.number}
+							</span>
+							<span class="truncate">{ch.title || `Chapter ${ch.number}`}</span>
+							{#if ch.number === audioStore.chapter}
+								<svg class="w-3 h-3 shrink-0 text-amber-400" fill="currentColor" viewBox="0 0 24 24">
+									<path d="M8 5v14l11-7z"/>
+								</svg>
+							{/if}
+						</a>
+					{/each}
+				</div>
+			</div>
+		{/if}
+
 		<!-- Generation progress bar (sits at very top of the bar) -->
 		{#if audioStore.status === 'generating' || audioStore.status === 'loading'}
 			<div class="h-0.5 bg-zinc-800">
@@ -400,8 +468,13 @@
 
 		<div class="max-w-6xl mx-auto px-4 py-2 flex items-center gap-3">
 
-			<!-- Track info -->
-			<div class="flex-1 min-w-0">
+		<!-- Track info (click to open chapter list drawer) -->
+			<button
+				class="flex-1 min-w-0 text-left rounded px-1 -ml-1 hover:bg-zinc-800 transition-colors"
+				onclick={() => { if (audioStore.chapters.length > 0) chapterDrawerOpen = !chapterDrawerOpen; }}
+				aria-label={audioStore.chapters.length > 0 ? 'Toggle chapter list' : undefined}
+				title={audioStore.chapters.length > 0 ? 'Chapter list' : undefined}
+			>
 				{#if audioStore.chapterTitle}
 					<p class="text-xs text-zinc-100 truncate leading-tight">{audioStore.chapterTitle}</p>
 				{/if}
@@ -419,7 +492,7 @@
 				{:else if audioStore.status === 'loading'}
 					<p class="text-xs text-zinc-500 leading-tight">Loading…</p>
 				{/if}
-			</div>
+			</button>
 
 			{#if audioStore.status === 'ready'}
 				<!-- Skip back 15s -->
@@ -510,17 +583,28 @@
 				</svg>
 			{/if}
 
-			<!-- Go to chapter link (only when we know which chapter is playing) -->
+			<!-- Cover thumbnail / go-to-chapter link -->
 			{#if audioStore.slug && audioStore.chapter > 0}
 				<a
 					href="/books/{audioStore.slug}/chapters/{audioStore.chapter}"
-					class="text-zinc-400 hover:text-zinc-100 transition-colors p-1.5 rounded flex-shrink-0"
+					class="shrink-0 rounded overflow-hidden hover:opacity-80 transition-opacity"
 					title="Go to chapter"
 					aria-label="Go to chapter"
 				>
-					<svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-						<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 7l5 5m0 0l-5 5m5-5H6"/>
-					</svg>
+					{#if audioStore.cover}
+						<img
+							src={audioStore.cover}
+							alt=""
+							class="w-8 h-11 object-cover rounded"
+						/>
+					{:else}
+						<!-- Fallback book icon -->
+						<div class="w-8 h-11 flex items-center justify-center bg-zinc-800 rounded border border-zinc-700">
+							<svg class="w-4 h-4 text-zinc-500" fill="currentColor" viewBox="0 0 24 24">
+								<path d="M18 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm-2 14H8v-2h8v2zm0-4H8v-2h8v2zm0-4H8V6h8v2z"/>
+							</svg>
+						</div>
+					{/if}
 				</a>
 			{/if}
 

ui/src/routes/admin/audio-jobs/+page.server.ts

@@ -0,0 +1,17 @@
+import { redirect } from '@sveltejs/kit';
+import type { PageServerLoad } from './$types';
+import { listAudioJobs } from '$lib/server/pocketbase';
+import { log } from '$lib/server/logger';
+
+export const load: PageServerLoad = async ({ locals }) => {
+	if (locals.user?.role !== 'admin') {
+		redirect(302, '/');
+	}
+
+	const jobs = await listAudioJobs().catch((e) => {
+		log.warn('admin/audio-jobs', 'failed to load audio jobs', { err: String(e) });
+		return [];
+	});
+
+	return { jobs };
+};

ui/src/routes/admin/audio-jobs/+page.svelte

@@ -0,0 +1,152 @@
+<script lang="ts">
+	import type { PageData } from './$types';
+
+	let { data }: { data: PageData } = $props();
+
+	let jobs = $state(data.jobs);
+
+	// ── Live-poll: refresh while any job is in-flight ────────────────────────────
+	let hasInFlight = $derived(jobs.some((j) => j.status === 'pending' || j.status === 'generating'));
+
+	$effect(() => {
+		if (!hasInFlight) return;
+		const id = setInterval(async () => {
+			const res = await fetch('/admin/audio-jobs?__data=1').catch(() => null);
+			if (res?.ok) {
+				// SvelteKit invalidateAll is cleaner — just trigger a soft navigation reload.
+				import('$app/navigation').then(({ invalidateAll }) => invalidateAll());
+			}
+		}, 3000);
+		return () => clearInterval(id);
+	});
+
+	// Keep local state in sync when server re-loads
+	$effect(() => {
+		jobs = data.jobs;
+	});
+
+	// ── Helpers ──────────────────────────────────────────────────────────────────
+	function statusColor(status: string) {
+		if (status === 'done') return 'text-green-400';
+		if (status === 'generating') return 'text-amber-400 animate-pulse';
+		if (status === 'pending') return 'text-sky-400 animate-pulse';
+		if (status === 'failed') return 'text-red-400';
+		return 'text-zinc-300';
+	}
+
+	function fmtDate(s: string) {
+		if (!s) return '—';
+		return new Date(s).toLocaleString(undefined, {
+			month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit'
+		});
+	}
+
+	function duration(started: string, finished: string) {
+		if (!started || !finished) return '—';
+		const ms = new Date(finished).getTime() - new Date(started).getTime();
+		if (ms < 0) return '—';
+		const s = Math.floor(ms / 1000);
+		if (s < 60) return `${s}s`;
+		const m = Math.floor(s / 60);
+		return `${m}m ${s % 60}s`;
+	}
+
+	// ── Search ───────────────────────────────────────────────────────────────────
+	let q = $state('');
+	let filtered = $derived(
+		q.trim()
+			? jobs.filter(
+					(j) =>
+						j.slug.toLowerCase().includes(q.toLowerCase().trim()) ||
+						j.voice.toLowerCase().includes(q.toLowerCase().trim()) ||
+						j.status.toLowerCase().includes(q.toLowerCase().trim())
+				)
+			: jobs
+	);
+
+	// ── Stats ────────────────────────────────────────────────────────────────────
+	let stats = $derived({
+		total: jobs.length,
+		done: jobs.filter((j) => j.status === 'done').length,
+		failed: jobs.filter((j) => j.status === 'failed').length,
+		inFlight: jobs.filter((j) => j.status === 'pending' || j.status === 'generating').length
+	});
+</script>
+
+<svelte:head>
+	<title>Audio jobs — libnovel admin</title>
+</svelte:head>
+
+<div class="space-y-6">
+	<div class="flex items-start justify-between flex-wrap gap-3">
+		<div>
+			<h1 class="text-2xl font-bold text-zinc-100">Audio jobs</h1>
+			<p class="text-zinc-400 text-sm mt-1">
+				{stats.total} total &middot;
+				<span class="text-green-400">{stats.done} done</span> &middot;
+				{#if stats.failed > 0}
+					<span class="text-red-400">{stats.failed} failed</span> &middot;
+				{/if}
+				{#if stats.inFlight > 0}
+					<span class="text-amber-400 animate-pulse">{stats.inFlight} in-flight</span>
+				{:else}
+					<span class="text-zinc-500">0 in-flight</span>
+				{/if}
+			</p>
+		</div>
+	</div>
+
+	<!-- Search -->
+	<input
+		type="search"
+		bind:value={q}
+		placeholder="Filter by slug, voice or status…"
+		class="w-full max-w-sm bg-zinc-800 border border-zinc-700 rounded-lg px-3 py-2 text-zinc-100 text-sm placeholder-zinc-500 focus:outline-none focus:ring-2 focus:ring-amber-400"
+	/>
+
+	{#if filtered.length === 0}
+		<p class="text-zinc-500 text-sm py-8 text-center">
+			{q.trim() ? 'No results.' : 'No audio jobs yet.'}
+		</p>
+	{:else}
+		<div class="overflow-x-auto rounded-xl border border-zinc-700">
+			<table class="w-full text-sm">
+				<thead class="bg-zinc-800 text-zinc-400 text-xs uppercase tracking-wide">
+					<tr>
+						<th class="px-4 py-3 text-left">Book</th>
+						<th class="px-4 py-3 text-right">Ch.</th>
+						<th class="px-4 py-3 text-left">Voice</th>
+						<th class="px-4 py-3 text-left">Status</th>
+						<th class="px-4 py-3 text-left">Started</th>
+						<th class="px-4 py-3 text-left">Duration</th>
+					</tr>
+				</thead>
+				<tbody class="divide-y divide-zinc-700/50">
+					{#each filtered as job}
+						<tr class="bg-zinc-900 hover:bg-zinc-800/50 transition-colors">
+							<td class="px-4 py-3 text-zinc-200 font-medium">
+								<a href="/books/{job.slug}" class="hover:text-amber-400 transition-colors">
+									{job.slug}
+								</a>
+							</td>
+							<td class="px-4 py-3 text-right text-zinc-400">{job.chapter}</td>
+							<td class="px-4 py-3 text-zinc-400 font-mono text-xs">{job.voice}</td>
+							<td class="px-4 py-3">
+								<span class="font-medium {statusColor(job.status)}">{job.status}</span>
+							</td>
+							<td class="px-4 py-3 text-zinc-400">{fmtDate(job.started)}</td>
+							<td class="px-4 py-3 text-zinc-400">{duration(job.started, job.finished)}</td>
+						</tr>
+						{#if job.error_message}
+							<tr class="bg-red-950/20">
+								<td colspan="6" class="px-4 py-2 text-xs text-red-400 font-mono"
+									>{job.error_message}</td
+								>
+							</tr>
+						{/if}
+					{/each}
+				</tbody>
+			</table>
+		</div>
+	{/if}
+</div>

ui/src/routes/api/audio/[slug]/[n]/+server.ts

@@ -11,8 +11,12 @@ const SCRAPER_URL = env.SCRAPER_API_URL ?? 'http://localhost:8080';
  * Keeps the scraper URL server-side — the browser never needs to know it.
  *
  * Body: { voice?: string }
- * Response: { url: string, filename: string }
- *   where `url` is a relative path to GET /api/audio/[slug]/[n]?voice=...
+ *
+ * Responses:
+ *   200 { url: string, filename: string }  — audio already cached; url is a
+ *       relative path to GET /api/audio/[slug]/[n]?voice=...
+ *   202 { job_id: string, status: "pending"|"generating" }  — generation
+ *       enqueued; poll GET /api/audio/status/[slug]/[n]?voice=... until done.
  */
 export const POST: RequestHandler = async ({ params, request }) => {
 	const { slug, n } = params;
@@ -40,18 +44,28 @@ export const POST: RequestHandler = async ({ params, request }) => {
 		error(scraperRes.status as Parameters<typeof error>[0], text || 'Audio generation failed');
 	}
 
-	const data = (await scraperRes.json()) as { url: string; filename: string };
+	const data = (await scraperRes.json()) as
+		| { url: string; filename: string }
+		| { job_id: string; status: string };
 
-	// The scraper returns a proxy URL pointing to /api/audio-proxy/... — we rewrite
-	// it to our own /api/audio/[slug]/[n]?... so the browser never calls the scraper directly.
 	const voice = body.voice ?? '';
 	const qs = new URLSearchParams();
 	if (voice) qs.set('voice', voice);
 
+	// 202 Accepted: generation enqueued — return job_id + status for polling.
+	if (scraperRes.status === 202 || 'job_id' in data) {
+		return new Response(JSON.stringify(data), {
+			status: 202,
+			headers: { 'Content-Type': 'application/json' }
+		});
+	}
+
+	// 200: audio was already cached — rewrite the proxy URL through our own handler.
+	const cached = data as { url: string; filename: string };
 	return new Response(
 		JSON.stringify({
 			url: `/api/audio/${slug}/${chapter}?${qs.toString()}`,
-			filename: data.filename
+			filename: cached.filename
 		}),
 		{ headers: { 'Content-Type': 'application/json' } }
 	);

ui/src/routes/api/audio/status/[slug]/[n]/+server.ts

@@ -0,0 +1,67 @@
+import { error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { env } from '$env/dynamic/private';
+import { log } from '$lib/server/logger';
+
+const SCRAPER_URL = env.SCRAPER_API_URL ?? 'http://localhost:8080';
+
+/**
+ * GET /api/audio/status/[slug]/[n]?voice=...
+ * Proxies the audio generation status check to the scraper's
+ * GET /api/audio/status/{slug}/{n} endpoint.
+ *
+ * Possible responses from scraper (passed through as-is):
+ *   {"status":"done","url":"/api/audio-proxy/...","filename":"..."}
+ *   {"status":"pending"|"generating","job_id":"..."}
+ *   {"status":"idle"}
+ *   {"status":"failed","error":"..."}
+ *
+ * When status is "done" the scraper returns a proxy URL pointing to its own
+ * /api/audio-proxy/... — we rewrite this to our own
+ * /api/audio/[slug]/[n]?voice=... so the browser never calls the scraper.
+ */
+export const GET: RequestHandler = async ({ params, url }) => {
+	const { slug, n } = params;
+	const chapter = parseInt(n, 10);
+	if (!slug || !chapter || chapter < 1) {
+		error(400, 'Invalid slug or chapter number');
+	}
+
+	const voice = url.searchParams.get('voice') ?? '';
+	const qs = new URLSearchParams();
+	if (voice) qs.set('voice', voice);
+
+	const scraperRes = await fetch(
+		`${SCRAPER_URL}/api/audio/status/${slug}/${chapter}?${qs.toString()}`
+	);
+
+	if (!scraperRes.ok) {
+		const text = await scraperRes.text().catch(() => '');
+		log.error('audio', 'scraper audio status check failed', {
+			slug,
+			chapter,
+			status: scraperRes.status,
+			body: text
+		});
+		error(scraperRes.status as Parameters<typeof error>[0], text || 'Status check failed');
+	}
+
+	const data = (await scraperRes.json()) as {
+		status: string;
+		job_id?: string;
+		url?: string;
+		filename?: string;
+		error?: string;
+	};
+
+	// Rewrite the proxy URL if the audio is done so it routes through us.
+	if (data.status === 'done' && data.url) {
+		const rewrittenQs = new URLSearchParams();
+		if (voice) rewrittenQs.set('voice', voice);
+		data.url = `/api/audio/${slug}/${chapter}?${rewrittenQs.toString()}`;
+	}
+
+	return new Response(JSON.stringify(data), {
+		headers: { 'Content-Type': 'application/json' }
+	});
+};

ui/src/routes/api/auth/change-password/+server.ts

@@ -0,0 +1,47 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { changePassword } from '$lib/server/pocketbase';
+import { log } from '$lib/server/logger';
+
+/**
+ * POST /api/auth/change-password
+ * Body: { currentPassword: string, newPassword: string }
+ * Requires authentication.
+ */
+export const POST: RequestHandler = async ({ request, locals }) => {
+	if (!locals.user) {
+		error(401, 'Not authenticated');
+	}
+
+	let body: { currentPassword?: string; newPassword?: string };
+	try {
+		body = await request.json();
+	} catch {
+		error(400, 'Invalid JSON body');
+	}
+
+	const currentPassword = body.currentPassword ?? '';
+	const newPassword = body.newPassword ?? '';
+
+	if (!currentPassword || !newPassword) {
+		error(400, 'currentPassword and newPassword are required');
+	}
+
+	if (newPassword.length < 4) {
+		error(400, 'New password must be at least 4 characters');
+	}
+
+	try {
+		const ok = await changePassword(locals.user.id, currentPassword, newPassword);
+		if (!ok) {
+			error(401, 'Current password is incorrect');
+		}
+	} catch (e: unknown) {
+		// Re-throw SvelteKit errors as-is
+		if (e && typeof e === 'object' && 'status' in e) throw e;
+		log.error('api/auth/change-password', 'unexpected error', { err: String(e) });
+		error(500, 'An error occurred. Please try again.');
+	}
+
+	return json({ ok: true });
+};

ui/src/routes/api/auth/login/+server.ts

@@ -0,0 +1,75 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { loginUser, mergeSessionProgress, createUserSession } from '$lib/server/pocketbase';
+import { createAuthToken } from '../../../../hooks.server';
+import { log } from '$lib/server/logger';
+import { randomBytes } from 'node:crypto';
+
+const AUTH_COOKIE = 'libnovel_auth';
+const ONE_YEAR = 60 * 60 * 24 * 365;
+
+/**
+ * POST /api/auth/login
+ * Body: { username: string, password: string }
+ * Returns: { token: string, user: { id, username, role } }
+ *
+ * Sets the libnovel_auth cookie and returns the raw token value so the
+ * iOS app can persist it for subsequent requests.
+ */
+export const POST: RequestHandler = async ({ request, cookies, locals }) => {
+	let body: { username?: string; password?: string };
+	try {
+		body = await request.json();
+	} catch {
+		error(400, 'Invalid JSON body');
+	}
+
+	const username = (body.username ?? '').trim();
+	const password = body.password ?? '';
+
+	if (!username || !password) {
+		error(400, 'Username and password are required');
+	}
+
+	let user;
+	try {
+		user = await loginUser(username, password);
+	} catch (e) {
+		log.error('api/auth/login', 'unexpected error', { username, err: String(e) });
+		error(500, 'An error occurred. Please try again.');
+	}
+
+	if (!user) {
+		error(401, 'Invalid username or password');
+	}
+
+	// Merge anonymous session progress (non-fatal)
+	mergeSessionProgress(locals.sessionId, user.id).catch((e) =>
+		log.warn('api/auth/login', 'mergeSessionProgress failed (non-fatal)', { err: String(e) })
+	);
+
+	const authSessionId = randomBytes(16).toString('hex');
+
+	const userAgent = request.headers.get('user-agent') ?? '';
+	const ip =
+		request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() ??
+		request.headers.get('x-real-ip') ??
+		'';
+	createUserSession(user.id, authSessionId, userAgent, ip).catch((e) =>
+		log.warn('api/auth/login', 'createUserSession failed (non-fatal)', { err: String(e) })
+	);
+
+	const token = createAuthToken(user.id, user.username, user.role ?? 'user', authSessionId);
+
+	cookies.set(AUTH_COOKIE, token, {
+		path: '/',
+		httpOnly: true,
+		sameSite: 'lax',
+		maxAge: ONE_YEAR
+	});
+
+	return json({
+		token,
+		user: { id: user.id, username: user.username, role: user.role ?? 'user' }
+	});
+};

ui/src/routes/api/auth/logout/+server.ts

@@ -0,0 +1,15 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+
+const AUTH_COOKIE = 'libnovel_auth';
+
+/**
+ * POST /api/auth/logout
+ * Clears the auth cookie and returns { ok: true }.
+ * Does not revoke the session record from PocketBase —
+ * for full revocation use DELETE /api/sessions/[id] first.
+ */
+export const POST: RequestHandler = async ({ cookies }) => {
+	cookies.delete(AUTH_COOKIE, { path: '/' });
+	return json({ ok: true });
+};

ui/src/routes/api/auth/me/+server.ts

@@ -0,0 +1,18 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+
+/**
+ * GET /api/auth/me
+ * Returns the currently authenticated user from the request's auth cookie.
+ * Returns 401 if not authenticated.
+ */
+export const GET: RequestHandler = async ({ locals }) => {
+	if (!locals.user) {
+		error(401, 'Not authenticated');
+	}
+	return json({
+		id: locals.user.id,
+		username: locals.user.username,
+		role: locals.user.role
+	});
+};

ui/src/routes/api/auth/register/+server.ts

@@ -0,0 +1,84 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { createUser, mergeSessionProgress, createUserSession } from '$lib/server/pocketbase';
+import { createAuthToken } from '../../../../hooks.server';
+import { log } from '$lib/server/logger';
+import { randomBytes } from 'node:crypto';
+
+const AUTH_COOKIE = 'libnovel_auth';
+const ONE_YEAR = 60 * 60 * 24 * 365;
+
+/**
+ * POST /api/auth/register
+ * Body: { username: string, password: string }
+ * Returns: { token: string, user: { id, username, role } }
+ *
+ * Sets the libnovel_auth cookie and returns the raw token value so the
+ * iOS app can persist it for subsequent requests.
+ */
+export const POST: RequestHandler = async ({ request, cookies, locals }) => {
+	let body: { username?: string; password?: string };
+	try {
+		body = await request.json();
+	} catch {
+		error(400, 'Invalid JSON body');
+	}
+
+	const username = (body.username ?? '').trim();
+	const password = body.password ?? '';
+
+	if (!username || !password) {
+		error(400, 'Username and password are required');
+	}
+	if (username.length < 3 || username.length > 32) {
+		error(400, 'Username must be between 3 and 32 characters');
+	}
+	if (!/^[a-zA-Z0-9_-]+$/.test(username)) {
+		error(400, 'Username may only contain letters, numbers, underscores and hyphens');
+	}
+	if (password.length < 8) {
+		error(400, 'Password must be at least 8 characters');
+	}
+
+	let user;
+	try {
+		user = await createUser(username, password);
+	} catch (e: unknown) {
+		const msg = e instanceof Error ? e.message : 'Registration failed.';
+		if (msg.includes('Username already taken')) {
+			error(409, 'That username is already taken');
+		}
+		log.error('api/auth/register', 'unexpected error', { username, err: String(e) });
+		error(500, 'An error occurred. Please try again.');
+	}
+
+	// Merge anonymous session progress (non-fatal)
+	mergeSessionProgress(locals.sessionId, user.id).catch((e) =>
+		log.warn('api/auth/register', 'mergeSessionProgress failed (non-fatal)', { err: String(e) })
+	);
+
+	const authSessionId = randomBytes(16).toString('hex');
+
+	const userAgent = request.headers.get('user-agent') ?? '';
+	const ip =
+		request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() ??
+		request.headers.get('x-real-ip') ??
+		'';
+	createUserSession(user.id, authSessionId, userAgent, ip).catch((e) =>
+		log.warn('api/auth/register', 'createUserSession failed (non-fatal)', { err: String(e) })
+	);
+
+	const token = createAuthToken(user.id, user.username, user.role ?? 'user', authSessionId);
+
+	cookies.set(AUTH_COOKIE, token, {
+		path: '/',
+		httpOnly: true,
+		sameSite: 'lax',
+		maxAge: ONE_YEAR
+	});
+
+	return json({
+		token,
+		user: { id: user.id, username: user.username, role: user.role ?? 'user' }
+	});
+};

ui/src/routes/api/book/[slug]/+server.ts

@@ -0,0 +1,105 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { getBook, listChapterIdx, getProgress, isBookSaved } from '$lib/server/pocketbase';
+import { log } from '$lib/server/logger';
+import { env } from '$env/dynamic/private';
+
+const SCRAPER_URL = env.SCRAPER_API_URL ?? 'http://localhost:8080';
+
+interface PreviewChapter {
+	number: number;
+	title: string;
+	url: string;
+}
+
+/**
+ * GET /api/book/[slug]
+ * Returns book metadata, chapter list, progress, and library status.
+ * Falls back to a live scraper preview if the book is not in PocketBase.
+ *
+ * Response shape mirrors BookDetailResponse in the iOS APIClient.
+ */
+export const GET: RequestHandler = async ({ params, locals }) => {
+	const { slug } = params;
+
+	// Try PocketBase first
+	let book = await getBook(slug).catch((e) => {
+		log.error('api/book', 'getBook failed', { slug, err: String(e) });
+		return null;
+	});
+
+	if (book) {
+		let chapters, progress, saved;
+		try {
+			[chapters, progress, saved] = await Promise.all([
+				listChapterIdx(slug),
+				getProgress(locals.sessionId, slug, locals.user?.id),
+				isBookSaved(locals.sessionId, slug, locals.user?.id)
+			]);
+		} catch (e) {
+			log.error('api/book', 'failed to load book detail data', { slug, err: String(e) });
+			error(500, 'Failed to load book');
+		}
+
+		return json({
+			book,
+			chapters,
+			preview_chapters: null,
+			in_lib: true,
+			saved,
+			last_chapter: progress?.chapter ?? null
+		});
+	}
+
+	// Fall back to live scraper preview
+	try {
+		const res = await fetch(`${SCRAPER_URL}/api/book-preview/${encodeURIComponent(slug)}`);
+		if (!res.ok) {
+			log.warn('api/book', 'book-preview returned error', { slug, status: res.status });
+			error(404, `Book "${slug}" not found`);
+		}
+		const preview: {
+			in_lib: boolean;
+			meta: {
+				slug: string;
+				title: string;
+				author: string;
+				cover: string;
+				status: string;
+				genres: string[];
+				summary: string;
+				total_chapters: number;
+				source_url: string;
+			};
+			chapters: PreviewChapter[];
+		} = await res.json();
+
+		const previewBook = {
+			id: '',
+			slug: preview.meta.slug || slug,
+			title: preview.meta.title,
+			author: preview.meta.author,
+			cover: preview.meta.cover,
+			status: preview.meta.status,
+			genres: preview.meta.genres ?? [],
+			summary: preview.meta.summary,
+			total_chapters: preview.meta.total_chapters,
+			source_url: preview.meta.source_url,
+			ranking: 0,
+			meta_updated: ''
+		};
+
+		return json({
+			book: previewBook,
+			chapters: [],
+			preview_chapters: preview.chapters,
+			in_lib: preview.in_lib,
+			saved: false,
+			last_chapter: null
+		});
+	} catch (e) {
+		if (e instanceof Error && 'status' in e) throw e;
+		log.error('api/book', 'book-preview fetch failed', { slug, err: String(e) });
+		error(404, `Book "${slug}" not found`);
+	}
+};

ui/src/routes/api/chapter/[slug]/[n]/+server.ts

@@ -0,0 +1,125 @@
+import { json, error } from '@sveltejs/kit';
+import { marked } from 'marked';
+import type { RequestHandler } from './$types';
+import { getBook, listChapterIdx } from '$lib/server/pocketbase';
+import { presignChapter } from '$lib/server/minio';
+import { log } from '$lib/server/logger';
+import { env } from '$env/dynamic/private';
+
+const SCRAPER_URL = env.SCRAPER_API_URL ?? 'http://localhost:8080';
+
+/**
+ * GET /api/chapter/[slug]/[n]
+ * Returns rendered chapter HTML, navigation info, and voice list.
+ * Supports ?preview=1&chapter_url=...&title=... for un-scraped books.
+ *
+ * Response shape mirrors ChapterResponse in the iOS APIClient.
+ */
+export const GET: RequestHandler = async ({ params, url, locals }) => {
+	const { slug } = params;
+	const n = parseInt(params.n, 10);
+
+	if (!n || n < 1) error(400, 'Invalid chapter number');
+
+	const isPreview = url.searchParams.get('preview') === '1';
+	const chapterUrl = url.searchParams.get('chapter_url') ?? '';
+	const chapterTitle = url.searchParams.get('title') ?? '';
+
+	if (isPreview) {
+		// Preview path: scrape live, nothing from PocketBase/MinIO
+		const previewParams = new URLSearchParams();
+		if (chapterUrl) previewParams.set('chapter_url', chapterUrl);
+		if (chapterTitle) previewParams.set('title', chapterTitle);
+
+		let chapterData: { slug: string; number: number; title: string; text: string; url: string };
+		try {
+			const res = await fetch(
+				`${SCRAPER_URL}/api/chapter-text-preview/${encodeURIComponent(slug)}/${n}?${previewParams.toString()}`
+			);
+			if (!res.ok) {
+				log.error('api/chapter', 'chapter-text-preview returned error', { slug, n, status: res.status });
+				error(404, `Chapter ${n} not found`);
+			}
+			chapterData = await res.json();
+		} catch (e) {
+			if (e instanceof Error && 'status' in e) throw e;
+			log.error('api/chapter', 'chapter-text-preview fetch failed', { slug, n, err: String(e) });
+			error(502, 'Could not fetch chapter preview');
+		}
+
+		const html = chapterData.text
+			? '<p>' + chapterData.text.replace(/\n{2,}/g, '</p><p>').replace(/\n/g, '<br>') + '</p>'
+			: '';
+
+		let voices: string[] = [];
+		try {
+			const vRes = await fetch(`${SCRAPER_URL}/api/voices`);
+			if (vRes.ok) {
+				const d = (await vRes.json()) as { voices: string[] };
+				voices = d.voices ?? [];
+			}
+		} catch {
+			// Non-critical
+		}
+
+		const pb = await getBook(slug).catch(() => null);
+
+		return json({
+			book: { slug, title: pb?.title ?? slug, cover: pb?.cover ?? '' },
+			chapter: { id: '', slug, number: n, title: chapterData.title || `Chapter ${n}`, date_label: '' },
+			html,
+			voices,
+			prev: null,
+			next: null,
+			chapters: [],
+			is_preview: true
+		});
+	}
+
+	// Normal path: PocketBase + MinIO
+	const [book, chapters, voicesRes] = await Promise.all([
+		getBook(slug),
+		listChapterIdx(slug),
+		fetch(`${SCRAPER_URL}/api/voices`).catch(() => null)
+	]);
+
+	if (!book) error(404, `Book "${slug}" not found`);
+
+	const chapterIdx = chapters.find((c) => c.number === n);
+	if (!chapterIdx) error(404, `Chapter ${n} not found`);
+
+	let voices: string[] = [];
+	try {
+		if (voicesRes?.ok) {
+			const data = (await voicesRes.json()) as { voices: string[] };
+			voices = data.voices ?? [];
+		}
+	} catch {
+		// Non-critical
+	}
+
+	let html = '';
+	try {
+		const presignUrl = await presignChapter(slug, n);
+		const res = await fetch(presignUrl);
+		if (!res.ok) throw new Error(`MinIO returned ${res.status}`);
+		const markdown = await res.text();
+		html = await marked(markdown, { async: true });
+	} catch (e) {
+		log.error('api/chapter', 'failed to fetch chapter content', { slug, n, err: String(e) });
+	}
+
+	const prevChapter = chapters.find((c) => c.number === n - 1) ?? null;
+	const nextChapter = chapters.find((c) => c.number === n + 1) ?? null;
+
+	return json({
+		book: { slug: book.slug, title: book.title, cover: book.cover ?? '' },
+		chapter: chapterIdx,
+		html,
+		voices,
+		prev: prevChapter ? prevChapter.number : null,
+		next: nextChapter ? nextChapter.number : null,
+		chapters: chapters.map((c) => ({ number: c.number, title: c.title })),
+		is_preview: false
+	});
+};

ui/src/routes/api/home/+server.ts

@@ -0,0 +1,48 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { listBooks, recentlyAddedBooks, allProgress, getHomeStats } from '$lib/server/pocketbase';
+import { log } from '$lib/server/logger';
+import type { Book, Progress } from '$lib/server/pocketbase';
+
+/**
+ * GET /api/home
+ * Returns home screen data: continue-reading list, recently updated books, and stats.
+ * Requires authentication (enforced by layout guard).
+ */
+export const GET: RequestHandler = async ({ locals }) => {
+	let allBooks: Book[] = [];
+	let recentBooks: Book[] = [];
+	let progressList: Progress[] = [];
+	let stats = { totalBooks: 0, totalChapters: 0 };
+
+	try {
+		[allBooks, recentBooks, progressList, stats] = await Promise.all([
+			listBooks(),
+			recentlyAddedBooks(8),
+			allProgress(locals.sessionId, locals.user?.id),
+			getHomeStats()
+		]);
+	} catch (e) {
+		log.error('api/home', 'failed to load home data', { err: String(e) });
+	}
+
+	const bookMap = new Map<string, Book>(allBooks.map((b) => [b.slug, b]));
+
+	const continueReading = progressList
+		.filter((p) => bookMap.has(p.slug))
+		.slice(0, 6)
+		.map((p) => ({ book: bookMap.get(p.slug)!, chapter: p.chapter }));
+
+	const inProgressSlugs = new Set(continueReading.map((c) => c.book.slug));
+	const recentlyUpdated = recentBooks.filter((b) => !inProgressSlugs.has(b.slug)).slice(0, 6);
+
+	return json({
+		continue_reading: continueReading,
+		recently_updated: recentlyUpdated,
+		stats: {
+			totalBooks: stats.totalBooks,
+			totalChapters: stats.totalChapters,
+			booksInProgress: continueReading.length
+		}
+	});
+};

ui/src/routes/api/library/+server.ts

@@ -0,0 +1,61 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { listBooks, allProgress, getSavedSlugs } from '$lib/server/pocketbase';
+import { log } from '$lib/server/logger';
+
+/**
+ * GET /api/library
+ * Returns the user's library: books they have started reading or explicitly saved.
+ * Each item includes the book record, the last chapter read, and saved_at timestamp.
+ *
+ * Response shape mirrors LibraryItem in the iOS APIClient.
+ */
+export const GET: RequestHandler = async ({ locals }) => {
+	let allBooks: Awaited<ReturnType<typeof listBooks>>;
+	let progressList: Awaited<ReturnType<typeof allProgress>>;
+	let savedSlugs: Set<string>;
+
+	try {
+		[allBooks, progressList, savedSlugs] = await Promise.all([
+			listBooks(),
+			allProgress(locals.sessionId, locals.user?.id),
+			getSavedSlugs(locals.sessionId, locals.user?.id)
+		]);
+	} catch (e) {
+		log.error('api/library', 'failed to load library data', { err: String(e) });
+		allBooks = [];
+		progressList = [];
+		savedSlugs = new Set();
+	}
+
+	const progressMap: Record<string, number> = {};
+	const progressUpdatedMap: Record<string, string> = {};
+	for (const p of progressList) {
+		progressMap[p.slug] = p.chapter;
+		progressUpdatedMap[p.slug] = p.updated;
+	}
+
+	const progressSlugs = new Set(progressList.map((p) => p.slug));
+	const books = allBooks.filter((b) => progressSlugs.has(b.slug) || savedSlugs.has(b.slug));
+
+	const withProgress = books.filter((b) => progressSlugs.has(b.slug));
+	const savedOnly = books
+		.filter((b) => !progressSlugs.has(b.slug))
+		.sort((a, b) => (a.title ?? '').localeCompare(b.title ?? ''));
+
+	withProgress.sort((a, b) => {
+		const ta = progressUpdatedMap[a.slug] ?? '';
+		const tb = progressUpdatedMap[b.slug] ?? '';
+		return tb.localeCompare(ta);
+	});
+
+	const ordered = [...withProgress, ...savedOnly];
+
+	const items = ordered.map((book) => ({
+		book,
+		last_chapter: progressMap[book.slug] ?? null,
+		saved_at: progressUpdatedMap[book.slug] ?? new Date().toISOString()
+	}));
+
+	return json(items);
+};

ui/src/routes/api/presign/audio/+server.ts

@@ -11,7 +11,8 @@ import { log } from '$lib/server/logger';
  */
 export const GET: RequestHandler = async ({ url }) => {
 	const slug = url.searchParams.get('slug');
-	const n = parseInt(url.searchParams.get('n') ?? '', 10);
+	// Accept both 'n' (web) and 'chapter' (iOS) as the chapter number param
+	const n = parseInt(url.searchParams.get('n') ?? url.searchParams.get('chapter') ?? '', 10);
 	const voice = url.searchParams.get('voice') ?? undefined;
 
 	if (!slug || !n || n < 1) {

ui/src/routes/api/progress/[slug]/+server.ts

@@ -0,0 +1,34 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { setProgress } from '$lib/server/pocketbase';
+import { log } from '$lib/server/logger';
+
+/**
+ * POST /api/progress/[slug]
+ * Body: { chapter: number }
+ * Records the user's reading position for a specific book.
+ *
+ * This is a slug-in-path variant of POST /api/progress (which takes slug in body).
+ * Used by the iOS app where slug is part of the URL path.
+ */
+export const POST: RequestHandler = async ({ params, request, locals }) => {
+	const { slug } = params;
+	const body = await request.json().catch(() => null);
+
+	if (!body || typeof body.chapter !== 'number') {
+		error(400, 'Invalid body — expected { chapter: number }');
+	}
+
+	try {
+		await setProgress(locals.sessionId, slug, body.chapter, locals.user?.id);
+	} catch (e) {
+		log.error('api/progress/[slug]', 'setProgress failed', {
+			slug,
+			chapter: body.chapter,
+			err: String(e)
+		});
+		error(500, 'Failed to save progress');
+	}
+
+	return json({ ok: true });
+};

ui/src/routes/api/ranking/+server.ts

@@ -0,0 +1,27 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { env } from '$env/dynamic/private';
+import { log } from '$lib/server/logger';
+
+const SCRAPER_URL = env.SCRAPER_API_URL ?? 'http://localhost:8080';
+
+/**
+ * GET /api/ranking
+ * Proxies to the Go scraper's /api/ranking endpoint.
+ * Returns the top-ranked novels list as JSON.
+ */
+export const GET: RequestHandler = async () => {
+	try {
+		const res = await fetch(`${SCRAPER_URL}/api/ranking`);
+		if (!res.ok) {
+			log.error('api/ranking', 'scraper returned error', { status: res.status });
+			error(502, `Ranking fetch failed: ${res.status}`);
+		}
+		const data = await res.json();
+		return json(data);
+	} catch (e) {
+		if (e instanceof Error && 'status' in e) throw e;
+		log.error('api/ranking', 'network error', { err: String(e) });
+		error(502, 'Could not load ranking');
+	}
+};

ui/src/routes/api/search/+server.ts

@@ -0,0 +1,36 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { env } from '$env/dynamic/private';
+import { log } from '$lib/server/logger';
+
+const SCRAPER_URL = env.SCRAPER_API_URL ?? 'http://localhost:8080';
+
+/**
+ * GET /api/search?q=<query>
+ * Proxies to the Go scraper's /api/search endpoint.
+ * Returns: { results, local_count, remote_count }
+ *
+ * Response shape mirrors SearchResponse in the iOS APIClient.
+ */
+export const GET: RequestHandler = async ({ url }) => {
+	const q = url.searchParams.get('q') ?? '';
+
+	if (q.trim().length < 2) {
+		return json({ results: [], local_count: 0, remote_count: 0 });
+	}
+
+	const apiURL = `${SCRAPER_URL}/api/search?q=${encodeURIComponent(q.trim())}`;
+	try {
+		const res = await fetch(apiURL);
+		if (!res.ok) {
+			log.error('api/search', 'scraper returned error', { status: res.status, q });
+			error(502, `Search failed: ${res.status}`);
+		}
+		const data = await res.json();
+		return json(data);
+	} catch (e) {
+		if (e instanceof Error && 'status' in e) throw e;
+		log.error('api/search', 'network error', { q, err: String(e) });
+		error(502, 'Could not reach search service');
+	}
+};

ui/src/routes/api/sessions/+server.ts

@@ -0,0 +1,32 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { listUserSessions } from '$lib/server/pocketbase';
+import { log } from '$lib/server/logger';
+
+/**
+ * GET /api/sessions
+ * Returns all active sessions for the logged-in user.
+ */
+export const GET: RequestHandler = async ({ locals }) => {
+	if (!locals.user) {
+		error(401, 'Not logged in');
+	}
+
+	try {
+		const sessions = await listUserSessions(locals.user.id);
+		// Don't expose raw session_id to the client — only the record ID for revocation
+		const safe = sessions.map((s) => ({
+			id: s.id,
+			user_agent: s.user_agent,
+			ip: s.ip,
+			created_at: s.created_at,
+			last_seen: s.last_seen,
+			// Tell the client whether this is the currently active session
+			is_current: s.session_id === locals.user!.authSessionId
+		}));
+		return json({ sessions: safe });
+	} catch (e) {
+		log.error('sessions', 'GET failed', { err: String(e) });
+		error(500, 'Failed to load sessions');
+	}
+};

ui/src/routes/api/sessions/[id]/+server.ts

@@ -0,0 +1,41 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { revokeUserSession } from '$lib/server/pocketbase';
+import { log } from '$lib/server/logger';
+
+/**
+ * DELETE /api/sessions/[id]
+ * Revokes a specific session by its PocketBase record ID.
+ * Only the owner can revoke their own sessions.
+ */
+export const DELETE: RequestHandler = async ({ params, locals, cookies }) => {
+	if (!locals.user) {
+		error(401, 'Not logged in');
+	}
+
+	const recordId = params.id;
+	if (!recordId) {
+		error(400, 'Session ID required');
+	}
+
+	try {
+		const ok = await revokeUserSession(recordId, locals.user.id);
+		if (!ok) {
+			error(404, 'Session not found or not yours');
+		}
+
+		// If the user is terminating their own current session, clear their auth cookie
+		// so they get logged out immediately (the hook would do this on the next request anyway,
+		// but clearing it here gives instant feedback for the "end this session" flow).
+		// For other sessions, we leave the cookie intact.
+		// We detect "current session" via authSessionId — but since the client sends the
+		// record ID (not the session_id), we rely on the UI to redirect after ending its own session.
+
+		log.info('sessions', 'session revoked', { recordId, userId: locals.user.id });
+		return json({ ok: true });
+	} catch (e) {
+		if (e instanceof Error && 'status' in e) throw e; // re-throw SvelteKit errors
+		log.error('sessions', 'DELETE failed', { recordId, err: String(e) });
+		error(500, 'Failed to revoke session');
+	}
+};

ui/src/routes/books/[slug]/+page.svelte

@@ -32,15 +32,23 @@
 
 	const genres = $derived(parseGenres(data.book.genres));
 
-	// Paginate chapter list — show 100 at a time
-	const PAGE_SIZE = 100;
+	// Paginate chapter list — 50 on mobile, 100 on sm+ (≥640px)
+	let pageSize = $state(50);
+
+	onMount(() => {
+		const mq = window.matchMedia('(min-width: 640px)');
+		pageSize = mq.matches ? 100 : 50;
+		const handler = (e: MediaQueryListEvent) => { pageSize = e.matches ? 100 : 50; };
+		mq.addEventListener('change', handler);
+		return () => mq.removeEventListener('change', handler);
+	});
 
 	// Start on the page that contains the current chapter (if any)
 	function pageForChapter(chapterNum: number | null, list: typeof chapterList): number {
 		if (!chapterNum || list.length === 0) return 0;
 		const idx = list.findIndex((c) => c.number === chapterNum);
 		if (idx === -1) return 0;
-		return Math.floor(idx / PAGE_SIZE);
+		return Math.floor(idx / pageSize);
 	}
 
 	let page = $state(pageForChapter(data.lastChapter, data.inLib ? data.chapters : (data.previewChapters ?? [])));
@@ -51,9 +59,9 @@
 			? data.chapters
 			: (data.previewChapters ?? [])
 	);
-	const totalPages = $derived(Math.ceil(chapterList.length / PAGE_SIZE));
+	const totalPages = $derived(Math.ceil(chapterList.length / pageSize));
 	const visibleChapters = $derived(
-		chapterList.slice(page * PAGE_SIZE, (page + 1) * PAGE_SIZE)
+		chapterList.slice(page * pageSize, (page + 1) * pageSize)
 	);
 
 	// ── Chapter list polling ──────────────────────────────────────────────────
@@ -148,54 +156,146 @@
 			rangeScraping = false;
 		}
 	}
+
+	// ── Summary expand/collapse ───────────────────────────────────────────────
+	let summaryExpanded = $state(false);
+
+	// ── Admin panel expand/collapse ───────────────────────────────────────────
+	let adminOpen = $state(false);
 </script>
 
 <svelte:head>
 	<title>{data.book.title} — libnovel</title>
 </svelte:head>
 
-<!-- Book header -->
-<div class="flex gap-6 mb-8">
+<!-- ═══════════════════════════════════════════════════════════════ Hero ══ -->
+<div class="relative rounded-xl overflow-hidden mb-8">
+	<!-- Blurred cover background -->
 	{#if data.book.cover}
-		<img
-			src={data.book.cover}
-			alt={data.book.title}
-			class="w-32 sm:w-40 rounded-lg object-cover flex-shrink-0 border border-zinc-700"
-		/>
+		<div
+			class="absolute inset-0 bg-cover bg-center scale-110"
+			style="background-image: url('{data.book.cover}'); filter: blur(24px); opacity: 0.18;"
+			aria-hidden="true"
+		></div>
 	{/if}
+	<div class="absolute inset-0 bg-gradient-to-b from-zinc-900/60 to-zinc-900/95 pointer-events-none" aria-hidden="true"></div>
 
-	<div class="flex flex-col gap-2 min-w-0">
-		<div class="flex items-center gap-2 flex-wrap">
-			<h1 class="text-2xl font-bold text-zinc-100 leading-tight">{data.book.title}</h1>
-			{#if !data.inLib}
-				<span class="text-xs px-2 py-0.5 rounded-full bg-zinc-700 text-zinc-400 border border-zinc-600 shrink-0" title="This book was fetched live from the source and is not yet in your library">
-					not in library
-				</span>
+	<div class="relative flex flex-col p-5 sm:p-7 gap-4">
+		<!-- Cover + meta row -->
+		<div class="flex gap-5 sm:gap-8">
+			<!-- Cover image -->
+			{#if data.book.cover}
+				<img
+					src={data.book.cover}
+					alt={data.book.title}
+					class="w-28 sm:w-48 rounded-lg object-cover flex-shrink-0 border border-zinc-700 shadow-xl self-start"
+				/>
 			{/if}
+
+			<!-- Meta -->
+			<div class="flex flex-col gap-2 min-w-0 flex-1">
+				<!-- Title + "not in library" badge -->
+				<div class="flex items-start gap-2 flex-wrap">
+					<h1 class="text-xl sm:text-3xl font-bold text-zinc-100 leading-tight">{data.book.title}</h1>
+					{#if !data.inLib}
+						<span
+							class="mt-1 text-xs px-2 py-0.5 rounded-full bg-zinc-700 text-zinc-400 border border-zinc-600 shrink-0"
+							title="This book was fetched live from the source and is not yet in your library"
+						>
+							not in library
+						</span>
+					{/if}
+				</div>
+
+				<!-- Author -->
+				{#if data.book.author}
+					<p class="text-zinc-400 text-sm">{data.book.author}</p>
+				{/if}
+
+				<!-- Status + genres -->
+				<div class="flex flex-wrap gap-1.5 mt-0.5">
+					{#if data.book.status}
+						<span class="text-xs px-2 py-0.5 rounded bg-zinc-700 text-zinc-300 border border-zinc-600">{data.book.status}</span>
+					{/if}
+					{#each genres as genre}
+						<span class="text-xs px-2 py-0.5 rounded bg-zinc-800 text-zinc-400 border border-zinc-700">{genre}</span>
+					{/each}
+				</div>
+
+				<!-- Summary with expand toggle -->
+				{#if data.book.summary}
+					<div class="mt-1">
+						<p class="text-zinc-400 text-sm leading-relaxed break-words {summaryExpanded ? '' : 'line-clamp-3'}">
+							{data.book.summary}
+						</p>
+						{#if data.book.summary.length > 220}
+							<button
+								onclick={() => (summaryExpanded = !summaryExpanded)}
+								class="text-xs text-amber-400/70 hover:text-amber-400 mt-1 transition-colors"
+							>
+								{summaryExpanded ? 'Less' : 'More'}
+							</button>
+						{/if}
+					</div>
+				{/if}
+
+				<!-- CTA buttons — desktop only (hidden on mobile, shown below on mobile) -->
+				<div class="hidden sm:flex gap-2 mt-3 items-center flex-wrap">
+					{#if data.lastChapter}
+						<a
+							href="/books/{data.book.slug}/chapters/{data.lastChapter}"
+							class="px-5 py-2 bg-amber-400 text-zinc-900 font-semibold rounded-lg text-sm hover:bg-amber-300 transition-colors shadow"
+						>
+							Continue ch.{data.lastChapter}
+						</a>
+					{/if}
+					{#if chapterList.length > 0}
+						<a
+							href="/books/{data.book.slug}/chapters/1"
+							class="px-4 py-2 rounded-lg text-sm font-semibold transition-colors
+								{data.lastChapter
+									? 'bg-zinc-700 text-zinc-300 hover:bg-zinc-600'
+									: 'bg-amber-400 text-zinc-900 hover:bg-amber-300 shadow'}"
+						>
+							{data.inLib ? 'Start from ch.1' : 'Preview ch.1'}
+						</a>
+					{/if}
+					{#if data.inLib}
+						<button
+							onclick={toggleSave}
+							disabled={saving}
+							title={saved ? 'Remove from library' : 'Add to library'}
+							class="flex items-center justify-center w-9 h-9 rounded-lg border transition-colors disabled:opacity-50
+								{saved
+									? 'bg-amber-400/20 text-amber-300 border-amber-400/30 hover:bg-red-500/20 hover:text-red-300 hover:border-red-400/30'
+									: 'bg-zinc-700 text-zinc-400 border-zinc-600 hover:bg-zinc-600 hover:text-zinc-100'}"
+						>
+							{#if saving}
+								<svg class="w-4 h-4 animate-spin" fill="none" viewBox="0 0 24 24">
+									<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+									<path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z"></path>
+								</svg>
+							{:else if saved}
+								<svg class="w-4 h-4" fill="currentColor" viewBox="0 0 24 24">
+									<path d="M5 4a2 2 0 012-2h10a2 2 0 012 2v16l-7-3.5L5 20V4z"/>
+								</svg>
+							{:else}
+								<svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+									<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 4a2 2 0 012-2h10a2 2 0 012 2v16l-7-3.5L5 20V4z"/>
+								</svg>
+							{/if}
+						</button>
+					{/if}
+				</div>
+			</div>
 		</div>
 
-		{#if data.book.author}
-			<p class="text-zinc-400 text-sm">{data.book.author}</p>
-		{/if}
-
-		<div class="flex flex-wrap gap-2 mt-1">
-			{#if data.book.status}
-				<span class="text-xs px-2 py-1 rounded bg-zinc-700 text-zinc-300">{data.book.status}</span>
-			{/if}
-			{#each genres as genre}
-				<span class="text-xs px-2 py-1 rounded bg-zinc-800 text-zinc-400">{genre}</span>
-			{/each}
-		</div>
-
-		{#if data.book.summary}
-			<p class="text-zinc-400 text-sm leading-relaxed line-clamp-4 mt-1">{data.book.summary}</p>
-		{/if}
-
-		<div class="flex gap-3 mt-2 flex-wrap items-center">
+		<!-- CTA buttons — mobile only, full-width row below cover+meta -->
+		<div class="flex sm:hidden gap-2 items-center">
 			{#if data.lastChapter}
 				<a
 					href="/books/{data.book.slug}/chapters/{data.lastChapter}"
-					class="px-4 py-2 bg-amber-400 text-zinc-900 font-semibold rounded text-sm hover:bg-amber-300 transition-colors"
+					class="flex-1 text-center px-4 py-2.5 bg-amber-400 text-zinc-900 font-semibold rounded-lg text-sm hover:bg-amber-300 transition-colors shadow"
 				>
 					Continue ch.{data.lastChapter}
 				</a>
@@ -203,21 +303,23 @@
 			{#if chapterList.length > 0}
 				<a
 					href="/books/{data.book.slug}/chapters/1"
-					class="px-4 py-2 bg-zinc-700 text-zinc-100 font-semibold rounded text-sm hover:bg-zinc-600 transition-colors"
+					class="flex-1 text-center px-4 py-2.5 rounded-lg text-sm font-semibold transition-colors
+						{data.lastChapter
+							? 'bg-zinc-700 text-zinc-300 hover:bg-zinc-600'
+							: 'bg-amber-400 text-zinc-900 hover:bg-amber-300 shadow'}"
 				>
 					{data.inLib ? 'Start from ch.1' : 'Preview ch.1'}
 				</a>
 			{/if}
-			<!-- Save / unsave button -->
 			{#if data.inLib}
 				<button
 					onclick={toggleSave}
 					disabled={saving}
 					title={saved ? 'Remove from library' : 'Add to library'}
-					class="flex items-center gap-1.5 px-3 py-2 rounded text-sm font-medium transition-colors disabled:opacity-50
+					class="flex items-center justify-center w-10 h-10 flex-shrink-0 rounded-lg border transition-colors disabled:opacity-50
 						{saved
-							? 'bg-amber-400/20 text-amber-300 hover:bg-red-500/20 hover:text-red-300 border border-amber-400/30 hover:border-red-400/30'
-							: 'bg-zinc-700 text-zinc-400 hover:text-zinc-100 hover:bg-zinc-600 border border-zinc-600'}"
+							? 'bg-amber-400/20 text-amber-300 border-amber-400/30 hover:bg-red-500/20 hover:text-red-300 hover:border-red-400/30'
+							: 'bg-zinc-700 text-zinc-400 border-zinc-600 hover:bg-zinc-600 hover:text-zinc-100'}"
 				>
 					{#if saving}
 						<svg class="w-4 h-4 animate-spin" fill="none" viewBox="0 0 24 24">
@@ -233,126 +335,48 @@
 							<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 4a2 2 0 012-2h10a2 2 0 012 2v16l-7-3.5L5 20V4z"/>
 						</svg>
 					{/if}
-					{saved ? 'Saved' : 'Save'}
 				</button>
 			{/if}
 		</div>
 	</div>
 </div>
 
-<!-- Chapter list -->
-<div class="mt-4">
+<!-- ══════════════════════════════════════════════════ Chapter list ══ -->
+<div>
+	<!-- Header row: title + pagination -->
 	<div class="flex items-center justify-between mb-3 flex-wrap gap-2">
-		<h2 class="text-lg font-semibold text-zinc-100">
+		<h2 class="text-base font-semibold text-zinc-200">
 			Chapters
-			<span class="text-zinc-500 font-normal text-sm ml-1">({chapterList.length})</span>
+			{#if chapterList.length > 0}
+				<span class="text-zinc-500 font-normal text-sm ml-1">({chapterList.length})</span>
+			{/if}
 		</h2>
 
-		<div class="flex items-center gap-3 flex-wrap">
-			{#if data.isAdmin && data.book.source_url}
+		{#if totalPages > 1}
+			<div class="flex gap-2 items-center text-sm">
 				<button
-					onclick={rescrape}
-					disabled={scraping}
-					class="px-3 py-1 rounded text-xs font-medium transition-colors flex items-center gap-1.5
-						{scraping
-							? 'bg-zinc-700 text-zinc-500 cursor-not-allowed'
-							: 'bg-zinc-700 text-zinc-200 hover:bg-zinc-600'}"
-					title="Re-scrape this book from source"
+					onclick={() => (page = Math.max(0, page - 1))}
+					disabled={page === 0}
+					class="px-2 py-1 rounded bg-zinc-800 text-zinc-300 disabled:opacity-40 hover:bg-zinc-700 transition-colors"
 				>
-					{#if scraping}
-						<svg class="w-3 h-3 animate-spin" fill="none" viewBox="0 0 24 24">
-							<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
-							<path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z"></path>
-						</svg>
-						Queuing…
-					{:else}
-						<svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-							<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"/>
-						</svg>
-						Rescrape
-					{/if}
+					&larr;
 				</button>
-			{/if}
-
-			{#if totalPages > 1}
-				<div class="flex gap-2 items-center text-sm">
-					<button
-						onclick={() => (page = Math.max(0, page - 1))}
-						disabled={page === 0}
-						class="px-2 py-1 rounded bg-zinc-700 text-zinc-300 disabled:opacity-40 hover:bg-zinc-600 transition-colors"
-					>
-						&larr;
-					</button>
-					<span class="text-zinc-400">{page + 1} / {totalPages}</span>
-					<button
-						onclick={() => (page = Math.min(totalPages - 1, page + 1))}
-						disabled={page === totalPages - 1}
-						class="px-2 py-1 rounded bg-zinc-700 text-zinc-300 disabled:opacity-40 hover:bg-zinc-600 transition-colors"
-					>
-						&rarr;
-					</button>
-				</div>
-			{/if}
-		</div>
+				<span class="text-zinc-500 text-xs tabular-nums">
+					{page * pageSize + 1}–{Math.min((page + 1) * pageSize, chapterList.length)} of {chapterList.length}
+				</span>
+				<button
+					onclick={() => (page = Math.min(totalPages - 1, page + 1))}
+					disabled={page === totalPages - 1}
+					class="px-2 py-1 rounded bg-zinc-800 text-zinc-300 disabled:opacity-40 hover:bg-zinc-700 transition-colors"
+				>
+					&rarr;
+				</button>
+			</div>
+		{/if}
 	</div>
 
-	{#if scrapeResult}
-		<div class="mb-3 px-3 py-2 rounded text-xs font-medium
-			{scrapeResult === 'queued' ? 'bg-green-900/40 text-green-300 border border-green-800' :
-			 scrapeResult === 'busy'   ? 'bg-amber-900/40 text-amber-300 border border-amber-800' :
-			                             'bg-red-900/40 text-red-300 border border-red-800'}">
-			{scrapeResult === 'queued' ? 'Rescrape queued — running in background.' :
-			 scrapeResult === 'busy'   ? 'Scraper is busy with another job. Try again shortly.' :
-			                             'Failed to queue rescrape. Check server logs.'}
-		</div>
-	{/if}
-
-	<!-- Admin: range scrape controls -->
-	{#if data.isAdmin && data.book.source_url}
-		<div class="mb-4 p-3 rounded bg-zinc-800/60 border border-zinc-700 flex flex-wrap items-end gap-3">
-			<div class="flex flex-col gap-1">
-				<label for="range-from" class="text-xs text-zinc-500">From chapter</label>
-				<input
-					id="range-from"
-					type="number"
-					min="1"
-					bind:value={rangeFrom}
-					placeholder="1"
-					class="w-24 px-2 py-1 rounded bg-zinc-700 border border-zinc-600 text-zinc-200 text-xs focus:outline-none focus:border-amber-400"
-				/>
-			</div>
-			<div class="flex flex-col gap-1">
-				<label for="range-to" class="text-xs text-zinc-500">To chapter (optional)</label>
-				<input
-					id="range-to"
-					type="number"
-					min="1"
-					bind:value={rangeTo}
-					placeholder="end"
-					class="w-24 px-2 py-1 rounded bg-zinc-700 border border-zinc-600 text-zinc-200 text-xs focus:outline-none focus:border-amber-400"
-				/>
-			</div>
-			<button
-				onclick={scrapeRange}
-				disabled={rangeScraping || !rangeFrom}
-				class="px-3 py-1.5 rounded text-xs font-medium transition-colors
-					{rangeScraping || !rangeFrom
-						? 'bg-zinc-700 text-zinc-500 cursor-not-allowed'
-						: 'bg-amber-500/20 text-amber-300 hover:bg-amber-500/40 border border-amber-500/30'}"
-			>
-				{rangeScraping ? 'Queuing…' : 'Scrape range'}
-			</button>
-
-			{#if rangeResult}
-				<span class="text-xs {rangeResult === 'queued' ? 'text-green-400' : rangeResult === 'busy' ? 'text-amber-400' : 'text-red-400'}">
-					{rangeResult === 'queued' ? 'Range scrape queued.' : rangeResult === 'busy' ? 'Scraper busy.' : 'Error queuing.'}
-				</span>
-			{/if}
-		</div>
-	{/if}
-
+	<!-- Chapter rows -->
 	{#if pollingChapters}
-		<!-- Chapter list is being indexed in the background -->
 		<div class="flex items-center gap-3 py-4 text-zinc-500 text-sm">
 			<svg class="w-4 h-4 animate-spin flex-shrink-0" fill="none" viewBox="0 0 24 24">
 				<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
@@ -360,7 +384,7 @@
 			</svg>
 			Indexing chapter list…
 		</div>
-		<div class="grid grid-cols-1 sm:grid-cols-2 gap-1 opacity-40 pointer-events-none">
+		<div class="flex flex-col gap-0.5 opacity-40 pointer-events-none">
 			{#each Array(8) as _}
 				<div class="h-9 rounded bg-zinc-800 animate-pulse"></div>
 			{/each}
@@ -368,35 +392,32 @@
 	{:else if chapterList.length === 0}
 		<p class="text-zinc-500 text-sm">No chapters available yet.</p>
 	{:else}
-		<div class="grid grid-cols-1 sm:grid-cols-2 gap-1">
+		<div class="flex flex-col gap-0.5">
 			{#each visibleChapters as chapter}
 				{@const isCurrent = data.lastChapter === chapter.number}
 				{@const chapterUrl = data.inLib
 					? `/books/${data.book.slug}/chapters/${chapter.number}`
 					: `/books/${data.book.slug}/chapters/${chapter.number}?preview=1&chapter_url=${encodeURIComponent((chapter as { url?: string }).url ?? '')}&title=${encodeURIComponent(chapter.title ?? '')}`}
-				<div class="flex items-center gap-3 px-3 py-2 rounded hover:bg-zinc-800 transition-colors group {isCurrent ? 'bg-zinc-800' : ''}">
-					<a
-						href={chapterUrl}
-						class="flex items-center gap-3 flex-1 min-w-0"
-					>
-						<span
-							class="text-xs font-mono w-10 text-right flex-shrink-0 {isCurrent
-								? 'text-amber-400'
-								: 'text-zinc-500'}"
-						>
+				<div class="flex items-center gap-2 px-3 py-2.5 rounded hover:bg-zinc-800/70 transition-colors group {isCurrent ? 'bg-zinc-800' : ''}">
+					<a href={chapterUrl} class="flex items-center gap-2 flex-1 min-w-0">
+						<!-- Chapter number -->
+						<span class="text-sm font-mono w-10 text-right flex-shrink-0 {isCurrent ? 'text-amber-400' : 'text-zinc-600'}">
 							{chapter.number}
 						</span>
-						<span class="text-sm text-zinc-300 group-hover:text-zinc-100 truncate flex-1">
+						<!-- Title -->
+						<span class="text-base {isCurrent ? 'text-amber-300' : 'text-zinc-300 group-hover:text-zinc-100'} truncate min-w-0 flex-1 transition-colors">
 							{chapter.title || `Chapter ${chapter.number}`}
 						</span>
-						{#if isCurrent}
-							<span class="text-xs text-amber-400 flex-shrink-0">reading</span>
-						{/if}
+						<!-- Date label — desktop only -->
 						{#if (chapter as { date_label?: string }).date_label}
-							<span class="text-xs text-zinc-600 flex-shrink-0 hidden sm:block">{(chapter as { date_label?: string }).date_label}</span>
+							<span class="text-sm text-zinc-600 flex-shrink-0 max-sm:hidden">&middot; {(chapter as { date_label?: string }).date_label}</span>
+						{/if}
+						<!-- "reading" badge -->
+						{#if isCurrent}
+							<span class="text-sm text-amber-500 flex-shrink-0 font-medium">reading</span>
 						{/if}
 					</a>
-					<!-- Admin: scrape from this chapter up -->
+					<!-- Admin: scrape from this chapter up (hover-only) -->
 					{#if data.isAdmin && data.book.source_url && data.inLib}
 						<button
 							onclick={() => scrapeFromChapter(chapter.number)}
@@ -411,4 +432,96 @@
 			{/each}
 		</div>
 	{/if}
+
+	<!-- ── Admin panel (collapsed by default) ── -->
+	{#if data.isAdmin && data.book.source_url}
+		<div class="mt-6 border border-zinc-800 rounded-lg overflow-hidden">
+			<button
+				onclick={() => (adminOpen = !adminOpen)}
+				class="w-full flex items-center gap-2 px-4 py-2.5 text-xs font-medium text-zinc-500 hover:text-zinc-300 hover:bg-zinc-800/50 transition-colors text-left"
+			>
+				<svg class="w-3.5 h-3.5 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+					<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10.325 4.317c.426-1.756 2.924-1.756 3.35 0a1.724 1.724 0 002.573 1.066c1.543-.94 3.31.826 2.37 2.37a1.724 1.724 0 001.065 2.572c1.756.426 1.756 2.924 0 3.35a1.724 1.724 0 00-1.066 2.573c.94 1.543-.826 3.31-2.37 2.37a1.724 1.724 0 00-2.572 1.065c-.426 1.756-2.924 1.756-3.35 0a1.724 1.724 0 00-2.573-1.066c-1.543.94-3.31-.826-2.37-2.37a1.724 1.724 0 00-1.065-2.572c-1.756-.426-1.756-2.924 0-3.35a1.724 1.724 0 001.066-2.573c-.94-1.543.826-3.31 2.37-2.37.996.608 2.296.07 2.572-1.065z"/>
+					<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 12a3 3 0 11-6 0 3 3 0 016 0z"/>
+				</svg>
+				Admin
+				<svg class="w-3 h-3 ml-auto transition-transform {adminOpen ? 'rotate-180' : ''}" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+					<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"/>
+				</svg>
+			</button>
+
+			{#if adminOpen}
+				<div class="px-4 py-3 border-t border-zinc-800 flex flex-col gap-4">
+					<!-- Rescrape -->
+					<div class="flex items-center gap-3 flex-wrap">
+						<button
+							onclick={rescrape}
+							disabled={scraping}
+							class="flex items-center gap-1.5 px-3 py-1.5 rounded text-xs font-medium transition-colors
+								{scraping ? 'bg-zinc-700 text-zinc-500 cursor-not-allowed' : 'bg-zinc-700 text-zinc-200 hover:bg-zinc-600'}"
+						>
+							{#if scraping}
+								<svg class="w-3 h-3 animate-spin" fill="none" viewBox="0 0 24 24">
+									<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+									<path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z"></path>
+								</svg>
+								Queuing…
+							{:else}
+								<svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+									<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"/>
+								</svg>
+								Rescrape book
+							{/if}
+						</button>
+						{#if scrapeResult}
+							<span class="text-xs {scrapeResult === 'queued' ? 'text-green-400' : scrapeResult === 'busy' ? 'text-amber-400' : 'text-red-400'}">
+								{scrapeResult === 'queued' ? 'Queued.' : scrapeResult === 'busy' ? 'Scraper busy.' : 'Error.'}
+							</span>
+						{/if}
+					</div>
+
+					<!-- Range scrape -->
+					<div class="flex flex-wrap items-end gap-3">
+						<div class="flex flex-col gap-1">
+							<label for="range-from" class="text-xs text-zinc-500">From chapter</label>
+							<input
+								id="range-from"
+								type="number"
+								min="1"
+								bind:value={rangeFrom}
+								placeholder="1"
+								class="w-24 px-2 py-1 rounded bg-zinc-700 border border-zinc-600 text-zinc-200 text-xs focus:outline-none focus:border-amber-400"
+							/>
+						</div>
+						<div class="flex flex-col gap-1">
+							<label for="range-to" class="text-xs text-zinc-500">To chapter (optional)</label>
+							<input
+								id="range-to"
+								type="number"
+								min="1"
+								bind:value={rangeTo}
+								placeholder="end"
+								class="w-24 px-2 py-1 rounded bg-zinc-700 border border-zinc-600 text-zinc-200 text-xs focus:outline-none focus:border-amber-400"
+							/>
+						</div>
+						<button
+							onclick={scrapeRange}
+							disabled={rangeScraping || !rangeFrom}
+							class="px-3 py-1.5 rounded text-xs font-medium transition-colors
+								{rangeScraping || !rangeFrom
+									? 'bg-zinc-700 text-zinc-500 cursor-not-allowed'
+									: 'bg-amber-500/20 text-amber-300 hover:bg-amber-500/40 border border-amber-500/30'}"
+						>
+							{rangeScraping ? 'Queuing…' : 'Scrape range'}
+						</button>
+						{#if rangeResult}
+							<span class="text-xs {rangeResult === 'queued' ? 'text-green-400' : rangeResult === 'busy' ? 'text-amber-400' : 'text-red-400'}">
+								{rangeResult === 'queued' ? 'Range scrape queued.' : rangeResult === 'busy' ? 'Scraper busy.' : 'Error queuing.'}
+							</span>
+						{/if}
+					</div>
+				</div>
+			{/if}
+		</div>
+	{/if}
 </div>

ui/src/routes/books/[slug]/chapters/[n]/+page.server.ts

@@ -77,6 +77,7 @@ export const load: PageServerLoad = async ({ params, url, locals }) => {
 			voices,
 			prev: null as number | null,
 			next: null as number | null,
+			chapters: [] as { number: number; title: string }[],
 			sessionId: locals.sessionId,
 			isPreview: true
 		};
@@ -129,6 +130,7 @@ export const load: PageServerLoad = async ({ params, url, locals }) => {
 		voices,
 		prev: prevChapter ? prevChapter.number : null,
 		next: nextChapter ? nextChapter.number : null,
+		chapters: chapters.map((c) => ({ number: c.number, title: c.title })),
 		sessionId: locals.sessionId,
 		isPreview: false
 	};

ui/src/routes/books/[slug]/chapters/[n]/+page.svelte

@@ -6,11 +6,19 @@
 
 	let { data }: { data: PageData } = $props();
 
-	// ── Live-fetch fallback when chapter text is missing in storage ───────────
 	let html = $state(data.html);
 	let fetchingContent = $state(!data.isPreview && !data.html);
 	let fetchError = $state('');
 
+	// ── Word count ────────────────────────────────────────────────────────────
+	function countWords(htmlStr: string | null): number {
+		if (!htmlStr) return 0;
+		// Strip HTML tags, collapse whitespace, split on whitespace
+		return htmlStr.replace(/<[^>]+>/g, ' ').trim().split(/\s+/).filter(Boolean).length;
+	}
+
+	const wordCount = $derived(countWords(html));
+
 	onMount(async () => {
 		// Record reading progress (skip for preview chapters)
 		if (!data.isPreview) {
@@ -60,7 +68,7 @@
 		<svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
 			<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 19l-7-7 7-7" />
 		</svg>
-		{data.book.title}
+		Chapters
 	</a>
 
 	<div class="flex gap-2">
@@ -85,12 +93,11 @@
 
 <!-- Chapter heading -->
 <div class="mb-6">
-	<p class="text-zinc-500 text-sm mb-1">Chapter {data.chapter.number}</p>
 	<h1 class="text-xl font-bold text-zinc-100">
 		{data.chapter.title || `Chapter ${data.chapter.number}`}
 	</h1>
-	{#if data.chapter.date_label}
-		<p class="text-zinc-600 text-xs mt-1">{data.chapter.date_label}</p>
+	{#if wordCount > 0}
+		<p class="text-zinc-600 text-xs mt-1">{wordCount.toLocaleString()} words</p>
 	{/if}
 </div>
 
@@ -103,6 +110,7 @@
 	bookTitle={data.book.title}
 	cover={data.book.cover}
 	nextChapter={data.next}
+	chapters={data.chapters}
 	voices={data.voices}
 />
 {:else}

ui/src/routes/disclaimer/+page.svelte

@@ -0,0 +1,34 @@
+<svelte:head>
+	<title>Disclaimer — libnovel</title>
+</svelte:head>
+
+<div class="max-w-2xl mx-auto py-10 px-4">
+	<h1 class="text-2xl font-bold text-zinc-100 mb-6">Disclaimer</h1>
+
+	<div class="space-y-5 text-sm text-zinc-400 leading-relaxed">
+		<p>
+			libnovel is a personal reading tool that indexes and caches publicly accessible novel content
+			from third-party sources, primarily <a href="https://novelfire.net" target="_blank" rel="noopener noreferrer" class="text-amber-400 hover:text-amber-300 transition-colors">novelfire.net</a>.
+			It is not affiliated with, endorsed by, or in any way officially connected to those sources.
+		</p>
+
+		<p>
+			All novel titles, cover images, chapter text, and related materials are the property of their
+			respective authors and publishers. libnovel does not claim ownership of any of this content.
+			The content is reproduced solely for personal, non-commercial reading convenience.
+		</p>
+
+		<p>
+			If you are a rights holder and believe your work is being used without authorisation, please
+			refer to our <a href="/dmca" class="text-amber-400 hover:text-amber-300 transition-colors">DMCA policy</a>
+			for instructions on how to request removal.
+		</p>
+
+		<p>
+			libnovel makes no warranties regarding the accuracy, completeness, or timeliness of any
+			content displayed. Use of this site is at your own risk.
+		</p>
+
+		<p class="text-zinc-600 text-xs mt-8">Last updated: {new Date().getFullYear()}</p>
+	</div>
+</div>

ui/src/routes/dmca/+page.svelte

@@ -0,0 +1,45 @@
+<svelte:head>
+	<title>DMCA — libnovel</title>
+</svelte:head>
+
+<div class="max-w-2xl mx-auto py-10 px-4">
+	<h1 class="text-2xl font-bold text-zinc-100 mb-6">DMCA Takedown Policy</h1>
+
+	<div class="prose-zinc space-y-5 text-sm text-zinc-400 leading-relaxed">
+		<p>
+			libnovel respects the intellectual property rights of authors, publishers, and other content
+			creators. If you believe that content available through this site infringes your copyright,
+			please send a written takedown notice to the contact address below.
+		</p>
+
+		<h2 class="text-base font-semibold text-zinc-200 mt-6">Your notice must include</h2>
+		<ol class="list-decimal list-inside space-y-2 pl-1">
+			<li>Your full legal name and contact information (email address).</li>
+			<li>A description of the copyrighted work you claim has been infringed.</li>
+			<li>The specific URL(s) on this site where the allegedly infringing content appears.</li>
+			<li>
+				A statement that you have a good-faith belief that the use is not authorised by the copyright
+				owner, its agent, or the law.
+			</li>
+			<li>
+				A statement, made under penalty of perjury, that the information in your notice is accurate
+				and that you are the copyright owner or authorised to act on their behalf.
+			</li>
+			<li>Your electronic or physical signature.</li>
+		</ol>
+
+		<h2 class="text-base font-semibold text-zinc-200 mt-6">How to submit</h2>
+		<p>
+			Send your notice by email to <span class="text-zinc-300 font-medium">dmca@libnovel.local</span>.
+			We will review valid notices and remove or disable access to the identified content promptly.
+		</p>
+
+		<h2 class="text-base font-semibold text-zinc-200 mt-6">Counter-notices</h2>
+		<p>
+			If you believe content was removed in error, you may submit a counter-notice to the same
+			address with the information required under 17 U.S.C. § 512(g)(3).
+		</p>
+
+		<p class="text-zinc-600 text-xs mt-8">Last updated: {new Date().getFullYear()}</p>
+	</div>
+</div>

ui/src/routes/login/+page.server.ts

@@ -1,8 +1,9 @@
 import { fail, redirect } from '@sveltejs/kit';
 import type { Actions, PageServerLoad } from './$types';
-import { loginUser, createUser, mergeSessionProgress } from '$lib/server/pocketbase';
+import { loginUser, createUser, mergeSessionProgress, createUserSession } from '$lib/server/pocketbase';
 import { createAuthToken } from '../../hooks.server';
 import { log } from '$lib/server/logger';
+import { randomBytes } from 'node:crypto';
 
 const AUTH_COOKIE = 'libnovel_auth';
 const ONE_YEAR = 60 * 60 * 24 * 365;
@@ -43,7 +44,20 @@ export const actions: Actions = {
 			log.warn('auth', 'login: mergeSessionProgress failed (non-fatal)', { err: String(err) })
 		);
 
-		const token = createAuthToken(user.id, user.username, user.role ?? 'user');
+		// Create a unique auth session ID for this login
+		const authSessionId = randomBytes(16).toString('hex');
+
+		// Record the session in PocketBase (best-effort, non-fatal)
+		const userAgent = request.headers.get('user-agent') ?? '';
+		const ip =
+			request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() ??
+			request.headers.get('x-real-ip') ??
+			'';
+		createUserSession(user.id, authSessionId, userAgent, ip).catch((err) =>
+			log.warn('auth', 'login: createUserSession failed (non-fatal)', { err: String(err) })
+		);
+
+		const token = createAuthToken(user.id, user.username, user.role ?? 'user', authSessionId);
 		cookies.set(AUTH_COOKIE, token, {
 			path: '/',
 			httpOnly: true,
@@ -102,7 +116,20 @@ export const actions: Actions = {
 			log.warn('auth', 'register: mergeSessionProgress failed (non-fatal)', { err: String(err) })
 		);
 
-		const token = createAuthToken(user.id, user.username, user.role ?? 'user');
+		// Create a unique auth session ID for this registration
+		const authSessionId = randomBytes(16).toString('hex');
+
+		// Record the session in PocketBase (best-effort, non-fatal)
+		const userAgent = request.headers.get('user-agent') ?? '';
+		const ip =
+			request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() ??
+			request.headers.get('x-real-ip') ??
+			'';
+		createUserSession(user.id, authSessionId, userAgent, ip).catch((err) =>
+			log.warn('auth', 'register: createUserSession failed (non-fatal)', { err: String(err) })
+		);
+
+		const token = createAuthToken(user.id, user.username, user.role ?? 'user', authSessionId);
 		cookies.set(AUTH_COOKIE, token, {
 			path: '/',
 			httpOnly: true,

ui/src/routes/privacy/+page.svelte

@@ -0,0 +1,55 @@
+<svelte:head>
+	<title>Privacy Policy — libnovel</title>
+</svelte:head>
+
+<div class="max-w-2xl mx-auto py-10 px-4">
+	<h1 class="text-2xl font-bold text-zinc-100 mb-6">Privacy Policy</h1>
+
+	<div class="space-y-5 text-sm text-zinc-400 leading-relaxed">
+		<p>
+			This policy describes what limited data libnovel collects and how it is used.
+		</p>
+
+		<h2 class="text-base font-semibold text-zinc-200 mt-6">Data we collect</h2>
+		<ul class="list-disc list-inside space-y-2 pl-1">
+			<li>
+				<span class="text-zinc-300">Session cookies</span> — a short-lived cookie is set when you
+				visit the site to track reading progress across pages. No account is required.
+			</li>
+			<li>
+				<span class="text-zinc-300">Account data (optional)</span> — if you create an account,
+				we store your username and a hashed password. No email address is required.
+			</li>
+			<li>
+				<span class="text-zinc-300">Reading progress</span> — the last chapter you read for each
+				book is stored server-side, tied to your session or account, so you can resume reading.
+			</li>
+			<li>
+				<span class="text-zinc-300">Saved books</span> — books you explicitly bookmark are stored
+				server-side tied to your session or account.
+			</li>
+		</ul>
+
+		<h2 class="text-base font-semibold text-zinc-200 mt-6">What we do not collect</h2>
+		<ul class="list-disc list-inside space-y-2 pl-1">
+			<li>No email addresses (unless you choose to provide one).</li>
+			<li>No tracking pixels, analytics scripts, or third-party ad networks.</li>
+			<li>No selling or sharing of data with third parties.</li>
+		</ul>
+
+		<h2 class="text-base font-semibold text-zinc-200 mt-6">Third-party content</h2>
+		<p>
+			Cover images and chapter content are fetched from third-party sources (e.g.
+			<a href="https://novelfire.net" target="_blank" rel="noopener noreferrer" class="text-amber-400 hover:text-amber-300 transition-colors">novelfire.net</a>).
+			Your browser may make requests directly to those domains when loading images.
+		</p>
+
+		<h2 class="text-base font-semibold text-zinc-200 mt-6">Data deletion</h2>
+		<p>
+			You can delete your reading progress and saved books from your profile page at any time.
+			To request full account deletion, contact us via the <a href="/dmca" class="text-amber-400 hover:text-amber-300 transition-colors">contact address listed in our DMCA policy</a>.
+		</p>
+
+		<p class="text-zinc-600 text-xs mt-8">Last updated: {new Date().getFullYear()}</p>
+	</div>
+</div>

ui/src/routes/profile/+page.server.ts

@@ -1,14 +1,30 @@
 import { fail, redirect } from '@sveltejs/kit';
 import type { Actions, PageServerLoad } from './$types';
-import { changePassword } from '$lib/server/pocketbase';
+import { changePassword, listUserSessions } from '$lib/server/pocketbase';
 import { log } from '$lib/server/logger';
 
 export const load: PageServerLoad = async ({ locals }) => {
 	if (!locals.user) {
 		redirect(302, '/login');
 	}
+
+	let sessions: Awaited<ReturnType<typeof listUserSessions>> = [];
+	try {
+		sessions = await listUserSessions(locals.user.id);
+	} catch (e) {
+		log.warn('profile', 'listUserSessions failed (non-fatal)', { err: String(e) });
+	}
+
 	return {
-		user: locals.user
+		user: locals.user,
+		sessions: sessions.map((s) => ({
+			id: s.id,
+			user_agent: s.user_agent,
+			ip: s.ip,
+			created_at: s.created_at,
+			last_seen: s.last_seen,
+			is_current: s.session_id === locals.user!.authSessionId
+		}))
 	};
 };
 

ui/src/routes/profile/+page.svelte

@@ -69,12 +69,81 @@
 			setTimeout(() => (pwSuccess = false), 3000);
 		}
 	});
+
+	// ── Sessions ────────────────────────────────────────────────────────────────
+	type Session = {
+		id: string;
+		user_agent: string;
+		ip: string;
+		created_at: string;
+		last_seen: string;
+		is_current: boolean;
+	};
+
+	let sessions = $state<Session[]>(data.sessions ?? []);
+	let revokingId = $state<string | null>(null);
+	let revokeError = $state('');
+
+	async function revokeSession(session: Session) {
+		revokingId = session.id;
+		revokeError = '';
+		try {
+			const res = await fetch(`/api/sessions/${session.id}`, { method: 'DELETE' });
+			if (!res.ok) {
+				revokeError = 'Failed to end session. Please try again.';
+				return;
+			}
+			if (session.is_current) {
+				// Ended our own session — submit the logout form to clear the cookie
+				const logoutForm = document.getElementById('logout-form') as HTMLFormElement | null;
+				if (logoutForm) {
+					logoutForm.submit();
+				}
+				return;
+			}
+			// Remove from local list
+			sessions = sessions.filter((s) => s.id !== session.id);
+		} catch {
+			revokeError = 'Network error. Please try again.';
+		} finally {
+			revokingId = null;
+		}
+	}
+
+	function formatDate(iso: string): string {
+		if (!iso) return '—';
+		try {
+			return new Intl.DateTimeFormat(undefined, {
+				dateStyle: 'medium',
+				timeStyle: 'short'
+			}).format(new Date(iso));
+		} catch {
+			return iso;
+		}
+	}
+
+	function parseUA(ua: string): string {
+		if (!ua) return 'Unknown browser';
+		// Very lightweight UA display — just show the most meaningful part
+		if (/Mobile/i.test(ua)) {
+			const match = ua.match(/\(([^)]+)\)/);
+			return match ? `Mobile — ${match[1].split(';')[0].trim()}` : 'Mobile device';
+		}
+		if (/Chrome\/(\d+)/i.test(ua)) return `Chrome ${ua.match(/Chrome\/(\d+)/i)![1]}`;
+		if (/Firefox\/(\d+)/i.test(ua)) return `Firefox ${ua.match(/Firefox\/(\d+)/i)![1]}`;
+		if (/Safari\/(\d+)/i.test(ua) && !/Chrome/i.test(ua)) return 'Safari';
+		if (/Edg\/(\d+)/i.test(ua)) return `Edge ${ua.match(/Edg\/(\d+)/i)![1]}`;
+		return ua.slice(0, 48) + (ua.length > 48 ? '…' : '');
+	}
 </script>
 
 <svelte:head>
 	<title>Profile — libnovel</title>
 </svelte:head>
 
+<!-- Hidden logout form used when user ends their own session -->
+<form id="logout-form" method="POST" action="/logout" class="hidden"></form>
+
 <div class="max-w-xl mx-auto space-y-10">
 	<div>
 		<h1 class="text-2xl font-bold text-zinc-100">Profile</h1>
@@ -151,6 +220,56 @@
 		</div>
 	</section>
 
+	<!-- ── Active sessions ──────────────────────────────────────────────────── -->
+	<section class="bg-zinc-800 rounded-xl border border-zinc-700 p-6 space-y-4">
+		<h2 class="text-lg font-semibold text-zinc-100">Active sessions</h2>
+		<p class="text-sm text-zinc-400">These are all devices currently signed into your account. End any session you don't recognise.</p>
+
+		{#if revokeError}
+			<div class="rounded-lg bg-red-900/40 border border-red-700 px-4 py-2.5 text-sm text-red-300">
+				{revokeError}
+			</div>
+		{/if}
+
+		{#if sessions.length === 0}
+			<p class="text-sm text-zinc-500 italic">No session records found. Sessions are tracked from the next login.</p>
+		{:else}
+			<ul class="space-y-2">
+				{#each sessions as session (session.id)}
+					<li class="flex items-start justify-between gap-3 rounded-lg px-4 py-3 {session.is_current ? 'bg-amber-400/10 border border-amber-400/30' : 'bg-zinc-700/50 border border-zinc-600/50'}">
+						<div class="min-w-0 space-y-0.5">
+							<div class="flex items-center gap-2 flex-wrap">
+								<span class="text-sm font-medium text-zinc-100 truncate">{parseUA(session.user_agent)}</span>
+								{#if session.is_current}
+									<span class="shrink-0 text-xs font-semibold px-1.5 py-0.5 rounded bg-amber-400/20 text-amber-300 border border-amber-400/40">This session</span>
+								{/if}
+							</div>
+							{#if session.ip}
+								<p class="text-xs text-zinc-400 font-mono">{session.ip}</p>
+							{/if}
+							<p class="text-xs text-zinc-500">
+								Signed in {formatDate(session.created_at)}
+								{#if session.last_seen && session.last_seen !== session.created_at}
+									· Last seen {formatDate(session.last_seen)}
+								{/if}
+							</p>
+						</div>
+						<button
+							onclick={() => revokeSession(session)}
+							disabled={revokingId === session.id}
+							class="shrink-0 px-3 py-1.5 rounded-lg text-xs font-medium transition-colors disabled:opacity-50
+								{session.is_current
+									? 'bg-red-900/40 text-red-300 border border-red-700/60 hover:bg-red-900/70'
+									: 'bg-zinc-600/60 text-zinc-300 border border-zinc-500/50 hover:bg-zinc-600'}"
+						>
+							{revokingId === session.id ? '…' : session.is_current ? 'Sign out' : 'End'}
+						</button>
+					</li>
+				{/each}
+			</ul>
+		{/if}
+	</section>
+
 	<!-- ── Change password ──────────────────────────────────────────────────── -->
 	<section class="bg-zinc-800 rounded-xl border border-zinc-700 p-6 space-y-4">
 		<h2 class="text-lg font-semibold text-zinc-100">Change password</h2>