fix: missing closing brace in setProgress function

- Add UserProfileView and UserProfileViewModel for iOS
- Implement user library API endpoint (/api/users/[username]/library)
- Add DELETE /api/progress/[slug] endpoint for removing books from library
- Integrate subscription feed in home API
- Update Xcode project with new profile components

.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,32 @@ 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 }}
+          build-args: |
+            VERSION=${{ gitea.sha }}
+            COMMIT=${{ 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,30 @@ 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 }}
+          build-args: |
+            BUILD_VERSION=${{ gitea.sha }}
+            BUILD_COMMIT=${{ gitea.sha }}

.gitea/workflows/deploy.yaml

@@ -1,134 +0,0 @@
-name: Deploy
-
-on:
-  push:
-    branches:
-      - "**"
-    paths:
-      - "scraper/**"
-      - "ui/**"
-      - "docker-compose.yml"
-  pull_request:
-    types: [closed]
-
-# tRPC API helper notes:
-#   Mutations: POST /api/trpc/<router>.<procedure>
-#              Body: {"0":{"json":{...input...}}}
-#              Header: x-api-key: <token>
-#   Queries:   GET  /api/trpc/<router>.<procedure>?batch=1&input={"0":{"json":{...input...}}}
-#              Header: x-api-key: <token>
-#   Response on success: HTTP 200, body: [{"result":{"data":{"json":{...}}}}]
-
-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')
-    steps:
-      - name: Redeploy production stack
-        run: |
-          RESPONSE=$(curl -s -w "\n%{http_code}" \
-            -X POST "${{ secrets.DOKPLOY_URL }}/api/trpc/compose.redeploy" \
-            -H "x-api-key: ${{ secrets.DOKPLOY_TOKEN }}" \
-            -H "Content-Type: application/json" \
-            -d '{"0":{"json":{"composeId":"${{ secrets.DOKPLOY_COMPOSE_ID }}"}}}')
-          HTTP_CODE=$(echo "$RESPONSE" | tail -1)
-          BODY=$(echo "$RESPONSE" | head -1)
-          echo "Status: $HTTP_CODE"
-          echo "Body: $BODY"
-          [ "$HTTP_CODE" = "200" ] || { echo "Redeploy failed"; exit 1; }
-
-  # ── preview deploy (feature branches) ────────────────────────────────────────
-  deploy-preview:
-    name: Deploy Preview
-    runs-on: ubuntu-latest
-    if: >
-      github.event_name == 'push' &&
-      github.ref != 'refs/heads/main' &&
-      github.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 }}" \
-            | tr '[:upper:]' '[:lower:]' \
-            | sed 's/[^a-z0-9]/-/g' \
-            | cut -c1-20 \
-            | sed 's/-*$//')
-          echo "suffix=$SUFFIX" >> $GITHUB_OUTPUT
-          echo "Preview suffix: $SUFFIX"
-
-      - name: Create or redeploy isolated preview stack
-        run: |
-          # compose.isolatedDeployment creates a new isolated copy of the compose stack
-          # suffixed with the branch name. If the stack already exists it redeploys it.
-          RESPONSE=$(curl -s -w "\n%{http_code}" \
-            -X POST "${{ secrets.DOKPLOY_URL }}/api/trpc/compose.isolatedDeployment" \
-            -H "x-api-key: ${{ secrets.DOKPLOY_TOKEN }}" \
-            -H "Content-Type: application/json" \
-            -d "{\"0\":{\"json\":{\"composeId\":\"${{ secrets.DOKPLOY_COMPOSE_ID }}\",\"suffix\":\"${{ steps.branch.outputs.suffix }}\"}}}")
-          HTTP_CODE=$(echo "$RESPONSE" | tail -1)
-          BODY=$(echo "$RESPONSE" | head -1)
-          echo "Status: $HTTP_CODE"
-          echo "Body: $BODY"
-          [ "$HTTP_CODE" = "200" ] || { echo "Preview deploy failed"; exit 1; }
-
-  # ── cleanup preview on PR close ───────────────────────────────────────────────
-  cleanup-preview:
-    name: Cleanup Preview
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request' && github.event.action == 'closed'
-    steps:
-      - name: Sanitize branch name
-        id: branch
-        run: |
-          SUFFIX=$(echo "${{ github.head_ref }}" \
-            | tr '[:upper:]' '[:lower:]' \
-            | sed 's/[^a-z0-9]/-/g' \
-            | cut -c1-20 \
-            | sed 's/-*$//')
-          echo "suffix=$SUFFIX" >> $GITHUB_OUTPUT
-          echo "Cleaning up preview suffix: $SUFFIX"
-
-      - name: Search for preview compose stack by appName
-        id: find
-        run: |
-          # compose.search is a tRPC query (GET). We search by appName pattern.
-          # appName is set by Dokploy as "<base-appName>-<suffix>" for isolated deployments.
-          INPUT=$(python3 -c "import json,sys; print(json.dumps({'0':{'json':{'appName':'libnovel-${{ steps.branch.outputs.suffix }}','limit':5,'offset':0}}}))")
-          RESPONSE=$(curl -s -w "\n%{http_code}" -G \
-            "${{ secrets.DOKPLOY_URL }}/api/trpc/compose.search" \
-            -H "x-api-key: ${{ secrets.DOKPLOY_TOKEN }}" \
-            --data-urlencode "batch=1" \
-            --data-urlencode "input=$INPUT")
-          HTTP_CODE=$(echo "$RESPONSE" | tail -1)
-          BODY=$(echo "$RESPONSE" | head -1)
-          echo "Status: $HTTP_CODE"
-          echo "Body: $BODY"
-          # Extract the first composeId from the JSON response array
-          COMPOSE_ID=$(echo "$BODY" | python3 -c "
-          import json,sys
-          data = json.load(sys.stdin)
-          items = data[0]['result']['data']['json']['items']
-          print(items[0]['composeId'] if items else '')
-          " 2>/dev/null || echo "")
-          echo "composeId=$COMPOSE_ID" >> $GITHUB_OUTPUT
-          echo "Found composeId: $COMPOSE_ID"
-
-      - name: Delete preview stack
-        if: steps.find.outputs.composeId != ''
-        run: |
-          RESPONSE=$(curl -s -w "\n%{http_code}" \
-            -X POST "${{ secrets.DOKPLOY_URL }}/api/trpc/compose.delete" \
-            -H "x-api-key: ${{ secrets.DOKPLOY_TOKEN }}" \
-            -H "Content-Type: application/json" \
-            -d "{\"0\":{\"json\":{\"composeId\":\"${{ steps.find.outputs.composeId }}\",\"deleteVolumes\":true}}}")
-          HTTP_CODE=$(echo "$RESPONSE" | tail -1)
-          BODY=$(echo "$RESPONSE" | head -1)
-          echo "Status: $HTTP_CODE"
-          echo "Body: $BODY"
-          [ "$HTTP_CODE" = "200" ] || { echo "Delete failed"; exit 1; }

.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-scraper.yaml

@@ -0,0 +1,68 @@
+name: Release / Scraper
+
+on:
+  push:
+    tags:
+      - "v*"
+
+concurrency:
+  group: ${{ gitea.workflow }}-${{ gitea.ref }}
+  cancel-in-progress: true
+
+jobs:
+  # ── lint & test ──────────────────────────────────────────────────────────────
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: scraper/go.mod
+          cache-dependency-path: scraper/go.sum
+
+      - name: go vet
+        working-directory: scraper
+        run: |
+          go vet ./...
+          go vet -tags integration ./...
+
+      - name: Run tests
+        working-directory: scraper
+        run: go test -short -race -count=1 -timeout=60s ./...
+
+  # ── docker build & push ──────────────────────────────────────────────────────
+  docker:
+    name: Docker
+    runs-on: ubuntu-latest
+    needs: [test]
+    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: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ secrets.DOCKER_USER }}/libnovel-scraper
+          tags: |
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=raw,value=latest
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: scraper
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          build-args: |
+            VERSION=${{ steps.meta.outputs.version }}
+            COMMIT=${{ gitea.sha }}

.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,32 @@ 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 }}
+          build-args: |
+            BUILD_VERSION=${{ steps.meta.outputs.version }}
+            BUILD_COMMIT=${{ gitea.sha }}

docker-compose.yml

@@ -35,6 +35,7 @@ services:
         mc mb --ignore-existing local/libnovel-chapters;
         mc mb --ignore-existing local/libnovel-audio;
         mc mb --ignore-existing local/libnovel-browse;
+        mc mb --ignore-existing local/libnovel-avatars;
         echo 'buckets ready';
       "
     environment:
@@ -81,6 +82,9 @@ services:
     build:
       context: ./scraper
       dockerfile: Dockerfile
+      args:
+        VERSION: "${GIT_TAG:-dev}"
+        COMMIT: "${GIT_COMMIT:-unknown}"
     #container_name: libnovel-scraper
     restart: unless-stopped
     depends_on:
@@ -106,6 +110,7 @@ services:
       MINIO_BUCKET_CHAPTERS: "${MINIO_BUCKET_CHAPTERS:-libnovel-chapters}"
       MINIO_BUCKET_AUDIO: "${MINIO_BUCKET_AUDIO:-libnovel-audio}"
       MINIO_BUCKET_BROWSE: "${MINIO_BUCKET_BROWSE:-libnovel-browse}"
+      MINIO_BUCKET_AVATARS: "${MINIO_BUCKET_AVATARS:-libnovel-avatars}"
       # Public endpoint used to sign presigned audio URLs so browsers can reach them.
       # Leave empty to use MINIO_ENDPOINT (fine for local dev).
       MINIO_PUBLIC_ENDPOINT: "${MINIO_PUBLIC_ENDPOINT:-}"
@@ -129,6 +134,9 @@ services:
     build:
       context: ./ui
       dockerfile: Dockerfile
+      args:
+        BUILD_VERSION: "${GIT_TAG:-dev}"
+        BUILD_COMMIT: "${GIT_COMMIT:-unknown}"
     #   container_name: libnovel-ui
     restart: unless-stopped
     depends_on:
@@ -147,7 +155,7 @@ services:
     ports:
       - "${UI_PORT:-5252}:3000"
     healthcheck:
-      test: ["CMD", "wget", "-qO-", "http://localhost:3000/"]
+      test: ["CMD", "wget", "-qO-", "http://127.0.0.1:3000/health"]
       interval: 15s
       timeout: 5s
       retries: 3

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</string>
+	<key>teamID</key>
+	<string>GHZXC6FVMU</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,730 @@
+// !$*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 */; };
+		41FB51553F1F1AEBFEA91C0A /* String+App.swift in Sources */ = {isa = PBXBuildFile; fileRef = FEC6F837FF2E902E334ED72E /* String+App.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 */; };
+		A1C3F2B84D9E72A1BC054F17 /* CommentsView.swift in Sources */ = {isa = PBXBuildFile; fileRef = B2E8D1C74A3F91D0E5C72A38 /* CommentsView.swift */; };
+		A2F1C3B84E9D71A0BC164F28 /* AccountMenuSheet.swift in Sources */ = {isa = PBXBuildFile; fileRef = B3E9D2C85A4F02E1F63B5A49 /* AccountMenuSheet.swift */; };
+		A9B95BAD7CE2DCD1DDDABD4C /* AudioPlayerService.swift in Sources */ = {isa = PBXBuildFile; fileRef = DB13E89E50529E3081533A66 /* AudioPlayerService.swift */; };
+		AA11BB22CC33DD44EE55FF66 /* UserProfileView.swift in Sources */ = {isa = PBXBuildFile; fileRef = AA11BB22CC33DD44EE55FF67 /* UserProfileView.swift */; };
+		BB22CC33DD44EE55FF66AA11 /* UserProfileViewModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = BB22CC33DD44EE55FF66AA12 /* UserProfileViewModel.swift */; };
+		BE7805A4E78037A82B12AE56 /* PlayerViews.swift in Sources */ = {isa = PBXBuildFile; fileRef = DF49C3AEF9D010F9FEDAB1FC /* PlayerViews.swift */; };
+		C3D7A2E15F8B04C9AB163D50 /* AvatarCropView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D4F1B8A26E3C97D0F52A4B71 /* AvatarCropView.swift */; };
+		C807AD8D627CF6BED47D517C /* HomeViewModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3AB2E843D93461074A89A171 /* HomeViewModel.swift */; };
+		CFDAA4776344B075A1E3CD6B /* Kingfisher in Frameworks */ = {isa = PBXBuildFile; productRef = 09584EAB68A07B47F876A062 /* Kingfisher */; };
+		D5E2A1C96F3B08D0F74C6B50 /* SearchView.swift in Sources */ = {isa = PBXBuildFile; fileRef = C4F0A3B75E2D19C0E85A7B61 /* SearchView.swift */; };
+		E1F564399D1325F6A1B2B84F /* LibraryView.swift in Sources */ = {isa = PBXBuildFile; fileRef = C21107BECA55C07416E0CB8B /* LibraryView.swift */; };
+		E2572692178FD17145FDAF77 /* Color+App.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9D83BB88C4306BE7A4F947CB /* Color+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; explicitFileType = wrapper.cfbundle; includeInIndex = 0; 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>"; };
+		AA11BB22CC33DD44EE55FF67 /* UserProfileView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UserProfileView.swift; sourceTree = "<group>"; };
+		B2E8D1C74A3F91D0E5C72A38 /* CommentsView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CommentsView.swift; sourceTree = "<group>"; };
+		B3E9D2C85A4F02E1F63B5A49 /* AccountMenuSheet.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AccountMenuSheet.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>"; };
+		BB22CC33DD44EE55FF66AA12 /* UserProfileViewModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UserProfileViewModel.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>"; };
+		C4F0A3B75E2D19C0E85A7B61 /* SearchView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SearchView.swift; sourceTree = "<group>"; };
+		D4F1B8A26E3C97D0F52A4B71 /* AvatarCropView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AvatarCropView.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>"; };
+		FEC6F837FF2E902E334ED72E /* String+App.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "String+App.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 */,
+				E6A2B4C07F1D38E0A95B3C72 /* Search */,
+			);
+			path = Views;
+			sourceTree = "<group>";
+		};
+		2F18D1275D6022B9847E310E /* Auth */ = {
+			isa = PBXGroup;
+			children = (
+				7CEF6782A2A28B2A485CBD48 /* AuthView.swift */,
+			);
+			path = Auth;
+			sourceTree = "<group>";
+		};
+		3DB66C5703A4CCAFFA1B7AFE /* Profile */ = {
+			isa = PBXGroup;
+			children = (
+				C0B17D50389C6C98FC78BDBC /* ProfileView.swift */,
+				D4F1B8A26E3C97D0F52A4B71 /* AvatarCropView.swift */,
+				B3E9D2C85A4F02E1F63B5A49 /* AccountMenuSheet.swift */,
+				AA11BB22CC33DD44EE55FF67 /* UserProfileView.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 */,
+				BB22CC33DD44EE55FF66AA12 /* UserProfileViewModel.swift */,
+			);
+			path = ViewModels;
+			sourceTree = "<group>";
+		};
+		DA6F6F625578875F3E74F1D3 /* Services */ = {
+			isa = PBXGroup;
+			children = (
+				DB13E89E50529E3081533A66 /* AudioPlayerService.swift */,
+				F219788AE5ACBD6F240674F5 /* AuthStore.swift */,
+			);
+			path = Services;
+			sourceTree = "<group>";
+		};
+		E6A2B4C07F1D38E0A95B3C72 /* Search */ = {
+			isa = PBXGroup;
+			children = (
+				C4F0A3B75E2D19C0E85A7B61 /* SearchView.swift */,
+			);
+			path = Search;
+			sourceTree = "<group>";
+		};
+		FA994FD601E79EC811D822A4 /* Library */ = {
+			isa = PBXGroup;
+			children = (
+				C21107BECA55C07416E0CB8B /* LibraryView.swift */,
+			);
+			path = Library;
+			sourceTree = "<group>";
+		};
+		FB5C0D4925633786D28C6DE3 /* BookDetail */ = {
+			isa = PBXGroup;
+			children = (
+				39DE056C37FBC5EED8771821 /* BookDetailView.swift */,
+				B2E8D1C74A3F91D0E5C72A38 /* CommentsView.swift */,
+			);
+			path = BookDetail;
+			sourceTree = "<group>";
+		};
+		FD5EDEE9747643D45CA6423E /* Extensions */ = {
+			isa = PBXGroup;
+			children = (
+				9D83BB88C4306BE7A4F947CB /* Color+App.swift */,
+				7CAFB96D2500F34F0B0C860C /* NavDestination.swift */,
+				FEC6F837FF2E902E334ED72E /* 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 = 2630;
+			};
+			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 */,
+				A1C3F2B84D9E72A1BC054F17 /* CommentsView.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 */,
+				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 */,
+				C3D7A2E15F8B04C9AB163D50 /* AvatarCropView.swift in Sources */,
+				A2F1C3B84E9D71A0BC164F28 /* AccountMenuSheet.swift in Sources */,
+				58E440CE4360D755401D1672 /* ProfileViewModel.swift in Sources */,
+				AA11BB22CC33DD44EE55FF66 /* UserProfileView.swift in Sources */,
+				BB22CC33DD44EE55FF66AA11 /* UserProfileViewModel.swift in Sources */,
+				367C88FFC11701D2BAD8CCD0 /* RootTabView.swift in Sources */,
+				D5E2A1C96F3B08D0F74C6B50 /* SearchView.swift in Sources */,
+				41FB51553F1F1AEBFEA91C0A /* String+App.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 = com.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 = com.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 = "Apple Development";
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				DEVELOPMENT_TEAM = GHZXC6FVMU;
+				GENERATE_INFOPLIST_FILE = NO;
+				INFOPLIST_FILE = LibNovel/Resources/Info.plist;
+				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.books";
+				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				MARKETING_VERSION = 1.0.1;
+				PRODUCT_BUNDLE_IDENTIFIER = com.kalekber.LibNovel;
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				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 = 1000;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_PREVIEWS = YES;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = 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;
+				STRING_CATALOG_GENERATE_SYMBOLS = YES;
+				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 = "Apple Development";
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Distribution";
+				CODE_SIGN_STYLE = Manual;
+				CURRENT_PROJECT_VERSION = 1;
+				DEVELOPMENT_TEAM = "";
+				"DEVELOPMENT_TEAM[sdk=iphoneos*]" = GHZXC6FVMU;
+				GENERATE_INFOPLIST_FILE = NO;
+				INFOPLIST_FILE = LibNovel/Resources/Info.plist;
+				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.books";
+				IPHONEOS_DEPLOYMENT_TARGET = 17.0;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				MARKETING_VERSION = 1.0.1;
+				PRODUCT_BUNDLE_IDENTIFIER = com.kalekber.LibNovel;
+				PROVISIONING_PROFILE = "af592c3a-f60b-4ac1-a14f-30b8a206017f";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				"PROVISIONING_PROFILE_SPECIFIER[sdk=iphoneos*]" = "LibNovel Distribution";
+				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 = 1000;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_PREVIEWS = YES;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = 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;
+				STRING_CATALOG_GENERATE_SYMBOLS = YES;
+				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" : "ad75ae2d3b8d8b80d99635f65213a3c1092464aa54a86354f850b8317b6fa240",
+  "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,105 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "2630"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <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">
+      <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>
+   </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>
+      <EnvironmentVariables>
+         <EnvironmentVariable
+            key = "LIBNOVEL_BASE_URL"
+            value = "[&quot;value&quot;: &quot;https://v2.libnovel.kalekber.cc&quot;, &quot;isEnabled&quot;: true]"
+            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>
+   </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,99 @@
+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
+    @State private var showCompactControls: 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, search
+    }
+
+    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)
+
+                SearchView()
+                    .tabItem { Label("Search", systemImage: "magnifyingglass") }
+                    .tag(Tab.search)
+            }
+
+            // Floating circular player button (hidden while full player is open)
+            if audioPlayer.isActive && !showFullPlayer {
+                ZStack {
+                    // Compact controls overlay (bottom sheet)
+                    if showCompactControls {
+                        CompactPlayerControls(isPresented: $showCompactControls)
+                            .transition(.move(edge: .bottom).combined(with: .opacity))
+                    }
+                    
+                    // Floating button (always on top)
+                    FloatingPlayerButton(
+                        showFullPlayer: $showFullPlayer,
+                        showControls: $showCompactControls
+                    )
+                }
+                .transition(.scale.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)
+        .animation(.spring(response: 0.3, dampingFraction: 0.7), value: showCompactControls)
+    }
+}

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,104 @@
+import SwiftUI
+
+// MARK: - Navigation destination enum used across all tabs
+
+enum NavDestination: Hashable {
+    case book(String)               // slug
+    case chapter(String, Int)       // slug + chapter number
+    case userProfile(String)        // username
+}
+
+// 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 {
+        modifier(AppNavigationDestinationModifier())
+    }
+
+    /// 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 ?? "")
+        }
+    }
+}
+
+// MARK: - Navigation destination modifier
+
+private struct AppNavigationDestinationModifier: ViewModifier {
+    @Namespace private var zoomNamespace
+
+    func body(content: Content) -> some View {
+        if #available(iOS 18.0, *) {
+            content
+                .navigationDestination(for: NavDestination.self) { dest in
+                    switch dest {
+                    case .book(let slug):
+                        BookDetailView(slug: slug)
+                            .navigationTransition(.zoom(sourceID: slug, in: zoomNamespace))
+                    case .chapter(let slug, let n):
+                        ChapterReaderView(slug: slug, chapterNumber: n)
+                    case .userProfile(let username):
+                        UserProfileView(username: username)
+                    }
+                }
+                // Expose namespace to child views via environment
+                .environment(\.bookZoomNamespace, zoomNamespace)
+        } else {
+            content
+                .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)
+                    case .userProfile(let username): UserProfileView(username: username)
+                    }
+                }
+        }
+    }
+}
+
+// MARK: - Environment key for zoom namespace
+
+struct BookZoomNamespaceKey: EnvironmentKey {
+    static var defaultValue: Namespace.ID? { nil }
+}
+
+extension EnvironmentValues {
+    var bookZoomNamespace: Namespace.ID? {
+        get { self[BookZoomNamespaceKey.self] }
+        set { self[BookZoomNamespaceKey.self] = newValue }
+    }
+}
+
+// MARK: - Cover card zoom source modifier
+
+/// Apply this to any cover image that should be a zoom source for book navigation.
+/// Falls back to a no-op on iOS 17 or when no namespace is available.
+struct BookCoverZoomSource: ViewModifier {
+    let slug: String
+    @Environment(\.bookZoomNamespace) private var namespace
+
+    func body(content: Content) -> some View {
+        if #available(iOS 18.0, *), let ns = namespace {
+            content.matchedTransitionSource(id: slug, in: ns)
+        } else {
+            content
+        }
+    }
+}
+
+extension View {
+    /// Marks a cover image as the zoom source for a book's navigation transition.
+    func bookCoverZoomSource(slug: String) -> some View {
+        modifier(BookCoverZoomSource(slug: slug))
+    }
+}
+

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

@@ -0,0 +1,41 @@
+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
+    }
+}

ios/LibNovel/LibNovel/Models/Models.swift

@@ -0,0 +1,395 @@
+import Foundation
+import SwiftUI
+
+// 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: - 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: - Reading Display Settings (local only — stored in UserDefaults)
+
+enum ReaderTheme: String, CaseIterable, Codable {
+    case white, sepia, night
+
+    var backgroundColor: Color {
+        switch self {
+        case .white: return Color(.sRGB, white: 1.0, opacity: 1)
+        case .sepia:  return Color(red: 0.97, green: 0.93, blue: 0.82)
+        case .night:  return Color(red: 0.10, green: 0.10, blue: 0.12)
+        }
+    }
+
+    var textColor: Color {
+        switch self {
+        case .white: return Color(.sRGB, white: 0.1, opacity: 1)
+        case .sepia:  return Color(red: 0.25, green: 0.18, blue: 0.08)
+        case .night:  return Color(red: 0.85, green: 0.85, blue: 0.87)
+        }
+    }
+
+    var colorScheme: ColorScheme? {
+        switch self {
+        case .white: return nil          // follows system
+        case .sepia:  return .light
+        case .night:  return .dark
+        }
+    }
+}
+
+enum ReaderFont: String, CaseIterable, Codable {
+    case system    = "System"
+    case georgia   = "Georgia"
+    case newYork   = "New York"
+
+    var fontName: String? {
+        switch self {
+        case .system:  return nil
+        case .georgia: return "Georgia"
+        case .newYork: return "NewYorkMedium-Regular"
+        }
+    }
+}
+
+struct ReaderSettings: Codable, Equatable {
+    var fontSize: CGFloat
+    var lineSpacing: CGFloat
+    var font: ReaderFont
+    var theme: ReaderTheme
+    var scrollMode: Bool
+
+    static let `default` = ReaderSettings(
+        fontSize: 17,
+        lineSpacing: 1.7,
+        font: .system,
+        theme: .white,
+        scrollMode: false
+    )
+
+    static let userDefaultsKey = "readerSettings"
+
+    static func load() -> ReaderSettings {
+        guard let data = UserDefaults.standard.data(forKey: userDefaultsKey),
+              let decoded = try? JSONDecoder().decode(ReaderSettings.self, from: data)
+        else { return .default }
+        return decoded
+    }
+
+    func save() {
+        if let data = try? JSONEncoder().encode(self) {
+            UserDefaults.standard.set(data, forKey: ReaderSettings.userDefaultsKey)
+        }
+    }
+}
+
+// MARK: - User
+
+struct AppUser: Codable, Identifiable {
+    let id: String
+    let username: String
+    let role: String
+    let created: String
+    let avatarURL: String?
+
+    var isAdmin: Bool { role == "admin" }
+
+    enum CodingKeys: String, CodingKey {
+        case id, username, role, created
+        case avatarURL = "avatar_url"
+    }
+
+    init(id: String, username: String, role: String, created: String, avatarURL: String?) {
+        self.id = id
+        self.username = username
+        self.role = role
+        self.created = created
+        self.avatarURL = avatarURL
+    }
+
+    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) ?? ""
+        avatarURL = try c.decodeIfPresent(String.self, forKey: .avatarURL)
+    }
+}
+
+// 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 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: - Comments
+
+struct BookComment: Identifiable, Codable, Hashable {
+    let id: String
+    let slug: String
+    let userId: String
+    let username: String
+    let body: String
+    var upvotes: Int
+    var downvotes: Int
+    let created: String
+    let parentId: String   // empty = top-level; non-empty = reply
+    var replies: [BookComment]? // populated client-side from the API response
+
+    enum CodingKeys: String, CodingKey {
+        case id, slug, username, body, upvotes, downvotes, created, replies
+        case userId = "user_id"
+        case parentId = "parent_id"
+    }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        id        = try c.decode(String.self, forKey: .id)
+        slug      = try c.decodeIfPresent(String.self, forKey: .slug) ?? ""
+        userId    = try c.decodeIfPresent(String.self, forKey: .userId) ?? ""
+        username  = try c.decodeIfPresent(String.self, forKey: .username) ?? ""
+        body      = try c.decodeIfPresent(String.self, forKey: .body) ?? ""
+        upvotes   = try c.decodeIfPresent(Int.self, forKey: .upvotes) ?? 0
+        downvotes = try c.decodeIfPresent(Int.self, forKey: .downvotes) ?? 0
+        created   = try c.decodeIfPresent(String.self, forKey: .created) ?? ""
+        parentId  = try c.decodeIfPresent(String.self, forKey: .parentId) ?? ""
+        replies   = try c.decodeIfPresent([BookComment].self, forKey: .replies)
+    }
+}
+
+struct CommentsResponse: Decodable {
+    let comments: [BookComment]
+    let myVotes: [String: String]
+    let avatarUrls: [String: String]
+
+    enum CodingKeys: String, CodingKey {
+        case comments
+        case myVotes = "myVotes"
+        case avatarUrls = "avatarUrls"
+    }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        comments   = try c.decode([BookComment].self, forKey: .comments)
+        myVotes    = try c.decodeIfPresent([String: String].self, forKey: .myVotes) ?? [:]
+        avatarUrls = try c.decodeIfPresent([String: String].self, forKey: .avatarUrls) ?? [:]
+    }
+}
+
+// MARK: - User Profile (public)
+
+struct PublicUserProfile: Decodable, Identifiable {
+    let id: String
+    let username: String
+    let avatarUrl: String?
+    let created: String
+    let followerCount: Int
+    let followingCount: Int
+    let isSubscribed: Bool
+    let isSelf: Bool
+
+    enum CodingKeys: String, CodingKey {
+        case id, username, created
+        case avatarUrl = "avatarUrl"
+        case followerCount = "followerCount"
+        case followingCount = "followingCount"
+        case isSubscribed = "isSubscribed"
+        case isSelf = "isSelf"
+    }
+
+    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)
+        avatarUrl     = try c.decodeIfPresent(String.self, forKey: .avatarUrl)
+        created       = try c.decodeIfPresent(String.self, forKey: .created) ?? ""
+        followerCount = try c.decodeIfPresent(Int.self, forKey: .followerCount) ?? 0
+        followingCount = try c.decodeIfPresent(Int.self, forKey: .followingCount) ?? 0
+        isSubscribed  = try c.decodeIfPresent(Bool.self, forKey: .isSubscribed) ?? false
+        isSelf        = try c.decodeIfPresent(Bool.self, forKey: .isSelf) ?? false
+    }
+}
+
+// MARK: - Subscription Feed
+
+struct SubscriptionFeedItem: Identifiable, Decodable {
+    var id: String { book.id + readerUsername }
+    let book: Book
+    let readerUsername: String
+
+    enum CodingKeys: String, CodingKey {
+        case book
+        case readerUsername = "readerUsername"
+    }
+}
+
+// MARK: - Public User Library
+
+struct PublicLibraryItem: Decodable, Identifiable {
+    var id: String { book.id }
+    let book: Book
+    let lastChapter: Int?
+    let saved: Bool
+
+    enum CodingKeys: String, CodingKey {
+        case book
+        case lastChapter = "last_chapter"
+        case saved
+    }
+}
+
+struct PublicUserLibraryResponse: Decodable {
+    let currentlyReading: [PublicLibraryItem]
+    let library: [PublicLibraryItem]
+
+    enum CodingKeys: String, CodingKey {
+        case currentlyReading = "currently_reading"
+        case library
+    }
+}
+
+// MARK: - Audio
+
+enum NextPrefetchStatus {
+    case none, prefetching, prefetched, failed
+}

ios/LibNovel/LibNovel/Networking/APIClient.swift

@@ -0,0 +1,580 @@
+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
+
+    // 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) }
+        }
+    }
+
+    // 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)
+        }
+    }
+
+    /// Like `fetch` but discards the response body — use for endpoints that return 204 No Content.
+    func fetchVoid(_ path: String, method: String = "GET", body: Encodable? = nil) async throws {
+        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
+        }
+        guard (200..<300).contains(http.statusCode) else {
+            let rawBody = String(data: data, encoding: .utf8) ?? "<non-utf8 data, \(data.count) bytes>"
+            throw APIError.httpError(http.statusCode, rawBody)
+        }
+    }
+
+    // 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 _: EmptyResponse = try await fetch("/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
+
+    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 deleteProgress(slug: String) async throws {
+        let _: EmptyResponse = try await fetch("/api/progress/\(slug)", method: "DELETE")
+    }
+
+    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: - Avatar
+
+    struct AvatarPresignResponse: Decodable {
+        let uploadURL: String
+        let key: String
+        enum CodingKeys: String, CodingKey { case uploadURL = "upload_url"; case key }
+    }
+
+    struct AvatarResponse: Decodable {
+        let avatarURL: String?
+        enum CodingKeys: String, CodingKey { case avatarURL = "avatar_url" }
+    }
+
+    /// Upload a profile avatar using a two-step presigned PUT flow:
+    /// 1. POST /api/profile/avatar → get a presigned PUT URL + object key
+    /// 2. PUT image bytes directly to MinIO via the presigned URL
+    /// 3. PATCH /api/profile/avatar with the key to record it in PocketBase
+    /// Returns the presigned GET URL for the uploaded avatar.
+    func uploadAvatar(_ imageData: Data, mimeType: String = "image/jpeg") async throws -> String? {
+        // Step 1: request a presigned PUT URL from the SvelteKit server
+        let presign: AvatarPresignResponse = try await fetch(
+            "/api/profile/avatar",
+            method: "POST",
+            body: ["mime_type": mimeType]
+        )
+
+        // Step 2: PUT the image bytes directly to MinIO
+        guard let putURL = URL(string: presign.uploadURL) else { throw APIError.invalidResponse }
+        var putReq = URLRequest(url: putURL)
+        putReq.httpMethod = "PUT"
+        putReq.setValue(mimeType, forHTTPHeaderField: "Content-Type")
+        putReq.httpBody = imageData
+
+        let (_, putResp) = try await session.data(for: putReq)
+        guard let putHttp = putResp as? HTTPURLResponse,
+              (200..<300).contains(putHttp.statusCode) else {
+            let code = (putResp as? HTTPURLResponse)?.statusCode ?? 0
+            throw APIError.httpError(code, "MinIO PUT failed")
+        }
+
+        // Step 3: record the key in PocketBase and get back a presigned GET URL
+        let result: AvatarResponse = try await fetch(
+            "/api/profile/avatar",
+            method: "PATCH",
+            body: ["key": presign.key]
+        )
+        return result.avatarURL
+    }
+
+    /// Fetches a fresh presigned GET URL for the current user's avatar.
+    /// Returns nil if the user has no avatar set.
+    /// Used on cold launch / session restore to convert the stored raw key into a viewable URL.
+    func fetchAvatarPresignedURL() async throws -> String? {
+        let result: AvatarResponse = try await fetch("/api/profile/avatar")
+        return result.avatarURL
+    }
+
+    // MARK: - User Profiles & Subscriptions
+
+    func fetchUserProfile(username: String) async throws -> PublicUserProfile {
+        try await fetch("/api/users/\(username)")
+    }
+
+    @discardableResult
+    func subscribeUser(username: String) async throws -> Bool {
+        struct Response: Decodable { let subscribed: Bool }
+        let r: Response = try await fetch("/api/users/\(username)/subscribe", method: "POST")
+        return r.subscribed
+    }
+
+    @discardableResult
+    func unsubscribeUser(username: String) async throws -> Bool {
+        struct Response: Decodable { let subscribed: Bool }
+        let r: Response = try await fetch("/api/users/\(username)/subscribe", method: "DELETE")
+        return r.subscribed
+    }
+
+    func fetchUserLibrary(username: String) async throws -> PublicUserLibraryResponse {
+        try await fetch("/api/users/\(username)/library")
+    }
+
+    // MARK: - Comments
+
+    func fetchComments(slug: String, sort: String = "top") async throws -> CommentsResponse {
+        try await fetch("/api/comments/\(slug)?sort=\(sort)")
+    }
+
+    struct PostCommentBody: Encodable {
+        let body: String
+        let parent_id: String?
+    }
+
+    func postComment(slug: String, body: String, parentId: String? = nil) async throws -> BookComment {
+        try await fetch("/api/comments/\(slug)", method: "POST", body: PostCommentBody(body: body, parent_id: parentId))
+    }
+
+    struct VoteBody: Encodable { let vote: String }
+
+    /// Cast, change, or toggle-off a vote on a comment.
+    /// Returns the updated BookComment (with refreshed upvotes/downvotes counts).
+    func voteComment(commentId: String, vote: String) async throws -> BookComment {
+        try await fetch("/api/comment/\(commentId)/vote", method: "POST", body: VoteBody(vote: vote))
+    }
+
+    /// Delete a comment (and its replies) by ID. Only the owner can delete.
+    func deleteComment(commentId: String) async throws {
+        try await fetchVoid("/api/comment/\(commentId)", 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
+    let subscriptionFeed: [SubscriptionFeedItem]
+
+    enum CodingKeys: String, CodingKey {
+        case continueReading = "continue_reading"
+        case recentlyUpdated = "recently_updated"
+        case stats
+        case subscriptionFeed = "subscription_feed"
+    }
+
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        continueReading  = try c.decodeIfPresent([ContinueItem].self, forKey: .continueReading) ?? []
+        recentlyUpdated  = try c.decodeIfPresent([Book].self, forKey: .recentlyUpdated) ?? []
+        stats            = try c.decode(HomeStats.self, forKey: .stats)
+        subscriptionFeed = try c.decodeIfPresent([SubscriptionFeedItem].self, forKey: .subscriptionFeed) ?? []
+    }
+}
+
+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
+}
+
+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,45 @@
+<?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>CFBundleDisplayName</key>
+	<string>LibNovel</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleName</key>
+	<string>LibNovel</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>$(MARKETING_VERSION)</string>
+	<key>CFBundleVersion</key>
+	<string>1000</string>
+	<key>LIBNOVEL_BASE_URL</key>
+	<string>$(LIBNOVEL_BASE_URL)</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UIBackgroundModes</key>
+	<array>
+		<string>audio</string>
+		<string>fetch</string>
+		<string>processing</string>
+	</array>
+	<key>UILaunchScreen</key>
+	<dict/>
+	<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>
+</dict>
+</plist>

ios/LibNovel/LibNovel/Services/AudioPlayerService.swift

@@ -0,0 +1,616 @@
+import Foundation
+import AVFoundation
+import MediaPlayer
+import Combine
+import Kingfisher
+
+// 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
+    /// Human-readable countdown string shown in the full player near the moon button.
+    /// e.g. "38:12" for minute-based, "2 ch left" for chapter-based, "" when off.
+    @Published var sleepTimerRemainingText: String = ""
+
+    @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
+        }
+    }
+
+    // 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
+    /// Absolute deadline for minute-based timers (nil when not active or chapter-based).
+    private var sleepTimerDeadline: Date? = nil
+    /// 1-second tick task that keeps sleepTimerRemainingText up-to-date.
+    private var sleepTimerCountdownTask: Task<Void, Never>? = nil
+
+    // 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 + countdown
+        sleepTimerTask?.cancel()
+        sleepTimerTask = nil
+        sleepTimerCountdownTask?.cancel()
+        sleepTimerCountdownTask = nil
+        sleepTimerDeadline = nil
+        
+        sleepTimer = option
+        
+        guard let option else {
+            sleepTimerRemainingText = ""
+            return
+        }
+        
+        // Start timer based on option
+        switch option {
+        case .chapters(let count):
+            sleepTimerStartChapter = chapter
+            // Update display immediately; chapter changes are tracked in handlePlaybackFinished.
+            updateChapterTimerLabel(chaptersRemaining: count)
+            
+        case .minutes(let minutes):
+            let deadline = Date().addingTimeInterval(Double(minutes) * 60)
+            sleepTimerDeadline = deadline
+            // Stop playback when the deadline is reached.
+            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
+                    self.sleepTimerRemainingText = ""
+                }
+            }
+            // 1-second tick to keep the countdown label fresh.
+            sleepTimerCountdownTask = Task { [weak self] in
+                while !Task.isCancelled {
+                    try? await Task.sleep(nanoseconds: 1_000_000_000)
+                    guard let self, !Task.isCancelled else { return }
+                    await MainActor.run {
+                        guard let deadline = self.sleepTimerDeadline else { return }
+                        let remaining = max(0, deadline.timeIntervalSinceNow)
+                        self.sleepTimerRemainingText = Self.formatCountdown(remaining)
+                    }
+                }
+            }
+            // Set initial label without waiting for the first tick.
+            sleepTimerRemainingText = Self.formatCountdown(Double(minutes) * 60)
+        }
+    }
+    
+    private func updateChapterTimerLabel(chaptersRemaining: Int) {
+        sleepTimerRemainingText = chaptersRemaining == 1 ? "1 ch left" : "\(chaptersRemaining) ch left"
+    }
+
+    private static func formatCountdown(_ seconds: Double) -> String {
+        let s = Int(max(0, seconds))
+        let m = s / 60
+        let sec = s % 60
+        return "\(m):\(String(format: "%02d", sec))"
+    }
+
+    func stop() {
+        player?.pause()
+        teardownPlayer()
+        isPlaying = false
+        currentTime = 0
+        duration = 0
+        audioURL = ""
+        status = .idle
+        
+        // Cancel sleep timer + countdown
+        sleepTimerTask?.cancel()
+        sleepTimerTask = nil
+        sleepTimerCountdownTask?.cancel()
+        sleepTimerCountdownTask = nil
+        sleepTimerDeadline = nil
+        sleepTimer = nil
+        sleepTimerRemainingText = ""
+    }
+
+    // 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
+            }
+            // Update the remaining chapters label.
+            let remaining = count - chaptersPlayed
+            updateChapterTimerLabel(chaptersRemaining: remaining)
+        }
+
+        // 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 }
+        KingfisherManager.shared.retrieveImage(with: url) { [weak self] result in
+            guard let self else { return }
+            if case .success(let value) = result {
+                let image = value.image
+                let artwork = MPMediaItemArtwork(boundsSize: image.size) { _ in image }
+                Task { @MainActor in
+                    self.cachedCoverArtwork = artwork
+                    self.updateNowPlaying()
+                }
+            }
+        }
+    }
+
+    // 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,159 @@
+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
+
+    /// Re-validates the current session and refreshes `user` + `settings`.
+    /// Call this after any operation that may change the user record (e.g. avatar upload).
+    func validateToken() async {
+        guard let token = loadToken() else { return }
+        await validateToken(token)
+    }
+
+    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()
+            var (restoredUser, restoredSettings) = try await (me, s)
+            // /api/auth/me returns the raw MinIO object key for avatar_url, not a presigned URL.
+            // Exchange the key for a fresh presigned GET URL so KFImage can display it.
+            if let key = restoredUser.avatarURL, !key.hasPrefix("http") {
+                if let presignedURL = try? await APIClient.shared.fetchAvatarPresignedURL() {
+                    restoredUser = AppUser(
+                        id: restoredUser.id,
+                        username: restoredUser.username,
+                        role: restoredUser.role,
+                        created: restoredUser.created,
+                        avatarURL: presignedURL
+                    )
+                }
+            }
+            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,47 @@
+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 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,30 @@
+import Foundation
+
+@MainActor
+final class HomeViewModel: ObservableObject {
+    @Published var continueReading: [ContinueReadingItem] = []
+    @Published var recentlyUpdated: [Book] = []
+    @Published var stats: HomeStats?
+    @Published var subscriptionFeed: [SubscriptionFeedItem] = []
+    @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
+            subscriptionFeed = data.subscriptionFeed
+        } 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/ViewModels/UserProfileViewModel.swift

@@ -0,0 +1,87 @@
+import Foundation
+
+@MainActor
+final class UserProfileViewModel: ObservableObject {
+    let username: String
+
+    @Published var profile: PublicUserProfile?
+    @Published var currentlyReading: [PublicLibraryItem] = []
+    @Published var library: [PublicLibraryItem] = []
+    @Published var isLoading = false
+    @Published var isTogglingSubscribe = false
+    @Published var error: String?
+
+    init(username: String) {
+        self.username = username
+    }
+
+    func load() async {
+        guard !isLoading else { return }
+        isLoading = true
+        error = nil
+        do {
+            async let profileFetch = APIClient.shared.fetchUserProfile(username: username)
+            async let libraryFetch = APIClient.shared.fetchUserLibrary(username: username)
+            let (p, lib) = try await (profileFetch, libraryFetch)
+            profile = p
+            currentlyReading = lib.currentlyReading
+            library = lib.library
+        } catch let apiError as APIError {
+            switch apiError {
+            case .httpError(404, _): error = "User not found."
+            default: error = apiError.localizedDescription
+            }
+        } catch {
+            if !(error is CancellationError) {
+                self.error = error.localizedDescription
+            }
+        }
+        isLoading = false
+    }
+
+    func toggleSubscribe() async {
+        guard let p = profile, !p.isSelf, !isTogglingSubscribe else { return }
+        isTogglingSubscribe = true
+        defer { isTogglingSubscribe = false }
+        do {
+            if p.isSubscribed {
+                try await APIClient.shared.unsubscribeUser(username: username)
+                profile = PublicUserProfile(
+                    id: p.id, username: p.username, avatarUrl: p.avatarUrl,
+                    created: p.created,
+                    followerCount: max(0, p.followerCount - 1),
+                    followingCount: p.followingCount,
+                    isSubscribed: false, isSelf: p.isSelf
+                )
+            } else {
+                try await APIClient.shared.subscribeUser(username: username)
+                profile = PublicUserProfile(
+                    id: p.id, username: p.username, avatarUrl: p.avatarUrl,
+                    created: p.created,
+                    followerCount: p.followerCount + 1,
+                    followingCount: p.followingCount,
+                    isSubscribed: true, isSelf: p.isSelf
+                )
+            }
+        } catch {
+            self.error = error.localizedDescription
+        }
+    }
+}
+
+// MARK: - Convenience memberwise init for PublicUserProfile (used in optimistic updates)
+
+private extension PublicUserProfile {
+    init(id: String, username: String, avatarUrl: String?, created: String,
+         followerCount: Int, followingCount: Int, isSubscribed: Bool, isSelf: Bool) {
+        // Encode then decode to go through the standard Decodable path without duplicating code
+        var dict: [String: Any] = [
+            "id": id, "username": username, "created": created,
+            "followerCount": followerCount, "followingCount": followingCount,
+            "isSubscribed": isSubscribed, "isSelf": isSelf
+        ]
+        if let url = avatarUrl { dict["avatarUrl"] = url }
+        let data = try! JSONSerialization.data(withJSONObject: dict)
+        self = try! JSONDecoder().decode(PublicUserProfile.self, from: data)
+    }
+}

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()
+            }
+            .toolbar(.hidden, for: .navigationBar)
+        }
+        .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,491 @@
+import SwiftUI
+import Kingfisher
+
+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 showChapters = false
+
+    init(slug: String) {
+        self.slug = slug
+        _vm = StateObject(wrappedValue: BookDetailViewModel(slug: slug))
+    }
+
+    var body: some View {
+        ZStack(alignment: .top) {
+            ScrollView {
+                VStack(alignment: .leading, spacing: 0) {
+                    if vm.isLoading {
+                        ProgressView().frame(maxWidth: .infinity).padding(.top, 120)
+                    } else if let book = vm.book {
+                        heroSection(book: book)
+                        metaSection(book: book)
+                        Divider().padding(.horizontal)
+                        chaptersRow(book: book)
+                        Divider().padding(.horizontal)
+                        CommentsView(slug: slug)
+                    }
+                }
+            }
+            .ignoresSafeArea(edges: .top)
+        }
+        .navigationBarTitleDisplayMode(.inline)
+        .appNavigationDestination()
+        .toolbar { bookmarkButton }
+        .task { await vm.load() }
+        .errorAlert($vm.error)
+        .sheet(isPresented: $showChapters) {
+            BookChaptersSheet(
+                slug: slug,
+                chapters: vm.chapters,
+                lastChapter: vm.lastChapter,
+                totalChapters: vm.book?.totalChapters ?? 0
+            )
+        }
+    }
+
+    // MARK: - Hero
+
+    @ViewBuilder
+    private func heroSection(book: Book) -> some View {
+        ZStack(alignment: .bottom) {
+            // Full-bleed blurred background
+            KFImage(URL(string: book.cover))
+                .resizable()
+                .scaledToFill()
+                .frame(maxWidth: .infinity)
+                .frame(height: 320)
+                .blur(radius: 24)
+                .clipped()
+                .overlay(
+                    LinearGradient(
+                        colors: [.black.opacity(0.15), .black.opacity(0.68)],
+                        startPoint: .top,
+                        endPoint: .bottom
+                    )
+                )
+
+            VStack(spacing: 16) {
+                KFImage(URL(string: book.cover))
+                    .resizable()
+                    .placeholder {
+                        RoundedRectangle(cornerRadius: 12)
+                            .fill(Color(.systemGray5))
+                    }
+                    .scaledToFill()
+                    .frame(width: 130, height: 188)
+                    .clipShape(RoundedRectangle(cornerRadius: 12))
+                    .shadow(color: .black.opacity(0.55), radius: 18, x: 0, y: 10)
+                    .shadow(color: .black.opacity(0.3), radius: 6, x: 0, y: 3)
+
+                VStack(spacing: 6) {
+                    Text(book.title)
+                        .font(.title3.bold())
+                        .foregroundStyle(.white)
+                        .multilineTextAlignment(.center)
+                        .lineLimit(3)
+                        .padding(.horizontal, 32)
+
+                    Text(book.author)
+                        .font(.subheadline)
+                        .foregroundStyle(.white.opacity(0.75))
+                }
+
+                if !book.genres.isEmpty {
+                    HStack(spacing: 8) {
+                        ForEach(book.genres.prefix(3), id: \.self) { genre in
+                            TagChip(label: genre).colorScheme(.dark)
+                        }
+                    }
+                }
+
+                if !book.status.isEmpty {
+                    StatusBadge(status: book.status)
+                }
+            }
+            .padding(.horizontal)
+            .padding(.bottom, 28)
+        }
+        .frame(minHeight: 320)
+    }
+
+    // MARK: - Meta section (stats + summary + CTAs)
+
+    @ViewBuilder
+    private func metaSection(book: Book) -> some View {
+        VStack(alignment: .leading, spacing: 0) {
+            // Quick stats row
+            HStack(spacing: 0) {
+                MetaStat(value: "\(book.totalChapters)", label: "Chapters", icon: "doc.text")
+                Divider().frame(height: 36)
+                MetaStat(
+                    value: book.status.capitalized.isEmpty ? "—" : book.status.capitalized,
+                    label: "Status", icon: "flag"
+                )
+                if book.ranking > 0 {
+                    Divider().frame(height: 36)
+                    MetaStat(value: "#\(book.ranking)", label: "Rank", icon: "chart.bar.fill")
+                }
+            }
+            .padding(.vertical, 16)
+            .frame(maxWidth: .infinity)
+
+            Divider().padding(.horizontal)
+
+            // Summary
+            VStack(alignment: .leading, spacing: 8) {
+                Text("About")
+                    .font(.headline)
+
+                Text(book.summary)
+                    .font(.subheadline)
+                    .foregroundStyle(.secondary)
+                    .lineLimit(summaryExpanded ? nil : 4)
+                    .animation(.easeInOut(duration: 0.2), value: summaryExpanded)
+
+                if book.summary.count > 200 {
+                    Button(summaryExpanded ? "Less" : "More") {
+                        withAnimation { summaryExpanded.toggle() }
+                    }
+                    .font(.caption.bold())
+                    .foregroundStyle(.amber)
+                }
+            }
+            .padding(.horizontal)
+            .padding(.vertical, 16)
+
+            Divider().padding(.horizontal)
+
+            // 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)
+                            .fontWeight(.semibold)
+                    }
+                    .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)
+                            .fontWeight(.semibold)
+                    }
+                    .buttonStyle(.borderedProminent)
+                    .tint(.amber)
+                }
+            }
+            .padding(.horizontal)
+            .padding(.vertical, 16)
+        }
+    }
+
+    // MARK: - Compact chapters row (tap → sheet)
+
+    @ViewBuilder
+    private func chaptersRow(book: Book) -> some View {
+        Button {
+            showChapters = true
+        } label: {
+            HStack(spacing: 12) {
+                Image(systemName: "list.number")
+                    .font(.subheadline.weight(.semibold))
+                    .foregroundStyle(.amber)
+                    .frame(width: 28)
+
+                VStack(alignment: .leading, spacing: 2) {
+                    Text("Chapters")
+                        .font(.subheadline.weight(.semibold))
+                        .foregroundStyle(.primary)
+                    if !vm.chapters.isEmpty {
+                        let last = vm.lastChapter
+                        let total = vm.chapters.count
+                        Text(last != nil && last! > 0
+                             ? "Reading Ch.\(last!) of \(total)"
+                             : "\(total) chapter\(total == 1 ? "" : "s")")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                    } else if vm.isLoading {
+                        Text("Loading…")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                    }
+                }
+
+                Spacer()
+
+                Image(systemName: "chevron.right")
+                    .font(.caption.weight(.semibold))
+                    .foregroundStyle(.tertiary)
+            }
+            .padding(.horizontal, 16)
+            .padding(.vertical, 14)
+            .contentShape(Rectangle())
+        }
+        .buttonStyle(.plain)
+    }
+
+    // MARK: - Bookmark toolbar
+
+    @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)
+            }
+        }
+    }
+}
+
+// MARK: - Chapters list sheet
+
+struct BookChaptersSheet: View {
+    let slug: String
+    let chapters: [ChapterIndex]
+    let lastChapter: Int?
+    let totalChapters: Int
+
+    @Environment(\.dismiss) private var dismiss
+    @State private var searchText = ""
+    @State private var scrollToCurrentOnAppear = true
+
+    private var filtered: [ChapterIndex] {
+        guard !searchText.isEmpty else { return chapters }
+        let q = searchText.lowercased()
+        return chapters.filter {
+            "chapter \($0.number)".contains(q) ||
+            $0.title.lowercased().contains(q)
+        }
+    }
+
+    var body: some View {
+        NavigationStack {
+            VStack(spacing: 0) {
+                // Search bar
+                HStack(spacing: 8) {
+                    Image(systemName: "magnifyingglass").foregroundStyle(.secondary)
+                    TextField("Search chapters…", text: $searchText)
+                        .autocorrectionDisabled()
+                    if !searchText.isEmpty {
+                        Button { searchText = "" } label: {
+                            Image(systemName: "xmark.circle.fill").foregroundStyle(.secondary)
+                        }
+                    }
+                }
+                .padding(10)
+                .background(Color(.systemGray6), in: RoundedRectangle(cornerRadius: 10))
+                .padding(.horizontal)
+                .padding(.vertical, 10)
+
+                Divider()
+
+                // Jump-to-current banner (shown when user has progress and not searching)
+                if let last = lastChapter, last > 0, searchText.isEmpty {
+                    Button {
+                        scrollToCurrentOnAppear = true
+                    } label: {
+                        HStack(spacing: 8) {
+                            Image(systemName: "arrow.down.circle.fill")
+                                .foregroundStyle(.amber)
+                            Text("Jump to Ch.\(last)")
+                                .font(.subheadline.weight(.semibold))
+                                .foregroundStyle(.amber)
+                            Spacer()
+                            let pct = totalChapters > 0
+                                ? Int(Double(last) / Double(totalChapters) * 100)
+                                : 0
+                            Text("\(pct)% read")
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                        }
+                        .padding(.horizontal, 16)
+                        .padding(.vertical, 10)
+                    }
+                    .buttonStyle(.plain)
+
+                    Divider()
+                }
+
+                if chapters.isEmpty {
+                    ProgressView()
+                        .frame(maxWidth: .infinity, maxHeight: .infinity)
+                } else if filtered.isEmpty {
+                    VStack(spacing: 10) {
+                        Image(systemName: "magnifyingglass")
+                            .font(.largeTitle)
+                            .foregroundStyle(.secondary)
+                        Text("No chapters match \"\(searchText)\"")
+                            .font(.subheadline)
+                            .foregroundStyle(.secondary)
+                    }
+                    .frame(maxWidth: .infinity, maxHeight: .infinity)
+                } else {
+                    ScrollViewReader { proxy in
+                        List {
+                            ForEach(filtered) { ch in
+                                NavigationLink(value: NavDestination.chapter(slug, ch.number)) {
+                                    ChapterRow(
+                                        chapter: ch,
+                                        isCurrent: ch.number == lastChapter,
+                                        totalChapters: chapters.count
+                                    )
+                                }
+                                .listRowInsets(EdgeInsets(top: 0, leading: 0, bottom: 0, trailing: 16))
+                                .id(ch.number)
+                            }
+                        }
+                        .listStyle(.plain)
+                        .appNavigationDestination()
+                        .onAppear {
+                            if scrollToCurrentOnAppear, let last = lastChapter, last > 0 {
+                                DispatchQueue.main.asyncAfter(deadline: .now() + 0.15) {
+                                    withAnimation {
+                                        proxy.scrollTo(last, anchor: .center)
+                                    }
+                                }
+                                scrollToCurrentOnAppear = false
+                            }
+                        }
+                        .onChange(of: scrollToCurrentOnAppear) { _, jump in
+                            if jump, let last = lastChapter, last > 0 {
+                                withAnimation {
+                                    proxy.scrollTo(last, anchor: .center)
+                                }
+                                scrollToCurrentOnAppear = false
+                            }
+                        }
+                    }
+                }
+            }
+            .navigationTitle("Chapters")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    Button("Done") { dismiss() }
+                        .fontWeight(.semibold)
+                }
+            }
+        }
+        .presentationDetents([.large])
+        .presentationDragIndicator(.visible)
+    }
+}
+
+// MARK: - Chapter row (reused by sheet)
+
+private struct ChapterRow: View {
+    let chapter: ChapterIndex
+    let isCurrent: Bool
+    let totalChapters: Int
+
+    var body: some View {
+        HStack(spacing: 12) {
+            // Number badge
+            ZStack {
+                Circle()
+                    .fill(isCurrent ? Color.amber : Color(.systemGray6))
+                Text("\(chapter.number)")
+                    .font(.caption2.bold().monospacedDigit())
+                    .foregroundStyle(isCurrent ? .black : .secondary)
+                    .minimumScaleFactor(0.6)
+            }
+            .frame(width: 32, height: 32)
+
+            VStack(alignment: .leading, spacing: 2) {
+                let displayTitle: String = {
+                    let stripped = chapter.title.strippingTrailingDate()
+                    if stripped.isEmpty || stripped == "Chapter \(chapter.number)" {
+                        return "Chapter \(chapter.number)"
+                    }
+                    return stripped
+                }()
+
+                Text(displayTitle)
+                    .font(.subheadline)
+                    .fontWeight(isCurrent ? .semibold : .regular)
+                    .foregroundStyle(isCurrent ? .amber : .primary)
+                    .lineLimit(1)
+
+                if !chapter.dateLabel.isEmpty {
+                    Text(chapter.dateLabel)
+                        .font(.caption2)
+                        .foregroundStyle(.tertiary)
+                }
+            }
+
+            Spacer(minLength: 8)
+
+            Image(systemName: "chevron.right")
+                .font(.caption2)
+                .foregroundStyle(.tertiary)
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 10)
+        .contentShape(Rectangle())
+    }
+}
+
+// MARK: - Supporting components
+
+private struct MetaStat: View {
+    let value: String
+    let label: String
+    let icon: String
+
+    var body: some View {
+        VStack(spacing: 4) {
+            Image(systemName: icon)
+                .font(.caption)
+                .foregroundStyle(.amber)
+            Text(value)
+                .font(.subheadline.bold())
+                .lineLimit(1)
+                .minimumScaleFactor(0.7)
+            Text(label)
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+        }
+        .frame(maxWidth: .infinity)
+    }
+}
+
+private struct StatusBadge: View {
+    let status: String
+
+    private var color: Color {
+        switch status.lowercased() {
+        case "ongoing", "active": return .green
+        case "completed": return .blue
+        case "hiatus": return .orange
+        default: return .secondary
+        }
+    }
+
+    var body: some View {
+        HStack(spacing: 4) {
+            Circle()
+                .fill(color)
+                .frame(width: 6, height: 6)
+            Text(status.capitalized)
+                .font(.caption.weight(.medium))
+                .foregroundStyle(color)
+        }
+        .padding(.horizontal, 10)
+        .padding(.vertical, 4)
+        .background(color.opacity(0.12), in: Capsule())
+    }
+}

ios/LibNovel/LibNovel/Views/BookDetail/CommentsView.swift

@@ -0,0 +1,643 @@
+import SwiftUI
+
+// MARK: - ViewModel
+
+@MainActor
+class CommentsViewModel: ObservableObject {
+    let slug: String
+
+    @Published var comments: [BookComment] = []
+    @Published var myVotes: [String: String] = [:]   // commentId → "up" | "down"
+    @Published var avatarUrls: [String: String] = [:] // userId → presigned URL
+    @Published var isLoading = true
+    @Published var error: String?
+
+    @Published var newBody = ""
+    @Published var isPosting = false
+    @Published var postError: String?
+
+    @Published var sort: CommentSortOrder = .top
+
+    // Reply state
+    @Published var replyingToId: String? = nil
+    @Published var replyBody = ""
+    @Published var isPostingReply = false
+    @Published var replyError: String?
+
+    private var votingIds: Set<String> = []
+    private var deletingIds: Set<String> = []
+
+    init(slug: String) {
+        self.slug = slug
+    }
+
+    func load() async {
+        isLoading = true
+        error = nil
+        do {
+            let response = try await APIClient.shared.fetchComments(slug: slug, sort: sort.rawValue)
+            comments = response.comments
+            myVotes = response.myVotes
+            avatarUrls = response.avatarUrls
+        } catch {
+            self.error = error.localizedDescription
+        }
+        isLoading = false
+    }
+
+    func postComment() async {
+        let text = newBody.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !text.isEmpty, !isPosting else { return }
+        if text.count > 2000 {
+            postError = "Comment too long (max 2000 characters)."
+            return
+        }
+        isPosting = true
+        postError = nil
+        do {
+            var created = try await APIClient.shared.postComment(slug: slug, body: text)
+            created.replies = []
+            comments.insert(created, at: 0)
+            newBody = ""
+        } catch let apiError as APIError {
+            switch apiError {
+            case .httpError(401, _): postError = "You must be logged in to comment."
+            default: postError = apiError.localizedDescription
+            }
+        } catch {
+            postError = error.localizedDescription
+        }
+        isPosting = false
+    }
+
+    func postReply(parentId: String) async {
+        let text = replyBody.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !text.isEmpty, !isPostingReply else { return }
+        if text.count > 2000 {
+            replyError = "Reply too long (max 2000 characters)."
+            return
+        }
+        isPostingReply = true
+        replyError = nil
+        do {
+            let created = try await APIClient.shared.postComment(slug: slug, body: text, parentId: parentId)
+            if let idx = comments.firstIndex(where: { $0.id == parentId }) {
+                var parent = comments[idx]
+                var replies = parent.replies ?? []
+                replies.append(created)
+                parent.replies = replies
+                comments[idx] = parent
+            }
+            replyBody = ""
+            replyingToId = nil
+        } catch let apiError as APIError {
+            switch apiError {
+            case .httpError(401, _): replyError = "You must be logged in to reply."
+            default: replyError = apiError.localizedDescription
+            }
+        } catch {
+            replyError = error.localizedDescription
+        }
+        isPostingReply = false
+    }
+
+    func deleteComment(commentId: String, parentId: String? = nil) async {
+        guard !deletingIds.contains(commentId) else { return }
+        deletingIds.insert(commentId)
+
+        // Optimistic removal — update the UI immediately before the network call
+        var removedComment: BookComment?
+        var removedAtIndex: Int?
+        if let parentId {
+            if let idx = comments.firstIndex(where: { $0.id == parentId }) {
+                var parent = comments[idx]
+                removedComment = parent.replies?.first(where: { $0.id == commentId })
+                removedAtIndex = idx
+                parent.replies = (parent.replies ?? []).filter { $0.id != commentId }
+                comments[idx] = parent
+            }
+        } else {
+            removedAtIndex = comments.firstIndex(where: { $0.id == commentId })
+            removedComment = removedAtIndex.map { comments[$0] }
+            comments.removeAll { $0.id == commentId }
+        }
+
+        do {
+            try await APIClient.shared.deleteComment(commentId: commentId)
+        } catch {
+            // Revert the optimistic removal on failure
+            if let removed = removedComment {
+                if let parentId, let idx = removedAtIndex {
+                    var parent = comments[idx]
+                    var replies = parent.replies ?? []
+                    replies.append(removed)
+                    replies.sort { $0.created < $1.created }
+                    parent.replies = replies
+                    comments[idx] = parent
+                } else if let idx = removedAtIndex {
+                    comments.insert(removed, at: min(idx, comments.count))
+                }
+            }
+        }
+
+        deletingIds.remove(commentId)
+    }
+
+    func vote(commentId: String, vote: String, parentId: String? = nil) async {
+        guard !votingIds.contains(commentId) else { return }
+        votingIds.insert(commentId)
+        defer { votingIds.remove(commentId) }
+        do {
+            let updated = try await APIClient.shared.voteComment(commentId: commentId, vote: vote)
+            if let parentId {
+                if let idx = comments.firstIndex(where: { $0.id == parentId }) {
+                    var parent = comments[idx]
+                    if let rIdx = parent.replies?.firstIndex(where: { $0.id == commentId }) {
+                        parent.replies![rIdx] = updated
+                    }
+                    comments[idx] = parent
+                }
+            } else {
+                if let idx = comments.firstIndex(where: { $0.id == commentId }) {
+                    var c = updated
+                    c.replies = comments[idx].replies
+                    comments[idx] = c
+                }
+            }
+            let prev = myVotes[commentId]
+            if prev == vote {
+                myVotes.removeValue(forKey: commentId)
+            } else {
+                myVotes[commentId] = vote
+            }
+        } catch {
+            // Silently ignore vote errors
+        }
+    }
+
+    func isVoting(_ commentId: String) -> Bool { votingIds.contains(commentId) }
+    func isDeleting(_ commentId: String) -> Bool { deletingIds.contains(commentId) }
+
+    func setSort(_ newSort: CommentSortOrder) {
+        guard newSort != sort else { return }
+        sort = newSort
+        Task { await load() }
+    }
+}
+
+enum CommentSortOrder: String, CaseIterable {
+    case top = "top"
+    case new = "new"
+
+    var label: String {
+        switch self {
+        case .top: return "Top"
+        case .new: return "New"
+        }
+    }
+}
+
+// MARK: - CommentsView
+
+struct CommentsView: View {
+    @StateObject private var vm: CommentsViewModel
+    @EnvironmentObject private var authStore: AuthStore
+
+    init(slug: String) {
+        _vm = StateObject(wrappedValue: CommentsViewModel(slug: slug))
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 0) {
+            // Section header + sort picker
+            HStack {
+                Text("Comments")
+                    .font(.headline)
+                let total = vm.comments.reduce(0) { $0 + 1 + ($1.replies?.count ?? 0) }
+                if !vm.isLoading && total > 0 {
+                    Text("(\(total))")
+                        .font(.subheadline)
+                        .foregroundStyle(.secondary)
+                }
+                Spacer()
+                // Sort picker
+                if !vm.isLoading && !vm.comments.isEmpty {
+                    Picker("Sort", selection: Binding(
+                        get: { vm.sort },
+                        set: { vm.setSort($0) }
+                    )) {
+                        ForEach(CommentSortOrder.allCases, id: \.self) { s in
+                            Text(s.label).tag(s)
+                        }
+                    }
+                    .pickerStyle(.segmented)
+                    .frame(width: 120)
+                }
+            }
+            .padding(.horizontal)
+            .padding(.vertical, 14)
+
+            Divider().padding(.horizontal)
+
+            // Post form
+            postForm
+                .padding(.horizontal)
+                .padding(.vertical, 12)
+
+            Divider().padding(.horizontal)
+
+            // Comment list
+            if vm.isLoading {
+                loadingPlaceholder
+            } else if let err = vm.error {
+                Text(err)
+                    .font(.subheadline)
+                    .foregroundStyle(.red)
+                    .padding()
+            } else if vm.comments.isEmpty {
+                Text("No comments yet. Be the first!")
+                    .font(.subheadline)
+                    .foregroundStyle(.secondary)
+                    .padding()
+            } else {
+                ForEach(vm.comments) { comment in
+                    commentThread(comment: comment)
+                    Divider().padding(.leading, 16)
+                }
+            }
+
+            Color.clear.frame(height: 16)
+        }
+        .task { await vm.load() }
+    }
+
+    // MARK: - Comment thread (top-level + replies)
+
+    @ViewBuilder
+    private func commentThread(comment: BookComment) -> some View {
+        VStack(alignment: .leading, spacing: 0) {
+            CommentRow(
+                comment: comment,
+                myVote: vm.myVotes[comment.id],
+                isVoting: vm.isVoting(comment.id),
+                isDeleting: vm.isDeleting(comment.id),
+                isOwner: authStore.user?.id == comment.userId,
+                isLoggedIn: authStore.isAuthenticated,
+                isReplyingTo: vm.replyingToId == comment.id,
+                avatarUrl: vm.avatarUrls[comment.userId],
+                onVote: { v in Task { await vm.vote(commentId: comment.id, vote: v) } },
+                onDelete: { Task { await vm.deleteComment(commentId: comment.id) } },
+                onReply: {
+                    if vm.replyingToId == comment.id {
+                        vm.replyingToId = nil
+                        vm.replyBody = ""
+                        vm.replyError = nil
+                    } else {
+                        vm.replyingToId = comment.id
+                        vm.replyBody = ""
+                        vm.replyError = nil
+                    }
+                }
+            )
+
+            // Inline reply form
+            if vm.replyingToId == comment.id {
+                replyForm(parentId: comment.id)
+                    .padding(.leading, 32)
+                    .padding(.trailing, 16)
+                    .padding(.bottom, 8)
+            }
+
+            // Replies
+            if let replies = comment.replies, !replies.isEmpty {
+                VStack(alignment: .leading, spacing: 0) {
+                    ForEach(replies) { reply in
+                        CommentRow(
+                            comment: reply,
+                            myVote: vm.myVotes[reply.id],
+                            isVoting: vm.isVoting(reply.id),
+                            isDeleting: vm.isDeleting(reply.id),
+                            isOwner: authStore.user?.id == reply.userId,
+                            isLoggedIn: authStore.isAuthenticated,
+                            isReplyingTo: false,
+                            isReply: true,
+                            avatarUrl: vm.avatarUrls[reply.userId],
+                            onVote: { v in Task { await vm.vote(commentId: reply.id, vote: v, parentId: comment.id) } },
+                            onDelete: { Task { await vm.deleteComment(commentId: reply.id, parentId: comment.id) } },
+                            onReply: nil
+                        )
+                        if reply.id != replies.last?.id {
+                            Divider().padding(.leading, 48)
+                        }
+                    }
+                }
+                .padding(.leading, 24)
+                .overlay(alignment: .leading) {
+                    Rectangle()
+                        .fill(Color(.systemGray4))
+                        .frame(width: 2)
+                        .padding(.leading, 16)
+                        .padding(.vertical, 4)
+                }
+            }
+        }
+    }
+
+    // MARK: - Reply form
+
+    @ViewBuilder
+    private func replyForm(parentId: String) -> some View {
+        VStack(alignment: .leading, spacing: 6) {
+            ZStack(alignment: .topLeading) {
+                if vm.replyBody.isEmpty {
+                    Text("Write a reply…")
+                        .font(.caption)
+                        .foregroundStyle(.tertiary)
+                        .padding(.top, 6)
+                        .padding(.leading, 4)
+                }
+                TextEditor(text: $vm.replyBody)
+                    .font(.caption)
+                    .frame(minHeight: 56, maxHeight: 120)
+                    .scrollContentBackground(.hidden)
+            }
+            .padding(8)
+            .background(Color(.systemGray6), in: RoundedRectangle(cornerRadius: 8))
+
+            HStack {
+                let count = vm.replyBody.count
+                Text("\(count)/2000")
+                    .font(.caption2)
+                    .monospacedDigit()
+                    .foregroundStyle(count > 2000 ? Color.red : Color.secondary)
+
+                Spacer()
+
+                if let err = vm.replyError {
+                    Text(err).font(.caption2).foregroundStyle(.red).lineLimit(1)
+                }
+
+                Button("Cancel") {
+                    vm.replyingToId = nil
+                    vm.replyBody = ""
+                    vm.replyError = nil
+                }
+                .font(.caption)
+                .foregroundStyle(.secondary)
+
+                Button {
+                    Task { await vm.postReply(parentId: parentId) }
+                } label: {
+                    if vm.isPostingReply {
+                        ProgressView().controlSize(.mini)
+                    } else {
+                        Text("Reply").fontWeight(.semibold).font(.caption)
+                    }
+                }
+                .buttonStyle(.borderedProminent)
+                .tint(.amber)
+                .controlSize(.mini)
+                .disabled(vm.isPostingReply || vm.replyBody.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty || vm.replyBody.count > 2000)
+            }
+        }
+    }
+
+    // MARK: - Post form
+
+    @ViewBuilder
+    private var postForm: some View {
+        if authStore.isAuthenticated {
+            VStack(alignment: .leading, spacing: 8) {
+                ZStack(alignment: .topLeading) {
+                    if vm.newBody.isEmpty {
+                        Text("Write a comment…")
+                            .font(.subheadline)
+                            .foregroundStyle(.tertiary)
+                            .padding(.top, 8)
+                            .padding(.leading, 4)
+                    }
+                    TextEditor(text: $vm.newBody)
+                        .font(.subheadline)
+                        .frame(minHeight: 72, maxHeight: 160)
+                        .scrollContentBackground(.hidden)
+                }
+                .padding(10)
+                .background(Color(.systemGray6), in: RoundedRectangle(cornerRadius: 10))
+
+                HStack {
+                    let count = vm.newBody.count
+                    Text("\(count)/2000")
+                        .font(.caption2)
+                        .monospacedDigit()
+                    .foregroundStyle(count > 2000 ? Color.red : Color.secondary)
+
+                Spacer()
+
+                if let err = vm.postError {
+                        Text(err)
+                            .font(.caption2)
+                            .foregroundStyle(.red)
+                            .lineLimit(1)
+                    }
+
+                    Button {
+                        Task { await vm.postComment() }
+                    } label: {
+                        if vm.isPosting {
+                            ProgressView().controlSize(.small)
+                        } else {
+                            Text("Post")
+                                .fontWeight(.semibold)
+                        }
+                    }
+                    .buttonStyle(.borderedProminent)
+                    .tint(.amber)
+                    .controlSize(.small)
+                    .disabled(vm.isPosting || vm.newBody.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty || vm.newBody.count > 2000)
+                }
+            }
+        } else {
+            Text("Log in to leave a comment.")
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+        }
+    }
+
+    // MARK: - Loading skeleton
+
+    @ViewBuilder
+    private var loadingPlaceholder: some View {
+        VStack(spacing: 12) {
+            ForEach(0..<3, id: \.self) { _ in
+                VStack(alignment: .leading, spacing: 8) {
+                    RoundedRectangle(cornerRadius: 4)
+                        .fill(Color(.systemGray5))
+                        .frame(width: 100, height: 12)
+                    RoundedRectangle(cornerRadius: 4)
+                        .fill(Color(.systemGray6))
+                        .frame(maxWidth: .infinity)
+                        .frame(height: 12)
+                    RoundedRectangle(cornerRadius: 4)
+                        .fill(Color(.systemGray6))
+                        .frame(width: 200, height: 12)
+                }
+                .padding(.horizontal)
+                .redacted(reason: .placeholder)
+            }
+        }
+        .padding(.vertical, 12)
+    }
+}
+
+// MARK: - CommentRow
+
+private struct CommentRow: View {
+    let comment: BookComment
+    let myVote: String?
+    let isVoting: Bool
+    let isDeleting: Bool
+    let isOwner: Bool
+    let isLoggedIn: Bool
+    let isReplyingTo: Bool
+    var isReply: Bool = false
+    var avatarUrl: String? = nil
+    let onVote: (String) -> Void
+    let onDelete: () -> Void
+    let onReply: (() -> Void)?
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            // Avatar + Username + date
+            HStack(spacing: 8) {
+                avatarView
+                NavigationLink(value: NavDestination.userProfile(comment.username.isEmpty ? "" : comment.username)) {
+                    Text(comment.username.isEmpty ? "Anonymous" : comment.username)
+                        .font(isReply ? .caption.weight(.medium) : .subheadline.weight(.medium))
+                        .foregroundStyle(.primary)
+                }
+                .buttonStyle(.plain)
+                .disabled(comment.username.isEmpty)
+                Text("·")
+                    .foregroundStyle(.tertiary)
+                Text(formattedDate(comment.created))
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+                Spacer()
+            }
+
+            // Body
+            Text(comment.body)
+                .font(isReply ? .caption : .subheadline)
+                .foregroundStyle(.primary)
+                .fixedSize(horizontal: false, vertical: true)
+
+            // Actions
+            HStack(spacing: 14) {
+                // Upvote
+                Button { onVote("up") } label: {
+                    HStack(spacing: 4) {
+                        Image(systemName: myVote == "up" ? "hand.thumbsup.fill" : "hand.thumbsup")
+                            .font(.caption)
+                        Text("\(comment.upvotes)")
+                            .font(.caption.monospacedDigit())
+                    }
+                    .foregroundStyle(myVote == "up" ? Color.amber : .secondary)
+                }
+                .disabled(isVoting)
+
+                // Downvote
+                Button { onVote("down") } label: {
+                    HStack(spacing: 4) {
+                        Image(systemName: myVote == "down" ? "hand.thumbsdown.fill" : "hand.thumbsdown")
+                            .font(.caption)
+                        Text("\(comment.downvotes)")
+                            .font(.caption.monospacedDigit())
+                    }
+                    .foregroundStyle(myVote == "down" ? .red : .secondary)
+                }
+                .disabled(isVoting)
+
+                // Reply button (top-level only, logged in)
+                if let onReply, isLoggedIn {
+                    Button { onReply() } label: {
+                        HStack(spacing: 3) {
+                            Image(systemName: "arrowshape.turn.up.left")
+                                .font(.caption)
+                            Text("Reply")
+                                .font(.caption)
+                        }
+                        .foregroundStyle(isReplyingTo ? Color.amber : .secondary)
+                    }
+                }
+
+                Spacer()
+
+                // Delete (owner only)
+                if isOwner {
+                    Button(role: .destructive) { onDelete() } label: {
+                        Image(systemName: "trash")
+                            .font(.caption)
+                    }
+                    .disabled(isDeleting)
+                }
+            }
+        }
+        .padding(.horizontal, 16)
+        .padding(.vertical, 12)
+        .opacity(isDeleting ? 0.5 : 1)
+        .animation(.easeInOut(duration: 0.15), value: isDeleting)
+    }
+
+    private var avatarSize: CGFloat { isReply ? 20 : 24 }
+
+    @ViewBuilder
+    private var avatarView: some View {
+        if let url = avatarUrl, let imageUrl = URL(string: url) {
+            AsyncImage(url: imageUrl) { phase in
+                switch phase {
+                case .success(let image):
+                    image.resizable().scaledToFill()
+                default:
+                    initialsView
+                }
+            }
+            .frame(width: avatarSize, height: avatarSize)
+            .clipShape(Circle())
+        } else {
+            initialsView
+        }
+    }
+
+    private var initialsView: some View {
+        let name = comment.username.isEmpty ? "?" : comment.username
+        let letters = String(name.prefix(2)).uppercased()
+        return ZStack {
+            Circle()
+                .fill(Color(.systemGray4))
+                .frame(width: avatarSize, height: avatarSize)
+            Text(letters)
+                .font(.system(size: avatarSize * 0.42, weight: .semibold))
+                .foregroundStyle(.secondary)
+        }
+    }
+
+    private func formattedDate(_ iso: String) -> String {
+        // PocketBase returns "2006-01-02 15:04:05.999Z" format
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        if let date = formatter.date(from: iso) {
+            let rel = RelativeDateTimeFormatter()
+            rel.unitsStyle = .abbreviated
+            return rel.localizedString(for: date, relativeTo: Date())
+        }
+        // Fallback: try space-separated format
+        let df = DateFormatter()
+        df.dateFormat = "yyyy-MM-dd HH:mm:ss.SSSZ"
+        if let date = df.date(from: iso) {
+            let rel = RelativeDateTimeFormatter()
+            rel.unitsStyle = .abbreviated
+            return rel.localizedString(for: date, relativeTo: Date())
+        }
+        return String(iso.prefix(10))
+    }
+}

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

@@ -0,0 +1,197 @@
+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) {
+                        ChipButton(label: "Sort: \(vm.sort.capitalized)", isSelected: vm.sort != "popular", style: .outlined) {
+                            showFilters = true
+                        }
+                        ChipButton(label: "Genre: \(vm.genre == "all" ? "All" : vm.genre.capitalized)", isSelected: vm.genre != "all", style: .outlined) {
+                            showFilters = true
+                        }
+                        ChipButton(label: "Status: \(vm.status == "all" ? "All" : vm.status.capitalized)", isSelected: vm.status != "all", style: .outlined) {
+                            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)
+                                        .bookCoverZoomSource(slug: novel.slug)
+                                }
+                                .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()
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    AvatarToolbarButton()
+                }
+            }
+            .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: - 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/Common/CommonViews.swift

@@ -0,0 +1,143 @@
+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())
+    }
+}
+
+// MARK: - Unified chip button (filter/sort chips across all screens)
+//
+// .filled  → amber background when selected (genre filter chips in Library)
+// .outlined → amber border + tint when selected, grey background (sort chips, browse filter chips)
+
+enum ChipButtonStyle { case filled, outlined }
+
+struct ChipButton: View {
+    let label: String
+    let isSelected: Bool
+    var style: ChipButtonStyle = .filled
+    let action: () -> Void
+
+    var body: some View {
+        Button(action: action) {
+            Text(label)
+                .font(chipFont)
+                .padding(.horizontal, chipHPad)
+                .padding(.vertical, 6)
+                .background(background)
+                .foregroundStyle(foregroundColor)
+                .overlay(border)
+        }
+        .buttonStyle(.plain)
+    }
+
+    private var chipFont: Font {
+        switch style {
+        case .filled:   return .caption.weight(isSelected ? .semibold : .regular)
+        case .outlined: return .subheadline.weight(isSelected ? .semibold : .regular)
+        }
+    }
+
+    private var chipHPad: CGFloat { style == .outlined ? 14 : 12 }
+
+    @ViewBuilder
+    private var background: some View {
+        switch style {
+        case .filled:
+            Capsule().fill(isSelected ? Color.amber : Color(.systemGray5))
+        case .outlined:
+            Capsule()
+                .fill(isSelected ? Color.amber.opacity(0.15) : Color(.systemGray6))
+                .overlay(Capsule().stroke(isSelected ? Color.amber : .clear, lineWidth: 1.5))
+        }
+    }
+
+    private var foregroundColor: Color {
+        switch style {
+        case .filled:   return isSelected ? .white : .primary
+        case .outlined: return isSelected ? .amber : .primary
+        }
+    }
+
+    @ViewBuilder
+    private var border: some View {
+        // outlined style already has its border baked into `background`
+        EmptyView()
+    }
+}

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

@@ -0,0 +1,372 @@
+import SwiftUI
+
+struct HomeView: View {
+    @StateObject private var vm = HomeViewModel()
+    @EnvironmentObject var authStore: AuthStore
+
+    var body: some View {
+        NavigationStack {
+            ScrollView {
+                VStack(alignment: .leading, spacing: 0) {
+
+                    // Continue reading — all in-progress books as a horizontal shelf (Apple Books style)
+                    if !vm.continueReading.isEmpty {
+                        ShelfHeader(title: "Continue Reading")
+                            .padding(.top, 8)
+                        ScrollView(.horizontal, showsIndicators: false) {
+                            HStack(alignment: .top, spacing: 16) {
+                                ForEach(vm.continueReading) { item in
+                                    NavigationLink(value: NavDestination.chapter(item.book.slug, item.chapter)) {
+                                        ContinueReadingCard(item: item)
+                                    }
+                                    .buttonStyle(.plain)
+                                    .contextMenu {
+                                        ContinueReadingContextMenu(
+                                            item: item,
+                                            onMarkFinished: {
+                                                Task { await markAsFinished(item.book) }
+                                            },
+                                            onRemove: {
+                                                Task { await removeFromLibrary(item.book.slug) }
+                                            }
+                                        )
+                                    }
+                                }
+                            }
+                            .padding(.horizontal)
+                            .padding(.bottom, 4)
+                        }
+                        .padding(.bottom, 28)
+                    }
+
+                    // Stats strip
+                    if let stats = vm.stats {
+                        StatsStrip(stats: stats)
+                            .padding(.horizontal)
+                            .padding(.bottom, 28)
+                    }
+
+                    // Recently updated shelf
+                    if !vm.recentlyUpdated.isEmpty {
+                        ShelfHeader(title: "Recently Updated")
+                        ScrollView(.horizontal, showsIndicators: false) {
+                            HStack(alignment: .top, spacing: 14) {
+                                ForEach(vm.recentlyUpdated) { book in
+                                    NavigationLink(value: NavDestination.book(book.slug)) {
+                                        ShelfBookCard(book: book)
+                                    }
+                                    .buttonStyle(.plain)
+                                    .contextMenu {
+                                        ShareLink(item: shareURL(for: book)) {
+                                            Label("Share", systemImage: "square.and.arrow.up")
+                                        }
+                                    }
+                                }
+                            }
+                            .padding(.horizontal)
+                            .padding(.bottom, 4)
+                        }
+                        .padding(.bottom, 28)
+                    }
+
+                    // Subscription feed shelf
+                    if !vm.subscriptionFeed.isEmpty {
+                        ShelfHeader(title: "From People You Follow")
+                        ScrollView(.horizontal, showsIndicators: false) {
+                            HStack(alignment: .top, spacing: 14) {
+                                ForEach(vm.subscriptionFeed) { item in
+                                    NavigationLink(value: NavDestination.book(item.book.slug)) {
+                                        SubscriptionFeedCard(item: item)
+                                    }
+                                    .buttonStyle(.plain)
+                                    .contextMenu {
+                                        ShareLink(item: shareURL(for: item.book)) {
+                                            Label("Share", systemImage: "square.and.arrow.up")
+                                        }
+                                    }
+                                }
+                            }
+                            .padding(.horizontal)
+                            .padding(.bottom, 4)
+                        }
+                        .padding(.bottom, 28)
+                    }
+
+                    // Empty state
+                    if vm.continueReading.isEmpty && vm.recentlyUpdated.isEmpty && vm.subscriptionFeed.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)
+                    }
+
+                    Color.clear.frame(height: 20)
+                }
+            }
+            .navigationTitle("Reading Now")
+            .appNavigationDestination()
+            .refreshable { await vm.load() }
+            .task { await vm.load() }
+            .errorAlert($vm.error)
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    AvatarToolbarButton()
+                }
+            }
+        }
+    }
+    
+    private func markAsFinished(_ book: Book) async {
+        do {
+            try await APIClient.shared.setProgress(slug: book.slug, chapter: book.totalChapters)
+            await vm.load()  // Refresh home
+        } catch {
+            vm.error = error.localizedDescription
+        }
+    }
+    
+    private func removeFromLibrary(_ slug: String) async {
+        do {
+            try await APIClient.shared.deleteProgress(slug: slug)
+            await vm.load()  // Refresh home
+        } catch {
+            vm.error = error.localizedDescription
+        }
+    }
+    
+    private func shareURL(for book: Book) -> URL {
+        let baseURL = Bundle.main.object(forInfoDictionaryKey: "LIBNOVEL_BASE_URL") as? String
+                      ?? "https://v2.libnovel.kalekber.cc"
+        return URL(string: "\(baseURL)/books/\(book.slug)")!
+    }
+}
+
+// MARK: - Shelf header
+
+private struct ShelfHeader: View {
+    let title: String
+
+    var body: some View {
+        Text(title)
+            .font(.title3.bold())
+            .padding(.horizontal)
+            .padding(.bottom, 10)
+    }
+}
+
+// MARK: - Horizontal shelf: continue reading card (Apple Books style)
+
+private struct ContinueReadingCard: View {
+    let item: ContinueReadingItem
+
+    private var progressFraction: Double {
+        guard item.book.totalChapters > 0 else { return 0 }
+        return min(1.0, Double(item.chapter) / Double(item.book.totalChapters))
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            // Cover
+            ZStack(alignment: .bottomLeading) {
+                AsyncCoverImage(url: item.book.cover)
+                    .frame(width: 130, height: 188)
+                    .clipShape(RoundedRectangle(cornerRadius: 10))
+                    .shadow(color: .black.opacity(0.18), radius: 6, y: 3)
+                    .bookCoverZoomSource(slug: item.book.slug)
+
+                // "Continue" pill badge at bottom-left
+                HStack(spacing: 4) {
+                    Image(systemName: "play.fill")
+                        .font(.system(size: 8, weight: .bold))
+                    Text("Ch.\(item.chapter)")
+                        .font(.system(size: 10, weight: .bold))
+                }
+                .foregroundStyle(.black.opacity(0.85))
+                .padding(.horizontal, 8)
+                .padding(.vertical, 5)
+                .background(Capsule().fill(Color.amber))
+                .padding(8)
+            }
+
+            // Title
+            Text(item.book.title)
+                .font(.caption.bold())
+                .lineLimit(2)
+                .frame(width: 130, alignment: .leading)
+                .foregroundStyle(.primary)
+
+            // Progress bar — show at least a 4pt sliver so early chapters aren't invisible
+            GeometryReader { geo in
+                ZStack(alignment: .leading) {
+                    Capsule()
+                        .fill(Color.secondary.opacity(0.2))
+                    Capsule()
+                        .fill(Color.amber.opacity(0.85))
+                        .frame(width: max(4, geo.size.width * progressFraction))
+                }
+            }
+            .frame(width: 130, height: 3)
+
+            // Percent label — floor at 1% so early chapters don't display "0%"
+            Text("\(max(1, Int(progressFraction * 100)))% complete")
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+        }
+        .frame(width: 130)
+    }
+}
+
+// MARK: - Horizontal shelf: recently updated book card
+
+private struct ShelfBookCard: View {
+    let book: Book
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            AsyncCoverImage(url: book.cover)
+                .frame(width: 110, height: 158)
+                .clipShape(RoundedRectangle(cornerRadius: 8))
+                .shadow(color: .black.opacity(0.12), radius: 4, y: 2)
+                .bookCoverZoomSource(slug: book.slug)
+
+            Text(book.title)
+                .font(.caption.bold())
+                .lineLimit(2)
+                .frame(width: 110, alignment: .leading)
+
+            Text(book.author)
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+                .lineLimit(1)
+                .frame(width: 110, alignment: .leading)
+        }
+    }
+}
+
+// MARK: - Horizontal shelf: subscription feed card
+
+private struct SubscriptionFeedCard: View {
+    let item: SubscriptionFeedItem
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            AsyncCoverImage(url: item.book.cover)
+                .frame(width: 110, height: 158)
+                .clipShape(RoundedRectangle(cornerRadius: 8))
+                .shadow(color: .black.opacity(0.12), radius: 4, y: 2)
+                .bookCoverZoomSource(slug: item.book.slug)
+
+            Text(item.book.title)
+                .font(.caption.bold())
+                .lineLimit(2)
+                .frame(width: 110, alignment: .leading)
+
+            // Tappable "via @username" attribution
+            NavigationLink(value: NavDestination.userProfile(item.readerUsername)) {
+                Text("via @\(item.readerUsername)")
+                    .font(.caption2)
+                    .foregroundStyle(Color.amber)
+                    .lineLimit(1)
+                    .frame(width: 110, alignment: .leading)
+            }
+            .buttonStyle(.plain)
+        }
+    }
+}
+
+// MARK: - Stats strip (compact inline)
+
+private struct StatsStrip: View {
+    let stats: HomeStats
+
+    var body: some View {
+        HStack(spacing: 0) {
+            StatPill(icon: "books.vertical.fill", value: "\(stats.totalBooks)", label: "Books")
+            Divider().frame(height: 28)
+            StatPill(icon: "text.alignleft", value: "\(stats.totalChapters)", label: "Chapters")
+            Divider().frame(height: 28)
+            StatPill(icon: "bookmark.fill", value: "\(stats.booksInProgress)", label: "In Progress")
+        }
+        .frame(maxWidth: .infinity)
+        .padding(.vertical, 14)
+        .background(.ultraThinMaterial, in: RoundedRectangle(cornerRadius: 14))
+    }
+}
+
+private struct StatPill: View {
+    let icon: String
+    let value: String
+    let label: String
+
+    var body: some View {
+        VStack(spacing: 4) {
+            Image(systemName: icon)
+                .font(.system(size: 14, weight: .medium))
+                .foregroundStyle(Color.amber.opacity(0.8))
+            Text(value)
+                .font(.subheadline.bold().monospacedDigit())
+                .foregroundStyle(.primary)
+            Text(label)
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+        }
+        .frame(maxWidth: .infinity)
+    }
+}
+
+// MARK: - Context menus
+
+private struct ContinueReadingContextMenu: View {
+    let item: ContinueReadingItem
+    let onMarkFinished: () -> Void
+    let onRemove: () -> Void
+    
+    private var isFinished: Bool {
+        guard item.book.totalChapters > 0 else { return false }
+        return item.chapter >= item.book.totalChapters
+    }
+    
+    var body: some View {
+        Group {
+            // Share book
+            ShareLink(item: shareURL) {
+                Label("Share", systemImage: "square.and.arrow.up")
+            }
+            
+            Divider()
+            
+            // Mark as finished (only show if not already finished)
+            if !isFinished {
+                Button {
+                    onMarkFinished()
+                } label: {
+                    Label("Mark as Finished", systemImage: "checkmark.circle")
+                }
+            }
+            
+            Divider()
+            
+            // Remove from library (destructive)
+            Button(role: .destructive) {
+                onRemove()
+            } label: {
+                Label("Remove from Library", systemImage: "trash")
+            }
+        }
+    }
+    
+    private var shareURL: URL {
+        let baseURL = Bundle.main.object(forInfoDictionaryKey: "LIBNOVEL_BASE_URL") as? String
+                      ?? "https://v2.libnovel.kalekber.cc"
+        return URL(string: "\(baseURL)/books/\(item.book.slug)")!
+    }
+}

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

@@ -0,0 +1,404 @@
+import SwiftUI
+import Kingfisher
+
+struct LibraryView: View {
+    @StateObject private var vm = LibraryViewModel()
+    @State private var sortOrder: SortOrder = .recentlyRead
+    @State private var readingFilter: ReadingFilter = .all
+    @State private var selectedGenre: String = "all"
+    @State private var searchText = ""
+
+    enum SortOrder: String, CaseIterable {
+        case recentlyRead = "Recent"
+        case title = "Title"
+        case author = "Author"
+        case progress = "Progress"
+    }
+
+    enum ReadingFilter: String, CaseIterable {
+        case all = "All"
+        case inProgress = "In Progress"
+        case completed = "Completed"
+    }
+
+    // All distinct genres across the library, sorted alphabetically.
+    private var availableGenres: [String] {
+        let all = vm.items.flatMap { $0.book.genres }
+        let unique = Array(Set(all)).sorted()
+        return unique
+    }
+
+    private var filtered: [LibraryItem] {
+        var result = vm.items
+
+        // 1. Reading filter
+        switch readingFilter {
+        case .all:
+            break
+        case .inProgress:
+            result = result.filter { !isCompleted($0) }
+        case .completed:
+            result = result.filter { isCompleted($0) }
+        }
+
+        // 2. Genre filter
+        if selectedGenre != "all" {
+            result = result.filter { $0.book.genres.contains(selectedGenre) }
+        }
+
+        // 3. Sort
+        switch sortOrder {
+        case .recentlyRead:
+            break   // server returns by recency
+        case .title:
+            result = result.sorted { $0.book.title < $1.book.title }
+        case .author:
+            result = result.sorted { $0.book.author < $1.book.author }
+        case .progress:
+            result = result.sorted { ($0.lastChapter ?? 0) > ($1.lastChapter ?? 0) }
+        }
+
+        // 4. Search
+        if !searchText.isEmpty {
+            result = result.filter {
+                $0.book.title.localizedCaseInsensitiveContains(searchText) ||
+                $0.book.author.localizedCaseInsensitiveContains(searchText)
+            }
+        }
+
+        return result
+    }
+
+    private func isCompleted(_ item: LibraryItem) -> Bool {
+        // Treat as completed if book status is "completed" OR
+        // the user has read up to (or past) the total chapter count.
+        if item.book.status.lowercased() == "completed",
+           let ch = item.lastChapter,
+           item.book.totalChapters > 0,
+           ch >= item.book.totalChapters {
+            return true
+        }
+        return item.book.status.lowercased() == "completed" && (item.lastChapter ?? 0) > 0
+    }
+
+    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 {
+                        VStack(spacing: 0) {
+                            // Search bar
+                            HStack(spacing: 8) {
+                                Image(systemName: "magnifyingglass")
+                                    .foregroundStyle(.secondary)
+                                TextField("Search library", text: $searchText)
+                                    .font(.subheadline)
+                                if !searchText.isEmpty {
+                                    Button { searchText = "" } label: {
+                                        Image(systemName: "xmark.circle.fill")
+                                            .foregroundStyle(.secondary)
+                                    }
+                                }
+                            }
+                            .padding(.horizontal, 12)
+                            .padding(.vertical, 10)
+                            .background(Color(.systemGray6), in: RoundedRectangle(cornerRadius: 10))
+                            .padding(.horizontal)
+                            .padding(.top, 8)
+
+                            // Reading filter (All / In Progress / Completed)
+                            Picker("", selection: $readingFilter) {
+                                ForEach(ReadingFilter.allCases, id: \.self) { f in
+                                    Text(f.rawValue).tag(f)
+                                }
+                            }
+                            .pickerStyle(.segmented)
+                            .padding(.horizontal)
+                            .padding(.top, 12)
+
+                            // Genre filter chips (only shown when genres are available)
+                            if !availableGenres.isEmpty {
+                                ScrollView(.horizontal, showsIndicators: false) {
+                                    HStack(spacing: 8) {
+                                        // "All" chip
+                                        ChipButton(
+                                            label: "All",
+                                            isSelected: selectedGenre == "all",
+                                            style: .filled
+                                        ) {
+                                            withAnimation { selectedGenre = "all" }
+                                        }
+                                        ForEach(availableGenres, id: \.self) { genre in
+                                            ChipButton(
+                                                label: genre.capitalized,
+                                                isSelected: selectedGenre == genre,
+                                                style: .filled
+                                            ) {
+                                                withAnimation {
+                                                    selectedGenre = selectedGenre == genre ? "all" : genre
+                                                }
+                                            }
+                                        }
+                                    }
+                                    .padding(.horizontal)
+                                }
+                                .padding(.top, 10)
+                            }
+
+                            // Sort chips
+                            ScrollView(.horizontal, showsIndicators: false) {
+                                HStack(spacing: 8) {
+                                    ForEach(SortOrder.allCases, id: \.self) { order in
+                                        ChipButton(
+                                            label: order.rawValue,
+                                            isSelected: sortOrder == order,
+                                            style: .outlined
+                                        ) {
+                                            withAnimation { sortOrder = order }
+                                        }
+                                    }
+                                }
+                                .padding(.horizontal)
+                            }
+                            .padding(.vertical, 10)
+
+                            // Book count
+                            Text("\(filtered.count) book\(filtered.count == 1 ? "" : "s")")
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                                .frame(maxWidth: .infinity, alignment: .leading)
+                                .padding(.horizontal)
+                                .padding(.bottom, 4)
+
+                            if filtered.isEmpty {
+                                VStack(spacing: 12) {
+                                    Image(systemName: readingFilter == .completed ? "checkmark.circle" : "book")
+                                        .font(.system(size: 40))
+                                        .foregroundStyle(.secondary)
+                                    Text(emptyMessage)
+                                        .font(.subheadline)
+                                        .foregroundStyle(.secondary)
+                                        .multilineTextAlignment(.center)
+                                }
+                                .frame(maxWidth: .infinity)
+                                .padding(.top, 60)
+                            } else {
+                                // 2-column grid (matches Discover)
+                                LazyVGrid(
+                                    columns: [
+                                        GridItem(.flexible(), spacing: 12),
+                                        GridItem(.flexible(), spacing: 12)
+                                    ],
+                                    spacing: 16
+                                ) {
+                                    ForEach(filtered) { item in
+                                        NavigationLink(value: NavDestination.book(item.book.slug)) {
+                                            LibraryBookCard(item: item)
+                                        }
+                                        .buttonStyle(.plain)
+                                        .contextMenu {
+                                            BookContextMenu(
+                                                book: item.book,
+                                                isFinished: isCompleted(item),
+                                                onMarkFinished: {
+                                                    Task {
+                                                        await markAsFinished(item.book)
+                                                    }
+                                                },
+                                                onRemove: {
+                                                    Task {
+                                                        await removeFromLibrary(item.book.slug)
+                                                    }
+                                                }
+                                            )
+                                        }
+                                    }
+                                }
+                                .padding(.horizontal)
+                                .padding(.top, 8)
+                                .padding(.bottom, 24)
+                            }
+                        }
+                    }
+                }
+            }
+            .navigationTitle("Library")
+            .appNavigationDestination()
+            .refreshable { await vm.load() }
+            .task { await vm.load() }
+            .errorAlert($vm.error)
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    AvatarToolbarButton()
+                }
+            }
+        }
+    }
+
+    private var emptyMessage: String {
+        switch readingFilter {
+        case .all:
+            return selectedGenre == "all" ? "No books match your search." : "No \(selectedGenre.capitalized) books in your library."
+        case .inProgress:
+            return "No books in progress."
+        case .completed:
+            return "No completed books yet."
+        }
+    }
+    
+    private func markAsFinished(_ book: Book) async {
+        do {
+            try await APIClient.shared.setProgress(slug: book.slug, chapter: book.totalChapters)
+            await vm.load()  // Refresh library
+        } catch {
+            vm.error = error.localizedDescription
+        }
+    }
+    
+    private func removeFromLibrary(_ slug: String) async {
+        do {
+            try await APIClient.shared.deleteProgress(slug: slug)
+            await vm.load()  // Refresh library
+        } catch {
+            vm.error = error.localizedDescription
+        }
+    }
+}
+
+// MARK: - Library book card (3-column)
+
+private struct LibraryBookCard: View {
+    let item: LibraryItem
+
+    private var progressFraction: Double {
+        guard let ch = item.lastChapter, item.book.totalChapters > 0 else { return 0 }
+        return Double(ch) / Double(item.book.totalChapters)
+    }
+
+    private var isCompleted: Bool {
+        progressFraction >= 1.0
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            ZStack(alignment: .topTrailing) {
+                // Cover image
+                KFImage(URL(string: item.book.cover))
+                    .resizable()
+                    .placeholder {
+                        RoundedRectangle(cornerRadius: 8)
+                            .fill(Color(.systemGray5))
+                            .overlay(
+                                Image(systemName: "book.closed")
+                                    .foregroundStyle(.secondary)
+                            )
+                    }
+                    .scaledToFill()
+                    .frame(maxWidth: .infinity)
+                    .aspectRatio(2/3, contentMode: .fit)
+                    .clipShape(RoundedRectangle(cornerRadius: 8))
+                    .shadow(color: .black.opacity(0.14), radius: 4, y: 2)
+                    .bookCoverZoomSource(slug: item.book.slug)
+
+                // Progress arc or completed checkmark in top-right corner
+                if isCompleted {
+                    Image(systemName: "checkmark.circle.fill")
+                        .font(.system(size: 18, weight: .semibold))
+                        .foregroundStyle(.white)
+                        .background(Circle().fill(Color.amber).padding(1))
+                        .padding(5)
+                } else if progressFraction > 0 {
+                    ProgressArc(fraction: progressFraction)
+                        .frame(width: 28, height: 28)
+                        .padding(4)
+                }
+            }
+
+            // Title
+            Text(item.book.title)
+                .font(.subheadline.bold())
+                .lineLimit(2)
+                .fixedSize(horizontal: false, vertical: true)
+
+            // Chapter badge if present
+            if let ch = item.lastChapter {
+                Text(isCompleted ? "Finished" : "Ch.\(ch)")
+                    .font(.caption)
+                    .foregroundStyle(isCompleted ? Color.amber : .secondary)
+            }
+        }
+    }
+}
+
+// MARK: - Circular progress arc overlay
+
+private struct ProgressArc: View {
+    let fraction: Double  // 0...1
+
+    var body: some View {
+        ZStack {
+            Circle()
+                .fill(.ultraThinMaterial)
+
+            Circle()
+                .trim(from: 0, to: fraction)
+                .stroke(Color.amber, style: StrokeStyle(lineWidth: 2.5, lineCap: .round))
+                .rotationEffect(.degrees(-90))
+                .animation(.easeInOut(duration: 0.5), value: fraction)
+        }
+    }
+}
+
+// MARK: - Book context menu
+
+private struct BookContextMenu: View {
+    let book: Book
+    let isFinished: Bool
+    let onMarkFinished: () -> Void
+    let onRemove: () -> Void
+    
+    var body: some View {
+        Group {
+            // Share book
+            ShareLink(item: shareURL) {
+                Label("Share", systemImage: "square.and.arrow.up")
+            }
+            
+            Divider()
+            
+            // Mark as finished (only show if not already finished)
+            if !isFinished {
+                Button {
+                    onMarkFinished()
+                } label: {
+                    Label("Mark as Finished", systemImage: "checkmark.circle")
+                }
+            }
+            
+            Divider()
+            
+            // Remove from library (destructive)
+            Button(role: .destructive) {
+                onRemove()
+            } label: {
+                Label("Remove from Library", systemImage: "trash")
+            }
+        }
+    }
+    
+    private var shareURL: URL {
+        // Share the book detail page URL
+        let baseURL = Bundle.main.object(forInfoDictionaryKey: "LIBNOVEL_BASE_URL") as? String
+                      ?? "https://v2.libnovel.kalekber.cc"
+        return URL(string: "\(baseURL)/books/\(book.slug)")!
+    }
+}

ios/LibNovel/LibNovel/Views/Profile/AccountMenuSheet.swift

@@ -0,0 +1,341 @@
+import SwiftUI
+import PhotosUI
+import Kingfisher
+
+// MARK: - AvatarNavButton
+// Drop this into any NavigationStack toolbar to get an avatar button that opens the account sheet.
+//
+// Usage:
+//   .toolbar { AvatarToolbarButton() }
+
+struct AvatarToolbarButton: View {
+    @EnvironmentObject private var authStore: AuthStore
+    @State private var showAccount = false
+
+    var body: some View {
+        Button {
+            showAccount = true
+        } label: {
+            AvatarThumb(urlString: authStore.user?.avatarURL, size: 30)
+        }
+        .sheet(isPresented: $showAccount) {
+            AccountMenuSheet()
+        }
+    }
+}
+
+// MARK: - AvatarThumb
+// Reusable small circular avatar (used by both toolbar button and the sheet header).
+
+struct AvatarThumb: View {
+    let urlString: String?
+    let size: CGFloat
+
+    var body: some View {
+        Group {
+            if let str = urlString, let url = URL(string: str) {
+                KFImage(url)
+                    .placeholder { placeholderCircle }
+                    .resizable()
+                    .scaledToFill()
+            } else {
+                placeholderCircle
+            }
+        }
+        .frame(width: size, height: size)
+        .clipShape(Circle())
+        .overlay(Circle().stroke(Color.amber.opacity(0.6), lineWidth: 1.5))
+    }
+
+    private var placeholderCircle: some View {
+        Circle()
+            .fill(Color(.systemGray4))
+            .overlay(
+                Image(systemName: "person.fill")
+                    .font(.system(size: size * 0.5))
+                    .foregroundStyle(Color.amber)
+            )
+    }
+}
+
+// MARK: - AccountMenuSheet
+
+struct AccountMenuSheet: View {
+    @EnvironmentObject private var authStore: AuthStore
+    @StateObject private var vm = ProfileViewModel()
+    @Environment(\.dismiss) private var dismiss
+
+    @State private var showChangePassword = false
+
+    // Avatar upload
+    @State private var photoPickerItem: PhotosPickerItem?
+    @State private var pendingCropImage: UIImage?
+    @State private var avatarURL: String? = nil
+    @State private var avatarUploading = false
+    @State private var avatarError: String?
+
+    var body: some View {
+        NavigationStack {
+            List {
+                // ── User header ────────────────────────────────────────────
+                Section {
+                    HStack(spacing: 16) {
+                        avatarPicker
+                        VStack(alignment: .leading, spacing: 3) {
+                            Text(authStore.user?.username ?? "")
+                                .font(.headline)
+                            Text(authStore.user?.role.capitalized ?? "")
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                            if let err = avatarError {
+                                Text(err)
+                                    .font(.caption2)
+                                    .foregroundStyle(.red)
+                            }
+                        }
+                    }
+                    .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) {
+                        dismiss()
+                        Task { await authStore.logout() }
+                    }
+                }
+            }
+            .navigationTitle("Account")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    Button("Done") { dismiss() }
+                        .fontWeight(.semibold)
+                }
+            }
+            .task { await vm.loadSessions() }
+            .sheet(isPresented: $showChangePassword) {
+                ChangePasswordView()
+            }
+            .sheet(item: Binding(
+                get: { pendingCropImage.map { CropImageItem(image: $0) } },
+                set: { if $0 == nil { pendingCropImage = nil } }
+            )) { item in
+                AvatarCropView(image: item.image) { croppedData in
+                    pendingCropImage = nil
+                    Task { await uploadCroppedData(croppedData) }
+                } onCancel: {
+                    pendingCropImage = nil
+                }
+            }
+            .errorAlert($vm.error)
+        }
+        .presentationDetents([.large])
+        .presentationDragIndicator(.visible)
+    }
+
+    // MARK: - Avatar upload
+
+    private func loadImageForCrop(_ item: PhotosPickerItem) async {
+        guard let data = try? await item.loadTransferable(type: Data.self),
+              let image = UIImage(data: data) else {
+            avatarError = "Could not read image"
+            return
+        }
+        pendingCropImage = image
+    }
+
+    private func uploadCroppedData(_ data: Data) async {
+        avatarUploading = true
+        avatarError = nil
+        defer { avatarUploading = false }
+        do {
+            let url = try await APIClient.shared.uploadAvatar(data, mimeType: "image/jpeg")
+            avatarURL = url
+            await authStore.validateToken()
+        } catch {
+            avatarError = "Upload failed: \(error.localizedDescription)"
+        }
+    }
+
+    // MARK: - Avatar picker
+
+    @ViewBuilder
+    private var avatarPicker: some View {
+        PhotosPicker(selection: $photoPickerItem,
+                     matching: .images,
+                     photoLibrary: .shared()) {
+            ZStack {
+                Circle()
+                    .fill(Color(.systemGray5))
+                    .frame(width: 72, height: 72)
+
+                if avatarUploading {
+                    ProgressView()
+                        .frame(width: 72, height: 72)
+                } else if let urlStr = avatarURL ?? authStore.user?.avatarURL,
+                          let url = URL(string: urlStr) {
+                    KFImage(url)
+                        .placeholder {
+                            Image(systemName: "person.circle.fill")
+                                .font(.system(size: 52))
+                                .foregroundStyle(.amber)
+                        }
+                        .resizable()
+                        .scaledToFill()
+                        .frame(width: 72, height: 72)
+                        .clipShape(Circle())
+                } else {
+                    Image(systemName: "person.circle.fill")
+                        .font(.system(size: 52))
+                        .foregroundStyle(.amber)
+                        .frame(width: 72, height: 72)
+                }
+
+                // Camera badge
+                if !avatarUploading {
+                    VStack {
+                        Spacer()
+                        HStack {
+                            Spacer()
+                            ZStack {
+                                Circle().fill(Color.amber).frame(width: 22, height: 22)
+                                Image(systemName: "camera.fill")
+                                    .font(.system(size: 10, weight: .semibold))
+                                    .foregroundStyle(.black)
+                            }
+                            .offset(x: 2, y: 2)
+                        }
+                    }
+                    .frame(width: 72, height: 72)
+                }
+            }
+        }
+        .buttonStyle(.plain)
+        .onChange(of: photoPickerItem) { _, item in
+            guard let item else { return }
+            Task { await loadImageForCrop(item) }
+        }
+    }
+
+    // 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 (local copy — mirrors ProfileView.SessionRow)
+
+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: - CropImageItem (Identifiable wrapper for the sheet)
+
+private struct CropImageItem: Identifiable {
+    let id = UUID()
+    let image: UIImage
+}

ios/LibNovel/LibNovel/Views/Profile/AvatarCropView.swift

@@ -0,0 +1,270 @@
+import SwiftUI
+
+// MARK: - AvatarCropView
+// A sheet that lets the user pan and pinch a photo to fill a 1:1 circular crop region.
+// Call: .sheet(item: $cropImage) { AvatarCropView(image: $0.image, onConfirm: { croppedData in … }) }
+
+struct AvatarCropView: View {
+    let image: UIImage
+    let onConfirm: (Data) -> Void
+    let onCancel: () -> Void
+
+    // Crop circle diameter (points)
+    private let cropSize: CGFloat = 280
+
+    // Pan/zoom state — all in screen points, relative to the image's natural fill-fitted frame
+    @State private var scale: CGFloat = 1.0
+    @State private var lastScale: CGFloat = 1.0
+    @State private var offset: CGSize = .zero
+    @State private var lastOffset: CGSize = .zero
+
+    // Container size captured from GeometryReader
+    @State private var containerSize: CGSize = .zero
+
+    var body: some View {
+        NavigationStack {
+            GeometryReader { geo in
+                ZStack {
+                    Color.black.ignoresSafeArea()
+
+                    // Draggable / pinchable image
+                    Image(uiImage: image)
+                        .resizable()
+                        .scaledToFill()
+                        .frame(width: geo.size.width, height: geo.size.height)
+                        .scaleEffect(scale, anchor: .center)
+                        .offset(offset)
+                        .gesture(
+                            SimultaneousGesture(
+                                MagnificationGesture()
+                                    .onChanged { value in
+                                        let proposed = lastScale * value
+                                        scale = max(minScale(in: geo.size), proposed)
+                                    }
+                                    .onEnded { _ in
+                                        lastScale = scale
+                                        clampOffset(in: geo.size)
+                                        lastOffset = offset
+                                    },
+                                DragGesture()
+                                    .onChanged { value in
+                                        let proposed = CGSize(
+                                            width: lastOffset.width + value.translation.width,
+                                            height: lastOffset.height + value.translation.height
+                                        )
+                                        offset = clampedOffset(proposed, in: geo.size)
+                                    }
+                                    .onEnded { _ in
+                                        lastOffset = offset
+                                    }
+                            )
+                        )
+                        .clipped()
+
+                    // Dim overlay with transparent crop circle cut out
+                    CropOverlay(cropSize: cropSize, containerSize: geo.size)
+                        .allowsHitTesting(false)
+                }
+                .onAppear {
+                    containerSize = geo.size
+                    fitImageInitially(in: geo.size)
+                }
+            }
+            .navigationTitle("Crop Photo")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .topBarLeading) {
+                    Button("Cancel", action: onCancel)
+                        .foregroundStyle(.white)
+                }
+                ToolbarItem(placement: .topBarTrailing) {
+                    Button("Use Photo") {
+                        confirmCrop()
+                    }
+                    .fontWeight(.semibold)
+                    .foregroundStyle(.amber)
+                }
+            }
+            .toolbarColorScheme(.dark, for: .navigationBar)
+        }
+    }
+
+    // MARK: - Initial fit
+
+    private func fitImageInitially(in size: CGSize) {
+        // The image is displayed with .scaledToFill() in the container (size).
+        // That means one dimension equals the container and the other overflows.
+        // We want the image to be just large enough that the crop circle is fully
+        // covered — i.e. the fill-fitted image's shorter displayed dimension >= cropSize.
+        //
+        // .scaledToFill fills the container, so the image already covers the container.
+        // The minimum scale that covers the crop square is therefore 1.0 (image already
+        // fills container which is >= cropSize on both axes).
+        // We keep scale = 1.0 and centre the offset.
+        scale = 1.0
+        lastScale = 1.0
+        offset = .zero
+        lastOffset = .zero
+    }
+
+    // MARK: - Clamping helpers
+
+    /// Minimum scale: the image (at .scaledToFill in container) must cover the crop square.
+    /// At scale=1 the image already fills the container; cropSize <= container dimension,
+    /// so 1.0 is always sufficient. We cap at 1.0 to prevent zooming out below fill.
+    private func minScale(in containerSize: CGSize) -> CGFloat {
+        return 1.0
+    }
+
+    /// The displayed (fill-fitted) image size in the container at the given user scale.
+    private func displayedImageSize(in containerSize: CGSize, userScale: CGFloat) -> CGSize {
+        let imgAspect = image.size.width / image.size.height
+        let containerAspect = containerSize.width / containerSize.height
+
+        // .scaledToFill base size before user scale
+        let baseWidth: CGFloat
+        let baseHeight: CGFloat
+        if imgAspect > containerAspect {
+            // image is wider — height fills container
+            baseHeight = containerSize.height
+            baseWidth = baseHeight * imgAspect
+        } else {
+            // image is taller — width fills container
+            baseWidth = containerSize.width
+            baseHeight = baseWidth / imgAspect
+        }
+        return CGSize(width: baseWidth * userScale, height: baseHeight * userScale)
+    }
+
+    /// Maximum offset so the crop square is always covered by the image.
+    private func clampedOffset(_ proposed: CGSize, in containerSize: CGSize) -> CGSize {
+        let displayed = displayedImageSize(in: containerSize, userScale: scale)
+        // Half of how much the image overflows the container on each axis
+        let maxX = max(0, (displayed.width - cropSize) / 2)
+        let maxY = max(0, (displayed.height - cropSize) / 2)
+        return CGSize(
+            width: min(maxX, max(-maxX, proposed.width)),
+            height: min(maxY, max(-maxY, proposed.height))
+        )
+    }
+
+    private func clampOffset(in containerSize: CGSize) {
+        offset = clampedOffset(offset, in: containerSize)
+    }
+
+    // MARK: - Crop
+
+    private func confirmCrop() {
+        let size = containerSize.width > 0 ? containerSize : CGSize(width: 390, height: 844)
+        let outputSize = CGSize(width: 400, height: 400)
+
+        // --- Step 1: compute the fill-fitted base display size ---
+        let imgAspect = image.size.width / image.size.height
+        let containerAspect = size.width / size.height
+
+        let baseDisplayW: CGFloat
+        let baseDisplayH: CGFloat
+        if imgAspect > containerAspect {
+            baseDisplayH = size.height
+            baseDisplayW = baseDisplayH * imgAspect
+        } else {
+            baseDisplayW = size.width
+            baseDisplayH = baseDisplayW / imgAspect
+        }
+
+        // Displayed image size after user zoom
+        let displayW = baseDisplayW * scale
+        let displayH = baseDisplayH * scale
+
+        // --- Step 2: the crop square centre is the container centre ---
+        // The image centre (after offset) in container coords:
+        let imageCentreX = size.width / 2 + offset.width
+        let imageCentreY = size.height / 2 + offset.height
+
+        // Top-left of the crop square in container coords:
+        let cropOriginX = (size.width - cropSize) / 2
+        let cropOriginY = (size.height - cropSize) / 2
+
+        // Top-left of the crop square relative to the image's top-left in display space:
+        let imageOriginX = imageCentreX - displayW / 2
+        let imageOriginY = imageCentreY - displayH / 2
+
+        let cropInImageX = cropOriginX - imageOriginX  // pixels in display space
+        let cropInImageY = cropOriginY - imageOriginY
+
+        // --- Step 3: convert display-space coords to image pixel coords ---
+        let displayToPixelX = image.size.width / displayW
+        let displayToPixelY = image.size.height / displayH
+
+        let pixelX = cropInImageX * displayToPixelX
+        let pixelY = cropInImageY * displayToPixelY
+        let pixelW = cropSize * displayToPixelX
+        let pixelH = cropSize * displayToPixelY
+
+        let cropRect = CGRect(x: pixelX, y: pixelY, width: pixelW, height: pixelH)
+            .intersection(CGRect(origin: .zero, size: image.size))
+
+        guard cropRect.width > 0, cropRect.height > 0 else {
+            // Fallback: use entire image
+            if let jpeg = image.jpegData(compressionQuality: 0.9) { onConfirm(jpeg) }
+            return
+        }
+
+        // --- Step 4: render cropped region into 400×400 ---
+        let renderer = UIGraphicsImageRenderer(size: outputSize)
+        let cropped = renderer.image { _ in
+            // Draw only the cropRect portion of the image scaled to fill outputSize
+            let destRect = CGRect(origin: .zero, size: outputSize)
+            // UIImage.draw(in:) draws the full image; we use CGImage cropping instead
+            if let cgImg = image.cgImage?.cropping(to: cropRect) {
+                let croppedUI = UIImage(cgImage: cgImg, scale: image.scale, orientation: image.imageOrientation)
+                croppedUI.draw(in: destRect)
+            } else {
+                image.draw(in: destRect)
+            }
+        }
+
+        if let jpeg = cropped.jpegData(compressionQuality: 0.9) {
+            onConfirm(jpeg)
+        }
+    }
+}
+
+// MARK: - Crop overlay
+
+private struct CropOverlay: View {
+    let cropSize: CGFloat
+    let containerSize: CGSize
+
+    var body: some View {
+        Canvas { context, size in
+            // Fill entire canvas with semi-transparent black
+            context.fill(Path(CGRect(origin: .zero, size: size)), with: .color(.black.opacity(0.55)))
+            // Cut out the crop circle in the centre
+            let origin = CGPoint(
+                x: (size.width - cropSize) / 2,
+                y: (size.height - cropSize) / 2
+            )
+            let cropRect = CGRect(origin: origin, size: CGSize(width: cropSize, height: cropSize))
+            context.blendMode = .destinationOut
+            context.fill(Path(ellipseIn: cropRect), with: .color(.white))
+        }
+        .compositingGroup()
+        .overlay {
+            // Amber circle border around the crop region
+            let origin = CGPoint(
+                x: (containerSize.width - cropSize) / 2,
+                y: (containerSize.height - cropSize) / 2
+            )
+            Circle()
+                .stroke(Color.amber.opacity(0.8), lineWidth: 2)
+                .frame(width: cropSize, height: cropSize)
+                .position(
+                    x: origin.x + cropSize / 2,
+                    y: origin.y + cropSize / 2
+                )
+        }
+        .frame(width: containerSize.width, height: containerSize.height)
+        .allowsHitTesting(false)
+    }
+}

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

@@ -0,0 +1,339 @@
+import SwiftUI
+import PhotosUI
+import Kingfisher
+
+struct ProfileView: View {
+    @EnvironmentObject var authStore: AuthStore
+    @StateObject private var vm = ProfileViewModel()
+    @State private var showChangePassword = false
+
+    // Avatar upload state
+    @State private var photoPickerItem: PhotosPickerItem?
+    @State private var pendingCropImage: UIImage?   // image waiting to be cropped
+    @State private var avatarURL: String? = nil
+    @State private var avatarUploading = false
+    @State private var avatarError: String?
+
+    var body: some View {
+        NavigationStack {
+            List {
+                // ── User header ────────────────────────────────────────────
+                Section {
+                    HStack(spacing: 16) {
+                        avatarPicker
+                        VStack(alignment: .leading, spacing: 3) {
+                            Text(authStore.user?.username ?? "")
+                                .font(.headline)
+                            Text(authStore.user?.role.capitalized ?? "")
+                                .font(.caption)
+                                .foregroundStyle(.secondary)
+                            if let err = avatarError {
+                                Text(err)
+                                    .font(.caption2)
+                                    .foregroundStyle(.red)
+                            }
+                        }
+                    }
+                    .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()
+            }
+            .sheet(item: Binding(
+                get: { pendingCropImage.map { CropImageItem(image: $0) } },
+                set: { if $0 == nil { pendingCropImage = nil } }
+            )) { item in
+                AvatarCropView(image: item.image) { croppedData in
+                    pendingCropImage = nil
+                    Task { await uploadCroppedData(croppedData) }
+                } onCancel: {
+                    pendingCropImage = nil
+                }
+            }
+            .errorAlert($vm.error)
+        }
+    }
+
+    // MARK: - Avatar upload
+
+    /// Step 1: Load the raw image from the picker and show the crop sheet.
+    private func loadImageForCrop(_ item: PhotosPickerItem) async {
+        guard let data = try? await item.loadTransferable(type: Data.self),
+              let image = UIImage(data: data) else {
+            avatarError = "Could not read image"
+            return
+        }
+        pendingCropImage = image
+    }
+
+    /// Step 2: Called by AvatarCropView once the user confirms. Upload the cropped JPEG.
+    private func uploadCroppedData(_ data: Data) async {
+        avatarUploading = true
+        avatarError = nil
+        defer { avatarUploading = false }
+        do {
+            let url = try await APIClient.shared.uploadAvatar(data, mimeType: "image/jpeg")
+            avatarURL = url
+            // Refresh user record so the new avatar persists across sessions
+            await authStore.validateToken()
+        } catch {
+            avatarError = "Upload failed: \(error.localizedDescription)"
+        }
+    }
+
+    // MARK: - Avatar picker
+
+    @ViewBuilder
+    private var avatarPicker: some View {
+        PhotosPicker(selection: $photoPickerItem,
+                     matching: .images,
+                     photoLibrary: .shared()) {
+            ZStack {
+                Circle()
+                    .fill(Color(.systemGray5))
+                    .frame(width: 72, height: 72)
+
+                if avatarUploading {
+                    ProgressView()
+                        .frame(width: 72, height: 72)
+                } else if let urlStr = avatarURL ?? authStore.user?.avatarURL,
+                          let url = URL(string: urlStr) {
+                    KFImage(url)
+                        .placeholder {
+                            Image(systemName: "person.circle.fill")
+                                .font(.system(size: 52))
+                                .foregroundStyle(.amber)
+                        }
+                        .resizable()
+                        .scaledToFill()
+                        .frame(width: 72, height: 72)
+                        .clipShape(Circle())
+                } else {
+                    Image(systemName: "person.circle.fill")
+                        .font(.system(size: 52))
+                        .foregroundStyle(.amber)
+                        .frame(width: 72, height: 72)
+                }
+
+                // Camera overlay badge
+                if !avatarUploading {
+                    VStack {
+                        Spacer()
+                        HStack {
+                            Spacer()
+                            ZStack {
+                                Circle()
+                                    .fill(Color.amber)
+                                    .frame(width: 22, height: 22)
+                                Image(systemName: "camera.fill")
+                                    .font(.system(size: 10, weight: .semibold))
+                                    .foregroundStyle(.black)
+                            }
+                            .offset(x: 2, y: 2)
+                        }
+                    }
+                    .frame(width: 72, height: 72)
+                }
+            }
+        }
+        .buttonStyle(.plain)
+        .onChange(of: photoPickerItem) { _, item in
+            guard let item else { return }
+            Task { await loadImageForCrop(item) }
+        }
+    }
+
+    // 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
+        }
+    }
+}
+
+// MARK: - Crop image item (Identifiable wrapper for .sheet(item:))
+
+private struct CropImageItem: Identifiable {
+    let id = UUID()
+    let image: UIImage
+}

ios/LibNovel/LibNovel/Views/Profile/UserProfileView.swift

@@ -0,0 +1,209 @@
+import SwiftUI
+
+struct UserProfileView: View {
+    let username: String
+
+    @StateObject private var vm: UserProfileViewModel
+    @EnvironmentObject private var authStore: AuthStore
+
+    init(username: String) {
+        self.username = username
+        _vm = StateObject(wrappedValue: UserProfileViewModel(username: username))
+    }
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 0) {
+                if vm.isLoading && vm.profile == nil {
+                    ProgressView()
+                        .frame(maxWidth: .infinity)
+                        .padding(.top, 60)
+                } else if let profile = vm.profile {
+                    profileHeader(profile)
+                        .padding(.bottom, 28)
+
+                    if !vm.currentlyReading.isEmpty {
+                        ShelfHeader(title: "Currently Reading")
+                        ScrollView(.horizontal, showsIndicators: false) {
+                            HStack(alignment: .top, spacing: 14) {
+                                ForEach(vm.currentlyReading) { item in
+                                    NavigationLink(value: NavDestination.book(item.book.slug)) {
+                                        ProfileBookCard(item: item)
+                                    }
+                                    .buttonStyle(.plain)
+                                }
+                            }
+                            .padding(.horizontal)
+                            .padding(.bottom, 4)
+                        }
+                        .padding(.bottom, 28)
+                    }
+
+                    if !vm.library.isEmpty {
+                        ShelfHeader(title: "Library")
+                        ScrollView(.horizontal, showsIndicators: false) {
+                            HStack(alignment: .top, spacing: 14) {
+                                ForEach(vm.library) { item in
+                                    NavigationLink(value: NavDestination.book(item.book.slug)) {
+                                        ProfileBookCard(item: item)
+                                    }
+                                    .buttonStyle(.plain)
+                                }
+                            }
+                            .padding(.horizontal)
+                            .padding(.bottom, 4)
+                        }
+                        .padding(.bottom, 28)
+                    }
+
+                    if vm.currentlyReading.isEmpty && vm.library.isEmpty && !vm.isLoading {
+                        EmptyStateView(
+                            icon: "books.vertical",
+                            title: "No books yet",
+                            message: "\(username) hasn't read anything yet."
+                        )
+                        .frame(maxWidth: .infinity)
+                        .padding(.top, 20)
+                    }
+                } else if let err = vm.error {
+                    EmptyStateView(icon: "exclamationmark.triangle", title: "Error", message: err)
+                        .frame(maxWidth: .infinity)
+                        .padding(.top, 60)
+                }
+
+                Color.clear.frame(height: 20)
+            }
+        }
+        .navigationTitle("@\(username)")
+        .navigationBarTitleDisplayMode(.inline)
+        .task { await vm.load() }
+        .refreshable { await vm.load() }
+        .errorAlert($vm.error)
+    }
+
+    // MARK: - Profile header
+
+    @ViewBuilder
+    private func profileHeader(_ profile: PublicUserProfile) -> some View {
+        VStack(alignment: .center, spacing: 16) {
+            AvatarThumb(urlString: profile.avatarUrl, size: 80)
+
+            VStack(spacing: 4) {
+                Text("@\(profile.username)")
+                    .font(.title3.bold())
+                if !profile.created.isEmpty {
+                    Text("Joined \(shortDate(profile.created))")
+                        .font(.caption)
+                        .foregroundStyle(.secondary)
+                }
+            }
+
+            // Stats row
+            HStack(spacing: 32) {
+                VStack(spacing: 2) {
+                    Text("\(profile.followerCount)")
+                        .font(.subheadline.bold().monospacedDigit())
+                    Text("Followers")
+                        .font(.caption2)
+                        .foregroundStyle(.secondary)
+                }
+                VStack(spacing: 2) {
+                    Text("\(profile.followingCount)")
+                        .font(.subheadline.bold().monospacedDigit())
+                    Text("Following")
+                        .font(.caption2)
+                        .foregroundStyle(.secondary)
+                }
+            }
+
+            // Follow button — only shown for other users (not self)
+            if !profile.isSelf && authStore.isAuthenticated {
+                Button {
+                    Task { await vm.toggleSubscribe() }
+                } label: {
+                    if vm.isTogglingSubscribe {
+                        ProgressView().controlSize(.small)
+                            .frame(width: 120, height: 34)
+                    } else if profile.isSubscribed {
+                        Label("Following", systemImage: "checkmark")
+                            .font(.subheadline.bold())
+                            .frame(width: 120, height: 34)
+                    } else {
+                        Text("Follow")
+                            .font(.subheadline.bold())
+                            .frame(width: 120, height: 34)
+                    }
+                }
+                .buttonStyle(.borderedProminent)
+                .tint(profile.isSubscribed ? Color(.systemGray4) : .amber)
+                .disabled(vm.isTogglingSubscribe)
+            }
+        }
+        .frame(maxWidth: .infinity)
+        .padding(.top, 24)
+        .padding(.horizontal)
+    }
+
+    private func shortDate(_ iso: String) -> String {
+        let formatter = DateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd HH:mm:ss.SSSZ"
+        if let date = formatter.date(from: iso) {
+            let out = DateFormatter()
+            out.dateStyle = .medium
+            out.timeStyle = .none
+            return out.string(from: date)
+        }
+        return String(iso.prefix(10))
+    }
+}
+
+// MARK: - Shelf header
+
+private struct ShelfHeader: View {
+    let title: String
+    var body: some View {
+        Text(title)
+            .font(.title3.bold())
+            .padding(.horizontal)
+            .padding(.bottom, 10)
+    }
+}
+
+// MARK: - Book card for profile shelves
+
+private struct ProfileBookCard: View {
+    let item: PublicLibraryItem
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            ZStack(alignment: .bottomLeading) {
+                AsyncCoverImage(url: item.book.cover)
+                    .frame(width: 110, height: 158)
+                    .clipShape(RoundedRectangle(cornerRadius: 8))
+                    .shadow(color: .black.opacity(0.12), radius: 4, y: 2)
+
+                // Chapter badge (if reading)
+                if let ch = item.lastChapter, ch > 0 {
+                    Text("Ch.\(ch)")
+                        .font(.system(size: 10, weight: .bold))
+                        .foregroundStyle(.black.opacity(0.85))
+                        .padding(.horizontal, 7)
+                        .padding(.vertical, 4)
+                        .background(Capsule().fill(Color.amber))
+                        .padding(6)
+                }
+            }
+
+            Text(item.book.title)
+                .font(.caption.bold())
+                .lineLimit(2)
+                .frame(width: 110, alignment: .leading)
+
+            Text(item.book.author)
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+                .lineLimit(1)
+                .frame(width: 110, alignment: .leading)
+        }
+    }
+}

ios/LibNovel/LibNovel/Views/Search/SearchView.swift

@@ -0,0 +1,247 @@
+import SwiftUI
+
+// MARK: - SearchView
+// Dedicated search tab modelled after Apple Books' Search screen.
+// Shows a prominent search bar; while idle displays recent searches and
+// trending/popular novels; after a query shows a results grid.
+
+struct SearchView: View {
+    @StateObject private var vm = SearchViewModel()
+
+    var body: some View {
+        NavigationStack {
+            VStack(spacing: 0) {
+                // ── Search bar ──────────────────────────────────────────────
+                HStack(spacing: 8) {
+                    Image(systemName: "magnifyingglass")
+                        .foregroundStyle(.secondary)
+                    TextField("Search novels, authors…", text: $vm.query)
+                        .textInputAutocapitalization(.never)
+                        .autocorrectionDisabled()
+                        .submitLabel(.search)
+                        .onSubmit { vm.submitSearch() }
+                    if !vm.query.isEmpty {
+                        Button { vm.clear() } label: {
+                            Image(systemName: "xmark.circle.fill")
+                                .foregroundStyle(.secondary)
+                        }
+                    }
+                }
+                .padding(10)
+                .background(Color(.systemGray6), in: RoundedRectangle(cornerRadius: 10))
+                .padding(.horizontal)
+                .padding(.top, 8)
+                .padding(.bottom, 12)
+
+                Divider()
+
+                // ── Content ─────────────────────────────────────────────────
+                if vm.query.isEmpty && vm.results.isEmpty {
+                    idleContent
+                } else if vm.isLoading {
+                    ProgressView()
+                        .frame(maxWidth: .infinity, maxHeight: .infinity)
+                } else if vm.results.isEmpty {
+                    EmptyStateView(
+                        icon: "magnifyingglass",
+                        title: "No results",
+                        message: "Try a different title or author name."
+                    )
+                    .frame(maxWidth: .infinity, maxHeight: .infinity)
+                } else {
+                    resultsGrid
+                }
+            }
+            .navigationTitle("Search")
+            .appNavigationDestination()
+            .toolbar {
+                ToolbarItem(placement: .topBarTrailing) {
+                    AvatarToolbarButton()
+                }
+            }
+        }
+    }
+
+    // MARK: - Idle screen (recent searches + popular)
+
+    @ViewBuilder
+    private var idleContent: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 24) {
+                // Recent searches
+                if !vm.recentSearches.isEmpty {
+                    VStack(alignment: .leading, spacing: 0) {
+                        HStack {
+                            Text("Recent")
+                                .font(.title3.bold())
+                            Spacer()
+                            Button("Clear") { vm.clearRecent() }
+                                .font(.subheadline)
+                                .foregroundStyle(.amber)
+                        }
+                        .padding(.horizontal)
+                        .padding(.bottom, 10)
+
+                        ForEach(vm.recentSearches, id: \.self) { term in
+                            Button {
+                                vm.query = term
+                                vm.submitSearch()
+                            } label: {
+                                HStack {
+                                    Image(systemName: "clock")
+                                        .foregroundStyle(.secondary)
+                                        .frame(width: 20)
+                                    Text(term)
+                                        .foregroundStyle(.primary)
+                                    Spacer()
+                                    Image(systemName: "arrow.up.left")
+                                        .font(.caption)
+                                        .foregroundStyle(.tertiary)
+                                }
+                                .padding(.horizontal)
+                                .padding(.vertical, 11)
+                            }
+                            Divider().padding(.leading, 44)
+                        }
+                    }
+                }
+
+                // Popular / trending novels (loaded from browse popular)
+                if !vm.popular.isEmpty {
+                    VStack(alignment: .leading, spacing: 10) {
+                        Text("Popular")
+                            .font(.title3.bold())
+                            .padding(.horizontal)
+
+                        LazyVGrid(
+                            columns: [
+                                GridItem(.flexible(), spacing: 12),
+                                GridItem(.flexible(), spacing: 12)
+                            ],
+                            spacing: 16
+                        ) {
+                            ForEach(vm.popular) { novel in
+                                NavigationLink(value: NavDestination.book(novel.slug)) {
+                                    SearchNovelCard(novel: novel)
+                                }
+                                .buttonStyle(.plain)
+                            }
+                        }
+                        .padding(.horizontal)
+                    }
+                }
+
+                Color.clear.frame(height: 20)
+            }
+            .padding(.top, 16)
+        }
+    }
+
+    // MARK: - Results grid
+
+    @ViewBuilder
+    private var resultsGrid: some View {
+        ScrollView {
+            LazyVGrid(
+                columns: [
+                    GridItem(.flexible(), spacing: 12),
+                    GridItem(.flexible(), spacing: 12)
+                ],
+                spacing: 16
+            ) {
+                ForEach(vm.results) { novel in
+                    NavigationLink(value: NavDestination.book(novel.slug)) {
+                        SearchNovelCard(novel: novel)
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+            .padding()
+        }
+    }
+}
+
+// MARK: - Search novel card (compact 2-column)
+
+private struct SearchNovelCard: View {
+    let novel: BrowseNovel
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            AsyncCoverImage(url: novel.cover)
+                .frame(maxWidth: .infinity)
+                .aspectRatio(2/3, contentMode: .fit)
+                .clipShape(RoundedRectangle(cornerRadius: 8))
+                .shadow(color: .black.opacity(0.12), radius: 4, y: 2)
+                .bookCoverZoomSource(slug: novel.slug)
+
+            Text(novel.title)
+                .font(.subheadline.bold())
+                .lineLimit(2)
+                .fixedSize(horizontal: false, vertical: true)
+        }
+    }
+}
+
+// MARK: - SearchViewModel
+
+@MainActor
+final class SearchViewModel: ObservableObject {
+    @Published var query: String = ""
+    @Published var results: [BrowseNovel] = []
+    @Published var popular: [BrowseNovel] = []
+    @Published var isLoading = false
+
+    // Persisted in UserDefaults (max 10 recent terms)
+    @Published var recentSearches: [String] = []
+
+    private let recentKey = "searchRecentTerms"
+
+    init() {
+        recentSearches = (UserDefaults.standard.stringArray(forKey: recentKey) ?? [])
+        Task { await loadPopular() }
+    }
+
+    func submitSearch() {
+        let term = query.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !term.isEmpty else { return }
+        saveRecent(term)
+        Task { await runSearch(term) }
+    }
+
+    func clear() {
+        query = ""
+        results = []
+    }
+
+    func clearRecent() {
+        recentSearches = []
+        UserDefaults.standard.removeObject(forKey: recentKey)
+    }
+
+    private func runSearch(_ term: String) async {
+        isLoading = true
+        do {
+            let result = try await APIClient.shared.search(query: term)
+            results = result.results
+        } catch {
+            results = []
+        }
+        isLoading = false
+    }
+
+    private func loadPopular() async {
+        do {
+            let result = try await APIClient.shared.browse(page: 1, genre: "all", sort: "popular", status: "all")
+            popular = Array(result.novels.prefix(12))
+        } catch {}
+    }
+
+    private func saveRecent(_ term: String) {
+        var list = recentSearches.filter { $0 != term }
+        list.insert(term, at: 0)
+        if list.count > 10 { list = Array(list.prefix(10)) }
+        recentSearches = list
+        UserDefaults.standard.set(list, forKey: recentKey)
+    }
+}

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,36 @@
+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 - signing settings are in project.yml Release config
+    build_app(
+      scheme: "LibNovel",
+      export_method: "app-store",
+      clean: true,
+      configuration: "Release",
+      export_options: {
+        method: "app-store",
+        teamID: "GHZXC6FVMU",
+        provisioningProfiles: {
+          "com.kalekber.LibNovel" => "LibNovel Distribution"
+        },
+        signingStyle: "manual"
+      }
+    )
+
+    # Upload to TestFlight
+    upload_to_testflight(
+      skip_waiting_for_build_processing: true
+    )
+  end
+end

ios/LibNovel/project.yml

@@ -0,0 +1,91 @@
+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
+          CODE_SIGN_IDENTITY: "Apple Distribution"
+          PROVISIONING_PROFILE: "af592c3a-f60b-4ac1-a14f-30b8a206017f"
+
+  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

ios/LibNovel/test-build.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+set -e
+
+# Test script for local iOS build iteration
+# Run from ios/LibNovel directory
+
+echo "=== Generating Xcode project ==="
+xcodegen generate --spec project.yml --project .
+
+echo ""
+echo "=== Listing available provisioning profiles ==="
+ls -la ~/Library/MobileDevice/Provisioning\ Profiles/ || echo "No profiles found"
+
+echo ""
+echo "=== Listing available signing identities ==="
+security find-identity -v -p codesigning
+
+echo ""
+echo "=== Attempting archive build ==="
+xcodebuild archive \
+  -project LibNovel.xcodeproj \
+  -scheme LibNovel \
+  -configuration Release \
+  -destination 'generic/platform=iOS' \
+  -archivePath ./build/LibNovel.xcarchive \
+  -allowProvisioningUpdates \
+  CODE_SIGN_STYLE=Manual \
+  CODE_SIGN_IDENTITY="Apple Distribution" \
+  DEVELOPMENT_TEAM="GHZXC6FVMU"
+
+echo ""
+echo "=== Build succeeded! ==="

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/Dockerfile

@@ -9,8 +9,14 @@ RUN go mod download
 
 COPY . .
 
+# Build-time version info — injected by docker-compose or CI via --build-arg.
+ARG VERSION=dev
+ARG COMMIT=unknown
+
 RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \
-    go build -ldflags="-s -w" -o /scraper ./cmd/scraper
+    go build \
+      -ldflags="-s -w -X main.Version=${VERSION} -X main.Commit=${COMMIT}" \
+      -o /scraper ./cmd/scraper
 
 # ── Runtime stage ──────────────────────────────────────────────────────────────
 FROM alpine:3.21

scraper/cmd/scraper/main.go

@@ -47,6 +47,13 @@ import (
 	"github.com/libnovel/scraper/internal/storage"
 )
 
+// Build-time version info — injected via -ldflags during docker build.
+// Falls back to "dev" / "unknown" when built without -ldflags (local dev).
+var (
+	Version = "dev"
+	Commit  = "unknown"
+)
+
 func main() {
 	logLevel := slog.LevelInfo
 	if v := os.Getenv("LOG_LEVEL"); v != "" {
@@ -95,6 +102,7 @@ func run(log *slog.Logger) error {
 		BucketChapters: envOr("MINIO_BUCKET_CHAPTERS", "libnovel-chapters"),
 		BucketAudio:    envOr("MINIO_BUCKET_AUDIO", "libnovel-audio"),
 		BucketBrowse:   envOr("MINIO_BUCKET_BROWSE", "libnovel-browse"),
+		BucketAvatars:  envOr("MINIO_BUCKET_AVATARS", "libnovel-avatars"),
 	}
 	pbCfg := storage.PocketBaseConfig{
 		BaseURL:       envOr("POCKETBASE_URL", "http://localhost:8090"),
@@ -182,7 +190,7 @@ func run(log *slog.Logger) error {
 			"pocketbase_url", pbCfg.BaseURL,
 			"pocketbase_email", pbCfg.AdminEmail,
 		)
-		srv := server.New(addr, oCfg, nf, log, store, kokoroURL, kokoroVoice)
+		srv := server.New(addr, oCfg, nf, log, store, kokoroURL, kokoroVoice, Version, Commit)
 		return srv.ListenAndServe(ctx)
 
 	case "save-browse":

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

@@ -151,12 +151,20 @@ func (s *mockStore) PresignChapter(_ context.Context, _ string, _ int, _ time.Du
 func (s *mockStore) PresignAudio(_ context.Context, _ string, _ time.Duration) (string, error) {
 	return "", nil
 }
+func (s *mockStore) PresignAvatarUpload(_ context.Context, _, _ string) (string, string, error) {
+	return "", "", nil
+}
+func (s *mockStore) PresignAvatarURL(_ context.Context, _ string) (string, bool, error) {
+	return "", false, nil
+}
+func (s *mockStore) DeleteAvatar(_ context.Context, _ string) error      { return nil }
 func (s *mockStore) SaveBrowsePage(_ context.Context, _, _ string) error { return nil }
 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 +180,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)
@@ -539,3 +649,64 @@ func (s *Server) handlePresignVoiceSample(w http.ResponseWriter, r *http.Request
 	w.Header().Set("Content-Type", "application/json")
 	_ = json.NewEncoder(w).Encode(map[string]string{"url": url})
 }
+
+// handlePresignAvatarUpload handles GET /api/presign/avatar-upload/{userId}.
+// Returns a short-lived presigned PUT URL for uploading an avatar image directly
+// to MinIO, along with the object key to record in PocketBase after the upload.
+// Query param: ext — image extension (jpg, png, webp). Defaults to "jpg".
+func (s *Server) handlePresignAvatarUpload(w http.ResponseWriter, r *http.Request) {
+	userID := r.PathValue("userId")
+	if userID == "" {
+		http.Error(w, `{"error":"missing userId"}`, http.StatusBadRequest)
+		return
+	}
+
+	ext := r.URL.Query().Get("ext")
+	switch ext {
+	case "jpg", "jpeg":
+		ext = "jpg"
+	case "png":
+		ext = "png"
+	case "webp":
+		ext = "webp"
+	default:
+		ext = "jpg"
+	}
+
+	uploadURL, key, err := s.store.PresignAvatarUpload(r.Context(), userID, ext)
+	if err != nil {
+		s.log.Error("presign avatar upload failed", "userId", userID, "err", err)
+		http.Error(w, `{"error":"presign failed"}`, http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(map[string]string{
+		"upload_url": uploadURL,
+		"key":        key,
+	})
+}
+
+// handlePresignAvatar handles GET /api/presign/avatar/{userId}.
+// Returns a presigned GET URL for a user's existing avatar, or 404 if none.
+func (s *Server) handlePresignAvatar(w http.ResponseWriter, r *http.Request) {
+	userID := r.PathValue("userId")
+	if userID == "" {
+		http.Error(w, `{"error":"missing userId"}`, http.StatusBadRequest)
+		return
+	}
+
+	url, found, err := s.store.PresignAvatarURL(r.Context(), userID)
+	if err != nil {
+		s.log.Error("presign avatar failed", "userId", userID, "err", err)
+		http.Error(w, `{"error":"presign failed"}`, http.StatusInternalServerError)
+		return
+	}
+	if !found {
+		http.NotFound(w, r)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(map[string]string{"url": url})
+}

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
 
@@ -42,16 +43,18 @@ type Server struct {
 	running     bool
 	kokoroURL   string // Kokoro-FastAPI base URL, e.g. http://kokoro:8880
 	kokoroVoice string // default voice, e.g. af_bella
+	version     string // semver tag, e.g. "v1.2.3" (set via ldflags)
+	commit      string // short git SHA (set via ldflags)
 
 	// voiceMu guards cachedVoices.
 	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.
@@ -73,7 +76,7 @@ type browseCacheEntry struct {
 }
 
 // New creates a new Server.
-func New(addr string, oCfg orchestrator.Config, novel scraper.NovelScraper, log *slog.Logger, store storage.Store, kokoroURL, kokoroVoice string) *Server {
+func New(addr string, oCfg orchestrator.Config, novel scraper.NovelScraper, log *slog.Logger, store storage.Store, kokoroURL, kokoroVoice, version, commit string) *Server {
 	return &Server{
 		addr:           addr,
 		oCfg:           oCfg,
@@ -82,7 +85,9 @@ func New(addr string, oCfg orchestrator.Config, novel scraper.NovelScraper, log
 		store:          store,
 		kokoroURL:      kokoroURL,
 		kokoroVoice:    kokoroVoice,
-		audioInFlight:  make(map[string]chan struct{}),
+		version:        version,
+		commit:         commit,
+		audioJobIDs:    make(map[string]string),
 		browseInFlight: make(map[string]struct{}),
 		browseMemCache: make(map[string]browseCacheEntry),
 	}
@@ -137,6 +142,7 @@ func (s *Server) voices() []string {
 func (s *Server) ListenAndServe(ctx context.Context) error {
 	mux := http.NewServeMux()
 	mux.HandleFunc("GET /health", s.handleHealth)
+	mux.HandleFunc("GET /api/version", s.handleVersion)
 	mux.HandleFunc("POST /scrape", s.handleScrapeCatalogue)
 	mux.HandleFunc("POST /scrape/book", s.handleScrapeBook)
 	mux.HandleFunc("POST /scrape/book/range", s.handleScrapeBookRange)
@@ -164,6 +170,8 @@ func (s *Server) ListenAndServe(ctx context.Context) error {
 	mux.HandleFunc("GET /api/presign/chapter/{slug}/{n}", s.handlePresignChapter)
 	mux.HandleFunc("GET /api/presign/audio/{slug}/{n}", s.handlePresignAudio)
 	mux.HandleFunc("GET /api/presign/voice-sample/{voice}", s.handlePresignVoiceSample)
+	mux.HandleFunc("GET /api/presign/avatar-upload/{userId}", s.handlePresignAvatarUpload)
+	mux.HandleFunc("GET /api/presign/avatar/{userId}", s.handlePresignAvatar)
 	// Plain-text chapter content (used server-side for audio generation)
 	mux.HandleFunc("GET /api/chapter-text/{slug}/{n}", s.handleChapterText)
 	// Voices list (proxied from Kokoro)
@@ -177,13 +185,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)
 
@@ -221,7 +227,19 @@ func (s *Server) ListenAndServe(ctx context.Context) error {
 
 func (s *Server) handleHealth(w http.ResponseWriter, _ *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
-	_ = json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
+	_ = json.NewEncoder(w).Encode(map[string]string{
+		"status":  "ok",
+		"version": s.version,
+		"commit":  s.commit,
+	})
+}
+
+func (s *Server) handleVersion(w http.ResponseWriter, _ *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(map[string]string{
+		"version": s.version,
+		"commit":  s.commit,
+	})
 }
 
 // ─── Session cookie helpers ───────────────────────────────────────────────────

scraper/internal/storage/hybrid.go

@@ -316,6 +316,18 @@ func (h *HybridStore) PresignAudio(ctx context.Context, key string, expires time
 	return h.minio.PresignAudio(ctx, key, expires)
 }
 
+func (h *HybridStore) PresignAvatarUpload(ctx context.Context, userID, ext string) (string, string, error) {
+	return h.minio.PresignAvatarUploadURL(ctx, userID, ext)
+}
+
+func (h *HybridStore) PresignAvatarURL(ctx context.Context, userID string) (string, bool, error) {
+	return h.minio.PresignAvatarURL(ctx, userID)
+}
+
+func (h *HybridStore) DeleteAvatar(ctx context.Context, userID string) error {
+	return h.minio.DeleteAvatar(ctx, userID)
+}
+
 // ─── Browse page snapshots ────────────────────────────────────────────────────
 
 func (h *HybridStore) SaveBrowsePage(ctx context.Context, key, html string) error {
@@ -330,6 +342,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 +408,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

@@ -23,6 +23,7 @@ type MinioConfig struct {
 	BucketChapters string // e.g. "libnovel-chapters"
 	BucketAudio    string // e.g. "libnovel-audio"
 	BucketBrowse   string // e.g. "libnovel-browse"
+	BucketAvatars  string // e.g. "libnovel-avatars"
 }
 
 // MinioClient wraps a minio.Client and exposes object operations for
@@ -59,7 +60,7 @@ func NewMinioClient(ctx context.Context, cfg MinioConfig) (*MinioClient, error)
 	}
 
 	mc := &MinioClient{c: c, pub: pub, cfg: cfg}
-	for _, bucket := range []string{cfg.BucketChapters, cfg.BucketAudio, cfg.BucketBrowse} {
+	for _, bucket := range []string{cfg.BucketChapters, cfg.BucketAudio, cfg.BucketBrowse, cfg.BucketAvatars} {
 		if bucket == "" {
 			continue
 		}
@@ -223,10 +224,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 {
@@ -313,3 +337,77 @@ func sanitiseVoice(voice string) string {
 		return '_'
 	}, voice)
 }
+
+// ─── Avatar objects ───────────────────────────────────────────────────────────
+
+// avatarKey returns the MinIO object key for a user avatar.
+// Layout: avatars/{userId}.{ext}
+func avatarKey(userID, ext string) string {
+	return fmt.Sprintf("avatars/%s.%s", userID, ext)
+}
+
+// PutAvatar stores an avatar image in the avatars bucket.
+// ext should be "jpg", "png", or "webp".
+func (m *MinioClient) PutAvatar(ctx context.Context, userID, ext string, data []byte, contentType string) error {
+	if m.cfg.BucketAvatars == "" {
+		return fmt.Errorf("minio: avatars bucket not configured")
+	}
+	key := avatarKey(userID, ext)
+	_, err := m.c.PutObject(ctx, m.cfg.BucketAvatars, key,
+		bytes.NewReader(data), int64(len(data)),
+		minio.PutObjectOptions{ContentType: contentType})
+	if err != nil {
+		return fmt.Errorf("minio: put avatar %s: %w", key, err)
+	}
+	return nil
+}
+
+// PresignAvatarUploadURL returns a presigned PUT URL for uploading an avatar image
+// directly to MinIO from the client. Signed with the public endpoint so iOS/browser
+// can PUT bytes straight to MinIO without routing through the server.
+// ext should be "jpg", "png", or "webp". Expires in 15 minutes.
+func (m *MinioClient) PresignAvatarUploadURL(ctx context.Context, userID, ext string) (string, string, error) {
+	if m.cfg.BucketAvatars == "" {
+		return "", "", fmt.Errorf("minio: avatars bucket not configured")
+	}
+	key := avatarKey(userID, ext)
+	u, err := m.pub.PresignedPutObject(ctx, m.cfg.BucketAvatars, key, 15*time.Minute)
+	if err != nil {
+		return "", "", fmt.Errorf("minio: presign avatar upload %s: %w", key, err)
+	}
+	return u.String(), key, nil
+}
+
+// PresignAvatarURL returns a presigned GET URL for a user avatar.
+// Returns ("", false, nil) when no avatar exists for the given userID.
+func (m *MinioClient) PresignAvatarURL(ctx context.Context, userID string) (string, bool, error) {
+	if m.cfg.BucketAvatars == "" {
+		return "", false, nil
+	}
+	// Try common extensions in order of preference.
+	for _, ext := range []string{"jpg", "png", "webp", "gif"} {
+		key := avatarKey(userID, ext)
+		_, statErr := m.c.StatObject(ctx, m.cfg.BucketAvatars, key, minio.StatObjectOptions{})
+		if statErr != nil {
+			continue
+		}
+		u, err := m.pub.PresignedGetObject(ctx, m.cfg.BucketAvatars, key, 24*time.Hour, nil)
+		if err != nil {
+			return "", false, fmt.Errorf("minio: presign avatar %s: %w", key, err)
+		}
+		return u.String(), true, nil
+	}
+	return "", false, nil
+}
+
+// DeleteAvatar removes any existing avatar for the given userID (all extensions).
+func (m *MinioClient) DeleteAvatar(ctx context.Context, userID string) error {
+	if m.cfg.BucketAvatars == "" {
+		return nil
+	}
+	for _, ext := range []string{"jpg", "png", "webp", "gif"} {
+		key := avatarKey(userID, ext)
+		_ = m.c.RemoveObject(ctx, m.cfg.BucketAvatars, key, minio.RemoveObjectOptions{})
+	}
+	return nil
+}

scraper/internal/storage/pocketbase.go

@@ -14,6 +14,11 @@
 //	                 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)
+//	book_comments  — slug(text), user_id(text), username(text), body(text),
+//	                 upvotes(number), downvotes(number), created(date)
+//	comment_votes  — comment_id(text), user_id(text), session_id(text), vote(text: up|down)
 package storage
 
 import (
@@ -394,6 +399,66 @@ 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"},
+			},
+		},
+		{
+			"name": "book_comments",
+			"type": "base",
+			"fields": []map[string]interface{}{
+				{"name": "slug", "type": "text", "required": true},
+				{"name": "user_id", "type": "text"},
+				{"name": "username", "type": "text"},
+				{"name": "body", "type": "text", "required": true},
+				{"name": "upvotes", "type": "number"},
+				{"name": "downvotes", "type": "number"},
+				{"name": "created", "type": "date"},
+				{"name": "parent_id", "type": "text"}, // empty = top-level; set = reply to that comment ID
+			},
+		},
+		{
+			"name": "comment_votes",
+			"type": "base",
+			"fields": []map[string]interface{}{
+				{"name": "comment_id", "type": "text", "required": true},
+				{"name": "user_id", "type": "text"},
+				{"name": "session_id", "type": "text", "required": true},
+				{"name": "vote", "type": "text", "required": true}, // "up" | "down"
+			},
+		},
+		{
+			// follower_id follows followee_id
+			"name": "user_subscriptions",
+			"type": "base",
+			"fields": []map[string]interface{}{
+				{"name": "follower_id", "type": "text", "required": true},
+				{"name": "followee_id", "type": "text", "required": true},
+				{"name": "created", "type": "date"},
+			},
+		},
 	}
 	for _, col := range collections {
 		name, _ := col["name"].(string)
@@ -430,6 +495,10 @@ type migration struct {
 var migrations = []migration{
 	// user_id was added to progress after initial deploy.
 	{"progress", "user_id", "text"},
+	// avatar_url stores the MinIO presign path for the user's profile picture.
+	{"app_users", "avatar_url", "text"},
+	// parent_id enables 1-level comment nesting (replies). Empty = top-level comment.
+	{"book_comments", "parent_id", "text"},
 }
 
 // EnsureMigrations idempotently adds any fields that are missing from existing
@@ -784,6 +853,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 {
@@ -146,6 +160,17 @@ type Store interface {
 	// PresignAudio returns a presigned GET URL for an audio object.
 	PresignAudio(ctx context.Context, key string, expires time.Duration) (string, error)
 
+	// PresignAvatarUpload returns a short-lived presigned PUT URL for uploading
+	// an avatar image directly to MinIO, and the object key that will be stored.
+	// ext should be "jpg", "png", or "webp".
+	PresignAvatarUpload(ctx context.Context, userID, ext string) (uploadURL, key string, err error)
+
+	// PresignAvatarURL returns a presigned GET URL for a user's avatar, or ("", false, nil) if none.
+	PresignAvatarURL(ctx context.Context, userID string) (string, bool, error)
+
+	// DeleteAvatar removes all avatar objects for a user (all extensions).
+	DeleteAvatar(ctx context.Context, userID string) error
+
 	// ── Browse page snapshots (MinIO) ──────────────────────────────────────
 
 	// SaveBrowsePage stores a SingleFile HTML snapshot for the given cache key.
@@ -156,6 +181,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 +202,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

@@ -0,0 +1,13 @@
+{
+  "WARNING": "This file is automatically generated by act-runner. Do not edit it manually unless you know what you are doing. Removing this file will cause act runner to re-register as a new runner.",
+  "id": 11,
+  "uuid": "d5d04e0a-572c-46c0-83be-405508948391",
+  "name": "runner-mac-1",
+  "token": "ddf214ce148b4673a186f29cb684b407cb8c2ecc",
+  "address": "https://gitea.kalekber.cc/",
+  "labels": [
+    "macos-latest:host",
+    "macos-14:host"
+  ],
+  "ephemeral": false
+}

scripts/pb-init.sh

@@ -177,7 +177,8 @@ create_collection "app_users" '{
     {"name": "username",      "type": "text", "required": true},
     {"name": "password_hash", "type": "text", "required": true},
     {"name": "role",          "type": "text"},
-    {"name": "created",       "type": "date"}
+    {"name": "created",       "type": "date"},
+    {"name": "avatar_url",    "type": "text"}
   ]
 }'
 
@@ -200,5 +201,32 @@ create_collection "user_settings" '{
 ensure_field "progress" "user_id" "text"
 ensure_field "progress" "audio_time" "number"
 ensure_field "user_settings" "user_id" "text"
+ensure_field "app_users" "avatar_url" "text"
+
+create_collection "book_comments" '{
+  "name": "book_comments",
+  "type": "base",
+  "fields": [
+    {"name": "slug",       "type": "text",   "required": true},
+    {"name": "user_id",    "type": "text"},
+    {"name": "username",   "type": "text"},
+    {"name": "body",       "type": "text",   "required": true},
+    {"name": "upvotes",    "type": "number"},
+    {"name": "downvotes",  "type": "number"},
+    {"name": "created",    "type": "date"},
+    {"name": "parent_id",  "type": "text"}
+  ]
+}'
+
+create_collection "comment_votes" '{
+  "name": "comment_votes",
+  "type": "base",
+  "fields": [
+    {"name": "comment_id", "type": "text", "required": true},
+    {"name": "user_id",    "type": "text"},
+    {"name": "session_id", "type": "text", "required": true},
+    {"name": "vote",       "type": "text", "required": true}
+  ]
+}'
 
 log "all collections ready"

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"

scripts/test-ci-signing.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+set -euo pipefail
+
+cd "$(dirname "$0")/../ios/LibNovel"
+
+echo "=== Testing CI-like signing process ==="
+
+# 1. Install provisioning profile (simulate CI)
+PP_PATH=~/Downloads/LibNovel_Distribution.mobileprovision
+UUID=$(security cms -D -i "$PP_PATH" | plutil -extract UUID raw -)
+PROFILE_NAME=$(security cms -D -i "$PP_PATH" | plutil -extract Name raw -)
+mkdir -p ~/Library/MobileDevice/Provisioning\ Profiles
+cp "$PP_PATH" ~/Library/MobileDevice/Provisioning\ Profiles/$UUID.mobileprovision
+
+echo "Installed profile: $PROFILE_NAME (UUID: $UUID)"
+
+# 2. Generate Xcode project
+echo "Generating Xcode project..."
+xcodegen generate --spec project.yml --project .
+
+# 3. List available provisioning profiles
+echo -e "\n=== Available provisioning profiles ==="
+ls -la ~/Library/MobileDevice/Provisioning\ Profiles/
+
+# 4. Try building with xcodebuild using manual signing
+echo -e "\n=== Attempting archive with manual signing ==="
+xcodebuild archive \
+  -scheme LibNovel \
+  -project LibNovel.xcodeproj \
+  -configuration Release \
+  -destination 'generic/platform=iOS' \
+  -archivePath /tmp/LibNovel.xcarchive \
+  CODE_SIGN_STYLE=Manual \
+  CODE_SIGN_IDENTITY="Apple Distribution: Kamil Alekberov (GHZXC6FVMU)" \
+  DEVELOPMENT_TEAM=GHZXC6FVMU \
+  PROVISIONING_PROFILE_SPECIFIER="$UUID" \
+  | xcpretty || true
+
+echo -e "\n=== Build complete ==="

scripts/test-ios-build-simple.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+# Simple iOS build test without fastlane
+# Run from project root: ./scripts/test-ios-build-simple.sh /path/to/profile.mobileprovision
+
+set -e
+
+PROFILE_PATH="$1"
+
+if [ -z "$PROFILE_PATH" ]; then
+  echo "Usage: $0 /path/to/profile.mobileprovision"
+  exit 1
+fi
+
+echo "=== Step 1: Extract profile info ==="
+UUID=$(security cms -D -i "$PROFILE_PATH" | plutil -extract UUID raw -)
+PROFILE_NAME=$(security cms -D -i "$PROFILE_PATH" | plutil -extract Name raw -)
+TEAM_ID=$(security cms -D -i "$PROFILE_PATH" | plutil -extract TeamIdentifier.0 raw -)
+
+echo "Profile Name: $PROFILE_NAME"
+echo "UUID: $UUID"
+echo "Team ID: $TEAM_ID"
+
+echo ""
+echo "=== Step 2: Install profile ==="
+mkdir -p ~/Library/MobileDevice/Provisioning\ Profiles
+cp "$PROFILE_PATH" ~/Library/MobileDevice/Provisioning\ Profiles/$UUID.mobileprovision
+echo "✓ Installed"
+
+echo ""
+echo "=== Step 3: Check signing identities ==="
+security find-identity -v -p codesigning
+
+echo ""
+echo "=== Step 4: Generate Xcode project ==="
+cd ios/LibNovel
+export USER=runner
+xcodegen generate --spec project.yml --project .
+echo "✓ Project generated"
+
+echo ""
+echo "=== Step 5: Try automatic signing build ==="
+xcodebuild archive \
+  -project LibNovel.xcodeproj \
+  -scheme LibNovel \
+  -configuration Release \
+  -destination 'generic/platform=iOS' \
+  -archivePath ./build/LibNovel.xcarchive \
+  -allowProvisioningUpdates \
+  CODE_SIGN_STYLE=Automatic \
+  DEVELOPMENT_TEAM="$TEAM_ID"
+
+echo ""
+echo "=== ✓ BUILD SUCCEEDED! ==="

scripts/test-ios-build.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+# Local build test script
+# Run from the project root: ./scripts/test-ios-build.sh /path/to/your/profile.mobileprovision
+
+set -e
+
+PROFILE_PATH="$1"
+
+if [ -z "$PROFILE_PATH" ]; then
+  echo "Usage: $0 /path/to/profile.mobileprovision"
+  exit 1
+fi
+
+if [ ! -f "$PROFILE_PATH" ]; then
+  echo "Error: Profile not found at $PROFILE_PATH"
+  exit 1
+fi
+
+echo "=== Extracting profile info ==="
+UUID=$(security cms -D -i "$PROFILE_PATH" | plutil -extract UUID raw -)
+PROFILE_NAME=$(security cms -D -i "$PROFILE_PATH" | plutil -extract Name raw -)
+BUNDLE_ID=$(security cms -D -i "$PROFILE_PATH" | plutil -extract Entitlements.application-identifier raw - 2>/dev/null | sed 's/.*\.//')
+TEAM_ID=$(security cms -D -i "$PROFILE_PATH" | plutil -extract TeamIdentifier.0 raw -)
+
+echo "Profile Name: $PROFILE_NAME"
+echo "UUID: $UUID"
+echo "Bundle ID: $BUNDLE_ID"
+echo "Team ID: $TEAM_ID"
+
+echo ""
+echo "=== Installing provisioning profile ==="
+mkdir -p ~/Library/MobileDevice/Provisioning\ Profiles
+cp "$PROFILE_PATH" ~/Library/MobileDevice/Provisioning\ Profiles/$UUID.mobileprovision
+echo "Installed to: ~/Library/MobileDevice/Provisioning Profiles/$UUID.mobileprovision"
+
+echo ""
+echo "=== Listing signing identities ==="
+security find-identity -v -p codesigning
+
+echo ""
+echo "=== Navigating to iOS project ==="
+cd ios/LibNovel
+
+echo ""
+echo "=== Generating Xcode project ==="
+xcodegen generate --spec project.yml --project .
+
+echo ""
+echo "=== Testing fastlane build ==="
+export USER=runner
+export BUILD_NUMBER=999
+export PROVISIONING_PROFILE_NAME="$PROFILE_NAME"
+
+# Run fastlane beta lane
+fastlane beta --verbose
+
+echo ""
+echo "=== Build succeeded! ==="

ui/Dockerfile

@@ -5,19 +5,23 @@ COPY package.json package-lock.json ./
 RUN npm ci
 
 COPY . .
+
+# Build-time version info — injected by docker-compose or CI via --build-arg.
+ARG BUILD_VERSION=dev
+ARG BUILD_COMMIT=unknown
+
+# Expose as PUBLIC_ env vars so SvelteKit's $env/dynamic/public can read them.
+ENV PUBLIC_BUILD_VERSION=$BUILD_VERSION
+ENV PUBLIC_BUILD_COMMIT=$BUILD_COMMIT
+
 RUN npm run build
 
 # ── Runtime image ──────────────────────────────────────────────────────────────
+# adapter-node bundles all dependencies into build/ — no npm install needed.
 FROM node:22-alpine
 WORKDIR /app
 
-# adapter-node produces a standalone build/
 COPY --from=builder /app/build ./build
-COPY --from=builder /app/package.json ./
-COPY --from=builder /app/package-lock.json ./
-
-# Install production dependencies (e.g. marked) that are imported at runtime
-RUN npm ci --omit=dev
 
 ENV NODE_ENV=production
 ENV PORT=3000
@@ -25,3 +29,4 @@ ENV HOST=0.0.0.0
 
 EXPOSE $PORT
 CMD ["node", "build"]
+

ui/package.json

@@ -25,6 +25,9 @@
 		"vite": "^7.3.1"
 	},
 	"dependencies": {
+		"@aws-sdk/client-s3": "^3.1005.0",
+		"@aws-sdk/s3-request-presigner": "^3.1005.0",
+		"cropperjs": "^1.6.2",
 		"marked": "^17.0.3",
 		"pocketbase": "^0.26.8"
 	}

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/components/AvatarCropModal.svelte

@@ -0,0 +1,116 @@
+<script lang="ts">
+	import { onDestroy } from 'svelte';
+	import Cropper from 'cropperjs';
+	import 'cropperjs/dist/cropper.css';
+
+	interface Props {
+		file: File;
+		onconfirm: (blob: Blob, mimeType: string) => void;
+		oncancel: () => void;
+	}
+
+	let { file, onconfirm, oncancel }: Props = $props();
+
+	let imgEl: HTMLImageElement | undefined = $state();
+	let cropper: Cropper | null = null;
+	let objectUrl = '';
+
+	// Initialize cropper once the img element is bound and the file is known.
+	// Use a $effect so it runs after the DOM is ready (replaces onMount).
+	$effect(() => {
+		if (!imgEl || !file) return;
+
+		// Create the object URL and set src directly on the element (not via reactive
+		// state) so cropperjs sees the correct src before the image load event fires.
+		objectUrl = URL.createObjectURL(file);
+		imgEl.src = objectUrl;
+
+		// Cropperjs must be initialised inside the image's load event so it can
+		// measure the natural dimensions — if we call new Cropper() before the image
+		// has loaded, the crop canvas is blank/invisible.
+		const handleLoad = () => {
+			cropper = new Cropper(imgEl!, {
+				aspectRatio: 1,
+				viewMode: 1,
+				dragMode: 'move',
+				autoCropArea: 0.8,
+				restore: false,
+				guides: false,
+				center: true,
+				highlight: false,
+				cropBoxMovable: true,
+				cropBoxResizable: true,
+				toggleDragModeOnDblclick: false,
+				background: false
+			});
+		};
+
+		imgEl.addEventListener('load', handleLoad, { once: true });
+
+		return () => {
+			imgEl?.removeEventListener('load', handleLoad);
+			cropper?.destroy();
+			cropper = null;
+			URL.revokeObjectURL(objectUrl);
+			objectUrl = '';
+		};
+	});
+
+	onDestroy(() => {
+		cropper?.destroy();
+		if (objectUrl) URL.revokeObjectURL(objectUrl);
+	});
+
+	function confirm() {
+		if (!cropper) return;
+		const canvas = cropper.getCroppedCanvas({ width: 400, height: 400 });
+		const mimeType = file.type === 'image/webp' ? 'image/webp' : 'image/jpeg';
+		canvas.toBlob(
+			(blob: Blob | null) => {
+				if (blob) onconfirm(blob, mimeType);
+			},
+			mimeType,
+			0.9
+		);
+	}
+</script>
+
+<!-- Backdrop -->
+<div
+	class="fixed inset-0 z-50 flex items-center justify-center bg-black/70 backdrop-blur-sm p-4"
+	role="dialog"
+	aria-modal="true"
+	aria-label="Crop profile picture"
+>
+	<div class="bg-zinc-900 rounded-2xl border border-zinc-700 shadow-2xl w-full max-w-sm flex flex-col gap-4 p-5">
+		<h2 class="text-base font-semibold text-zinc-100">Crop profile picture</h2>
+
+		<!-- Cropper image container — overflow must be visible so cropperjs can
+		     render the crop canvas outside the natural image bounds. The fixed
+		     height gives cropperjs a stable container to size itself against. -->
+		<div class="rounded-xl bg-zinc-800" style="height: 300px; position: relative;">
+			<img
+				bind:this={imgEl}
+				alt="Crop preview"
+				style="display:block; max-width:100%; max-height:100%;"
+			/>
+		</div>
+
+		<p class="text-xs text-zinc-500 text-center">Drag to reposition · pinch or scroll to zoom · drag corners to resize</p>
+
+		<div class="flex gap-3">
+			<button
+				onclick={oncancel}
+				class="flex-1 py-2 rounded-lg border border-zinc-600 text-zinc-300 text-sm font-medium hover:bg-zinc-700 transition-colors"
+			>
+				Cancel
+			</button>
+			<button
+				onclick={confirm}
+				class="flex-1 py-2 rounded-lg bg-amber-400 text-zinc-900 text-sm font-semibold hover:bg-amber-300 transition-colors"
+			>
+				Use photo
+			</button>
+		</div>
+	</div>
+</div>

ui/src/lib/components/CommentsSection.svelte

@@ -0,0 +1,560 @@
+<script lang="ts">
+	interface BookComment {
+		id: string;
+		slug: string;
+		user_id: string;
+		username: string;
+		body: string;
+		upvotes: number;
+		downvotes: number;
+		created: string;
+		parent_id?: string;
+		replies?: BookComment[];
+	}
+
+	let {
+		slug,
+		isLoggedIn = false,
+		currentUserId = ''
+	}: {
+		slug: string;
+		isLoggedIn?: boolean;
+		currentUserId?: string;
+	} = $props();
+
+	// ── State ─────────────────────────────────────────────────────────────────
+	let comments = $state<BookComment[]>([]);
+	let myVotes = $state<Record<string, 'up' | 'down'>>({});
+	let avatarUrls = $state<Record<string, string>>({});
+	let loading = $state(true);
+	let loadError = $state('');
+
+	// Top-level new comment
+	let newBody = $state('');
+	let posting = $state(false);
+	let postError = $state('');
+
+	// Sort
+	let sort = $state<'new' | 'top'>('top');
+
+	// Reply state: which comment is being replied to
+	let replyingTo = $state<string | null>(null); // comment id
+	let replyBody = $state('');
+	let replyPosting = $state(false);
+	let replyError = $state('');
+
+	// Delete in-flight set
+	let deletingIds = $state(new Set<string>());
+
+	// Per-comment vote inflight set (prevents double-clicks)
+	let votingIds = $state(new Set<string>());
+
+	// ── Load comments ─────────────────────────────────────────────────────────
+	async function loadComments() {
+		loading = true;
+		loadError = '';
+		try {
+			const res = await fetch(
+				`/api/comments/${encodeURIComponent(slug)}?sort=${sort}`
+			);
+			if (!res.ok) throw new Error(`${res.status}`);
+			const data = await res.json();
+			comments = data.comments ?? [];
+			myVotes = data.myVotes ?? {};
+			avatarUrls = data.avatarUrls ?? {};
+		} catch (e) {
+			loadError = 'Failed to load comments.';
+		} finally {
+			loading = false;
+		}
+	}
+
+	$effect(() => {
+		loadComments();
+	});
+
+	// Re-load when sort changes (after initial mount)
+	let firstLoad = true;
+	$effect(() => {
+		// Read sort to create a dependency
+		const _ = sort;
+		if (firstLoad) { firstLoad = false; return; }
+		loadComments();
+	});
+
+	// ── Post top-level comment ────────────────────────────────────────────────
+	async function postComment() {
+		const text = newBody.trim();
+		if (!text || posting) return;
+		if (text.length > 2000) { postError = 'Comment is too long (max 2000 characters).'; return; }
+		posting = true;
+		postError = '';
+		try {
+			const res = await fetch(`/api/comments/${encodeURIComponent(slug)}`, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ body: text })
+			});
+			if (res.status === 401) { postError = 'You must be logged in to comment.'; return; }
+			if (!res.ok) {
+				const err = await res.json().catch(() => ({}));
+				postError = err.message ?? 'Failed to post comment.';
+				return;
+			}
+			const created: BookComment = await res.json();
+			created.replies = [];
+			// Prepend for 'new', or re-sort for 'top'
+			if (sort === 'new') {
+				comments = [created, ...comments];
+			} else {
+				comments = [created, ...comments]; // new comment has 0 score, goes to end after sort would happen
+			}
+			newBody = '';
+		} catch {
+			postError = 'Failed to post comment.';
+		} finally {
+			posting = false;
+		}
+	}
+
+	// ── Post reply ────────────────────────────────────────────────────────────
+	async function postReply(parentId: string) {
+		const text = replyBody.trim();
+		if (!text || replyPosting) return;
+		if (text.length > 2000) { replyError = 'Reply is too long (max 2000 characters).'; return; }
+		replyPosting = true;
+		replyError = '';
+		try {
+			const res = await fetch(`/api/comments/${encodeURIComponent(slug)}`, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ body: text, parent_id: parentId })
+			});
+			if (res.status === 401) { replyError = 'You must be logged in to reply.'; return; }
+			if (!res.ok) {
+				const err = await res.json().catch(() => ({}));
+				replyError = err.message ?? 'Failed to post reply.';
+				return;
+			}
+			const created: BookComment = await res.json();
+			// Append to the parent's replies list
+			comments = comments.map((c) => {
+				if (c.id !== parentId) return c;
+				return { ...c, replies: [...(c.replies ?? []), created] };
+			});
+			replyBody = '';
+			replyingTo = null;
+		} catch {
+			replyError = 'Failed to post reply.';
+		} finally {
+			replyPosting = false;
+		}
+	}
+
+	// ── Delete ────────────────────────────────────────────────────────────────
+	async function deleteComment(commentId: string, parentId?: string) {
+		if (deletingIds.has(commentId)) return;
+		deletingIds = new Set([...deletingIds, commentId]);
+		try {
+			const res = await fetch(`/api/comment/${commentId}`, { method: 'DELETE' });
+			if (!res.ok) return;
+			if (parentId) {
+				// Remove reply from parent
+				comments = comments.map((c) => {
+					if (c.id !== parentId) return c;
+					return { ...c, replies: (c.replies ?? []).filter((r) => r.id !== commentId) };
+				});
+			} else {
+				// Remove top-level comment
+				comments = comments.filter((c) => c.id !== commentId);
+			}
+		} finally {
+			const next = new Set(deletingIds);
+			next.delete(commentId);
+			deletingIds = next;
+		}
+	}
+
+	// ── Vote ──────────────────────────────────────────────────────────────────
+	async function vote(commentId: string, v: 'up' | 'down', parentId?: string) {
+		if (votingIds.has(commentId)) return;
+		votingIds = new Set([...votingIds, commentId]);
+		try {
+			const res = await fetch(`/api/comment/${commentId}/vote`, {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ vote: v })
+			});
+			if (!res.ok) return;
+			const updated: BookComment = await res.json();
+			// Update comment in list (handle both top-level and replies)
+			if (parentId) {
+				comments = comments.map((c) => {
+					if (c.id !== parentId) return c;
+					return {
+						...c,
+						replies: (c.replies ?? []).map((r) => (r.id === commentId ? updated : r))
+					};
+				});
+			} else {
+				comments = comments.map((c) => (c.id === commentId ? { ...updated, replies: c.replies } : c));
+			}
+			// Update myVotes: toggle off if same, else set new vote
+			const prev = myVotes[commentId];
+			if (prev === v) {
+				const next = { ...myVotes };
+				delete next[commentId];
+				myVotes = next;
+			} else {
+				myVotes = { ...myVotes, [commentId]: v };
+			}
+		} finally {
+			const next = new Set(votingIds);
+			next.delete(commentId);
+			votingIds = next;
+		}
+	}
+
+	// ── Helpers ───────────────────────────────────────────────────────────────
+	function initials(username: string): string {
+		const name = username.trim() || '?';
+		return name.slice(0, 2).toUpperCase();
+	}
+
+	function formatDate(iso: string): string {
+		try {
+			const date = new Date(iso);
+			const now = Date.now();
+			const diffMs = now - date.getTime();
+			const diffMins = Math.floor(diffMs / 60_000);
+			if (diffMins < 1) return 'just now';
+			if (diffMins < 60) return `${diffMins}m ago`;
+			const diffHours = Math.floor(diffMins / 60);
+			if (diffHours < 24) return `${diffHours}h ago`;
+			const diffDays = Math.floor(diffHours / 24);
+			if (diffDays < 30) return `${diffDays}d ago`;
+			return date.toLocaleDateString(undefined, { year: 'numeric', month: 'short', day: 'numeric' });
+		} catch {
+			return iso;
+		}
+	}
+
+	const charCount = $derived(newBody.length);
+	const charOver = $derived(charCount > 2000);
+	const replyCharCount = $derived(replyBody.length);
+	const replyCharOver = $derived(replyCharCount > 2000);
+
+	const totalCount = $derived(
+		comments.reduce((n, c) => n + 1 + (c.replies?.length ?? 0), 0)
+	);
+</script>
+
+<div class="mt-10">
+	<!-- Header + sort controls -->
+	<div class="flex items-center justify-between gap-3 mb-4 flex-wrap">
+		<h2 class="text-base font-semibold text-zinc-200">
+			Comments
+			{#if !loading && totalCount > 0}
+				<span class="text-zinc-500 font-normal text-sm ml-1">({totalCount})</span>
+			{/if}
+		</h2>
+
+		<!-- Sort tabs -->
+		{#if !loading && comments.length > 0}
+			<div class="flex items-center gap-1 text-xs rounded-lg bg-zinc-800/60 p-1">
+				<button
+					onclick={() => (sort = 'top')}
+					class="px-2.5 py-1 rounded-md transition-colors {sort === 'top'
+						? 'bg-zinc-700 text-zinc-100'
+						: 'text-zinc-500 hover:text-zinc-300'}"
+				>
+					Top
+				</button>
+				<button
+					onclick={() => (sort = 'new')}
+					class="px-2.5 py-1 rounded-md transition-colors {sort === 'new'
+						? 'bg-zinc-700 text-zinc-100'
+						: 'text-zinc-500 hover:text-zinc-300'}"
+				>
+					New
+				</button>
+			</div>
+		{/if}
+	</div>
+
+	<!-- Post form -->
+	<div class="mb-6">
+		{#if isLoggedIn}
+			<div class="flex flex-col gap-2">
+				<textarea
+					bind:value={newBody}
+					placeholder="Write a comment…"
+					rows="3"
+					class="w-full px-3 py-2 rounded-lg bg-zinc-800 border border-zinc-700 text-zinc-200 text-sm placeholder-zinc-500 resize-none focus:outline-none focus:border-amber-400 transition-colors"
+				></textarea>
+				<div class="flex items-center justify-between gap-3">
+					<span class="text-xs {charOver ? 'text-red-400' : 'text-zinc-600'} tabular-nums">
+						{charCount}/2000
+					</span>
+					<div class="flex items-center gap-3">
+						{#if postError}
+							<span class="text-xs text-red-400">{postError}</span>
+						{/if}
+						<button
+							onclick={postComment}
+							disabled={posting || !newBody.trim() || charOver}
+							class="px-4 py-1.5 rounded-lg text-sm font-medium transition-colors
+								{posting || !newBody.trim() || charOver
+									? 'bg-zinc-700 text-zinc-500 cursor-not-allowed'
+									: 'bg-amber-400 text-zinc-900 hover:bg-amber-300'}"
+						>
+							{posting ? 'Posting…' : 'Post'}
+						</button>
+					</div>
+				</div>
+			</div>
+		{:else}
+			<p class="text-sm text-zinc-500">
+				<a href="/auth/login" class="text-amber-400 hover:text-amber-300 transition-colors">Log in</a>
+				to leave a comment.
+			</p>
+		{/if}
+	</div>
+
+	<!-- Comment list -->
+	{#if loading}
+		<div class="flex flex-col gap-3">
+			{#each Array(3) as _}
+				<div class="rounded-lg bg-zinc-800/50 p-4 animate-pulse">
+					<div class="h-3 w-24 bg-zinc-700 rounded mb-3"></div>
+					<div class="h-3 w-full bg-zinc-700/60 rounded mb-2"></div>
+					<div class="h-3 w-3/4 bg-zinc-700/60 rounded"></div>
+				</div>
+			{/each}
+		</div>
+	{:else if loadError}
+		<p class="text-sm text-red-400">{loadError}</p>
+	{:else if comments.length === 0}
+		<p class="text-sm text-zinc-500">No comments yet. Be the first!</p>
+	{:else}
+		<div class="flex flex-col gap-3">
+			{#each comments as comment (comment.id)}
+				{@const myVote = myVotes[comment.id]}
+				{@const voting = votingIds.has(comment.id)}
+				{@const deleting = deletingIds.has(comment.id)}
+				{@const isOwner = isLoggedIn && currentUserId === comment.user_id}
+
+				<div class="rounded-lg bg-zinc-800/50 border border-zinc-700/50 px-4 py-3 flex flex-col gap-2 {deleting ? 'opacity-50' : ''}">
+					<!-- Header -->
+					<div class="flex items-center gap-2 flex-wrap">
+						{#if avatarUrls[comment.user_id]}
+							<img src={avatarUrls[comment.user_id]} alt={comment.username} class="w-6 h-6 rounded-full object-cover flex-shrink-0" />
+						{:else}
+							<div class="w-6 h-6 rounded-full bg-zinc-700 flex items-center justify-center flex-shrink-0">
+								<span class="text-[9px] font-semibold text-zinc-300 leading-none">{initials(comment.username)}</span>
+							</div>
+						{/if}
+						{#if comment.username}
+						<a href="/users/{comment.username}" class="text-sm font-medium text-zinc-200 hover:text-amber-400 transition-colors">{comment.username}</a>
+					{:else}
+						<span class="text-sm font-medium text-zinc-400">Anonymous</span>
+					{/if}
+						<span class="text-zinc-600 text-xs">&middot;</span>
+						<span class="text-xs text-zinc-500">{formatDate(comment.created)}</span>
+					</div>
+
+					<!-- Body -->
+					<p class="text-sm text-zinc-300 leading-relaxed whitespace-pre-wrap break-words">{comment.body}</p>
+
+					<!-- Actions row: votes + reply + delete -->
+					<div class="flex items-center gap-3 pt-1 flex-wrap">
+						<!-- Upvote -->
+						<button
+							onclick={() => vote(comment.id, 'up')}
+							disabled={voting}
+							title="Upvote"
+							class="flex items-center gap-1 text-xs transition-colors disabled:opacity-50
+								{myVote === 'up' ? 'text-amber-400' : 'text-zinc-500 hover:text-zinc-300'}"
+						>
+							<svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2">
+								<path stroke-linecap="round" stroke-linejoin="round" d="M14 10h4.764a2 2 0 011.789 2.894l-3.5 7A2 2 0 0115.263 21h-4.017c-.163 0-.326-.02-.485-.06L7 20m7-10V5a2 2 0 00-2-2h-.095c-.5 0-.905.405-.905.905 0 .714-.211 1.412-.608 2.006L7 11v9m7-10h-2M7 20H5a2 2 0 01-2-2v-6a2 2 0 012-2h2.5"/>
+							</svg>
+							<span class="tabular-nums">{comment.upvotes ?? 0}</span>
+						</button>
+
+						<!-- Downvote -->
+						<button
+							onclick={() => vote(comment.id, 'down')}
+							disabled={voting}
+							title="Downvote"
+							class="flex items-center gap-1 text-xs transition-colors disabled:opacity-50
+								{myVote === 'down' ? 'text-red-400' : 'text-zinc-500 hover:text-zinc-300'}"
+						>
+							<svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2">
+								<path stroke-linecap="round" stroke-linejoin="round" d="M10 14H5.236a2 2 0 01-1.789-2.894l3.5-7A2 2 0 018.736 3h4.018a2 2 0 01.485.06l3.76.94m-7 10v5a2 2 0 002 2h.096c.5 0 .905-.405.905-.904 0-.715.211-1.413.608-2.008L17 13V4m-7 10h2m5-10h2a2 2 0 012 2v6a2 2 0 01-2 2h-2.5"/>
+							</svg>
+							<span class="tabular-nums">{comment.downvotes ?? 0}</span>
+						</button>
+
+						<!-- Reply button -->
+						{#if isLoggedIn}
+							<button
+								onclick={() => {
+									if (replyingTo === comment.id) {
+										replyingTo = null;
+										replyBody = '';
+										replyError = '';
+									} else {
+										replyingTo = comment.id;
+										replyBody = '';
+										replyError = '';
+									}
+								}}
+								class="flex items-center gap-1 text-xs transition-colors
+									{replyingTo === comment.id
+										? 'text-amber-400'
+										: 'text-zinc-500 hover:text-zinc-300'}"
+							>
+								<svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2">
+									<path stroke-linecap="round" stroke-linejoin="round" d="M3 10h10a8 8 0 018 8v2M3 10l6 6m-6-6l6-6"/>
+								</svg>
+								Reply
+							</button>
+						{/if}
+
+						<!-- Delete (owner only) -->
+						{#if isOwner}
+							<button
+								onclick={() => deleteComment(comment.id)}
+								disabled={deleting}
+								class="flex items-center gap-1 text-xs text-zinc-600 hover:text-red-400 transition-colors disabled:opacity-50 ml-auto"
+								title="Delete comment"
+							>
+								<svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2">
+									<path stroke-linecap="round" stroke-linejoin="round" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"/>
+								</svg>
+								Delete
+							</button>
+						{/if}
+					</div>
+
+					<!-- Inline reply form -->
+					{#if replyingTo === comment.id}
+						<div class="mt-1 flex flex-col gap-2 pl-2 border-l-2 border-zinc-700">
+							<textarea
+								bind:value={replyBody}
+								placeholder="Write a reply…"
+								rows="2"
+								class="w-full px-3 py-2 rounded-lg bg-zinc-900 border border-zinc-700 text-zinc-200 text-sm placeholder-zinc-500 resize-none focus:outline-none focus:border-amber-400 transition-colors"
+							></textarea>
+							<div class="flex items-center justify-between gap-2">
+								<span class="text-xs {replyCharOver ? 'text-red-400' : 'text-zinc-600'} tabular-nums">
+									{replyCharCount}/2000
+								</span>
+								<div class="flex items-center gap-2">
+									{#if replyError}
+										<span class="text-xs text-red-400">{replyError}</span>
+									{/if}
+									<button
+										onclick={() => { replyingTo = null; replyBody = ''; replyError = ''; }}
+										class="px-3 py-1 rounded-lg text-xs text-zinc-400 hover:text-zinc-200 transition-colors"
+									>
+										Cancel
+									</button>
+									<button
+										onclick={() => postReply(comment.id)}
+										disabled={replyPosting || !replyBody.trim() || replyCharOver}
+										class="px-3 py-1.5 rounded-lg text-xs font-medium transition-colors
+											{replyPosting || !replyBody.trim() || replyCharOver
+												? 'bg-zinc-700 text-zinc-500 cursor-not-allowed'
+												: 'bg-amber-400 text-zinc-900 hover:bg-amber-300'}"
+									>
+										{replyPosting ? 'Posting…' : 'Reply'}
+									</button>
+								</div>
+							</div>
+						</div>
+					{/if}
+
+					<!-- Replies -->
+					{#if comment.replies && comment.replies.length > 0}
+						<div class="mt-1 flex flex-col gap-2 pl-3 border-l-2 border-zinc-700/60">
+							{#each comment.replies as reply (reply.id)}
+								{@const replyVote = myVotes[reply.id]}
+								{@const replyVoting = votingIds.has(reply.id)}
+								{@const replyDeleting = deletingIds.has(reply.id)}
+								{@const replyIsOwner = isLoggedIn && currentUserId === reply.user_id}
+
+								<div class="rounded-md bg-zinc-800/30 px-3 py-2.5 flex flex-col gap-1.5 {replyDeleting ? 'opacity-50' : ''}">
+									<!-- Reply header -->
+									<div class="flex items-center gap-2 flex-wrap">
+										{#if avatarUrls[reply.user_id]}
+											<img src={avatarUrls[reply.user_id]} alt={reply.username} class="w-5 h-5 rounded-full object-cover flex-shrink-0" />
+										{:else}
+											<div class="w-5 h-5 rounded-full bg-zinc-700 flex items-center justify-center flex-shrink-0">
+												<span class="text-[8px] font-semibold text-zinc-300 leading-none">{initials(reply.username)}</span>
+											</div>
+										{/if}
+										{#if reply.username}
+										<a href="/users/{reply.username}" class="text-xs font-medium text-zinc-300 hover:text-amber-400 transition-colors">{reply.username}</a>
+									{:else}
+										<span class="text-xs font-medium text-zinc-400">Anonymous</span>
+									{/if}
+										<span class="text-zinc-600 text-xs">&middot;</span>
+										<span class="text-xs text-zinc-500">{formatDate(reply.created)}</span>
+									</div>
+
+									<!-- Reply body -->
+									<p class="text-sm text-zinc-300 leading-relaxed whitespace-pre-wrap break-words">{reply.body}</p>
+
+									<!-- Reply actions -->
+									<div class="flex items-center gap-3 pt-0.5">
+										<button
+											onclick={() => vote(reply.id, 'up', comment.id)}
+											disabled={replyVoting}
+											title="Upvote"
+											class="flex items-center gap-1 text-xs transition-colors disabled:opacity-50
+												{replyVote === 'up' ? 'text-amber-400' : 'text-zinc-500 hover:text-zinc-300'}"
+										>
+											<svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2">
+												<path stroke-linecap="round" stroke-linejoin="round" d="M14 10h4.764a2 2 0 011.789 2.894l-3.5 7A2 2 0 0115.263 21h-4.017c-.163 0-.326-.02-.485-.06L7 20m7-10V5a2 2 0 00-2-2h-.095c-.5 0-.905.405-.905.905 0 .714-.211 1.412-.608 2.006L7 11v9m7-10h-2M7 20H5a2 2 0 01-2-2v-6a2 2 0 012-2h2.5"/>
+											</svg>
+											<span class="tabular-nums">{reply.upvotes ?? 0}</span>
+										</button>
+
+										<button
+											onclick={() => vote(reply.id, 'down', comment.id)}
+											disabled={replyVoting}
+											title="Downvote"
+											class="flex items-center gap-1 text-xs transition-colors disabled:opacity-50
+												{replyVote === 'down' ? 'text-red-400' : 'text-zinc-500 hover:text-zinc-300'}"
+										>
+											<svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2">
+												<path stroke-linecap="round" stroke-linejoin="round" d="M10 14H5.236a2 2 0 01-1.789-2.894l3.5-7A2 2 0 018.736 3h4.018a2 2 0 01.485.06l3.76.94m-7 10v5a2 2 0 002 2h.096c.5 0 .905-.405.905-.904 0-.715.211-1.413.608-2.008L17 13V4m-7 10h2m5-10h2a2 2 0 012 2v6a2 2 0 01-2 2h-2.5"/>
+											</svg>
+											<span class="tabular-nums">{reply.downvotes ?? 0}</span>
+										</button>
+
+										{#if replyIsOwner}
+											<button
+												onclick={() => deleteComment(reply.id, comment.id)}
+												disabled={replyDeleting}
+												class="flex items-center gap-1 text-xs text-zinc-600 hover:text-red-400 transition-colors disabled:opacity-50 ml-auto"
+												title="Delete reply"
+											>
+												<svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24" stroke-width="2">
+													<path stroke-linecap="round" stroke-linejoin="round" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"/>
+												</svg>
+												Delete
+											</button>
+										{/if}
+									</div>
+								</div>
+							{/each}
+						</div>
+					{/if}
+				</div>
+			{/each}
+		</div>
+	{/if}
+</div>

ui/src/lib/server/minio.ts

@@ -15,6 +15,46 @@ const SCRAPER_URL = env.SCRAPER_API_URL ?? 'http://localhost:8080';
 // In docker-compose this would differ from the internal endpoint.
 const MINIO_PUBLIC_URL = pubEnv.PUBLIC_MINIO_PUBLIC_URL ?? 'http://localhost:9000';
 
+// ─── Avatar helpers ───────────────────────────────────────────────────────────
+
+function extFromMime(mime: string): string {
+	if (mime.includes('png')) return 'png';
+	if (mime.includes('webp')) return 'webp';
+	if (mime.includes('gif')) return 'gif';
+	return 'jpg';
+}
+
+/**
+ * Returns a short-lived presigned PUT URL for uploading an avatar directly to MinIO,
+ * along with the object key to record in PocketBase after upload completes.
+ * Routed through the Go scraper which holds MinIO credentials.
+ */
+export async function presignAvatarUploadUrl(userId: string, mimeType: string): Promise<{ uploadUrl: string; key: string }> {
+	const ext = extFromMime(mimeType);
+	const res = await fetch(`${SCRAPER_URL}/api/presign/avatar-upload/${encodeURIComponent(userId)}?ext=${ext}`);
+	if (!res.ok) {
+		const body = await res.text().catch(() => '');
+		throw new Error(`presign avatar upload failed: ${res.status} ${body}`);
+	}
+	const data = (await res.json()) as { upload_url: string; key: string };
+	return { uploadUrl: data.upload_url, key: data.key };
+}
+
+/**
+ * Returns a presigned GET URL for a user's avatar, rewritten to the public URL.
+ * Returns null if no avatar exists.
+ */
+export async function presignAvatarUrl(userId: string): Promise<string | null> {
+	const res = await fetch(`${SCRAPER_URL}/api/presign/avatar/${encodeURIComponent(userId)}`);
+	if (res.status === 404) return null;
+	if (!res.ok) {
+		const body = await res.text().catch(() => '');
+		throw new Error(`presign avatar failed: ${res.status} ${body}`);
+	}
+	const data = (await res.json()) as { url: string };
+	return data.url ?? null;
+}
+
 /**
  * Rewrites the MinIO host in a presigned URL to the public-facing URL.
  * The presigned URL is signed against the internal endpoint (e.g. minio:9000),

ui/src/lib/server/pocketbase.ts

@@ -62,6 +62,7 @@ export interface User {
 	password_hash: string;
 	role: string;
 	created: string;
+	avatar_url?: string;
 }
 
 // ─── Auth token cache ─────────────────────────────────────────────────────────
@@ -126,6 +127,14 @@ async function pbPatch(path: string, body: unknown): Promise<Response> {
 	});
 }
 
+async function pbDelete(path: string): Promise<Response> {
+	const token = await getToken();
+	return fetch(`${PB_URL}${path}`, {
+		method: 'DELETE',
+		headers: { Authorization: `Bearer ${token}` }
+	});
+}
+
 interface PBList<T> {
 	items: T[];
 	totalItems: number;
@@ -289,6 +298,38 @@ export async function setProgress(
 	}
 }
 
+/**
+ * Delete progress entry for a specific book (removes from library/continue reading).
+ */
+export async function deleteProgress(
+	sessionId: string,
+	slug: string,
+	userId?: string
+): Promise<void> {
+	const existing = await listOne<Progress & { id: string }>(
+		'progress',
+		progressFilter(sessionId, slug, userId)
+	);
+
+	if (!existing) {
+		log.debug('pocketbase', 'deleteProgress: no record found', { sessionId, slug, userId });
+		return;
+	}
+
+	const res = await pbDelete(`/api/collections/progress/records/${existing.id}`);
+	if (!res.ok) {
+		const body = await res.text().catch(() => '');
+		log.error('pocketbase', 'deleteProgress failed', {
+			slug,
+			id: existing.id,
+			status: res.status,
+			body
+		});
+		throw new Error(`Failed to delete progress: ${res.status}`);
+	}
+	log.info('pocketbase', 'deleteProgress success', { slug, id: existing.id });
+}
+
 /**
  * Merge anonymous session progress into a user account on login/register.
  *
@@ -657,6 +698,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 +726,624 @@ 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(() => {})
+		)
+	);
+}
+
+/**
+ * Update the avatar_url field for a user record.
+ */
+export async function updateUserAvatarUrl(userId: string, avatarUrl: string): Promise<void> {
+	const token = await getToken();
+	const res = await fetch(`${PB_URL}/api/collections/app_users/records/${userId}`, {
+		method: 'PATCH',
+		headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+		body: JSON.stringify({ avatar_url: avatarUrl })
+	});
+	if (!res.ok) {
+		const body = await res.text().catch(() => '');
+		throw new Error(`updateUserAvatarUrl failed: ${res.status} ${body}`);
+	}
+}
+
+// ─── Comments ─────────────────────────────────────────────────────────────────
+
+export interface BookComment {
+	id: string;
+	slug: string;
+	user_id: string;
+	username: string;
+	body: string;
+	upvotes: number;
+	downvotes: number;
+	created: string;
+	parent_id?: string; // empty / absent = top-level; set = reply
+}
+
+export interface CommentVote {
+	id: string;
+	comment_id: string;
+	user_id: string;
+	session_id: string;
+	vote: 'up' | 'down';
+}
+
+export type CommentSort = 'top' | 'new';
+
+/**
+ * List top-level comments for a book.
+ * sort='top'  → by net score (upvotes − downvotes) desc, then newest
+ * sort='new'  → newest first (default)
+ * Replies (parent_id != "") are NOT included — fetch them separately.
+ */
+export async function listComments(
+	slug: string,
+	sort: CommentSort = 'new'
+): Promise<BookComment[]> {
+	const token = await getToken();
+	const slugEsc = slug.replace(/"/g, '\\"');
+	// Only top-level comments (parent_id is empty or missing)
+	const filter = encodeURIComponent(`slug="${slugEsc}"&&(parent_id=""||parent_id=null)`);
+	// PocketBase sorts: for 'top' we still fetch all and re-sort in JS because
+	// PocketBase doesn't support computed sort fields.  For 'new' we push the
+	// sort down to the DB so large result sets are still paged correctly.
+	const pbSort = sort === 'new' ? '&sort=-created' : '&sort=-created';
+	const res = await fetch(
+		`${PB_URL}/api/collections/book_comments/records?filter=${filter}${pbSort}&perPage=200`,
+		{ headers: { Authorization: `Bearer ${token}` } }
+	);
+	if (!res.ok) return [];
+	const data = await res.json();
+	let items = (data.items ?? []) as BookComment[];
+	if (sort === 'top') {
+		items = items.sort((a, b) => {
+			const scoreB = (b.upvotes ?? 0) - (b.downvotes ?? 0);
+			const scoreA = (a.upvotes ?? 0) - (a.downvotes ?? 0);
+			if (scoreB !== scoreA) return scoreB - scoreA;
+			// tie-break: newest first
+			return new Date(b.created).getTime() - new Date(a.created).getTime();
+		});
+	}
+	return items;
+}
+
+/**
+ * List replies (1-level deep) for a single parent comment.
+ * Always sorted oldest-first so the conversation reads naturally.
+ */
+export async function listReplies(parentId: string): Promise<BookComment[]> {
+	const token = await getToken();
+	const filter = encodeURIComponent(`parent_id="${parentId.replace(/"/g, '\\"')}"`);
+	const res = await fetch(
+		`${PB_URL}/api/collections/book_comments/records?filter=${filter}&sort=created&perPage=100`,
+		{ headers: { Authorization: `Bearer ${token}` } }
+	);
+	if (!res.ok) return [];
+	const data = await res.json();
+	return (data.items ?? []) as BookComment[];
+}
+
+/**
+ * Create a new comment. Returns the created record.
+ * Pass parentId to create a reply; omit / pass undefined for a top-level comment.
+ */
+export async function createComment(
+	slug: string,
+	body: string,
+	userId: string | undefined,
+	username: string,
+	parentId?: string
+): Promise<BookComment> {
+	const token = await getToken();
+	const res = await fetch(`${PB_URL}/api/collections/book_comments/records`, {
+		method: 'POST',
+		headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+		body: JSON.stringify({
+			slug,
+			body,
+			user_id: userId ?? '',
+			username,
+			upvotes: 0,
+			downvotes: 0,
+			parent_id: parentId ?? '',
+			created: new Date().toISOString()
+		})
+	});
+	if (!res.ok) {
+		const text = await res.text().catch(() => '');
+		throw new Error(`createComment failed: ${res.status} ${text}`);
+	}
+	return res.json() as Promise<BookComment>;
+}
+
+/**
+ * Delete a comment (and optionally its replies) by ID.
+ * Only the comment owner (matched by userId) may delete.
+ * Throws if the comment doesn't exist or the user doesn't own it.
+ */
+export async function deleteComment(commentId: string, userId: string): Promise<void> {
+	const token = await getToken();
+
+	// Fetch the comment to verify ownership
+	const getRes = await fetch(`${PB_URL}/api/collections/book_comments/records/${commentId}`, {
+		headers: { Authorization: `Bearer ${token}` }
+	});
+	if (!getRes.ok) throw new Error(`Comment not found: ${commentId}`);
+	const comment = (await getRes.json()) as BookComment;
+	if (comment.user_id !== userId) throw new Error('Not authorized to delete this comment');
+
+	// Delete any replies first
+	const repliesFilter = encodeURIComponent(`parent_id="${commentId.replace(/"/g, '\\"')}"`);
+	const repliesRes = await fetch(
+		`${PB_URL}/api/collections/book_comments/records?filter=${repliesFilter}&perPage=100`,
+		{ headers: { Authorization: `Bearer ${token}` } }
+	);
+	if (repliesRes.ok) {
+		const repliesData = await repliesRes.json();
+		const replies = (repliesData.items ?? []) as BookComment[];
+		await Promise.all(
+			replies.map((r) =>
+				fetch(`${PB_URL}/api/collections/book_comments/records/${r.id}`, {
+					method: 'DELETE',
+					headers: { Authorization: `Bearer ${token}` }
+				})
+			)
+		);
+	}
+
+	// Delete the comment itself
+	const delRes = await fetch(`${PB_URL}/api/collections/book_comments/records/${commentId}`, {
+		method: 'DELETE',
+		headers: { Authorization: `Bearer ${token}` }
+	});
+	if (!delRes.ok) throw new Error(`deleteComment failed: ${delRes.status}`);
+}
+
+/**
+ * Get an existing vote by this voter (identified by user_id or session_id) on a comment.
+ */
+export async function getCommentVote(
+	commentId: string,
+	sessionId: string,
+	userId?: string
+): Promise<CommentVote | null> {
+	const token = await getToken();
+	const voterFilter = userId
+		? `comment_id="${commentId}"&&user_id="${userId}"`
+		: `comment_id="${commentId}"&&session_id="${sessionId}"`;
+	const res = await fetch(
+		`${PB_URL}/api/collections/comment_votes/records?filter=${encodeURIComponent(voterFilter)}&perPage=1`,
+		{ headers: { Authorization: `Bearer ${token}` } }
+	);
+	if (!res.ok) return null;
+	const data = await res.json();
+	const items = (data.items ?? []) as CommentVote[];
+	return items[0] ?? null;
+}
+
+/**
+ * Cast or change a vote on a comment. Handles:
+ * - New vote: creates vote record, increments counter.
+ * - Same vote again: removes it (toggle off), decrements counter.
+ * - Changed vote: updates record, adjusts both counters.
+ * Returns the updated comment.
+ */
+export async function voteComment(
+	commentId: string,
+	vote: 'up' | 'down',
+	sessionId: string,
+	userId?: string
+): Promise<BookComment> {
+	const token = await getToken();
+
+	// Fetch current comment
+	const commentRes = await fetch(`${PB_URL}/api/collections/book_comments/records/${commentId}`, {
+		headers: { Authorization: `Bearer ${token}` }
+	});
+	if (!commentRes.ok) throw new Error(`Comment not found: ${commentId}`);
+	const comment = (await commentRes.json()) as BookComment;
+
+	const existing = await getCommentVote(commentId, sessionId, userId);
+
+	let upDelta = 0;
+	let downDelta = 0;
+
+	if (!existing) {
+		// New vote
+		await fetch(`${PB_URL}/api/collections/comment_votes/records`, {
+			method: 'POST',
+			headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+			body: JSON.stringify({ comment_id: commentId, user_id: userId ?? '', session_id: sessionId, vote })
+		});
+		vote === 'up' ? upDelta++ : downDelta++;
+	} else if (existing.vote === vote) {
+		// Toggle off — remove vote
+		await fetch(`${PB_URL}/api/collections/comment_votes/records/${existing.id}`, {
+			method: 'DELETE',
+			headers: { Authorization: `Bearer ${token}` }
+		});
+		vote === 'up' ? upDelta-- : downDelta--;
+	} else {
+		// Changed vote
+		await fetch(`${PB_URL}/api/collections/comment_votes/records/${existing.id}`, {
+			method: 'PATCH',
+			headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+			body: JSON.stringify({ vote })
+		});
+		if (vote === 'up') { upDelta++; downDelta--; }
+		else { upDelta--; downDelta++; }
+	}
+
+	// Patch comment counters
+	const patchRes = await fetch(`${PB_URL}/api/collections/book_comments/records/${commentId}`, {
+		method: 'PATCH',
+		headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+		body: JSON.stringify({
+			upvotes: Math.max(0, (comment.upvotes ?? 0) + upDelta),
+			downvotes: Math.max(0, (comment.downvotes ?? 0) + downDelta)
+		})
+	});
+	if (!patchRes.ok) throw new Error(`Failed to update vote counts on comment ${commentId}`);
+	return patchRes.json() as Promise<BookComment>;
+}
+
+/**
+ * Fetch votes cast by this session/user, keyed by comment_id.
+ * Returns a map of commentId → 'up' | 'down'.
+ */
+export async function getMyVotes(
+	commentIds: string[],
+	sessionId: string,
+	userId?: string
+): Promise<Record<string, 'up' | 'down'>> {
+	if (commentIds.length === 0) return {};
+	const token = await getToken();
+	const idFilter = commentIds.map((id) => `comment_id="${id}"`).join('||');
+	const voterPart = userId ? `user_id="${userId}"` : `session_id="${sessionId}"`;
+	const filter = encodeURIComponent(`(${idFilter})&&${voterPart}`);
+	const res = await fetch(
+		`${PB_URL}/api/collections/comment_votes/records?filter=${filter}&perPage=200`,
+		{ headers: { Authorization: `Bearer ${token}` } }
+	);
+	if (!res.ok) return {};
+	const data = await res.json();
+	const map: Record<string, 'up' | 'down'> = {};
+	for (const v of (data.items ?? []) as CommentVote[]) {
+		map[v.comment_id] = v.vote as 'up' | 'down';
+	}
+	return map;
+}
+
+// ─── User subscriptions ───────────────────────────────────────────────────────
+
+export interface UserSubscription {
+	id: string;
+	follower_id: string;
+	followee_id: string;
+	created: string;
+}
+
+/**
+ * Returns the subscription record if follower_id follows followee_id, else null.
+ */
+export async function getSubscription(
+	followerId: string,
+	followeeId: string
+): Promise<UserSubscription | null> {
+	const filter = encodeURIComponent(`follower_id="${followerId}"&&followee_id="${followeeId}"`);
+	const res = await pbGet<{ items: UserSubscription[]; totalItems: number }>(
+		`/api/collections/user_subscriptions/records?filter=${filter}&perPage=1`
+	).catch(() => null);
+	return res?.items?.[0] ?? null;
+}
+
+/**
+ * Subscribe follower_id to followee_id. No-ops if already subscribed.
+ * Returns the subscription record.
+ */
+export async function subscribe(followerId: string, followeeId: string): Promise<void> {
+	const existing = await getSubscription(followerId, followeeId);
+	if (existing) return;
+	const res = await pbPost('/api/collections/user_subscriptions/records', {
+		follower_id: followerId,
+		followee_id: followeeId,
+		created: new Date().toISOString()
+	});
+	if (!res.ok) {
+		const body = await res.text().catch(() => '');
+		throw new Error(`Failed to subscribe: ${res.status} — ${body}`);
+	}
+}
+
+/**
+ * Unsubscribe follower_id from followee_id. No-ops if not subscribed.
+ */
+export async function unsubscribe(followerId: string, followeeId: string): Promise<void> {
+	const existing = await getSubscription(followerId, followeeId);
+	if (!existing) return;
+	const token = await getToken();
+	await fetch(`${PB_URL}/api/collections/user_subscriptions/records/${existing.id}`, {
+		method: 'DELETE',
+		headers: { Authorization: `Bearer ${token}` }
+	});
+}
+
+/**
+ * Returns the list of user IDs that followerId is subscribed to.
+ */
+export async function getFollowingIds(followerId: string): Promise<string[]> {
+	const items = await listAll<UserSubscription>(
+		'user_subscriptions',
+		`follower_id="${followerId}"`,
+		'-created'
+	).catch(() => [] as UserSubscription[]);
+	return items.map((s) => s.followee_id);
+}
+
+/**
+ * Returns the count of subscribers (followers) for a given user.
+ */
+export async function getFollowerCount(followeeId: string): Promise<number> {
+	return countCollection('user_subscriptions', `followee_id="${followeeId}"`).catch(() => 0);
+}
+
+/**
+ * Returns the count of accounts a user is following.
+ */
+export async function getFollowingCount(followerId: string): Promise<number> {
+	return countCollection('user_subscriptions', `follower_id="${followerId}"`).catch(() => 0);
+}
+
+/**
+ * Public profile data for a user.
+ */
+export interface PublicProfile {
+	id: string;
+	username: string;
+	avatar_url?: string;
+	created: string;
+	followerCount: number;
+	followingCount: number;
+}
+
+/**
+ * Returns a user's public profile (no sensitive fields) by username.
+ */
+export async function getPublicProfile(username: string): Promise<PublicProfile | null> {
+	const user = await getUserByUsername(username);
+	if (!user) return null;
+	const [followerCount, followingCount] = await Promise.all([
+		getFollowerCount(user.id),
+		getFollowingCount(user.id)
+	]);
+	return {
+		id: user.id,
+		username: user.username,
+		avatar_url: user.avatar_url,
+		created: user.created,
+		followerCount,
+		followingCount
+	};
+}
+
+/**
+ * Returns a user's public library: books they have saved or are reading.
+ * Only includes books with progress or explicit saves (user_library).
+ */
+export async function getUserPublicLibrary(
+	userId: string
+): Promise<Array<{ book: Book; chapter: number | null; saved: boolean }>> {
+	const [allBooks, progressList, savedEntries] = await Promise.all([
+		listBooks(),
+		listAll<Progress>('progress', `user_id="${userId}"`, '-updated').catch(() => [] as Progress[]),
+		listAll<{ id: string; slug: string; saved_at: string }>(
+			'user_library',
+			`user_id="${userId}"`,
+			'-saved_at'
+		).catch(() => [] as { id: string; slug: string; saved_at: string }[])
+	]);
+
+	const bookMap = new Map<string, Book>(allBooks.map((b) => [b.slug, b]));
+	const result: Array<{ book: Book; chapter: number | null; saved: boolean }> = [];
+	const seen = new Set<string>();
+
+	// Books with progress first (most recently read)
+	for (const p of progressList) {
+		const book = bookMap.get(p.slug);
+		if (!book || seen.has(p.slug)) continue;
+		seen.add(p.slug);
+		result.push({ book, chapter: p.chapter, saved: false });
+	}
+
+	// Saved-only books next
+	for (const e of savedEntries) {
+		const book = bookMap.get(e.slug);
+		if (!book || seen.has(e.slug)) continue;
+		seen.add(e.slug);
+		result.push({ book, chapter: null, saved: true });
+	}
+
+	// Mark saved flag for books that are both in progress AND saved
+	const savedSlugs = new Set(savedEntries.map((e) => e.slug));
+	return result.map((r) => ({ ...r, saved: savedSlugs.has(r.book.slug) }));
+}
+
+/**
+ * Returns the currently-reading books (books with progress, not completed)
+ * for a given user ID.
+ */
+export async function getUserCurrentlyReading(
+	userId: string
+): Promise<Array<{ book: Book; chapter: number }>> {
+	const [allBooks, progressList] = await Promise.all([
+		listBooks(),
+		listAll<Progress>('progress', `user_id="${userId}"`, '-updated').catch(() => [] as Progress[])
+	]);
+	const bookMap = new Map<string, Book>(allBooks.map((b) => [b.slug, b]));
+	return progressList
+		.filter((p) => {
+			const book = bookMap.get(p.slug);
+			return book && p.chapter > 0 && p.chapter < book.total_chapters;
+		})
+		.slice(0, 10)
+		.map((p) => ({ book: bookMap.get(p.slug)!, chapter: p.chapter }));
+}
+
+/**
+ * Returns recently-updated books from ALL users that followerId is subscribed to.
+ * Deduplicates across followed users; sorts by most recently updated.
+ */
+export async function getSubscriptionFeed(
+	followerId: string,
+	limit = 12
+): Promise<Array<{ book: Book; readerUsername: string }>> {
+	const followingIds = await getFollowingIds(followerId);
+	if (followingIds.length === 0) return [];
+
+	// Fetch all users we follow (for display names)
+	const token = await getToken();
+	const userFetches = followingIds.map((id) =>
+		fetch(`${PB_URL}/api/collections/app_users/records/${id}`, {
+			headers: { Authorization: `Bearer ${token}` }
+		})
+			.then((r) => (r.ok ? (r.json() as Promise<User>) : null))
+			.catch(() => null)
+	);
+	const users = (await Promise.all(userFetches)).filter(Boolean) as User[];
+	const userMap = new Map<string, User>(users.map((u) => [u.id, u]));
+
+	// Fetch progress for each followed user
+	const progressFetches = followingIds.map((id) =>
+		listAll<Progress>('progress', `user_id="${id}"`, '-updated').catch(() => [] as Progress[])
+	);
+	const allProgressArrays = await Promise.all(progressFetches);
+
+	const allBooks = await listBooks();
+	const bookMap = new Map<string, Book>(allBooks.map((b) => [b.slug, b]));
+
+	// Merge: per slug take the most-recent progress entry
+	const seen = new Set<string>();
+	const feed: Array<{ book: Book; readerUsername: string; updated: string }> = [];
+
+	for (let i = 0; i < followingIds.length; i++) {
+		const uid = followingIds[i];
+		const username = userMap.get(uid)?.username ?? 'unknown';
+		for (const p of allProgressArrays[i]) {
+			if (seen.has(p.slug)) continue;
+			const book = bookMap.get(p.slug);
+			if (!book) continue;
+			seen.add(p.slug);
+			feed.push({ book, readerUsername: username, updated: p.updated });
+		}
+	}
+
+	// Sort by most recently read across all followed users
+	feed.sort((a, b) => b.updated.localeCompare(a.updated));
+	return feed.slice(0, limit).map(({ book, readerUsername }) => ({ book, readerUsername }));
+}

ui/src/routes/+layout.svelte

@@ -5,12 +5,16 @@
 	import type { Snippet } from 'svelte';
 	import type { LayoutData } from './$types';
 	import { audioStore } from '$lib/audio.svelte';
+	import { env } from '$env/dynamic/public';
 
 	let { children, data }: { children: Snippet; data: LayoutData } = $props();
 
 	// 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 +212,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 +248,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 +340,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 +372,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 +390,16 @@
 					</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>
+				{#if env.PUBLIC_BUILD_VERSION && env.PUBLIC_BUILD_VERSION !== 'dev'}
+					<span class="text-zinc-800">{env.PUBLIC_BUILD_VERSION}+{env.PUBLIC_BUILD_COMMIT?.slice(0, 7)}</span>
+				{/if}
+			</div>
 		</div>
 	</footer>
 </div>
@@ -375,6 +408,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 +472,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 +496,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 +587,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/+page.server.ts

@@ -3,7 +3,8 @@ import {
 	listBooks,
 	recentlyAddedBooks,
 	allProgress,
-	getHomeStats
+	getHomeStats,
+	getSubscriptionFeed
 } from '$lib/server/pocketbase';
 import { log } from '$lib/server/logger';
 import type { Book, Progress } from '$lib/server/pocketbase';
@@ -38,9 +39,18 @@ export const load: PageServerLoad = async ({ locals }) => {
 	const inProgressSlugs = new Set(continueReading.map((c) => c.book.slug));
 	const recentlyUpdated = recentBooks.filter((b) => !inProgressSlugs.has(b.slug)).slice(0, 6);
 
+	// Subscription feed — only when logged in
+	const subscriptionFeed = locals.user
+		? await getSubscriptionFeed(locals.user.id, 12).catch((e) => {
+				log.error('home', 'failed to load subscription feed', { err: String(e) });
+				return [] as Awaited<ReturnType<typeof getSubscriptionFeed>>;
+			})
+		: [];
+
 	return {
 		continueReading,
 		recentlyUpdated,
+		subscriptionFeed,
 		stats: {
 			...stats,
 			booksInProgress: continueReading.length

ui/src/routes/+page.svelte

@@ -147,3 +147,56 @@
 		</a>
 	</div>
 {/if}
+
+<!-- From Subscriptions -->
+{#if data.subscriptionFeed.length > 0}
+	<section class="mb-10">
+		<div class="flex items-baseline justify-between mb-3">
+			<h2 class="text-lg font-bold text-zinc-100">From People You Follow</h2>
+		</div>
+		<div class="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-6 gap-4">
+			{#each data.subscriptionFeed as { book, readerUsername }}
+				{@const genres = parseGenres(book.genres)}
+				<a
+					href="/books/{book.slug}"
+					class="group flex flex-col rounded-lg overflow-hidden bg-zinc-800 hover:bg-zinc-700 transition-colors border border-zinc-700 hover:border-zinc-500"
+				>
+					<div class="aspect-[2/3] bg-zinc-900 overflow-hidden">
+						{#if book.cover}
+							<img
+								src={book.cover}
+								alt={book.title}
+								class="w-full h-full object-cover group-hover:scale-105 transition-transform duration-300"
+								loading="lazy"
+							/>
+						{:else}
+							<div class="w-full h-full flex items-center justify-center text-zinc-600">
+								<svg class="w-10 h-10" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+									<path stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5"
+										d="M12 6.253v13m0-13C10.832 5.477 9.246 5 7.5 5S4.168 5.477 3 6.253v13C4.168 18.477 5.754 18 7.5 18s3.332.477 4.5 1.253m0-13C13.168 5.477 14.754 5 16.5 5c1.747 0 3.332.477 4.5 1.253v13C19.832 18.477 18.247 18 16.5 18c-1.746 0-3.332.477-4.5 1.253" />
+								</svg>
+							</div>
+						{/if}
+					</div>
+					<div class="p-2 flex flex-col gap-1">
+						<h3 class="text-xs font-semibold text-zinc-100 line-clamp-2 leading-snug">{book.title ?? ''}</h3>
+						{#if book.author}
+							<p class="text-xs text-zinc-400 truncate">{book.author}</p>
+						{/if}
+						<!-- Reader attribution -->
+						<p class="text-xs text-zinc-600 truncate mt-0.5">
+							via <span class="text-amber-500/70">{readerUsername}</span>
+						</p>
+						{#if genres.length > 0}
+							<div class="flex flex-wrap gap-1 mt-auto pt-1">
+								{#each genres.slice(0, 1) as genre}
+									<span class="text-xs px-1 py-0.5 rounded bg-zinc-900 text-zinc-500">{genre}</span>
+								{/each}
+							</div>
+						{/if}
+					</div>
+				</a>
+			{/each}
+		</div>
+	</section>
+{/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,22 @@
+import { json, error } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { getUserByUsername } from '$lib/server/pocketbase';
+
+/**
+ * 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');
+	}
+	// Fetch full record from PocketBase to get avatar_url
+	const record = await getUserByUsername(locals.user.username).catch(() => null);
+	return json({
+		id: locals.user.id,
+		username: locals.user.username,
+		role: locals.user.role,
+		avatar_url: record?.avatar_url ?? null
+	});
+};

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`);
+	}
+};