feat: restore General plus 19 LoRA editor

MODEL_BOM.md

@@ -18,12 +18,14 @@ The Rapid AIO source statement is why this repository explicitly records
 `content_moderation_enabled: false`. No input-image, Prompt, or output-image
 NSFW classifier, safety checker, or semantic blocklist is added in H2.
 
-## Candidate LoRAs
+## Enabled LoRA allowlist
 
-The source Space exposed all 19 candidates below, and H2 pinned their revisions
-for provenance. The current public runtime enables none of them: requests run
-the pinned replacement transformer directly in general edit mode without loading,
-selecting, or applying a LoRA adapter.
+The source Space exposed all 19 adapters below. This source revision enables
+their exact API IDs in addition to the default `__base__` general mode. Weights
+are loaded lazily at their pinned revisions, and the runtime unloads the prior
+adapter before loading another so at most one LoRA is resident. Enablement is a
+technical runtime fact, not a conclusion that every license, attribution, or
+brand-use question has been resolved.
 
 | API ID | Repository | Revision | Recorded status |
 |---|---|---|---|
@@ -47,16 +49,18 @@ selecting, or applying a LoRA adapter.
 | `Studio-DeLight` | `prithivMLmods/QIE-2511-Studio-DeLight` | `a5c2440989ba6a025ac99acac095369486e32774` | Metadata observed as Apache-2.0 |
 | `Cinematic-FlatLog` | `prithivMLmods/QIE-2511-Cinematic-FlatLog-Control` | `f30505226920906802c9677634219bc53edfd915` | Metadata observed as Apache-2.0 |
 
-## Open release gates
+## Open release facts and gates
 
 - Resolve license text and attribution requirements for the full runtime chain,
   not only top-level metadata.
-- Resolve `Style-Transfer`'s metadata/card conflict before enabling it.
-- Decide whether brand-named adapter IDs are appropriate for first-party UI.
-- Confirm that the upstream example images may be redistributed. H2 keeps their
-  files for source-history fidelity but removes their API/UI exposure and blocks
-  the directory from Gradio file serving.
+- `Style-Transfer` is technically enabled, but its metadata/card license conflict
+  remains unresolved and must not be described as license-cleared.
+- Brand-named adapter IDs remain exposed in the selector; brand-use review is
+  still open.
+- The 19 fixed upstream examples are exposed through generated thumbnails and
+  the non-GPU `/load_example` endpoint. Their redistribution status has not been
+  independently cleared. Direct Gradio file serving of `examples/` stays blocked.
 - Produce an exact Linux transitive dependency lock after a controlled build.
-- A previous `Anime-V2` smoke does not validate the new no-LoRA general edit path.
-  Run a separate, explicitly authorized synthetic-image smoke before describing
-  general no-LoRA image generation as end-to-end verified.
+- A previous `Anime-V2` smoke predates this single-resident adapter state machine
+  and does not validate General mode, multi-image mode, or the other 18 adapters.
+  No new GPU smoke was performed as part of this source-only restoration.

README.md

@@ -9,7 +9,7 @@ python_version: 3.10.13
 app_file: app.py
 pinned: true
 license: apache-2.0
-short_description: Revision-pinned general AI image editor and API
+short_description: Revision-pinned general and LoRA AI image editor
 ---
 
 # hy3dlab Image-to-Image
@@ -18,27 +18,32 @@ Public backend duplicated from
 [`prithivMLmods/Qwen-Image-Edit-2511-LoRAs-Fast`](https://huggingface.co/spaces/prithivMLmods/Qwen-Image-Edit-2511-LoRAs-Fast)
 at commit `e1c9d2e8421d7934841d67f809d87ac7a6cdf720`.
 
-Current mode: general image editing through the pinned replacement transformer.
-No LoRA adapter is loaded. The legacy `lora_adapter` API field is retained for
-compatibility and accepts only the reserved internal value `__base__`.
+General editing through the pinned replacement transformer is the default mode
+(`lora_adapter="__base__"`). The same seven-field endpoint also accepts the 19
+revision-pinned LoRA IDs recorded in `provenance.py`. Adapter changes use a
+single-resident state machine: the prior adapter is unloaded before another is
+loaded, and activation plus inference are serialized by one pipeline lock.
 
-The Space App includes a first-party single-image editor with upload, Prompt,
-queue status, before/after comparison, session history, and PNG download. Its
-browser code is self-hosted and uses the same strict seven-field API contract;
-the removed upstream LoRA and example controls are not exposed.
+The Space App includes a first-party one-or-two-image editor with Prompt,
+General/Style-LoRA selection, Quick Prompts, 19 fixed examples, queue status,
+before/after comparison, session history, and PNG download. Browser code is
+self-hosted and uses the same strict seven-field API contract.
 
 ## API boundary
 
 - Named endpoint: `/edit_image`
+- Non-GPU example endpoint: `/load_example`
 - Input shape: the upstream seven fields
 - Output shape: `{ "image": "data:image/png;base64,...", "seed": number }`
-- Technical validation: one PNG/JPEG/WebP data URL, at most 10 MiB and 16 MP,
-  Prompt length, numeric ranges, the reserved general edit mode, and one
-  concurrent pipeline operation
+- Technical validation: one or two PNG/JPEG/WebP data URLs, at most 10 MiB and
+  16 MP each (20 MiB and 32 MP total), Prompt length, numeric ranges, an exact
+  allowlisted edit mode, and one concurrent pipeline operation
 - Error output: stable low-cardinality codes; raw provider exceptions and user
   content are not returned or logged
 - Input and output are processed in memory and are not deliberately written to
   application storage
+- Generated output remains a single PNG with a maximum 1024px long side. The
+  `Upscaler` adapter does not make this API a 4K-output service.
 
 ## Content-moderation decision
 
@@ -50,10 +55,10 @@ applicable law.
 
 ## Reproducibility
 
-Remote model, transformer, kernel, and candidate LoRA revisions are pinned in
+Remote model, transformer, kernel, and all enabled LoRA revisions are pinned in
 `provenance.py`. See `MODEL_BOM.md` for the recorded supply-chain facts and open
-release gates. Candidate LoRAs are provenance records only and none are enabled
-by the runtime. Python direct dependencies are pinned in `requirements.txt` and
+release gates; enablement is not a claim that every license/brand question has
+been cleared. Python direct dependencies are pinned in `requirements.txt` and
 `pre-requirements.txt`. The browser client is vendored at the installed
 `@gradio/client` 2.3.1 build and hash-checked by the static test suite; a Linux
 transitive lock remains a post-build task.

app.py

@@ -1,19 +1,23 @@
-"""Public, revision-pinned general Image-to-Image backend for hy3d.dev."""
+"""Public, revision-pinned general + LoRA Image-to-Image backend for hy3d.dev."""
 
 from __future__ import annotations
 
+import base64
 import gc
 import logging
+import math
 import os
 import random
 import threading
+from io import BytesIO
 
 import gradio as gr
 import spaces
 import torch
 from fastapi import HTTPException
-from fastapi.responses import FileResponse, HTMLResponse
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
 from gradio import Server
+from PIL import Image, ImageOps
 
 from i2i_contract import (
     ALLOWED_MIME_FORMATS,
@@ -24,24 +28,31 @@ from i2i_contract import (
     MAX_GUIDANCE,
     MAX_IMAGE_BYTES,
     MAX_IMAGE_PIXELS,
+    MAX_INPUT_IMAGES,
     MAX_OUTPUT_SIDE,
     MAX_PROMPT_CHARS,
     MAX_REQUEST_JSON_CHARS,
     MAX_SEED,
     MAX_STEPS,
+    MAX_TOTAL_IMAGE_BYTES,
+    MAX_TOTAL_IMAGE_PIXELS,
     MIN_GUIDANCE,
+    MIN_INPUT_IMAGES,
     MIN_IMAGE_SIDE,
     MIN_STEPS,
+    SingleResidentAdapterManager,
     ValidatedEditRequest,
     decode_validated_images,
     execute_validated_edit,
     output_dimensions,
+    parse_example_index,
     public_error_text,
     serialize_png_candidate,
 )
 from provenance import (
     BASE_MODEL_ID,
     BASE_MODEL_REVISION,
+    ENABLED_ADAPTER_SPECS,
     TRANSFORMER_MODEL_ID,
     TRANSFORMER_MODEL_REVISION,
     UPSTREAM_SPACE_ID,
@@ -55,12 +66,111 @@ logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s %(message
 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 DTYPE = torch.bfloat16
 PIPELINE_LOCK = threading.Lock()
+LANCZOS = getattr(Image, "Resampling", Image).LANCZOS
 
 NEGATIVE_PROMPT = (
     "worst quality, low quality, bad anatomy, bad hands, text, error, missing fingers, "
     "extra digit, fewer digits, cropped, jpeg artifacts, signature, watermark, username, blurry"
 )
 
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+EXAMPLES_DIR = os.path.realpath(os.path.join(BASE_DIR, "examples"))
+
+# Fixed, index-addressed manifest copied from the pinned upstream Space. The
+# Upscaler text is deliberately accurate for this API's 1024px output limit.
+EXAMPLES_CONFIG = (
+    {"images": ("examples/B.jpg",), "prompt": "Transform into anime.", "lora": "Photo-to-Anime"},
+    {"images": ("examples/HRP.jpg",), "prompt": "Transform into a hyper-realistic face portrait.", "lora": "Hyper-Realistic-Portrait"},
+    {"images": ("examples/A.jpeg",), "prompt": "Rotate the camera 45 degrees to the right.", "lora": "Multiple-Angles"},
+    {"images": ("examples/U.jpg",), "prompt": "Upscale and enhance image detail.", "lora": "Upscaler"},
+    {"images": ("examples/L1.jpg", "examples/L2.jpg"), "prompt": "Apply the lighting from image 2 to image 1.", "lora": "Any-light"},
+    {"images": ("examples/PP1.jpg",), "prompt": "cinematic polaroid with soft grain subtle vignette gentle lighting white frame handwritten photographed preserving realistic texture and details.", "lora": "Polaroid-Photo"},
+    {"images": ("examples/Z1.jpg",), "prompt": "Front-right quarter view.", "lora": "Fal-Multiple-Angles"},
+    {"images": ("examples/URP.jpg",), "prompt": "Transform into a cinematic flat log.", "lora": "Cinematic-FlatLog"},
+    {"images": ("examples/SL.jpg",), "prompt": "Neutral uniform lighting. Preserve identity and composition.", "lora": "Studio-DeLight"},
+    {"images": ("examples/PI.jpg",), "prompt": "Transform it into Pixar-inspired 3D.", "lora": "Pixar-Inspired-3D"},
+    {"images": ("examples/MT.jpg",), "prompt": "Paint with manga tone.", "lora": "Manga-Tone"},
+    {"images": ("examples/NCB.jpg",), "prompt": "Transform into a noir comic book style.", "lora": "Noir-Comic-Book"},
+    {"images": ("examples/URP.jpg",), "prompt": "Ultra-realistic portrait.", "lora": "Ultra-Realistic-Portrait"},
+    {"images": ("examples/MN.jpg",), "prompt": "Transform into Midnight Noir Eyes Spotlight.", "lora": "Midnight-Noir-Eyes-Spotlight"},
+    {"images": ("examples/ST1.jpg", "examples/ST2.jpg"), "prompt": "Convert Image 1 to the style of Image 2.", "lora": "Style-Transfer"},
+    {"images": ("examples/R1.jpg",), "prompt": "Change the picture to realistic photograph.", "lora": "Anything2Real"},
+    {"images": ("examples/UA.jpeg",), "prompt": "Unblur and upscale.", "lora": "Unblur-Anything"},
+    {"images": ("examples/L1.jpg", "examples/L2.jpg"), "prompt": "Refer to the color tone, remove the original lighting from Image 1, and relight Image 1 based on the lighting and color tone of Image 2.", "lora": "Light-Migration"},
+    {"images": ("examples/P1.jpg",), "prompt": "Transform into anime (while preserving the background and remaining elements maintaining realism and original details.)", "lora": "Anime-V2"},
+)
+
+if len(EXAMPLES_CONFIG) != 19 or any(example["lora"] not in ENABLED_ADAPTER_SPECS for example in EXAMPLES_CONFIG):
+    raise RuntimeError("The fixed example manifest must reference all approved runtime assets")
+
+EXAMPLE_ASSET_PATHS = frozenset(
+    relative_path
+    for example in EXAMPLES_CONFIG
+    for relative_path in example["images"]
+)
+
+
+def _fixed_example_path(relative_path: str) -> str:
+    """Resolve only paths present in the static example manifest."""
+
+    if relative_path not in EXAMPLE_ASSET_PATHS:
+        raise ValueError("Unknown example asset")
+    resolved = os.path.realpath(os.path.join(BASE_DIR, relative_path))
+    if os.path.commonpath((EXAMPLES_DIR, resolved)) != EXAMPLES_DIR:
+        raise ValueError("Invalid example asset path")
+    return resolved
+
+
+def _make_example_thumbnail(relative_path: str, max_side: int = 220) -> str:
+    try:
+        with Image.open(_fixed_example_path(relative_path)) as source:
+            source.load()
+            image = ImageOps.exif_transpose(source).convert("RGB")
+            image.thumbnail((max_side, max_side), LANCZOS)
+            buffer = BytesIO()
+            image.save(buffer, format="JPEG", quality=65, optimize=True)
+        return f"data:image/jpeg;base64,{base64.b64encode(buffer.getvalue()).decode('ascii')}"
+    except (OSError, SyntaxError, ValueError) as exc:
+        LOGGER.warning("event=example_thumbnail_failed error_class=%s", type(exc).__name__)
+        return ""
+
+
+def _encode_example_image(relative_path: str) -> str:
+    """Encode one fixed example, normalizing it to the public input limits."""
+
+    with Image.open(_fixed_example_path(relative_path)) as source:
+        source.load()
+        image = ImageOps.exif_transpose(source).convert("RGB")
+        if image.width * image.height > MAX_IMAGE_PIXELS:
+            scale = math.sqrt(MAX_IMAGE_PIXELS / (image.width * image.height))
+            target = (max(MIN_IMAGE_SIDE, int(image.width * scale)), max(MIN_IMAGE_SIDE, int(image.height * scale)))
+            image = image.resize(target, LANCZOS)
+        buffer = BytesIO()
+        image.save(buffer, format="JPEG", quality=90, optimize=True)
+    encoded = buffer.getvalue()
+    if len(encoded) > MAX_IMAGE_BYTES:
+        raise ValueError("Normalized example exceeds the public image limit")
+    return f"data:image/jpeg;base64,{base64.b64encode(encoded).decode('ascii')}"
+
+
+def _build_example_cards() -> list[dict]:
+    cards = []
+    for index, example in enumerate(EXAMPLES_CONFIG):
+        cards.append(
+            {
+                "idx": index,
+                "thumbs": [_make_example_thumbnail(path) for path in example["images"]],
+                "n_images": len(example["images"]),
+                "lora": example["lora"],
+                "prompt": example["prompt"],
+            }
+        )
+    return cards
+
+
+EXAMPLE_CARDS = _build_example_cards()
+EXAMPLE_ASSETS_READY = all(card["thumbs"] and all(card["thumbs"]) for card in EXAMPLE_CARDS)
+
 
 # Importing spaces before torch and moving the model at module scope follows the
 # Hugging Face ZeroGPU model-placement contract. All Hub assets are pinned to
@@ -89,25 +199,57 @@ except Exception as exc:  # The pipeline can run with its default processor.
     LOGGER.warning("event=attention_processor_fallback error_class=%s", type(exc).__name__)
 
 
+def _load_adapter(edit_mode: str) -> None:
+    spec = ENABLED_ADAPTER_SPECS[edit_mode]
+    pipe.load_lora_weights(
+        spec.repo,
+        revision=spec.revision,
+        weight_name=spec.weights,
+        adapter_name=spec.adapter_name,
+    )
+
+
+def _activate_adapter(edit_mode: str) -> None:
+    pipe.set_adapters(
+        [ENABLED_ADAPTER_SPECS[edit_mode].adapter_name],
+        adapter_weights=[1.0],
+    )
+
+
+def _unload_adapters() -> None:
+    pipe.unload_lora_weights()
+
+
+ADAPTER_MANAGER = SingleResidentAdapterManager(
+    adapter_modes=ENABLED_ADAPTER_SPECS,
+    load_adapter=_load_adapter,
+    activate_adapter=_activate_adapter,
+    unload_adapters=_unload_adapters,
+)
+
+
 def _public_gradio_error(code: str) -> gr.Error:
     return gr.Error(public_error_text(code), print_exception=False)
 
 
 def _is_public_error(error: gr.Error) -> bool:
     message = str(getattr(error, "message", error))
-    return any(message.startswith(f"{code}:") for code in (
-        "I2I_BAD_REQUEST",
-        "I2I_UNSUPPORTED_TYPE",
-        "I2I_FILE_TOO_LARGE",
-        "I2I_IMAGE_DECODE_FAILED",
-        "I2I_IMAGE_DIMENSIONS_INVALID",
-        "I2I_PROMPT_REQUIRED",
-        "I2I_PROMPT_TOO_LONG",
-        "I2I_LORA_NOT_ALLOWED",
-        "I2I_PROVIDER_BUSY",
-        "I2I_INFERENCE_FAILED",
-        "I2I_INVALID_OUTPUT",
-    ))
+    return message in {
+        public_error_text(code)
+        for code in (
+            "I2I_BAD_REQUEST",
+            "I2I_UNSUPPORTED_TYPE",
+            "I2I_FILE_TOO_LARGE",
+            "I2I_IMAGE_DECODE_FAILED",
+            "I2I_IMAGE_DIMENSIONS_INVALID",
+            "I2I_PROMPT_REQUIRED",
+            "I2I_PROMPT_TOO_LONG",
+            "I2I_LORA_NOT_ALLOWED",
+            "I2I_PROVIDER_BUSY",
+            "I2I_INFERENCE_FAILED",
+            "I2I_INVALID_OUTPUT",
+        )
+    }
 
 
 def _provider_error_code(error: gr.Error) -> str:
@@ -126,11 +268,23 @@ def _clear_cuda_cache() -> None:
 
 @spaces.GPU(size="xlarge")
 def _run_gpu_edit(request: ValidatedEditRequest) -> tuple[bytes, int]:
-    """Run one general edit with the pinned replacement transformer and no LoRA."""
+    """Activate one allowed mode and run inference under one pipeline lock."""
 
     _clear_cuda_cache()
     try:
         with PIPELINE_LOCK:
+            try:
+                ADAPTER_MANAGER.activate_mode(request.edit_mode)
+            except ContractError:
+                raise
+            except Exception as exc:
+                LOGGER.warning(
+                    "event=adapter_transition_failed edit_mode=%s error_class=%s",
+                    request.edit_mode,
+                    type(exc).__name__,
+                )
+                raise _public_gradio_error("I2I_INFERENCE_FAILED") from None
+
             used_seed = random.randint(0, MAX_SEED) if request.randomize_seed else request.seed
             generator = torch.Generator(device=DEVICE).manual_seed(used_seed)
             width, height = output_dimensions(request.images[0])
@@ -177,9 +331,9 @@ def edit_image(
 ) -> dict:
     """Validate on CPU, then call the internal ZeroGPU edit function.
 
-    The public seven-field contract is retained for compatibility. The legacy
-    lora_adapter field must contain the reserved general-mode value; no LoRA is
-    loaded. Validation is technical only, with no semantic content moderation.
+    The public seven-field contract is retained for compatibility. General mode
+    uses the reserved ``__base__`` value; 19 provenance-pinned LoRA IDs are also
+    accepted. Validation is technical only, with no semantic moderation.
     """
 
     try:
@@ -191,7 +345,7 @@ def edit_image(
             randomize_seed=randomize_seed,
             guidance_scale=guidance_scale,
             steps=steps,
-            allowed_edit_modes={BASE_EDIT_MODE_ID},
+            allowed_edit_modes={BASE_EDIT_MODE_ID, *ENABLED_ADAPTER_SPECS},
             runner=_run_gpu_edit,
         )
     except ContractError as exc:
@@ -210,6 +364,7 @@ def edit_image(
 
 def _service_metadata() -> dict:
     deploy_sha = os.environ.get("APP_DEPLOY_SHA", "unknown")
+    lora_ids = list(ENABLED_ADAPTER_SPECS)
     return {
         "service": "hy3dlab-image-to-image",
         "api_version": API_VERSION,
@@ -219,17 +374,28 @@ def _service_metadata() -> dict:
         "base_model_revision": BASE_MODEL_REVISION,
         "transformer_revision": TRANSFORMER_MODEL_REVISION,
         "content_moderation_enabled": CONTENT_MODERATION_ENABLED,
-        "edit_mode": "general",
-        "uses_lora": False,
-        "required_lora_adapter_value": BASE_EDIT_MODE_ID,
-        "enabled_loras": [],
-        "ready": deploy_sha != "unknown",
+        "edit_mode": "general-and-lora",
+        "uses_lora": True,
+        "supports_general_mode": True,
+        "general_mode_value": BASE_EDIT_MODE_ID,
+        "required_lora_adapter_value": None,
+        "default_edit_mode": BASE_EDIT_MODE_ID,
+        "enabled_loras": lora_ids,
+        "enabled_edit_modes": [BASE_EDIT_MODE_ID, *lora_ids],
+        "adapter_residency": "single",
+        "examples_count": len(EXAMPLE_CARDS),
+        "example_assets_ready": EXAMPLE_ASSETS_READY,
+        "ready": deploy_sha != "unknown" and EXAMPLE_ASSETS_READY,
         "limits": {
-            "input_images": 1,
+            "input_images": MAX_INPUT_IMAGES,
+            "min_input_images": MIN_INPUT_IMAGES,
+            "max_input_images": MAX_INPUT_IMAGES,
             "mime_types": sorted(ALLOWED_MIME_FORMATS),
             "max_image_bytes": MAX_IMAGE_BYTES,
+            "max_total_image_bytes": MAX_TOTAL_IMAGE_BYTES,
             "max_request_json_chars": MAX_REQUEST_JSON_CHARS,
             "max_image_pixels": MAX_IMAGE_PIXELS,
+            "max_total_image_pixels": MAX_TOTAL_IMAGE_PIXELS,
             "min_image_side": MIN_IMAGE_SIDE,
             "max_prompt_chars": MAX_PROMPT_CHARS,
             "seed": [0, MAX_SEED],
@@ -241,27 +407,63 @@ def _service_metadata() -> dict:
 
 
 @app.get("/healthz")
-def healthz() -> dict:
+def healthz() -> JSONResponse:
     """Non-inference configuration and revision check."""
 
-    return _service_metadata()
+    return JSONResponse(content=_service_metadata(), headers=NO_STORE_HEADERS)
+
+
+def _example_error_response() -> dict:
+    return {"images": [], "prompt": "", "lora": "", "names": [], "status": "error"}
+
+
+@app.api(name="load_example", queue=False)
+def load_example(idx: float) -> dict:
+    """Return one fixed example payload without allocating a GPU."""
+
+    index = parse_example_index(idx, len(EXAMPLES_CONFIG))
+    if index is None:
+        return _example_error_response()
+
+    example = EXAMPLES_CONFIG[index]
+    try:
+        images = [_encode_example_image(path) for path in example["images"]]
+    except (OSError, SyntaxError, ValueError) as exc:
+        LOGGER.warning("event=example_load_failed error_class=%s", type(exc).__name__)
+        return _example_error_response()
+
+    if len(images) != len(example["images"]) or not all(images):
+        return _example_error_response()
+    return {
+        "images": images,
+        "prompt": example["prompt"],
+        "lora": example["lora"],
+        "names": [os.path.basename(path) for path in example["images"]],
+        "status": "ok",
+    }
 
 
 @app.get("/api/config")
-def client_config() -> dict:
+def client_config() -> JSONResponse:
     """Public, non-secret configuration for the first-party frontend."""
 
     metadata = _service_metadata()
-    return {
+    config = {
         "api_version": metadata["api_version"],
         "content_moderation_enabled": metadata["content_moderation_enabled"],
         "edit_mode": metadata["edit_mode"],
         "uses_lora": metadata["uses_lora"],
+        "supports_general_mode": metadata["supports_general_mode"],
+        "general_mode_value": metadata["general_mode_value"],
         "required_lora_adapter_value": metadata["required_lora_adapter_value"],
-        "loras": [],
+        "default_edit_mode": metadata["default_edit_mode"],
+        "enabled_edit_modes": metadata["enabled_edit_modes"],
+        "loras": metadata["enabled_loras"],
         "default_lora": None,
+        "examples": EXAMPLE_CARDS,
         "limits": metadata["limits"],
     }
+    return JSONResponse(content=config, headers=NO_STORE_HEADERS)
 
 
 NO_STORE_HEADERS = {

assets/app-ui.js

@@ -1,12 +1,38 @@
 import { Client } from "/hy3d-assets/gradio-client-2.3.1.js";
 
 const GENERAL_MODE_ID = "__base__";
+const EXPECTED_API_VERSION = "2026-08-12.3";
+const EXPECTED_LORA_IDS = Object.freeze([
+  "Multiple-Angles",
+  "Photo-to-Anime",
+  "Anime-V2",
+  "Light-Migration",
+  "Upscaler",
+  "Style-Transfer",
+  "Manga-Tone",
+  "Anything2Real",
+  "Fal-Multiple-Angles",
+  "Polaroid-Photo",
+  "Unblur-Anything",
+  "Midnight-Noir-Eyes-Spotlight",
+  "Hyper-Realistic-Portrait",
+  "Ultra-Realistic-Portrait",
+  "Pixar-Inspired-3D",
+  "Noir-Comic-Book",
+  "Any-light",
+  "Studio-DeLight",
+  "Cinematic-FlatLog",
+]);
 const MAX_HISTORY_ITEMS = 6;
 const FALLBACK_LIMITS = Object.freeze({
-  input_images: 1,
+  input_images: 2,
+  min_input_images: 1,
+  max_input_images: 2,
   mime_types: ["image/jpeg", "image/png", "image/webp"],
   max_image_bytes: 10 * 1024 * 1024,
+  max_total_image_bytes: 20 * 1024 * 1024,
   max_image_pixels: 16_000_000,
+  max_total_image_pixels: 32_000_000,
   min_image_side: 64,
   max_prompt_chars: 1000,
   seed: [0, 2147483647],
@@ -30,14 +56,22 @@ const PUBLIC_ERROR_MESSAGES = Object.freeze({
 });
 
 const SUGGESTIONS = Object.freeze([
-  ["Studio Background", "Replace the background with a clean studio backdrop while preserving the subject."],
-  ["Warm Light", "Add warm natural lighting while keeping the subject unchanged."],
-  ["Cool Light", "Add cool balanced lighting while keeping the subject unchanged."],
-  ["B&W", "Convert the image to black and white with balanced contrast."],
-  ["Blur Background", "Add a natural shallow depth of field and softly blur the background."],
-  ["Sharpen", "Improve clarity and fine detail without changing the composition."],
-  ["Remove Object", "Remove the distracting object and reconstruct the background naturally."],
-  ["Product Photo", "Turn this into a clean professional product photo with even lighting."],
+  ["Anime", "Transform into anime."],
+  ["B&W", "Convert it to black and white."],
+  ["Cinematic", "Add cinematic lighting with warm orange tones and film grain."],
+  ["Oil Paint", "Apply oil painting effect with visible brush strokes."],
+  ["Upscale / Enhance", "Enhance clarity and fine detail while preserving the original composition."],
+  ["Watercolor", "Make it look like a watercolor painting with soft edges."],
+  ["Pencil Sketch", "Convert to detailed pencil sketch with cross-hatching and shading."],
+  ["Pop Art", "Apply pop art style with bold colors and halftone patterns."],
+  ["Vintage Retro", "Apply a vintage retro film look with faded colors and light leaks."],
+  ["Neon Glow", "Add neon glow effects with vibrant colors against a dark background."],
+  ["Pixel Art", "Convert to pixel art style with a retro 16-bit aesthetic."],
+  ["Noir Comic", "Transform into a noir comic book style."],
+  ["HyperReal", "Transform into a hyper-realistic face portrait."],
+  ["Unblur", "Unblur and enhance image clarity."],
+  ["Pixar 3D", "Transform into Pixar-inspired 3D."],
+  ["Manga Tone", "Paint with manga tone."],
 ]);
 
 const galleryGrid = document.getElementById("image-gallery-grid");
@@ -48,6 +82,7 @@ const btnRemove = document.getElementById("tb-remove");
 const btnClear = document.getElementById("tb-clear");
 const promptInput = document.getElementById("custom-prompt-input");
 const charCount = document.getElementById("char-count");
+const loraSelect = document.getElementById("custom-lora-select");
 const runBtn = document.getElementById("custom-run-btn");
 const runBtnLabel = document.getElementById("run-btn-label");
 const cancelBtn = document.getElementById("custom-cancel-btn");
@@ -87,11 +122,19 @@ const segInput = document.getElementById("seg-input");
 const connDot = document.getElementById("conn-dot");
 const connText = document.getElementById("conn-text");
 const suggestionsWrap = document.getElementById("suggestions-wrap");
+const tabEdit = document.getElementById("tab-edit");
+const tabExamples = document.getElementById("tab-examples");
+const pageEdit = document.getElementById("page-edit");
+const pageExamples = document.getElementById("page-examples");
+const examplesScroll = document.getElementById("examples-scroll");
+const sbEditMode = document.getElementById("sb-edit-mode");
 
 let client = null;
 let limits = FALLBACK_LIMITS;
 let contractReady = false;
-let inputImage = null;
+let enabledEditModes = new Set();
+let images = [];
+let selectedImageIndex = -1;
 let currentResult = null;
 let history = [];
 let historyIndex = -1;
@@ -104,6 +147,9 @@ let currentStage = "idle";
 let cancellationRequested = false;
 let activeRunId = 0;
 let selectionId = 0;
+let exampleLoadId = 0;
+let loadingExample = false;
+let pendingUpload = { mode: "add", index: -1 };
 let toastTimer = null;
 
 function errorClass(error) {
@@ -155,7 +201,8 @@ function setStatus(text, style = "") {
 }
 
 function updateRunButton() {
-  runBtn.disabled = !contractReady || running || !inputImage;
+  const validInputCount = images.length >= limits.min_input_images && images.length <= limits.max_input_images;
+  runBtn.disabled = !contractReady || running || loadingExample || !validInputCount || !enabledEditModes.has(loraSelect.value);
 }
 
 function flashPromptError() {
@@ -175,24 +222,26 @@ function exitCompareMode() {
   compareBtn.setAttribute("aria-pressed", "false");
   compareWrap.classList.remove("visible");
   const canvasImage = getCanvasImage();
-  if (canvasImage && (currentResult || inputImage)) canvasImage.style.display = "";
+  if (canvasImage && (currentResult || images.length)) canvasImage.style.display = "";
 }
 
 function updateRailState() {
   const hasResult = Boolean(currentResult);
-  btnUpload.disabled = running || !contractReady;
-  dlBtn.disabled = running || !hasResult;
-  useAsInputBtn.disabled = running || !hasResult;
-  compareBtn.disabled = running || !(hasResult && currentResult.beforeB64);
-  zoomBtn.disabled = running || !(hasResult || inputImage);
-  btnRemove.disabled = running || !inputImage;
-  btnClear.disabled = running || !inputImage;
+  const locked = running || loadingExample;
+  btnUpload.disabled = locked || !contractReady;
+  dlBtn.disabled = locked || !hasResult;
+  useAsInputBtn.disabled = locked || !hasResult;
+  compareBtn.disabled = locked || !(hasResult && currentResult.beforeB64);
+  zoomBtn.disabled = locked || !(hasResult || images.length);
+  btnRemove.disabled = locked || selectedImageIndex < 0;
+  btnClear.disabled = locked || !images.length;
 }
 
 function renderCanvas() {
   exitCompareMode();
   let canvasImage = getCanvasImage();
-  const shown = viewMode === "result" ? currentResult : inputImage;
+  const selectedInput = selectedImageIndex >= 0 ? images[selectedImageIndex] : images[0];
+  const shown = viewMode === "result" ? currentResult : selectedInput;
   if (shown) {
     outPh.style.display = "none";
     if (!canvasImage) {
@@ -206,14 +255,16 @@ function renderCanvas() {
       outBody.appendChild(canvasImage);
     }
     canvasImage.style.display = "";
-    canvasImage.src = viewMode === "result" ? currentResult.b64 : inputImage.b64;
+    canvasImage.src = viewMode === "result" ? currentResult.b64 : selectedInput.b64;
     canvasMeta.textContent = viewMode === "result"
-      ? `result · seed ${currentResult.seed}`
-      : `input · ${inputImage.name || "image"}`;
+      ? `${currentResult.editMode || "result"} · seed ${currentResult.seed}`
+      : `input #${Math.max(0, selectedImageIndex) + 1} · ${selectedInput.name || "image"}`;
   } else {
     if (canvasImage) canvasImage.style.display = "none";
     outPh.style.display = "";
-    canvasMeta.textContent = inputImage ? "Input ready — run an edit" : "No image loaded";
+    canvasMeta.textContent = images.length
+      ? `${images.length} input${images.length === 1 ? "" : "s"} ready — run an edit`
+      : "No image loaded";
   }
   updateRailState();
 }
@@ -226,47 +277,63 @@ function setViewMode(mode) {
 }
 
 function updateCounts() {
-  const inputCount = inputImage ? 1 : 0;
-  imgCountTb.textContent = String(inputCount);
-  imgCountSb.textContent = inputCount
-    ? `1 input · ${history.length} result${history.length === 1 ? "" : "s"}`
+  imgCountTb.textContent = String(images.length);
+  imgCountSb.textContent = images.length
+    ? `${images.length} input${images.length === 1 ? "" : "s"} · ${history.length} result${history.length === 1 ? "" : "s"}`
     : "No inputs";
 }
 
 function renderInputStrip() {
   galleryGrid.replaceChildren();
-  if (!inputImage) {
+  if (!images.length) {
     const empty = document.createElement("div");
     empty.className = "fs-empty";
-    empty.textContent = "Drop or paste one image…";
+    empty.textContent = "Drop or paste up to two images…";
     galleryGrid.appendChild(empty);
-  } else {
+  }
+  images.forEach((entry, index) => {
     const thumb = document.createElement("div");
-    thumb.className = "fs-thumb selected";
+    thumb.className = `fs-thumb${index === selectedImageIndex ? " selected" : ""}`;
+    const select = document.createElement("button");
+    select.type = "button";
+    select.className = "fs-thumb-select";
+    select.setAttribute("aria-label", `Select input image ${index + 1}`);
+    select.setAttribute("aria-pressed", String(index === selectedImageIndex));
     const image = document.createElement("img");
-    image.src = inputImage.b64;
-    image.alt = "Input image";
+    image.src = entry.b64;
+    image.alt = `Input image ${index + 1}`;
     const badge = document.createElement("span");
     badge.className = "fs-badge";
-    badge.textContent = "#1";
+    badge.textContent = `#${index + 1}`;
     const remove = document.createElement("button");
     remove.className = "fs-remove";
     remove.type = "button";
     remove.textContent = "✕";
-    remove.setAttribute("aria-label", "Remove input image");
+    remove.setAttribute("aria-label", `Remove input image ${index + 1}`);
     remove.addEventListener("click", (event) => {
       event.stopPropagation();
-      clearInput();
+      removeInput(index);
     });
-    thumb.append(image, badge, remove);
-    thumb.addEventListener("click", () => setViewMode("input"));
+    select.append(image, badge);
+    select.addEventListener("click", () => {
+      selectedImageIndex = index;
+      renderInputStrip();
+      setViewMode("input");
+    });
+    thumb.append(select, remove);
     galleryGrid.appendChild(thumb);
-  }
+  });
   const add = document.createElement("button");
   add.type = "button";
   add.className = "fs-add";
-  add.innerHTML = '<span class="add-icon">+</span><span class="add-text">Replace</span>';
-  add.addEventListener("click", () => fileInput.click());
+  const addIcon = document.createElement("span");
+  addIcon.className = "add-icon";
+  addIcon.textContent = "+";
+  const addText = document.createElement("span");
+  addText.className = "add-text";
+  addText.textContent = images.length < limits.max_input_images ? "Add" : "Replace";
+  add.append(addIcon, addText);
+  add.addEventListener("click", () => openFilePicker());
   galleryGrid.appendChild(add);
   updateRailState();
 }
@@ -302,29 +369,42 @@ function renderHistory() {
   });
 }
 
-function clearInput() {
+function setInputs(nextImages, selectedIndex = 0) {
   selectionId += 1;
-  inputImage = null;
-  fileInput.value = "";
+  images = nextImages;
+  selectedImageIndex = images.length ? Math.max(0, Math.min(selectedIndex, images.length - 1)) : -1;
   renderInputStrip();
   updateCounts();
-  renderCanvas();
+  if (images.length) setViewMode("input");
+  else renderCanvas();
   updateRunButton();
 }
 
-function replaceInput(b64, name) {
-  inputImage = { b64, name };
-  renderInputStrip();
-  updateCounts();
-  setViewMode("input");
-  updateRunButton();
+function removeInput(index) {
+  if (!Number.isInteger(index) || index < 0 || index >= images.length) return;
+  const nextImages = images.filter((_, itemIndex) => itemIndex !== index);
+  const nextSelected = nextImages.length ? Math.min(index, nextImages.length - 1) : -1;
+  setInputs(nextImages, nextSelected);
+}
+
+function clearInputs() {
+  fileInput.value = "";
+  setInputs([], -1);
+}
+
+function openFilePicker() {
+  if (running || loadingExample || !contractReady) return;
+  pendingUpload = images.length >= limits.max_input_images
+    ? { mode: "replace", index: selectedImageIndex >= 0 ? selectedImageIndex : 0 }
+    : { mode: "add", index: -1 };
+  fileInput.click();
 }
 
 function readFileAsDataUrl(file) {
   return new Promise((resolve, reject) => {
     const reader = new FileReader();
-    reader.onload = () => typeof reader.result === "string" ? resolve(reader.result) : reject(new Error("invalid_reader_result"));
-    reader.onerror = () => reject(new Error("file_read_failed"));
+    reader.onload = () => typeof reader.result === "string" ? resolve(reader.result) : reject(new Error("I2I_IMAGE_DECODE_FAILED"));
+    reader.onerror = () => reject(new Error("I2I_IMAGE_DECODE_FAILED"));
     reader.readAsDataURL(file);
   });
 }
@@ -339,58 +419,129 @@ function decodeImageFile(file) {
     };
     image.onerror = () => {
       URL.revokeObjectURL(url);
-      reject(new Error("image_decode_failed"));
+      reject(new Error("I2I_IMAGE_DECODE_FAILED"));
     };
     image.src = url;
   });
 }
 
-async function processFile(file) {
-  if (!file) return;
+function dataUrlByteLength(dataUrl) {
+  if (typeof dataUrl !== "string") return -1;
+  const separator = dataUrl.indexOf(",");
+  if (separator < 0) return -1;
+  const encoded = dataUrl.slice(separator + 1);
+  if (!encoded || encoded.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(encoded)) return -1;
+  const padding = encoded.endsWith("==") ? 2 : encoded.endsWith("=") ? 1 : 0;
+  return (encoded.length / 4) * 3 - padding;
+}
+
+function decodeImageDataUrl(dataUrl) {
+  return new Promise((resolve, reject) => {
+    const image = new Image();
+    image.onload = () => resolve({ width: image.naturalWidth, height: image.naturalHeight });
+    image.onerror = () => reject(new Error("I2I_IMAGE_DECODE_FAILED"));
+    image.src = dataUrl;
+  });
+}
+
+function validateDimensions(dimensions) {
+  const pixels = dimensions.width * dimensions.height;
+  if (
+    !Number.isInteger(dimensions.width) || !Number.isInteger(dimensions.height) ||
+    Math.min(dimensions.width, dimensions.height) < limits.min_image_side ||
+    pixels > limits.max_image_pixels
+  ) {
+    throw new Error("I2I_IMAGE_DIMENSIONS_INVALID");
+  }
+  return pixels;
+}
+
+function validateInputTotals(nextImages) {
+  const totalBytes = nextImages.reduce((sum, item) => sum + item.bytes, 0);
+  const totalPixels = nextImages.reduce((sum, item) => sum + item.pixels, 0);
+  if (totalBytes > limits.max_total_image_bytes) throw new Error("I2I_FILE_TOO_LARGE");
+  if (totalPixels > limits.max_total_image_pixels) throw new Error("I2I_IMAGE_DIMENSIONS_INVALID");
+}
+
+async function inputFromFile(file) {
+  if (!limits.mime_types.includes(file.type)) throw new Error("I2I_UNSUPPORTED_TYPE");
+  if (file.size <= 0 || file.size > limits.max_image_bytes) throw new Error("I2I_FILE_TOO_LARGE");
+  const dimensions = await decodeImageFile(file);
+  const pixels = validateDimensions(dimensions);
+  const b64 = await readFileAsDataUrl(file);
+  return { b64, name: file.name || "image", bytes: file.size, pixels };
+}
+
+async function inputFromDataUrl(dataUrl, name) {
+  const header = typeof dataUrl === "string" ? dataUrl.slice(0, dataUrl.indexOf(",")) : "";
+  const mime = header.startsWith("data:") && header.endsWith(";base64") ? header.slice(5, -7) : "";
+  if (!limits.mime_types.includes(mime)) throw new Error("I2I_UNSUPPORTED_TYPE");
+  const bytes = dataUrlByteLength(dataUrl);
+  if (bytes <= 0 || bytes > limits.max_image_bytes) throw new Error("I2I_FILE_TOO_LARGE");
+  const dimensions = await decodeImageDataUrl(dataUrl);
+  const pixels = validateDimensions(dimensions);
+  return { b64: dataUrl, name: name || "image", bytes, pixels };
+}
+
+async function processFiles(fileList, action = { mode: "add", index: -1 }) {
+  const files = Array.from(fileList || []);
+  if (!files.length) return;
   if (!contractReady) {
     showToast("The editor is still connecting. Try again shortly.", "warning");
     return;
   }
-  if (running) {
-    showToast("Wait for the current edit to finish.", "warning");
+  if (running || loadingExample) {
+    showToast(running ? "Wait for the current edit to finish." : "Wait for the example to finish loading.", "warning");
     return;
   }
   const localSelectionId = ++selectionId;
-  if (!limits.mime_types.includes(file.type)) {
-    showToast(PUBLIC_ERROR_MESSAGES.I2I_UNSUPPORTED_TYPE);
-    return;
-  }
-  if (file.size <= 0 || file.size > limits.max_image_bytes) {
-    showToast(PUBLIC_ERROR_MESSAGES.I2I_FILE_TOO_LARGE);
-    return;
-  }
   try {
-    const dimensions = await decodeImageFile(file);
-    if (
-      Math.min(dimensions.width, dimensions.height) < limits.min_image_side ||
-      dimensions.width * dimensions.height > limits.max_image_pixels
-    ) {
-      showToast(PUBLIC_ERROR_MESSAGES.I2I_IMAGE_DIMENSIONS_INVALID);
-      return;
+    let nextImages;
+    let nextSelected;
+    if (action.mode === "replace") {
+      const replacement = await inputFromFile(files[0]);
+      if (localSelectionId !== selectionId) return;
+      const replaceIndex = Number.isInteger(action.index) && action.index >= 0 && action.index < images.length
+        ? action.index
+        : 0;
+      nextImages = images.slice();
+      nextImages[replaceIndex] = replacement;
+      nextSelected = replaceIndex;
+      if (files.length > 1) showToast("One selected slot was replaced; extra files were not added.", "warning");
+    } else {
+      const remaining = limits.max_input_images - images.length;
+      if (remaining <= 0) {
+        showToast(`You can use up to ${limits.max_input_images} input images. Select a slot to replace it.`, "warning");
+        return;
+      }
+      const acceptedFiles = files.slice(0, remaining);
+      const additions = await Promise.all(acceptedFiles.map(inputFromFile));
+      if (localSelectionId !== selectionId) return;
+      nextSelected = images.length;
+      nextImages = images.concat(additions);
+      if (files.length > acceptedFiles.length) {
+        showToast(`Only ${limits.max_input_images} input images are supported.`, "warning");
+      }
     }
-    const b64 = await readFileAsDataUrl(file);
-    if (localSelectionId !== selectionId) return;
-    replaceInput(b64, file.name);
-    showToast("Input image ready", "info");
+    validateInputTotals(nextImages);
+    setInputs(nextImages, nextSelected);
+    showToast(`${nextImages.length} input image${nextImages.length === 1 ? "" : "s"} ready`, "info");
   } catch (error) {
     console.warn("[image-editor] input validation failed", { error_class: errorClass(error) });
-    showToast(PUBLIC_ERROR_MESSAGES.I2I_IMAGE_DECODE_FAILED);
+    const code = extractPublicErrorCode(error);
+    showToast(PUBLIC_ERROR_MESSAGES[code]);
   }
 }
 
 fileInput.addEventListener("change", () => {
-  const file = fileInput.files && fileInput.files[0];
-  void processFile(file);
+  const files = fileInput.files;
+  void processFiles(files, pendingUpload);
   fileInput.value = "";
+  pendingUpload = { mode: "add", index: -1 };
 });
-btnUpload.addEventListener("click", () => fileInput.click());
-btnRemove.addEventListener("click", clearInput);
-btnClear.addEventListener("click", clearInput);
+btnUpload.addEventListener("click", openFilePicker);
+btnRemove.addEventListener("click", () => removeInput(selectedImageIndex));
+btnClear.addEventListener("click", clearInputs);
 
 let dragDepth = 0;
 window.addEventListener("dragenter", (event) => {
@@ -413,8 +564,7 @@ window.addEventListener("drop", (event) => {
   dropOverlay.classList.remove("visible");
   const files = event.dataTransfer && event.dataTransfer.files;
   if (!files || !files.length) return;
-  if (files.length > 1) showToast("Only the first image will be used.", "warning");
-  void processFile(files[0]);
+  void processFiles(files);
 });
 
 document.addEventListener("paste", (event) => {
@@ -422,13 +572,28 @@ document.addEventListener("paste", (event) => {
   if (event.target === promptInput) return;
   const items = event.clipboardData && event.clipboardData.items;
   if (!items) return;
-  const item = Array.from(items).find((candidate) => candidate.kind === "file" && limits.mime_types.includes(candidate.type));
-  const file = item && item.getAsFile();
-  if (!file) return;
+  const files = Array.from(items)
+    .filter((candidate) => candidate.kind === "file")
+    .map((candidate) => candidate.getAsFile())
+    .filter(Boolean);
+  if (!files.length) return;
   event.preventDefault();
-  void processFile(file);
+  void processFiles(files);
 });
 
+function showInspectorPage(page) {
+  const showEdit = page === "edit";
+  tabEdit.classList.toggle("active", showEdit);
+  tabExamples.classList.toggle("active", !showEdit);
+  tabEdit.setAttribute("aria-selected", String(showEdit));
+  tabExamples.setAttribute("aria-selected", String(!showEdit));
+  pageEdit.classList.toggle("active", showEdit);
+  pageExamples.classList.toggle("active", !showEdit);
+}
+
+tabEdit.addEventListener("click", () => showInspectorPage("edit"));
+tabExamples.addEventListener("click", () => showInspectorPage("examples"));
+
 SUGGESTIONS.forEach(([label, prompt]) => {
   const chip = document.createElement("button");
   chip.type = "button";
@@ -451,6 +616,132 @@ promptInput.addEventListener("input", () => {
   updateRunButton();
 });
 
+loraSelect.addEventListener("change", () => {
+  sbEditMode.textContent = loraSelect.value === GENERAL_MODE_ID ? "General / No LoRA" : loraSelect.value;
+  updateRunButton();
+});
+
+function renderLoraOptions(loraIds) {
+  loraSelect.replaceChildren();
+  const generalOption = document.createElement("option");
+  generalOption.value = GENERAL_MODE_ID;
+  generalOption.textContent = "General / No LoRA";
+  loraSelect.appendChild(generalOption);
+  loraIds.forEach((loraId) => {
+    const option = document.createElement("option");
+    option.value = loraId;
+    option.textContent = loraId;
+    loraSelect.appendChild(option);
+  });
+  loraSelect.value = GENERAL_MODE_ID;
+  loraSelect.disabled = false;
+  sbEditMode.textContent = "General / No LoRA";
+}
+
+function renderExamples(examples) {
+  examplesScroll.replaceChildren();
+  examples.forEach((example) => {
+    const card = document.createElement("button");
+    card.type = "button";
+    card.className = "example-card";
+    card.setAttribute("aria-label", `Load ${example.lora} example with ${example.n_images} image${example.n_images === 1 ? "" : "s"}`);
+
+    const thumbnails = document.createElement("span");
+    thumbnails.className = "example-thumbs";
+    example.thumbs.forEach((source, imageIndex) => {
+      const thumbnail = document.createElement("img");
+      thumbnail.src = source;
+      thumbnail.alt = `${example.lora} example input ${imageIndex + 1}`;
+      thumbnail.loading = "lazy";
+      thumbnail.decoding = "async";
+      thumbnails.appendChild(thumbnail);
+    });
+
+    const meta = document.createElement("span");
+    meta.className = "example-meta";
+    const imageBadge = document.createElement("span");
+    imageBadge.className = "example-badge";
+    imageBadge.textContent = `${example.n_images} img${example.n_images === 1 ? "" : "s"}`;
+    const loraBadge = document.createElement("span");
+    loraBadge.className = "example-lora-badge";
+    loraBadge.textContent = example.lora;
+    meta.append(imageBadge, loraBadge);
+
+    const promptText = document.createElement("span");
+    promptText.className = "example-prompt-text";
+    promptText.textContent = example.prompt;
+    card.append(thumbnails, meta, promptText);
+    card.addEventListener("click", () => void loadExample(card, example.idx));
+    examplesScroll.appendChild(card);
+  });
+}
+
+function validateLoadedExample(data) {
+  if (
+    !data || data.status !== "ok" ||
+    !Array.isArray(data.images) || !Array.isArray(data.names) ||
+    data.images.length < limits.min_input_images || data.images.length > limits.max_input_images ||
+    data.names.length !== data.images.length ||
+    typeof data.prompt !== "string" || !data.prompt.trim() || Array.from(data.prompt.trim()).length > limits.max_prompt_chars ||
+    typeof data.lora !== "string" || !EXPECTED_LORA_IDS.includes(data.lora) ||
+    !data.names.every((name) => typeof name === "string" && /^[A-Za-z0-9._ -]{1,128}$/.test(name))
+  ) {
+    throw new Error("invalid_example_payload");
+  }
+  return data;
+}
+
+async function loadExample(card, index) {
+  if (!contractReady || !client) {
+    showToast("The editor is not connected. Refresh the page.");
+    return;
+  }
+  if (running) {
+    showToast("Wait for the current edit to finish.", "warning");
+    return;
+  }
+  const loadId = ++exampleLoadId;
+  selectionId += 1;
+  loadingExample = true;
+  examplesScroll.querySelectorAll(".example-card").forEach((item) => { item.disabled = true; });
+  card.classList.add("loading");
+  setStatus("Loading example…");
+  updateRailState();
+  updateRunButton();
+  try {
+    const result = await client.predict("/load_example", { idx: index });
+    if (loadId !== exampleLoadId) return;
+    if (!result || !Array.isArray(result.data) || result.data.length !== 1) throw new Error("invalid_example_result");
+    const data = validateLoadedExample(result.data[0]);
+    const nextImages = await Promise.all(data.images.map((source, imageIndex) => inputFromDataUrl(source, data.names[imageIndex])));
+    if (loadId !== exampleLoadId) return;
+    validateInputTotals(nextImages);
+
+    promptInput.value = data.prompt.trim();
+    charCount.textContent = String(Array.from(promptInput.value).length);
+    suggestionsWrap.querySelectorAll(".suggestion-chip").forEach((item) => item.classList.remove("active"));
+    loraSelect.value = data.lora;
+    if (loraSelect.value !== data.lora) throw new Error("invalid_example_lora");
+    sbEditMode.textContent = data.lora;
+    setInputs(nextImages, 0);
+    showInspectorPage("edit");
+    setStatus("Ready");
+    showToast(`Example loaded — ${nextImages.length} image${nextImages.length === 1 ? "" : "s"}`, "info");
+  } catch (error) {
+    console.warn("[image-editor] example load failed", { error_class: errorClass(error) });
+    setStatus("Ready");
+    showToast("Could not load this example. Try again.");
+  } finally {
+    if (loadId === exampleLoadId) {
+      loadingExample = false;
+      examplesScroll.querySelectorAll(".example-card").forEach((item) => { item.disabled = false; });
+      card.classList.remove("loading");
+      updateRailState();
+      updateRunButton();
+    }
+  }
+}
+
 function bindSlider(slider) {
   const value = document.getElementById(`${slider.id}-val`);
   slider.addEventListener("input", () => { value.textContent = slider.value; });
@@ -515,7 +806,7 @@ function decodeOutput(dataUrl) {
         reject(new Error("I2I_INVALID_OUTPUT"));
         return;
       }
-      resolve();
+      resolve({ width: image.naturalWidth, height: image.naturalHeight });
     };
     image.onerror = () => reject(new Error("I2I_INVALID_OUTPUT"));
     image.src = dataUrl;
@@ -618,7 +909,8 @@ document.addEventListener("keydown", (event) => {
   if (event.key === "Escape") closeLightbox();
 });
 zoomBtn.addEventListener("click", () => {
-  const source = viewMode === "result" && currentResult ? currentResult.b64 : inputImage && inputImage.b64;
+  const selectedInput = selectedImageIndex >= 0 ? images[selectedImageIndex] : images[0];
+  const source = viewMode === "result" && currentResult ? currentResult.b64 : selectedInput && selectedInput.b64;
   if (!source) return;
   openLightbox(source, zoomBtn);
 });
@@ -631,10 +923,16 @@ dlBtn.addEventListener("click", () => {
   link.click();
   link.remove();
 });
-useAsInputBtn.addEventListener("click", () => {
+useAsInputBtn.addEventListener("click", async () => {
   if (!currentResult) return;
-  replaceInput(currentResult.b64, `hy3d-image-edit-${currentResult.seed}.png`);
-  showToast("Result is ready for another edit", "info");
+  try {
+    const nextInput = await inputFromDataUrl(currentResult.b64, `hy3d-image-edit-${currentResult.seed}.png`);
+    setInputs([nextInput], 0);
+    showToast("Result is ready for another edit", "info");
+  } catch (error) {
+    console.warn("[image-editor] result chaining failed", { error_class: errorClass(error) });
+    showToast(PUBLIC_ERROR_MESSAGES.I2I_INVALID_OUTPUT);
+  }
 });
 seedChip.addEventListener("click", () => {
   if (!currentResult || !navigator.clipboard) return;
@@ -658,8 +956,8 @@ function validateBeforeRun() {
     showToast("The editor is not connected. Refresh the page.");
     return false;
   }
-  if (!inputImage) {
-    showToast("Upload one image first.");
+  if (images.length < limits.min_input_images || images.length > limits.max_input_images) {
+    showToast(`Upload ${limits.min_input_images === limits.max_input_images ? limits.min_input_images : `${limits.min_input_images}–${limits.max_input_images}`} input images first.`);
     return false;
   }
   const prompt = promptInput.value.trim();
@@ -672,15 +970,21 @@ function validateBeforeRun() {
     showToast(PUBLIC_ERROR_MESSAGES.I2I_PROMPT_TOO_LONG);
     return false;
   }
+  if (!enabledEditModes.has(loraSelect.value)) {
+    showToast(PUBLIC_ERROR_MESSAGES.I2I_LORA_NOT_ALLOWED);
+    return false;
+  }
   return true;
 }
 
 async function runEdit() {
-  if (running || !validateBeforeRun()) return;
+  if (running || loadingExample || !validateBeforeRun()) return;
   const runId = ++activeRunId;
   cancellationRequested = false;
-  const beforeB64 = inputImage.b64;
+  const inputSnapshot = images.map((item) => item.b64);
+  const beforeB64 = inputSnapshot[0];
   const prompt = promptInput.value.trim();
+  const editMode = loraSelect.value;
   let parsedResult = null;
   setRunningUi(true, "preparing");
   setViewMode("result");
@@ -688,9 +992,9 @@ async function runEdit() {
   setStatus("Queued");
 
   const payload = {
-    images_b64_json: JSON.stringify([beforeB64]),
+    images_b64_json: JSON.stringify(inputSnapshot),
     prompt,
-    lora_adapter: GENERAL_MODE_ID,
+    lora_adapter: editMode,
     seed: Number.parseInt(seedSlider.value, 10),
     randomize_seed: randomizeInput.checked,
     guidance_scale: Number.parseFloat(guidanceSlider.value),
@@ -736,6 +1040,7 @@ async function runEdit() {
           b64: output.image,
           seed: output.seed,
           prompt,
+          editMode,
           beforeB64,
         };
       }
@@ -798,12 +1103,24 @@ document.addEventListener("keydown", (event) => {
 function validateConfig(config) {
   if (
     !config ||
-    config.edit_mode !== "general" ||
-    config.uses_lora !== false ||
-    config.required_lora_adapter_value !== GENERAL_MODE_ID ||
+    config.api_version !== EXPECTED_API_VERSION ||
+    config.edit_mode !== "general-and-lora" ||
+    config.uses_lora !== true ||
+    config.supports_general_mode !== true ||
+    config.general_mode_value !== GENERAL_MODE_ID ||
+    config.required_lora_adapter_value !== null ||
+    config.default_edit_mode !== GENERAL_MODE_ID ||
+    config.default_lora !== null ||
     config.content_moderation_enabled !== false ||
     !Array.isArray(config.loras) ||
-    config.loras.length !== 0 ||
+    config.loras.length !== EXPECTED_LORA_IDS.length ||
+    !EXPECTED_LORA_IDS.every((loraId, index) => config.loras[index] === loraId) ||
+    !Array.isArray(config.enabled_edit_modes) ||
+    config.enabled_edit_modes.length !== EXPECTED_LORA_IDS.length + 1 ||
+    config.enabled_edit_modes[0] !== GENERAL_MODE_ID ||
+    !EXPECTED_LORA_IDS.every((loraId, index) => config.enabled_edit_modes[index + 1] === loraId) ||
+    !Array.isArray(config.examples) ||
+    config.examples.length !== EXPECTED_LORA_IDS.length ||
     !config.limits
   ) {
     throw new Error("contract_mismatch");
@@ -814,9 +1131,14 @@ function validateConfig(config) {
     !Array.isArray(nextLimits.mime_types) ||
     nextLimits.mime_types.length !== expectedMimes.length ||
     !expectedMimes.every((mime) => nextLimits.mime_types.includes(mime)) ||
-    nextLimits.input_images !== 1 ||
+    nextLimits.input_images !== 2 ||
+    nextLimits.min_input_images !== 1 ||
+    nextLimits.max_input_images !== 2 ||
     !Number.isInteger(nextLimits.max_image_bytes) || nextLimits.max_image_bytes <= 0 ||
+    !Number.isInteger(nextLimits.max_total_image_bytes) || nextLimits.max_total_image_bytes !== nextLimits.max_image_bytes * 2 ||
+    !Number.isInteger(nextLimits.max_request_json_chars) || nextLimits.max_request_json_chars <= nextLimits.max_total_image_bytes ||
     !Number.isInteger(nextLimits.max_image_pixels) || nextLimits.max_image_pixels <= 0 ||
+    !Number.isInteger(nextLimits.max_total_image_pixels) || nextLimits.max_total_image_pixels !== nextLimits.max_image_pixels * 2 ||
     !Number.isInteger(nextLimits.min_image_side) || nextLimits.min_image_side <= 0 ||
     !Number.isInteger(nextLimits.max_prompt_chars) || nextLimits.max_prompt_chars <= 0 ||
     !Array.isArray(nextLimits.seed) ||
@@ -825,11 +1147,29 @@ function validateConfig(config) {
     nextLimits.seed.length !== 2 || !nextLimits.seed.every(Number.isInteger) || nextLimits.seed[0] < 0 || nextLimits.seed[0] > nextLimits.seed[1] ||
     nextLimits.guidance.length !== 2 || !nextLimits.guidance.every(Number.isFinite) || nextLimits.guidance[0] > nextLimits.guidance[1] ||
     nextLimits.steps.length !== 2 || !nextLimits.steps.every(Number.isInteger) || nextLimits.steps[0] < 1 || nextLimits.steps[0] > nextLimits.steps[1] ||
-    !Number.isInteger(nextLimits.max_output_side) || nextLimits.max_output_side <= 0
+    nextLimits.max_output_side !== 1024
   ) {
     throw new Error("invalid_limits");
   }
-  return nextLimits;
+
+  const seenExampleLoras = new Set();
+  config.examples.forEach((example, index) => {
+    if (
+      !example || example.idx !== index ||
+      !Number.isInteger(example.n_images) || example.n_images < nextLimits.min_input_images || example.n_images > nextLimits.max_input_images ||
+      !Array.isArray(example.thumbs) || example.thumbs.length !== example.n_images ||
+      !example.thumbs.every((source) => typeof source === "string" && /^data:image\/jpeg;base64,[A-Za-z0-9+/]+={0,2}$/.test(source)) ||
+      typeof example.prompt !== "string" || !example.prompt.trim() || Array.from(example.prompt.trim()).length > nextLimits.max_prompt_chars ||
+      typeof example.lora !== "string" || !EXPECTED_LORA_IDS.includes(example.lora)
+    ) {
+      throw new Error("invalid_examples");
+    }
+    seenExampleLoras.add(example.lora);
+  });
+  if (seenExampleLoras.size !== EXPECTED_LORA_IDS.length || !EXPECTED_LORA_IDS.every((loraId) => seenExampleLoras.has(loraId))) {
+    throw new Error("invalid_examples");
+  }
+  return config;
 }
 
 function applyLimits(nextLimits) {
@@ -851,7 +1191,11 @@ async function initialize() {
       Client.connect(window.location.origin, { events: ["data", "status"] }),
     ]);
     if (!configResponse.ok) throw new Error("config_unavailable");
-    applyLimits(validateConfig(await configResponse.json()));
+    const config = validateConfig(await configResponse.json());
+    applyLimits(config.limits);
+    enabledEditModes = new Set(config.enabled_edit_modes);
+    renderLoraOptions(config.loras);
+    renderExamples(config.examples);
     client = connectedClient;
     contractReady = true;
     connDot.classList.remove("off", "pending");
@@ -860,6 +1204,8 @@ async function initialize() {
   } catch (error) {
     console.warn("[image-editor] initialization failed", { error_class: errorClass(error) });
     contractReady = false;
+    enabledEditModes = new Set();
+    loraSelect.disabled = true;
     connDot.classList.remove("pending");
     connDot.classList.add("off");
     connText.textContent = "offline";

i2i_contract.py

@@ -19,14 +19,21 @@ from typing import Callable, Collection, Sequence
 from PIL import Image, ImageOps, UnidentifiedImageError
 
 
-API_VERSION = "2026-08-12.2"
+API_VERSION = "2026-08-12.3"
 CONTENT_MODERATION_ENABLED = False
 BASE_EDIT_MODE_ID = "__base__"
 
-MAX_INPUT_IMAGES = 1
+MIN_INPUT_IMAGES = 1
+MAX_INPUT_IMAGES = 2
 MAX_IMAGE_BYTES = 10 * 1024 * 1024
-MAX_REQUEST_JSON_CHARS = 4 * math.ceil(MAX_IMAGE_BYTES / 3) + 256
+MAX_TOTAL_IMAGE_BYTES = MAX_IMAGE_BYTES * MAX_INPUT_IMAGES
+# Bound the JSON string before parsing or allocating decoded byte buffers. The
+# fixed allowance covers two data-URL headers, JSON quoting/separators, and a
+# small amount of harmless whitespace while each encoded image remains subject
+# to its own exact limit below.
+MAX_REQUEST_JSON_CHARS = MAX_INPUT_IMAGES * (4 * math.ceil(MAX_IMAGE_BYTES / 3) + 64) + 256
 MAX_IMAGE_PIXELS = 16_000_000
+MAX_TOTAL_IMAGE_PIXELS = MAX_IMAGE_PIXELS * MAX_INPUT_IMAGES
 MIN_IMAGE_SIDE = 64
 MAX_OUTPUT_SIDE = 1024
 MAX_PROMPT_CHARS = 1000
@@ -86,6 +93,79 @@ class ValidatedEditRequest:
     steps: int
 
 
+class SingleResidentAdapterManager:
+    """Maintain a fail-closed, at-most-one-resident LoRA state machine.
+
+    The caller must serialize ``activate_mode`` with the same lock used for
+    inference. Marking a load dirty before mutation means a partial adapter
+    load is never treated as a clean base-model state.
+    """
+
+    def __init__(
+        self,
+        *,
+        adapter_modes: Collection[str],
+        load_adapter: Callable[[str], None],
+        activate_adapter: Callable[[str], None],
+        unload_adapters: Callable[[], None],
+    ):
+        self._adapter_modes = frozenset(adapter_modes)
+        self._load_adapter = load_adapter
+        self._activate_adapter = activate_adapter
+        self._unload_adapters = unload_adapters
+        self._resident_adapter_mode: str | None = None
+        self._dirty = False
+
+    @property
+    def resident_adapter_mode(self) -> str | None:
+        return self._resident_adapter_mode
+
+    @property
+    def dirty(self) -> bool:
+        return self._dirty
+
+    def _drop_resident_adapter(self) -> None:
+        if self._resident_adapter_mode is None and not self._dirty:
+            return
+        try:
+            self._unload_adapters()
+        except Exception:
+            self._resident_adapter_mode = None
+            self._dirty = True
+            raise
+        self._resident_adapter_mode = None
+        self._dirty = False
+
+    def activate_mode(self, edit_mode: str) -> None:
+        if edit_mode != BASE_EDIT_MODE_ID and edit_mode not in self._adapter_modes:
+            raise ContractError("I2I_LORA_NOT_ALLOWED")
+        if edit_mode == self._resident_adapter_mode and not self._dirty:
+            return
+
+        self._drop_resident_adapter()
+        if edit_mode == BASE_EDIT_MODE_ID:
+            return
+
+        # Loading can mutate the pipeline before raising, so assume the state
+        # is dirty until load + activation both complete.
+        self._dirty = True
+        try:
+            self._load_adapter(edit_mode)
+            self._activate_adapter(edit_mode)
+        except Exception:
+            try:
+                self._unload_adapters()
+            except Exception:
+                self._dirty = True
+            else:
+                self._dirty = False
+            self._resident_adapter_mode = None
+            raise
+
+        self._resident_adapter_mode = edit_mode
+        self._dirty = False
+
+
 def public_error_text(code: str) -> str:
     """Return a stable client-safe code and message."""
 
@@ -191,9 +271,35 @@ def _decode_images(images_b64_json: str) -> tuple[ValidatedInputImage, ...]:
         values = json.loads(images_b64_json)
     except (json.JSONDecodeError, TypeError):
         raise ContractError("I2I_BAD_REQUEST") from None
-    if not isinstance(values, list) or len(values) != MAX_INPUT_IMAGES:
+    if not isinstance(values, list) or not MIN_INPUT_IMAGES <= len(values) <= MAX_INPUT_IMAGES:
         raise ContractError("I2I_BAD_REQUEST")
-    return tuple(_decode_image_data_url(value) for value in values)
+
+    decoded_images: list[ValidatedInputImage] = []
+    total_bytes = 0
+    total_pixels = 0
+    for value in values:
+        image = _decode_image_data_url(value)
+        total_bytes += len(image.data)
+        if total_bytes > MAX_TOTAL_IMAGE_BYTES:
+            raise ContractError("I2I_FILE_TOO_LARGE")
+        total_pixels += image.width * image.height
+        if total_pixels > MAX_TOTAL_IMAGE_PIXELS:
+            raise ContractError("I2I_IMAGE_DIMENSIONS_INVALID")
+        decoded_images.append(image)
+    return tuple(decoded_images)
+
+
+def parse_example_index(value: object, total_examples: int) -> int | None:
+    """Return a bounded integer example index, rejecting coercive values."""
+
+    if isinstance(total_examples, bool) or not isinstance(total_examples, int) or total_examples < 0:
+        raise ValueError("total_examples must be a non-negative integer")
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    if isinstance(value, float) and (not math.isfinite(value) or not value.is_integer()):
+        return None
+    index = int(value)
+    return index if 0 <= index < total_examples else None
 
 
 def validate_edit_request(

index.html

@@ -239,6 +239,11 @@ body{
 @keyframes thumbIn{from{opacity:0;transform:scale(.92)}to{opacity:1;transform:scale(1)}}
 .fs-thumb:hover{border-color:var(--border2);transform:translateY(-2px)}
 .fs-thumb.selected{border-color:var(--accent);box-shadow:0 0 0 2px rgba(30,144,255,.25)}
+.fs-thumb-select{
+    display:block;width:100%;height:100%;padding:0;border:0;border-radius:inherit;
+    background:transparent;color:inherit;cursor:pointer;overflow:hidden;
+}
+.fs-thumb-select:focus-visible{outline:2px solid var(--accent2);outline-offset:-3px}
 .fs-thumb img{width:100%;height:100%;object-fit:cover}
 .fs-badge{
     position:absolute;bottom:4px;left:4px;background:rgba(0,0,0,.75);color:#fff;
@@ -311,6 +316,47 @@ body{
 .suggestion-chip:hover{background:rgba(30,144,255,.15);border-color:rgba(30,144,255,.35);color:var(--accent2)}
 .suggestion-chip.active{background:rgba(30,144,255,.25);border-color:var(--accent);color:#fff}
 
+.lora-native-select{
+    width:100%;background:var(--panel2);
+    border:1px solid var(--border2);border-radius:8px;
+    padding:9px 34px 9px 13px;
+    font-family:'Inter',sans-serif;font-size:12px;font-weight:600;color:var(--text);
+    outline:none;appearance:none;-webkit-appearance:none;
+    background-image:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%231E90FF' d='M6 8L1 3h10z'/%3E%3C/svg%3E");
+    background-repeat:no-repeat;background-position:right 11px center;
+    cursor:pointer;transition:border-color .2s;color-scheme:dark;
+}
+.lora-native-select:focus{border-color:var(--accent);box-shadow:0 0 0 3px rgba(30,144,255,.15)}
+.lora-native-select:disabled{opacity:.55;cursor:not-allowed}
+.lora-native-select option{background:var(--panel);color:var(--text)}
+
+/* Examples page */
+.examples-list{padding:12px 14px;display:flex;flex-direction:column;gap:10px}
+.example-card{
+    width:100%;text-align:left;background:var(--panel2);border:1px solid var(--border);
+    border-radius:10px;overflow:hidden;cursor:pointer;transition:all .2s ease;flex-shrink:0;
+    color:var(--text);font-family:'Inter',sans-serif;padding:0;
+}
+.example-card:hover:not(:disabled){border-color:var(--accent);box-shadow:0 4px 14px rgba(30,144,255,.15)}
+.example-card:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.example-card.loading,.example-card:disabled{opacity:.5;pointer-events:none}
+.example-thumbs{display:flex;height:96px;overflow:hidden;background:var(--panel)}
+.example-thumbs img{flex:1;object-fit:cover;min-width:0;border-bottom:1px solid var(--border)}
+.example-meta{padding:6px 10px 2px;display:flex;align-items:center;gap:5px;flex-wrap:wrap}
+.example-badge{
+    display:inline-flex;padding:2px 7px;background:rgba(30,144,255,.1);border-radius:4px;
+    font-size:9px;font-weight:600;color:var(--accent2);font-family:'JetBrains Mono',monospace;white-space:nowrap;
+}
+.example-lora-badge{
+    display:inline-flex;padding:2px 7px;background:rgba(255,255,255,.05);border-radius:4px;
+    font-size:9px;font-weight:600;color:var(--muted);font-family:'JetBrains Mono',monospace;
+    white-space:nowrap;border:1px solid var(--border);max-width:190px;overflow:hidden;text-overflow:ellipsis;
+}
+.example-prompt-text{
+    padding:4px 10px 9px;font-size:11px;color:var(--muted);line-height:1.45;
+    display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;overflow:hidden;
+}
+
 .btn-run{
     display:flex;align-items:center;justify-content:center;gap:8px;width:100%;
     background:linear-gradient(135deg,#1E90FF,#1873CC);border:none;border-radius:9px;
@@ -538,7 +584,7 @@ body{
       <svg viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path d="M12 23c-3.6 0-8-2.69-8-7.5 0-3.5 3-6.5 4.5-8 .27-.27.75-.08.75.28v2.44c0 .42.5.63.72.28C12.28 7.5 13 3 13 1c0-.42.48-.64.8-.35C18 4.5 20 9 20 12c0 5.5-3.5 11-8 11z"/></svg>
     </div>
     <div class="menubar-title">Hy3D Studio <span>/ Image Editor</span></div>
-    <span class="menubar-badge">GENERAL</span>
+    <span class="menubar-badge">GENERAL + LORA</span>
     <span class="menubar-badge fast">4 STEPS DEFAULT</span>
     <div class="menubar-spacer"></div>
     <div class="menubar-status"><span class="dot pending" id="conn-dot"></span><span id="conn-text" role="status" aria-live="polite">connecting…</span></div>
@@ -578,12 +624,13 @@ body{
 
   <!-- ══ Inspector ══ -->
   <div class="inspector">
-    <div class="inspector-tabs">
-      <button class="insp-tab active" type="button">Edit</button>
+    <div class="inspector-tabs" role="tablist" aria-label="Image editor panels">
+      <button class="insp-tab active" id="tab-edit" type="button" role="tab" aria-selected="true" aria-controls="page-edit">Edit</button>
+      <button class="insp-tab" id="tab-examples" type="button" role="tab" aria-selected="false" aria-controls="page-examples">Examples</button>
     </div>
 
     <!-- Edit page -->
-    <div class="insp-page active" id="page-edit">
+    <div class="insp-page active" id="page-edit" role="tabpanel" aria-labelledby="tab-edit">
       <div class="insp-section">
         <div class="insp-section-title"><span>Instruction</span><span class="char-count" id="char-count">0</span></div>
         <textarea id="custom-prompt-input" class="modern-textarea" rows="3" maxlength="1000"
@@ -595,6 +642,13 @@ body{
         <div class="suggestions-wrap" id="suggestions-wrap"></div>
       </div>
 
+      <div class="insp-section">
+        <div class="insp-section-title"><label for="custom-lora-select">Style / LoRA</label></div>
+        <select id="custom-lora-select" class="lora-native-select" disabled>
+          <option value="">Connecting&hellip;</option>
+        </select>
+      </div>
+
       <div class="insp-section">
         <button id="custom-run-btn" class="btn-run" disabled>
           <svg viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><path d="M12 23c-3.6 0-8-2.69-8-7.5 0-3.5 3-6.5 4.5-8 .27-.27.75-.08.75.28v2.44c0 .42.5.63.72.28C12.28 7.5 13 3 13 1c0-.42.48-.64.8-.35C18 4.5 20 9 20 12c0 5.5-3.5 11-8 11z"/></svg>
@@ -632,6 +686,11 @@ body{
         </div>
       </details>
     </div>
+
+    <!-- Examples page -->
+    <div class="insp-page" id="page-examples" role="tabpanel" aria-labelledby="tab-examples">
+      <div class="examples-list" id="examples-scroll"></div>
+    </div>
   </div>
 
   <!-- ══ Workspace ══ -->
@@ -662,7 +721,7 @@ body{
         </svg>
         <div class="cp-title">Canvas is empty</div>
         <div class="cp-sub">
-          Drop an image anywhere, paste with <kbd>⌘/Ctrl+V</kbd>, or use the rail to upload.
+          Drop up to two images anywhere, paste with <kbd>⌘/Ctrl+V</kbd>, or use the rail to upload.
           Then write an instruction and press <kbd>⌘/Ctrl</kbd>+<kbd>↵</kbd>.
         </div>
       </div>
@@ -693,14 +752,14 @@ body{
   <div class="statusbar">
     <div class="sb-section" id="sb-image-count">No inputs</div>
     <div class="sb-right">
-      <span class="sb-link">General mode · no LoRA</span>
+      <span class="sb-link" id="sb-edit-mode">General / No LoRA</span>
       <span class="sb-pill" id="sb-status" role="status" aria-live="polite" aria-atomic="true">Connecting…</span>
     </div>
   </div>
 
 </div>
 
-<input id="custom-file-input" type="file" accept="image/png,image/jpeg,image/webp" style="display:none;" />
+<input id="custom-file-input" type="file" accept="image/png,image/jpeg,image/webp" multiple style="display:none;" />
 
 <!-- Lightbox -->
 <div class="lightbox" id="lightbox" role="dialog" aria-modal="true" aria-label="Image preview" aria-hidden="true" tabindex="-1">
@@ -709,7 +768,7 @@ body{
 </div>
 
 <!-- Global drop overlay -->
-<div class="drop-overlay" id="drop-overlay"><div class="drop-overlay-inner">Drop one image to upload</div></div>
+<div class="drop-overlay" id="drop-overlay"><div class="drop-overlay-inner">Drop up to two images to upload</div></div>
 
 <script type="module" src="/hy3d-assets/app-ui.js"></script>
 </body>

provenance.py

@@ -25,9 +25,8 @@ class AdapterSpec:
     license_status: str
 
 
-# These are provenance-pinned candidates copied from the approved upstream
-# revision. They are not automatically enabled for the public API. Enabling a
-# candidate requires a later license/product decision and a code review.
+# These are the provenance-pinned adapters copied from the approved upstream
+# revision. Runtime code may only load entries from this immutable allowlist.
 CANDIDATE_ADAPTER_SPECS: dict[str, AdapterSpec] = {
     "Multiple-Angles": AdapterSpec(
         repo="dx8152/Qwen-Edit-2509-Multiple-angles",
@@ -165,12 +164,14 @@ CANDIDATE_ADAPTER_SPECS: dict[str, AdapterSpec] = {
 }
 
 
-# The public base edit mode deliberately loads no LoRA. Candidate records remain
-# pinned for provenance only and are not available to the runtime API.
-ENABLED_ADAPTER_IDS: frozenset[str] = frozenset()
+# General editing remains available without an adapter, while all 19 pinned
+# upstream adapters are explicitly enabled. The runtime keeps at most one LoRA
+# resident at a time; this allowlist does not imply that all weights are loaded.
+ENABLED_ADAPTER_IDS: frozenset[str] = frozenset(CANDIDATE_ADAPTER_SPECS)
 ENABLED_ADAPTER_SPECS = {
     adapter_id: CANDIDATE_ADAPTER_SPECS[adapter_id]
-    for adapter_id in sorted(ENABLED_ADAPTER_IDS)
+    for adapter_id in CANDIDATE_ADAPTER_SPECS
+    if adapter_id in ENABLED_ADAPTER_IDS
 }
 
 

tests/test_i2i_contract.py

@@ -1,3 +1,4 @@
+import ast
 import base64
 import json
 import struct
@@ -6,26 +7,36 @@ import time
 import unittest
 import zlib
 from io import BytesIO
+from pathlib import Path
+from unittest.mock import patch
 
 from PIL import Image, features
+from provenance import ENABLED_ADAPTER_SPECS
 
 from i2i_contract import (
     BASE_EDIT_MODE_ID,
     ContractError,
     MAX_IMAGE_BYTES,
+    MAX_INPUT_IMAGES,
     MAX_PROMPT_CHARS,
     MAX_REQUEST_JSON_CHARS,
     MAX_SEED,
+    MAX_TOTAL_IMAGE_BYTES,
+    MAX_TOTAL_IMAGE_PIXELS,
+    MIN_INPUT_IMAGES,
+    SingleResidentAdapterManager,
     decode_validated_images,
     encode_png_result,
     execute_validated_edit,
     output_dimensions,
+    parse_example_index,
     serialize_png_candidate,
     validate_edit_request,
 )
 
 
-ALLOWED_EDIT_MODES = {BASE_EDIT_MODE_ID}
+ALLOWED_EDIT_MODES = {BASE_EDIT_MODE_ID, "Anime-V2"}
+ROOT = Path(__file__).resolve().parents[1]
 
 
 def image_bytes(fmt="PNG", size=(128, 96), color=(20, 40, 60)):
@@ -77,6 +88,15 @@ class ContractTests(unittest.TestCase):
         self.assertEqual(decoded[0].size, (128, 96))
         self.assertEqual(output_dimensions(request.images[0]), (1024, 768))
 
+    def test_one_or_two_images_are_accepted(self):
+        first = data_url(image_bytes(color=(1, 2, 3)))
+        second = data_url(image_bytes(color=(4, 5, 6)))
+        one = validate_edit_request(**request_args(images_b64_json=json.dumps([first])))
+        two = validate_edit_request(**request_args(images_b64_json=json.dumps([first, second])))
+        self.assertEqual(len(one.images), MIN_INPUT_IMAGES)
+        self.assertEqual(len(two.images), MAX_INPUT_IMAGES)
+        self.assertEqual([image.width for image in two.images], [128, 128])
+
     def test_jpeg_and_webp_are_accepted(self):
         jpeg = json.dumps([data_url(image_bytes("JPEG"), "image/jpeg")])
         self.assertEqual(validate_edit_request(**request_args(images_b64_json=jpeg)).images[0].mime, "image/jpeg")
@@ -88,8 +108,8 @@ class ContractTests(unittest.TestCase):
         self.assert_code("I2I_BAD_REQUEST", images_b64_json="not-json")
         self.assert_code("I2I_BAD_REQUEST", images_b64_json="{}")
         self.assert_code("I2I_BAD_REQUEST", images_b64_json="[]")
-        two = json.dumps([data_url(image_bytes()), data_url(image_bytes())])
-        self.assert_code("I2I_BAD_REQUEST", images_b64_json=two)
+        three = json.dumps([data_url(image_bytes())] * 3)
+        self.assert_code("I2I_BAD_REQUEST", images_b64_json=three)
         self.assert_code("I2I_BAD_REQUEST", images_b64_json=json.dumps([123]))
 
     def test_mime_base64_and_magic_are_strict(self):
@@ -108,6 +128,16 @@ class ContractTests(unittest.TestCase):
         )
         self.assert_code("I2I_FILE_TOO_LARGE", images_b64_json=" " * (MAX_REQUEST_JSON_CHARS + 1))
 
+    def test_total_byte_and_pixel_limits_are_enforced(self):
+        raw = image_bytes()
+        two = json.dumps([data_url(raw), data_url(raw)])
+        with patch("i2i_contract.MAX_TOTAL_IMAGE_BYTES", len(raw) * 2 - 1):
+            self.assert_code("I2I_FILE_TOO_LARGE", images_b64_json=two)
+        with patch("i2i_contract.MAX_TOTAL_IMAGE_PIXELS", (128 * 96 * 2) - 1):
+            self.assert_code("I2I_IMAGE_DIMENSIONS_INVALID", images_b64_json=two)
+        self.assertEqual(MAX_TOTAL_IMAGE_BYTES, MAX_IMAGE_BYTES * MAX_INPUT_IMAGES)
+        self.assertEqual(MAX_TOTAL_IMAGE_PIXELS, 16_000_000 * MAX_INPUT_IMAGES)
+
     def test_dimensions_are_bounded(self):
         small = json.dumps([data_url(image_bytes(size=(63, 128)))])
         self.assert_code("I2I_IMAGE_DIMENSIONS_INVALID", images_b64_json=small)
@@ -120,7 +150,10 @@ class ContractTests(unittest.TestCase):
         self.assert_code("I2I_PROMPT_REQUIRED", prompt="  ")
         self.assert_code("I2I_PROMPT_TOO_LONG", prompt="x" * (MAX_PROMPT_CHARS + 1))
         self.assert_code("I2I_LORA_NOT_ALLOWED", lora_adapter="unknown")
-        self.assert_code("I2I_LORA_NOT_ALLOWED", lora_adapter="Anime-V2")
+        self.assertEqual(
+            validate_edit_request(**request_args(lora_adapter="Anime-V2")).edit_mode,
+            "Anime-V2",
+        )
         self.assert_code("I2I_BAD_REQUEST", seed=True)
         self.assert_code("I2I_BAD_REQUEST", seed=-1)
         self.assert_code("I2I_BAD_REQUEST", seed=MAX_SEED + 1)
@@ -188,6 +221,228 @@ class ContractTests(unittest.TestCase):
             worker.join()
         self.assertEqual(max_active, 1)
 
+    def test_single_resident_adapter_state_machine(self):
+        events = []
+        manager = SingleResidentAdapterManager(
+            adapter_modes={"Anime-V2", "Style-Transfer"},
+            load_adapter=lambda mode: events.append(("load", mode)),
+            activate_adapter=lambda mode: events.append(("activate", mode)),
+            unload_adapters=lambda: events.append(("unload", None)),
+        )
+
+        manager.activate_mode(BASE_EDIT_MODE_ID)
+        self.assertEqual(events, [])
+        manager.activate_mode("Anime-V2")
+        manager.activate_mode("Anime-V2")
+        self.assertEqual(manager.resident_adapter_mode, "Anime-V2")
+        self.assertFalse(manager.dirty)
+        manager.activate_mode("Style-Transfer")
+        manager.activate_mode(BASE_EDIT_MODE_ID)
+        self.assertEqual(
+            events,
+            [
+                ("load", "Anime-V2"),
+                ("activate", "Anime-V2"),
+                ("unload", None),
+                ("load", "Style-Transfer"),
+                ("activate", "Style-Transfer"),
+                ("unload", None),
+            ],
+        )
+        self.assertIsNone(manager.resident_adapter_mode)
+        self.assertFalse(manager.dirty)
+        with self.assertRaises(ContractError) as caught:
+            manager.activate_mode("unknown")
+        self.assertEqual(caught.exception.code, "I2I_LORA_NOT_ALLOWED")
+
+    def test_partial_adapter_load_is_cleaned_before_retry(self):
+        events = []
+
+        def load(mode):
+            events.append(("load", mode))
+            if mode == "Style-Transfer":
+                raise RuntimeError("synthetic load failure")
+
+        manager = SingleResidentAdapterManager(
+            adapter_modes={"Anime-V2", "Style-Transfer"},
+            load_adapter=load,
+            activate_adapter=lambda mode: events.append(("activate", mode)),
+            unload_adapters=lambda: events.append(("unload", None)),
+        )
+        manager.activate_mode("Anime-V2")
+        with self.assertRaises(RuntimeError):
+            manager.activate_mode("Style-Transfer")
+        self.assertIsNone(manager.resident_adapter_mode)
+        self.assertFalse(manager.dirty)
+        self.assertEqual(events[-3:], [("unload", None), ("load", "Style-Transfer"), ("unload", None)])
+        manager.activate_mode(BASE_EDIT_MODE_ID)
+        self.assertEqual(events[-1], ("unload", None))
+
+    def test_adapter_activation_failure_is_cleaned_before_next_mode(self):
+        events = []
+        fail_activation_once = True
+
+        def activate(mode):
+            nonlocal fail_activation_once
+            events.append(("activate", mode))
+            if fail_activation_once:
+                fail_activation_once = False
+                raise RuntimeError("synthetic activation failure")
+
+        manager = SingleResidentAdapterManager(
+            adapter_modes={"Anime-V2", "Style-Transfer"},
+            load_adapter=lambda mode: events.append(("load", mode)),
+            activate_adapter=activate,
+            unload_adapters=lambda: events.append(("unload", None)),
+        )
+
+        with self.assertRaises(RuntimeError):
+            manager.activate_mode("Anime-V2")
+        self.assertIsNone(manager.resident_adapter_mode)
+        self.assertFalse(manager.dirty)
+        self.assertEqual(
+            events,
+            [
+                ("load", "Anime-V2"),
+                ("activate", "Anime-V2"),
+                ("unload", None),
+            ],
+        )
+
+        manager.activate_mode("Style-Transfer")
+        self.assertEqual(manager.resident_adapter_mode, "Style-Transfer")
+        self.assertFalse(manager.dirty)
+        self.assertEqual(
+            events[-2:],
+            [("load", "Style-Transfer"), ("activate", "Style-Transfer")],
+        )
+
+    def test_failed_cleanup_stays_dirty_and_is_retried_before_base_mode(self):
+        events = []
+        fail_load_once = True
+        fail_unload_once = True
+
+        def load(mode):
+            nonlocal fail_load_once
+            events.append(("load", mode))
+            if fail_load_once:
+                fail_load_once = False
+                raise RuntimeError("synthetic load failure")
+
+        def unload():
+            nonlocal fail_unload_once
+            events.append(("unload", None))
+            if fail_unload_once:
+                fail_unload_once = False
+                raise RuntimeError("synthetic cleanup failure")
+
+        manager = SingleResidentAdapterManager(
+            adapter_modes={"Anime-V2"},
+            load_adapter=load,
+            activate_adapter=lambda mode: events.append(("activate", mode)),
+            unload_adapters=unload,
+        )
+
+        with self.assertRaises(RuntimeError):
+            manager.activate_mode("Anime-V2")
+        self.assertIsNone(manager.resident_adapter_mode)
+        self.assertTrue(manager.dirty)
+
+        manager.activate_mode(BASE_EDIT_MODE_ID)
+        self.assertIsNone(manager.resident_adapter_mode)
+        self.assertFalse(manager.dirty)
+        self.assertEqual(
+            events,
+            [
+                ("load", "Anime-V2"),
+                ("unload", None),
+                ("unload", None),
+            ],
+        )
+
+    def test_switch_unload_failure_is_retried_before_loading_new_mode(self):
+        events = []
+        unload_calls = 0
+
+        def unload():
+            nonlocal unload_calls
+            unload_calls += 1
+            events.append(("unload", None))
+            if unload_calls == 1:
+                raise RuntimeError("synthetic unload failure")
+
+        manager = SingleResidentAdapterManager(
+            adapter_modes={"Anime-V2", "Style-Transfer"},
+            load_adapter=lambda mode: events.append(("load", mode)),
+            activate_adapter=lambda mode: events.append(("activate", mode)),
+            unload_adapters=unload,
+        )
+
+        manager.activate_mode("Anime-V2")
+        with self.assertRaises(RuntimeError):
+            manager.activate_mode("Style-Transfer")
+        self.assertIsNone(manager.resident_adapter_mode)
+        self.assertTrue(manager.dirty)
+        self.assertNotIn(("load", "Style-Transfer"), events)
+
+        manager.activate_mode("Style-Transfer")
+        self.assertEqual(manager.resident_adapter_mode, "Style-Transfer")
+        self.assertFalse(manager.dirty)
+        self.assertEqual(
+            events[-3:],
+            [
+                ("unload", None),
+                ("load", "Style-Transfer"),
+                ("activate", "Style-Transfer"),
+            ],
+        )
+
+    def test_example_index_requires_a_finite_bounded_integer(self):
+        self.assertEqual(parse_example_index(0, 19), 0)
+        self.assertEqual(parse_example_index(18.0, 19), 18)
+        for invalid in (True, "1", None, -1, 19, 1.5, float("nan"), float("inf")):
+            self.assertIsNone(parse_example_index(invalid, 19))
+        with self.assertRaises(ValueError):
+            parse_example_index(0, -1)
+
+    def test_fixed_example_manifest_matches_all_enabled_loras(self):
+        tree = ast.parse((ROOT / "app.py").read_text(encoding="utf-8"))
+        assignment = next(
+            node
+            for node in tree.body
+            if isinstance(node, ast.Assign)
+            and any(isinstance(target, ast.Name) and target.id == "EXAMPLES_CONFIG" for target in node.targets)
+        )
+        examples = ast.literal_eval(assignment.value)
+        self.assertEqual(len(examples), 19)
+        self.assertEqual({example["lora"] for example in examples}, set(ENABLED_ADAPTER_SPECS))
+        self.assertTrue(all(1 <= len(example["images"]) <= 2 for example in examples))
+        self.assertEqual(sum(len(example["images"]) == 2 for example in examples), 3)
+        for example in examples:
+            for relative_path in example["images"]:
+                path = (ROOT / relative_path).resolve()
+                self.assertTrue(path.is_relative_to((ROOT / "examples").resolve()))
+                self.assertTrue(path.is_file())
+        upscaler = next(example for example in examples if example["lora"] == "Upscaler")
+        self.assertEqual(upscaler["prompt"], "Upscale and enhance image detail.")
+
+    def test_example_endpoint_is_non_gpu_and_adapter_mutation_is_pinned(self):
+        source = (ROOT / "app.py").read_text(encoding="utf-8")
+        tree = ast.parse(source)
+        load_example = next(
+            node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name == "load_example"
+        )
+        decorators = [ast.unparse(decorator) for decorator in load_example.decorator_list]
+        self.assertEqual(decorators, ["app.api(name='load_example', queue=False)"])
+        self.assertIn("revision=spec.revision", source)
+        self.assertIn("pipe.unload_lora_weights()", source)
+        self.assertIn("ADAPTER_MANAGER.activate_mode(request.edit_mode)", source)
+        lock_start = source.index("with PIPELINE_LOCK:")
+        activation = source.index("ADAPTER_MANAGER.activate_mode(request.edit_mode)")
+        inference = source.index("result = pipe(", activation)
+        self.assertLess(lock_start, activation)
+        self.assertLess(activation, inference)
+
     def test_output_contract_rejects_non_png_bad_dimensions_and_seed(self):
         with self.assertRaises(ContractError) as caught:
             encode_png_result(image_bytes("JPEG"), 1)

tests/test_space_static.py

@@ -15,7 +15,7 @@ class SpaceStaticTests(unittest.TestCase):
     def test_remote_assets_are_pinned_and_candidate_count_is_stable(self):
         provenance.assert_pinned_provenance()
         self.assertEqual(len(provenance.CANDIDATE_ADAPTER_SPECS), 19)
-        self.assertEqual(set(provenance.ENABLED_ADAPTER_SPECS), set())
+        self.assertEqual(set(provenance.ENABLED_ADAPTER_SPECS), set(provenance.CANDIDATE_ADAPTER_SPECS))
         for spec in provenance.CANDIDATE_ADAPTER_SPECS.values():
             self.assertRegex(spec.revision, r"^[0-9a-f]{40}$")
             self.assertNotEqual(spec.revision, "main")
@@ -45,6 +45,9 @@ class SpaceStaticTests(unittest.TestCase):
                 "I2I_INVALID_OUTPUT",
             },
         )
+        source = (ROOT / "app.py").read_text(encoding="utf-8")
+        self.assertIn("return message in {", source)
+        self.assertNotIn('message.startswith(f"{code}:")', source)
 
     def test_edit_endpoint_has_seven_fields_and_serial_concurrency(self):
         tree = ast.parse((ROOT / "app.py").read_text(encoding="utf-8"))
@@ -75,45 +78,68 @@ class SpaceStaticTests(unittest.TestCase):
         self.assertNotRegex(source, r"\{\s*(?:e|exc)\s*\}")
         self.assertNotIn("str(exc)", source)
         self.assertNotIn("traceback", source)
-        self.assertNotIn("load_lora_weights", source)
-        self.assertNotIn("set_adapters", source)
-        self.assertNotIn("unload_lora_weights", source)
+        self.assertIn("load_lora_weights", source)
+        self.assertIn("revision=spec.revision", source)
+        self.assertIn("set_adapters", source)
+        self.assertIn("unload_lora_weights", source)
+        self.assertIn("SingleResidentAdapterManager", source)
 
-    def test_public_runtime_is_explicitly_general_no_lora_mode(self):
+    def test_public_runtime_has_general_default_and_19_opt_in_loras(self):
         source = (ROOT / "app.py").read_text(encoding="utf-8")
-        self.assertIn('"edit_mode": "general"', source)
-        self.assertIn('"uses_lora": False', source)
-        self.assertIn("allowed_edit_modes={BASE_EDIT_MODE_ID}", source)
+        self.assertIn('"edit_mode": "general-and-lora"', source)
+        self.assertIn('"uses_lora": True', source)
+        self.assertIn('"supports_general_mode": True', source)
+        self.assertIn('"default_edit_mode": BASE_EDIT_MODE_ID', source)
+        self.assertIn("allowed_edit_modes={BASE_EDIT_MODE_ID, *ENABLED_ADAPTER_SPECS}", source)
 
-    def test_homepage_is_an_interactive_self_hosted_single_image_editor(self):
+    def test_homepage_is_a_hardened_full_feature_editor(self):
         html = (ROOT / "index.html").read_text(encoding="utf-8")
         script = (ROOT / "assets" / "app-ui.js").read_text(encoding="utf-8")
 
         self.assertIn('src="/hy3d-assets/app-ui.js"', html)
         self.assertIn('accept="image/png,image/jpeg,image/webp"', html)
-        self.assertNotIn(" multiple", html)
-        self.assertNotIn("Style / LoRA", html)
-        self.assertNotIn("tab-examples", html)
+        self.assertIn(" multiple", html)
+        self.assertIn("Style / LoRA", html)
+        self.assertIn('id="tab-examples"', html)
+        self.assertIn('id="examples-scroll"', html)
         self.assertNotRegex(html, r'<(?:script|link)[^>]+(?:src|href)=["\']https?://')
         self.assertNotIn("googleapis", html.lower())
         self.assertNotIn("jsdelivr", html.lower())
 
         self.assertIn('const GENERAL_MODE_ID = "__base__"', script)
-        self.assertIn("images_b64_json: JSON.stringify([beforeB64])", script)
-        self.assertIn("lora_adapter: GENERAL_MODE_ID", script)
+        self.assertIn('const EXPECTED_API_VERSION = "2026-08-12.3"', script)
+        self.assertIn("images_b64_json: JSON.stringify(inputSnapshot)", script)
+        self.assertIn("lora_adapter: editMode", script)
         self.assertIn('events: ["data", "status"]', script)
         self.assertIn("await currentJob.wait_for_id()", script)
         self.assertIn("await job.return()", script)
-        self.assertIn("uses_lora !== false", script)
-        self.assertIn("config.loras.length !== 0", script)
-        self.assertIn("nextLimits.input_images !== 1", script)
+        self.assertIn("config.uses_lora !== true", script)
+        self.assertIn("config.loras.length !== EXPECTED_LORA_IDS.length", script)
+        self.assertIn("nextLimits.input_images !== 2", script)
+        self.assertIn("nextLimits.min_input_images !== 1", script)
+        self.assertIn("nextLimits.max_input_images !== 2", script)
+        self.assertIn('client.predict("/load_example", { idx: index })', script)
         self.assertIn("Stopped waiting for this job. The backend may still finish it.", script)
         self.assertNotIn("Queued job cancelled", script)
         self.assertNotIn('hideLoader("Cancelled")', script)
-        self.assertNotIn("Anime-V2", script)
-        self.assertNotIn("Photo-to-Anime", script)
-        self.assertNotIn("/load_example", script)
-        self.assertNotIn("cfg.examples", script)
+        self.assertIn('"Anime-V2"', script)
+        self.assertIn('"Photo-to-Anime"', script)
+        self.assertIn('"General / No LoRA"', script)
+        lora_block = re.search(r"const EXPECTED_LORA_IDS = Object\.freeze\(\[(.*?)\]\);", script, re.DOTALL)
+        self.assertIsNotNone(lora_block)
+        ui_loras = re.findall(r'^\s*"([^"]+)",?$', lora_block.group(1), re.MULTILINE)
+        self.assertEqual(ui_loras, list(provenance.CANDIDATE_ADAPTER_SPECS))
+        suggestion_block = re.search(r"const SUGGESTIONS = Object\.freeze\(\[(.*?)\]\);", script, re.DOTALL)
+        self.assertIsNotNone(suggestion_block)
+        self.assertEqual(len(re.findall(r'^\s*\["', suggestion_block.group(1), re.MULTILINE)), 16)
+        suggestion_handler = re.search(r"SUGGESTIONS\.forEach\(.*?\n\}\);", script, re.DOTALL)
+        self.assertIsNotNone(suggestion_handler)
+        self.assertNotIn("loraSelect", suggestion_handler.group(0))
+        self.assertIn('["Upscale / Enhance", "Enhance clarity and fine detail while preserving the original composition."]', script)
+        self.assertNotIn("Upscale 4K", script)
+        self.assertNotIn("4K resolution", script)
+        self.assertNotIn("card.innerHTML", script)
+        self.assertIn("card.append(thumbnails, meta, promptText)", script)
 
         self.assertIn('class="dot pending"', html)
         self.assertIn("4 STEPS DEFAULT", html)
@@ -125,6 +151,17 @@ class SpaceStaticTests(unittest.TestCase):
         self.assertIn("studio.inert = true", script)
         self.assertIn("function isLightboxOpen()", script)
         self.assertGreaterEqual(script.count("if (isLightboxOpen()) return;"), 3)
+        input_strip = re.search(r"function renderInputStrip\(\) \{(.*?)\n\}", script, re.DOTALL)
+        self.assertIsNotNone(input_strip)
+        self.assertIn('const select = document.createElement("button")', input_strip.group(1))
+        self.assertIn('select.type = "button"', input_strip.group(1))
+        self.assertIn('select.className = "fs-thumb-select"', input_strip.group(1))
+        self.assertIn('select.setAttribute("aria-label", `Select input image ${index + 1}`)', input_strip.group(1))
+        self.assertIn('select.setAttribute("aria-pressed", String(index === selectedImageIndex))', input_strip.group(1))
+        self.assertIn("select.append(image, badge)", input_strip.group(1))
+        self.assertIn("thumb.append(select, remove)", input_strip.group(1))
+        self.assertNotIn('thumb.addEventListener("click"', input_strip.group(1))
+        self.assertIn(".fs-thumb-select:focus-visible", html)
 
     def test_browser_client_is_exactly_vendored(self):
         client_path = ROOT / "assets" / "gradio-client-2.3.1.js"
@@ -156,9 +193,12 @@ class SpaceStaticTests(unittest.TestCase):
             self.assertRegex(package, r"^[A-Za-z0-9_.-]+==[^=<>~]+$")
         self.assertEqual((ROOT / "pre-requirements.txt").read_text(encoding="utf-8").strip(), "pip==26.1.2")
 
-    def test_examples_are_not_exposed_by_api_or_homepage(self):
+    def test_examples_are_fixed_non_gpu_api_assets(self):
         source = (ROOT / "app.py").read_text(encoding="utf-8")
-        self.assertNotIn("load_example", source)
+        self.assertIn('@app.api(name="load_example", queue=False)', source)
+        self.assertIn("def load_example(idx: float) -> dict", source)
+        self.assertIn("parse_example_index", source)
+        self.assertIn("EXAMPLES_CONFIG", source)
         self.assertIn("blocked_paths=[examples_path]", source)
 
     def test_kernel_revision_is_pinned(self):