Merge pull request #36 from maribakulj/claude/analyze-app-issues-MYBpt

CLAUDE.md

@@ -159,9 +159,12 @@ iiif-studio/
 ├── data/                            ← JAMAIS versionné (.gitignore)
 │   └── corpora/
 │       └── {corpus_slug}/
-│           ├── masters/             ← images sources originales
-│           ├── derivatives/         ← JPEG 1500px pour l'IA
-│           ├── thumbnails/          ← aperçus 300px
+│           ├── masters/             ← images uploadées (mode fichier uniquement)
+│           ├── derivatives/         ← JPEG 1500px (mode fichier uniquement)
+│           ├── thumbnails/          ← aperçus 300px (mode fichier uniquement)
+│           │   NOTE : en mode IIIF natif, masters/, derivatives/ et
+│           │   thumbnails/ sont VIDES — les images sont streamées
+│           │   depuis le serveur IIIF d'origine.
 │           ├── iiif/
 │           │   ├── manifest.json
 │           │   └── annotations/

backend/app/api/v1/ingest.py

@@ -144,6 +144,10 @@ async def _create_page(
     folio_label: str,
     sequence: int,
     image_master_path: str | None = None,
+    iiif_service_url: str | None = None,
+    canvas_width: int | None = None,
+    canvas_height: int | None = None,
+    manifest_url: str | None = None,
 ) -> PageModel | None:
     """Crée une page si elle n'existe pas déjà.  Retourne None si l'ID est déjà pris."""
     existing = await db.get(PageModel, page_id)
@@ -157,6 +161,10 @@ async def _create_page(
         folio_label=folio_label,
         sequence=sequence,
         image_master_path=image_master_path,
+        iiif_service_url=iiif_service_url,
+        canvas_width=canvas_width,
+        canvas_height=canvas_height,
+        manifest_url=manifest_url,
         processing_status="INGESTED",
     )
     db.add(page)
@@ -214,6 +222,78 @@ def _extract_canvas_label(canvas: dict, index: int) -> str:
     return f"f{index + 1:03d}r"
 
 
+# Pattern IIIF Image API : {service}/full/{size}/{rotation}/{quality}.{format}
+_IIIF_IMAGE_API_RE = re.compile(
+    r"^(https?://.+)/full/[^/]+/\d+/default\.\w+$"
+)
+
+
+def _extract_iiif_service(canvas: dict) -> tuple[str | None, int | None, int | None]:
+    """Détecte le IIIF Image Service d'un canvas et ses dimensions.
+
+    Retourne (service_url, canvas_width, canvas_height).
+    service_url est None si aucun service IIIF trouvé (image statique).
+    """
+    canvas_w = canvas.get("width")
+    canvas_h = canvas.get("height")
+
+    # ── IIIF 3.0 : body → service[] ─────────────────────────────────────
+    items = canvas.get("items") or []
+    if items:
+        ann_items = (items[0].get("items") or []) if items else []
+        if ann_items:
+            body = ann_items[0].get("body") or {}
+            if isinstance(body, dict):
+                # Chercher un service IIIF sur le body
+                services = body.get("service") or []
+                if isinstance(services, dict):
+                    services = [services]
+                for svc in services:
+                    svc_type = svc.get("type") or svc.get("@type") or ""
+                    if "ImageService" in svc_type:
+                        svc_url = (svc.get("id") or svc.get("@id") or "").rstrip("/")
+                        if svc_url:
+                            return svc_url, canvas_w, canvas_h
+
+                # Fallback : détecter le pattern Image API dans body.id
+                body_id = body.get("id") or body.get("@id") or ""
+                m = _IIIF_IMAGE_API_RE.match(body_id)
+                if m:
+                    return m.group(1), canvas_w, canvas_h
+
+    # ── IIIF 2.x : resource → service ───────────────────────────────────
+    images = canvas.get("images") or []
+    if images:
+        resource = images[0].get("resource") or {}
+        services = resource.get("service") or []
+        if isinstance(services, dict):
+            services = [services]
+        for svc in services:
+            svc_type = svc.get("@type") or svc.get("type") or ""
+            if "ImageService" in svc_type:
+                svc_url = (svc.get("@id") or svc.get("id") or "").rstrip("/")
+                if svc_url:
+                    return svc_url, canvas_w, canvas_h
+
+        # Fallback : pattern Image API dans resource @id
+        res_id = resource.get("@id") or resource.get("id") or ""
+        m = _IIIF_IMAGE_API_RE.match(res_id)
+        if m:
+            return m.group(1), canvas_w, canvas_h
+
+    return None, canvas_w, canvas_h
+
+
+def _detect_iiif_service_from_url(url: str) -> str | None:
+    """Tente de détecter une URL de service IIIF à partir d'une URL d'image directe.
+
+    Si l'URL suit le pattern IIIF Image API ({base}/full/{size}/{rot}/{qual}.{fmt}),
+    retourne la base. Sinon retourne None.
+    """
+    m = _IIIF_IMAGE_API_RE.match(url)
+    return m.group(1) if m else None
+
+
 def _extract_canvas_image_url(canvas: dict) -> str | None:
     """Extrait l'URL de l'image principale d'un canvas IIIF (3.0 ou 2.x)."""
     # IIIF 3.0
@@ -385,9 +465,14 @@ async def ingest_iiif_manifest(
         folio_label = labels[i]
         page_id = _make_page_id(corpus.slug, folio_label, seq + i, dupes)
         image_url = _extract_canvas_image_url(canvas)
+        service_url, c_width, c_height = _extract_iiif_service(canvas)
         page = await _create_page(
             db, ms.id, page_id, folio_label, seq + i,
             image_master_path=image_url,
+            iiif_service_url=service_url,
+            canvas_width=c_width,
+            canvas_height=c_height,
+            manifest_url=body.manifest_url,
         )
         if page is None:
             skipped += 1
@@ -406,7 +491,13 @@ async def ingest_iiif_manifest(
 
     logger.info(
         "Manifest IIIF ingéré",
-        extra={"corpus_id": corpus_id, "url": body.manifest_url, "created": len(created), "skipped": skipped},
+        extra={
+            "corpus_id": corpus_id,
+            "url": body.manifest_url,
+            "created": len(created),
+            "skipped": skipped,
+            "iiif_service_detected": sum(1 for p in created if p.iiif_service_url),
+        },
     )
     return IngestResponse(
         corpus_id=corpus_id,
@@ -446,9 +537,12 @@ async def ingest_iiif_images(
     skipped = 0
     for i, (url, folio_label) in enumerate(zip(body.urls, sanitized_labels)):
         page_id = _make_page_id(corpus.slug, folio_label, seq + i, dupes)
+        # Tenter de détecter un service IIIF à partir du pattern URL
+        service_url = _detect_iiif_service_from_url(url)
         page = await _create_page(
             db, ms.id, page_id, folio_label, seq + i,
             image_master_path=url,
+            iiif_service_url=service_url,
         )
         if page is None:
             skipped += 1

backend/app/api/v1/manuscripts.py

@@ -24,6 +24,10 @@ class PageResponse(BaseModel):
     folio_label: str
     sequence: int
     image_master_path: str | None
+    iiif_service_url: str | None = None
+    canvas_width: int | None = None
+    canvas_height: int | None = None
+    manifest_url: str | None = None
     processing_status: str
     confidence_summary: float | None
 

backend/app/api/v1/pages.py

@@ -64,6 +64,10 @@ class PageResponse(BaseModel):
     folio_label: str
     sequence: int
     image_master_path: str | None
+    iiif_service_url: str | None = None
+    canvas_width: int | None = None
+    canvas_height: int | None = None
+    manifest_url: str | None = None
     processing_status: str
     confidence_summary: float | None
 

backend/app/models/corpus.py

@@ -74,6 +74,10 @@ class PageModel(Base):
     folio_label: Mapped[str] = mapped_column(String, nullable=False)
     sequence: Mapped[int] = mapped_column(Integer, nullable=False)
     image_master_path: Mapped[str | None] = mapped_column(Text, nullable=True)
+    iiif_service_url: Mapped[str | None] = mapped_column(Text, nullable=True)
+    canvas_width: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    canvas_height: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    manifest_url: Mapped[str | None] = mapped_column(Text, nullable=True)
     processing_status: Mapped[str] = mapped_column(
         String, nullable=False, default="CREATED"
     )

backend/app/schemas/image.py

@@ -1,12 +1,19 @@
 """
-Schéma Pydantic pour les métadonnées du dérivé image produit par le pipeline.
+Schémas Pydantic pour les métadonnées image du pipeline.
+
+Deux schémas coexistent :
+- ImageDerivativeInfo : dérivés stockés sur disque (upload de fichiers)
+- ImageSourceInfo     : source IIIF sans stockage local (mode natif)
 """
 # 2. third-party
 from pydantic import BaseModel
 
 
 class ImageDerivativeInfo(BaseModel):
-    """Résultat de la normalisation d'une image : dimensions originales et chemins des dérivés."""
+    """Résultat de la normalisation d'une image : dimensions originales et chemins des dérivés.
+
+    Utilisé pour les images uploadées via /ingest/files (stockage local).
+    """
 
     original_url: str
     original_width: int
@@ -17,3 +24,19 @@ class ImageDerivativeInfo(BaseModel):
     thumbnail_path: str
     thumbnail_width: int
     thumbnail_height: int
+
+
+class ImageSourceInfo(BaseModel):
+    """Source d'image IIIF — pas de stockage local.
+
+    Utilisé pour les images ingérées via manifest ou URLs IIIF.
+    Les bytes ne sont jamais écrits sur disque : téléchargés en RAM
+    pour l'IA, puis jetés.
+    """
+
+    original_url: str                     # URL statique de l'image (fallback)
+    iiif_service_url: str | None = None   # URL du service IIIF Image API
+    manifest_url: str | None = None       # URL du manifest source
+    is_iiif: bool = False                 # a un IIIF Image Service détecté ?
+    original_width: int
+    original_height: int

backend/app/schemas/page_master.py

@@ -38,14 +38,23 @@ class Region(BaseModel):
 
 
 class ImageInfo(BaseModel):
-    """Métadonnées image — CLAUDE.md §4.2."""
-
-    master: str
-    derivative_web: str | None = None
-    thumbnail: str | None = None
-    iiif_base: str | None = None
-    width: int
-    height: int
+    """Métadonnées image — CLAUDE.md §4.2.
+
+    Supporte deux modes :
+    - IIIF natif : iiif_service_url renseigné, images streamées depuis le serveur
+      d'origine (pas de stockage local). derivative_web / thumbnail = None.
+    - Upload local : master = chemin local, derivative_web / thumbnail = chemins
+      des dérivés sur disque (mode legacy ou upload de fichiers).
+    """
+
+    master: str                           # URL source (service IIIF ou statique) ou chemin local
+    derivative_web: str | None = None     # chemin dérivé 1500px (legacy/upload)
+    thumbnail: str | None = None          # chemin thumbnail 256px (legacy/upload)
+    iiif_base: str | None = None          # compat arrière
+    iiif_service_url: str | None = None   # URL du IIIF Image Service (zoom tuilé)
+    manifest_url: str | None = None       # URL du manifest source (provenance)
+    width: int                            # largeur du canvas original
+    height: int                           # hauteur du canvas original
 
 
 class OCRResult(BaseModel):

backend/app/services/ai/analyzer.py

@@ -11,7 +11,7 @@ from pathlib import Path
 
 # 3. local
 from app.schemas.corpus_profile import CorpusProfile
-from app.schemas.image import ImageDerivativeInfo
+from app.schemas.image import ImageDerivativeInfo, ImageSourceInfo
 from app.schemas.model_config import ModelConfig
 from app.schemas.page_master import EditorialInfo, EditorialStatus, ImageInfo, PageMaster, ProcessingInfo
 from app.services.ai.master_writer import write_ai_raw, write_master_json
@@ -22,8 +22,32 @@ from app.services.ai.response_parser import ParseError, parse_ai_response  # noq
 logger = logging.getLogger(__name__)
 
 
+def _scale_bbox_coordinates(layout: dict, scale_x: float, scale_y: float) -> dict:
+    """Met à l'échelle les bbox de l'espace dérivé vers l'espace canvas original.
+
+    L'IA analyse un dérivé 1500px mais les coordonnées dans master.json
+    doivent être en pixels absolus du canvas original (convention IIIF).
+    """
+    if abs(scale_x - 1.0) < 0.01 and abs(scale_y - 1.0) < 0.01:
+        return layout  # pas de scaling nécessaire
+
+    regions = layout.get("regions", [])
+    for region in regions:
+        bbox = region.get("bbox")
+        if bbox and len(bbox) == 4:
+            region["bbox"] = [
+                round(bbox[0] * scale_x),
+                round(bbox[1] * scale_y),
+                round(bbox[2] * scale_x),
+                round(bbox[3] * scale_y),
+            ]
+    return layout
+
+
 def run_primary_analysis(
-    derivative_image_path: Path,
+    *,
+    derivative_image_bytes: bytes | None = None,
+    derivative_image_path: Path | None = None,
     corpus_profile: CorpusProfile,
     model_config: ModelConfig,
     page_id: str,
@@ -31,38 +55,22 @@ def run_primary_analysis(
     corpus_slug: str,
     folio_label: str,
     sequence: int,
-    image_info: ImageDerivativeInfo,
+    image_info: ImageDerivativeInfo | ImageSourceInfo,
+    derivative_width: int | None = None,
+    derivative_height: int | None = None,
     base_data_dir: Path = Path("data"),
     project_root: Path = Path("."),
 ) -> PageMaster:
     """Analyse primaire d'un folio : charge le prompt, appelle l'IA, écrit les fichiers.
 
-    Respecte R05 : ai_raw.json est toujours écrit en premier, même en cas
-    d'erreur de parsing. master.json n'est écrit QUE si le parsing a réussi.
-
-    Le provider est sélectionné dynamiquement depuis model_config.provider ;
-    Google AI Studio, Vertex et Mistral sont supportés de façon identique.
-
-    Args:
-        derivative_image_path: chemin vers le JPEG dérivé (1500px max).
-        corpus_profile: profil du corpus (pilote le prompt et les layers).
-        model_config: configuration du modèle sélectionné (provider + model_id).
-        page_id: identifiant unique de la page (ex. "beatus-lat8878-0013r").
-        manuscript_id: identifiant du manuscrit.
-        corpus_slug: identifiant du corpus (ex. "beatus-lat8878").
-        folio_label: label du folio (ex. "0013r").
-        sequence: numéro de séquence dans le manuscrit.
-        image_info: métadonnées de l'image normalisée (dimensions, chemins).
-        base_data_dir: racine du dossier data.
-        project_root: racine du projet (pour résoudre les chemins des prompts).
-
-    Returns:
-        PageMaster validé (ai_raw.json et master.json écrits sur disque).
-
-    Raises:
-        ParseError: si la réponse IA n'est pas un JSON valide.
-        FileNotFoundError: si le template de prompt est introuvable.
-        RuntimeError: si le provider n'est pas configuré (variable d'env absente).
+    Supporte deux modes :
+    - IIIF natif : derivative_image_bytes fourni (bytes en RAM, jamais sur disque)
+    - Legacy : derivative_image_path fourni (chemin fichier sur disque)
+
+    Respecte R05 : ai_raw.json toujours écrit en premier.
+
+    Si les dimensions originales (canvas) diffèrent du dérivé, les bbox sont
+    mises à l'échelle de l'espace dérivé vers l'espace canvas original.
     """
     # ── Chemins de sortie ───────────────────────────────────────────────────
     page_dir = base_data_dir / "corpora" / corpus_slug / "pages" / folio_label
@@ -85,13 +93,18 @@ def run_primary_analysis(
         extra={"template": prompt_rel_path, "corpus": corpus_slug, "folio": folio_label},
     )
 
-    # ── 2. Chargement de l'image dérivée ────────────────────────────────────
-    if not derivative_image_path.exists():
-        raise FileNotFoundError(f"Image dérivée introuvable : {derivative_image_path}")
-    try:
-        jpeg_bytes = derivative_image_path.read_bytes()
-    except OSError as exc:
-        raise RuntimeError(f"Erreur lecture image {derivative_image_path} : {exc}") from exc
+    # ── 2. Obtention des bytes image ────────────────────────────────────────
+    if derivative_image_bytes is not None:
+        jpeg_bytes = derivative_image_bytes
+    elif derivative_image_path is not None:
+        if not derivative_image_path.exists():
+            raise FileNotFoundError(f"Image dérivée introuvable : {derivative_image_path}")
+        try:
+            jpeg_bytes = derivative_image_path.read_bytes()
+        except OSError as exc:
+            raise RuntimeError(f"Erreur lecture image {derivative_image_path} : {exc}") from exc
+    else:
+        raise ValueError("Il faut fournir derivative_image_bytes ou derivative_image_path")
 
     # ── 3. Appel IA via le provider sélectionné ─────────────────────────────
     provider = get_provider(model_config.provider)
@@ -116,21 +129,45 @@ def run_primary_analysis(
     # ── 5. Parsing + validation (ParseError si JSON invalide) ───────────────
     layout, ocr = parse_ai_response(raw_text)
 
+    # ── 5b. Scaling bbox si les dimensions originales diffèrent du dérivé ──
+    is_iiif_source = isinstance(image_info, ImageSourceInfo)
+    original_w = image_info.original_width
+    original_h = image_info.original_height
+    deriv_w = derivative_width or (getattr(image_info, "derivative_width", None)) or original_w
+    deriv_h = derivative_height or (getattr(image_info, "derivative_height", None)) or original_h
+
+    if original_w > 0 and deriv_w > 0 and (original_w != deriv_w or original_h != deriv_h):
+        scale_x = original_w / deriv_w
+        scale_y = original_h / deriv_h
+        layout = _scale_bbox_coordinates(layout, scale_x, scale_y)
+
     # ── 6. Construction du PageMaster ───────────────────────────────────────
     processed_at = datetime.now(tz=timezone.utc)
+
+    if is_iiif_source:
+        image_block = ImageInfo(
+            master=image_info.original_url,
+            iiif_service_url=image_info.iiif_service_url,
+            manifest_url=image_info.manifest_url,
+            width=original_w,
+            height=original_h,
+        )
+    else:
+        image_block = ImageInfo(
+            master=image_info.original_url,
+            derivative_web=getattr(image_info, "derivative_path", None),
+            thumbnail=getattr(image_info, "thumbnail_path", None),
+            width=original_w,
+            height=original_h,
+        )
+
     page_master = PageMaster(
         page_id=page_id,
         corpus_profile=corpus_profile.profile_id,
         manuscript_id=manuscript_id,
         folio_label=folio_label,
         sequence=sequence,
-        image=ImageInfo(
-            master=image_info.original_url,
-            derivative_web=image_info.derivative_path,
-            thumbnail=image_info.thumbnail_path,
-            width=image_info.derivative_width,
-            height=image_info.derivative_height,
-        ),
+        image=image_block,
         layout=layout,
         ocr=ocr,
         processing=ProcessingInfo(
@@ -154,6 +191,7 @@ def run_primary_analysis(
             "corpus": corpus_slug,
             "folio": folio_label,
             "regions": len(layout.get("regions", [])),
+            "iiif_native": is_iiif_source,
         },
     )
     return page_master

backend/app/services/export/alto.py

@@ -160,7 +160,7 @@ def generate_alto(master: PageMaster) -> str:
     etree.SubElement(desc, _a("MeasurementUnit")).text = "pixel"
 
     src_info = etree.SubElement(desc, _a("sourceImageInformation"))
-    file_name = master.image.master or master.image.derivative_web or master.page_id
+    file_name = master.image.iiif_service_url or master.image.master or master.image.derivative_web or master.page_id
     etree.SubElement(src_info, _a("fileName")).text = str(file_name)
 
     if master.processing:

backend/app/services/export/iiif.py

@@ -108,6 +108,23 @@ def generate_manifest(
         annotation_page_id = f"{canvas_id}/annotation-page/1"
         annotation_id      = f"{canvas_id}/annotation/painting"
         image_url          = page.image.master or ""
+        iiif_svc           = page.image.iiif_service_url
+
+        # Corps de l'annotation painting
+        body: dict = {
+            "id":     image_url,
+            "type":   "Image",
+            "format": "image/jpeg",
+            "width":  width,
+            "height": height,
+        }
+        # Si un IIIF Image Service est connu, le déclarer (zoom tuilé natif)
+        if iiif_svc:
+            body["service"] = [{
+                "id":      iiif_svc,
+                "type":    "ImageService3",
+                "profile": "level2",
+            }]
 
         canvas: dict = {
             "id":     canvas_id,
@@ -124,14 +141,8 @@ def generate_manifest(
                             "id":         annotation_id,
                             "type":       "Annotation",
                             "motivation": "painting",
-                            "body": {
-                                "id":     image_url,
-                                "type":   "Image",
-                                "format": "image/jpeg",
-                                "width":  width,
-                                "height": height,
-                            },
-                            "target": canvas_id,
+                            "body":       body,
+                            "target":     canvas_id,
                         }
                     ],
                 }

backend/app/services/export/mets.py

@@ -178,20 +178,28 @@ def generate_mets(
     for page in pages:
         sid = _safe_id(page.page_id)
 
-        # master image
+        # master image (IIIF service URL ou URL statique)
+        master_url = page.image.iiif_service_url or page.image.master or ""
+        if page.image.iiif_service_url:
+            master_url = f"{page.image.iiif_service_url}/full/max/0/default.jpg"
         f_master = _el(grp_master, f"{_M}file", {"ID": f"IMG_MASTER_{sid}", "MIMETYPE": "image/jpeg"})
         _el(f_master, f"{_M}FLocat", {
             "LOCTYPE": "URL",
-            f"{_XL}href": page.image.master or "",
+            f"{_XL}href": master_url,
             f"{_XL}type": "simple",
         })
 
-        # dérivé web
+        # dérivé web (URL IIIF 1500px ou chemin local legacy)
+        if page.image.iiif_service_url:
+            deriv_href = f"{page.image.iiif_service_url}/full/!1500,1500/0/default.jpg"
+            deriv_loctype_attrs = {"LOCTYPE": "URL"}
+        else:
+            deriv_href = page.image.derivative_web or ""
+            deriv_loctype_attrs = {"LOCTYPE": "OTHER", "OTHERLOCTYPE": "filepath"}
         f_deriv = _el(grp_deriv, f"{_M}file", {"ID": f"IMG_DERIV_{sid}", "MIMETYPE": "image/jpeg"})
         _el(f_deriv, f"{_M}FLocat", {
-            "LOCTYPE": "OTHER",
-            "OTHERLOCTYPE": "filepath",
-            f"{_XL}href": page.image.derivative_web or "",
+            **deriv_loctype_attrs,
+            f"{_XL}href": deriv_href,
             f"{_XL}type": "simple",
         })
 

backend/app/services/image/normalizer.py

@@ -143,3 +143,55 @@ def fetch_and_normalize(
     """
     source_bytes = fetch_iiif_image(url)
     return create_derivatives(source_bytes, url, corpus_slug, folio_label, base_data_dir)
+
+
+# ── Mode IIIF natif : images en mémoire, jamais sur disque ───────────────────
+
+def fetch_ai_derivative_bytes(
+    iiif_service_url: str | None,
+    fallback_url: str | None,
+) -> tuple[bytes, int, int]:
+    """Retourne (jpeg_bytes, width, height) pour l'IA — jamais sauvé sur disque.
+
+    - Si iiif_service_url est fourni : utilise l'IIIF Image API pour demander
+      au serveur un dérivé 1500px directement redimensionné côté serveur.
+    - Sinon (fallback_url) : télécharge l'image complète et redimensionne
+      en mémoire.
+
+    Returns:
+        Tuple (jpeg_bytes, derivative_width, derivative_height).
+
+    Raises:
+        ValueError: si aucune source n'est fournie.
+        httpx.HTTPStatusError: si le serveur retourne une erreur.
+    """
+    from app.services.ingest.iiif_fetcher import fetch_iiif_derivative, fetch_iiif_image
+
+    if iiif_service_url:
+        raw_bytes = fetch_iiif_derivative(iiif_service_url, max_px=_MAX_DERIVATIVE_PX)
+    elif fallback_url:
+        raw_bytes = fetch_iiif_image(fallback_url)
+    else:
+        raise ValueError("Aucune source image fournie (ni iiif_service_url ni fallback_url)")
+
+    # Ouvrir en mémoire pour obtenir les dimensions (et redimensionner si fallback)
+    image = Image.open(io.BytesIO(raw_bytes))
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+
+    if not iiif_service_url:
+        # Fallback : le serveur n'a pas redimensionné, on le fait en mémoire
+        image = _resize_to_max(image, _MAX_DERIVATIVE_PX)
+
+    w, h = image.size
+
+    # Encoder en JPEG en mémoire
+    buf = io.BytesIO()
+    image.save(buf, format="JPEG", quality=_DERIVATIVE_QUALITY)
+    jpeg_bytes = buf.getvalue()
+
+    logger.info(
+        "Dérivé IA en mémoire",
+        extra={"iiif": bool(iiif_service_url), "size": f"{w}x{h}", "bytes": len(jpeg_bytes)},
+    )
+    return jpeg_bytes, w, h

backend/app/services/ingest/iiif_fetcher.py

@@ -48,3 +48,38 @@ def fetch_iiif_image(url: str, timeout: float = _DEFAULT_TIMEOUT) -> bytes:
         extra={"url": url, "size_bytes": len(response.content)},
     )
     return response.content
+
+
+def fetch_iiif_derivative(
+    service_url: str,
+    max_px: int = 1500,
+    timeout: float = _DEFAULT_TIMEOUT,
+) -> bytes:
+    """Télécharge un dérivé via l'IIIF Image API — jamais stocké sur disque.
+
+    Construit l'URL : {service_url}/full/!{max_px},{max_px}/0/default.jpg
+    Le serveur IIIF retourne une image redimensionnée côté serveur.
+
+    Args:
+        service_url: URL du IIIF Image Service (sans le suffix /full/.../default.jpg).
+        max_px: taille max du grand côté (défaut : 1500).
+        timeout: délai maximal en secondes.
+
+    Returns:
+        Contenu brut de l'image JPEG en bytes.
+    """
+    # Pattern IIIF Image API : !w,h = "best fit" (le serveur choisit)
+    derivative_url = f"{service_url.rstrip('/')}/full/!{max_px},{max_px}/0/default.jpg"
+    logger.info("Fetching IIIF derivative", extra={"url": derivative_url, "max_px": max_px})
+    response = httpx.get(
+        derivative_url,
+        headers=_HEADERS,
+        follow_redirects=True,
+        timeout=httpx.Timeout(timeout, connect=10.0),
+    )
+    response.raise_for_status()
+    logger.info(
+        "IIIF derivative fetched",
+        extra={"url": derivative_url, "size_bytes": len(response.content)},
+    )
+    return response.content

backend/app/services/job_runner.py

@@ -32,8 +32,13 @@ from app.models.database import async_session_factory
 from app.models.job import JobModel
 from app.models.model_config_db import ModelConfigDB
 from app.schemas.corpus_profile import CorpusProfile
+from app.schemas.image import ImageSourceInfo
 from app.schemas.model_config import ModelConfig, ProviderType
-from app.services.image.normalizer import create_derivatives, fetch_and_normalize
+from app.services.image.normalizer import (
+    create_derivatives,
+    fetch_ai_derivative_bytes,
+    fetch_and_normalize,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -126,19 +131,65 @@ async def _run_job_impl(job_id: str, db: AsyncSession) -> None:
             available_models=[],
         )
 
-        # ── 5. Normaliser l'image ────────────────────────────────────────────
+        # ── 5. Obtenir l'image pour l'IA ─────────────────────────────────────
         data_dir = _config_module.settings.data_dir
         image_source = page.image_master_path or ""
 
-        if image_source.startswith(("http://", "https://")):
+        from app.services.ai.analyzer import run_primary_analysis
+
+        if page.iiif_service_url:
+            # ── Mode IIIF natif : fetch en mémoire, zéro stockage ────────────
+            deriv_bytes, deriv_w, deriv_h = fetch_ai_derivative_bytes(
+                iiif_service_url=page.iiif_service_url,
+                fallback_url=None,
+            )
+            image_source_info = ImageSourceInfo(
+                original_url=image_source or page.iiif_service_url,
+                iiif_service_url=page.iiif_service_url,
+                manifest_url=page.manifest_url,
+                is_iiif=True,
+                original_width=page.canvas_width or deriv_w,
+                original_height=page.canvas_height or deriv_h,
+            )
+
+            # ── 6. Analyse primaire IA (R05 : double stockage) ───────────────
+            page_master = run_primary_analysis(
+                derivative_image_bytes=deriv_bytes,
+                derivative_width=deriv_w,
+                derivative_height=deriv_h,
+                corpus_profile=corpus_profile,
+                model_config=model_config,
+                page_id=page.id,
+                manuscript_id=manuscript.id,
+                corpus_slug=corpus.slug,
+                folio_label=page.folio_label,
+                sequence=page.sequence,
+                image_info=image_source_info,
+                base_data_dir=data_dir,
+                project_root=_PROJECT_ROOT,
+            )
+
+        elif image_source.startswith(("http://", "https://")):
+            # ── Mode fallback URL : télécharge + stocke sur disque (legacy) ──
             image_info = fetch_and_normalize(
                 image_source, corpus.slug, page.folio_label, data_dir
             )
+            page_master = run_primary_analysis(
+                derivative_image_path=Path(image_info.derivative_path),
+                corpus_profile=corpus_profile,
+                model_config=model_config,
+                page_id=page.id,
+                manuscript_id=manuscript.id,
+                corpus_slug=corpus.slug,
+                folio_label=page.folio_label,
+                sequence=page.sequence,
+                image_info=image_info,
+                base_data_dir=data_dir,
+                project_root=_PROJECT_ROOT,
+            )
+
         elif image_source:
-            # Validation anti path-traversal : le chemin résolu doit être
-            # sous data_dir. Empêche la lecture de fichiers arbitraires
-            # si image_master_path contient des séquences ../ ou un
-            # chemin absolu hors du répertoire de données.
+            # ── Mode fichier local (upload) ──────────────────────────────────
             source_path = Path(image_source).resolve()
             data_dir_resolved = data_dir.resolve()
             if not str(source_path).startswith(str(data_dir_resolved) + "/") and source_path != data_dir_resolved:
@@ -150,29 +201,26 @@ async def _run_job_impl(job_id: str, db: AsyncSession) -> None:
             image_info = create_derivatives(
                 source_bytes, image_source, corpus.slug, page.folio_label, data_dir
             )
+            page_master = run_primary_analysis(
+                derivative_image_path=Path(image_info.derivative_path),
+                corpus_profile=corpus_profile,
+                model_config=model_config,
+                page_id=page.id,
+                manuscript_id=manuscript.id,
+                corpus_slug=corpus.slug,
+                folio_label=page.folio_label,
+                sequence=page.sequence,
+                image_info=image_info,
+                base_data_dir=data_dir,
+                project_root=_PROJECT_ROOT,
+            )
+
         else:
             raise ValueError(
                 f"La page {page.id} n'a pas d'image source "
-                "(image_master_path vide ou None)"
+                "(ni iiif_service_url, ni image_master_path)"
             )
 
-        # ── 6. Analyse primaire IA (R05 : double stockage) ───────────────────
-        from app.services.ai.analyzer import run_primary_analysis
-
-        page_master = run_primary_analysis(
-            derivative_image_path=Path(image_info.derivative_path),
-            corpus_profile=corpus_profile,
-            model_config=model_config,
-            page_id=page.id,
-            manuscript_id=manuscript.id,
-            corpus_slug=corpus.slug,
-            folio_label=page.folio_label,
-            sequence=page.sequence,
-            image_info=image_info,
-            base_data_dir=data_dir,
-            project_root=_PROJECT_ROOT,
-        )
-
         # ── 7. Générer et écrire l'ALTO XML ──────────────────────────────────
         from app.services.export.alto import generate_alto, write_alto
 

backend/tests/test_ai_analyzer.py

@@ -663,8 +663,9 @@ def test_run_primary_analysis_image_dict(tmp_path):
         )
 
     assert result.image.master == image_info.original_url
-    assert result.image.width == image_info.derivative_width
-    assert result.image.height == image_info.derivative_height
+    # L'analyzer stocke désormais les dimensions originales (pas celles du dérivé)
+    assert result.image.width == image_info.original_width
+    assert result.image.height == image_info.original_height
 
 
 def test_run_primary_analysis_regions_in_layout(tmp_path):
@@ -866,3 +867,98 @@ def test_run_primary_analysis_invalid_region_skipped(tmp_path):
 
     assert len(result.layout["regions"]) == 1
     assert result.layout["regions"][0]["id"] == "r_good"
+
+
+# ---------------------------------------------------------------------------
+# Mode IIIF natif — bytes en mémoire
+# ---------------------------------------------------------------------------
+
+from app.schemas.image import ImageSourceInfo
+
+
+def _make_image_source_info() -> ImageSourceInfo:
+    return ImageSourceInfo(
+        original_url="https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29/full/max/0/default.jpg",
+        iiif_service_url="https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29",
+        manifest_url="https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/manifest.json",
+        is_iiif=True,
+        original_width=3543,
+        original_height=4724,
+    )
+
+
+def test_run_primary_analysis_iiif_bytes_mode(tmp_path):
+    """Mode IIIF natif : passe des bytes directement, pas de chemin fichier."""
+    prompt_rel = "prompts/medieval-illuminated/primary_v1.txt"
+    _setup_prompt_file(tmp_path, prompt_rel)
+
+    jpeg_bytes = _make_jpeg_bytes(200, 300)
+    mock_provider = _make_mock_provider(_valid_ai_json())
+
+    with patch("app.services.ai.analyzer.get_provider", return_value=mock_provider):
+        result = run_primary_analysis(
+            derivative_image_bytes=jpeg_bytes,
+            derivative_width=200,
+            derivative_height=300,
+            corpus_profile=_make_corpus_profile(prompt_rel_path=prompt_rel),
+            model_config=_make_model_config(),
+            page_id="test-iiif-0001r",
+            manuscript_id="ms-test",
+            corpus_slug="test-corpus",
+            folio_label="0001r",
+            sequence=1,
+            image_info=_make_image_source_info(),
+            base_data_dir=tmp_path / "data",
+            project_root=tmp_path,
+        )
+
+    assert result.image.iiif_service_url == "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29"
+    assert result.image.manifest_url is not None
+    assert result.image.derivative_web is None
+    assert result.image.width == 3543  # dimensions originales, pas dérivé
+    assert result.image.height == 4724
+
+
+def test_run_primary_analysis_iiif_bbox_scaling(tmp_path):
+    """Les bbox sont mises à l'échelle du dérivé vers le canvas original."""
+    prompt_rel = "prompts/medieval-illuminated/primary_v1.txt"
+    _setup_prompt_file(tmp_path, prompt_rel)
+
+    # Image source : 4000x6000 original, dérivé 1000x1500
+    source_info = ImageSourceInfo(
+        original_url="https://example.com/img",
+        iiif_service_url="https://example.com/img",
+        is_iiif=True,
+        original_width=4000,
+        original_height=6000,
+    )
+
+    # Réponse IA avec bbox dans l'espace du dérivé (1000x1500)
+    ai_response = json.dumps({
+        "layout": {"regions": [
+            {"id": "r1", "type": "text_block", "bbox": [100, 200, 500, 300], "confidence": 0.9},
+        ]},
+        "ocr": {"diplomatic_text": "test", "language": "la", "confidence": 0.8},
+    })
+    mock_provider = _make_mock_provider(ai_response)
+
+    with patch("app.services.ai.analyzer.get_provider", return_value=mock_provider):
+        result = run_primary_analysis(
+            derivative_image_bytes=_make_jpeg_bytes(100, 150),
+            derivative_width=1000,
+            derivative_height=1500,
+            corpus_profile=_make_corpus_profile(prompt_rel_path=prompt_rel),
+            model_config=_make_model_config(),
+            page_id="test-scale-0001r",
+            manuscript_id="ms-test",
+            corpus_slug="test-corpus",
+            folio_label="0001r",
+            sequence=1,
+            image_info=source_info,
+            base_data_dir=tmp_path / "data",
+            project_root=tmp_path,
+        )
+
+    # Scale factor : 4000/1000 = 4.0, 6000/1500 = 4.0
+    bbox = result.layout["regions"][0]["bbox"]
+    assert bbox == [400, 800, 2000, 1200]  # 100*4, 200*4, 500*4, 300*4

backend/tests/test_iiif_service_detection.py

@@ -0,0 +1,247 @@
+"""
+Tests de détection du IIIF Image Service à l'ingestion.
+
+Vérifie :
+- Extraction depuis un canvas IIIF 3.0 avec ImageService3
+- Extraction depuis un canvas IIIF 2.x avec service @id
+- Détection par pattern URL (Gallica, etc.)
+- Fallback quand aucun service n'est trouvé
+- Détection depuis URL directe (ingest/iiif-images)
+"""
+import pytest
+
+from app.api.v1.ingest import (
+    _detect_iiif_service_from_url,
+    _extract_iiif_service,
+)
+
+
+# ---------------------------------------------------------------------------
+# _extract_iiif_service — IIIF 3.0
+# ---------------------------------------------------------------------------
+
+def test_extract_iiif3_with_image_service3():
+    """Canvas IIIF 3.0 avec service ImageService3 explicite."""
+    canvas = {
+        "width": 3543,
+        "height": 4724,
+        "items": [{
+            "items": [{
+                "body": {
+                    "id": "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29/full/max/0/default.jpg",
+                    "type": "Image",
+                    "service": [{
+                        "id": "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29",
+                        "type": "ImageService3",
+                        "profile": "level2",
+                    }],
+                },
+            }],
+        }],
+    }
+    svc_url, w, h = _extract_iiif_service(canvas)
+    assert svc_url == "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29"
+    assert w == 3543
+    assert h == 4724
+
+
+def test_extract_iiif3_with_image_service2():
+    """Canvas IIIF 3.0 avec un service de type ImageService2."""
+    canvas = {
+        "width": 2000,
+        "height": 3000,
+        "items": [{
+            "items": [{
+                "body": {
+                    "id": "https://example.com/image/1/full/max/0/default.jpg",
+                    "type": "Image",
+                    "service": [{
+                        "id": "https://example.com/image/1",
+                        "type": "ImageService2",
+                        "profile": "level1",
+                    }],
+                },
+            }],
+        }],
+    }
+    svc_url, w, h = _extract_iiif_service(canvas)
+    assert svc_url == "https://example.com/image/1"
+    assert w == 2000
+
+
+def test_extract_iiif3_service_as_dict():
+    """Le champ service peut être un dict au lieu d'une liste."""
+    canvas = {
+        "width": 1000,
+        "height": 1500,
+        "items": [{
+            "items": [{
+                "body": {
+                    "id": "https://example.com/img/full/max/0/default.jpg",
+                    "service": {
+                        "id": "https://example.com/img",
+                        "type": "ImageService3",
+                    },
+                },
+            }],
+        }],
+    }
+    svc_url, _, _ = _extract_iiif_service(canvas)
+    assert svc_url == "https://example.com/img"
+
+
+def test_extract_iiif3_fallback_url_pattern():
+    """Sans service explicite, détecte le pattern Image API dans body.id."""
+    canvas = {
+        "width": 3000,
+        "height": 4000,
+        "items": [{
+            "items": [{
+                "body": {
+                    "id": "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29/full/max/0/default.jpg",
+                    "type": "Image",
+                    # Pas de "service" !
+                },
+            }],
+        }],
+    }
+    svc_url, w, h = _extract_iiif_service(canvas)
+    assert svc_url == "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29"
+    assert w == 3000
+
+
+def test_extract_iiif3_no_service_no_pattern():
+    """Canvas sans service et sans pattern Image API → None."""
+    canvas = {
+        "width": 800,
+        "height": 600,
+        "items": [{
+            "items": [{
+                "body": {
+                    "id": "https://example.com/static/page1.jpg",
+                    "type": "Image",
+                },
+            }],
+        }],
+    }
+    svc_url, w, h = _extract_iiif_service(canvas)
+    assert svc_url is None
+    assert w == 800
+    assert h == 600
+
+
+# ---------------------------------------------------------------------------
+# _extract_iiif_service — IIIF 2.x
+# ---------------------------------------------------------------------------
+
+def test_extract_iiif2_with_service():
+    """Canvas IIIF 2.x avec service dans resource."""
+    canvas = {
+        "width": 4000,
+        "height": 5000,
+        "images": [{
+            "resource": {
+                "@id": "https://example.com/image/2/full/full/0/default.jpg",
+                "service": {
+                    "@id": "https://example.com/image/2",
+                    "@type": "ImageService2",
+                },
+            },
+        }],
+    }
+    svc_url, w, h = _extract_iiif_service(canvas)
+    assert svc_url == "https://example.com/image/2"
+    assert w == 4000
+
+
+def test_extract_iiif2_fallback_url_pattern():
+    """IIIF 2.x : détection par pattern dans resource @id."""
+    canvas = {
+        "width": 2500,
+        "height": 3500,
+        "images": [{
+            "resource": {
+                "@id": "https://iiif.bodleian.ox.ac.uk/image/abc123/full/full/0/default.jpg",
+            },
+        }],
+    }
+    svc_url, _, _ = _extract_iiif_service(canvas)
+    assert svc_url == "https://iiif.bodleian.ox.ac.uk/image/abc123"
+
+
+def test_extract_iiif2_no_service():
+    """IIIF 2.x sans service et URL statique → None."""
+    canvas = {
+        "width": 1200,
+        "height": 1600,
+        "images": [{
+            "resource": {
+                "@id": "https://example.com/images/scan.png",
+            },
+        }],
+    }
+    svc_url, w, h = _extract_iiif_service(canvas)
+    assert svc_url is None
+    assert w == 1200
+
+
+# ---------------------------------------------------------------------------
+# _extract_iiif_service — cas limites
+# ---------------------------------------------------------------------------
+
+def test_extract_empty_canvas():
+    """Canvas vide → None sans crash."""
+    svc_url, w, h = _extract_iiif_service({})
+    assert svc_url is None
+    assert w is None
+    assert h is None
+
+
+def test_extract_service_url_trailing_slash_stripped():
+    """L'URL du service ne doit pas se terminer par /."""
+    canvas = {
+        "width": 1000,
+        "height": 1000,
+        "items": [{
+            "items": [{
+                "body": {
+                    "id": "https://example.com/img/full/max/0/default.jpg",
+                    "service": [{
+                        "id": "https://example.com/img/",
+                        "type": "ImageService3",
+                    }],
+                },
+            }],
+        }],
+    }
+    svc_url, _, _ = _extract_iiif_service(canvas)
+    assert svc_url == "https://example.com/img"
+    assert not svc_url.endswith("/")
+
+
+# ---------------------------------------------------------------------------
+# _detect_iiif_service_from_url — détection depuis URL directe
+# ---------------------------------------------------------------------------
+
+def test_detect_from_gallica_url():
+    """URL Gallica complète → service URL déduit."""
+    url = "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29/full/max/0/default.jpg"
+    assert _detect_iiif_service_from_url(url) == "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29"
+
+
+def test_detect_from_iiif_url_with_size():
+    """URL avec taille spécifique → service URL déduit."""
+    url = "https://example.com/iiif/img1/full/!1500,1500/0/default.jpg"
+    assert _detect_iiif_service_from_url(url) == "https://example.com/iiif/img1"
+
+
+def test_detect_from_static_url_returns_none():
+    """URL statique (pas de pattern IIIF) → None."""
+    url = "https://example.com/images/page1.jpg"
+    assert _detect_iiif_service_from_url(url) is None
+
+
+def test_detect_from_iiif_url_different_format():
+    """URL avec format PNG au lieu de JPEG."""
+    url = "https://example.com/iiif/img2/full/max/0/default.png"
+    assert _detect_iiif_service_from_url(url) == "https://example.com/iiif/img2"

backend/tests/test_schemas.py

@@ -300,3 +300,85 @@ def test_annotation_layer_all_layer_types():
             created_at=datetime(2026, 3, 16, tzinfo=timezone.utc),
         )
         assert layer.layer_type == layer_type
+
+
+# ---------------------------------------------------------------------------
+# ImageInfo — compatibilité arrière et champs IIIF natifs
+# ---------------------------------------------------------------------------
+
+from app.schemas.page_master import ImageInfo
+from app.schemas.image import ImageSourceInfo
+
+
+def test_image_info_backward_compat_without_iiif_fields():
+    """Un ImageInfo sans les nouveaux champs IIIF doit toujours valider."""
+    info = ImageInfo.model_validate({
+        "master": "data/corpora/test/masters/0001r.tif",
+        "derivative_web": "data/corpora/test/derivatives/0001r.jpg",
+        "width": 2000,
+        "height": 3000,
+    })
+    assert info.iiif_service_url is None
+    assert info.manifest_url is None
+
+
+def test_image_info_with_iiif_service_url():
+    """Un ImageInfo avec iiif_service_url doit valider."""
+    info = ImageInfo.model_validate({
+        "master": "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29/full/max/0/default.jpg",
+        "iiif_service_url": "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29",
+        "manifest_url": "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/manifest.json",
+        "width": 3543,
+        "height": 4724,
+    })
+    assert info.iiif_service_url == "https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29"
+    assert info.manifest_url is not None
+    assert info.derivative_web is None
+    assert info.thumbnail is None
+
+
+def test_image_info_iiif_native_no_local_paths():
+    """En mode IIIF natif, derivative_web et thumbnail sont None."""
+    info = ImageInfo(
+        master="https://example.com/image.jpg",
+        iiif_service_url="https://example.com/iiif/img1",
+        width=5000,
+        height=7000,
+    )
+    assert info.derivative_web is None
+    assert info.thumbnail is None
+    assert info.width == 5000
+    assert info.height == 7000
+
+
+def test_page_master_backward_compat_v10(minimal_page_master):
+    """Un PageMaster v1.0 (sans champs IIIF) doit toujours valider."""
+    pm = PageMaster.model_validate(minimal_page_master)
+    assert pm.schema_version == "1.0"
+    assert pm.image.iiif_service_url is None
+
+
+def test_image_source_info_iiif():
+    """ImageSourceInfo avec service IIIF détecté."""
+    info = ImageSourceInfo(
+        original_url="https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29/full/max/0/default.jpg",
+        iiif_service_url="https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/f29",
+        manifest_url="https://gallica.bnf.fr/iiif/ark:/12148/btv1b8432314s/manifest.json",
+        is_iiif=True,
+        original_width=3543,
+        original_height=4724,
+    )
+    assert info.is_iiif is True
+    assert "gallica" in info.iiif_service_url
+
+
+def test_image_source_info_static_fallback():
+    """ImageSourceInfo sans service IIIF (image statique)."""
+    info = ImageSourceInfo(
+        original_url="https://example.com/static/page1.jpg",
+        is_iiif=False,
+        original_width=2000,
+        original_height=3000,
+    )
+    assert info.is_iiif is False
+    assert info.iiif_service_url is None

frontend/src/components/Viewer.tsx

@@ -3,14 +3,16 @@ import OpenSeadragon from 'openseadragon'
 import { RetroButton } from './retro'
 
 interface Props {
-  imageUrl: string
+  /** URL du IIIF Image Service (zoom tuilé natif) */
+  iiifServiceUrl?: string | null
+  /** URL image statique (fallback si pas de service IIIF) */
+  fallbackImageUrl?: string | null
   onViewerReady?: (viewer: OpenSeadragon.Viewer) => void
 }
 
-const Viewer: FC<Props> = ({ imageUrl, onViewerReady }) => {
+const Viewer: FC<Props> = ({ iiifServiceUrl, fallbackImageUrl, onViewerReady }) => {
   const containerRef = useRef<HTMLDivElement>(null)
   const viewerRef = useRef<OpenSeadragon.Viewer | null>(null)
-  // Ref pour toujours accéder au callback le plus récent (évite stale closure)
   const onViewerReadyRef = useRef(onViewerReady)
   onViewerReadyRef.current = onViewerReady
 
@@ -25,6 +27,7 @@ const Viewer: FC<Props> = ({ imageUrl, onViewerReady }) => {
       animationTime: 0.3,
       minZoomLevel: 0.1,
       maxZoomLevel: 20,
+      crossOriginPolicy: 'Anonymous',
     })
 
     viewerRef.current = viewer
@@ -35,15 +38,25 @@ const Viewer: FC<Props> = ({ imageUrl, onViewerReady }) => {
     }
   }, [])
 
+  // Source à ouvrir : préférer le service IIIF (zoom tuilé), sinon image statique
+  const source = iiifServiceUrl || fallbackImageUrl || ''
+
   useEffect(() => {
     const viewer = viewerRef.current
-    if (!viewer || !imageUrl) return
+    if (!viewer || !source) return
+
+    if (iiifServiceUrl) {
+      // Zoom tuilé natif — OpenSeadragon fetch info.json et configure les tuiles
+      viewer.open(iiifServiceUrl + '/info.json')
+    } else {
+      // Image statique simple (pas de zoom tuilé)
+      viewer.open({ type: 'image', url: source })
+    }
 
-    viewer.open({ type: 'image', url: imageUrl })
     viewer.addOnceHandler('open', () => {
       onViewerReadyRef.current?.(viewer)
     })
-  }, [imageUrl])
+  }, [source, iiifServiceUrl])
 
   return (
     <div className="relative w-full h-full bg-retro-black">

frontend/src/lib/api.ts

@@ -83,6 +83,10 @@ export interface Page {
   folio_label: string
   sequence: number
   image_master_path: string | null
+  iiif_service_url: string | null
+  canvas_width: number | null
+  canvas_height: number | null
+  manifest_url: string | null
   processing_status: string
   confidence_summary: number | null
 }
@@ -150,6 +154,8 @@ export interface ImageInfo {
   derivative_web?: string | null
   thumbnail?: string | null
   iiif_base?: string | null
+  iiif_service_url?: string | null
+  manifest_url?: string | null
   width: number
   height: number
 }

frontend/src/pages/Editor.tsx

@@ -154,7 +154,8 @@ export default function Editor() {
     )
   }
 
-  const imageUrl = master?.image?.derivative_web ?? master?.image?.master ?? ''
+  const iiifServiceUrl = master?.image?.iiif_service_url ?? null
+  const fallbackImageUrl = master?.image?.derivative_web ?? master?.image?.master ?? ''
   const regions = master?.layout?.regions ?? []
 
   return (
@@ -194,8 +195,8 @@ export default function Editor() {
           className="flex-1 min-w-0"
         >
           <div className="relative w-full h-full">
-            <Viewer imageUrl={imageUrl} onViewerReady={() => {}} />
-            {!imageUrl && (
+            <Viewer iiifServiceUrl={iiifServiceUrl} fallbackImageUrl={fallbackImageUrl} onViewerReady={() => {}} />
+            {!iiifServiceUrl && !fallbackImageUrl && (
               <div className="absolute inset-0 flex items-center justify-center bg-retro-gray text-retro-darkgray text-retro-sm">
                 Apercu non disponible
               </div>

frontend/src/pages/Reader.tsx

@@ -122,7 +122,8 @@ export default function Reader() {
   }
 
   const currentPage = pages[currentIndex]
-  const imageUrl = currentPage.image_master_path ?? ''
+  const iiifServiceUrl = currentPage.iiif_service_url ?? null
+  const fallbackImageUrl = currentPage.image_master_path ?? ''
   const regions: Region[] = master?.layout?.regions ?? []
 
   return (
@@ -168,12 +169,12 @@ export default function Reader() {
           statusBar={
             master
               ? `${master.editorial.status} — v${master.editorial.version}`
-              : imageUrl ? 'Page non analysee' : 'Aucune image'
+              : (iiifServiceUrl || fallbackImageUrl) ? 'Page non analysee' : 'Aucune image'
           }
           className="flex-[7] min-w-0"
         >
           <div className="relative w-full h-full">
-            <Viewer imageUrl={imageUrl} onViewerReady={handleViewerReady} />
+            <Viewer iiifServiceUrl={iiifServiceUrl} fallbackImageUrl={fallbackImageUrl} onViewerReady={handleViewerReady} />
             <RegionOverlay
               viewer={osdViewer}
               regions={regions}
@@ -211,7 +212,7 @@ export default function Reader() {
             )}
 
             {/* Not analyzed / error badge */}
-            {!master && !loading && imageUrl && (
+            {!master && !loading && (iiifServiceUrl || fallbackImageUrl) && (
               <div className="absolute top-2 left-2">
                 {masterError
                   ? <RetroBadge variant="error">Erreur: {masterError}</RetroBadge>
@@ -261,7 +262,7 @@ export default function Reader() {
               </div>
             ) : (
               <div className="p-3 text-retro-sm text-retro-darkgray">
-                {imageUrl
+                {(iiifServiceUrl || fallbackImageUrl)
                   ? 'Page non encore analysee par l\'IA.'
                   : 'Aucune image associee a cette page.'
                 }