Implemente un systeme de pages pour le support de formation

Retour utilisateur : "il faut implementer un systeme de page". Un
support est desormais compose de PLUSIEURS pages (_document_pages),
chacune un document independant affiche seul sur le canevas -- chaque
element appartient a exactement une page via page_id (document_engine/
elements/*, routes/document/document_element_add.py/document_render.py
revalident desormais un page_id explicite). Migration automatique et
silencieuse pour les supports crees avant cette fonctionnalite
(db/supports/ensure_document_pages_schema.py, meme convention que les
ensure_X_schema.py existants) : leurs elements deviennent tous les
enfants d'une "Page 1" creee a la volee, aucune perte de contenu.

Nouveau paquet document_engine/pages/ (add/list/get/rename/move/delete)
et 4 routes dediees (routes/document/document_page_*.py) -- supprimer
la DERNIERE page restante est refuse (garde-fou pose a la route, meme
decoupage que routes/game/screens/screen_delete.py cote jeu, jamais
dans la fonction bas niveau).

Cote editeur : une bande d'ONGLETS au-dessus du canevas (jamais un
panneau lateral, choix explicite de l'utilisateur) -- clic pour changer
de page, double-clic pour renommer (contenteditable), glisser pour
reordonner, "+" pour ajouter, "x" pour supprimer. Changer de page vide
la pile Annuler/Retablir (une commande empilee sur une autre page n'a
plus de sens). Mode Apercu : navigation Page precedente/suivante avec
indicateur "Page X / N" (choix explicite : page par page, pas de
defilement continu), jamais affichee s'il n'y a qu'une seule page.

Verifie : suite pytest complete (702 tests, dont 14 nouveaux pour les
routes de pages), simulation DOM reelle (jsdom, 25 assertions couvrant
tout le cycle de vie cote client -- creation/bascule/renommage/
reordonnancement/suppression de page, portee correcte des elements par
page, pile Annuler/Retablir videe au changement de page, pilule de
navigation en Apercu), et un test de fumee HTTP reel contre le serveur
de dev en marche (creation/ajout d'element/rendu/renommage/suppression
d'une page, refus de supprimer la derniere page, page inconnue -> 404).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

tests/document/test_document_elements.py

@@ -2,7 +2,11 @@
 — sans Flask, directement contre le support.db créé par db.create_support.
 Couvre : CRUD complet, rangées (parent_id), réinsertion (move_document_element
 vers une nouvelle rangée/position), suppression en cascade d'une rangée avec
-enfants, et les attributs de position/taille/rotation d'une forme."""
+enfants, et les attributs de position/taille/rotation d'une forme.
+
+Chaque élément appartient désormais à une page (voir document_engine/
+pages/) — _new_support renvoie (slug, page_id) de la première page créée
+par défaut, réutilisée par tous les tests de ce fichier."""
 
 from typing import Any
 
@@ -10,35 +14,37 @@ import db
 import document_engine as doc_engine
 
 
-def _new_support(tmp_support_slug_cleanup: Any, name: str = "Support de test") -> str:
+def _new_support(tmp_support_slug_cleanup: Any, name: str = "Support de test") -> tuple[str, int]:
     slug = db.create_support(name, owner_folder="90")
     tmp_support_slug_cleanup(slug)
-    return slug
+    page_id = doc_engine.list_document_pages(slug)[0]["id"]
+    return slug, page_id
 
 
 def test_add_and_get_document_element_uses_default_attributes(tmp_support_slug_cleanup: Any) -> None:
-    slug = _new_support(tmp_support_slug_cleanup)
-    element_id = doc_engine.add_document_element(slug, "titre")
+    slug, page_id = _new_support(tmp_support_slug_cleanup)
+    element_id = doc_engine.add_document_element(slug, "titre", page_id=page_id)
     element = doc_engine.get_document_element(slug, element_id)
     assert element is not None
     assert element["kind"] == "titre"
+    assert element["page_id"] == page_id
     assert element["parent_id"] is None
     assert element["attributes"]["content"] == "Nouveau titre"
 
 
 def test_get_document_element_returns_none_for_missing_id(tmp_support_slug_cleanup: Any) -> None:
-    slug = _new_support(tmp_support_slug_cleanup)
+    slug, _page_id = _new_support(tmp_support_slug_cleanup)
     assert doc_engine.get_document_element(slug, 999) is None
 
 
 def test_list_document_elements_groups_row_children_together(tmp_support_slug_cleanup: Any) -> None:
-    slug = _new_support(tmp_support_slug_cleanup)
-    row_id = doc_engine.add_document_element(slug, "row")
-    top_titre_id = doc_engine.add_document_element(slug, "titre")
-    child_a_id = doc_engine.add_document_element(slug, "paragraphe", parent_id=row_id)
-    child_b_id = doc_engine.add_document_element(slug, "image", parent_id=row_id)
+    slug, page_id = _new_support(tmp_support_slug_cleanup)
+    row_id = doc_engine.add_document_element(slug, "row", page_id=page_id)
+    top_titre_id = doc_engine.add_document_element(slug, "titre", page_id=page_id)
+    child_a_id = doc_engine.add_document_element(slug, "paragraphe", page_id=page_id, parent_id=row_id)
+    child_b_id = doc_engine.add_document_element(slug, "image", page_id=page_id, parent_id=row_id)
 
-    elements = doc_engine.list_document_elements(slug)
+    elements = doc_engine.list_document_elements(slug, page_id)
     ids_in_order = [el["id"] for el in elements]
 
     # Les deux top-niveau (row_id, top_titre_id) groupés avant les deux
@@ -48,9 +54,19 @@ def test_list_document_elements_groups_row_children_together(tmp_support_slug_cl
     assert ids_in_order.index(child_a_id) < ids_in_order.index(child_b_id)
 
 
+def test_list_document_elements_only_returns_the_given_page(tmp_support_slug_cleanup: Any) -> None:
+    slug, page1_id = _new_support(tmp_support_slug_cleanup)
+    page2_id = doc_engine.add_document_page(slug)
+    el1_id = doc_engine.add_document_element(slug, "titre", page_id=page1_id)
+    el2_id = doc_engine.add_document_element(slug, "titre", page_id=page2_id)
+
+    assert [el["id"] for el in doc_engine.list_document_elements(slug, page1_id)] == [el1_id]
+    assert [el["id"] for el in doc_engine.list_document_elements(slug, page2_id)] == [el2_id]
+
+
 def test_update_document_element_attributes_replaces_whole_json(tmp_support_slug_cleanup: Any) -> None:
-    slug = _new_support(tmp_support_slug_cleanup)
-    element_id = doc_engine.add_document_element(slug, "paragraphe")
+    slug, page_id = _new_support(tmp_support_slug_cleanup)
+    element_id = doc_engine.add_document_element(slug, "paragraphe", page_id=page_id)
     doc_engine.update_document_element_attributes(slug, element_id, {"content": "Texte modifié", "style": "legende"})
     element = doc_engine.get_document_element(slug, element_id)
     assert element is not None
@@ -58,8 +74,8 @@ def test_update_document_element_attributes_replaces_whole_json(tmp_support_slug
 
 
 def test_shape_default_attributes_carry_real_position_and_size(tmp_support_slug_cleanup: Any) -> None:
-    slug = _new_support(tmp_support_slug_cleanup)
-    element_id = doc_engine.add_document_element(slug, "rectangle")
+    slug, page_id = _new_support(tmp_support_slug_cleanup)
+    element_id = doc_engine.add_document_element(slug, "rectangle", page_id=page_id)
     element = doc_engine.get_document_element(slug, element_id)
     assert element is not None
     attrs = element["attributes"]
@@ -83,23 +99,23 @@ def test_shape_default_attributes_carry_real_position_and_size(tmp_support_slug_
 
 
 def test_move_document_element_reorders_within_same_parent(tmp_support_slug_cleanup: Any) -> None:
-    slug = _new_support(tmp_support_slug_cleanup)
-    first_id = doc_engine.add_document_element(slug, "titre")
-    second_id = doc_engine.add_document_element(slug, "paragraphe")
-    third_id = doc_engine.add_document_element(slug, "image")
+    slug, page_id = _new_support(tmp_support_slug_cleanup)
+    first_id = doc_engine.add_document_element(slug, "titre", page_id=page_id)
+    second_id = doc_engine.add_document_element(slug, "paragraphe", page_id=page_id)
+    third_id = doc_engine.add_document_element(slug, "image", page_id=page_id)
 
     doc_engine.move_document_element(slug, third_id, None, 0)
 
-    elements = doc_engine.list_document_elements(slug)
+    elements = doc_engine.list_document_elements(slug, page_id)
     top_level = [el for el in elements if el["parent_id"] is None]
     ordered_ids = [el["id"] for el in sorted(top_level, key=lambda el: el["order_index"])]
     assert ordered_ids == [third_id, first_id, second_id]
 
 
 def test_move_document_element_reparents_into_a_row(tmp_support_slug_cleanup: Any) -> None:
-    slug = _new_support(tmp_support_slug_cleanup)
-    row_id = doc_engine.add_document_element(slug, "row")
-    lone_titre_id = doc_engine.add_document_element(slug, "titre")
+    slug, page_id = _new_support(tmp_support_slug_cleanup)
+    row_id = doc_engine.add_document_element(slug, "row", page_id=page_id)
+    lone_titre_id = doc_engine.add_document_element(slug, "titre", page_id=page_id)
 
     doc_engine.move_document_element(slug, lone_titre_id, row_id, 0)
 
@@ -110,9 +126,9 @@ def test_move_document_element_reparents_into_a_row(tmp_support_slug_cleanup: An
 
 
 def test_delete_document_element_cascades_to_row_children(tmp_support_slug_cleanup: Any) -> None:
-    slug = _new_support(tmp_support_slug_cleanup)
-    row_id = doc_engine.add_document_element(slug, "row")
-    child_id = doc_engine.add_document_element(slug, "titre", parent_id=row_id)
+    slug, page_id = _new_support(tmp_support_slug_cleanup)
+    row_id = doc_engine.add_document_element(slug, "row", page_id=page_id)
+    child_id = doc_engine.add_document_element(slug, "titre", page_id=page_id, parent_id=row_id)
 
     doc_engine.delete_document_element(slug, row_id)
 
@@ -121,17 +137,17 @@ def test_delete_document_element_cascades_to_row_children(tmp_support_slug_clean
 
 
 def test_delete_document_element_on_missing_id_is_a_noop(tmp_support_slug_cleanup: Any) -> None:
-    slug = _new_support(tmp_support_slug_cleanup)
+    slug, _page_id = _new_support(tmp_support_slug_cleanup)
     doc_engine.delete_document_element(slug, 999)
 
 
 def test_render_document_includes_row_children_and_shape_position(tmp_support_slug_cleanup: Any) -> None:
-    slug = _new_support(tmp_support_slug_cleanup)
-    row_id = doc_engine.add_document_element(slug, "row")
-    doc_engine.add_document_element(slug, "titre", parent_id=row_id)
-    rect_id = doc_engine.add_document_element(slug, "rectangle")
+    slug, page_id = _new_support(tmp_support_slug_cleanup)
+    row_id = doc_engine.add_document_element(slug, "row", page_id=page_id)
+    doc_engine.add_document_element(slug, "titre", page_id=page_id, parent_id=row_id)
+    rect_id = doc_engine.add_document_element(slug, "rectangle", page_id=page_id)
 
-    html = doc_engine.render_document(doc_engine.list_document_elements(slug))
+    html = doc_engine.render_document(doc_engine.list_document_elements(slug, page_id))
 
     assert 'data-kind="row"' in html
     assert 'data-kind="titre"' in html

tests/document/test_document_pages_routes.py

@@ -0,0 +1,95 @@
+"""Routes HTTP des pages d'un support de formation (routes/document/
+document_page_*.py) — retour utilisateur du 21/09/2026 : "il faut
+implémenter un système de page". Un support a toujours au moins une page
+(créée par défaut avec le support, voir la fixture `support`)."""
+
+from flask.testing import FlaskClient
+
+import document_engine
+
+
+def _page_id(support: str) -> int:
+    return int(document_engine.list_document_pages(support)[0]["id"])
+
+
+def test_document_page_add_creates_a_second_page(client: FlaskClient, support: str) -> None:
+    resp = client.post(f"/document/{support}/pages/add", json={})
+    assert resp.status_code == 200
+    payload = resp.get_json()
+    assert payload["title"] == "Page 2"
+
+    pages = document_engine.list_document_pages(support)
+    assert [p["title"] for p in pages] == ["Page 1", "Page 2"]
+    assert pages[1]["id"] == payload["id"]
+
+
+def test_document_page_add_accepts_a_custom_title(client: FlaskClient, support: str) -> None:
+    resp = client.post(f"/document/{support}/pages/add", json={"title": "Chapitre 2"})
+    assert resp.status_code == 200
+    assert resp.get_json()["title"] == "Chapitre 2"
+
+
+def test_document_page_rename_persists_the_new_title(client: FlaskClient, support: str) -> None:
+    page_id = _page_id(support)
+    resp = client.post(f"/document/{support}/pages/{page_id}/rename", json={"title": "Introduction"})
+    assert resp.status_code == 200
+    assert resp.get_json() == {"ok": True, "title": "Introduction"}
+    page = document_engine.get_document_page(support, page_id)
+    assert page is not None
+    assert page["title"] == "Introduction"
+
+
+def test_document_page_rename_ignores_an_empty_title(client: FlaskClient, support: str) -> None:
+    page_id = _page_id(support)
+    resp = client.post(f"/document/{support}/pages/{page_id}/rename", json={"title": "   "})
+    assert resp.status_code == 200
+    assert resp.get_json()["title"] == "Page 1"
+
+
+def test_document_page_rename_rejects_an_unknown_page(client: FlaskClient, support: str) -> None:
+    assert client.post(f"/document/{support}/pages/999/rename", json={"title": "X"}).status_code == 404
+
+
+def test_document_page_delete_refuses_the_last_remaining_page(client: FlaskClient, support: str) -> None:
+    page_id = _page_id(support)
+    resp = client.post(f"/document/{support}/pages/{page_id}/delete")
+    assert resp.status_code == 400
+    assert "error" in resp.get_json()
+    assert document_engine.get_document_page(support, page_id) is not None
+
+
+def test_document_page_delete_removes_a_non_last_page_and_its_elements(client: FlaskClient, support: str) -> None:
+    first_page_id = _page_id(support)
+    second_page_id = client.post(f"/document/{support}/pages/add", json={}).get_json()["id"]
+    element_resp = client.post(f"/document/{support}/elements/add", data={"kind": "titre", "page_id": second_page_id})
+    element_id = element_resp.get_json()["id"]
+
+    resp = client.post(f"/document/{support}/pages/{second_page_id}/delete")
+    assert resp.status_code == 200
+    assert resp.get_json()["ok"] is True
+
+    assert document_engine.get_document_page(support, second_page_id) is None
+    assert document_engine.get_document_element(support, element_id) is None
+    assert [p["id"] for p in document_engine.list_document_pages(support)] == [first_page_id]
+
+
+def test_document_page_delete_rejects_an_unknown_page(client: FlaskClient, support: str) -> None:
+    client.post(f"/document/{support}/pages/add", json={})
+    assert client.post(f"/document/{support}/pages/999/delete").status_code == 404
+
+
+def test_document_page_move_reorders_the_tab_strip(client: FlaskClient, support: str) -> None:
+    first_page_id = _page_id(support)
+    second_page_id = client.post(f"/document/{support}/pages/add", json={}).get_json()["id"]
+    third_page_id = client.post(f"/document/{support}/pages/add", json={}).get_json()["id"]
+
+    resp = client.post(f"/document/{support}/pages/{third_page_id}/move", json={"new_index": 0})
+    assert resp.status_code == 200
+    assert resp.get_json()["ok"] is True
+
+    ordered_ids = [p["id"] for p in document_engine.list_document_pages(support)]
+    assert ordered_ids == [third_page_id, first_page_id, second_page_id]
+
+
+def test_document_page_move_rejects_an_unknown_page(client: FlaskClient, support: str) -> None:
+    assert client.post(f"/document/{support}/pages/999/move", json={"new_index": 0}).status_code == 404

tests/document/test_document_routes.py

@@ -1,6 +1,12 @@
 """Routes HTTP du support de formation (routes/document/) — création,
 édition directe (sans page intermédiaire), CRUD des éléments en AJAX,
-publication, et isolation par propriétaire (core/auth_guard.py)."""
+publication, et isolation par propriétaire (core/auth_guard.py).
+
+Chaque élément appartient désormais à une page (voir document_engine/
+pages/ et test_document_pages_routes.py pour les routes dédiées aux
+pages elles-mêmes) — _page_id() renvoie l'id de la page par défaut
+("Page 1") créée avec chaque support de test, réutilisé par toutes les
+routes d'élément ci-dessous qui exigent désormais un page_id explicite."""
 
 from typing import Any
 
@@ -11,6 +17,10 @@ import db
 import document_engine
 
 
+def _page_id(support: str) -> int:
+    return int(document_engine.list_document_pages(support)[0]["id"])
+
+
 def test_documents_new_creates_a_support_not_a_game(client: FlaskClient) -> None:
     resp = client.post("/documents/new", data={"name": "Sécurité incendie"}, follow_redirects=False)
     assert resp.status_code == 302
@@ -29,7 +39,7 @@ def test_document_edit_renders_directly_no_intermediate_page(client: FlaskClient
 
 
 def test_document_element_add_returns_rendered_html(client: FlaskClient, support: str) -> None:
-    resp = client.post(f"/document/{support}/elements/add", data={"kind": "titre"})
+    resp = client.post(f"/document/{support}/elements/add", data={"kind": "titre", "page_id": _page_id(support)})
     assert resp.status_code == 200
     payload = resp.get_json()
     assert payload["kind"] == "titre"
@@ -37,7 +47,15 @@ def test_document_element_add_returns_rendered_html(client: FlaskClient, support
 
 
 def test_document_element_add_rejects_unknown_kind(client: FlaskClient, support: str) -> None:
-    assert client.post(f"/document/{support}/elements/add", data={"kind": "n-importe-quoi"}).status_code == 400
+    resp = client.post(
+        f"/document/{support}/elements/add", data={"kind": "n-importe-quoi", "page_id": _page_id(support)}
+    )
+    assert resp.status_code == 400
+
+
+def test_document_element_add_rejects_a_missing_or_unknown_page(client: FlaskClient, support: str) -> None:
+    assert client.post(f"/document/{support}/elements/add", data={"kind": "titre"}).status_code == 404
+    assert client.post(f"/document/{support}/elements/add", data={"kind": "titre", "page_id": 999}).status_code == 404
 
 
 def test_document_element_add_accepts_row_for_the_layout_engine(client: FlaskClient, support: str) -> None:
@@ -46,13 +64,14 @@ def test_document_element_add_accepts_row_for_the_layout_engine(client: FlaskCli
     route — c'est le moteur de layout côté client qui en crée une à la
     volée au moment d'un dépôt latéral (voir
     static/document/js/document-editor.js)."""
-    resp = client.post(f"/document/{support}/elements/add", data={"kind": "row"})
+    resp = client.post(f"/document/{support}/elements/add", data={"kind": "row", "page_id": _page_id(support)})
     assert resp.status_code == 200
     assert resp.get_json()["kind"] == "row"
 
 
 def test_document_element_update_persists_attributes(client: FlaskClient, support: str) -> None:
-    add_resp = client.post(f"/document/{support}/elements/add", data={"kind": "paragraphe"})
+    page_id = _page_id(support)
+    add_resp = client.post(f"/document/{support}/elements/add", data={"kind": "paragraphe", "page_id": page_id})
     element_id = add_resp.get_json()["id"]
 
     resp = client.post(
@@ -62,7 +81,7 @@ def test_document_element_update_persists_attributes(client: FlaskClient, suppor
     assert resp.status_code == 200
     assert resp.get_json()["ok"] is True
 
-    reread = client.post(f"/document/{support}/elements/add", data={"kind": "titre"})
+    reread = client.post(f"/document/{support}/elements/add", data={"kind": "titre", "page_id": page_id})
     assert reread.status_code == 200
 
 
@@ -72,7 +91,7 @@ def test_document_element_update_sanitizes_quiz_config_on_write(client: FlaskCli
     (5e) doit être tronqué, et la réponse renvoie les attributs
     RÉELLEMENT persistés (pas ceux envoyés tels quels) pour que le
     client ne dérive jamais de la vérité serveur."""
-    add_resp = client.post(f"/document/{support}/elements/add", data={"kind": "quiz"})
+    add_resp = client.post(f"/document/{support}/elements/add", data={"kind": "quiz", "page_id": _page_id(support)})
     element_id = add_resp.get_json()["id"]
 
     resp = client.post(
@@ -94,7 +113,9 @@ def test_document_element_update_sanitizes_quiz_config_on_write(client: FlaskCli
 
 
 def test_document_element_update_sanitizes_association_config_on_write(client: FlaskClient, support: str) -> None:
-    add_resp = client.post(f"/document/{support}/elements/add", data={"kind": "association"})
+    add_resp = client.post(
+        f"/document/{support}/elements/add", data={"kind": "association", "page_id": _page_id(support)}
+    )
     element_id = add_resp.get_json()["id"]
 
     resp = client.post(
@@ -115,7 +136,7 @@ def test_document_element_update_sanitizes_association_config_on_write(client: F
 
 
 def test_document_element_update_sanitizes_memory_config_on_write(client: FlaskClient, support: str) -> None:
-    add_resp = client.post(f"/document/{support}/elements/add", data={"kind": "memory"})
+    add_resp = client.post(f"/document/{support}/elements/add", data={"kind": "memory", "page_id": _page_id(support)})
     element_id = add_resp.get_json()["id"]
 
     resp = client.post(
@@ -151,7 +172,8 @@ def test_document_edit_sanitizes_stale_scenario_attributes_from_an_old_schema(
     écrire ce schéma obsolète tel quel, en contournant volontairement le
     sanitize de la route d'update — pour simuler une ligne réellement
     ancienne en base, jamais nettoyée depuis."""
-    add_resp = client.post(f"/document/{support}/elements/add", data={"kind": "scenario"})
+    page_id = _page_id(support)
+    add_resp = client.post(f"/document/{support}/elements/add", data={"kind": "scenario", "page_id": page_id})
     element_id = add_resp.get_json()["id"]
     stale_attributes = {
         "theme_color": "#ff5f2e",
@@ -167,7 +189,7 @@ def test_document_edit_sanitizes_stale_scenario_attributes_from_an_old_schema(
 
     edit_resp = client.get(f"/document/{support}/edit")
     assert edit_resp.status_code == 200
-    render_resp = client.get(f"/document/{support}/render")
+    render_resp = client.get(f"/document/{support}/render", query_string={"page_id": page_id})
     assert render_resp.status_code == 200
     rendered_element = next(el for el in render_resp.get_json()["elements"] if el["id"] == element_id)
     # Le vieux schéma n'a ni "title" ni "nodes" valides : sanitize_scenario_config
@@ -177,9 +199,19 @@ def test_document_edit_sanitizes_stale_scenario_attributes_from_an_old_schema(
     assert rendered_element["attributes"] == document_engine.DEFAULT_SCENARIO_CONFIG
 
 
+def test_document_render_rejects_a_missing_or_unknown_page(client: FlaskClient, support: str) -> None:
+    assert client.get(f"/document/{support}/render").status_code == 404
+    assert client.get(f"/document/{support}/render", query_string={"page_id": 999}).status_code == 404
+
+
 def test_document_element_move_and_delete(client: FlaskClient, support: str) -> None:
-    first_id = client.post(f"/document/{support}/elements/add", data={"kind": "titre"}).get_json()["id"]
-    second_id = client.post(f"/document/{support}/elements/add", data={"kind": "paragraphe"}).get_json()["id"]
+    page_id = _page_id(support)
+    first_id = client.post(f"/document/{support}/elements/add", data={"kind": "titre", "page_id": page_id}).get_json()[
+        "id"
+    ]
+    second_id = client.post(
+        f"/document/{support}/elements/add", data={"kind": "paragraphe", "page_id": page_id}
+    ).get_json()["id"]
 
     move_resp = client.post(
         f"/document/{support}/elements/{second_id}/move",