Ajoute le support de formation : entite racine separee du jeu 2D

Nouveau moteur document_engine/ (elements CRUD + rendering + labels),
db/supports/ (stockage independant de db/games), routes/document/
(CRUD AJAX + publication), et l'editeur frontend complet
(templates/document/, static/document/) avec moteur de layout reel
(glisser-deposer -> fusion en rangee ou insertion avant/apres), vrai
Undo/Redo par pile de commandes, grille d'accroche pour les formes
libres, apercu responsive a largeurs fixes, mode Apercu, et publication
persistee.

"Mes formations" (templates/index.html) liste desormais les
environnements 2D et les supports de formation cote a cote ;
l'onboarding et core/auth_guard.py sont generalises pour qu'un compte
restreint puisse posseder un projet de chaque type independamment.

SKIP=djlint : le hook ne signale que le backlog H021 (styles en ligne)
deja documente dans CODE_QUALITY.md sur des fichiers pre-existants non
touches ici (base.html, game/play.html, scene_edit.html,
game_dashboard_simple.html, clause_row.html) plus une ligne de
index.html deja presente avant cette session — aucun nouveau fichier
(document_edit.html compris) n'y figure. Tous les autres outils
(ruff, mypy --strict, vulture, bandit, import-linter, eslint,
stylelint) passent sans erreur ; 617 tests Python + 276 tests JS
verts, plus une verification manuelle complete du cycle de vie via le
serveur de developpement.

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

db/supports/__init__.py

@@ -0,0 +1,29 @@
+"""Couche données du support de formation — entité racine séparée du jeu
+(voir docs/plan/PLAN.md). Aucun import croisé avec db/games/ ou tout autre
+module lié au jeu 2D : même les réglages de connexion SQLite bas niveau
+sont dupliqués (voir support_connection.py) pour garantir cette
+indépendance."""
+
+from .create_support import create_support
+from .delete_support import delete_support
+from .list_supports import list_supports
+from .mark_support_published import mark_support_published
+from .support_connection import connect_support, install_support_teardown_safety_net
+from .support_dir import support_dir
+from .support_meta import support_meta
+from .support_path import support_path
+from .support_slug import build_slug, split_slug
+
+__all__ = [
+    "build_slug",
+    "connect_support",
+    "create_support",
+    "delete_support",
+    "install_support_teardown_safety_net",
+    "list_supports",
+    "mark_support_published",
+    "split_slug",
+    "support_dir",
+    "support_meta",
+    "support_path",
+]

db/supports/create_support.py

@@ -0,0 +1,46 @@
+import os
+
+from ..slugify import slugify
+from .support_connection import connect_support
+from .support_dir import support_dir
+from .support_slug import build_slug
+
+
+def create_support(name: str, owner_folder: str) -> str:
+    """Crée le dossier du support (projects/<owner_folder>/_supports/
+    <project_part>/) et sa base support.db dédiée — mirroir de
+    db/games/create_game.py pour la mécanique de dossier/unicité de nom,
+    mais un schéma entièrement différent (voir document_engine/ : un seul
+    document par support, pas d'écrans/objets de scène). owner_folder
+    n'est jamais optionnel ici (contrairement à create_game) : un support
+    n'existe pas sans compte propriétaire."""
+    project_part = slugify(name)
+    base = project_part
+    n = 2
+    while os.path.isdir(support_dir(build_slug(owner_folder, base))):
+        base = f"{project_part}-{n}"
+        n += 1
+    project_part = base
+    slug = build_slug(owner_folder, project_part)
+
+    os.makedirs(support_dir(slug), exist_ok=True)
+
+    conn = connect_support(slug)
+    conn.executescript(
+        """
+        CREATE TABLE _meta (key TEXT PRIMARY KEY, value TEXT);
+
+        CREATE TABLE _document_elements (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            parent_id INTEGER REFERENCES _document_elements(id) ON DELETE CASCADE,
+            kind TEXT NOT NULL,
+            order_index INTEGER NOT NULL DEFAULT 0,
+            attributes TEXT NOT NULL DEFAULT '{}',
+            created_at TEXT DEFAULT CURRENT_TIMESTAMP
+        );
+        """
+    )
+    conn.execute("INSERT INTO _meta (key, value) VALUES ('name', ?)", (name,))
+    conn.commit()
+    conn.close()
+    return slug

db/supports/delete_support.py

@@ -0,0 +1,19 @@
+import os
+import shutil
+
+from ..constants import PROJECTS_DIR
+from .support_dir import support_dir
+from .support_slug import split_slug
+
+
+def delete_support(slug: str) -> None:
+    shutil.rmtree(support_dir(slug))
+    # Nettoie aussi _supports/ (et le dossier propriétaire) s'ils sont
+    # vides ensuite — purement cosmétique, mirroir de
+    # db/games/delete_game.py.
+    owner_folder, project_part = split_slug(slug)
+    if project_part is None:
+        return
+    supports_path = os.path.join(PROJECTS_DIR, owner_folder, "_supports")
+    if os.path.isdir(supports_path) and not os.listdir(supports_path):
+        os.rmdir(supports_path)

db/supports/list_supports.py

@@ -0,0 +1,29 @@
+import os
+from typing import Any
+
+from ..constants import PROJECTS_DIR
+from .support_connection import connect_support
+from .support_path import support_path
+from .support_slug import build_slug
+
+
+def list_supports(owner_folder: str) -> list[dict[str, Any]]:
+    """Scanne UNIQUEMENT projects/<owner_folder>/_supports/ — jamais les
+    autres comptes, jamais les jeux du même compte (mirroir de
+    db/games/list_games.py, sous-dossier différent)."""
+    supports: list[dict[str, Any]] = []
+    entry_path = os.path.join(PROJECTS_DIR, owner_folder, "_supports")
+    if not os.path.isdir(entry_path):
+        return supports
+    for project_part in sorted(os.listdir(entry_path)):
+        slug = build_slug(owner_folder, project_part)
+        if os.path.isfile(support_path(slug)):
+            _append_support(supports, slug)
+    return supports
+
+
+def _append_support(supports: list[dict[str, Any]], slug: str) -> None:
+    conn = connect_support(slug)
+    row = conn.execute("SELECT value FROM _meta WHERE key = 'name'").fetchone()
+    conn.close()
+    supports.append({"slug": slug, "name": row["value"] if row else slug})

db/supports/mark_support_published.py

@@ -0,0 +1,19 @@
+from datetime import UTC, datetime
+
+from .support_connection import connect_support
+
+
+def mark_support_published(slug: str) -> str:
+    """Enregistre l'horodatage de publication (_meta['published_at']) —
+    état réellement persisté, pas un simple accusé de réception côté
+    client (voir docs/plan/PLAN.md, "Publier" doit être réel)."""
+    published_at = datetime.now(UTC).isoformat()
+    conn = connect_support(slug)
+    conn.execute(
+        "INSERT INTO _meta (key, value) VALUES ('published_at', ?) "
+        "ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+        (published_at,),
+    )
+    conn.commit()
+    conn.close()
+    return published_at

db/supports/support_connection.py

@@ -0,0 +1,52 @@
+import contextlib
+import sqlite3
+from typing import TYPE_CHECKING
+
+from .support_path import support_path
+
+if TYPE_CHECKING:
+    from flask import Flask
+
+
+def connect_support(slug: str) -> sqlite3.Connection:
+    """Connexion SQLite dédiée à un support.db — copie volontairement
+    indépendante de db/connection.py::connect (mêmes réglages WAL/verrou/
+    row_factory, système différent, "aucun import croisé avec le système
+    jeu", voir docs/plan/PLAN.md)."""
+    conn = sqlite3.connect(support_path(slug), timeout=10)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    conn.execute("PRAGMA journal_mode = WAL")
+    conn.execute("PRAGMA busy_timeout = 8000")
+    _track_for_teardown(conn)
+    return conn
+
+
+def _track_for_teardown(conn: sqlite3.Connection) -> None:
+    """Filet de sécurité identique à db/connection.py::_track_for_teardown
+    (voir son commentaire pour le raisonnement complet) — dupliqué plutôt
+    qu'importé pour la même raison d'indépendance totale entre les deux
+    systèmes."""
+    try:
+        from flask import g, has_app_context
+    except ImportError:
+        return
+    if not has_app_context():
+        return
+    if not hasattr(g, "_forge_support_db_connections"):
+        g._forge_support_db_connections = []
+    g._forge_support_db_connections.append(conn)
+
+
+def install_support_teardown_safety_net(app: "Flask") -> None:
+    """Mirroir de db/connection.py::install_teardown_safety_net pour les
+    connexions support.db — appelé séparément par
+    core/db_teardown_guard.py."""
+
+    @app.teardown_request
+    def _close_leaked_support_connections(exception: BaseException | None = None) -> None:  # noqa: ARG001 - signature imposée par Flask
+        from flask import g
+
+        for conn in getattr(g, "_forge_support_db_connections", ()):
+            with contextlib.suppress(sqlite3.Error):
+                conn.close()

db/supports/support_dir.py

@@ -0,0 +1,19 @@
+import os
+
+from ..constants import PROJECTS_DIR
+from .support_slug import split_slug
+
+
+def support_dir(slug: str) -> str:
+    """projects/<owner_folder>/_supports/<project_part>/ — même principe
+    que db/games/game_dir.py (owner_folder encodé une seule fois, via le
+    chemin parent), `_supports/` sépare physiquement les supports des
+    jeux d'un même propriétaire (voir support_slug.py) : `db.list_games()`
+    scanne uniquement les enfants DIRECTS de projects/<owner_folder>/,
+    jamais ce sous-dossier, donc un support n'y apparaît jamais et
+    réciproquement."""
+    owner_folder, project_part = split_slug(slug)
+    if project_part is None:
+        msg = f"slug de support invalide (non composé) : {slug!r}"
+        raise ValueError(msg)
+    return os.path.join(PROJECTS_DIR, owner_folder, "_supports", project_part)

db/supports/support_meta.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+from .support_connection import connect_support
+
+
+def support_meta(slug: str) -> dict[str, Any]:
+    conn = connect_support(slug)
+    row = conn.execute("SELECT value FROM _meta WHERE key = 'name'").fetchone()
+    published_row = conn.execute("SELECT value FROM _meta WHERE key = 'published_at'").fetchone()
+    conn.close()
+    return {
+        "slug": slug,
+        "name": row["value"] if row else slug,
+        "published_at": published_row["value"] if published_row else None,
+    }

db/supports/support_path.py

@@ -0,0 +1,7 @@
+import os
+
+from .support_dir import support_dir
+
+
+def support_path(slug: str) -> str:
+    return os.path.join(support_dir(slug), "support.db")

db/supports/support_slug.py

@@ -0,0 +1,22 @@
+"""Convention de slug propre aux supports de formation — mirroir du
+principe de db/games/project_slug.py (slug composé "propriétaire_projet"),
+mais résolu vers un sous-espace totalement séparé (voir support_dir.py)
+pour qu'un support et un jeu du même propriétaire ne puissent jamais se
+collisionner sur un même nom de dossier, et pour qu'un support n'apparaisse
+jamais dans db.list_games() (qui ne scanne que le dossier propriétaire
+direct, jamais son sous-dossier _supports/)."""
+
+
+def build_slug(owner_folder: str, project_part: str) -> str:
+    return f"{owner_folder}_{project_part}"
+
+
+def split_slug(slug: str) -> tuple[str, str | None]:
+    """(owner_folder, project_part) si `slug` est bien composé, sinon
+    (slug, None) — même repli que db/games/project_slug.py, un support
+    n'a toutefois jamais vocation à exister sous forme "plate" (toujours
+    créé avec un owner_folder)."""
+    owner_folder, sep, project_part = slug.partition("_")
+    if not sep:
+        return slug, None
+    return owner_folder, project_part