feat(series): flat series sequence + cosmetic chapter dividers (#789 Phase 1)

Reframe a series from "ordered chapters that own pages" to ONE flat,
series-global ordered run of pages with optional cosmetic chapter DIVIDERS
over it. A chapter no longer wraps content — it's a labeled divider anchored
to the page that begins it; a page's chapter is derived as the nearest
preceding divider. This is what lets installments assembled from multiple
sources sit in one continuous, correctly-numbered sequence (operator's
Goblin Juice case).

- migration 0047: flatten each series to a series-global page_number
  (preserving today's reading order); convert each existing chapter to a
  divider anchored at its first page (keeping title/stated_part); drop
  series_page.chapter_id; reshape series_chapter (anchor_page_id UNIQUE FK,
  drop chapter_number/is_placeholder/stated_page_start/end). Loss-safe for
  content; drops empty placeholder chapters + a redundant page-1 divider.
- series_page: page_number is now the series-global order; no chapter_id.
- series_chapter: anchored divider (anchor_page_id, title, stated_part).
- series_service: flat list_pages (one run + derived dividers + per-page
  source_post + part_gaps), series-wide reorder/renumber, divider CRUD
  (create/update/move/delete); retired per-chapter reorder/merge/placement.
- api/tags: drop chapter_id from add; /chapters endpoints are divider
  create/update/delete (removed chapter reorder/merge/page-reorder).
- series_match_service: series "end" reads max(series_page.stated_page);
  accept appends via add_post. tag_service series-merge appends src's pages
  after tgt's max so the merged series stays one clean run.
- frontend: seriesManage store + SeriesManageView → one continuous
  drag-reorder grid with inline divider bars + series-global page numbers;
  reader walks the flat run, headings from dividers; PostSeriesMenu copy.
- tests reworked across the series suite for the divider model.

Phase 2 (pending staging for add-from-post) is separate.

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

tests/test_cleanup_service.py

@@ -178,14 +178,21 @@ def test_find_unused_tags_excludes_fandom_referenced_by_character(db_sync):
     assert "NobodysFandom" in names      # genuinely orphaned → still swept
 
 
-def test_find_unused_tags_excludes_series_with_only_chapters(db_sync):
-    # An all-placeholder series has chapters but no pages yet — not unused.
-    series = _make_tag(db_sync, name="EmptySeries", kind=TagKind.series)
-    db_sync.add(SeriesChapter(series_tag_id=series.id, chapter_number=1))
+def test_find_unused_tags_excludes_series_with_a_divider(db_sync):
+    # A series with a chapter divider (which anchors to a page) is in use.
+    a = _make_artist(db_sync)
+    series = _make_tag(db_sync, name="DivSeries", kind=TagKind.series)
+    img = _make_image(
+        db_sync, artist=a, path="/tmp/fc_divser.jpg", sha256="e" * 64,
+    )
+    page = SeriesPage(series_tag_id=series.id, image_id=img.id, page_number=1)
+    db_sync.add(page)
+    db_sync.flush()
+    db_sync.add(SeriesChapter(series_tag_id=series.id, anchor_page_id=page.id))
     db_sync.commit()
 
     names = [t.name for t in cleanup_service.find_unused_tags(db_sync)]
-    assert "EmptySeries" not in names
+    assert "DivSeries" not in names
 
 
 # --- unlink_image_files ---------------------------------------------
@@ -391,7 +398,12 @@ def test_prune_unused_tags_commit_spares_fandom_and_chaptered_series(
         image_record_id=img.id, tag_id=char.id,
     ))
     series = _make_tag(db_sync, name="EmptySeries", kind=TagKind.series)
-    db_sync.add(SeriesChapter(series_tag_id=series.id, chapter_number=1))
+    simg = _make_image(
+        db_sync, artist=a, path=str(tmp_path / "s.jpg"), sha256="e" * 64,
+    )
+    db_sync.add(SeriesPage(
+        series_tag_id=series.id, image_id=simg.id, page_number=1
+    ))
     _make_tag(db_sync, name="GenuinelyUnused")
     db_sync.commit()
 
@@ -480,11 +492,8 @@ def test_reset_content_tagging_deletes_content_keeps_fandom_series(db_sync, tmp_
         {"image_record_id": img.id, "tag_id": c.id},
         {"image_record_id": img.id, "tag_id": s.id},  # series membership
     ]))
-    ch = SeriesChapter(series_tag_id=s.id, chapter_number=1)
-    db_sync.add(ch)
-    db_sync.flush()
     db_sync.add(SeriesPage(
-        series_tag_id=s.id, chapter_id=ch.id, image_id=img.id, page_number=1
+        series_tag_id=s.id, image_id=img.id, page_number=1
     ))
     db_sync.commit()
 

tests/test_series_chapters.py

@@ -1,4 +1,4 @@
-"""FC-6.1 — chapter layer over series_page."""
+"""FC-6.x — cosmetic chapter dividers over the flat series page run."""
 
 import pytest
 from sqlalchemy import func, select
@@ -30,155 +30,138 @@ async def _series(db, name):
     return (await TagService(db).find_or_create(name, TagKind.series)).id
 
 
-async def _chapter_numbers(db, sid):
-    rows = (
-        await db.execute(
-            select(SeriesChapter.id, SeriesChapter.chapter_number)
-            .where(SeriesChapter.series_tag_id == sid)
-            .order_by(SeriesChapter.chapter_number)
-        )
-    ).all()
-    return [(r.id, r.chapter_number) for r in rows]
-
-
-async def _page_order(db, chapter_id):
+async def _order(db, sid):
     rows = (
         await db.execute(
             select(SeriesPage.image_id)
-            .where(SeriesPage.chapter_id == chapter_id)
+            .where(SeriesPage.series_tag_id == sid)
             .order_by(SeriesPage.page_number)
         )
     ).scalars().all()
     return list(rows)
 
 
+async def _dividers(db, sid):
+    """(anchor_image_id, title, stated_part) ordered by anchor page position."""
+    rows = (
+        await db.execute(
+            select(
+                SeriesChapter.id,
+                SeriesPage.image_id,
+                SeriesChapter.title,
+                SeriesChapter.stated_part,
+            )
+            .join(SeriesPage, SeriesPage.id == SeriesChapter.anchor_page_id)
+            .where(SeriesChapter.series_tag_id == sid)
+            .order_by(SeriesPage.page_number)
+        )
+    ).all()
+    return rows
+
+
 @pytest.mark.asyncio
-async def test_add_images_creates_default_chapter(db):
+async def test_create_divider_anchors_before_a_page(db):
     svc = SeriesService(db)
     sid = await _series(db, "C1")
-    i1, i2 = await _img(db), await _img(db)
-    await svc.add_images(sid, [i1, i2])
-    chapters = await _chapter_numbers(db, sid)
-    assert len(chapters) == 1
-    assert chapters[0][1] == 1
-    assert await _page_order(db, chapters[0][0]) == [i1, i2]
+    i1, i2, i3 = await _img(db), await _img(db), await _img(db)
+    await svc.add_images(sid, [i1, i2, i3])
+    await svc.create_divider(sid, i2, title="Two", stated_part=2)
+    divs = await _dividers(db, sid)
+    assert len(divs) == 1
+    assert divs[0].image_id == i2
+    assert divs[0].title == "Two"
+    assert divs[0].stated_part == 2
 
 
 @pytest.mark.asyncio
-async def test_create_and_target_specific_chapter(db):
+async def test_create_divider_rejects_image_not_in_series(db):
     svc = SeriesService(db)
     sid = await _series(db, "C2")
-    i1, i2 = await _img(db), await _img(db)
-    await svc.add_images(sid, [i1])  # default chapter 1
-    ch2 = await svc.create_chapter(sid, title="Two")
-    assert ch2["chapter_number"] == 2
-    await svc.add_images(sid, [i2], chapter_id=ch2["id"])
-    assert await _page_order(db, ch2["id"]) == [i2]
-    # i1 stayed in chapter 1.
-    chapters = await _chapter_numbers(db, sid)
-    assert len(chapters) == 2
+    i1 = await _img(db)
+    await svc.add_images(sid, [i1])
+    with pytest.raises(SeriesError):
+        await svc.create_divider(sid, 999999)
 
 
 @pytest.mark.asyncio
-async def test_reorder_chapters(db):
+async def test_one_divider_per_page(db):
     svc = SeriesService(db)
     sid = await _series(db, "C3")
-    c1 = (await svc.create_chapter(sid))["id"]
-    c2 = (await svc.create_chapter(sid))["id"]
-    c3 = (await svc.create_chapter(sid))["id"]
-    await svc.reorder_chapters(sid, [c3, c1, c2])
-    assert await _chapter_numbers(db, sid) == [(c3, 1), (c1, 2), (c2, 3)]
+    i1, i2 = await _img(db), await _img(db)
+    await svc.add_images(sid, [i1, i2])
+    await svc.create_divider(sid, i2)
     with pytest.raises(SeriesError):
-        await svc.reorder_chapters(sid, [c1, c2])
+        await svc.create_divider(sid, i2)
 
 
 @pytest.mark.asyncio
-async def test_reorder_pages_within_chapter(db):
+async def test_update_divider_sets_part_title_and_moves_anchor(db):
     svc = SeriesService(db)
     sid = await _series(db, "C4")
     i1, i2, i3 = await _img(db), await _img(db), await _img(db)
     await svc.add_images(sid, [i1, i2, i3])
-    cid = (await _chapter_numbers(db, sid))[0][0]
-    await svc.reorder_pages(sid, cid, [i3, i1, i2])
-    assert await _page_order(db, cid) == [i3, i1, i2]
+    d = await svc.create_divider(sid, i2)
+    await svc.update_divider(
+        sid, d["id"], set_title=True, title="X", set_part=True, stated_part=3
+    )
+    await svc.update_divider(
+        sid, d["id"], set_anchor=True, anchor_image_id=i3
+    )
+    divs = await _dividers(db, sid)
+    assert divs[0].image_id == i3
+    assert divs[0].title == "X"
+    assert divs[0].stated_part == 3
 
 
 @pytest.mark.asyncio
-async def test_legacy_reorder_rejects_multi_chapter(db):
+async def test_delete_divider_leaves_pages(db):
     svc = SeriesService(db)
     sid = await _series(db, "C5")
-    i1 = await _img(db)
-    await svc.add_images(sid, [i1])
-    await svc.create_chapter(sid)  # now 2 chapters
-    with pytest.raises(SeriesError):
-        await svc.reorder(sid, [i1])
+    i1, i2, i3 = await _img(db), await _img(db), await _img(db)
+    await svc.add_images(sid, [i1, i2, i3])
+    d = await svc.create_divider(sid, i2)
+    await svc.delete_divider(sid, d["id"])
+    assert await _order(db, sid) == [i1, i2, i3]
+    assert len(await _dividers(db, sid)) == 0
 
 
 @pytest.mark.asyncio
-async def test_merge_chapter_moves_pages_and_renumbers(db):
+async def test_removing_anchor_page_cascades_its_divider(db):
     svc = SeriesService(db)
     sid = await _series(db, "C6")
     i1, i2, i3 = await _img(db), await _img(db), await _img(db)
-    await svc.add_images(sid, [i1])  # chapter 1
-    c2 = (await svc.create_chapter(sid))["id"]
-    await svc.add_images(sid, [i2, i3], chapter_id=c2)
-    c1 = (await _chapter_numbers(db, sid))[0][0]
-    moved = await svc.merge_chapter(sid, c2, c1)
-    assert moved == 2
-    assert await _page_order(db, c1) == [i1, i2, i3]
-    # source chapter gone; remaining renumbered 1..N.
-    assert await _chapter_numbers(db, sid) == [(c1, 1)]
-
-
-@pytest.mark.asyncio
-async def test_delete_chapter_cascades_pages_and_renumbers(db):
-    svc = SeriesService(db)
-    sid = await _series(db, "C7")
-    i1, i2 = await _img(db), await _img(db)
-    await svc.add_images(sid, [i1])
-    c2 = (await svc.create_chapter(sid))["id"]
-    await svc.add_images(sid, [i2], chapter_id=c2)
-    await svc.delete_chapter(sid, c2)
-    assert [c for _, c in await _chapter_numbers(db, sid)] == [1]
-    # i2's page cascaded away with its chapter.
+    await svc.add_images(sid, [i1, i2, i3])
+    await svc.create_divider(sid, i2)
+    await svc.remove_images(sid, [i2])
+    # the divider anchored at i2 cascaded away; pages compacted to 1..N.
+    assert len(await _dividers(db, sid)) == 0
+    assert await _order(db, sid) == [i1, i3]
     cnt = await db.scalar(
-        select(func.count()).select_from(SeriesPage)
-        .where(SeriesPage.image_id == i2)
+        select(func.count()).select_from(SeriesChapter)
+        .where(SeriesChapter.series_tag_id == sid)
     )
     assert cnt == 0
 
 
 @pytest.mark.asyncio
-async def test_set_cover_brings_chapter_and_page_to_front(db):
+async def test_list_pages_returns_dividers_and_part_gaps(db):
     svc = SeriesService(db)
-    sid = await _series(db, "C8")
+    sid = await _series(db, "C7")
     i1, i2, i3 = await _img(db), await _img(db), await _img(db)
-    await svc.add_images(sid, [i1])  # chapter 1
-    c2 = (await svc.create_chapter(sid))["id"]
-    await svc.add_images(sid, [i2, i3], chapter_id=c2)
-    await svc.set_cover(sid, i3)
-    chapters = await _chapter_numbers(db, sid)
-    assert chapters[0][0] == c2  # i3's chapter is now first
-    assert (await _page_order(db, c2))[0] == i3  # i3 first in its chapter
-
-
-@pytest.mark.asyncio
-async def test_list_pages_flags_gaps_from_stated_ranges(db):
-    svc = SeriesService(db)
-    sid = await _series(db, "C9")
-    await svc.create_chapter(sid, stated_page_start=1, stated_page_end=4)
-    await svc.create_chapter(sid, stated_page_start=9, stated_page_end=12)
+    await svc.add_images(sid, [i1, i2, i3])
+    await svc.create_divider(sid, i1, stated_part=1)
+    await svc.create_divider(sid, i3, stated_part=3)
     out = await svc.list_pages(sid)
-    assert len(out["chapters"]) == 2
-    assert len(out["gaps"]) == 1
-    assert out["gaps"][0]["start"] == 5
-    assert out["gaps"][0]["end"] == 8
+    assert len(out["dividers"]) == 2
+    assert len(out["part_gaps"]) == 1
+    assert out["part_gaps"][0]["start"] == 2
+    assert out["part_gaps"][0]["end"] == 2
 
 
 @pytest.mark.asyncio
 async def test_add_with_stated_pages_records_them(db):
     svc = SeriesService(db)
-    sid = await _series(db, "C10")
+    sid = await _series(db, "C8")
     i1, i2 = await _img(db), await _img(db)
     await svc.add_images(sid, [i1, i2], stated_pages={i1: 9, i2: 10})
     rows = dict(

tests/test_series_from_post.py

@@ -1,9 +1,11 @@
-"""FC-6.2 — promote a post to a series + add a post as a chapter + browse list."""
+"""FC-6.x — promote a post to a series + add a post's pages + browse list."""
 
 import pytest
+from sqlalchemy import select
 
 from backend.app.models import Artist, ImageRecord, Post, TagKind
-from backend.app.services.series_service import SeriesService
+from backend.app.models.series_page import SeriesPage
+from backend.app.services.series_service import SeriesError, SeriesService
 from backend.app.services.tag_service import TagService
 
 pytestmark = pytest.mark.integration
@@ -53,12 +55,10 @@ async def test_promote_post_to_series(db):
     assert out["name"] == "My Comic pages 1-3"
 
     data = await svc.list_pages(out["series_tag_id"])
-    assert len(data["chapters"]) == 1
-    ch = data["chapters"][0]
-    assert ch["stated_page_start"] == 1
-    assert ch["stated_page_end"] == 3
-    assert [p["image_id"] for p in ch["pages"]] == imgs  # capture order
-    assert [p["stated_page"] for p in ch["pages"]] == [1, 2, 3]
+    # one flat run in capture order, no dividers, stated pages parsed 1..3
+    assert [p["image_id"] for p in data["pages"]] == imgs
+    assert [p["stated_page"] for p in data["pages"]] == [1, 2, 3]
+    assert data["dividers"] == []
 
 
 @pytest.mark.asyncio
@@ -66,31 +66,35 @@ async def test_promote_requires_images(db):
     svc = SeriesService(db)
     artist = await _artist(db, "Empty Artist")
     post = await _post(db, artist, "No images", "pp2")
-    from backend.app.services.series_service import SeriesError
     with pytest.raises(SeriesError):
         await svc.promote_post_to_series(post.id)
 
 
 @pytest.mark.asyncio
-async def test_add_post_as_chapter_slots_by_stated_page(db):
+async def test_add_post_appends_pages_to_the_run(db):
     svc = SeriesService(db)
     artist = await _artist(db, "Story Artist")
     sid = (await TagService(db).find_or_create("Story", TagKind.series)).id
-    # An existing chapter stating pages 9-12.
-    await svc.create_chapter(sid, stated_page_start=9, stated_page_end=12)
-    # A post stating pages 1-4 should slot BEFORE the 9-12 chapter.
-    post = await _post(db, artist, "Story pages 1-4", "pp3")
-    await _post_images(db, post, artist, 4)
-    out = await svc.add_post_as_chapter(sid, post.id)
-    assert out["added"] == 4
+    # Seed the series with two existing pages.
+    seed_post = await _post(db, artist, "seed", "pp3a")
+    seed = await _post_images(db, seed_post, artist, 2)
+    await svc.add_images(sid, seed)
+    # A later post's pages append to the END (operator orders afterward).
+    post = await _post(db, artist, "Story pages 9-11", "pp3b")
+    imgs = await _post_images(db, post, artist, 3)
+    out = await svc.add_post(sid, post.id)
+    assert out["added"] == 3
 
-    data = await svc.list_pages(sid)
-    chapters = data["chapters"]
-    assert chapters[0]["stated_page_start"] == 1   # new one is first
-    assert chapters[1]["stated_page_start"] == 9
-    # gap 5-8 flagged between them
-    assert data["gaps"][0]["start"] == 5
-    assert data["gaps"][0]["end"] == 8
+    rows = (
+        await db.execute(
+            select(SeriesPage.image_id, SeriesPage.stated_page)
+            .where(SeriesPage.series_tag_id == sid)
+            .order_by(SeriesPage.page_number)
+        )
+    ).all()
+    assert [r.image_id for r in rows] == seed + imgs
+    stated = {r.image_id: r.stated_page for r in rows}
+    assert [stated[i] for i in imgs] == [9, 10, 11]
 
 
 @pytest.mark.asyncio
@@ -104,61 +108,32 @@ async def test_list_series_cards(db):
     rows = await svc.list_series()
     card = next(r for r in rows if r["id"] == out["series_tag_id"])
     assert card["name"] == "Card Comic pages 1-2"
-    assert card["chapter_count"] == 1
+    assert card["chapter_count"] == 0  # a flat promote has no dividers
     assert card["page_count"] == 2
     assert card["artist_name"] == "Card Artist"
     assert card["cover_thumbnail_url"]
     assert card["has_gap"] is False
 
     # artist filter keeps it; a different artist id drops it.
-    assert any(r["id"] == out["series_tag_id"] for r in await svc.list_series(artist_id=artist.id))
-    assert all(r["id"] != out["series_tag_id"] for r in await svc.list_series(artist_id=artist.id + 99999))
-
-
-# --- FC-6.4: stated_part, part_gaps, source_post label ---------------------
+    assert any(
+        r["id"] == out["series_tag_id"]
+        for r in await svc.list_series(artist_id=artist.id)
+    )
+    assert all(
+        r["id"] != out["series_tag_id"]
+        for r in await svc.list_series(artist_id=artist.id + 99999)
+    )
 
 
 @pytest.mark.asyncio
-async def test_update_chapter_sets_and_clears_stated_part(db):
-    svc = SeriesService(db)
-    sid = (await TagService(db).find_or_create("Part Series", TagKind.series)).id
-    ch = await svc.create_chapter(sid)
-    # Set the installment to Part 2 (chapter_number stays its positional value).
-    await svc.update_chapter(sid, ch["id"], stated_part=2, set_part=True)
-    data = await svc.list_pages(sid)
-    assert data["chapters"][0]["stated_part"] == 2
-    assert data["chapters"][0]["chapter_number"] == 1
-    # Clearing it writes NULL back.
-    await svc.update_chapter(sid, ch["id"], stated_part=None, set_part=True)
-    data = await svc.list_pages(sid)
-    assert data["chapters"][0]["stated_part"] is None
-
-
-@pytest.mark.asyncio
-async def test_part_gaps_flagged_from_stated_part(db):
-    svc = SeriesService(db)
-    sid = (await TagService(db).find_or_create("Gappy Series", TagKind.series)).id
-    c1 = await svc.create_chapter(sid)
-    c3 = await svc.create_chapter(sid)
-    await svc.update_chapter(sid, c1["id"], stated_part=1, set_part=True)
-    await svc.update_chapter(sid, c3["id"], stated_part=3, set_part=True)
-    data = await svc.list_pages(sid)
-    assert len(data["part_gaps"]) == 1
-    gap = data["part_gaps"][0]
-    assert gap["after_chapter_id"] == c1["id"]
-    assert gap["start"] == 2
-    assert gap["end"] == 2
-
-
-@pytest.mark.asyncio
-async def test_source_post_label_when_pages_share_one_post(db):
+async def test_source_post_label_is_per_page(db):
     svc = SeriesService(db)
     artist = await _artist(db, "Src Artist")
     post = await _post(db, artist, "Source Comic pages 1-2", "pp5")
     await _post_images(db, post, artist, 2)
     out = await svc.promote_post_to_series(post.id)
     data = await svc.list_pages(out["series_tag_id"])
-    sp = data["chapters"][0]["source_post"]
+    sp = data["pages"][0]["source_post"]
     assert sp is not None
     assert sp["id"] == post.id
     assert sp["title"] == "Source Comic pages 1-2"

tests/test_series_match_service.py

@@ -79,7 +79,7 @@ async def test_match_is_idempotent_under_unique(db):
 
 
 @pytest.mark.asyncio
-async def test_accept_adds_chapter_and_marks_added(db):
+async def test_accept_appends_pages_and_marks_added(db):
     artist = await _artist(db, "Accept Artist")
     a = await _post_with_images(db, artist, "Saga pages 1-4", "a", 3)
     sid = await _series_from(db, a)
@@ -90,7 +90,8 @@ async def test_accept_adds_chapter_and_marks_added(db):
 
     await svc.accept(sug["id"])
     data = await SeriesService(db).list_pages(sid)
-    assert len(data["chapters"]) == 2          # b became a 2nd chapter
+    # b's pages were appended to the series' flat run (3 from a + 3 from b).
+    assert len(data["pages"]) == 6
     status = await db.scalar(
         select(SeriesSuggestion.status).where(SeriesSuggestion.id == sug["id"])
     )

tests/test_series_model.py

@@ -25,20 +25,10 @@ async def _img(db):
 
 
 @pytest.mark.asyncio
-async def _chapter(db, series_tag_id):
-    ch = SeriesChapter(series_tag_id=series_tag_id, chapter_number=1)
-    db.add(ch)
-    await db.flush()
-    return ch.id
-
-
 async def test_series_page_roundtrip_and_unique_image(db):
     s = await TagService(db).find_or_create("Vol1", TagKind.series)
     i1 = await _img(db)
-    ch = await _chapter(db, s.id)
-    db.add(SeriesPage(
-        series_tag_id=s.id, chapter_id=ch, image_id=i1, page_number=1
-    ))
+    db.add(SeriesPage(series_tag_id=s.id, image_id=i1, page_number=1))
     await db.flush()
     got = await db.scalar(
         select(SeriesPage.page_number).where(SeriesPage.image_id == i1)
@@ -46,9 +36,21 @@ async def test_series_page_roundtrip_and_unique_image(db):
     assert got == 1
     # UNIQUE image_id: same image can't be a page twice (any series).
     s2 = await TagService(db).find_or_create("Vol2", TagKind.series)
-    ch2 = await _chapter(db, s2.id)
-    db.add(SeriesPage(
-        series_tag_id=s2.id, chapter_id=ch2, image_id=i1, page_number=1
-    ))
+    db.add(SeriesPage(series_tag_id=s2.id, image_id=i1, page_number=1))
+    with pytest.raises(IntegrityError):
+        await db.flush()
+
+
+@pytest.mark.asyncio
+async def test_chapter_divider_anchor_is_unique(db):
+    # A chapter divider anchors to the page that begins it; one divider per page.
+    s = await TagService(db).find_or_create("Vol3", TagKind.series)
+    i1 = await _img(db)
+    p = SeriesPage(series_tag_id=s.id, image_id=i1, page_number=1)
+    db.add(p)
+    await db.flush()
+    db.add(SeriesChapter(series_tag_id=s.id, anchor_page_id=p.id))
+    await db.flush()
+    db.add(SeriesChapter(series_tag_id=s.id, anchor_page_id=p.id))
     with pytest.raises(IntegrityError):
         await db.flush()

tests/test_tag_merge.py

@@ -409,19 +409,18 @@ async def test_merge_repoints_series_pages(db):
     a = await svc.find_or_create("SerA", TagKind.series)
     b = await svc.find_or_create("SerB", TagKind.series)
     img = await _img(db)
-    cha = SeriesChapter(series_tag_id=a.id, chapter_number=1)
-    db.add(cha)
+    p = SeriesPage(series_tag_id=a.id, image_id=img, page_number=1)
+    db.add(p)
     await db.flush()
-    db.add(SeriesPage(
-        series_tag_id=a.id, chapter_id=cha.id, image_id=img, page_number=1
-    ))
+    cha = SeriesChapter(series_tag_id=a.id, anchor_page_id=p.id)
+    db.add(cha)
     await db.flush()
     await svc.merge(a.id, b.id)
     owner = await db.scalar(
         select(SeriesPage.series_tag_id).where(SeriesPage.image_id == img)
     )
     assert owner == b.id
-    # The chapter moved to the survivor too, so the page's FK stayed valid.
+    # The chapter divider moved to the survivor too (its anchor page moved).
     ch_owner = await db.scalar(
         select(SeriesChapter.series_tag_id).where(SeriesChapter.id == cha.id)
     )