good luck

README_API.md

@@ -34,8 +34,8 @@ uvicorn api:app --reload --host 0.0.0.0 --port 8000
 | Method | Path                 | Description                                                                                        |
 | ------ | -------------------- | -------------------------------------------------------------------------------------------------- |
 | GET    | `/entries`           | List all chapters. Query: `order_by`, `order_desc`                                                 |
-| GET    | `/segments`          | Get segments. Query: `provider_id`, `manga_title`, `chapter_number`, `page_number` (all optional)  |
-| GET    | `/chapters/segments` | Get all segments for one chapter. Query: `provider_id`, `manga_title`, `chapter_number` (required) |
+| GET    | `/panels`          | Get panels. Query: `manga_title`, `chapter_number`, `page_number` (all optional)  |
+| GET    | `/chapters/panels` | Get all panels for one chapter. Query: `manga_title`, `chapter_number` (required) |
 | GET    | `/health`            | Health check                                                                                       |
 
 ## Example requests (frontend or curl)
@@ -48,10 +48,10 @@ curl "http://localhost:8000/entries"
 curl "http://localhost:8000/entries?order_by=manga_title&order_desc=false"
 
 # Get all segments for a chapter
-curl "http://localhost:8000/chapters/segments?provider_id=local&manga_title=One%20Piece&chapter_number=1"
+curl "http://localhost:8000/chapters/panels?manga_title=One%20Piece&chapter_number=1"
 
 # Get segments for one page
-curl "http://localhost:8000/segments?provider_id=local&manga_title=One%20Piece&chapter_number=1&page_number=1"
+curl "http://localhost:8000/panels?manga_title=One%20Piece&chapter_number=1&page_number=1"
 ```
 
 ## CORS

alembic/env.py

@@ -21,10 +21,8 @@ except ImportError:
 # Import all models so they're registered with SQLModel.metadata
 from db.models import (
     Manga,
-    MangaSource,
     Chapters,
-    Pages,
-    Segments,
+    Panels,
     Users,
     ReadingListCollection,
     ReadingListItem,

alembic/versions/20260429_000005_squash_panels_mangadex_remove_manga_source.py

@@ -0,0 +1,253 @@
+"""squash: panels refactor + mangadex ids + remove manga_source
+
+Revision ID: 20260429_000005
+Revises: 34d55d0d8469
+Create Date: 2026-04-29
+
+This squashes the following revisions into one:
+  - 20260429_000001_segments_match_translated_segment_shape.py
+  - 20260429_000002_panels_drop_pages.py
+  - 20260429_000003_add_mangadex_chapter_id_to_chapters_panels.py
+  - 20260429_000004_remove_manga_source.py
+
+Target end-state:
+  - pages/segments removed; panels table used instead
+  - chapters and panels include mangadex_chapter_id
+  - manga includes mangadex_manga_id; manga_source removed
+"""
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import text
+
+
+revision = "20260429_000005"
+down_revision = "34d55d0d8469"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+
+    # --- 1) segments: rename segment_index -> bubble_index; add width/height ---
+    # Handle both "segment_index" (older) and already-renamed "bubble_index" (idempotent).
+    conn.execute(
+        text(
+            """
+            DO $$
+            BEGIN
+              IF EXISTS (
+                SELECT 1 FROM information_schema.columns
+                WHERE table_name='segments' AND column_name='segment_index'
+              ) AND NOT EXISTS (
+                SELECT 1 FROM information_schema.columns
+                WHERE table_name='segments' AND column_name='bubble_index'
+              ) THEN
+                ALTER TABLE segments RENAME COLUMN segment_index TO bubble_index;
+              END IF;
+            END
+            $$;
+            """
+        )
+    )
+
+    conn.execute(
+        text(
+            """
+            DO $$
+            BEGIN
+              IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name='segments') THEN
+                IF NOT EXISTS (
+                  SELECT 1 FROM information_schema.columns
+                  WHERE table_name='segments' AND column_name='width'
+                ) THEN
+                  ALTER TABLE segments ADD COLUMN width INTEGER NULL;
+                END IF;
+                IF NOT EXISTS (
+                  SELECT 1 FROM information_schema.columns
+                  WHERE table_name='segments' AND column_name='height'
+                ) THEN
+                  ALTER TABLE segments ADD COLUMN height INTEGER NULL;
+                END IF;
+              END IF;
+            END
+            $$;
+            """
+        )
+    )
+
+    # Ensure composite index matches the renamed column (best-effort).
+    conn.execute(text("DROP INDEX IF EXISTS ix_segments_page_segment"))
+    conn.execute(text("DROP INDEX IF EXISTS ix_segments_page_bubble"))
+    conn.execute(
+        text(
+            """
+            DO $$
+            BEGIN
+              IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name='segments') THEN
+                CREATE INDEX IF NOT EXISTS ix_segments_page_bubble ON segments (page_id, bubble_index);
+              END IF;
+            END
+            $$;
+            """
+        )
+    )
+
+    # --- 2) create panels and migrate data from segments+pages ---
+    op.create_table(
+        "panels",
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("chapter_id", sa.Integer(), nullable=False),
+        sa.Column("page_number", sa.Integer(), nullable=False),
+        sa.Column("mangadex_chapter_id", sa.String(), nullable=True),
+        sa.Column("bubble_index", sa.Integer(), nullable=False),
+        sa.Column("width", sa.Integer(), nullable=True),
+        sa.Column("height", sa.Integer(), nullable=True),
+        sa.Column("x1", sa.Float(), nullable=False),
+        sa.Column("y1", sa.Float(), nullable=False),
+        sa.Column("x2", sa.Float(), nullable=False),
+        sa.Column("y2", sa.Float(), nullable=False),
+        sa.Column("original_text", sa.String(), nullable=False),
+        sa.Column("translated_text", sa.String(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), nullable=True),
+        sa.ForeignKeyConstraint(["chapter_id"], ["chapters.id"]),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index("ix_panels_chapter_id", "panels", ["chapter_id"], unique=False)
+    op.create_index("ix_panels_page_number", "panels", ["page_number"], unique=False)
+    op.create_index(
+        "ix_panels_chapter_page_bubble",
+        "panels",
+        ["chapter_id", "page_number", "bubble_index"],
+        unique=False,
+    )
+    op.create_index(
+        "ix_panels_mangadex_chapter_id",
+        "panels",
+        ["mangadex_chapter_id"],
+        unique=False,
+    )
+
+    # Copy all existing segment rows into panels (if the old tables exist).
+    conn.execute(
+        text(
+            """
+            DO $$
+            BEGIN
+              IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name='segments')
+                 AND EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name='pages')
+              THEN
+                INSERT INTO panels
+                    (chapter_id, page_number, bubble_index, width, height,
+                     x1, y1, x2, y2, original_text, translated_text, created_at)
+                SELECT
+                    p.chapter_id,
+                    p.page_number,
+                    s.bubble_index,
+                    s.width,
+                    s.height,
+                    s.x1, s.y1, s.x2, s.y2,
+                    s.original_text,
+                    s.translated_text,
+                    s.created_at
+                FROM segments s
+                INNER JOIN pages p ON p.id = s.page_id;
+              END IF;
+            END
+            $$;
+            """
+        )
+    )
+
+    # --- 3) add mangadex_chapter_id to chapters (nullable) ---
+    conn.execute(
+        text(
+            """
+            DO $$
+            BEGIN
+              IF NOT EXISTS (
+                SELECT 1 FROM information_schema.columns
+                WHERE table_name='chapters' AND column_name='mangadex_chapter_id'
+              ) THEN
+                ALTER TABLE chapters ADD COLUMN mangadex_chapter_id VARCHAR NULL;
+              END IF;
+            END
+            $$;
+            """
+        )
+    )
+    conn.execute(text("CREATE INDEX IF NOT EXISTS ix_chapters_mangadex_chapter_id ON chapters (mangadex_chapter_id)"))
+
+    # Copy chapter mangadex id into panels (best-effort backfill).
+    conn.execute(
+        text(
+            """
+            UPDATE panels p
+            SET mangadex_chapter_id = c.mangadex_chapter_id
+            FROM chapters c
+            WHERE p.chapter_id = c.id
+              AND p.mangadex_chapter_id IS NULL
+              AND c.mangadex_chapter_id IS NOT NULL;
+            """
+        )
+    )
+
+    # --- 4) manga: add mangadex_manga_id and backfill from manga_source, then drop manga_source ---
+    conn.execute(
+        text(
+            """
+            DO $$
+            BEGIN
+              IF NOT EXISTS (
+                SELECT 1 FROM information_schema.columns
+                WHERE table_name='manga' AND column_name='mangadex_manga_id'
+              ) THEN
+                ALTER TABLE manga ADD COLUMN mangadex_manga_id VARCHAR NULL;
+              END IF;
+            END
+            $$;
+            """
+        )
+    )
+    conn.execute(text("CREATE INDEX IF NOT EXISTS ix_manga_mangadex_manga_id ON manga (mangadex_manga_id)"))
+    conn.execute(
+        text(
+            """
+            DO $$
+            BEGIN
+              IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name='manga_source') THEN
+                UPDATE manga m
+                SET mangadex_manga_id = ms.external_manga_id
+                FROM (
+                  SELECT manga_id, MIN(external_manga_id) AS external_manga_id
+                  FROM manga_source
+                  WHERE provider_id = 'mangadex'
+                    AND external_manga_id IS NOT NULL
+                    AND external_manga_id NOT LIKE 'legacy-%'
+                    AND external_manga_id NOT LIKE 'local-%'
+                  GROUP BY manga_id
+                ) ms
+                WHERE m.id = ms.manga_id
+                  AND (m.mangadex_manga_id IS NULL OR m.mangadex_manga_id = '');
+              END IF;
+            END
+            $$;
+            """
+        )
+    )
+    conn.execute(
+        text(
+            "CREATE UNIQUE INDEX IF NOT EXISTS uq_manga_mangadex_manga_id ON manga (mangadex_manga_id)"
+        )
+    )
+    conn.execute(text("DROP TABLE IF EXISTS manga_source CASCADE"))
+
+    # --- 5) drop old pages/segments tables (if present) ---
+    conn.execute(text("DROP TABLE IF EXISTS segments CASCADE"))
+    conn.execute(text("DROP TABLE IF EXISTS pages CASCADE"))
+
+
+def downgrade() -> None:
+    raise NotImplementedError("Squashed migration is not designed to downgrade.")
+

alembic/versions/20260429_000006_single_provider_drop_provider_id_nullable_page_number.py

@@ -0,0 +1,60 @@
+"""single provider: drop chapters.provider_id; panels.page_number nullable
+
+Revision ID: 20260429_000006
+Revises: 20260429_000005
+Create Date: 2026-04-29
+"""
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import text
+
+
+revision = "20260429_000006"
+down_revision = "20260429_000005"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+
+    # --- chapters: drop provider_id + replace unique constraint ---
+    # Drop old constraint/index if present.
+    conn.execute(text("ALTER TABLE chapters DROP CONSTRAINT IF EXISTS uq_chapters_manga_provider_chapter"))
+    conn.execute(text("DROP INDEX IF EXISTS ix_chapters_provider_id"))
+
+    # Drop the column if it exists.
+    conn.execute(
+        text(
+            """
+            DO $$
+            BEGIN
+              IF EXISTS (
+                SELECT 1 FROM information_schema.columns
+                WHERE table_name='chapters' AND column_name='provider_id'
+              ) THEN
+                ALTER TABLE chapters DROP COLUMN provider_id;
+              END IF;
+            END
+            $$;
+            """
+        )
+    )
+
+    # Ensure new uniqueness.
+    conn.execute(text("ALTER TABLE chapters DROP CONSTRAINT IF EXISTS uq_chapters_manga_chapter"))
+    conn.execute(text("ALTER TABLE chapters ADD CONSTRAINT uq_chapters_manga_chapter UNIQUE (manga_id, chapter_number)"))
+
+    # --- panels: allow page_number NULL ---
+    op.alter_column(
+        "panels",
+        "page_number",
+        existing_type=sa.Integer(),
+        nullable=True,
+    )
+
+
+def downgrade() -> None:
+    raise NotImplementedError("Not supporting downgrade for this schema simplification.")
+

alembic/versions/20260429_000007_panels_add_panel_url.py

@@ -0,0 +1,24 @@
+"""panels: add panel_url
+
+Revision ID: 20260429_000007
+Revises: 20260429_000006
+Create Date: 2026-04-29
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+
+revision = "20260429_000007"
+down_revision = "20260429_000006"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column("panels", sa.Column("panel_url", sa.String(), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column("panels", "panel_url")
+

alembic/versions/20260429_000008_panels_panel_url_unique_partial.py

@@ -0,0 +1,29 @@
+"""panels: global unique panel_url (when set)
+
+Revision ID: 20260429_000008
+Revises: 20260429_000007
+Create Date: 2026-04-29
+"""
+
+from alembic import op
+
+
+revision = "20260429_000008"
+down_revision = "20260429_000007"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # Postgres: enforce uniqueness only when panel_url is present (still allows many NULLs).
+    op.execute(
+        """
+        CREATE UNIQUE INDEX IF NOT EXISTS uq_panels_panel_url_not_null
+        ON panels (panel_url)
+        WHERE panel_url IS NOT NULL;
+        """
+    )
+
+
+def downgrade() -> None:
+    op.execute("DROP INDEX IF EXISTS uq_panels_panel_url_not_null;")

alembic/versions/20260429_000009_dedupe_manga_mangadex.py

@@ -0,0 +1,146 @@
+"""Data migration: merge duplicate manga rows sharing the same MangaDex series id.
+
+Revision ID: 20260429_000009
+Revises: 20260429_000008
+Create Date: 2026-04-29
+
+When the same series was added to several reading lists in parallel, multiple
+``manga`` rows could be created with the same ``mangadex_manga_id`` (possibly
+differing only by case). This migration:
+
+- Keeps the smallest ``manga.id`` per ``lower(trim(mangadex_manga_id))`` group
+- Points ``reading_list_item`` and ``chapters`` at that canonical row
+- Merges overlapping chapters (same ``chapter_number``) by moving panels and
+  dropping duplicate chapters; deletes source panels that would duplicate a
+  non-null ``panel_url`` already present on the target chapter
+- Removes extra ``reading_list_item`` rows that share the same
+  ``(reading_list_id, manga_id)`` after the merge (keeps best progress)
+
+Requires PostgreSQL. Irreversible: duplicate rows are deleted, not restored.
+"""
+
+from __future__ import annotations
+
+from alembic import op
+from sqlalchemy import text
+
+
+revision = "20260429_000009"
+down_revision = "20260429_000008"
+branch_labels = None
+depends_on = None
+
+
+def _merge_one_duplicate_manga(conn, canonical_id: int, dup_id: int) -> None:
+    """Remap FKs from dup_id onto canonical_id, then delete dup_id manga row."""
+    conn.execute(
+        text(
+            "UPDATE reading_list_item SET manga_id = :canon WHERE manga_id = :dup",
+        ),
+        {"canon": canonical_id, "dup": dup_id},
+    )
+
+    chapters = conn.execute(
+        text(
+            "SELECT id, chapter_number FROM chapters WHERE manga_id = :d ORDER BY id",
+        ),
+        {"d": dup_id},
+    ).fetchall()
+
+    for ch_id, ch_num in chapters:
+        row = conn.execute(
+            text(
+                "SELECT id FROM chapters WHERE manga_id = :c AND chapter_number = :n "
+                "LIMIT 1",
+            ),
+            {"c": canonical_id, "n": ch_num},
+        ).fetchone()
+
+        if row is not None:
+            canon_ch_id = row[0]
+            # Drop source panels whose panel_url already exists on the target chapter
+            # (partial unique index uq_panels_panel_url_not_null).
+            conn.execute(
+                text(
+                    """
+                    DELETE FROM panels p
+                    WHERE p.chapter_id = :old_ch
+                      AND p.panel_url IS NOT NULL
+                      AND EXISTS (
+                        SELECT 1 FROM panels p2
+                        WHERE p2.chapter_id = :new_ch
+                          AND p2.panel_url IS NOT NULL
+                          AND p2.panel_url = p.panel_url
+                      )
+                    """,
+                ),
+                {"old_ch": ch_id, "new_ch": canon_ch_id},
+            )
+            conn.execute(
+                text(
+                    "UPDATE panels SET chapter_id = :cc WHERE chapter_id = :oc",
+                ),
+                {"cc": canon_ch_id, "oc": ch_id},
+            )
+            conn.execute(text("DELETE FROM chapters WHERE id = :oc"), {"oc": ch_id})
+        else:
+            conn.execute(
+                text("UPDATE chapters SET manga_id = :c WHERE id = :cid"),
+                {"c": canonical_id, "cid": ch_id},
+            )
+
+    conn.execute(text("DELETE FROM manga WHERE id = :d"), {"d": dup_id})
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+
+    groups = conn.execute(
+        text(
+            """
+            SELECT array_agg(id ORDER BY id) AS ids
+            FROM manga
+            WHERE mangadex_manga_id IS NOT NULL
+              AND btrim(mangadex_manga_id) <> ''
+            GROUP BY lower(btrim(mangadex_manga_id))
+            HAVING COUNT(*) > 1
+            """,
+        ),
+    ).fetchall()
+
+    for (ids_arr,) in groups:
+        if not ids_arr:
+            continue
+        ids = [int(x) for x in ids_arr]
+        canonical_id = min(ids)
+        dup_ids = [i for i in ids if i != canonical_id]
+        for dup_id in dup_ids:
+            _merge_one_duplicate_manga(conn, canonical_id, dup_id)
+
+    # Same list may now reference the same manga twice — keep one row (best progress).
+    conn.execute(
+        text(
+            """
+            DELETE FROM reading_list_item
+            WHERE id IN (
+              SELECT id FROM (
+                SELECT id,
+                       ROW_NUMBER() OVER (
+                         PARTITION BY reading_list_id, manga_id
+                         ORDER BY COALESCE(last_chapter_number, -1) DESC NULLS LAST,
+                                  updated_at DESC NULLS LAST,
+                                  id ASC
+                       ) AS rn
+                FROM reading_list_item
+              ) sub
+              WHERE rn > 1
+            )
+            """,
+        ),
+    )
+
+
+def downgrade() -> None:
+    raise NotImplementedError(
+        "Dedupe migration is irreversible (merged rows are deleted).",
+    )

api.py

@@ -1,5 +1,5 @@
 """
-Read-only API for the frontend. Wraps db list_entries, get_segments, get_chapter_segments.
+Read-only API for the frontend. Wraps db list_entries, get_panels, get_chapter_panels.
 Run from backend:  uvicorn api:app --reload --host 0.0.0.0 --port 8000
 """
 
@@ -22,7 +22,8 @@ from db.schemas import (
     ReadingListCollectionOut,
     ReadingListCollectionRenameIn,
     ReadingListItemOut,
-    SegmentListOut,
+    ReadingListProgressPatchIn,
+    PanelListOut,
     UserDisplayNamePatchIn,
 )
 
@@ -78,26 +79,23 @@ def list_mangas(
 @router.get("/chapters", response_model=list[ChapterListOut])
 def list_chapters(
     manga_title: str = Query(...),
-    provider_id: str | None = Query(None, description="e.g. local, mangadex"),
     limit: int | None = Query(None, ge=1, le=500, description="Max results (default: all)"),
     offset: int = Query(0, ge=0, description="Skip N results"),
 ):
-    """List chapters (id, chapter_number, created_at, updated_at). Filters by manga_title; optionally by provider_id."""
-    return db.list_chapters(manga_title, provider_id, limit=limit, offset=offset)
+    """List chapters (id, chapter_number, created_at, updated_at). Filters by manga_title."""
+    return db.list_chapters(manga_title, limit=limit, offset=offset)
 
 
-@router.get("/segments", response_model=list[SegmentListOut])
-def get_segments(
-    provider_id: str | None = Query(None, description="e.g. local, mangadex"),
+@router.get("/panels", response_model=list[PanelListOut])
+def get_panels(
     manga_title: str | None = Query(None),
     chapter_number: float | None = Query(None),
     page_number: int | None = Query(None),
     limit: int | None = Query(None, ge=1, le=1000, description="Max results (default: all)"),
     offset: int = Query(0, ge=0, description="Skip N results"),
 ):
-    """Get segments with optional filters. Supports pagination."""
-    return db.get_segments(
-        provider_id=provider_id,
+    """Get panels with optional filters. Supports pagination."""
+    return db.get_panels(
         manga_title=manga_title,
         chapter_number=chapter_number,
         page_number=page_number,
@@ -106,16 +104,17 @@ def get_segments(
     )
 
 
-@router.get("/chapters/segments", response_model=list[SegmentListOut])
-def get_chapter_segments(
-    provider_id: str = Query(..., description="e.g. local, mangadex"),
+@router.get("/chapters/panels", response_model=list[PanelListOut])
+def get_chapter_panels(
     manga_title: str = Query(...),
     chapter_number: float = Query(...),
     limit: int | None = Query(None, ge=1, le=1000, description="Max results (default: all)"),
     offset: int = Query(0, ge=0, description="Skip N results"),
 ):
-    """Get all segments for one chapter. Supports pagination."""
-    return db.get_chapter_segments(provider_id, manga_title, chapter_number, limit=limit, offset=offset)
+    """Get all panels for one chapter. Supports pagination."""
+    return db.get_chapter_panels(manga_title, chapter_number, limit=limit, offset=offset)
+
+
 
 
 # to make sure api is running and responding
@@ -214,14 +213,13 @@ def get_reading_list_items(
 def post_reading_list_item(
     user_id: CurrentUserId, reading_list_id: int, body: ReadingListAddIn
 ):
-    """Add or update a manga on a named list (by provider catalog id)."""
+    """Add or update a manga on a named list (by MangaDex series id)."""
     if db.get_reading_list_collection(user_id, reading_list_id) is None:
         raise HTTPException(status_code=404, detail="Reading list not found")
     try:
         row = db.add_reading_list_item_by_source(
             user_id,
             reading_list_id,
-            body.provider_id,
             body.external_manga_id,
             body.manga_title,
             last_chapter_number=body.last_chapter_number,
@@ -246,6 +244,32 @@ def delete_reading_list_item(
     return {"ok": True}
 
 
+@router.patch(
+    "/reading-lists/{reading_list_id}/items/{manga_id}",
+    response_model=ReadingListItemOut,
+)
+def patch_reading_list_item_progress(
+    user_id: CurrentUserId,
+    reading_list_id: int,
+    manga_id: int,
+    body: ReadingListProgressPatchIn,
+):
+    """Update last-read chapter for one manga row (stored value only increases)."""
+    ok = db.update_reading_list_item_last_read(
+        user_id,
+        reading_list_id,
+        manga_id,
+        body.last_chapter_number,
+    )
+    if not ok:
+        raise HTTPException(status_code=404, detail="Not on this reading list")
+    items = db.list_reading_list_items_with_manga(user_id, reading_list_id, limit=500)
+    for it in items:
+        if it.manga_id == manga_id:
+            return it
+    raise HTTPException(status_code=404, detail="Item not found after update")
+
+
 @router.patch("/users/me")
 def patch_me_display_name(ctx: CurrentAuthContext, body: UserDisplayNamePatchIn):
     """Update display_name on public.users for the signed-in user."""

db/__init__.py

@@ -4,8 +4,6 @@
     Users,
     ReadingListCollection,
     ReadingListItem,
-    MangaSource,
-    resolve_manga_id_by_source,
     get_reading_list_collection,
     create_reading_list_collection,
     update_reading_list_collection,
@@ -15,36 +13,39 @@
     upsert_reading_list_item,
     remove_reading_list_item_from_list,
     add_reading_list_item_by_source,
-    save_page_translation,
-    get_segments,
-    get_chapter_segments,
+    save_panels_translation,
+    get_panels,
+    get_chapter_panels,
+    delete_page_panels,
+    delete_chapter_panels,
     list_entries,
-    delete_page_segments,
-    delete_chapter_segments,
     get_connection,
     get_engine
 """
-from .const import PROVIDER_IDS, PROVIDER_LOCAL, PROVIDER_MANGADEX
-from .models import Users, ReadingListCollection, ReadingListItem, MangaSource
+from .models import Users, ReadingListCollection, ReadingListItem
 from .db import (
     init_db,
-    resolve_manga_id_by_source,
     get_reading_list_collection,
     create_reading_list_collection,
     update_reading_list_collection,
+    update_app_user_display_name,
     delete_reading_list_collection,
     list_reading_list_collections_with_counts,
     list_reading_list_items_with_manga,
     upsert_reading_list_item,
+    update_reading_list_item_last_read,
     remove_reading_list_item_from_list,
     add_reading_list_item_by_source,
-    save_page_translation,
-    get_segments,
-    get_chapter_segments,
+    save_panels_translation,
+    upsert_panel_translation,
+    get_panels,
+    get_panel_by_panel_url,
+    delete_panel_by_panel_url,
+    get_chapter_panels,
+    delete_page_panels,
+    delete_chapter_panels,
     list_mangas,
     list_chapters,
-    delete_page_segments,
-    delete_chapter_segments,
     delete_all_manga,
     get_connection,
     get_engine,

db/const.py

@@ -1,3 +0,0 @@
-PROVIDER_LOCAL = "local"
-PROVIDER_MANGADEX = "mangadex"
-PROVIDER_IDS = frozenset((PROVIDER_LOCAL, PROVIDER_MANGADEX))

db/db.py

@@ -1,7 +1,7 @@
 """
 Database: SQL (PostgreSQL) via SQLModel.
 
-Schema: Users, reading_list_collection, reading_list_item; Manga → Chapters → Pages → Segments
+Schema: Users, reading_list_collection, reading_list_item; Manga → Chapters → Panels
 
 Utility Functions:
 
@@ -20,27 +20,27 @@ get_connection(db_url=None):
 
 init_db(db_url=None):
     Initializes the database schema by creating tables for all SQLModel models
-    (Users, ReadingListCollection, ReadingListItem, Manga, Chapters, Pages, Segments).
+    (Users, ReadingListCollection, ReadingListItem, Manga, Chapters, Panels).
 
 Other Core Database Functions:
 
-save_page_translation(provider_id, manga_title, chapter_number, page_number, bubbles, language_code, db_url=None):
-    Saves text bubble/segment data for a specific manga page to the database.
+save_panels_translation(manga_title, chapter_number, page_number, panels, language_code, db_url=None):
+    Saves text bubble/panel data for a specific manga page to the database.
 
-get_segments(provider_id=None, manga_title=None, chapter_number=None, page_number=None, db_url=None):
-    Returns all segments (bubbles) matching the specified filters.
+get_panels(manga_title=None, chapter_number=None, page_number=None, db_url=None):
+    Returns all panels (bubbles) matching the specified filters.
 
-get_chapter_segments(provider_id, manga_title, chapter_number, db_url=None):
-    Returns all segments for every page in a single chapter.
+get_chapter_panels(manga_title, chapter_number, db_url=None):
+    Returns all panels for every page in a single chapter.
 
 list_entries(db_url=None, order_by="created_at", order_desc=True):
-    Lists chapters with provider_id, manga_title, chapter_number, and last_updated.
+    Lists chapters with manga_title, chapter_number, and last_updated.
 
-delete_page_segments(provider_id, manga_title, chapter_number, page_number, db_url=None):
-    Removes all segments for a specific page in a chapter.
+delete_page_panels(manga_title, chapter_number, page_number, db_url=None):
+    Removes all panels for a specific page in a chapter.
 
-delete_chapter_segments(provider_id, manga_title, chapter_number, db_url=None):
-    Removes all pages and segments for an entire chapter.
+delete_chapter_panels(manga_title, chapter_number, db_url=None):
+    Removes all panels for an entire chapter.
 """
 
 import os
@@ -49,15 +49,14 @@ from pathlib import Path
 from typing import Optional
 from uuid import UUID
 from sqlalchemy import desc, func
+from sqlalchemy.exc import IntegrityError
 from sqlmodel import Session, SQLModel, create_engine, select
 
-from .const import PROVIDER_IDS, PROVIDER_LOCAL, PROVIDER_MANGADEX
+# Single-provider setup (MangaDex).
 from .models import (
     Manga,
-    MangaSource,
     Chapters,
-    Pages,
-    Segments,
+    Panels,
     ReadingListCollection,
     ReadingListItem,
     Users,
@@ -66,15 +65,10 @@ from .schemas import (
     ChapterListOut,
     ReadingListCollectionOut,
     ReadingListItemOut,
-    SegmentListOut,
+    PanelListOut,
 )
 
 
-def _validate_provider_id(provider_id: str) -> None:
-    if provider_id not in PROVIDER_IDS:
-        raise ValueError(f"provider_id must be one of {sorted(PROVIDER_IDS)}, got {provider_id!r}")
-
-
 try:
     from dotenv import load_dotenv
     load_dotenv(Path(__file__).resolve().parent.parent / ".env")
@@ -109,109 +103,98 @@ def get_connection(db_url=None):
 
 
 def init_db(db_url=None):
-    """Create tables: users, reading_list_collection, reading_list_item, manga, manga_source, chapters, pages, segments."""
+    """Create tables: users, reading_list_collection, reading_list_item, manga, chapters, panels."""
     engine = get_engine(db_url)
     SQLModel.metadata.create_all(engine)
 
 
-def _is_placeholder_external_manga_id(external_manga_id: str) -> bool:
-    """Synthetic ids we generate when the provider has no catalog key (local-*, legacy-*)."""
-    return external_manga_id.startswith("legacy-") or external_manga_id.startswith("local-")
-
-
-def _synthetic_external_manga_id(provider_id: str, manga_id: int) -> str:
-    """Stable per-umbrella id for manga_source when no real external id was passed."""
-    if provider_id == PROVIDER_LOCAL:
-        return f"local-{manga_id}"
-    return f"legacy-{manga_id}"
-
-
-def _ensure_manga_source(session, manga_id: int, provider_id: str, external_manga_id: str) -> None:
-    stmt = select(MangaSource).where(
-        MangaSource.manga_id == manga_id,
-        MangaSource.provider_id == provider_id,
-    )
-    row = session.exec(stmt).first()
-    if row:
-        if external_manga_id and not _is_placeholder_external_manga_id(external_manga_id):
-            row.external_manga_id = external_manga_id
-            session.add(row)
-            session.flush()
-        return
-    session.add(
-        MangaSource(
-            manga_id=manga_id,
-            provider_id=provider_id,
-            external_manga_id=external_manga_id,
-        )
-    )
-    session.flush()
-
-
 def resolve_manga_id(
     session,
-    provider_id: str,
     manga_title: str,
     external_manga_id: Optional[str],
 ) -> int:
-    """Find or create umbrella manga and ensure a MangaSource row for this provider."""
-    ext_in = (external_manga_id or "").strip()
-    if ext_in:
-        src = session.exec(
-            select(MangaSource).where(
-                MangaSource.provider_id == provider_id,
-                MangaSource.external_manga_id == ext_in,
-            )
+    """Find or create umbrella manga.
+
+    If external_manga_id is provided, it is treated as MangaDex series id and stored
+    on Manga.mangadex_manga_id for later lookups.
+
+    MangaDex ids are normalized to lowercase so lookups stay stable. Concurrent
+    inserts for the same series id are merged via DB uniqueness + IntegrityError
+    handling (important when one title is added to several lists in parallel).
+    """
+    title_stripped = (manga_title or "").strip() or "Untitled"
+    ext_raw = (external_manga_id or "").strip()
+    norm_ext = ext_raw.lower() if ext_raw else ""
+
+    if norm_ext:
+        row = session.exec(
+            select(Manga).where(func.lower(Manga.mangadex_manga_id) == norm_ext),
         ).first()
-        if src:
-            return src.manga_id
+        if row:
+            return row.id
 
-    row = session.exec(select(Manga).where(Manga.manga_title == manga_title)).first()
+    row = session.exec(
+        select(Manga).where(Manga.manga_title == title_stripped),
+    ).first()
     if row:
-        synth = _synthetic_external_manga_id(provider_id, row.id)
-        _ensure_manga_source(session, row.id, provider_id, ext_in or synth)
+        if norm_ext:
+            existing_norm = (row.mangadex_manga_id or "").strip().lower()
+            if existing_norm != norm_ext:
+                row.mangadex_manga_id = norm_ext
+                row.updated_at = datetime.now(timezone.utc)
+                session.add(row)
+                session.flush()
         return row.id
 
-    m = Manga(manga_title=manga_title)
+    if norm_ext:
+        try:
+            with session.begin_nested():
+                m = Manga(manga_title=title_stripped, mangadex_manga_id=norm_ext)
+                session.add(m)
+                session.flush()
+                return m.id
+        except IntegrityError:
+            dup = session.exec(
+                select(Manga).where(
+                    func.lower(Manga.mangadex_manga_id) == norm_ext,
+                ),
+            ).first()
+            if dup is None:
+                raise
+            return dup.id
+
+    m = Manga(manga_title=title_stripped, mangadex_manga_id=None)
     session.add(m)
     session.flush()
-    synth = _synthetic_external_manga_id(provider_id, m.id)
-    _ensure_manga_source(session, m.id, provider_id, ext_in or synth)
     return m.id
 
 
-def resolve_manga_id_by_source(provider_id: str, external_manga_id: str, db_url=None) -> Optional[int]:
-    """Return umbrella manga id for a provider catalog id, if mapped."""
-    _validate_provider_id(provider_id)
-    ext = external_manga_id.strip()
-    if not ext:
-        return None
-    engine = get_engine(db_url)
-    with Session(engine) as session:
-        src = session.exec(
-            select(MangaSource).where(
-                MangaSource.provider_id == provider_id,
-                MangaSource.external_manga_id == ext,
-            )
-        ).first()
-        return src.manga_id if src else None
-
-
 def _get_or_create_chapter(
-    session, manga_id: int, provider_id: str, chapter_number: float, language_code: str
+    session,
+    manga_id: int,
+    chapter_number: float,
+    language_code: str,
+    *,
+    mangadex_chapter_id: Optional[str] = None,
 ) -> int:
     stmt = select(Chapters).where(
         Chapters.manga_id == manga_id,
-        Chapters.provider_id == provider_id,
         Chapters.chapter_number == chapter_number,
     )
     row = session.exec(stmt).first()
     if row:
+        if mangadex_chapter_id is not None:
+            v = mangadex_chapter_id.strip()
+            if v and row.mangadex_chapter_id != v:
+                row.mangadex_chapter_id = v
+                row.updated_at = datetime.now(timezone.utc)
+                session.add(row)
+                session.flush()
         return row.id
     ch = Chapters(
         manga_id=manga_id,
-        provider_id=provider_id,
         chapter_number=chapter_number,
+        mangadex_chapter_id=(mangadex_chapter_id.strip() if mangadex_chapter_id else None),
         language_code=language_code,
     )
     session.add(ch)
@@ -219,134 +202,202 @@ def _get_or_create_chapter(
     return ch.id
 
 
-def _get_or_create_page(session, chapter_id: int, page_number: int) -> int:
-    stmt = select(Pages).where(Pages.chapter_id == chapter_id, Pages.page_number == page_number)
-    row = session.exec(stmt).first()
-    if row:
-        return row.id
-    p = Pages(chapter_id=chapter_id, page_number=page_number)
-    session.add(p)
-    session.flush()
-    return p.id
+def save_panels_translation(
+    manga_title: str,
+    chapter_number: float,
+    page_number: Optional[int],
+    panels: list[dict],
+    language_code: str,
+    *,
+    external_manga_id: Optional[str] = None,
+    mangadex_chapter_id: Optional[str] = None,
+    db_url=None,
+) -> None:
+    """Save panels (replace existing for this manga/chapter/page)."""
+    engine = get_engine(db_url)
+    with Session(engine) as session:
+        manga_id = resolve_manga_id(session, manga_title, external_manga_id)
+        chapter_id = _get_or_create_chapter(
+            session,
+            manga_id,
+            chapter_number,
+            language_code,
+            mangadex_chapter_id=mangadex_chapter_id,
+        )
+        for p in session.exec(
+            select(Panels).where(Panels.chapter_id == chapter_id, Panels.page_number == page_number)
+        ).all():
+            session.delete(p)
+        session.flush()
+        for panel in panels:
+            row = Panels(
+                chapter_id=chapter_id,
+                page_number=page_number,
+                mangadex_chapter_id=(mangadex_chapter_id.strip() if mangadex_chapter_id else None),
+                bubble_index=panel["bubble_index"],
+                width=panel.get("width"),
+                height=panel.get("height"),
+                panel_url=panel.get("panel_url"),
+                x1=panel["x1"],
+                y1=panel["y1"],
+                x2=panel["x2"],
+                y2=panel["y2"],
+                original_text=panel["original_text"],
+                translated_text=panel["translated_text"],
+            )
+            session.add(row)
+        now = datetime.now(timezone.utc)
+        chapter = session.get(Chapters, chapter_id)
+        if chapter:
+            chapter.updated_at = now
+            manga = session.get(Manga, chapter.manga_id)
+            if manga:
+                manga.updated_at = now
+        session.commit()
 
 
-def save_page_translation(
-    provider_id: str,
+# Backwards-compatible alias (older code/tests may still import this name).
+save_panel_translation = save_panels_translation
+
+
+def upsert_panel_translation(
     manga_title: str,
     chapter_number: float,
-    page_number: int,
-    bubbles: list[dict],
+    page_number: Optional[int],
+    panel: dict,
     language_code: str,
     *,
     external_manga_id: Optional[str] = None,
+    mangadex_chapter_id: Optional[str] = None,
     db_url=None,
 ) -> None:
-    """Save one page's segments (replace existing for this provider/manga/chapter/page)."""
-    _validate_provider_id(provider_id)
+    """Insert/update a single panel without deleting other panels.
+
+    If panel_url is provided, uniqueness is treated as (chapter_id, page_number, panel_url).
+    Otherwise falls back to (chapter_id, page_number, bubble_index).
+    """
     engine = get_engine(db_url)
     with Session(engine) as session:
-        manga_id = resolve_manga_id(session, provider_id, manga_title, external_manga_id)
-        chapter_id = _get_or_create_chapter(session, manga_id, provider_id, chapter_number, language_code)
-        page_id = _get_or_create_page(session, chapter_id, page_number)
-        for s in session.exec(select(Segments).where(Segments.page_id == page_id)).all():
-            session.delete(s)
-        session.flush()
-        for b in bubbles:
-            seg = Segments(
-                page_id=page_id,
-                segment_index=b["bubble_index"],
-                x1=b["x1"], y1=b["y1"], x2=b["x2"], y2=b["y2"],
-                original_text=b["original_text"],
-                translated_text=b["translated_text"],
+        manga_id = resolve_manga_id(session, manga_title, external_manga_id)
+        chapter_id = _get_or_create_chapter(
+            session,
+            manga_id,
+            chapter_number,
+            language_code,
+            mangadex_chapter_id=mangadex_chapter_id,
+        )
+
+        bubble_index = panel["bubble_index"]
+        panel_url = panel.get("panel_url")
+        panel_url = panel_url.strip() if isinstance(panel_url, str) else None
+        if panel_url:
+            existing = session.exec(
+                select(Panels).where(
+                    Panels.chapter_id == chapter_id,
+                    Panels.page_number == page_number,
+                    Panels.panel_url == panel_url,
+                )
+            ).first()
+        else:
+            existing = session.exec(
+                select(Panels).where(
+                    Panels.chapter_id == chapter_id,
+                    Panels.page_number == page_number,
+                    Panels.bubble_index == bubble_index,
+                )
+            ).first()
+
+        mdx = mangadex_chapter_id.strip() if mangadex_chapter_id else None
+        if existing:
+            existing.mangadex_chapter_id = mdx
+            existing.panel_url = panel_url
+            existing.bubble_index = bubble_index
+            existing.width = panel.get("width")
+            existing.height = panel.get("height")
+            existing.x1 = panel["x1"]
+            existing.y1 = panel["y1"]
+            existing.x2 = panel["x2"]
+            existing.y2 = panel["y2"]
+            existing.original_text = panel["original_text"]
+            existing.translated_text = panel["translated_text"]
+            session.add(existing)
+        else:
+            row = Panels(
+                chapter_id=chapter_id,
+                page_number=page_number,
+                mangadex_chapter_id=mdx,
+                bubble_index=bubble_index,
+                width=panel.get("width"),
+                height=panel.get("height"),
+                panel_url=panel_url,
+                x1=panel["x1"],
+                y1=panel["y1"],
+                x2=panel["x2"],
+                y2=panel["y2"],
+                original_text=panel["original_text"],
+                translated_text=panel["translated_text"],
             )
-            session.add(seg)
+            session.add(row)
+
         now = datetime.now(timezone.utc)
-        page = session.get(Pages, page_id)
-        if page:
-            page.updated_at = now
-            chapter = session.get(Chapters, page.chapter_id)
-            if chapter:
-                chapter.updated_at = now
-                manga = session.get(Manga, chapter.manga_id)
-                if manga:
-                    manga.updated_at = now
+        chapter = session.get(Chapters, chapter_id)
+        if chapter:
+            chapter.updated_at = now
+            manga = session.get(Manga, chapter.manga_id)
+            if manga:
+                manga.updated_at = now
         session.commit()
 
 
-def delete_page_segments(
-    provider_id: str,
+def delete_page_panels(
     manga_title: str,
     chapter_number: float,
-    page_number: int,
+    page_number: Optional[int],
     db_url=None,
 ) -> None:
-    """Delete all segments for one page and the page row."""
-    _validate_provider_id(provider_id)
+    """Delete all panels for one page."""
     engine = get_engine(db_url)
     with Session(engine) as session:
         m = session.exec(select(Manga).where(Manga.manga_title == manga_title)).first()
         if not m:
             return
-        ch_stmt = select(Chapters).where(
-            Chapters.manga_id == m.id,
-            Chapters.provider_id == provider_id,
-            Chapters.chapter_number == chapter_number,
-        )
+        ch_stmt = select(Chapters).where(Chapters.manga_id == m.id, Chapters.chapter_number == chapter_number)
         ch = session.exec(ch_stmt).first()
         if not ch:
             return
-        page_stmt = select(Pages).where(Pages.chapter_id == ch.id, Pages.page_number == page_number)
-        page = session.exec(page_stmt).first()
-        if not page:
-            return
-        for seg in session.exec(select(Segments).where(Segments.page_id == page.id)).all():
-            session.delete(seg)
-        session.flush()
-        session.delete(page)
+        for p in session.exec(
+            select(Panels).where(Panels.chapter_id == ch.id, Panels.page_number == page_number)
+        ).all():
+            session.delete(p)
         session.commit()
 
 
-def delete_chapter_segments(
-    provider_id: str,
+def delete_chapter_panels(
     manga_title: str,
     chapter_number: float,
     db_url=None,
 ) -> None:
-    """Delete chapter and all its pages/segments (explicit deletes; DB may not have CASCADE)."""
-    _validate_provider_id(provider_id)
+    """Delete chapter and all its panels (explicit deletes; DB may not have CASCADE)."""
     engine = get_engine(db_url)
     with Session(engine) as session:
         m = session.exec(select(Manga).where(Manga.manga_title == manga_title)).first()
         if not m:
             return
-        ch = session.exec(
-            select(Chapters).where(
-                Chapters.manga_id == m.id,
-                Chapters.provider_id == provider_id,
-                Chapters.chapter_number == chapter_number,
-            )
-        ).first()
+        ch = session.exec(select(Chapters).where(Chapters.manga_id == m.id, Chapters.chapter_number == chapter_number)).first()
         if not ch:
             return
-        pages = list(session.exec(select(Pages).where(Pages.chapter_id == ch.id)).all())
-        for page in pages:
-            for seg in session.exec(select(Segments).where(Segments.page_id == page.id)).all():
-                session.delete(seg)
-        session.flush()
-        for page in pages:
-            session.delete(page)
+        for p in session.exec(select(Panels).where(Panels.chapter_id == ch.id)).all():
+            session.delete(p)
         session.flush()
         session.delete(ch)
         session.commit()
 
 
 def delete_all_manga(db_url=None) -> None:
-    """Delete all segments, pages, chapters, reading-list rows, manga_source rows, and manga rows."""
+    """Delete all panels, chapters, reading-list rows, and manga rows."""
     engine = get_engine(db_url)
     with Session(engine) as session:
-        for seg in session.exec(select(Segments)).all():
-            session.delete(seg)
-        for p in session.exec(select(Pages)).all():
+        for p in session.exec(select(Panels)).all():
             session.delete(p)
         for ch in session.exec(select(Chapters)).all():
             session.delete(ch)
@@ -354,83 +405,231 @@ def delete_all_manga(db_url=None) -> None:
             session.delete(rli)
         for rlc in session.exec(select(ReadingListCollection)).all():
             session.delete(rlc)
-        for ms in session.exec(select(MangaSource)).all():
-            session.delete(ms)
         for m in session.exec(select(Manga)).all():
             session.delete(m)
         session.commit()
 
 
-def get_segments(
-    provider_id: Optional[str] = None,
+def get_panels(
     manga_title: Optional[str] = None,
     chapter_number: Optional[float] = None,
     page_number: Optional[int] = None,
     limit: Optional[int] = None,
     offset: int = 0,
     db_url=None,
-) -> list[SegmentListOut]:
-    """Query segments; provider_id filters on chapter. Supports limit/offset for pagination."""
-    if provider_id is not None:
-        _validate_provider_id(provider_id)
+) -> list[PanelListOut]:
+    """Query panels. Supports limit/offset for pagination.
+    """
     engine = get_engine(db_url)
     with Session(engine) as session:
         stmt = (
             select(
-                Segments.id,
-                Chapters.provider_id,
+                Panels.id,
                 Manga.manga_title,
                 Chapters.chapter_number,
-                Pages.page_number,
-                Segments.segment_index,
-                Segments.x1, Segments.y1, Segments.x2, Segments.y2,
-                Segments.original_text,
-                Segments.translated_text,
+                Chapters.mangadex_chapter_id,
+                Panels.page_number,
+                Panels.bubble_index,
+                Panels.width,
+                Panels.height,
+                Panels.x1, Panels.y1, Panels.x2, Panels.y2,
+                Panels.original_text,
+                Panels.translated_text,
+                Panels.panel_url,
                 Chapters.language_code,
-                Segments.created_at,
+                Panels.created_at,
             )
-            .select_from(Segments)
-            .join(Pages, Segments.page_id == Pages.id)
-            .join(Chapters, Pages.chapter_id == Chapters.id)
+            .select_from(Panels)
+            .join(Chapters, Panels.chapter_id == Chapters.id)
             .join(Manga, Chapters.manga_id == Manga.id)
         )
-        if provider_id is not None:
-            stmt = stmt.where(Chapters.provider_id == provider_id)
         if manga_title is not None:
             stmt = stmt.where(Manga.manga_title == manga_title)
         if chapter_number is not None:
             stmt = stmt.where(Chapters.chapter_number == chapter_number)
         if page_number is not None:
-            stmt = stmt.where(Pages.page_number == page_number)
-        stmt = stmt.order_by(Chapters.chapter_number, Pages.page_number, Segments.segment_index)
+            stmt = stmt.where(Panels.page_number == page_number)
+        stmt = stmt.order_by(
+            Chapters.chapter_number,
+            func.coalesce(Panels.page_number, 0),
+            Panels.bubble_index,
+        )
         if offset > 0:
             stmt = stmt.offset(offset)
         if limit is not None and limit > 0:
             stmt = stmt.limit(limit)
         rows = session.exec(stmt).all()
         return [
-            SegmentListOut(
-                id=r[0], provider_id=r[1], manga_title=r[2], chapter_number=r[3],
-                page_number=r[4], segment_index=r[5], x1=r[6], y1=r[7], x2=r[8],
-                y2=r[9], original_text=r[10], translated_text=r[11], language_code=r[12],
-                created_at=r[13],
+            PanelListOut(
+                id=r[0],
+                manga_title=r[1],
+                chapter_number=r[2],
+                mangadex_chapter_id=r[3],
+                page_number=r[4],
+                bubble_index=r[5],
+                width=r[6],
+                height=r[7],
+                x1=r[8],
+                y1=r[9],
+                x2=r[10],
+                y2=r[11],
+                original_text=r[12],
+                translated_text=r[13],
+                panel_url=r[14],
+                language_code=r[15],
+                created_at=r[16],
             )
             for r in rows
         ]
 
 
-def get_chapter_segments(
-    provider_id: str,
+def get_panel_by_panel_url(
+    panel_url: str,
+    *,
+    manga_title: Optional[str] = None,
+    chapter_number: Optional[float] = None,
+    mangadex_chapter_id: Optional[str] = None,
+    page_number: Optional[int] = None,
+    db_url=None,
+) -> Optional[PanelListOut]:
+    """Return the first matching panel for panel_url (or None)."""
+    url = (panel_url or "").strip()
+    if not url:
+        return None
+    engine = get_engine(db_url)
+    with Session(engine) as session:
+        stmt = (
+            select(
+                Panels.id,
+                Manga.manga_title,
+                Chapters.chapter_number,
+                Chapters.mangadex_chapter_id,
+                Panels.page_number,
+                Panels.bubble_index,
+                Panels.width,
+                Panels.height,
+                Panels.x1,
+                Panels.y1,
+                Panels.x2,
+                Panels.y2,
+                Panels.original_text,
+                Panels.translated_text,
+                Panels.panel_url,
+                Chapters.language_code,
+                Panels.created_at,
+            )
+            .select_from(Panels)
+            .join(Chapters, Panels.chapter_id == Chapters.id)
+            .join(Manga, Chapters.manga_id == Manga.id)
+            .where(Panels.panel_url == url)
+        )
+        if manga_title is not None:
+            stmt = stmt.where(Manga.manga_title == manga_title)
+        if chapter_number is not None:
+            stmt = stmt.where(Chapters.chapter_number == chapter_number)
+        if mangadex_chapter_id is not None:
+            v = mangadex_chapter_id.strip()
+            if v:
+                stmt = stmt.where(Chapters.mangadex_chapter_id == v)
+        if page_number is not None:
+            stmt = stmt.where(Panels.page_number == page_number)
+        stmt = stmt.order_by(
+            Chapters.chapter_number,
+            func.coalesce(Panels.page_number, 0),
+            Panels.bubble_index,
+        ).limit(1)
+        r = session.exec(stmt).first()
+        if not r:
+            return None
+        return PanelListOut(
+            id=r[0],
+            manga_title=r[1],
+            chapter_number=r[2],
+            mangadex_chapter_id=r[3],
+            page_number=r[4],
+            bubble_index=r[5],
+            width=r[6],
+            height=r[7],
+            x1=r[8],
+            y1=r[9],
+            x2=r[10],
+            y2=r[11],
+            original_text=r[12],
+            translated_text=r[13],
+            panel_url=r[14],
+            language_code=r[15],
+            created_at=r[16],
+        )
+
+
+def delete_panel_by_panel_url(
+    panel_url: str,
+    *,
+    manga_title: Optional[str] = None,
+    chapter_number: Optional[float] = None,
+    mangadex_chapter_id: Optional[str] = None,
+    page_number: Optional[int] = None,
+    db_url=None,
+) -> int:
+    """Delete panel rows matching panel_url (optionally scoped).
+
+    Returns number of deleted rows.
+    """
+    url = (panel_url or "").strip()
+    if not url:
+        return 0
+    engine = get_engine(db_url)
+    with Session(engine) as session:
+        stmt = select(Panels).where(Panels.panel_url == url)
+        if (
+            manga_title is not None
+            or chapter_number is not None
+            or mangadex_chapter_id is not None
+        ):
+            stmt = stmt.join(Chapters, Panels.chapter_id == Chapters.id).join(
+                Manga, Chapters.manga_id == Manga.id
+            )
+            if manga_title is not None:
+                stmt = stmt.where(Manga.manga_title == manga_title)
+            if chapter_number is not None:
+                stmt = stmt.where(Chapters.chapter_number == chapter_number)
+            if mangadex_chapter_id is not None:
+                v = mangadex_chapter_id.strip()
+                if v:
+                    stmt = stmt.where(Chapters.mangadex_chapter_id == v)
+        if page_number is not None:
+            stmt = stmt.where(Panels.page_number == page_number)
+
+        panels = session.exec(stmt).all()
+        if not panels:
+            return 0
+
+        chapter_ids = {p.chapter_id for p in panels}
+        for p in panels:
+            session.delete(p)
+        session.flush()
+
+        now = datetime.now(timezone.utc)
+        for cid in chapter_ids:
+            chapter = session.get(Chapters, cid)
+            if chapter:
+                chapter.updated_at = now
+                manga = session.get(Manga, chapter.manga_id)
+                if manga:
+                    manga.updated_at = now
+        session.commit()
+        return len(panels)
+
+
+def get_chapter_panels(
     manga_title: str,
     chapter_number: float,
     limit: Optional[int] = None,
     offset: int = 0,
     db_url=None,
-) -> list[SegmentListOut]:
-    """Get all segments for a chapter. Supports limit/offset for pagination."""
-    _validate_provider_id(provider_id)
-    return get_segments(
-        provider_id=provider_id,
+) -> list[PanelListOut]:
+    """Get all panels for a chapter. Supports limit/offset for pagination."""
+    return get_panels(
         manga_title=manga_title,
         chapter_number=chapter_number,
         limit=limit,
@@ -439,25 +638,29 @@ def get_chapter_segments(
     )
 
 
+
 def list_chapters(
     manga_title: str,
-    provider_id: Optional[str] = None,
     limit: Optional[int] = None,
     offset: int = 0,
     db_url=None,
 ) -> list[ChapterListOut]:
-    """List chapters for an umbrella manga_title; optionally filter by chapter provider_id."""
+    """List chapters for an umbrella manga_title."""
     engine = get_engine(db_url)
     with Session(engine) as session:
         stmt = (
-            select(Manga.manga_title, Chapters.provider_id, Chapters.id, Chapters.chapter_number, Chapters.created_at, Chapters.updated_at)
+            select(
+                Manga.manga_title,
+                Chapters.id,
+                Chapters.chapter_number,
+                Chapters.mangadex_chapter_id,
+                Chapters.created_at,
+                Chapters.updated_at,
+            )
             .select_from(Chapters)
             .join(Manga, Chapters.manga_id == Manga.id)
             .where(Manga.manga_title == manga_title)
         )
-        if provider_id is not None:
-            _validate_provider_id(provider_id)
-            stmt = stmt.where(Chapters.provider_id == provider_id)
         if offset > 0:
             stmt = stmt.offset(offset)
         if limit is not None and limit > 0:
@@ -465,8 +668,12 @@ def list_chapters(
         rows = session.exec(stmt).all()
         return [
             ChapterListOut(
-                manga_title=r[0], provider_id=r[1], id=r[2], chapter_number=r[3],
-                created_at=r[4], updated_at=r[5],
+                manga_title=r[0],
+                id=r[1],
+                chapter_number=r[2],
+                mangadex_chapter_id=r[3],
+                created_at=r[4],
+                updated_at=r[5],
             )
             for r in rows
         ]
@@ -658,13 +865,8 @@ def list_reading_list_collections_with_counts(
         if ids:
             rows = list(
                 session.exec(
-                    select(ReadingListItem, MangaSource)
+                    select(ReadingListItem, Manga)
                     .join(Manga, ReadingListItem.manga_id == Manga.id)
-                    .outerjoin(
-                        MangaSource,
-                        (MangaSource.manga_id == Manga.id)
-                        & (MangaSource.provider_id == PROVIDER_MANGADEX),
-                    )
                     .where(ReadingListItem.reading_list_id.in_(ids))
                     .order_by(
                         ReadingListItem.reading_list_id,
@@ -672,20 +874,11 @@ def list_reading_list_collections_with_counts(
                     )
                 ).all()
             )
-            for item, src in rows:
+            for item, manga in rows:
                 lid = item.reading_list_id
                 if lid in latest_ext:
                     continue
-                ext: Optional[str] = None
-                if (
-                    src
-                    and src.external_manga_id
-                    and not _is_placeholder_external_manga_id(
-                        src.external_manga_id
-                    )
-                ):
-                    ext = src.external_manga_id
-                latest_ext[lid] = ext
+                latest_ext[lid] = manga.mangadex_manga_id
     return [
         ReadingListCollectionOut(
             id=c.id,
@@ -712,13 +905,8 @@ def list_reading_list_items_with_manga(
     engine = get_engine(db_url)
     with Session(engine) as session:
         stmt = (
-            select(ReadingListItem, Manga, MangaSource)
+            select(ReadingListItem, Manga)
             .join(Manga, ReadingListItem.manga_id == Manga.id)
-            .outerjoin(
-                MangaSource,
-                (MangaSource.manga_id == Manga.id)
-                & (MangaSource.provider_id == PROVIDER_MANGADEX),
-            )
             .where(ReadingListItem.reading_list_id == reading_list_id)
             .order_by(desc(ReadingListItem.updated_at))
         )
@@ -728,12 +916,8 @@ def list_reading_list_items_with_manga(
             stmt = stmt.limit(limit)
         rows = session.exec(stmt).all()
     out: list[ReadingListItemOut] = []
-    for item, manga, src in rows:
-        ext = None
-        if src and src.external_manga_id and not _is_placeholder_external_manga_id(
-            src.external_manga_id
-        ):
-            ext = src.external_manga_id
+    for item, manga in rows:
+        ext = manga.mangadex_manga_id
         out.append(
             ReadingListItemOut(
                 id=item.id,
@@ -774,7 +958,10 @@ def upsert_reading_list_item(
         row = session.exec(stmt).first()
         if row:
             if last_chapter_number is not None:
-                row.last_chapter_number = last_chapter_number
+                new_val = float(last_chapter_number)
+                prev = row.last_chapter_number
+                if prev is None or new_val > prev:
+                    row.last_chapter_number = new_val
             row.updated_at = now
             session.add(row)
             col.updated_at = now
@@ -797,6 +984,47 @@ def upsert_reading_list_item(
         return entry
 
 
+def update_reading_list_item_last_read(
+    user_id: UUID,
+    reading_list_id: int,
+    manga_id: int,
+    last_chapter_number: float,
+    *,
+    db_url=None,
+) -> bool:
+    """Set last-read chapter for one list row (only increases stored value)."""
+    if get_reading_list_collection(user_id, reading_list_id, db_url) is None:
+        return False
+    engine = get_engine(db_url)
+    now = datetime.now(timezone.utc)
+    new_val = float(last_chapter_number)
+    with Session(engine) as session:
+        row = session.exec(
+            select(ReadingListItem).where(
+                ReadingListItem.reading_list_id == reading_list_id,
+                ReadingListItem.manga_id == manga_id,
+            )
+        ).first()
+        if row is None:
+            return False
+        prev = row.last_chapter_number
+        if prev is None or new_val > prev:
+            row.last_chapter_number = new_val
+        row.updated_at = now
+        session.add(row)
+        col = session.exec(
+            select(ReadingListCollection).where(
+                ReadingListCollection.id == reading_list_id,
+                ReadingListCollection.user_id == user_id,
+            )
+        ).first()
+        if col:
+            col.updated_at = now
+            session.add(col)
+        session.commit()
+        return True
+
+
 def remove_reading_list_item_from_list(
     user_id: UUID, reading_list_id: int, manga_id: int, db_url=None
 ) -> bool:
@@ -828,21 +1056,19 @@ def remove_reading_list_item_from_list(
 def add_reading_list_item_by_source(
     user_id: UUID,
     reading_list_id: int,
-    provider_id: str,
     external_manga_id: str,
     manga_title: str,
     *,
     last_chapter_number: Optional[float] = None,
     db_url=None,
 ) -> ReadingListItem:
-    _validate_provider_id(provider_id)
     ext = (external_manga_id or "").strip()
     title = (manga_title or "").strip() or "Untitled"
     if not ext:
         raise ValueError("external_manga_id is required")
     engine = get_engine(db_url)
     with Session(engine) as session:
-        manga_id = resolve_manga_id(session, provider_id, title, ext)
+        manga_id = resolve_manga_id(session, title, ext)
         session.commit()
     return upsert_reading_list_item(
         user_id,

db/models.py

@@ -7,7 +7,6 @@ User table: app profile keyed by Supabase auth user id (UUID)
 
 Manga table: stores manga metadata
   id: int, primary key
-  provider_id: str
   manga_title: str
   created_at: datetime
 
@@ -17,9 +16,7 @@ Chapter table: stores manga chapter info
   page_number: int
   created_at: datetime
 
-Chapter table: chapter data scoped by provider (same umbrella manga can have chapters per source)
-
-Page / Segment tables: unchanged hierarchy under chapters
+Chapter table: chapter data (single-provider setup)
 
 ReadingListCollection: named list per user (e.g. "Want to read").
 ReadingListItem: one row per named list + umbrella manga (manga_id).
@@ -47,33 +44,21 @@ class Users(SQLModel, table=True):
 
 
 class Manga(SQLModel, table=True):
-    """Umbrella series; use MangaSource for per-provider external ids."""
+    """Umbrella series.
+
+    We keep MangaDex series id directly on this table (optional) since MangaDex
+    is the primary external provider used by the app.
+    """
 
     __table_args__ = ({"extend_existing": True},)
 
     id: Optional[int] = Field(default=None, primary_key=True)
     manga_title: str = Field(index=True)
+    mangadex_manga_id: Optional[str] = Field(default=None, index=True, unique=True)
     created_at: Optional[datetime] = Field(default_factory=_utc_now)
     updated_at: Optional[datetime] = Field(default_factory=_utc_now)
 
 
-class MangaSource(SQLModel, table=True):
-    """Links an umbrella manga to a provider catalog id (e.g. MangaDex UUID)."""
-
-    __tablename__ = "manga_source"
-    __table_args__ = (
-        UniqueConstraint("provider_id", "external_manga_id", name="uq_manga_source_provider_external"),
-        UniqueConstraint("manga_id", "provider_id", name="uq_manga_source_manga_provider"),
-        {"extend_existing": True},
-    )
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-    manga_id: int = Field(foreign_key="manga.id", index=True)
-    provider_id: str = Field(index=True)
-    external_manga_id: str = Field(index=True) #if there is no external manga id, it will be the same as the manga_id with local in front
-    created_at: Optional[datetime] = Field(default_factory=_utc_now)
-
-
 class ReadingListCollection(SQLModel, table=True):
     """User-owned named reading list (container for manga)."""
 
@@ -106,41 +91,39 @@ class ReadingListItem(SQLModel, table=True):
 
 class Chapters(SQLModel, table=True):
     __table_args__ = (
-        UniqueConstraint("manga_id", "provider_id", "chapter_number", name="uq_chapters_manga_provider_chapter"),
+        UniqueConstraint("manga_id", "chapter_number", name="uq_chapters_manga_chapter"),
         {"extend_existing": True},
     )
 
     id: Optional[int] = Field(default=None, primary_key=True)
     manga_id: int = Field(foreign_key="manga.id", index=True)
-    provider_id: str = Field(index=True)
     chapter_number: float = Field(index=True)
+    # MangaDex chapter UUID (single-provider setup)
+    mangadex_chapter_id: Optional[str] = Field(default=None, index=True)
     language_code: str
     created_at: Optional[datetime] = Field(default_factory=_utc_now)
     updated_at: Optional[datetime] = Field(default_factory=_utc_now)
 
 
-class Pages(SQLModel, table=True):
+class Panels(SQLModel, table=True):
+    __tablename__ = "panels"
     __table_args__ = (
-        UniqueConstraint("chapter_id", "page_number", name="uq_pages_chapter_page"),
+        Index("ix_panels_chapter_page_bubble", "chapter_id", "page_number", "bubble_index"),
         {"extend_existing": True},
     )
 
     id: Optional[int] = Field(default=None, primary_key=True)
     chapter_id: int = Field(foreign_key="chapters.id", index=True)
-    page_number: int = Field(index=True)
-    created_at: Optional[datetime] = Field(default_factory=_utc_now)
-    updated_at: Optional[datetime] = Field(default_factory=_utc_now)
-
-
-class Segments(SQLModel, table=True):
-    __table_args__ = (
-        Index("ix_segments_page_segment", "page_id", "segment_index"),
-        {"extend_existing": True},
-    )
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-    page_id: int = Field(foreign_key="pages.id", index=True)
-    segment_index: int
+    page_number: Optional[int] = Field(default=None, index=True)
+    # Denormalized copy of MangaDex chapter UUID for convenience (optional).
+    mangadex_chapter_id: Optional[str] = Field(default=None, index=True)
+    # Optional URL for this panel's image (e.g. MangaDex at-home URL or proxied URL).
+    panel_url: Optional[str] = Field(default=None)
+    # bubble index within a page (0..N-1)
+    bubble_index: int
+    # page dimensions for this segment's coordinate space (optional; helpful for clients)
+    width: Optional[int] = Field(default=None)
+    height: Optional[int] = Field(default=None)
     x1: float
     y1: float
     x2: float

db/schemas.py

@@ -17,12 +17,12 @@ class MangaOut(SQLModel):
 
 
 class ChapterListOut(SQLModel):
-    """Chapter list response (includes manga_title, provider_id from chapter)."""
+    """Chapter list response (includes manga_title)."""
 
     manga_title: str
-    provider_id: str
     id: int
     chapter_number: float
+    mangadex_chapter_id: Optional[str] = None
     created_at: Optional[datetime] = None
     updated_at: Optional[datetime] = None
 
@@ -66,28 +66,36 @@ class ReadingListItemOut(SQLModel):
 
 
 class ReadingListAddIn(SQLModel):
-    """Add a title by provider catalog id (e.g. MangaDex UUID)."""
+    """Add a title by MangaDex series id (UUID)."""
 
-    provider_id: str = Field(default="mangadex")
     external_manga_id: str
     manga_title: str
     last_chapter_number: Optional[float] = None
 
 
-class SegmentListOut(SQLModel):
-    """Segment list response (join of Segments + Pages + Chapters + Manga)."""
+class ReadingListProgressPatchIn(SQLModel):
+    """Update furthest chapter read for a title already on a list."""
+
+    last_chapter_number: float
+
+
+class PanelListOut(SQLModel):
+    """Panel list response (join of Panels + Chapters + Manga)."""
 
     id: int
-    provider_id: str
     manga_title: str
     chapter_number: float
-    page_number: int
-    segment_index: int
+    page_number: Optional[int] = None
+    mangadex_chapter_id: Optional[str] = None
+    bubble_index: int
+    width: Optional[int] = None
+    height: Optional[int] = None
     x1: float
     y1: float
     x2: float
     y2: float
     original_text: str
     translated_text: str
+    panel_url: Optional[str] = None
     language_code: str
     created_at: Optional[datetime] = None

db/test_db.py

@@ -32,84 +32,77 @@ class TestDb(unittest.TestCase):
 
     def setUp(self):
         """Clean up test data before each test."""
-        db.delete_chapter_segments(db.PROVIDER_LOCAL, self.MANGA, self.CHAPTER)
+        db.delete_chapter_panels(self.MANGA, self.CHAPTER)
 
     def tearDown(self):
-        db.delete_chapter_segments(db.PROVIDER_LOCAL, self.MANGA, self.CHAPTER)
+        db.delete_chapter_panels(self.MANGA, self.CHAPTER)
 
     def test_init_db(self):
         """init_db creates tables without error."""
         db.init_db()
 
-    def test_save_and_get_segments(self):
-        """save_page_translation stores segments; get_segments returns them."""
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+    def test_save_and_get_panels(self):
+        """save_panels_translation stores panels; get_panels returns them."""
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=self.PAGE,
-            bubbles=_bubbles("こんにちは", "Hello"),
+            panels=_bubbles("こんにちは", "Hello"),
             language_code=self.LANG,
         )
-        rows = db.get_segments(provider_id=db.PROVIDER_LOCAL, manga_title=self.MANGA, chapter_number=self.CHAPTER, page_number=self.PAGE)
+        rows = db.get_panels(manga_title=self.MANGA, chapter_number=self.CHAPTER, page_number=self.PAGE)
         self.assertEqual(len(rows), 2)
         self.assertEqual(rows[0].translated_text, "Hello")
-        self.assertEqual(rows[0].provider_id, db.PROVIDER_LOCAL)
         self.assertEqual(rows[0].manga_title, self.MANGA)
         self.assertEqual(rows[0].chapter_number, self.CHAPTER)
         self.assertEqual(rows[0].page_number, self.PAGE)
 
     def test_save_replaces_existing(self):
-        """save_page_translation replaces existing segments for same page."""
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+        """save_panels_translation replaces existing panels for same page."""
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=self.PAGE,
-            bubbles=_bubbles("first", "First"),
+            panels=_bubbles("first", "First"),
             language_code=self.LANG,
         )
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=self.PAGE,
-            bubbles=_bubbles("second", "Second"),
+            panels=_bubbles("second", "Second"),
             language_code=self.LANG,
         )
-        rows = db.get_segments(provider_id=db.PROVIDER_LOCAL, manga_title=self.MANGA, chapter_number=self.CHAPTER, page_number=self.PAGE)
+        rows = db.get_panels(manga_title=self.MANGA, chapter_number=self.CHAPTER, page_number=self.PAGE)
         self.assertEqual(len(rows), 2)
         self.assertEqual(rows[0].translated_text, "Second")
 
-    def test_get_chapter_segments(self):
-        """get_chapter_segments returns all segments for a chapter."""
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+    def test_get_chapter_panels(self):
+        """get_chapter_panels returns all panels for a chapter."""
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=1,
-            bubbles=_bubbles("a", "A"),
+            panels=_bubbles("a", "A"),
             language_code=self.LANG,
         )
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=2,
-            bubbles=_bubbles("b", "B"),
+            panels=_bubbles("b", "B"),
             language_code=self.LANG,
         )
-        rows = db.get_chapter_segments(db.PROVIDER_LOCAL, self.MANGA, self.CHAPTER)
+        rows = db.get_chapter_panels(self.MANGA, self.CHAPTER)
         self.assertEqual(len(rows), 4)  # 2 bubbles per page, 2 pages
 
     def test_list_mangas(self):
         """list_mangas returns mangas; order_by and order_desc work."""
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=self.PAGE,
-            bubbles=_bubbles("x", "X"),
+            panels=_bubbles("x", "X"),
             language_code=self.LANG,
         )
         entries = db.list_mangas()
@@ -125,12 +118,11 @@ class TestDb(unittest.TestCase):
 
     def test_list_mangas_pagination(self):
         """list_mangas respects limit and offset."""
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=self.PAGE,
-            bubbles=_bubbles("x", "X"),
+            panels=_bubbles("x", "X"),
             language_code=self.LANG,
         )
         all_entries = db.list_mangas()
@@ -140,138 +132,117 @@ class TestDb(unittest.TestCase):
         self.assertEqual(len(offset_entries), 1)
 
     def test_list_chapters(self):
-        """list_chapters returns chapters for a manga; optional provider_id filter."""
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+        """list_chapters returns chapters for a manga."""
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=self.PAGE,
-            bubbles=_bubbles("x", "X"),
+            panels=_bubbles("x", "X"),
             language_code=self.LANG,
         )
         chapters = db.list_chapters(self.MANGA)
         found = [c for c in chapters if c.chapter_number == self.CHAPTER]
         self.assertGreater(len(found), 0)
         self.assertTrue(hasattr(found[0], "manga_title"))
-        self.assertTrue(hasattr(found[0], "provider_id"))
+        # single-provider setup: no provider_id stored on chapters
         self.assertTrue(hasattr(found[0], "id"))
         self.assertTrue(hasattr(found[0], "chapter_number"))
         self.assertTrue(hasattr(found[0], "created_at"))
         self.assertTrue(hasattr(found[0], "updated_at"))
         self.assertEqual(found[0].manga_title, self.MANGA)
-        self.assertEqual(found[0].provider_id, db.PROVIDER_LOCAL)
+        # provider removed
 
-        chapters_with_provider = db.list_chapters(self.MANGA, provider_id=db.PROVIDER_LOCAL)
-        self.assertGreater(len(chapters_with_provider), 0)
+        self.assertGreater(len(chapters), 0)
 
     def test_list_chapters_pagination(self):
         """list_chapters respects limit and offset."""
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=self.PAGE,
-            bubbles=_bubbles("x", "X"),
+            panels=_bubbles("x", "X"),
             language_code=self.LANG,
         )
-        all_chapters = db.list_chapters(self.MANGA, provider_id=db.PROVIDER_LOCAL)
-        limited = db.list_chapters(self.MANGA, provider_id=db.PROVIDER_LOCAL, limit=1)
+        all_chapters = db.list_chapters(self.MANGA)
+        limited = db.list_chapters(self.MANGA, limit=1)
         self.assertEqual(len(limited), 1)
-        offset_chapters = db.list_chapters(self.MANGA, provider_id=db.PROVIDER_LOCAL, limit=1, offset=0)
+        offset_chapters = db.list_chapters(self.MANGA, limit=1, offset=0)
         self.assertEqual(len(offset_chapters), 1)
 
-    def test_get_segments_pagination(self):
-        """get_segments respects limit and offset."""
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+    def test_get_panels_pagination(self):
+        """get_panels respects limit and offset."""
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=self.PAGE,
-            bubbles=_bubbles("a", "A"),
+            panels=_bubbles("a", "A"),
             language_code=self.LANG,
         )
-        all_rows = db.get_segments(provider_id=db.PROVIDER_LOCAL, manga_title=self.MANGA, chapter_number=self.CHAPTER)
+        all_rows = db.get_panels(manga_title=self.MANGA, chapter_number=self.CHAPTER)
         self.assertEqual(len(all_rows), 2)
-        limited = db.get_segments(provider_id=db.PROVIDER_LOCAL, manga_title=self.MANGA, chapter_number=self.CHAPTER, limit=1)
+        limited = db.get_panels(manga_title=self.MANGA, chapter_number=self.CHAPTER, limit=1)
         self.assertEqual(len(limited), 1)
-        offset_rows = db.get_segments(provider_id=db.PROVIDER_LOCAL, manga_title=self.MANGA, chapter_number=self.CHAPTER, limit=1, offset=1)
+        offset_rows = db.get_panels(manga_title=self.MANGA, chapter_number=self.CHAPTER, limit=1, offset=1)
         self.assertEqual(len(offset_rows), 1)
         self.assertEqual(offset_rows[0].translated_text, "A 2")
 
-    def test_delete_page_segments(self):
-        """delete_page_segments removes page and its segments."""
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+    def test_delete_page_panels(self):
+        """delete_page_panels removes panels for one page."""
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=self.PAGE,
-            bubbles=_bubbles("x", "X"),
+            panels=_bubbles("x", "X"),
             language_code=self.LANG,
         )
-        db.delete_page_segments(db.PROVIDER_LOCAL, self.MANGA, self.CHAPTER, self.PAGE)
-        rows = db.get_segments(provider_id=db.PROVIDER_LOCAL, manga_title=self.MANGA, chapter_number=self.CHAPTER, page_number=self.PAGE)
+        db.delete_page_panels(self.MANGA, self.CHAPTER, self.PAGE)
+        rows = db.get_panels(manga_title=self.MANGA, chapter_number=self.CHAPTER, page_number=self.PAGE)
         self.assertEqual(len(rows), 0)
 
-    def test_delete_chapter_segments(self):
-        """delete_chapter_segments removes chapter and all its pages/segments."""
-        db.save_page_translation(
-            provider_id=db.PROVIDER_LOCAL,
+    def test_delete_chapter_panels(self):
+        """delete_chapter_panels removes chapter and all its panels."""
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=self.PAGE,
-            bubbles=_bubbles("x", "X"),
+            panels=_bubbles("x", "X"),
             language_code=self.LANG,
         )
-        db.delete_chapter_segments(db.PROVIDER_LOCAL, self.MANGA, self.CHAPTER)
-        rows = db.get_chapter_segments(db.PROVIDER_LOCAL, self.MANGA, self.CHAPTER)
+        db.delete_chapter_panels(self.MANGA, self.CHAPTER)
+        rows = db.get_chapter_panels(self.MANGA, self.CHAPTER)
         self.assertEqual(len(rows), 0)
 
-    def test_provider_id_validation_save(self):
-        """save_page_translation raises ValueError for invalid provider_id."""
-        with self.assertRaises(ValueError) as ctx:
-            db.save_page_translation(
-                provider_id="invalid_provider",
-                manga_title=self.MANGA,
-                chapter_number=self.CHAPTER,
-                page_number=self.PAGE,
-                bubbles=_bubbles("x", "X"),
-                language_code=self.LANG,
-            )
-        self.assertIn("provider_id must be one of", str(ctx.exception))
-
-    def test_provider_id_validation_get_chapter_segments(self):
-        """get_chapter_segments raises ValueError for invalid provider_id."""
-        with self.assertRaises(ValueError):
-            db.get_chapter_segments("invalid_provider", self.MANGA, self.CHAPTER)
+    def test_save_requires_no_provider_id(self):
+        """save_panels_translation does not require a provider_id."""
+        db.save_panels_translation(
+            manga_title=self.MANGA,
+            chapter_number=self.CHAPTER,
+            page_number=self.PAGE,
+            panels=_bubbles("x", "X"),
+            language_code=self.LANG,
+        )
 
     def test_provider_id_validation_delete_page(self):
-        """delete_page_segments raises ValueError for invalid provider_id."""
-        with self.assertRaises(ValueError):
-            db.delete_page_segments("invalid_provider", self.MANGA, self.CHAPTER, self.PAGE)
+        """delete_page_panels deletes without a provider_id."""
+        # No exception expected; function no longer takes a provider.
+        db.delete_page_panels(self.MANGA, self.CHAPTER, self.PAGE)
 
     def test_provider_id_validation_delete_chapter(self):
-        """delete_chapter_segments raises ValueError for invalid provider_id."""
-        with self.assertRaises(ValueError):
-            db.delete_chapter_segments("invalid_provider", self.MANGA, self.CHAPTER)
-
-    def test_provider_id_validation_get_segments(self):
-        """get_segments raises ValueError when provider_id is invalid."""
-        with self.assertRaises(ValueError):
-            db.get_segments(provider_id="invalid_provider")
+        """delete_chapter_panels deletes without a provider_id."""
+        db.delete_chapter_panels(self.MANGA, self.CHAPTER)
 
     def test_provider_mangadex(self):
-        """PROVIDER_MANGADEX is accepted."""
-        db.save_page_translation(
-            provider_id=db.PROVIDER_MANGADEX,
+        """Basic provider-less flow works."""
+        db.save_panels_translation(
             manga_title=self.MANGA,
             chapter_number=self.CHAPTER,
             page_number=self.PAGE,
-            bubbles=_bubbles("m", "M"),
+            panels=_bubbles("m", "M"),
             language_code=self.LANG,
         )
-        rows = db.get_segments(provider_id=db.PROVIDER_MANGADEX, manga_title=self.MANGA, chapter_number=self.CHAPTER)
+        rows = db.get_panels(manga_title=self.MANGA, chapter_number=self.CHAPTER)
         self.assertEqual(len(rows), 2)
-        db.delete_chapter_segments(db.PROVIDER_MANGADEX, self.MANGA, self.CHAPTER)
+        db.delete_chapter_panels(self.MANGA, self.CHAPTER)
 
 
 class TestDbNoUrl(unittest.TestCase):

db/test_functions/create_data.py

@@ -3,27 +3,45 @@ Insert sample data into the database for testing.
 Run from backend:  python -m db.test_functions.create_data
 Requires DATABASE_URL in backend/.env.
 
-Uses umbrella Manga + MangaSource + Chapters (per provider_id). Optional external_manga_id
-on save_page_translation links a provider catalog id (e.g. MangaDex UUID).
+Uses umbrella Manga + Chapters. Optional external_manga_id (MangaDex series id)
+on save_panels_translation stores MangaDex series id.
 """
 
 import db
-from db.const import PROVIDER_LOCAL, PROVIDER_MANGADEX
 
 # Demo external ids (MangaDex uses UUID strings; local can use legacy-* from DB or omit)
 NARUTO_MANGADEX_ID = "931b3112-7b75-43e4-a13f-908f0a251ae2"  # example placeholder UUID
 
 
-def _bubbles(*pairs: tuple[str, str]) -> list[dict]:
-    """Create fake text segments from (original, translated) pairs."""
+def _slug(title: str) -> str:
+    s = title.strip().lower().replace(" ", "_")
+    return "".join(ch for ch in s if ch.isalnum() or ch == "_")
+
+
+def _bubbles(
+    manga_title: str,
+    chapter_number: float,
+    page_number: int,
+    *pairs: tuple[str, str],
+) -> list[dict]:
+    """Create fake panels from (original, translated) pairs."""
+    slug = _slug(manga_title)
     result = []
     for i, (orig, trans) in enumerate(pairs):
         result.append({
             "bubble_index": i,
-            "x1": 10.0 + i * 5,
-            "y1": 20.0 + i * 40,
-            "x2": 100.0,
-            "y2": 50.0 + i * 40,
+            # Page coordinate space (example values)
+            "width": 1080,
+            "height": 1522,
+            # Globally unique demo URLs (matches global uniqueness on panel_url).
+            "panel_url": (
+                "https://example.invalid/panels/"
+                f"{slug}/ch{chapter_number:g}/p{page_number}/b{i}.jpg"
+            ),
+            "x1": 120.0 + i * 18,
+            "y1": 140.0 + i * 55,
+            "x2": 420.0 + i * 18,
+            "y2": 260.0 + i * 55,
             "original_text": orig,
             "translated_text": trans,
         })
@@ -33,39 +51,57 @@ def _bubbles(*pairs: tuple[str, str]) -> list[dict]:
 def seed():
     db.init_db()
 
-    # Umbrella manga 1: One Piece — local files only (no API id → omit external_manga_id, DB uses legacy-*)
-    db.save_page_translation(
-        provider_id=PROVIDER_LOCAL,
+    # Umbrella manga 1: One Piece — MangaDex provider (example seed)
+    db.save_panels_translation(
         manga_title="One Piece",
         chapter_number=1.0,
         page_number=1,
-        bubbles=_bubbles(("海賊王に俺はなる！", "I'm gonna be King of the Pirates!")),
+        panels=_bubbles(
+            "One Piece",
+            1.0,
+            1,
+            ("海賊王に俺はなる！", "I'm gonna be King of the Pirates!"),
+        ),
         language_code="en",
     )
-    db.save_page_translation(
-        provider_id=PROVIDER_LOCAL,
+    db.save_panels_translation(
         manga_title="One Piece",
         chapter_number=1.0,
         page_number=2,
-        bubbles=_bubbles(("麦わらのルフィ", "Monkey D. Luffy"), ("ゼファ", "Zeff")),
+        panels=_bubbles(
+            "One Piece",
+            1.0,
+            2,
+            ("麦わらのルフィ", "Monkey D. Luffy"),
+            ("ゼファ", "Zeff"),
+        ),
         language_code="en",
     )
-    db.save_page_translation(
-        provider_id=PROVIDER_LOCAL,
+    db.save_panels_translation(
         manga_title="One Piece",
         chapter_number=2.0,
         page_number=1,
-        bubbles=_bubbles(("冒険の始まり", "The adventure begins")),
+        panels=_bubbles(
+            "One Piece",
+            2.0,
+            1,
+            ("冒険の始まり", "The adventure begins"),
+        ),
         language_code="en",
     )
 
-    # Umbrella manga 2: Naruto — MangaDex catalog id stored in manga_source via external_manga_id
-    db.save_page_translation(
-        provider_id=PROVIDER_MANGADEX,
+    # Umbrella manga 2: Naruto — MangaDex series id stored on Manga via external_manga_id
+    db.save_panels_translation(
         manga_title="Naruto",
         chapter_number=1.0,
         page_number=1,
-        bubbles=_bubbles(("忍たま乱太郎", "Ninja Academy"), ("うずまきナルト", "Uzumaki Naruto")),
+        panels=_bubbles(
+            "Naruto",
+            1.0,
+            1,
+            ("忍たま乱太郎", "Ninja Academy"),
+            ("うずまきナルト", "Uzumaki Naruto"),
+        ),
         language_code="en",
         external_manga_id=NARUTO_MANGADEX_ID,
     )
@@ -79,26 +115,24 @@ def seed():
         print(f"  id={m.id}  title={m.manga_title!r}  updated_at={m.updated_at}")
 
     # --- Chapters are scoped by provider: same title can exist per source ---
-    print("\n=== list_chapters('One Piece', provider_id=local) ===")
-    for c in db.list_chapters("One Piece", provider_id=PROVIDER_LOCAL):
-        print(f"  ch.id={c.id}  provider={c.provider_id!r}  ch={c.chapter_number}  updated={c.updated_at}")
-
-    print("\n=== list_chapters('Naruto', provider_id=mangadex) ===")
-    for c in db.list_chapters("Naruto", provider_id=PROVIDER_MANGADEX):
-        print(f"  ch.id={c.id}  provider={c.provider_id!r}  ch={c.chapter_number}  updated={c.updated_at}")
-
-    # Resolve umbrella id from provider + external catalog id
-    mid = db.resolve_manga_id_by_source(PROVIDER_MANGADEX, NARUTO_MANGADEX_ID)
-    print("\n=== resolve_manga_id_by_source(mangadex, external_manga_id) ===")
-    print(f"  umbrella manga_id for Naruto sample UUID: {mid}")
-
-    # Sample segment query (provider on chapter)
-    segs = db.get_chapter_segments(PROVIDER_LOCAL, "One Piece", 1.0)
-    print("\n=== get_chapter_segments(local, 'One Piece', 1.0) ===")
-    print(f"  segment count: {len(segs)}")
-    if segs:
-        s0 = segs[0]
-        print(f"  first: provider_id={s0.provider_id!r}  page={s0.page_number}  translated={s0.translated_text!r}")
+    print("\n=== list_chapters('One Piece') ===")
+    for c in db.list_chapters("One Piece"):
+        print(f"  ch.id={c.id}  ch={c.chapter_number}  updated={c.updated_at}")
+
+    print("\n=== list_chapters('Naruto') ===")
+    for c in db.list_chapters("Naruto"):
+        print(f"  ch.id={c.id}  ch={c.chapter_number}  updated={c.updated_at}")
+
+    print("\n=== MangaDex external_manga_id mapping ===")
+    print("  Stored on manga.mangadex_manga_id")
+
+    # Sample panel query
+    panels = db.get_chapter_panels("One Piece", 1.0)
+    print("\n=== get_chapter_panels('One Piece', 1.0) ===")
+    print(f"  panel count: {len(panels)}")
+    if panels:
+        p0 = panels[0]
+        print(f"  first: page={p0.page_number}  translated={p0.translated_text!r}")
 
 
 if __name__ == "__main__":

db/test_functions/delete_data.py

@@ -10,18 +10,18 @@ import db
 def clear_seed_data():
     """Remove the manga chapters inserted by create_data.py."""
     to_delete = [
-        (db.PROVIDER_LOCAL, "One Piece", 1.0),
-        (db.PROVIDER_LOCAL, "One Piece", 2.0),
-        (db.PROVIDER_MANGADEX, "Naruto", 1.0),
+        ("One Piece", 1.0),
+        ("One Piece", 2.0),
+        ("Naruto", 1.0),
     ]
-    for provider_id, manga_title, chapter_number in to_delete:
-        db.delete_chapter_segments(provider_id, manga_title, chapter_number)
-        print(f"Deleted {provider_id} | {manga_title} ch.{chapter_number}")
+    for manga_title, chapter_number in to_delete:
+        db.delete_chapter_panels(manga_title, chapter_number)
+        print(f"Deleted {manga_title} ch.{chapter_number}")
     print("Seed data cleared.")
 
 
 def clear_all():
-    """Delete all segments, pages, chapters, reading list, manga_source, and umbrella manga."""
+    """Delete all panels, chapters, reading list, and umbrella manga."""
     db.delete_all_manga()
     print("Cleared all manga and related data.")
 

db/test_functions/query_data.py

@@ -11,7 +11,7 @@ def run():
     print("=== list_mangas (default: newest first) ===\n")
     mangas = db.list_mangas()
     for m in mangas:
-        print(f"  {m.provider_id} | {m.manga_title}")
+        print(f"  {m.manga_title}")
     print(f"\n  Total: {len(mangas)} manga(s)\n")
 
     if not mangas:
@@ -19,46 +19,64 @@ def run():
         return
 
     first_manga = mangas[0]
-    provider_id = first_manga.provider_id
     manga_title = first_manga.manga_title
 
-    chapters = db.list_chapters(manga_title, provider_id=provider_id)
+    chapters = db.list_chapters(manga_title)
     if not chapters:
         print(f"No chapters for {manga_title}. Run create_data to add pages.")
         return
     chapter_number = chapters[0].chapter_number
 
-    print(f"=== list_chapters({manga_title!r}, provider_id={provider_id!r}) ===\n")
+    print(f"=== list_chapters({manga_title!r}) ===\n")
     for c in chapters[:5]:
         print(f"  ch.{c.chapter_number} (id={c.id})")
     if len(chapters) > 5:
         print(f"  ... and {len(chapters) - 5} more chapter(s)")
     print(f"\n  Total: {len(chapters)} chapter(s)\n")
 
-    print(f"=== get_chapter_segments({provider_id!r}, {manga_title!r}, {chapter_number}) ===\n")
-    segments = db.get_chapter_segments(provider_id, manga_title, chapter_number)
-    for i, s in enumerate(segments[:5]):  # show first 5
-        print(f"  [{i+1}] page {s.page_number} seg {s.segment_index}: {s.original_text[:30]!r} → {s.translated_text[:30]!r}")
-    if len(segments) > 5:
-        print(f"  ... and {len(segments) - 5} more segment(s)")
-    print(f"\n  Total: {len(segments)} segment(s) in chapter\n")
+    print(f"=== get_chapter_panels({manga_title!r}, {chapter_number}) ===\n")
+    panels = db.get_chapter_panels(manga_title, chapter_number)
+    for i, s in enumerate(panels[:5]):  # show first 5
+        print(
+            f"  [{i+1}] page {s.page_number} bubble {s.bubble_index}: "
+            f"{s.original_text[:30]!r} → {s.translated_text[:30]!r} "
+            f"(url={s.panel_url!r})"
+        )
+    if len(panels) > 5:
+        print(f"  ... and {len(panels) - 5} more panel(s)")
+    print(f"\n  Total: {len(panels)} panel(s) in chapter\n")
 
-    print(f"=== get_segments (provider_id={provider_id!r}, manga_title={manga_title!r}, chapter_number={chapter_number}, page_number=1) ===\n")
-    page_segments = db.get_segments(
-        provider_id=provider_id,
+    if panels and panels[0].panel_url:
+        url = panels[0].panel_url
+        print(f"=== get_panel_by_panel_url({url!r}) ===\n")
+        p = db.get_panel_by_panel_url(url)
+        if p:
+            print(
+                f"  found: {p.manga_title} ch.{p.chapter_number} "
+                f"page={p.page_number} bubble={p.bubble_index} url={p.panel_url!r}"
+            )
+        else:
+            print("  not found")
+        print()
+
+    print(f"=== get_panels (manga_title={manga_title!r}, chapter_number={chapter_number}, page_number=1) ===\n")
+    page_panels = db.get_panels(
         manga_title=manga_title,
         chapter_number=chapter_number,
         page_number=1,
     )
-    for s in page_segments:
-        print(f"  seg {s.segment_index}: {s.translated_text!r}")
-    print(f"\n  Total: {len(page_segments)} segment(s) on page 1\n")
+    for s in page_panels:
+        print(f"  bubble {s.bubble_index}: {s.translated_text!r}")
+    print(f"\n  Total: {len(page_panels)} panel(s) on page 1\n")
 
-    print("=== get_segments (no filters: all segments) ===\n")
-    all_segments = db.get_segments()
-    for s in all_segments:
-        print(f"  {s.provider_id} | {s.manga_title} ch.{s.chapter_number} | {s.page_number} | {s.segment_index}: {s.translated_text!r}")
-    print(f"\n  Total: {len(all_segments)} segment(s)\n")
+    print("=== get_panels (no filters: all panels) ===\n")
+    all_panels = db.get_panels()
+    for s in all_panels:
+        print(
+            f"  {s.manga_title} ch.{s.chapter_number} | {s.page_number} | "
+            f"{s.bubble_index}: {s.translated_text!r} (url={s.panel_url!r})"
+        )
+    print(f"\n  Total: {len(all_panels)} panel(s)\n")
 
 if __name__ == "__main__":
     run()

main.py

@@ -159,10 +159,10 @@ class TranslationRequest(BaseModel):
 async def translate_manga_panel(request: TranslationRequest):
     try:
         results = await processor.download_and_process(request.image_url, request.language)
-        return {"status": "success", "data": results}    
+        return {"status": "success", "data": results}
     except Exception as e:
         print(f"Translation Route Error: {e}")
-    
+
 if __name__ == "__main__":
     # processor.process_image("./test_1.jpg", "")
     # show_boxes("./test_1.jpg")