Upload 6 files

Age_classifier.py

@@ -0,0 +1,1202 @@
+"""
+Age classifier: blocks prompts and images that depict or describe a minor.
+
+Public API:
+    check_prompt_no_minors(text)
+    check_image_no_minors(pil_image, context="image")
+    warmup()
+
+Both checks raise gr.Error on a hit. Runs on CPU by default; set GUARD_DEVICE=cuda
+to use the GPU.
+"""
+
+import os
+import csv
+import datetime
+import threading
+import time
+import gradio as gr
+import torch
+
+# CPU by default: the age model is small, and this keeps VRAM free for the
+# main pipelines. Set GUARD_DEVICE=cuda to run it on the GPU instead.
+device = "cuda" if (os.environ.get("GUARD_DEVICE", "cpu") == "cuda" and torch.cuda.is_available()) else "cpu"
+
+import re
+
+GUARD_ENABLED = os.environ.get("GUARD_ENABLED", "1") != "0"
+AGE_MODEL_ID = os.environ.get("AGE_MODEL_ID", "AST-1320/vit-age-classifier")
+_GUARD_PRESETS = {
+    "strict": {
+        "teen_confidence": 0.5, "teen_margin": 0.10,
+        "hard_bucket_min": 0.30, "hard_mass": 0.40,
+        "whole_image": 0.70, "no_face_hard": 0.40,
+    },
+    "balanced": {
+        "teen_confidence": 0.6, "teen_margin": 0.15,
+        "hard_bucket_min": 0.40, "hard_mass": 0.50,
+        "whole_image": 0.85, "no_face_hard": 0.60,
+    },
+    "lenient": {
+        "teen_confidence": 0.8, "teen_margin": 0.20,
+        "hard_bucket_min": 0.50, "hard_mass": 0.60,
+        "whole_image": 0.90, "no_face_hard": 0.75,
+    },
+}
+GUARD_PRESET = os.environ.get("GUARD_PRESET", "balanced").strip().lower()
+if GUARD_PRESET not in _GUARD_PRESETS:
+    print(f"[guard] unknown GUARD_PRESET '{GUARD_PRESET}', using 'balanced'")
+    GUARD_PRESET = "balanced"
+_PRESET = _GUARD_PRESETS[GUARD_PRESET]
+# The age model's output buckets are: 0-2, 3-9, 10-19, 20-29, 30-39, ...
+# "0-2" and "3-9" are blocked at ANY confidence — real photos of adults are
+# essentially never misclassified into these buckets.
+# "10-19" is the bucket most prone to false positives on youthful-looking
+# adults (a known weakness of this classifier, especially on East Asian
+# faces), so it only blocks when the model is reasonably confident — a
+# narrow top-1 win over "20-29" is not enough on its own.
+_HARD_MINOR_BUCKETS = {"0-2", "3-9"}
+_SOFT_MINOR_BUCKET = "10-19"
+_ADULT_COMPARISON_BUCKET = "20-29"
+MINOR_TEEN_CONFIDENCE_THRESHOLD = float(os.environ.get("MINOR_TEEN_CONFIDENCE_THRESHOLD", _PRESET["teen_confidence"]))
+# Beyond the raw confidence threshold above, also require the "10-19" bucket
+# to win by at least this much over the adjacent "20-29" bucket. A narrow win
+# (e.g. 0.51 vs 0.49) is a coin flip and shouldn't carry the same weight as a
+# decisive one (e.g. 0.9 vs 0.05) — this cuts down on borderline false
+# positives against youthful-looking adults without touching the threshold.
+MINOR_TEEN_MARGIN = float(os.environ.get("MINOR_TEEN_MARGIN", _PRESET["teen_margin"]))
+
+# --- Calibration for GENERATED images only (context="output") ----------------
+# Input photos (any other context) keep the original strict rules. A generated
+# image is different: stylised / AI faces are out-of-distribution for a model
+# trained on real photos, and when no face is found the classifier is asked to
+# score a whole scene, which is the least reliable thing it can be asked.
+#   * face crop: a hard bucket (0-2 / 3-9) blocks when it is the top label with
+#     score >= HARD_BUCKET_MIN_SCORE, OR when the two hard buckets together hold
+#     >= HARD_MASS_THRESHOLD of the probability (catches "spread out" results).
+#   * no face found: only block on a clear result (>= WHOLE_IMAGE_THRESHOLD).
+HARD_BUCKET_MIN_SCORE = float(os.environ.get("HARD_BUCKET_MIN_SCORE", _PRESET["hard_bucket_min"]))
+HARD_MASS_THRESHOLD = float(os.environ.get("HARD_MASS_THRESHOLD", _PRESET["hard_mass"]))
+WHOLE_IMAGE_THRESHOLD = float(os.environ.get("WHOLE_IMAGE_THRESHOLD", _PRESET["whole_image"]))
+NO_FACE_HARD_THRESHOLD = float(os.environ.get("NO_FACE_HARD_THRESHOLD", _PRESET["no_face_hard"]))
+
+MEDIAPIPE_MODEL_URL = os.environ.get(
+    "MEDIAPIPE_FACE_MODEL_URL",
+    "https://storage.googleapis.com/mediapipe-models/face_detector/"
+    "blaze_face_short_range/float16/1/blaze_face_short_range.tflite",
+)
+MEDIAPIPE_MODEL_PATH = os.environ.get(
+    "MEDIAPIPE_FACE_MODEL_PATH",
+    os.path.join(os.environ.get("TMPDIR", "/tmp"), "blaze_face_short_range.tflite"),
+)
+MEDIAPIPE_MIN_CONFIDENCE = float(os.environ.get("MEDIAPIPE_MIN_CONFIDENCE", "0.5"))
+
+_age_classifier = None
+_face_cascade = None
+_mediapipe_detector = None
+_mediapipe_retry_at = 0.0
+_mediapipe_init_lock = threading.Lock()
+_mediapipe_lock = threading.Lock()
+MEDIAPIPE_RETRY_SECONDS = float(os.environ.get("MEDIAPIPE_RETRY_SECONDS", "60"))
+MEDIAPIPE_TILE_FRACTIONS = tuple(
+    float(v) for v in os.environ.get("MEDIAPIPE_TILE_FRACTIONS", "0.5,0.33").split(",") if v.strip()
+)
+
+
+def _load_age_classifier():
+    """Lazy-load the age-estimation model. Loading fails closed: if it can't
+    load, generation is blocked rather than silently skipping the check."""
+    global _age_classifier
+    if _age_classifier is not None:
+        return _age_classifier
+    try:
+        from transformers import pipeline as hf_pipeline
+        _age_classifier = hf_pipeline(
+            "image-classification",
+            model=AGE_MODEL_ID,
+            device=0 if device == "cuda" else -1,
+        )
+        print(f"Loaded Guard age classifier: {AGE_MODEL_ID}")
+        return _age_classifier
+    except Exception as exc:
+        raise gr.Error(
+            "Guard filter failed to load (missing 'transformers' or model "
+            "download failed). Generation is blocked until this is fixed."
+        ) from exc
+
+
+def _load_face_cascade():
+    """Lazy-load an OpenCV Haar cascade face detector (fallback path)."""
+    global _face_cascade
+    if _face_cascade is not None:
+        return _face_cascade
+    try:
+        import cv2
+        cascade_path = cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
+        cascade = cv2.CascadeClassifier(cascade_path)
+        _face_cascade = cascade
+        return _face_cascade
+    except Exception as exc:
+        raise gr.Error(
+            "Guard filter failed to load (missing 'opencv-python-headless'). "
+            "Generation is blocked until this is fixed."
+        ) from exc
+
+
+def _load_mediapipe_detector():
+    """Lazy-load Google's mediapipe face detector. This is the primary
+    detector — it's meaningfully more robust than Haar cascade on angled,
+    partially-occluded, or unevenly-lit faces, which matters here because a
+    missed face falls back to scoring the whole image (noisier, worse for
+    both false positives and false negatives). Returns None if mediapipe
+    isn't installed, so callers can fall back to Haar cascade rather than
+    hard-failing — Haar cascade alone is still a valid, working detector."""
+    global _mediapipe_detector, _mediapipe_retry_at
+    if os.environ.get("MEDIAPIPE_ENABLED", "1") == "0":
+        return None
+    if _mediapipe_detector is not None:
+        return _mediapipe_detector
+    if time.time() < _mediapipe_retry_at:
+        return None
+    with _mediapipe_init_lock:
+        if _mediapipe_detector is not None:
+            return _mediapipe_detector
+        if time.time() < _mediapipe_retry_at:
+            return None
+        try:
+            from mediapipe.tasks import python as mp_python
+            from mediapipe.tasks.python import vision as mp_vision
+
+            if not os.path.exists(MEDIAPIPE_MODEL_PATH):
+                import urllib.request
+                tmp_path = MEDIAPIPE_MODEL_PATH + ".part"
+                urllib.request.urlretrieve(MEDIAPIPE_MODEL_URL, tmp_path)
+                os.replace(tmp_path, MEDIAPIPE_MODEL_PATH)
+            _mediapipe_detector = mp_vision.FaceDetector.create_from_options(
+                mp_vision.FaceDetectorOptions(
+                    base_options=mp_python.BaseOptions(model_asset_path=MEDIAPIPE_MODEL_PATH),
+                    running_mode=mp_vision.RunningMode.IMAGE,
+                    min_detection_confidence=MEDIAPIPE_MIN_CONFIDENCE,
+                )
+            )
+            print("Loaded Guard face detector: mediapipe (Tasks API)")
+        except Exception as exc:
+            print(f"[guard] mediapipe unavailable ({exc}); using Haar cascade, retrying in {MEDIAPIPE_RETRY_SECONDS:.0f}s")
+            _mediapipe_detector = None
+            _mediapipe_retry_at = time.time() + MEDIAPIPE_RETRY_SECONDS
+        return _mediapipe_detector
+
+
+def _mp_detect_array(detector, arr):
+    import numpy as _np
+    import mediapipe as mp
+    mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=_np.ascontiguousarray(arr))
+    with _mediapipe_lock:
+        result = detector.detect(mp_image)
+    return [
+        (int(d.bounding_box.origin_x), int(d.bounding_box.origin_y),
+         int(d.bounding_box.width), int(d.bounding_box.height))
+        for d in result.detections
+    ]
+
+
+def _box_overlap(a, b):
+    ax, ay, aw, ah = a
+    bx, by, bw, bh = b
+    iw = min(ax + aw, bx + bw) - max(ax, bx)
+    ih = min(ay + ah, by + bh) - max(ay, by)
+    if iw <= 0 or ih <= 0:
+        return 0.0
+    return (iw * ih) / max(1, min(aw * ah, bw * bh))
+
+
+def _merge_boxes(boxes, threshold=0.5):
+    kept = []
+    for box in sorted(boxes, key=lambda b: b[2] * b[3], reverse=True):
+        if all(_box_overlap(box, k) < threshold for k in kept):
+            kept.append(box)
+    return kept
+
+
+def _detect_faces_mediapipe(rgb_image):
+    """Return (x, y, w, h) boxes using mediapipe, or None if unavailable."""
+    detector = _load_mediapipe_detector()
+    if detector is None:
+        return None
+    import numpy as _np
+    arr = _np.array(rgb_image.convert("RGB"))
+    h_img, w_img = arr.shape[:2]
+
+    boxes = _mp_detect_array(detector, arr)
+
+    for frac in MEDIAPIPE_TILE_FRACTIONS:
+        if not 0.1 <= frac < 1.0:
+            continue
+        tw, th = max(64, int(w_img * frac)), max(64, int(h_img * frac))
+        if tw >= w_img and th >= h_img:
+            continue
+        step_x, step_y = max(1, tw // 2), max(1, th // 2)
+        xs = list(range(0, max(1, w_img - tw + 1), step_x))
+        ys = list(range(0, max(1, h_img - th + 1), step_y))
+        if xs[-1] + tw < w_img:
+            xs.append(w_img - tw)
+        if ys[-1] + th < h_img:
+            ys.append(h_img - th)
+        for ty in ys:
+            for tx in xs:
+                tile = arr[ty:ty + th, tx:tx + tw]
+                for (x, y, w, h) in _mp_detect_array(detector, tile):
+                    edge = max(2, int(0.02 * max(tw, th)))
+                    cut = (
+                        (tx > 0 and x <= edge)
+                        or (ty > 0 and y <= edge)
+                        or (tx + tw < w_img and x + w >= tw - edge)
+                        or (ty + th < h_img and y + h >= th - edge)
+                    )
+                    if not cut:
+                        boxes.append((x + tx, y + ty, w, h))
+
+    return _merge_boxes(boxes)
+
+
+def _detect_faces_haar(rgb_image):
+    """Return (x, y, w, h) boxes using OpenCV Haar cascade (fallback)."""
+    import numpy as _np
+    cascade = _load_face_cascade()
+    gray = _np.array(rgb_image.convert("L"))
+    faces = cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40))
+    return list(faces)
+
+
+def _extract_faces(pil_image):
+    """Return (crop, is_face_crop) pairs: cropped face regions (with margin), preferring mediapipe and
+    falling back to Haar cascade if mediapipe isn't installed or finds
+    nothing. If no face is detected by either, fall back to checking the
+    whole image so nothing slips through unchecked.
+
+    NOTE: the whole image is only used as a last-resort fallback, not
+    checked in addition to a found face crop. This classifier is trained on
+    face-centric crops; feeding it a full scene (background, hands, objects)
+    is out of distribution and can produce unreliable — including
+    unconditionally-blocking "0-2" hard-bucket — false positives. Once a
+    face is found, only the face crop(s) are scored."""
+    rgb = pil_image.convert("RGB")
+    w_img, h_img = rgb.size
+
+    boxes = _detect_faces_mediapipe(rgb)
+    if not boxes:
+        boxes = _detect_faces_haar(rgb)
+
+    if not boxes:
+        return [(rgb, False)]
+
+    crops = []
+    for (x, y, w, h) in boxes:
+        pad = int(0.4 * max(w, h))
+        x0, y0 = max(0, x - pad), max(0, y - pad)
+        x1, y1 = min(w_img, x + w + pad), min(h_img, y + h + pad)
+        if x1 > x0 and y1 > y0:
+            crops.append(rgb.crop((x0, y0, x1, y1)))
+
+    return [(c, True) for c in crops] if crops else [(rgb, False)]
+
+
+# Shared, explicit user-facing message for every Guard block (image or
+# prompt). Deliberately spells out *why* the request was blocked instead of a
+# vague "content not allowed", so a user who is confused (like in the
+# screenshot report) can immediately understand what triggered it, instead of
+# guessing. Wording only — this does not change what gets blocked or when.
+GUARD_BLOCK_MESSAGE = (
+    "Blocked by Guard: this image/prompt appears to depict or "
+    "describe someone under 18. This app does not generate, edit, or process "
+    "any content involving minors, for any reason or context — this is not "
+    "adjustable and applies even if the person is an adult who looks young, "
+    "a school uniform or similar styling is involved, or the intent is "
+    "non-sexual. If you believe this was flagged in error, try a different "
+    "photo/prompt that doesn't resemble a minor. If the match was a false "
+    "alarm (a name, a brand, or the age of an object rather than a person), "
+    "just rephrase that part and try again."
+)
+
+
+GUARD_NO_FACE_MESSAGE = (
+    "Blocked by Guard: no clear face was detected in this image, and the image "
+    "as a whole looked like it may involve someone under 18. If this is a photo "
+    "of an adult, try one where the face is clearly visible and well lit — the "
+    "check is much more accurate that way. This app does not generate, edit, or "
+    "process any content involving minors."
+)
+
+GUARD_LOG_PATH = os.environ.get("GUARD_LOG_PATH", "guard_blocks.csv")
+_GUARD_LOG_FIELDS = [
+    "time_utc", "preset", "context", "face", "reason", "top_label", "top_score",
+    "hard_mass", "teen_score", "adult_score", "image_size",
+]
+_guard_log_lock = threading.Lock()
+
+
+def _write_guard_log(row):
+    if not GUARD_LOG_PATH:
+        return
+    row = {
+        "time_utc": datetime.datetime.now(datetime.timezone.utc).isoformat(timespec="seconds"),
+        "preset": GUARD_PRESET,
+        **row,
+    }
+    try:
+        with _guard_log_lock:
+            is_new = not os.path.exists(GUARD_LOG_PATH) or os.path.getsize(GUARD_LOG_PATH) == 0
+            with open(GUARD_LOG_PATH, "a", newline="", encoding="utf-8") as fh:
+                writer = csv.DictWriter(fh, fieldnames=_GUARD_LOG_FIELDS, extrasaction="ignore")
+                if is_new:
+                    writer.writeheader()
+                writer.writerow(row)
+    except Exception as exc:
+        print(f"[guard] could not write block log: {exc}")
+
+
+def _block_image(context, is_face, reason, scores, top_label, hard_mass, pil_image):
+    width, height = pil_image.size
+    _write_guard_log({
+        "context": context,
+        "face": is_face,
+        "reason": reason,
+        "top_label": top_label,
+        "top_score": round(scores[top_label], 3),
+        "hard_mass": round(hard_mass, 3),
+        "teen_score": round(scores.get(_SOFT_MINOR_BUCKET, 0.0), 3),
+        "adult_score": round(scores.get(_ADULT_COMPARISON_BUCKET, 0.0), 3),
+        "image_size": f"{width}x{height}",
+    })
+    raise gr.Error(GUARD_BLOCK_MESSAGE if is_face else GUARD_NO_FACE_MESSAGE)
+
+
+def check_image_no_minors(pil_image, context="image"):
+    """Raise gr.Error if pil_image appears to depict anyone in a minor age
+    bracket.
+
+    context != "output" (e.g. "input", a user-supplied photo): the original
+    strict rules. "0-2"/"3-9" block unconditionally; "10-19" blocks only at
+    reasonably high confidence, to cut down on false positives against
+    youthful-looking adults while still catching clear cases.
+
+    context == "output" (a generated image): same idea, calibrated for the fact
+    that stylised / AI-generated faces are out-of-distribution for this model.
+    See HARD_BUCKET_MIN_SCORE / HARD_MASS_THRESHOLD / WHOLE_IMAGE_THRESHOLD.
+    """
+    if not GUARD_ENABLED or pil_image is None:
+        return
+    classifier = _load_age_classifier()
+    lenient = (context == "output")
+    for face, is_face in _extract_faces(pil_image):
+        try:
+            preds = classifier(face, top_k=None)
+        except TypeError:
+            # Some pipeline versions use `top_k` differently; fall back.
+            try:
+                preds = classifier(face)
+            except Exception:
+                raise gr.Error(
+                    "This request was blocked: the image could not be verified as safe."
+                )
+        except Exception:
+            # If the classifier can't score this crop, fail closed.
+            raise gr.Error(
+                "This request was blocked: the image could not be verified as safe."
+            )
+        if not preds:
+            continue
+
+        scores = {p["label"].strip(): p["score"] for p in preds}
+        top_label = max(scores, key=scores.get)
+        hard_mass = sum(scores.get(b, 0.0) for b in _HARD_MINOR_BUCKETS)
+
+        if lenient and is_face:
+            hard_hit = (
+                (top_label in _HARD_MINOR_BUCKETS and scores[top_label] >= HARD_BUCKET_MIN_SCORE)
+                or hard_mass >= HARD_MASS_THRESHOLD
+            )
+        elif lenient:
+            hard_hit = hard_mass >= WHOLE_IMAGE_THRESHOLD
+        elif not is_face:
+            hard_hit = hard_mass >= NO_FACE_HARD_THRESHOLD
+        else:
+            hard_hit = top_label in _HARD_MINOR_BUCKETS
+        if hard_hit:
+            print(
+                f"[guard] BLOCKED {context} image (hard bucket) label={top_label} "
+                f"score={scores[top_label]:.3f} hard_mass={hard_mass:.3f} face={is_face}"
+            )
+            _block_image(context, is_face, "hard_bucket", scores, top_label, hard_mass, pil_image)
+
+        if top_label == _SOFT_MINOR_BUCKET:
+            teen_score = scores[top_label]
+            adult_score = scores.get(_ADULT_COMPARISON_BUCKET, 0.0)
+            margin = teen_score - adult_score
+            threshold = MINOR_TEEN_CONFIDENCE_THRESHOLD
+            if lenient and not is_face:
+                threshold = max(threshold, WHOLE_IMAGE_THRESHOLD)
+            if teen_score >= threshold and margin >= MINOR_TEEN_MARGIN:
+                print(
+                    f"[guard] BLOCKED {context} image (soft bucket) label={top_label} "
+                    f"score={teen_score:.3f} threshold={threshold} "
+                    f"margin={margin:.3f} (min {MINOR_TEEN_MARGIN}) face={is_face}"
+                )
+                _block_image(context, is_face, "soft_bucket", scores, top_label, hard_mass, pil_image)
+            else:
+                print(
+                    f"[guard] soft bucket hit but not decisive enough — "
+                    f"label={top_label} score={teen_score:.3f} margin={margin:.3f} "
+                    f"(needs score>={threshold} and margin>={MINOR_TEEN_MARGIN})"
+                )
+
+
+# Prompt-level filter — blocks prompts that describe a minor. This tool does not
+# generate depictions of minors at all, so the policy itself is unchanged; what
+# changed is HOW words are matched, so that harmless prompts stop colliding:
+#   * non-Latin keywords and a small core of English words ("child", "baby",
+#     "toddler", ...) use plain substring + compact (space-stripped) matching;
+#   * every other Latin-script keyword (Spanish, Vietnamese, Indonesian, ...) is
+#     matched at the START of a word, with spaced-out evasion ("b e b e") only
+#     accepted when it is a standalone token. Without that, the space-stripped
+#     text turned "to be better" into "bebe" and "them below" into "em be".
+# Multilingual by design: prompts aren't only in English.
+_MINOR_KEYWORDS = [
+    # --- English ---
+    "child", "children", "kid", "kids", "toddler", "infant", "baby", "babies",
+    "tween", "preteen", "pre-teen", "teen", "teens", "teenage", "teenager",
+    "minor", "underage", "under-age", "schoolgirl", "schoolboy",
+    "elementary school", "middle school", "high schooler",
+    "little girl", "little boy", "young girl", "young boy",
+    "sweet sixteen", "sweet 16",
+
+    # --- Spanish ---
+    "niño", "nina", "niña", "ninos", "niños", "ninas", "niñas", "nino",
+    "infante", "bebé", "bebe", "bebés", "bebes", "menor de edad", "menor",
+    "adolescente", "adolescentes", "colegiala", "colegial",
+    "niña pequeña", "niño pequeño",
+
+    # --- Portuguese ---
+    "criança", "crianca", "crianças", "criancas", "bebê", "bebes",
+    "menor de idade", "adolescente", "adolescentes", "colegial", "colegiala",
+    "garotinha", "garotinho",
+
+    # --- French ---
+    "enfant", "enfants", "bébé", "bebe", "bébés", "tout-petit",
+    "adolescent", "adolescente", "adolescents", "mineur", "mineure",
+    "mineurs", "écolière", "ecoliere", "écolier", "ecolier",
+    "petite fille", "petit garçon", "petit garcon",
+
+    # --- German ---
+    "kind", "kinder", "kleinkind", "säugling", "saugling", "baby",
+    "teenager", "minderjährig", "minderjahrig", "minderjährige",
+    "schulmädchen", "schulmadchen", "schuljunge",
+    "kleines mädchen", "kleines madchen", "kleiner junge",
+
+    # --- Italian ---
+    "bambino", "bambina", "bambini", "bambine", "neonato", "neonata",
+    "adolescente", "adolescenti", "minorenne", "minorenni",
+    "scolaretta", "scolaro",
+    "bambina piccola", "bambino piccolo",
+
+    # --- Dutch ---
+    "kind", "kinderen", "kleuter", "baby", "peuter",
+    "tiener", "tieners", "minderjarig", "minderjarige",
+    "schoolmeisje", "schooljongen",
+
+    # --- Russian ---
+    "ребёнок", "ребенок", "дети", "малыш", "малышка", "младенец",
+    "подросток", "подростки", "несовершеннолетний", "несовершеннолетняя",
+    "школьница", "школьник", "маленькая девочка", "маленький мальчик",
+
+    # --- Ukrainian ---
+    "дитина", "діти", "немовля", "малюк", "підліток",
+    "неповнолітній", "неповнолітня", "школярка", "школяр",
+
+    # --- Polish ---
+    "dziecko", "dzieci", "niemowlę", "niemowle", "maluch",
+    "nastolatek", "nastolatka", "niepełnoletni", "niepelnoletni",
+    "uczennica", "uczeń", "uczen", "mała dziewczynka", "mala dziewczynka",
+    "mały chłopiec", "maly chlopiec",
+
+    # --- Turkish ---
+    "çocuk", "cocuk", "çocuklar", "cocuklar", "bebek", "yürüyen çocuk",
+    "genç", "genc", "ergen", "reşit olmayan", "resit olmayan",
+    "okul kızı", "okul kizi", "okul çocuğu", "küçük kız", "kucuk kiz",
+    "küçük erkek", "kucuk erkek",
+
+    # --- Arabic ---
+    "طفل", "طفلة", "أطفال", "اطفال", "رضيع", "رضيعة",
+    "مراهق", "مراهقة", "قاصر", "قاصرة",
+    "تلميذة", "تلميذ", "فتاة صغيرة", "ولد صغير",
+
+    # --- Persian/Farsi ---
+    "کودک", "بچه", "نوزاد", "نوجوان", "خردسال", "صغیر",
+    "دختر بچه", "پسر بچه",
+
+    # --- Urdu ---
+    "بچہ", "بچی", "بچے", "شیر خوار", "نوعمر", "نابالغ",
+    "چھوٹی لڑکی", "چھوٹا لڑکا",
+
+    # --- Hindi ---
+    "बच्चा", "बच्ची", "बच्चे", "शिशु", "बालक", "बालिका",
+    "किशोर", "किशोरी", "नाबालिग",
+    "छोटी लड़की", "छोटा लड़का",
+
+    # --- Bengali ---
+    "শিশু", "বাচ্চা", "শিশুরা", "কিশোর", "কিশোরী", "নাবালক", "নাবালিকা",
+    "ছোট মেয়ে", "ছোট ছেলে",
+
+    # --- Punjabi ---
+    "ਬੱਚਾ", "ਬੱਚੀ", "ਬੱਚੇ", "ਨਾਬਾਲਗ",
+
+    # --- Marathi ---
+    "मूल", "मुलगी", "मुलगा", "बालक", "अल्पवयीन",
+
+    # --- Tamil ---
+    "குழந்தை", "சிறுவன்", "சிறுமி", "இளம்பருவத்தினர்", "வயது வராதவர்",
+
+    # --- Telugu ---
+    "పిల్లవాడు", "పిల్ల", "శిశువు", "కౌమారదశ", "మైనర్",
+
+    # --- Kannada ---
+    "ಮಗು", "ಮಕ್ಕಳು", "ಶಿಶು", "ಹದಿಹರೆಯದ", "ಅಪ್ರಾಪ್ತ",
+
+    # --- Malayalam ---
+    "കുട്ടി", "കുട്ടികൾ", "ശിശു", "കൗമാരക്കാരൻ", "പ്രായപൂർത്തിയാകാത്ത",
+
+    # --- Gujarati ---
+    "બાળક", "બાળકો", "શિશુ", "કિશોર", "સગીર",
+
+    # --- Nepali ---
+    "बालक", "बालि��ा", "शिशु", "किशोर", "नाबालिग",
+
+    # --- Sinhala ---
+    "දරුවා", "බිළිඳා", "නව යොවුන්", "අවයස්කරු",
+
+    # --- Chinese (Simplified & Traditional) ---
+    "孩子", "小孩", "儿童", "兒童", "婴儿", "嬰兒", "幼儿", "幼兒",
+    "少年", "少女", "青少年", "未成年", "未成年人",
+    "女童", "男童", "小女孩", "小男孩", "小学生", "小學生", "中学生", "中學生",
+
+    # --- Japanese ---
+    "子供", "こども", "子ども", "幼児", "赤ちゃん", "赤ん坊",
+    "少年", "少女", "十代", "未成年", "未成年者",
+    "女子小学生", "男子小学生", "小学生", "中学生", "女子中学生",
+
+    # --- Korean ---
+    "아이", "어린이", "아기", "유아", "영아",
+    "청소년", "미성년자", "미성년",
+    "여자아이", "남자아이", "초등학생", "여중생", "여고생",
+
+    # --- Vietnamese ---
+    "trẻ em", "tre em", "trẻ con", "tre con", "em bé", "em be",
+    "thiếu niên", "thieu nien", "vị thành niên", "vi thanh nien",
+    "trẻ vị thành niên", "học sinh", "hoc sinh",
+    "bé gái", "be gai", "bé trai", "be trai",
+
+    # --- Thai ---
+    "เด็ก", "เด็กๆ", "ทารก", "เด็กทารก",
+    "วัยรุ่น", "ผู้เยาว์", "เด็กหญิง", "เด็กชาย", "นักเรียนหญิง", "นักเรียนชาย",
+
+    # --- Indonesian / Malay ---
+    "anak", "anak-anak", "bayi", "balita",
+    "remaja", "di bawah umur", "dibawah umur",
+    "murid perempuan", "murid lelaki", "gadis kecil", "anak perempuan kecil",
+    "anak lelaki kecil", "budak perempuan", "budak lelaki",
+
+    # --- Tagalog / Filipino ---
+    "bata", "mga bata", "sanggol", "paslit",
+    "wala pang sapat na gulang",
+    "batang babae", "batang lalaki",
+
+    # --- Burmese ---
+    "ကလေး", "ကလေးများ", "နို့စို့", "လူငယ်", "အသက်မပြည့်သေးသူ",
+
+    # --- Khmer ---
+    "កុមារ", "ក្មេង", "ទារក", "យុវវ័យ", "អនីតិជន",
+
+    # --- Lao ---
+    "ເດັກນ້ອຍ", "ເດັກ", "ໄວລຸ້ນ", "ຜູ້ຍັງບໍ່ບັນລຸນິຕິພາວະ",
+
+    # --- Hebrew ---
+    "ילד", "ילדה", "ילדים", "תינוק", "תינוקת",
+    "מתבגר", "מתבגרת", "קטין", "קטינה",
+    "ילדה קטנה", "ילד קטן",
+
+    # --- Greek ---
+    "παιδί", "παιδι", "παιδιά", "παιδια", "μωρό", "μωρο", "βρέφος", "βρεφος",
+    "έφηβος", "εφηβος", "έφηβη", "εφηβη", "ανήλικος", "ανηλικος",
+    "ανήλικη", "ανηλικη", "μικρό κορίτσι", "μικρο κοριτσι",
+    "μικρό αγόρι", "μικρο αγορι",
+
+    # --- Swahili ---
+    "mtoto", "watoto", "mtoto mchanga", "kijana", "kijana mdogo",
+    "mtoto mdogo wa kike", "mtoto mdogo wa kiume",
+
+    # --- Hausa ---
+    "yaro", "yarinya", "yara", "jariri", "matashi",
+
+    # --- Amharic ---
+    "ልጅ", "ልጆች", "ጨቅላ", "ታዳጊ", "ታዳጊ ወጣት",
+
+    # --- Yoruba ---
+    "ọmọde", "omode", "ọmọ", "omo", "ọmọ ọwọ́", "omo owo",
+
+    # --- Romanian ---
+    "copil", "copilă", "copila", "copii", "bebeluș", "bebelus",
+    "adolescent", "adolescentă", "adolescenta", "minor", "minoră", "minora",
+    "fetiță", "fetita", "băiețel", "baietel",
+
+    # --- Hungarian ---
+    "gyermek", "gyerek", "gyerekek", "csecsemő", "csecsemo",
+    "tizenéves", "tizeneves", "kiskorú", "kiskoru",
+    "kislány", "kislany", "kisfiú", "kisfiu",
+
+    # --- Czech ---
+    "dítě", "dite", "děti", "deti", "kojenec", "batole",
+    "nezletilý", "nezletily", "nezletilá", "nezletila",
+    "školačka", "skolacka", "školák", "skolak",
+
+    # --- Swedish ---
+    "barn", "barnet", "spädbarn", "spadbarn", "tonåring", "tonaring",
+    "minderårig", "minderarig", "skolflicka", "skolpojke",
+
+    # --- Finnish ---
+    "lapsi", "lapset", "vauva", "taapero", "teini", "alaikäinen", "alaikainen",
+    "koulutyttö", "koulutytto", "koulupoika",
+]
+# "10 year old whisky" / "5 year old oak" are ages of OBJECTS, not people. Skip
+# them only when the noun after "old" is a known non-person noun that is not
+# itself followed by a person noun ("10 year old cat girl" still blocks).
+_OLD_NONHUMAN = (
+    r"wine|whisk(?:e)?y|scotch|bourbon|cognac|brandy|cheese|oak|trees?|houses?|homes?|"
+    r"buildings?|churche?s?|castles?|barns?|cars?|trucks?|bikes?|boats?|ships?|"
+    r"compan(?:y|ies)|brands?|business(?:es)?|bottles?|ruins?|vines?|bonsai|"
+    r"manuscripts?|books?"
+)
+_OLD_PERSON = r"girls?|boys?|kids?|child(?:ren)?|maids?|ladies|lady|wom[ae]n|m[ae]n|guys?|females?|males?"
+_NOT_NONHUMAN_OLD = (
+    r"(?![\s-]+(?:" + _OLD_NONHUMAN + r")(?![a-z])(?![\s-]+(?:" + _OLD_PERSON + r")(?![a-z])))"
+)
+_MINOR_AGE_PATTERN = re.compile(
+    r"\b(?:age[d]?\s*)?([0-9]|1[0-7])\s*[- ]?\s*(?:years?[\s-]?old" + _NOT_NONHUMAN_OLD + r"|yo\b|y\.o\.?)",
+    re.IGNORECASE,
+)
+
+# --- Multilingual numeric-age detection ------------------------------------
+# The pattern above only ever caught the English construction ("15 years
+# old", "15 yo"). Every other language expresses "age 15" differently
+# ("อายุ 15ปี", "15 años", "15岁", "15세", "בת 15", "15 tuổi", ...), and none
+# of those were covered — a prompt in any non-English language describing a
+# specific under-18 age slipped straight through. This closes that gap
+# generically: a list of "age" prefix/suffix words per language, matched
+# immediately adjacent to a 0-17 number.
+#
+# Suffix words = come AFTER the number ("15 years old", "15ปี", "15岁").
+# Prefix words  = come BEFORE the number ("age 15", "อายุ 15", "בת 15").
+_AGE_SUFFIX_WORDS = [
+    # Units that can only mean "N years old" for a person: always checked.
+    "jahre alt", "jährig", "jährige", "jahrig", "jahrige",
+    "jaar oud",
+    "yaşında", "yasinda", "yaş",
+    "岁", "歲", "歳",
+    "살",
+    "tuổi", "tuoi",
+    "ขวบ",
+    "ساله",
+    "வயது",
+    "വയസ്സ്",
+    "taong gulang",
+    "éves",
+    "årig",
+    "vuotias",
+]
+# Units that just mean "year(s)" ("10 ปี" = 10 years, "5 tahun lalu" = 5 years
+# ago, "3 ans", "2 anos"). Matching these blindly flagged "cafe, 10th
+# anniversary 10 ปี". They only count when the prompt is clearly about a person
+# (see _PERSON_CUE_RE), the number is followed by a real word boundary, and the
+# match is not a prefix of a longer word ("5 animals" != "5 ani").
+_AGE_SUFFIX_AMBIGUOUS_WORDS = [
+    "años", "año", "anos", "ano", "ans", "anni", "jaar",
+    "лет", "года", "год", "років", "рік", "роки",
+    "lat", "let", "letá", "leta", "letý", "lety",
+    "세", "才", "ปี",
+    "سنة", "سنوات", "عاما", "عامًا", "سال",
+    "साल", "वर्ष", "বছর", "సంవత్సరాలు", "ఏళ్ళ", "ವರ್ಷ",
+    "tahun", "gulang", "שנים", "χρονών", "ετών", "χρόνων",
+    "miaka", "ani", "år",
+]
+_AGE_PREFIX_WORDS = [
+    # English "age"/"aged"/"age de" are handled by _EN_AGE_PREFIX_RE below
+    # (word-boundary aware). Matching them here on the compacted text made
+    # "image1" -> "age1" look like "age 1".
+    # Thai
+    "อายุ",
+    # Spanish / French
+    "edad de", "edad", "âgé de", "âgée de",
+    # German
+    "im alter von",
+    # Persian / Arabic
+    "سن", "بعمر", "في سن", "عمرها", "عمره",
+    # Hebrew (also literally "daughter of" / "son of", used for age)
+    "בגיל", "בת", "בן",
+    # Hindi / Urdu
+    "उम्र", "عمر",
+    # Indonesian / Malay
+    "berusia", "usia",
+    # Chinese
+    "年龄", "年齡",
+]
+
+# Non-Latin numeral systems (Arabic-Indic, Devanagari, Thai, etc.) map onto
+# the same ASCII digits so "๑๕ปี" (Thai digits) is caught the same as
+# "15ปี". Each of these Unicode blocks is 10 consecutive code points for
+# digits 0-9.
+_DIGIT_BLOCK_STARTS = [
+    0x0660,  # Arabic-Indic
+    0x06F0,  # Extended Arabic-Indic (Persian/Urdu)
+    0x0966,  # Devanagari
+    0x09E6,  # Bengali
+    0x0A66,  # Gurmukhi
+    0x0AE6,  # Gujarati
+    0x0B66,  # Oriya
+    0x0BE6,  # Tamil
+    0x0C66,  # Telugu
+    0x0CE6,  # Kannada
+    0x0D66,  # Malayalam
+    0x0E50,  # Thai
+    0x0ED0,  # Lao
+    0x1040,  # Myanmar
+    0x17E0,  # Khmer
+    0xFF10,  # Fullwidth
+]
+_DIGIT_TRANS = {}
+for _start in _DIGIT_BLOCK_STARTS:
+    for _i in range(10):
+        _DIGIT_TRANS[_start + _i] = str(_i)
+
+# --- Anti-evasion normalization -------------------------------------------
+# Plain "kw in text" substring matching is easy to dodge with spacing tricks
+# ("chil d"), invisible characters, stretched-out letters ("chiiiild"),
+# leetspeak ("ch1ld"), or look-alike letters from other scripts ("сhild"
+# with a Cyrillic с). This normalizes both the prompt and the keyword list
+# into a "compact" form before matching, so those tricks collapse back to
+# the plain word instead of slipping through. This is deliberately
+# aggressive (matching against a version of the whole prompt with all
+# spaces removed) — for this filter, an occasional false positive on an
+# unlucky adjacent word is a far better outcome than a missed evasion.
+import unicodedata
+
+# Unicode format characters (zero-width space/joiner/non-joiner, word
+# joiner, BOM, soft hyphen, directional marks, etc.) — invisible on screen,
+# often used to split a blocked word into pieces that don't string-match.
+_INVISIBLE_RE = re.compile(
+    "[" + "".join(
+        chr(c) for c in range(0x110000)
+        if unicodedata.category(chr(c)) == "Cf"
+    ) + "\u00ad]"
+)
+
+# Visible separator/punctuation characters commonly inserted between
+# letters to break up a word ("c-h-i-l-d", "c.h.i.l.d", "c_h_i_l_d").
+_SEPARATOR_RE = re.compile(r"[\s\-_.,*/\\|+~^`'\"!?:;()\[\]{}<>=]+")
+
+# Common leetspeak / symbol substitutions for Latin-script text.
+_LEET_MAP = str.maketrans({
+    "0": "o", "1": "i", "3": "e", "4": "a", "5": "s",
+    "7": "t", "8": "b", "@": "a", "$": "s", "!": "i", "|": "l",
+})
+
+# A small set of frequently-abused look-alike letters from other scripts
+# (Cyrillic, Greek) mapped to their Latin visual equivalent, so mixed-script
+# spoofing of Latin keywords ("сhild" with Cyrillic с) still matches. This
+# does not affect matching of the genuine Cyrillic/Greek keywords above,
+# since the same mapping is applied consistently to both the prompt and the
+# keyword list before comparison.
+_HOMOGLYPH_MAP = str.maketrans({
+    "а": "a", "е": "e", "о": "o", "р": "p", "с": "c", "у": "y",
+    "х": "x", "і": "i", "ѕ": "s", "һ": "h", "ԁ": "d", "𝒌": "k",
+    "α": "a", "ο": "o", "ν": "n", "ρ": "p", "ι": "i", "κ": "k",
+})
+
+# Collapses runs of 3+ identical characters down to 1 ("chiiiild" ->
+# "child"). Threshold of 3 (not 2) avoids touching legitimate doubled
+# letters like "little" or "school".
+_STRETCH_RE = re.compile(r"(.)\1{2,}")
+
+
+def _normalize_for_age_matching(text):
+    """Like _normalize_for_matching below, but preserves digits as digits
+    instead of running them through the leetspeak map — that map turns "1"
+    into "i" and "5" into "s", which would silently turn "15" into "is" and
+    defeat every numeric-age check. Non-Latin digit scripts (Thai, Arabic,
+    Devanagari, ...) are folded to ASCII 0-9 first so localized numerals
+    aren't a bypass either."""
+    text = unicodedata.normalize("NFKC", text).lower()
+    text = _INVISIBLE_RE.sub("", text)
+    text = text.translate(_HOMOGLYPH_MAP)
+    text = text.translate(_DIGIT_TRANS)
+    text = _SEPARATOR_RE.sub("", text)
+    text = _STRETCH_RE.sub(r"\1", text)
+    return text
+
+
+def _build_age_regex(words, number_first):
+    alt = "|".join(re.escape(_normalize_for_age_matching(w)) for w in words if w)
+    number = r"(?:[0-9]|1[0-7])"
+    if number_first:
+        # number then unit word, e.g. "15ปี", "15años"
+        return re.compile(r"(?<!\d)(" + number + r")(?!\d)(?:" + alt + r")")
+    else:
+        # unit word then number, e.g. "age15", "อายุ15"
+        return re.compile(r"(?:" + alt + r")(" + number + r")(?!\d)")
+
+
+_AGE_SUFFIX_PATTERN = _build_age_regex(_AGE_SUFFIX_WORDS, number_first=True)
+_AGE_PREFIX_PATTERN = _build_age_regex(_AGE_PREFIX_WORDS, number_first=False)
+
+
+# English "N year(s) old" on separator-stripped text (catches "1 5 y e a r s o l d"),
+# with the same object-age exception as _MINOR_AGE_PATTERN.
+_AGE_EN_COMPACT_PATTERN = re.compile(
+    r"(?<!\d)(?:[0-9]|1[0-7])(?!\d)(?:years?|yrs?)old"
+    r"(?!(?:" + _OLD_NONHUMAN + r")(?!(?:" + _OLD_PERSON + r")))"
+)
+
+
+def _normalize_age_keep_spaces(text):
+    """Digit-preserving normalisation that keeps word boundaries."""
+    text = unicodedata.normalize("NFKC", text).lower()
+    text = _INVISIBLE_RE.sub("", text)
+    text = text.translate(_HOMOGLYPH_MAP)
+    return text.translate(_DIGIT_TRANS)
+
+
+_AGE_SUFFIX_AMBIGUOUS_PATTERN = re.compile(
+    r"(?<!\d)(?:[0-9]|1[0-7])(?!\d)\s*(?:"
+    + "|".join(
+        re.escape(unicodedata.normalize("NFKC", w).lower())
+        for w in sorted(_AGE_SUFFIX_AMBIGUOUS_WORDS, key=len, reverse=True)
+    )
+    + r")(?![^\W\d_])"
+)
+
+_CUE_LATIN = (
+    r"girls?|boys?|wom[ae]n|m[ae]n|lady|ladies|guy|guys|females?|males?|persons?|persona|personas|"
+    r"pessoa|personne|people|students?|models?|daughter|son|sister|brother|portrait|selfie|"
+    r"bikini|swimsuit|lingerie|nude|naked|topless|uniform|wearing|dress|outfit|pose|posing|"
+    r"mujer|chica|chico|hombre|joven|jovem|garota|garoto|menina|menino|fille|garçon|garcon|"
+    r"femme|homme|mädchen|madchen|frau|mann|junge|ragazza|ragazzo|donna|uomo|perempuan|gadis"
+)
+_CUE_OTHER = (
+    "ผู้หญิง|ผู้ชาย|สาว|หนุ่ม|หญิง|ชาย|นักเรียน|น้อง|ลูกสาว|ลูกชาย|"
+    "女|男|妹|姐|弟|学生|學生|娘|息子|여자|남자|소녀|소년|학생"
+)
+_PERSON_CUE_RE = re.compile(
+    r"(?<![^\W\d_])(?:" + _CUE_LATIN + r")(?![^\W\d_])|" + _CUE_OTHER
+)
+
+# English/French "age N" with a real word boundary, run on text that still
+# has its spaces. (?<![a-z0-9]) stops "image1", "page2", "message3",
+# "usage5", "stage4" from being read as "age N".
+_EN_AGE_PREFIX_RE = re.compile(
+    r"(?<![a-z0-9])(?:aged?|agee? de)\s*[:=\-]?\s*([0-9]|1[0-7])(?!\d)"
+)
+
+
+def _normalize_for_matching(text):
+    """Return a compact, evasion-resistant form of `text` for keyword
+    matching: invisible characters and separators stripped out, leetspeak
+    and look-alike letters folded to their plain equivalent, stretched
+    letters collapsed. Applied identically to prompts and keywords so
+    genuine (non-evasive) matches in any covered language still work."""
+    text = unicodedata.normalize("NFKC", text).lower()
+    text = _INVISIBLE_RE.sub("", text)
+    text = text.translate(_HOMOGLYPH_MAP)
+    text = text.translate(_LEET_MAP)
+    text = _SEPARATOR_RE.sub("", text)
+    text = _STRETCH_RE.sub(r"\1", text)
+    return text
+
+
+# ---------------------------------------------------------------------------
+# Short keywords are matched as WHOLE WORDS, not as substrings.
+#
+# Why: short Latin-script keywords collide with ordinary words when matched as
+# a substring, and even more so on the space-stripped "compact" text, where
+# letters from neighbouring words join up ("see you tomorrow" -> "omo",
+# "kindly" -> "kind", "sixteenth century" -> "teen", "edited" -> "dite",
+# "agency" -> "genc", "did it elegantly" -> "dite", "between" -> "tween").
+# That blocked harmless prompts and gave users no way to understand why.
+#
+# Whole-word mode keeps every real match AND the spacing / separator /
+# leetspeak / look-alike-letter / stretched-letter evasion handling:
+#   * the text is folded first (invisible chars, look-alike letters, leetspeak,
+#     stretched letters), so "ch1ld", "k1d", "kiiid" still collapse to the word;
+#   * separators are allowed BETWEEN the letters of the keyword, so "k.i.d",
+#     "k i d", "t-e-e-n" still match;
+#   * only the edges must not touch other letters, so "kidney" / "tomorrow"
+#     no longer match, while the common glued forms listed in
+#     _WORD_SUFFIXES ("teengirl", "kiddo", "minors") still do.
+# Longer keywords, non-Latin keywords and multi-word phrases keep the original
+# (stricter) substring + compact matching.
+# ---------------------------------------------------------------------------
+_KEEP_AS_SUBSTRING = {"child", "baby"}
+# Longer words that also need whole-word matching ("infantry", "barnet").
+# The bare numbers thirteen..seventeen are NOT blocked on their own any more:
+# "fifteen roses", "sixteen candles", "SEVENTEEN (kpop)" were being blocked.
+# They are still caught when they are used as an age: "sixteen years old",
+# "aged sixteen" (_SPELLED_AGE_RE) and "girl, sixteen" (_NUMWORD_NEAR_PERSON_RE).
+_EXTRA_WORD_BOUND = {"infant", "barnet"}
+_WORD_PREFIXES = {
+    "kind": "schul|klein|einzel|wunsch|pflege|stief|enkel|adoptiv|waisen|zwillings",
+    "kid": "little|lil|big|young|small|tiny|cute|baby|school|sexy|hot",
+    "teen": "little|lil|big|young|small|tiny|cute|baby|school|sexy|hot",
+}
+_WORD_SUFFIXES = {
+    "kind": "je|chen|lein|es",
+    "barn": "en|et|a|barn",
+    "kid": "s|do|dos|die|dies|dy|girl|girls|boy|boys",
+    "teen": "s|age|ager|agers|girl|girls|boy|boys|ie|ies|y|ish|hood|model|models",
+    "tween": "s|age|ager|agers",
+    "minor": "s",
+    "infant": "s|ile",
+    "genc": "ler|lik|ligi|lerin",
+    "ergen": "ler|lik|ligi|lerin",
+}
+
+
+# Short keywords that collide with ordinary English ("kid"->"kidney", "dite"->"edited",
+# "genc"->"agency", "ergen"->"emergency", "omo"->"tomorrow", "bata"->"a bat and").
+# Every other keyword, in every language, keeps the original substring matching, so
+# inflected / compound forms (Spanish "menores", Indonesian "anaknya", Finnish
+# "lapsille", German "Schulkind", Swedish "barnen") are still caught.
+_ENGLISH_COLLIDING = {
+    "kid", "kids", "kind", "teen", "teens", "tween", "minor",
+    "omo", "omode", "barn", "bata", "dite", "genc", "ergen",
+}
+
+
+def _is_word_bound(kw):
+    if kw in _KEEP_AS_SUBSTRING:
+        return False
+    return kw in _EXTRA_WORD_BOUND or kw in _ENGLISH_COLLIDING
+
+
+_WORD_BOUND_KEYWORDS = sorted({kw for kw in _MINOR_KEYWORDS if _is_word_bound(kw)} | _EXTRA_WORD_BOUND)
+_SUBSTRING_KEYWORDS = [kw for kw in _MINOR_KEYWORDS if not _is_word_bound(kw)]
+
+
+def _word_pattern(kw):
+    letters = r"[\W_]*".join(re.escape(ch) for ch in kw)
+    suffix = _WORD_SUFFIXES.get(kw)
+    tail = r"(?:" + suffix + r")?" if suffix else ""
+    prefix = _WORD_PREFIXES.get(kw)
+    head = r"(?:" + prefix + r")?" if prefix else ""
+    return re.compile(r"(?<![a-z])" + head + letters + tail + r"(?![a-z])")
+
+
+_WORD_BOUND_PATTERNS = [(kw, _word_pattern(kw)) for kw in _WORD_BOUND_KEYWORDS]
+
+# Phrases that are plainly innocent and contain a keyword. They are removed
+# before matching. Narrow on purpose: "minor" is only excused when it is followed
+# by an editing word ("minor adjustments"), and "kind" only in ordinary English
+# phrases ("what kind of", "kind eyes").
+_INNOCENT_RE = re.compile(
+    r"(?<![a-z])(?:"
+    r"minors?[\s-]+(?:adjust|chang|tweak|detail|edit|fix|touch|retouch|improv|flaw|imperfect|"
+    r"blemish|correct|variation|differenc|refine|modif|wrinkle|scratch|damage|issue|error|artifact|noise|blur)[a-z]*"
+    r"|menorahs?|copilots?|proteins?|collapsing|collapsible|relapsing|elapsing"
+    r"|kinds?[\s-]+(?:of|to|and|hearted)"
+    r"|kind[\s-]+(?:eyes?|face|smile|expression|gaze|look(?:ing)?|soul|gentle|person|people|old|man|woman|lady)"
+    r"|(?:old|red|wooden|farm|hay|big|white|empty|abandoned|rustic|country)[\s-]+barns?"
+    r"|barns?[\s-]+(?:door|doors|owl|swallow|yard|house|dance|loft|wood|style|raising)"
+    r"|(?:what|which|this|that|these|those|some|any|every|each|same|other|another|different|a|one|no|all)[\s-]+kinds?"
+    # colours / products / franchises that only contain a keyword
+    r"|baby[\s-]+(?:blue|pink|powder|breath|oil|yoda|shower)s?"
+    r"|child[\s-]?(?:proof|care|less)"
+    r"|anakin"
+    r"|(?:ice|stone|bronze|iron|space|golden|dark|new|jazz|digital|information|atomic|machine)[\s-]+ages?"
+    # bare "teen" is only excused next to clearly non-person nouns
+    r"|teens?[\s-]+(?:spirit|slang|bedroom|room|decor|furniture|trends?|vogue|beat|choice)"
+    # words in other scripts that merely START with / contain a keyword
+    r"|아이(?:폰|돌|디|템|스|패드|라인|섀도|콘|브|맥)"
+    r"|मूल्य|मूलभूत|मूलतः"
+    r"|పిల్లి"
+    r")(?![a-z])"
+)
+
+# Spelled-out ages in English ("sixteen years old", "aged eight", "nine yo").
+# Digit ages were already covered; this closes the spelled-out version.
+_NUM_WORDS = "zero|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen"
+_TENS_GUARD = "".join(
+    r"(?<!" + t + r"[\s-])" for t in ("twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety")
+)
+_SPELLED_AGE_RE = re.compile(
+    r"(?<![a-z])" + _TENS_GUARD + r"(?:" + _NUM_WORDS + r")"
+    r"(?:[\s-]*(?:years?|yrs?)[\s-]*old" + _NOT_NONHUMAN_OLD + r"|[\s-]*y\.?o\b)"
+    r"|(?<![a-z])(?:age|aged)[\s:]*(?:" + _NUM_WORDS + r")(?![a-z])(?![\s-]*(?:hundred|thousand|million))"
+)
+
+# "girl, sixteen" / "sixteen girl": a teen number glued to a (singular) person
+# noun. A following plural ("girl sixteen candles") reads as a count, not an age.
+_TEEN_NUM_WORDS = "thirteen|fourteen|fifteen|sixteen|seventeen"
+_PERSON_SINGULAR = r"girl|boy|female|male|student|schoolgirl|schoolboy|woman|man|lady|guy|person|kid"
+_NUMWORD_NEAR_PERSON_RE = re.compile(
+    r"(?<![a-z])(?:" + _TEEN_NUM_WORDS + r")(?![a-z])[\s,:\-]*(?:" + _PERSON_SINGULAR + r")(?![a-z])"
+    r"|(?<![a-z])(?:" + _PERSON_SINGULAR + r")(?![a-z])[\s,:\-]*(?:" + _TEEN_NUM_WORDS + r")(?![a-z])"
+    r"(?![\s-]+[a-z]+s(?![a-z]))"
+)
+
+
+def _fold_keep_spaces(text, leet):
+    """Evasion-folded text that keeps word boundaries (unlike the compact form)."""
+    text = unicodedata.normalize("NFKC", text).lower()
+    text = _INVISIBLE_RE.sub("", text)
+    text = text.translate(_HOMOGLYPH_MAP)
+    if leet:
+        text = text.translate(_LEET_MAP)
+    return _STRETCH_RE.sub(r"\1", text)
+
+
+def _is_latin_word(kw):
+    letters = [ch for ch in kw if ch.isalpha()]
+    return bool(letters) and all(unicodedata.name(ch, "").startswith("LATIN") for ch in letters)
+
+
+# Core English words: keep plain substring + compact (space-stripped) matching.
+# They are long/unusual enough that stripping spaces does not create collisions.
+_COMPACT_CORE = {
+    "child", "children", "toddler", "baby", "babies", "preteen", "pre-teen",
+    "teenage", "teenager", "underage", "under-age", "schoolgirl", "schoolboy",
+    "elementary school", "middle school", "high schooler",
+    "little girl", "little boy", "young girl", "young boy",
+    "sweet sixteen", "sweet 16",
+}
+
+_PLAIN_KEYWORDS = []   # non-Latin scripts + the core English words above
+_LATIN_KEYWORDS = []   # every other Latin-script keyword (es, pt, fr, de, vi, id, ...)
+for _kw in dict.fromkeys(_SUBSTRING_KEYWORDS):
+    if _kw in _COMPACT_CORE or not _is_latin_word(_kw):
+        _PLAIN_KEYWORDS.append(_kw)
+    else:
+        _LATIN_KEYWORDS.append(_kw)
+
+
+def _latin_pattern(kw):
+    """Pattern for a Latin-script keyword that must not match across word
+    boundaries by accident.
+
+    * 8+ letters: unbounded, separators allowed between letters (evasion-proof,
+      and long enough that collisions are not a concern).
+    * shorter: must START a word. Letters may be glued ("menores", "anaknya"
+      still match) or spread out as a standalone token ("b e b e"), but the
+      spread-out form also needs a word boundary at the end — so "to be better"
+      no longer reads as "bebe" and "them below" no longer reads as "em be".
+    """
+    words = [w for w in re.split(r"[\s\-]+", _fold_keep_spaces(kw, False)) if w]
+    letters = [ch for w in words for ch in w]
+    spaced = r"[\W_]*".join(re.escape(ch) for ch in letters)
+    if len(letters) >= 8:
+        return re.compile(spaced)
+    start, end = r"(?<![^\W\d_])", r"(?![^\W\d_])"
+    contiguous = r"[\W_]+".join("".join(re.escape(ch) for ch in w) for w in words)
+    if len(words) == 1:
+        return re.compile(start + "(?:" + contiguous + "|" + spaced + end + ")")
+    return re.compile(start + "(?:" + contiguous + "|" + spaced + ")" + end)
+
+
+_WORD_BOUND_PATTERNS += [(kw, _latin_pattern(kw)) for kw in _LATIN_KEYWORDS]
+
+# Precomputed compact form of every plain-matched keyword, built once at import time.
+_MINOR_KEYWORDS_COMPACT = [
+    (kw, _normalize_for_matching(kw)) for kw in _PLAIN_KEYWORDS
+]
+
+
+def check_prompt_no_minors(prompt_text):
+    if not GUARD_ENABLED or not prompt_text:
+        return
+    # Drop plainly innocent phrases first, then match on what is left.
+    text = _INNOCENT_RE.sub(" ", unicodedata.normalize("NFKC", prompt_text).lower())
+    compact_text = _normalize_for_matching(text)
+
+    # 1) Non-Latin keywords and the core English words: substring + compact matching.
+    for kw in _PLAIN_KEYWORDS:
+        if kw in text:
+            print(f"[guard] BLOCKED prompt (keyword match: '{kw}')")
+            raise gr.Error(GUARD_BLOCK_MESSAGE)
+    for kw, compact_kw in _MINOR_KEYWORDS_COMPACT:
+        if compact_kw and compact_kw in compact_text:
+            print(f"[guard] BLOCKED prompt (normalized keyword match: '{kw}')")
+            raise gr.Error(GUARD_BLOCK_MESSAGE)
+
+    # 2) Short English keywords and all other Latin-script keywords: whole-word /
+    #    start-of-word matching on evasion-folded text.
+    for leet in (False, True):
+        folded = _fold_keep_spaces(text, leet)
+        for kw, pattern in _WORD_BOUND_PATTERNS:
+            if pattern.search(folded):
+                print(f"[guard] BLOCKED prompt (whole-word keyword match: '{kw}')")
+                raise gr.Error(GUARD_BLOCK_MESSAGE)
+
+    # 3) Ages written in English: spelled out, number words next to a person
+    #    noun, and digits ("15 years old", "15yo", "age 15").
+    folded_plain = _fold_keep_spaces(text, False)
+    match = _SPELLED_AGE_RE.search(folded_plain)
+    if match:
+        print(f"[guard] BLOCKED prompt (spelled-out age: '{match.group(0)}')")
+        raise gr.Error(GUARD_BLOCK_MESSAGE)
+
+    match = _NUMWORD_NEAR_PERSON_RE.search(folded_plain)
+    if match:
+        print(f"[guard] BLOCKED prompt (teen number next to person: '{match.group(0)}')")
+        raise gr.Error(GUARD_BLOCK_MESSAGE)
+
+    for candidate in (text, compact_text):
+        match = _MINOR_AGE_PATTERN.search(candidate)
+        if match:
+            print(f"[guard] BLOCKED prompt (age pattern match: '{match.group(0)}')")
+            raise gr.Error(GUARD_BLOCK_MESSAGE)
+
+    # 4) Multilingual numeric-age check (e.g. Thai "อายุ 15ปี", Spanish "15
+    #    años", Chinese "15岁") — see _build_age_regex above. Uses its own
+    #    digit-preserving normalization, not `compact_text`, because the
+    #    leetspeak map used for word matching would corrupt digits.
+    age_compact = _normalize_for_age_matching(text)
+    for pattern in (_AGE_SUFFIX_PATTERN, _AGE_PREFIX_PATTERN, _AGE_EN_COMPACT_PATTERN):
+        match = pattern.search(age_compact)
+        if match:
+            print(f"[guard] BLOCKED prompt (multilingual age match: '{match.group(0)}')")
+            raise gr.Error(GUARD_BLOCK_MESSAGE)
+
+    # Units that only mean "year(s)" count when the prompt is about a person.
+    age_spaced = _normalize_age_keep_spaces(text)
+    if _PERSON_CUE_RE.search(age_spaced):
+        match = _AGE_SUFFIX_AMBIGUOUS_PATTERN.search(age_spaced)
+        if match:
+            print(f"[guard] BLOCKED prompt (multilingual age + person: '{match.group(0)}')")
+            raise gr.Error(GUARD_BLOCK_MESSAGE)
+
+    match = _EN_AGE_PREFIX_RE.search(folded_plain)
+    if match:
+        print(f"[guard] BLOCKED prompt (english age match: '{match.group(0)}')")
+        raise gr.Error(GUARD_BLOCK_MESSAGE)
+# ============================================================================
+# END GUARD
+# ============================================================================
+
+
+def warmup():
+    """Optional: call once at app start so the first real request doesn't pay
+    for model download/loading. Safe to call; failures are printed, not raised
+    (the per-request checks still fail closed)."""
+    if not GUARD_ENABLED:
+        return
+    try:
+        _load_age_classifier()
+        if _load_mediapipe_detector() is None:
+            _load_face_cascade()
+    except Exception as exc:
+        print(f"[guard] warmup failed: {exc}")

app.py

@@ -55,6 +55,11 @@ if not hasattr(_torchao_quantization, "FqnToConfig"):
         pass
     _torchao_quantization.FqnToConfig = FqnToConfig
 
+from diffusers import Flux2KleinPipeline
+try:
+    from diffusers import Flux2KleinKVPipeline
+except ImportError:
+    Flux2KleinKVPipeline = None
 from huggingface_hub import hf_hub_download
 from PIL import Image
 from safetensors import safe_open
@@ -65,23 +70,24 @@ from qwenimage.pipeline_qwenimage_edit_plus import QwenImageEditPlusPipeline
 from qwenimage.transformer_qwenimage import QwenImageTransformer2DModel
 from qwenimage.qwen_fa3_processor import QwenDoubleStreamAttnProcessorFA3
 
+import Age_classifier
+
+from esrgan import load_esrgan, upscale_to_pixels
 from security import (
     FloodGuard,
     check_admin_password,
     check_admin_tab_visibility,
-    check_user_password,
     clear_all_admin_log,
     delete_admin_log_entry,
-    end_session,
     is_admin,
     is_quota_error,
-    is_user,
     load_admin_gallery,
     load_rate_stats,
     log_generation,
     mark_browser_session,
     rate_acquire,
     rate_release,
+    record_age_block,
     save_input_images,
     show_rate_message,
 )
@@ -116,41 +122,12 @@ if torch.cuda.is_available():
     torch.backends.cudnn.allow_tf32 = True
 
 MODEL_QWEN = "qwen"
+MODEL_FLUX = "flux"
 
-PRESET_RESOLUTIONS = [
-    ("720×1280 (9:16)", 720, 1280),
-    ("864×1536 (9:16)", 864, 1536),
-    ("1080×1920 (9:16)", 1080, 1920),
-    ("1440×2560 (9:16)", 1440, 2560),
-    ("1600×2560 (10:16)", 1600, 2560),
-    ("1536×2728 (9:16)", 1536, 2728),
-    ("1280×720 (16:9)", 1280, 720),
-    ("1536×864 (16:9)", 1536, 864),
-    ("1920×1080 (16:9)", 1920, 1080),
-    ("2560×1440 (16:9)", 2560, 1440),
-    ("2560×1600 (16:10)", 2560, 1600),
-    ("2728×1536 (16:9)", 2728, 1536),
-    ("768×1024 (3:4)", 768, 1024),
-    ("1080×1440 (3:4)", 1080, 1440),
-    ("1536×2048 (3:4)", 1536, 2048),
-    ("1024×1536 (2:3)", 1024, 1536),
-    ("1440×1800 (4:5)", 1440, 1800),
-    ("1080×2400 (9:20)", 1080, 2400),
-    ("1024×768 (4:3)", 1024, 768),
-    ("1440×1080 (4:3)", 1440, 1080),
-    ("2048×1536 (4:3)", 2048, 1536),
-    ("1536×1024 (3:2)", 1536, 1024),
-    ("1800×1440 (5:4)", 1800, 1440),
-    ("2560×1080 (21:9)", 2560, 1080),
-]
-PRESET_RESOLUTION_MAP = {label: (w, h) for label, w, h in PRESET_RESOLUTIONS}
-PRESET_TALL = [label for label, w, h in PRESET_RESOLUTIONS if w < h]
-PRESET_WIDE = [label for label, w, h in PRESET_RESOLUTIONS if w > h]
-PRESET_ALL = PRESET_TALL + PRESET_WIDE
-PRESET_DEFAULT = "720×1280 (9:16)"
-AUTO_SCALES = ["1x", "2x", "3x", "4x"]
-AUTO_BASE_PIXELS = 1024 * 1024
-AUTO_MAX_PIXELS = 4194304
+ASPECT_RATIOS = ["Default", "1:1", "3:2", "2:3", "9:16", "16:9", "3:4", "4:3", "21:9", "9:21"]
+RATIO_DEFAULT = "Default"
+QWEN_TARGET_PIXELS = 2073600
+UPSCALE_PIXELS = {"Basic": 3686400, "Medium": 5760000, "High": 8294400}
 
 from diffusers.utils import logging as diffusers_logging
 
@@ -163,6 +140,10 @@ gc.collect()
 
 QWEN_TRANSFORMER_MODE = "fp8_exact"
 
+QWEN_TE_QUANT_MODE = "int8_weight_only"
+
+FLUX_QUANT_MODE = os.environ.get("FLUX_QUANT_MODE", "int8_weight_only").strip().lower()
+
 
 class _FP8ExactLinear(torch.nn.Module):
     def __init__(self, linear: torch.nn.Linear):
@@ -196,6 +177,30 @@ def _convert_linears_to_fp8_exact(model) -> int:
     return len(targets)
 
 
+def _apply_quant(module, label, mode):
+    order = {
+        "int8_weight_only": ["int8_weight_only", "fp8_weight_only", "dynamic"],
+        "fp8_weight_only": ["fp8_weight_only", "dynamic"],
+        "dynamic": ["dynamic"],
+    }[mode]
+    for m in order:
+        try:
+            if m == "int8_weight_only":
+                from torchao.quantization import Int8WeightOnlyConfig
+                cfg = Int8WeightOnlyConfig()
+            elif m == "fp8_weight_only":
+                from torchao.quantization import Float8WeightOnlyConfig
+                cfg = Float8WeightOnlyConfig()
+            else:
+                cfg = Float8DynamicActivationFloat8WeightConfig()
+        except ImportError as e_cfg:
+            print(f"[quant] {label}: {m} unavailable ({e_cfg}); trying the next scheme")
+            continue
+        quantize_(module, cfg)
+        return m
+    raise RuntimeError(f"no usable quantization scheme for {label}")
+
+
 def _enable_vae_tiling(p, tile=None):
     vae = getattr(p, "vae", None)
     if vae is None:
@@ -218,7 +223,7 @@ def _enable_vae_tiling(p, tile=None):
         print("[vae] tiling applied:", {k: getattr(vae, k, None) for k in ("tile_sample_min_height", "tile_sample_min_width", "tile_sample_stride_height", "tile_sample_stride_width")})
 
 
-QWEN_VAE_TILE = int(os.environ.get("QWEN_VAE_TILE", "1600"))
+QWEN_VAE_TILE = int(os.environ.get("QWEN_VAE_TILE", "0"))
 
 
 pipe = QwenImageEditPlusPipeline.from_pretrained(
@@ -248,11 +253,93 @@ else:
     quantize_(pipe.transformer, Float8DynamicActivationFloat8WeightConfig())
     print("[qwen] FP8 quantization: SUCCESS (transformer)")
 
-_enable_vae_tiling(pipe, QWEN_VAE_TILE)
+if getattr(pipe, "text_encoder", None) is not None:
+    try:
+        _te_mode_used = _apply_quant(pipe.text_encoder, "qwen text_encoder", QWEN_TE_QUANT_MODE)
+        print(f"[qwen] text_encoder quantization ({_te_mode_used}): SUCCESS")
+    except Exception as e:
+        print(f"[qwen] text_encoder quantization FAILED, staying bf16 (~+8GB VRAM): {e}")
+
+if QWEN_VAE_TILE > 0:
+    _enable_vae_tiling(pipe, QWEN_VAE_TILE)
+else:
+    print("[vae] Qwen VAE tiling OFF (full-frame decode)")
 
 pipe.transformer.__class__ = QwenImageTransformer2DModel
 pipe.transformer.set_attn_processor(QwenDoubleStreamAttnProcessorFA3())
 
+FLUX_REPO = os.environ.get("FLUX_REPO", "black-forest-labs/FLUX.2-klein-9b-kv")
+FLUX_REFINE_PROMPT = os.environ.get("FLUX_REFINE_PROMPT", "An ultra-high-resolution masterpiece with exceptional sharpness and detail, featuring only a subtle, barely perceptible amount of noise on the skin’s surface. The image remains entirely unzoomed and unaltered, preserving its original composition and proportions, with lighting and shadows meticulously controlled to remain perfectly faithful to the original")
+FLUX_REFINE_GUIDANCE_SCALE = float(os.environ.get("FLUX_REFINE_GUIDANCE_SCALE", "1"))
+FLUX_NUM_INFERENCE_STEPS = int(os.environ.get("FLUX_NUM_INFERENCE_STEPS", "4"))
+FLUX_SEED = int(os.environ.get("FLUX_SEED", "42"))
+FLUX_MAX_PIXELS = 2073600
+
+_flux_use_kv = "kv" in FLUX_REPO.lower()
+if _flux_use_kv and Flux2KleinKVPipeline is None:
+    raise RuntimeError(
+        "FLUX_REPO is a KV checkpoint but this diffusers has no Flux2KleinKVPipeline. "
+        "Install diffusers from GitHub: pip install git+https://github.com/huggingface/diffusers.git"
+    )
+_FluxPipeCls = Flux2KleinKVPipeline if _flux_use_kv else Flux2KleinPipeline
+_flux_repo_lc = FLUX_REPO.lower()
+_flux_size = "9B" if "9b" in _flux_repo_lc else ("4B" if "4b" in _flux_repo_lc else "")
+if _flux_size:
+    FLUX_SHORT_NAME = f"Flux.2 {_flux_size}" + (" KV" if _flux_use_kv else "") + (" Base" if "base" in _flux_repo_lc else "")
+else:
+    FLUX_SHORT_NAME = FLUX_REPO.split("/")[-1]
+print(f"[flux] loading {FLUX_REPO} with {_FluxPipeCls.__name__}")
+flux_pipe = _FluxPipeCls.from_pretrained(FLUX_REPO, torch_dtype=dtype)
+
+with torch.no_grad():
+    _flux_prompt_embeds, _ = flux_pipe.encode_prompt(
+        prompt=FLUX_REFINE_PROMPT, device="cpu", num_images_per_prompt=1
+    )
+_flux_prompt_embeds = _flux_prompt_embeds.to(dtype).cpu()
+flux_pipe.text_encoder = None
+gc.collect()
+
+flux_pipe = flux_pipe.to(device)
+if FLUX_QUANT_MODE == "none":
+    print("[flux] quantization disabled (FLUX_QUANT_MODE=none), running in bf16")
+else:
+    try:
+        _flux_mode_used = _apply_quant(flux_pipe.transformer, "flux transformer", FLUX_QUANT_MODE)
+        print(f"[flux] quantization ({_flux_mode_used}): SUCCESS")
+    except Exception as e:
+        print(f"[flux] quantization FAILED, continuing in bf16 (roughly 2x the VRAM/transfer time): {e}")
+
+if hasattr(flux_pipe, "vae") and flux_pipe.vae is not None:
+    try:
+        flux_pipe.vae.enable_slicing()
+    except Exception:
+        pass
+
+_flux_ip = getattr(flux_pipe, "image_processor", None)
+if _flux_ip is not None and hasattr(_flux_ip, "_resize_to_target_area"):
+    _orig_resize_to_target_area = _flux_ip._resize_to_target_area
+
+    def _flux_resize_with_higher_cap(image, target_area):
+        if target_area == 1024 * 1024:
+            w, h = image.size
+            if w * h <= FLUX_MAX_PIXELS:
+                return image
+            return _orig_resize_to_target_area(image, FLUX_MAX_PIXELS)
+        return _orig_resize_to_target_area(image, target_area)
+
+    _flux_ip._resize_to_target_area = _flux_resize_with_higher_cap
+    print(f"[flux] reference-image cap raised: no downscale up to {FLUX_MAX_PIXELS} px")
+else:
+    print("[flux] WARNING: image_processor._resize_to_target_area not found; "
+          "FLUX will use its built-in ~1MP reference-image downscale")
+
+esrgan_model = load_esrgan(device)
+print("[esrgan] RealESRGAN_x2plus loaded")
+
+# FLUX VAE tiling is off by default because tiled encode/decode shifted skin colour.
+if os.environ.get("FLUX_VAE_TILING", "0") == "1":
+    _enable_vae_tiling(flux_pipe)
+
 gc.collect()
 
 
@@ -294,33 +381,44 @@ def _round_size(width, height, multiple=8):
     return max(multiple, (int(width) // multiple) * multiple), max(multiple, (int(height) // multiple) * multiple)
 
 
-def _auto_size(scale_choice, image_1, image_2):
+def _ratio_size(ratio, pixels=QWEN_TARGET_PIXELS, multiple=16):
+    width = (pixels * ratio) ** 0.5
+    height = width / ratio
+    return (
+        max(multiple, int(width) // multiple * multiple),
+        max(multiple, int(height) // multiple * multiple),
+    )
+
+
+def _image_ratio(image_1, image_2):
     src = image_1 if image_1 is not None else image_2
     if src is None:
-        return None, None
+        return 1.0
     try:
         with Image.open(src if isinstance(src, str) else src.name) as im:
-            width, height = im.size
+            return im.width / im.height
     except Exception:
-        return None, None
-    factor = _to_int(str(scale_choice).rstrip("x"), 1, 4, 1)
-    pixels = min(AUTO_BASE_PIXELS * factor, AUTO_MAX_PIXELS)
-    ratio = width / height
-    out_w = (pixels * ratio) ** 0.5
-    return _round_size(int(out_w), int(out_w / ratio), multiple=16)
+        return 1.0
 
 
-def _resolve_size(mode, preset, custom_width, custom_height, auto_scale, image_1, image_2):
+def _resolve_size(ratio_label, image_1, image_2):
     try:
-        if mode == "Preset" and preset in PRESET_RESOLUTION_MAP:
-            return _round_size(*PRESET_RESOLUTION_MAP[preset])
-        if mode == "Custom":
-            return _round_size(int(custom_width), int(custom_height))
-        if mode == "Auto":
-            return _auto_size(auto_scale, image_1, image_2)
-    except (TypeError, ValueError, OverflowError):
+        if ratio_label in ASPECT_RATIOS and ratio_label != RATIO_DEFAULT:
+            w, h = ratio_label.split(":")
+            return _ratio_size(int(w) / int(h))
+    except (TypeError, ValueError, ZeroDivisionError):
         pass
-    return None, None
+    return _ratio_size(_image_ratio(image_1, image_2))
+
+
+def _fit_size(width, height, max_pixels=FLUX_MAX_PIXELS, multiple=16):
+    if width * height <= max_pixels:
+        return width, height
+    scale = (max_pixels / (width * height)) ** 0.5
+    return (
+        max(multiple, int(width * scale) // multiple * multiple),
+        max(multiple, int(height * scale) // multiple * multiple),
+    )
 
 
 def _load_image(img):
@@ -360,6 +458,7 @@ def log_vram(label):
 
 
 def _generate_core(
+    model_choice,
     image_1,
     image_2,
     prompt,
@@ -369,7 +468,6 @@ def _generate_core(
     num_inference_steps,
     height,
     width,
-    duplicate_input=True,
     progress=gr.Progress(track_tqdm=True),
 ):
     if randomize_seed:
@@ -385,40 +483,65 @@ def _generate_core(
         except Exception:
             continue
 
-    duplicated = False
-    if duplicate_input and len(pil_images) == 1:
-        pil_images.append(pil_images[0].copy())
-        duplicated = True
+    if model_choice == MODEL_FLUX:
+        _flux_inputs = []
+        for im in pil_images:
+            if im.width * im.height > FLUX_MAX_PIXELS:
+                new_size = _fit_size(*im.size)
+                print(f"[flux] input {im.width}x{im.height} exceeds {FLUX_MAX_PIXELS} px, downscaled to {new_size[0]}x{new_size[1]}")
+                im = im.resize(new_size, Image.LANCZOS)
+            _flux_inputs.append(im)
+        pil_images = _flux_inputs
+        if width and height:
+            width, height = _fit_size(width, height)
 
     res_txt = f"{width}x{height}" if (width and height) else "auto"
-    print(f"[gen] model={MODEL_QWEN} guidance={true_guidance_scale} steps={num_inference_steps} resolution={res_txt}")
+    print()
+    _model_desc = FLUX_SHORT_NAME if model_choice == MODEL_FLUX else model_choice
+    print(f"[gen] model={_model_desc} guidance={true_guidance_scale} steps={num_inference_steps} resolution={res_txt}")
 
     if torch.cuda.is_available():
         torch.cuda.reset_peak_memory_stats(device)
-    log_vram(f"{MODEL_QWEN} before generation")
+    log_vram(f"{model_choice} before generation")
 
     try:
-        images_pil = pipe(
-            image=pil_images or None,
-            prompt=prompt,
-            height=height,
-            width=width,
-            negative_prompt=" ",
-            num_inference_steps=num_inference_steps,
-            generator=generator,
-            true_cfg_scale=true_guidance_scale,
-            num_images_per_prompt=1,
-        ).images
+        if model_choice == MODEL_FLUX:
+            _flux_kwargs = {}
+            if not _flux_use_kv:
+                _flux_kwargs["guidance_scale"] = true_guidance_scale
+            images_pil = flux_pipe(
+                image=pil_images or None,
+                prompt=None,
+                prompt_embeds=_flux_prompt_embeds.to(device),
+                height=height,
+                width=width,
+                num_inference_steps=num_inference_steps,
+                generator=generator,
+                num_images_per_prompt=1,
+                **_flux_kwargs,
+            ).images
+        else:
+            images_pil = pipe(
+                image=pil_images or None,
+                prompt=prompt,
+                height=height,
+                width=width,
+                negative_prompt=" ",
+                num_inference_steps=num_inference_steps,
+                generator=generator,
+                true_cfg_scale=true_guidance_scale,
+                num_images_per_prompt=1,
+            ).images
 
     except torch.cuda.OutOfMemoryError:
         _free_vram_cache()
         raise
-    log_vram(f"{MODEL_QWEN} after generation")
+    log_vram(f"{model_choice} after generation")
 
     return {
         "images": images_pil, "seed": seed, "width": width, "height": height,
-        "duplicated": duplicated, "steps": num_inference_steps,
-        "guidance": true_guidance_scale, "model": MODEL_QWEN,
+        "steps": num_inference_steps,
+        "guidance": true_guidance_scale, "model": model_choice,
     }
 
 
@@ -438,6 +561,7 @@ def _finalize(res, image_1, image_2, prompt, output_format):
         else:
             img.save(output_path)
         output_paths.append(output_path)
+        print(f"[out] resolution={img.width}x{img.height}")
         log_generation(
             path=output_path,
             prompt=prompt,
@@ -449,42 +573,147 @@ def _finalize(res, image_1, image_2, prompt, output_format):
             height=res["height"],
             out_width=img.width,
             out_height=img.height,
-            duplicated=res["duplicated"],
             inputs=input_paths,
         )
     has_output = bool(output_paths)
     return output_paths, seed, gr.update(visible=has_output)
 
 
-def _make_gpu_variant(duration_seconds, size):
-    def _infer_gpu_call(*args, **kwargs):
-        return _generate_core(*args, **kwargs)
+def _make_qwen_flux_gpu_variant(duration_seconds, size):
+    def _qwen_then_flux_gpu_call(qwen_kwargs, scale_up):
+        _free_vram_cache()
+        q = _generate_core(MODEL_QWEN, **qwen_kwargs)
+        if not q["images"]:
+            return q, None
+        _free_vram_cache()
+        img = q["images"][0]
+        w, h = _round_size(*img.size, multiple=16)
+        f = _generate_core(
+            MODEL_FLUX, image_1=img, image_2=None, prompt=FLUX_REFINE_PROMPT,
+            seed=FLUX_SEED, randomize_seed=False,
+            true_guidance_scale=FLUX_REFINE_GUIDANCE_SCALE,
+            num_inference_steps=FLUX_NUM_INFERENCE_STEPS,
+            height=h, width=w,
+            progress=qwen_kwargs["progress"],
+        )
+        if scale_up and f["images"]:
+            _free_vram_cache()
+            f = {**f, "images": [upscale_to_pixels(esrgan_model, f["images"][0], scale_up)]}
+        return q, f
 
-    _infer_gpu_call.__name__ = f"_infer_impl_gpu_{size}_{duration_seconds}s"
-    _infer_gpu_call.__qualname__ = _infer_gpu_call.__name__
-    return spaces.GPU(duration=duration_seconds, size=size)(_infer_gpu_call)
+    _qwen_then_flux_gpu_call.__name__ = f"_qwen_then_flux_gpu_{size}_{duration_seconds}s"
+    _qwen_then_flux_gpu_call.__qualname__ = _qwen_then_flux_gpu_call.__name__
+    return spaces.GPU(duration=duration_seconds, size=size)(_qwen_then_flux_gpu_call)
 
 
-_gpu_variants = {(s, d): _make_gpu_variant(d, s) for s in GPU_SIZE_OPTIONS for d in _GPU_DURATION_STEPS}
+_qwen_then_flux_variants = {(s, d): _make_qwen_flux_gpu_variant(d, s) for s in GPU_SIZE_OPTIONS for d in _GPU_DURATION_STEPS}
 
 
-def _pick_gpu_variant(gpu_duration, gpu_size=GPU_SIZE_DEFAULT):
+def _pick_qwen_flux_variant(gpu_duration, gpu_size=GPU_SIZE_DEFAULT):
     requested = _to_int(gpu_duration, GPU_DURATION_MIN, GPU_DURATION_MAX, GPU_DURATION_DEFAULT)
     chosen = next((d for d in _GPU_DURATION_STEPS if d >= requested), _GPU_DURATION_STEPS[-1])
     size = gpu_size if gpu_size in GPU_SIZE_OPTIONS else GPU_SIZE_DEFAULT
-    gpu_fn = _gpu_variants[(size, chosen)]
+    gpu_fn = _qwen_then_flux_variants[(size, chosen)]
 
-    def _call(image_1, image_2, prompt, *args, output_format="PNG", **kwargs):
-        res = gpu_fn(image_1, image_2, prompt, *args, **kwargs)
-        return _finalize(res, image_1, image_2, prompt, output_format)
+    def _call(image_1, image_2, prompt, output_format, qwen_kwargs, scale_up):
+        q, f = gpu_fn(qwen_kwargs, scale_up)
+        final = f if (f is not None and f["images"]) else q
+        return _finalize({**q, "images": final["images"]}, image_1, image_2, prompt, output_format)
 
     return _call
 
 
+_BLOCK_IMAGE_PATH = os.path.join("outputs", "blocked", "blocked_notice.png")
+
+
+def _block_image():
+    if os.path.exists(_BLOCK_IMAGE_PATH):
+        return _BLOCK_IMAGE_PATH
+    import textwrap
+    from PIL import ImageDraw, ImageFont
+
+    def font(size):
+        try:
+            return ImageFont.load_default(size=size)
+        except TypeError:
+            return ImageFont.load_default()
+
+    size = 768
+    img = Image.new("RGB", (size, size), (28, 30, 38))
+    d = ImageDraw.Draw(img)
+    d.polygon([(384, 40), (500, 250), (268, 250)], fill=(255, 200, 0))
+    f_mark = font(130)
+    d.text((384 - d.textlength("!", font=f_mark) / 2, 92), "!", font=f_mark, fill=(28, 30, 38))
+    f_head = font(64)
+    head = "BLOCKED"
+    d.text(((size - d.textlength(head, font=f_head)) / 2, 290), head, font=f_head, fill=(255, 200, 0))
+    f_body = font(36)
+    y = 400
+    for line in textwrap.wrap("This request appears to involve a minor, so it can't be processed.", width=30):
+        d.text(((size - d.textlength(line, font=f_body)) / 2, y), line, font=f_body, fill=(225, 228, 238))
+        y += 48
+    os.makedirs(os.path.dirname(_BLOCK_IMAGE_PATH), exist_ok=True)
+    img.save(_BLOCK_IMAGE_PATH)
+    return _BLOCK_IMAGE_PATH
+
+
+def _is_age_block(exc):
+    return getattr(exc, "message", str(exc)) == Age_classifier.GUARD_BLOCK_MESSAGE
+
+
+def _is_block_image(gallery_items):
+    try:
+        return os.path.basename(str(_first_path(gallery_items))).startswith("blocked_notice")
+    except Exception:
+        return False
+
+
+def _screen_inputs(request, prompt, *images):
+    try:
+        Age_classifier.check_prompt_no_minors(prompt)
+    except gr.Error as exc:
+        if _is_age_block(exc):
+            record_age_block("prompt", request)
+        raise
+    for img in images:
+        if img is None:
+            continue
+        try:
+            pil = _load_image(img)
+        except Exception:
+            continue
+        try:
+            Age_classifier.check_image_no_minors(pil, context="input")
+        except gr.Error as exc:
+            if _is_age_block(exc):
+                record_age_block("input", request)
+            raise
+
+
+def _screen_outputs(result, request=None):
+    paths = result[0] if isinstance(result, (tuple, list)) and result else None
+    if not isinstance(paths, (list, tuple)):
+        return result
+    try:
+        for path in paths:
+            with Image.open(path) as im:
+                im.load()
+                Age_classifier.check_image_no_minors(im, context="output")
+    except gr.Error as exc:
+        if _is_age_block(exc):
+            record_age_block("output", request)
+        for path in paths:
+            try:
+                delete_admin_log_entry(path)
+                if os.path.exists(path):
+                    os.remove(path)
+            except Exception as rm_exc:
+                print(f"[age] failed to remove blocked output: {rm_exc}")
+        raise
+    return result
+
+
 def _run_limited(request, seed, run):
-    if not is_user(request):
-        gr.Warning("Please log in first.")
-        return gr.update(), seed, gr.update()
     ok, key, msg = rate_acquire(request)
     if not ok:
         show_rate_message(msg)
@@ -499,7 +728,7 @@ def _run_limited(request, seed, run):
         rate_release(key, refund=refund)
 
 
-def infer_qwen_only(
+def run_qwen_and_flux(
     image_1,
     image_2,
     prompt,
@@ -509,36 +738,47 @@ def infer_qwen_only(
     num_inference_steps,
     gpu_duration,
     gpu_size,
-    resolution_mode,
-    resolution_preset,
-    custom_width,
-    custom_height,
-    auto_scale,
+    aspect_ratio,
+    scale_basic,
+    scale_medium,
+    scale_high,
     output_format,
-    duplicate_input,
+    age_confirmed=False,
     progress=gr.Progress(track_tqdm=True),
     request: gr.Request = None,
 ):
+    if not age_confirmed:
+        raise gr.Error("Please tick the box to confirm you are 18 or older.")
+
     if not (isinstance(prompt, str) and prompt.strip()):
         return gr.update(), seed, gr.update()
 
     def run():
         clean_seed, duration, fmt = _sanitize_common(seed, gpu_duration, output_format)
-        width, height = _resolve_size(resolution_mode, resolution_preset, custom_width, custom_height, auto_scale, image_1, image_2)
-        return _pick_gpu_variant(duration, gpu_size)(
-            image_1,
-            image_2,
-            prompt if isinstance(prompt, str) else "",
-            seed=clean_seed,
-            randomize_seed=bool(randomize_seed),
+        width, height = _resolve_size(aspect_ratio, image_1, image_2)
+        clean_prompt = prompt if isinstance(prompt, str) else ""
+        qwen_kwargs = dict(
+            image_1=image_1, image_2=image_2, prompt=clean_prompt,
+            seed=clean_seed, randomize_seed=bool(randomize_seed),
             true_guidance_scale=_to_float(true_guidance_scale, LIMIT_GUIDANCE_MIN, LIMIT_GUIDANCE_MAX, 1.0),
             num_inference_steps=int(num_inference_steps),
-            height=height,
-            width=width,
-            output_format=fmt,
-            duplicate_input=bool(duplicate_input),
+            height=height, width=width,
             progress=progress,
         )
+        upscale_pixels = next(
+            (UPSCALE_PIXELS[name] for name, on in (("High", scale_high), ("Medium", scale_medium), ("Basic", scale_basic)) if on),
+            0,
+        )
+        try:
+            _screen_inputs(request, clean_prompt, image_1, image_2)
+            return _screen_outputs(
+                _pick_qwen_flux_variant(duration, gpu_size)(image_1, image_2, clean_prompt, fmt, qwen_kwargs, upscale_pixels),
+                request,
+            )
+        except gr.Error as exc:
+            if not _is_age_block(exc):
+                raise
+            return [_block_image()], seed, gr.update(visible=False)
 
     return _run_limited(request, seed, run)
 
@@ -550,7 +790,7 @@ def use_output_as_input(output_images):
 
 
 def _sync_result_followups(output_images):
-    return gr.update(visible=bool(output_images))
+    return gr.update(visible=bool(output_images) and not _is_block_image(output_images))
 
 
 def _clear_all_admin_images(request: gr.Request):
@@ -583,58 +823,135 @@ css = """
     -webkit-text-fill-color: transparent;
     color: transparent;
     animation: ast-title-flash 10s linear infinite;
+    white-space: nowrap;
 }
-/* Force a 2-column grid for the preset radio (Gradio's default flex-wrap stacks into one column on mobile). */
-.preset-grid > .wrap,
-.preset-grid .wrap {
-    display: grid !important;
-    grid-template-columns: 1fr 1fr !important;
-    gap: 8px !important;
+@media (max-width: 480px) {
+    #ast-main-title { font-size: 5.8vw !important; }
 }
-#adv-settings:has(#res-mode input[value="Preset"]:checked) #res-custom-height,
-#adv-settings:has(#res-mode input[value="Preset"]:checked) #res-custom-width,
-#adv-settings:has(#res-mode input[value="Preset"]:checked) #res-auto-scale,
-#adv-settings:has(#res-mode input[value="Custom"]:checked) #res-preset,
-#adv-settings:has(#res-mode input[value="Custom"]:checked) #res-auto-scale,
-#adv-settings:has(#res-mode input[value="Auto"]:checked) #res-preset,
-#adv-settings:has(#res-mode input[value="Auto"]:checked) #res-custom-height,
-#adv-settings:has(#res-mode input[value="Auto"]:checked) #res-custom-width {
-    display: none !important;
+#logo-title h1#ast-nfaa-title {
+    margin: 0 -0.3em 0 0 !important;
+    padding: 0 0.3em 0 0 !important;
+    line-height: 1.15 !important;
 }
-/* Seed is an output component: hide Gradio's progress/status overlay so it never covers the number box. */
-#seed-slider .wrap.generating,
-#seed-slider .wrap.pending,
-#seed-slider .progress-text,
-#seed-slider .progress-level {
-    display: none !important;
+#ast-nfaa-title {
+    font-style: italic;
+    display: inline-block;
+    white-space: nowrap;
+    zoom: 0.8;
+    background: linear-gradient(90deg, #FF0000, #FF2A2A, #E00000, #FF1010, #FF0000);
+    background-size: 400% 400%;
+    -webkit-background-clip: text;
+    background-clip: text;
+    -webkit-text-fill-color: transparent;
+    color: transparent;
+    animation: ast-title-flash 10s linear infinite;
 }
-.preset-grid label {
-    width: 100% !important;
-    margin: 0 !important;
-    box-sizing: border-box !important;
+@media (max-width: 400px) {
+    #ast-nfaa-title { zoom: 0.7; }
 }
-#res-mode .wrap {
-    display: grid !important;
-    grid-template-columns: repeat(3, 1fr) !important;
-    gap: 8px !important;
+#ast-notice {
+    width: 100%;
+    max-width: 560px;
+    margin: 11px auto 0 !important;
+    padding: 1px 0 1px 14px !important;
+    border-left: 2px solid transparent;
+    border-image: linear-gradient(180deg, #FF3CAC, #7B2FF7, #00E5FF) 1;
+    text-align: left;
 }
-#res-mode label {
-    width: 100% !important;
-    margin: 0 !important;
-    box-sizing: border-box !important;
-    justify-content: center !important;
+#ast-notice, #ast-notice p, #ast-notice b {
+    font-family: "Space Grotesk", "DM Sans", system-ui, -apple-system, "Segoe UI", Roboto, "Noto Sans Thai", sans-serif !important;
 }
-#output-format .wrap {
-    display: grid !important;
-    grid-template-columns: repeat(3, 1fr) !important;
-    gap: 8px !important;
+#ast-notice p {
+    margin: 0 0 9px 0 !important;
+    text-indent: 1.6em;
+    font-size: 11.5px !important;
+    font-weight: 400 !important;
+    line-height: 1.75 !important;
+    letter-spacing: 0.015em !important;
+    color: var(--body-text-color-subdued, #9aa0a6) !important;
+    text-wrap: pretty;
 }
-#output-format label {
-    width: 100% !important;
-    margin: 0 !important;
-    box-sizing: border-box !important;
-    justify-content: center !important;
+#ast-notice p:last-child {
+    margin-bottom: 0 !important;
+}
+#ast-notice b {
+    font-weight: 600 !important;
+    letter-spacing: 0.02em;
+    color: var(--body-text-color, #e5e7eb) !important;
+}
+#age-confirm {
+    padding: 10px 12px !important;
+    min-height: 0 !important;
+}
+#age-confirm label, #age-confirm label span, #age-confirm span {
+    font-size: 14px !important;
+    font-weight: 400 !important;
+    line-height: 1.35 !important;
+    color: var(--body-text-color, #e5e7eb) !important;
+}
+#age-confirm input[type="checkbox"] {
+    width: 18px !important;
+    height: 18px !important;
+    min-width: 18px !important;
+    border: 2px solid #FF4040 !important;
+    border-radius: 5px !important;
+    cursor: pointer;
+}
+#age-confirm input[type="checkbox"]:checked {
+    background-color: #FF1010 !important;
+    border-color: #FF1010 !important;
+}
+#seed-slider .wrap.generating,
+#seed-slider .wrap.pending,
+#seed-slider .progress-text,
+#seed-slider .progress-level {
+    display: none !important;
 }
+"""
+
+_RATIO_ICON_MAX = 30
+_RATIO_ICON_BOX = 34
+_RATIO_ACCENT = "var(--checkbox-background-color-selected, var(--color-accent, var(--primary-500)))"
+
+
+def _ratio_css():
+    acc = _RATIO_ACCENT
+    rules = [
+        "#aspect-ratio .wrap { display: grid !important; grid-template-columns: repeat(5, minmax(0, 1fr)) !important; gap: 6px !important; }",
+        "#aspect-ratio label { display: flex !important; flex-direction: column !important; align-items: center !important; "
+        "justify-content: center !important; gap: 0 !important; width: 100% !important; min-width: 0 !important; "
+        "margin: 0 !important; padding: 8px 2px 6px !important; box-sizing: border-box !important; "
+        "border-radius: 12px !important; cursor: pointer; }",
+        "#aspect-ratio label input { display: none !important; }",
+        "#aspect-ratio label span { font-size: 13px !important; line-height: 1.2 !important; white-space: nowrap; margin: 0 !important; padding: 0 !important; text-indent: 0 !important; text-align: center !important; }",
+        "#aspect-ratio label::before { content: \"\"; display: block; flex: none; border-radius: 4px; background: rgba(128, 128, 128, 0.38); }",
+        f"#aspect-ratio label:has(input:checked), #aspect-ratio label.selected {{ border-color: color-mix(in srgb, {acc} 90%, transparent) !important; background: color-mix(in srgb, {acc} 14%, transparent) !important; }}",
+        f"#aspect-ratio label:has(input:checked)::before, #aspect-ratio label.selected::before {{ background: color-mix(in srgb, {acc} 70%, transparent); }}",
+        '#aspect-ratio label:has(input[value="Default"])::before { background: transparent !important; border: 1.5px dashed rgba(150, 150, 150, 0.8); box-sizing: border-box; }',
+        f'#aspect-ratio label:has(input[value="Default"]:checked)::before, #aspect-ratio label.selected:has(input[value="Default"])::before {{ border-color: color-mix(in srgb, {acc} 95%, transparent); }}',
+    ]
+    for label in ASPECT_RATIOS:
+        w, h = (4, 3) if label == RATIO_DEFAULT else (int(x) for x in label.split(":"))
+        k = _RATIO_ICON_MAX / max(w, h)
+        iw, ih = round(w * k), round(h * k)
+        pad = (_RATIO_ICON_BOX - ih) / 2
+        rules.append(
+            f'#aspect-ratio label:has(input[value="{label}"])::before '
+            f'{{ width: {iw}px; height: {ih}px; margin: {pad:g}px 0; }}'
+        )
+    return "\n".join(rules) + "\n"
+
+
+css += _ratio_css()
+css += f"""
+#output-format {{ background: transparent !important; border: none !important; box-shadow: none !important; padding: 0 !important; }}
+#output-format .wrap {{ display: flex !important; justify-content: center !important; gap: 1px !important; background: transparent !important; padding: 0 !important; margin: 0 !important; }}
+#output-format label {{ flex: 1 1 0 !important; min-width: 0 !important; justify-content: center !important; align-items: center !important; height: 38px !important; min-height: 0 !important; margin: 0 !important; padding: 0 8px !important; border: none !important; border-radius: 0 !important; box-shadow: none !important; background: var(--block-background-fill) !important; }}
+#output-format label:has(input:checked), #output-format label.selected, #lanczos-row .block:has(input:checked) {{ background-image: linear-gradient(color-mix(in srgb, {_RATIO_ACCENT} 14%, transparent), color-mix(in srgb, {_RATIO_ACCENT} 14%, transparent)) !important; }}
+.lanczos-title {{ padding: 4px 0 3px 6px !important; background: var(--block-background-fill) !important; }}
+"""
+
+css += """
 #gpu-size .wrap {
     display: grid !important;
     grid-template-columns: repeat(2, 1fr) !important;
@@ -661,38 +978,14 @@ css = """
     margin: 0 !important;
     font-family: inherit !important;
     font-size: var(--checkbox-label-text-size, var(--text-md, 1rem)) !important;
-    font-size: min(var(--checkbox-label-text-size, var(--text-md, 1rem)), 5.2cqw) !important;
+    font-size: min(var(--checkbox-label-text-size, var(--text-md, 1rem)), 4.8cqw) !important;
     white-space: nowrap !important;
     font-style: normal !important;
     line-height: 1.5 !important;
     opacity: 0.7;
 }
-#res-auto-scale .wrap {
-    display: grid !important;
-    grid-template-columns: repeat(4, minmax(0, 1fr)) !important;
-    gap: 6px !important;
-}
-#res-auto-scale label {
-    width: 100% !important;
-    min-width: 0 !important;
-    margin: 0 !important;
-    padding-left: 8px !important;
-    padding-right: 8px !important;
-    box-sizing: border-box !important;
-    justify-content: center !important;
-}
 """
 
-_div_a = f'.preset-grid label:has(input[value="{PRESET_WIDE[0]}"])'
-_div_b = f'.preset-grid label:has(input[value="{PRESET_WIDE[1]}"])'
-css += (
-    f"{_div_a}, {_div_b} {{ position: relative !important; margin-top: 12px !important; overflow: visible !important; }}\n"
-    f"{_div_a}::before, {_div_b}::before {{ content: \"\"; position: absolute; top: -10px; height: 1px; "
-    f"background: rgba(128, 128, 128, 0.55); pointer-events: none; }}\n"
-    f"{_div_a}::before {{ left: 0; right: -4px; }}\n"
-    f"{_div_b}::before {{ left: -4px; right: 0; }}\n"
-)
-
 _theme_dir = os.path.dirname(os.path.abspath(__file__))
 _theme_pick = os.environ.get("UI_THEME", "")
 if _theme_pick == "off":
@@ -709,22 +1002,28 @@ if _theme_name and os.path.isfile(os.path.join(_theme_dir, _theme_name)):
 with gr.Blocks(**({} if _GR6 else {"css": css})) as demo:
     with gr.Tabs():
         with gr.Tab("Editor"):
-            with gr.Group(visible=True) as login_group:
-                login_password = gr.Textbox(label="Password", type="password", placeholder="Enter password")
-                login_btn = gr.Button("Login", variant="primary")
-                login_status = gr.Markdown("")
-            with gr.Column(elem_id="col-container", visible=False) as app_col:
-                gr.HTML('<div id="logo-title"><h1 id="ast-main-title">Qwen 2511 Image Edit</h1></div>')
+            with gr.Column(elem_id="col-container"):
+                gr.HTML(
+                    '<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@400;600&display=swap">'
+                    '<div id="logo-title">'
+                    '<h1 id="ast-main-title">Multi Ratio Image Editor</h1>'
+                    '<br>'
+                    '<h1 id="ast-nfaa-title">Not For All Audiences</h1>'
+                    '<div id="ast-notice">'
+                    '<p><b>Adults only:</b> Zero tolerance for any content involving minors. '
+                    'Images and prompts are screened, and violations are blocked.</p>'
+                    '<p>Please upload only images of adults who have consented. '
+                    'Under-18s must not use this Space.</p>'
+                    '<p>We apologize if your adult photo is blocked because it looks young, '
+                    'or if it is blocked by error. Automated screening is not perfect.</p>'
+                    '</div>'
+                    '</div>'
+                )
                 with gr.Row():
                     with gr.Column():
                         with gr.Row():
                             image_1 = gr.Image(label="Image 1", type="filepath", interactive=True)
-                            with gr.Column():
-                                image_2 = gr.Image(label="Image 2 (optional)", type="filepath", interactive=True)
-                                duplicate_input = gr.Checkbox(
-                                    label="Duplicate image 1",
-                                    value=False,
-                                )
+                            image_2 = gr.Image(label="Image 2 (optional)", type="filepath", interactive=True)
 
                         prompt = gr.Text(
                             label="Prompt 🪄",
@@ -732,22 +1031,33 @@ with gr.Blocks(**({} if _GR6 else {"css": css})) as demo:
                             placeholder="Enter your prompt here...",
                         )
                         run_button = gr.Button("Edit!", variant="primary", interactive=False)
+                        age_confirm = gr.Checkbox(
+                            label="I am 18+ and will use only images of consenting adults",
+                            value=False,
+                            elem_id="age-confirm",
+                        )
 
                         with gr.Group():
-                            gpu_size = gr.Radio(
-                                label="GPU Size",
-                                choices=[("Large", "large"), ("Xlarge", "xlarge")],
-                                value=GPU_SIZE_DEFAULT,
-                                elem_id="gpu-size",
-                            )
-                            gr.Markdown(
-                                "⚠️ Note: Xlarge is faster but uses 2× quota",
-                                elem_id="gpu-size-note",
+                            aspect_ratio = gr.Radio(
+                                label="Aspect Ratio",
+                                show_label=True,
+                                choices=ASPECT_RATIOS,
+                                value=RATIO_DEFAULT,
+                                elem_id="aspect-ratio",
                             )
 
                         with gr.Group():
+                            gr.Markdown("Lanczos Upscale", elem_classes=["lanczos-title"])
+                            with gr.Row(elem_id="lanczos-row"):
+                                scale_basic = gr.Checkbox(label="Basic", value=False, min_width=0)
+                                scale_medium = gr.Checkbox(label="Medium", value=False, min_width=0)
+                                scale_high = gr.Checkbox(label="High", value=False, min_width=0)
+
+                        with gr.Group():
+                            gr.Markdown("Output Format", elem_classes=["lanczos-title"])
                             output_format = gr.Radio(
                                 label="Output Format",
+                                show_label=False,
                                 choices=["PNG", "JPG", "WebP"],
                                 value="PNG",
                                 elem_id="output-format",
@@ -781,40 +1091,21 @@ with gr.Blocks(**({} if _GR6 else {"css": css})) as demo:
                                 )
 
                             with gr.Group():
-                                resolution_mode = gr.Radio(
-                                    label="Resolution mode",
-                                    choices=["Auto", "Preset", "Custom"],
-                                    value="Auto",
-                                    elem_id="res-mode",
-                                )
-                                resolution_preset = gr.Radio(
-                                    label="Resolution",
-                                    choices=PRESET_ALL,
-                                    value=PRESET_DEFAULT,
-                                    elem_classes=["preset-grid"],
-                                    elem_id="res-preset",
+                                gpu_size = gr.Radio(
+                                    label="GPU Size",
+                                    choices=[("Large", "large"), ("Xlarge", "xlarge")],
+                                    value=GPU_SIZE_DEFAULT,
+                                    elem_id="gpu-size",
                                 )
-                                custom_height = gr.Slider(
-                                    label="Height", minimum=256, maximum=2048, step=8, value=256,
-                                    buttons=[], elem_id="res-custom-height",
-                                )
-                                custom_width = gr.Slider(
-                                    label="Width", minimum=256, maximum=2048, step=8, value=256,
-                                    buttons=[], elem_id="res-custom-width",
-                                )
-                                auto_scale = gr.Radio(
-                                    label="Auto resolution",
-                                    choices=AUTO_SCALES,
-                                    value="1x",
-                                    elem_id="res-auto-scale",
+                                gr.Markdown(
+                                    "⚠️ Note: Xlarge is faster but uses 2× quota",
+                                    elem_id="gpu-size-note",
                                 )
 
                     with gr.Column():
                         result = gr.Gallery(label="Result", show_label=False, type="filepath")
-                        with gr.Row():
-                            use_output_btn = gr.Button("↗️ Use as input", variant="secondary", size="sm", visible=False)
+                        use_output_btn = gr.Button("↗️ Use as input", variant="secondary", size="sm", visible=False)
 
-            gr.HTML('<div style="height:1024px"></div>', elem_id="login-spacer")
 
         with gr.Tab("🔒", visible=False) as admin_tab:
             with gr.Group(visible=True) as admin_lock_group:
@@ -871,9 +1162,23 @@ with gr.Blocks(**({} if _GR6 else {"css": css})) as demo:
                                         **_PRIVATE,
                                     )
 
-    gr.on(
+    for _box, _js in (
+        (scale_basic, "(on) => [on, false, false]"),
+        (scale_medium, "(on) => [false, on, false]"),
+        (scale_high, "(on) => [false, false, on]"),
+    ):
+        _box.input(
+            fn=None,
+            inputs=[_box],
+            outputs=[scale_basic, scale_medium, scale_high],
+            js=_js,
+            show_progress="hidden",
+            **_PRIVATE,
+        )
+
+    edit_event = gr.on(
         triggers=[run_button.click, prompt.submit],
-        fn=infer_qwen_only,
+        fn=run_qwen_and_flux,
         inputs=[
             image_1,
             image_2,
@@ -884,34 +1189,24 @@ with gr.Blocks(**({} if _GR6 else {"css": css})) as demo:
             num_inference_steps,
             gpu_duration,
             gpu_size,
-            resolution_mode,
-            resolution_preset,
-            custom_width,
-            custom_height,
-            auto_scale,
+            aspect_ratio,
+            scale_basic,
+            scale_medium,
+            scale_high,
             output_format,
-            duplicate_input,
+            age_confirm,
         ],
         outputs=[result, seed, use_output_btn],
         **({"show_progress_on": [result]} if _SHOW_PROGRESS_ON else {}),
-    ).then(
+    )
+    edit_event.then(
         fn=_sync_result_followups,
         inputs=result,
         outputs=use_output_btn,
         show_progress="hidden",
     )
 
-    prompt.change(
-        fn=None,
-        inputs=prompt,
-        outputs=run_button,
-        js="(text) => ({__type__: 'update', interactive: !!(text && text.trim())})",
-        show_progress="hidden",
-        **_PRIVATE,
-    )
-
     use_output_btn.click(fn=use_output_as_input, inputs=[result], outputs=[image_1])
-
     result.change(
         fn=_sync_result_followups,
         inputs=result,
@@ -919,49 +1214,24 @@ with gr.Blocks(**({} if _GR6 else {"css": css})) as demo:
         show_progress="hidden",
     )
 
-    gr.on(
-        triggers=[login_btn.click, login_password.submit],
-        fn=check_user_password,
-        inputs=[login_password],
-        outputs=[login_group, app_col, login_status],
-        **_PRIVATE,
-    ).then(
-        fn=None, inputs=None, outputs=None,
-        js="""() => {
-            const nudge = () => {
-                window.dispatchEvent(new Event("resize"));
-                try { if (window.parentIFrame && window.parentIFrame.size) window.parentIFrame.size(); } catch (e) {}
-            };
-            setTimeout(() => {
-                const sp = document.getElementById("login-spacer");
-                const col = document.getElementById("col-container");
-                if (sp && col && col.offsetParent !== null) sp.style.display = "none";
-                nudge();
-            }, 600);
-            [900, 1500, 3000].forEach((ms) => setTimeout(nudge, ms));
-        }""",
+    age_confirm.change(
+        fn=None,
+        inputs=[age_confirm, prompt],
+        outputs=run_button,
+        js="(confirmed, text) => ({__type__: 'update', interactive: !!(confirmed && text && text.trim())})",
         show_progress="hidden",
         **_PRIVATE,
     )
 
-    resolution_mode.change(
-        fn=None, inputs=None, outputs=None,
-        js="""() => {
-            const nudge = () => {
-                window.dispatchEvent(new Event("resize"));
-                try { if (window.parentIFrame && window.parentIFrame.size) window.parentIFrame.size(); } catch (e) {}
-            };
-            [0, 100, 300, 800].forEach((ms) => setTimeout(nudge, ms));
-        }""",
+    prompt.change(
+        fn=None,
+        inputs=[prompt, age_confirm],
+        outputs=run_button,
+        js="(text, confirmed) => ({__type__: 'update', interactive: !!(confirmed && text && text.trim())})",
         show_progress="hidden",
         **_PRIVATE,
     )
 
-    try:
-        demo.unload(end_session)
-    except Exception as e:
-        print(f"[auth] demo.unload not available, sessions persist until restart: {e}")
-
     demo.load(fn=mark_browser_session, inputs=None, outputs=None, **_PRIVATE)
     demo.load(fn=check_admin_tab_visibility, inputs=None, outputs=[admin_tab], **_PRIVATE)
 
@@ -985,6 +1255,8 @@ with gr.Blocks(**({} if _GR6 else {"css": css})) as demo:
     )
 
 if __name__ == "__main__":
+    Age_classifier.warmup()
+    _block_image()
     demo.queue(max_size=int(os.environ.get("QUEUE_MAX_SIZE", "30")))
     launch_kwargs = dict(
         ssr_mode=False,

esrgan.py

@@ -0,0 +1,100 @@
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from huggingface_hub import HfApi, hf_hub_download
+from PIL import Image
+from safetensors.torch import load_file
+
+ESRGAN_REPO = "AST-1320/RealESRGAN_x2plus"
+
+
+class ResidualDenseBlock(nn.Module):
+    def __init__(self, num_feat=64, num_grow_ch=32):
+        super().__init__()
+        self.conv1 = nn.Conv2d(num_feat, num_grow_ch, 3, 1, 1)
+        self.conv2 = nn.Conv2d(num_feat + num_grow_ch, num_grow_ch, 3, 1, 1)
+        self.conv3 = nn.Conv2d(num_feat + 2 * num_grow_ch, num_grow_ch, 3, 1, 1)
+        self.conv4 = nn.Conv2d(num_feat + 3 * num_grow_ch, num_grow_ch, 3, 1, 1)
+        self.conv5 = nn.Conv2d(num_feat + 4 * num_grow_ch, num_feat, 3, 1, 1)
+        self.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)
+
+    def forward(self, x):
+        x1 = self.lrelu(self.conv1(x))
+        x2 = self.lrelu(self.conv2(torch.cat((x, x1), 1)))
+        x3 = self.lrelu(self.conv3(torch.cat((x, x1, x2), 1)))
+        x4 = self.lrelu(self.conv4(torch.cat((x, x1, x2, x3), 1)))
+        x5 = self.conv5(torch.cat((x, x1, x2, x3, x4), 1))
+        return x5 * 0.2 + x
+
+
+class RRDB(nn.Module):
+    def __init__(self, num_feat, num_grow_ch=32):
+        super().__init__()
+        self.rdb1 = ResidualDenseBlock(num_feat, num_grow_ch)
+        self.rdb2 = ResidualDenseBlock(num_feat, num_grow_ch)
+        self.rdb3 = ResidualDenseBlock(num_feat, num_grow_ch)
+
+    def forward(self, x):
+        out = self.rdb3(self.rdb2(self.rdb1(x)))
+        return out * 0.2 + x
+
+
+class RRDBNet(nn.Module):
+    def __init__(self, num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32):
+        super().__init__()
+        self.conv_first = nn.Conv2d(num_in_ch * 4, num_feat, 3, 1, 1)
+        self.body = nn.Sequential(*[RRDB(num_feat, num_grow_ch) for _ in range(num_block)])
+        self.conv_body = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
+        self.conv_up1 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
+        self.conv_up2 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
+        self.conv_hr = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
+        self.conv_last = nn.Conv2d(num_feat, num_out_ch, 3, 1, 1)
+        self.lrelu = nn.LeakyReLU(negative_slope=0.2, inplace=True)
+
+    def forward(self, x):
+        feat = self.conv_first(F.pixel_unshuffle(x, 2))
+        feat = feat + self.conv_body(self.body(feat))
+        feat = self.lrelu(self.conv_up1(F.interpolate(feat, scale_factor=2, mode="nearest")))
+        feat = self.lrelu(self.conv_up2(F.interpolate(feat, scale_factor=2, mode="nearest")))
+        return self.conv_last(self.lrelu(self.conv_hr(feat)))
+
+
+def load_esrgan(device):
+    files = sorted(f for f in HfApi().list_repo_files(ESRGAN_REPO) if f.endswith(".safetensors"))
+    if not files:
+        raise FileNotFoundError(f"no .safetensors file in {ESRGAN_REPO}")
+    state = load_file(hf_hub_download(repo_id=ESRGAN_REPO, filename=files[0]))
+    for prefix in ("params_ema.", "params.", "model."):
+        if any(k.startswith(prefix) for k in state):
+            state = {(k[len(prefix):] if k.startswith(prefix) else k): v for k, v in state.items()}
+    net = RRDBNet()
+    net.load_state_dict(state, strict=True)
+    dtype = torch.float16 if str(device).startswith("cuda") else torch.float32
+    return net.eval().to(device=device, dtype=dtype)
+
+
+@torch.no_grad()
+def esrgan_x2(model, image):
+    param = next(model.parameters())
+    arr = np.asarray(image.convert("RGB"), dtype=np.float32) / 255.0
+    x = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0).to(device=param.device, dtype=param.dtype)
+    h, w = x.shape[2], x.shape[3]
+    if h % 2 or w % 2:
+        x = F.pad(x, (0, w % 2, 0, h % 2), mode="reflect")
+    y = model(x)[:, :, : h * 2, : w * 2].float().clamp_(0, 1)
+    out = (y.squeeze(0).permute(1, 2, 0).cpu().numpy() * 255.0).round().astype(np.uint8)
+    return Image.fromarray(out)
+
+
+def upscale_to_pixels(model, image, target_pixels):
+    w, h = image.size
+    scale = (target_pixels / (w * h)) ** 0.5
+    if scale <= 1.0:
+        return image
+    target = (round(w * scale), round(h * scale))
+    if model is not None:
+        image = esrgan_x2(model, image)
+    if image.size != target:
+        image = image.resize(target, Image.LANCZOS)
+    return image

packages.txt

@@ -0,0 +1,3 @@
+libgles2
+libegl1
+libgl1

requirements.txt

@@ -7,4 +7,6 @@ torchvision==0.28.0
 torchao==0.18.0
 huggingface-hub==1.33.0
 tokenizers==0.23.3
-pillow==12.3.0
+pillow==12.3.0
+opencv-python-headless==4.13.0.92
+mediapipe==0.10.35

security.py

@@ -88,7 +88,7 @@ def save_input_images(sources, seed):
 
 
 def log_generation(path, prompt, seed, steps, guidance, model, width, height,
-                   out_width=None, out_height=None, duplicated=False, inputs=None):
+                   out_width=None, out_height=None, inputs=None):
     try:
         os.makedirs("outputs", exist_ok=True)
         entry = {
@@ -102,7 +102,6 @@ def log_generation(path, prompt, seed, steps, guidance, model, width, height,
             "height": height,
             "out_width": out_width,
             "out_height": out_height,
-            "duplicated_input": duplicated,
             "inputs": list(inputs or []),
             "timestamp": time.time(),
         }
@@ -229,64 +228,6 @@ def check_admin_password(password, request: gr.Request):
     return (*locked, "❌ Wrong password")
 
 
-APP_PASSWORD = os.environ.get("APP_PASSWORD", "")
-_USER_SESSIONS = set()
-_USER_LOCK = threading.Lock()
-_USER_FAILS = {}
-_USER_FAILS_ALL = []
-_USER_MAX_FAILS = 5
-_USER_MAX_FAILS_ALL = 60
-_USER_WINDOW_S = 600
-_USER_FAILS_MAX_KEYS = 5000
-
-
-def is_user(request):
-    sid = _session_id(request)
-    if not sid:
-        return False
-    with _USER_LOCK:
-        return sid in _USER_SESSIONS
-
-
-def check_user_password(password, request: gr.Request):
-    locked = (gr.update(visible=True), gr.update(visible=False))
-    if not APP_PASSWORD:
-        return (*locked, "⚠️ No APP_PASSWORD secret set on this Space — app stays locked.")
-    sid = _session_id(request)
-    ckey = _client_key(request)
-    now = time.time()
-    with _USER_LOCK:
-        _USER_FAILS_ALL[:] = [t for t in _USER_FAILS_ALL if now - t < _USER_WINDOW_S]
-        count, start = _USER_FAILS.get(ckey, [0, now])
-        if now - start > _USER_WINDOW_S:
-            count, start = 0, now
-        if count >= _USER_MAX_FAILS or len(_USER_FAILS_ALL) >= _USER_MAX_FAILS_ALL:
-            return (*locked, "⏳ Too many attempts — try again later.")
-    if sid and hmac.compare_digest(str(password or "").encode("utf-8"), APP_PASSWORD.encode("utf-8")):
-        with _USER_LOCK:
-            _USER_SESSIONS.add(sid)
-            _USER_FAILS.pop(ckey, None)
-        return gr.update(visible=False), gr.update(visible=True), ""
-    with _USER_LOCK:
-        _USER_FAILS[ckey] = [count + 1, start]
-        _USER_FAILS_ALL.append(now)
-        if len(_USER_FAILS) > _USER_FAILS_MAX_KEYS:
-            for k in [k for k, v in _USER_FAILS.items() if now - v[1] > _USER_WINDOW_S]:
-                _USER_FAILS.pop(k, None)
-    time.sleep(1.0)
-    return (*locked, "❌ Wrong password")
-
-
-def end_session(request: gr.Request):
-    sid = _session_id(request)
-    if not sid:
-        return
-    with _USER_LOCK:
-        _USER_SESSIONS.discard(sid)
-    _ADMIN_SESSIONS.discard(sid)
-    _ADMIN_URL_OK_SESSIONS.discard(sid)
-
-
 _BROWSER_SESSIONS = {}
 _BROWSER_SESSIONS_MAX = 20000
 
@@ -324,6 +265,9 @@ _RATE_STATS = {
     "blocked_locked": 0,
     "lockouts": 0,
     "lockouts_extended": 0,
+    "age_prompt": 0,
+    "age_input": 0,
+    "age_output": 0,
     "since": time.time(),
 }
 
@@ -401,6 +345,13 @@ def show_rate_message(msg):
     gr.Warning(msg)
 
 
+def record_age_block(kind, request=None):
+    kind = f"age_{kind}"
+    with _RATE_LOCK:
+        if kind in _RATE_STATS:
+            _RATE_STATS[kind] += 1
+
+
 def rate_acquire(request):
     if is_admin(request):
         return True, None, ""
@@ -427,7 +378,7 @@ def rate_acquire(request):
                 pen["spam"] = 0
                 pen["until"] = min(pen["until"] + SPAM_EXTRA_LOCK_S, now + LOCKOUT_MAX_S)
                 _RATE_STATS["lockouts_extended"] += 1
-                print(f"[rate] lock extended by {SPAM_EXTRA_LOCK_S}s on {key} (spam while locked)")
+                print(f"[rate] lock extended by {SPAM_EXTRA_LOCK_S}s (spam while locked)")
             return False, None, _paused_msg(pen["until"] - now)
 
         hits = [t for t in _RATE_HITS.get(key, []) if now - t < RATE_WINDOW_S]
@@ -548,7 +499,7 @@ def _flood_retry_after(ip, bucket="join", limit=None):
                 until = min(until + SPAM_EXTRA_LOCK_S, now + LOCKOUT_MAX_S)
                 _FLOOD_BANNED[ip] = until
                 _FLOOD_STATS["extended"] += 1
-                print(f"[flood] {ip} kept sending while banned - ban extended by {SPAM_EXTRA_LOCK_S}s")
+                print(f"[flood] ban extended by {SPAM_EXTRA_LOCK_S}s (spam while banned)")
             _FLOOD_SPAM[ip] = spam
             return int(until - now) + 1
         if until:
@@ -644,6 +595,7 @@ def load_rate_stats(request: gr.Request):
         f"- Blocked - locked-out IP: {st['blocked_locked']}",
         f"- Lockouts issued: {st['lockouts']}",
         f"- Lockouts extended (spam while locked): {st['lockouts_extended']}",
+        f"- Age classifier blocks - prompt: {st['age_prompt']}, input: {st['age_input']}, output: {st['age_output']}",
         f"- Browser sessions tracked: {sessions}",
         f"- IPs locked right now: {len(locked)}",
         f"- Flood-guard bans issued: {flood_bans}",