Upload 9 files

app.py

@@ -10,6 +10,14 @@ from typing import Any, Dict
 _CONFIG_MARKER = b"OMNICFG1"
 
 
+def _apply_frame_interpolation_settings() -> None:
+    os.environ["OMNI_BASE_FPS"] = "12"
+    os.environ["OMNI_FRAME_MULTIPLIER"] = "2"
+    os.environ["OMNI_CRF"] = "0" 
+    os.environ["OMNI_ALLOWED_FPS"] = "16,32,64,128"
+    print("[startup] Frame interpolation settings applied: BASE_FPS=12, MULTIPLIER=2, CRF=auto, ALLOWED_FPS=16,32,64,128")
+
+
 def _collect_config_values(namespace: Dict[str, Any]) -> Dict[str, Any]:
     data: Dict[str, Any] = {}
     for key, value in namespace.items():
@@ -77,7 +85,6 @@ def _materialize_private_config_from_env() -> None:
         except Exception as exc:
             print(f"[startup] warning: build private config failed: {type(exc).__name__}: {exc}")
 
-    # Local/dev fallback: if local private source exists, pack it to src/config.pyc.
     local_source_candidates = (
         repo_dir / "tools_local" / "config.py",
         repo_dir / "src_codes" / "src" / "config.py",
@@ -93,7 +100,6 @@ def _materialize_private_config_from_env() -> None:
         except Exception as exc:
             print(f"[startup] warning: pack local private config failed: {type(exc).__name__}: {exc}")
 
-    # Compatibility migration: keep existing source-less pyc workable, then repack once.
     if not pyc_target.exists():
         return
     try:
@@ -165,6 +171,7 @@ def _log_model_config_status() -> None:
 
 
 if __name__ == "__main__":
+    _apply_frame_interpolation_settings()
     _log_model_config_status()
     print("[startup] runtime preparation:")
     if callable(kickoff_runtime_prepare_background):
@@ -177,4 +184,4 @@ if __name__ == "__main__":
     else:
         print(ensure_models_ready_on_startup())
     demo = build_demo()
-    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")))
+    demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", "7860")), ssr_mode=False)

packages.txt

@@ -0,0 +1 @@
+ffmpeg

requirements.txt

@@ -1,21 +1,20 @@
 gradio==5.44.1
 spaces>=0.34.0
+gradio==5.44.1
+spaces>=0.34.0
 huggingface_hub==0.34.4
 comfyui-frontend-package==1.36.13
 comfyui-workflow-templates==0.7.69
 comfyui-embedded-docs==0.3.1
-comfy-kitchen>=0.2.5
 torch
 torchsde
 torchvision
 torchaudio
-torchao==0.17.0
-peft==0.19.1
-diffusers==0.38.0
-transformers==4.57.6
-accelerate>=1.13.0
 numpy>=1.25.0
 einops
+transformers>=4.50.3
+accelerate>=1.0.1
+diffusers>=0.35.0
 tokenizers>=0.13.3
 sentencepiece
 safetensors>=0.4.2
@@ -53,14 +52,18 @@ imageio-ffmpeg>=0.5.1
 alembic
 SQLAlchemy
 av>=14.2.0
+comfy-kitchen>=0.2.5
 kornia>=0.7.1
 spandrel
 pydantic~=2.0
 pydantic-settings~=2.0
-redis>=5.0.8
-
 opencv-python-headless==4.12.0.88
-sageattention
-onnx
+redis>=5.0.8
 glitch-this
+PyOpenGL
+PyOpenGL_accelerate
+glfw
+onnx
+onnxruntime
+sageattention
 scikit-image

src/app_lib.py

@@ -1,5 +1,3 @@
-# Auto-generated bundle. DO NOT EDIT.
-# Source-of-truth lives in src_codes/src/app_lib.py
 import os
 import json
 import re
@@ -19,14 +17,14 @@ from typing import Dict, List, Optional, Tuple, Any
 
 import gradio as gr
 import spaces
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
 
 try:
     import redis
-except Exception:  # pragma: no cover
+except Exception:
     redis = None
 
-# PRIVACY BUILD: Redis usage tracking is disabled entirely.
-# No per-IP counters, no country stats, no NSFW hit tracking.
 redis = None
 
 os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")
@@ -53,12 +51,9 @@ WORKFLOW_FILES = ("video_t2v_api.json", "video_i2v_api.json", "video_v2v_api.jso
 WORKFLOW_PACK_MARKER = b"OMNIWF1"
 WORKFLOW_PACK_SUFFIX = ".pack"
 
-# PUBLIC BUILD: built-in model manifest used when the OMNI_VIDEOS env var is
-# not set, so a duplicated Space works with no secrets. All four files are on
-# public Hugging Face repos. Override by setting OMNI_VIDEOS if desired.
 DEFAULT_OMNI_VIDEOS = (
     "wan_2.1_vae.safetensors@Comfy-Org/Wan_2.1_ComfyUI_repackaged@split_files/vae/wan_2.1_vae.safetensors"
-    "#umt5_xxl_fp8_e4m3fn_scaled.safetensors@Comfy-Org/Wan_2.1_ComfyUI_repackaged@split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors"
+    "#nsfw_wan_umt5-xxl_fp8_scaled.safetensors@geceff/Wan2.2-Custom-Models-GGUF@text_encoders/nsfw_wan_umt5-xxl_fp8_scaled.safetensors"
     "#wan22EnhancedNSFWCameraPrompt_nsfwFASTMOVEFP8High.safetensors@jorgmikel76/wan22EnhancedNSFWCameraPrompt_nsfwFASTMOVEFP8High@wan22EnhancedNSFWCameraPrompt_nsfwFASTMOVEFP8High.safetensors"
     "#wan22EnhancedNSFWCameraPrompt_nsfwFASTMOVEFP8Low.safetensors@jorgmikel76/wan22EnhancedNSFWCameraPrompt_nsfwFASTMOVEFP8High@wan22EnhancedNSFWCameraPrompt_nsfwFASTMOVEFP8Low.safetensors"
 )
@@ -72,6 +67,22 @@ _RUNTIME_PREP_RUNNING = False
 _RUNTIME_PREP_STATUS = "runtime preparation not started"
 _PREP_IO_LOCK = threading.Lock()
 
+_QWEN_MODEL = None
+_QWEN_TOKENIZER = None
+_QWEN_LOCK = threading.Lock()
+
+def _load_qwen_model():
+    global _QWEN_MODEL, _QWEN_TOKENIZER
+    with _QWEN_LOCK:
+        if _QWEN_MODEL is None:
+            model_id = "Qwen/Qwen3-0.6B"
+            _QWEN_TOKENIZER = AutoTokenizer.from_pretrained(model_id)
+            _QWEN_MODEL = AutoModelForCausalLM.from_pretrained(
+                model_id,
+                dtype=torch.float32,
+                device_map="cpu"
+            )
+    return _QWEN_MODEL, _QWEN_TOKENIZER
 
 def _split_parts(value: Optional[str] = None) -> Tuple[str, str, str, str]:
     raw = (value if value is not None else os.getenv("OMNI_VIDEOS") or DEFAULT_OMNI_VIDEOS).strip()
@@ -80,7 +91,6 @@ def _split_parts(value: Optional[str] = None) -> Tuple[str, str, str, str]:
         raise ValueError("OMNI_VIDEOS must have 4 non-empty parts separated by '#'.")
     return parts[0], parts[1], parts[2], parts[3]
 
-
 def _parse_entry(entry: str) -> Tuple[str, Optional[str], Optional[str]]:
     parts = (entry or "").strip().split("@", 2)
     filename = parts[0].strip() if parts and parts[0].strip() else ""
@@ -88,7 +98,6 @@ def _parse_entry(entry: str) -> Tuple[str, Optional[str], Optional[str]]:
     repo_relpath = parts[2].strip() if len(parts) >= 3 and parts[2].strip() else None
     return filename, repo_id, repo_relpath
 
-
 def parse_model_names(value: Optional[str] = None) -> Dict[str, str]:
     a, b, c, d = _split_parts(value)
     vae, _, _ = _parse_entry(a)
@@ -104,7 +113,6 @@ def parse_model_names(value: Optional[str] = None) -> Dict[str, str]:
         "unet_q6kl": unet_q6kl,
     }
 
-
 def parse_model_entries(value: Optional[str] = None) -> Dict[str, Tuple[str, Optional[str], Optional[str]]]:
     a, b, c, d = _split_parts(value)
     return {
@@ -114,7 +122,6 @@ def parse_model_entries(value: Optional[str] = None) -> Dict[str, Tuple[str, Opt
         "unet_q6kl": _parse_entry(d),
     }
 
-
 def _split_one_key(
     value: Optional[str] = None,
 ) -> Tuple[Optional[str], Optional[str], Optional[str], Optional[str], Optional[str]]:
@@ -125,14 +132,13 @@ def _split_one_key(
     while len(parts) < 5:
         parts.append("")
     return (
-        parts[0] or None,  # hf token
-        parts[1] or None,  # xai/openrouter token
-        parts[2] or None,  # legacy api base
-        parts[3] or None,  # worker api token
-        parts[4] or None,  # github token
+        parts[0] or None,
+        parts[1] or None,
+        parts[2] or None,
+        parts[3] or None,
+        parts[4] or None,
     )
 
-
 def _get_hf_token() -> Optional[str]:
     hf_from_one_key, _, _, _, _ = _split_one_key()
     if hf_from_one_key:
@@ -143,7 +149,6 @@ def _get_hf_token() -> Optional[str]:
             return value
     return None
 
-
 def _get_worker_api_token() -> Optional[str]:
     _, _, _, worker_from_one_key, _ = _split_one_key()
     if worker_from_one_key:
@@ -154,12 +159,10 @@ def _get_worker_api_token() -> Optional[str]:
             return value
     return None
 
-
 def _get_legacy_api_base() -> Optional[str]:
     _, _, legacy_api_base, _, _ = _split_one_key()
     return legacy_api_base
 
-
 def _get_github_token() -> Optional[str]:
     _, _, _, _, github_from_one_key = _split_one_key()
     if github_from_one_key:
@@ -170,22 +173,18 @@ def _get_github_token() -> Optional[str]:
             return value
     return None
 
-
 def _model_root_dir() -> Path:
     src_dir = Path(__file__).resolve().parent
     repo_dir = src_dir.parent
     return repo_dir / "ComfyUIVideo" / "models"
 
-
 def _repo_dir() -> Path:
     src_dir = Path(__file__).resolve().parent
     return src_dir.parent
 
-
 def _comfy_dir() -> Path:
     return _repo_dir() / "ComfyUIVideo"
 
-
 def _load_app_config():
     path = _repo_dir() / "src" / "config.pyc"
     if not path.exists():
@@ -194,7 +193,6 @@ def _load_app_config():
     raw = path.read_bytes()
     marker = b"OMNICFG1"
 
-    # Preferred format: packed binary config payload in `src/config.pyc`.
     if raw.startswith(marker):
         payload = raw[len(marker) :]
         try:
@@ -207,7 +205,6 @@ def _load_app_config():
         print(f"[config] loaded packed private config: {path}")
         return types.SimpleNamespace(**data)
 
-    # Compatibility format: standard Python sourceless bytecode.
     loader = importlib.machinery.SourcelessFileLoader("omni_video_factory_private_config", str(path))
     spec = importlib.util.spec_from_loader("omni_video_factory_private_config", loader)
     module = importlib.util.module_from_spec(spec) if spec else None
@@ -232,38 +229,30 @@ def _load_app_config():
     print(f"[config] loaded sourceless private config: {path}")
     return types.SimpleNamespace(**data)
 
-
 APP_CONFIG = _load_app_config()
 
-
 def _runtime_git_repo() -> str:
     repo = (os.getenv("OMNI_RUNTIME_GIT_REPO") or "selfitcamera/ComfyUIVideo").strip()
     return repo.removesuffix(".git")
 
-
 def _runtime_git_revision() -> str:
-    # Pin default runtime revision to a known-good commit; env can still override.
     return (os.getenv("OMNI_RUNTIME_GIT_REF") or "17b9fb3").strip()
 
-
 def _is_commit_hash(ref: str) -> bool:
     ref = (ref or "").strip()
     if len(ref) < 7 or len(ref) > 40:
         return False
     return all(ch in "0123456789abcdefABCDEF" for ch in ref)
 
-
 def _runtime_git_user() -> str:
     return (os.getenv("OMNI_RUNTIME_GIT_USER") or "selfitcamera").strip()
 
-
 def _workflow_repo_id() -> str:
     env_space_id = (os.getenv("SPACE_ID") or "").strip()
     if env_space_id:
         return env_space_id
     return (os.getenv("OMNI_WORKFLOW_REPO") or "FrameAI4687/AI-Video-0213-02").strip()
 
-
 def _runtime_git_clone_url() -> str:
     github_token = _get_github_token()
     repo = _runtime_git_repo()
@@ -271,7 +260,6 @@ def _runtime_git_clone_url() -> str:
         return f"https://{_runtime_git_user()}:{github_token}@github.com/{repo}.git"
     return f"https://github.com/{repo}.git"
 
-
 def _redact_sensitive(text: str) -> str:
     out = text
     for secret in (_get_hf_token(), _get_worker_api_token(), _get_github_token()):
@@ -279,11 +267,9 @@ def _redact_sensitive(text: str) -> str:
             out = out.replace(secret, "***")
     return out
 
-
 def _llm_api_base() -> str:
     return (os.getenv("OMNI_LLM_API_BASE") or "https://omnifilm.net").strip().rstrip("/")
 
-
 def _llm_api_base_candidates() -> List[str]:
     candidates: List[str] = []
     env_base = (os.getenv("OMNI_LLM_API_BASE") or "").strip().rstrip("/")
@@ -292,7 +278,6 @@ def _llm_api_base_candidates() -> List[str]:
     candidates.append("https://omnifilm.net")
     legacy_base = (_get_legacy_api_base() or "").strip().rstrip("/")
     if legacy_base.startswith("http://") or legacy_base.startswith("https://"):
-        # ONE_KEY third segment may include a path; keep only scheme+host as fallback.
         parts = legacy_base.split("/", 3)
         if len(parts) >= 3:
             candidates.append(parts[0] + "//" + parts[2])
@@ -304,7 +289,6 @@ def _llm_api_base_candidates() -> List[str]:
             seen.add(base)
     return ordered
 
-
 def _http_json(
     method: str,
     url: str,
@@ -349,7 +333,6 @@ def _http_json(
         return _decode_json(raw)
     except urllib.error.HTTPError as exc:
         detail = exc.read().decode("utf-8", errors="replace")
-        # Cloudflare 1010 may block urllib requests in Spaces while curl still works.
         if int(getattr(exc, "code", 0) or 0) == 403 and "1010" in detail:
             try:
                 return _http_json_via_curl()
@@ -359,7 +342,6 @@ def _http_json(
     except Exception as exc:
         raise RuntimeError(f"{type(exc).__name__}: {exc}") from exc
 
-
 def _extract_result_text(obj) -> str:
     def _strip_answer_wrapper(text: str) -> str:
         raw = (text or "").strip()
@@ -384,7 +366,6 @@ def _extract_result_text(obj) -> str:
         with_sep = [t for t in texts if "¥" in t]
         return max(with_sep or texts, key=len)
     if isinstance(obj, dict):
-        # Prefer common chat completion fields first.
         if "choices" in obj and isinstance(obj["choices"], list):
             for choice in obj["choices"]:
                 if isinstance(choice, dict):
@@ -405,7 +386,6 @@ def _extract_result_text(obj) -> str:
         return max(with_sep or texts, key=len)
     return ""
 
-
 _NSFW_PIPELINE = None
 _NSFW_STATE_LOCK = threading.Lock()
 _USAGE_STATE_LOCK = threading.Lock()
@@ -415,7 +395,6 @@ _REDIS_STATE_LOCK = threading.Lock()
 _REDIS_CLIENT = None
 _REDIS_MEMORY_LAST_CHECK_TS = 0.0
 
-
 def _redis_url() -> str:
     for key in ("REDIS_KEY", "REDIS_URL", "OMNI_REDIS_URL"):
         value = (os.getenv(key) or "").strip()
@@ -423,11 +402,9 @@ def _redis_url() -> str:
             return value
     return ""
 
-
 def _redis_enabled() -> bool:
     return bool(_redis_url())
 
-
 def _runtime_boot_marker() -> str:
     host = (os.getenv("HOSTNAME") or "unknown-host").strip() or "unknown-host"
     proc_boot = ""
@@ -442,7 +419,6 @@ def _runtime_boot_marker() -> str:
         return f"{host}:{proc_boot}"
     return host
 
-
 def _redis_scan_delete(client, pattern: str) -> int:
     total = 0
     cursor = 0
@@ -454,7 +430,6 @@ def _redis_scan_delete(client, pattern: str) -> int:
             break
     return total
 
-
 def _redis_prepare_usage_on_boot(client) -> None:
     marker_key = "ovf:meta:boot_marker"
     marker = _runtime_boot_marker()
@@ -462,36 +437,28 @@ def _redis_prepare_usage_on_boot(client) -> None:
         old = str(client.get(marker_key) or "")
     except Exception:
         old = ""
-
     if old == marker:
         return
-
     cleared_usage = 0
     try:
         cleared_usage += _redis_scan_delete(client, "ovf:usage:*")
         cleared_usage += _redis_scan_delete(client, "ovf:usage_window:*")
     except Exception as exc:
-        print(f"[redis] usage reset skipped: {type(exc).__name__}: {exc}")
-
+        pass
     try:
         client.set(marker_key, marker)
     except Exception:
         pass
 
-    print(f"[redis] usage counters reset on startup. cleared={cleared_usage} marker={marker}")
-
-
 def _redis_maybe_flush_all(client) -> None:
     global _REDIS_MEMORY_LAST_CHECK_TS
     now = time.time()
     interval_default = int(getattr(APP_CONFIG, "REDIS_MEMORY_CHECK_INTERVAL_SECONDS", 120))
     interval = max(15, int((os.getenv("REDIS_MEMORY_CHECK_INTERVAL_SECONDS") or str(interval_default)).strip() or str(interval_default)))
-
     with _REDIS_STATE_LOCK:
         if (now - float(_REDIS_MEMORY_LAST_CHECK_TS or 0.0)) < interval:
             return
         _REDIS_MEMORY_LAST_CHECK_TS = now
-
     try:
         info = client.info(section="memory")
         used = int(info.get("used_memory") or 0)
@@ -500,30 +467,24 @@ def _redis_maybe_flush_all(client) -> None:
             max_memory = int((os.getenv("REDIS_MEMORY_LIMIT_BYTES") or str(30 * 1024 * 1024)).strip() or str(30 * 1024 * 1024))
         if max_memory <= 0:
             return
-
         ratio = float(used) / float(max_memory)
         threshold_default = float(getattr(APP_CONFIG, "REDIS_FLUSH_ALL_RATIO", 0.95))
         threshold = float((os.getenv("REDIS_FLUSH_ALL_RATIO") or str(threshold_default)).strip() or str(threshold_default))
         threshold = min(0.999, max(0.6, threshold))
-
         if ratio >= threshold:
             client.flushdb()
-            print(f"[redis] memory high ({used}/{max_memory}, ratio={ratio:.3f}). flushdb executed.")
     except Exception as exc:
-        print(f"[redis] memory check skipped: {type(exc).__name__}: {exc}")
-
+        pass
 
 def _redis_client():
     global _REDIS_CLIENT
     if _REDIS_CLIENT is not None:
         return _REDIS_CLIENT
-
     if redis is None:
         return None
     url = _redis_url()
     if not url:
         return None
-
     with _REDIS_STATE_LOCK:
         if _REDIS_CLIENT is not None:
             return _REDIS_CLIENT
@@ -543,30 +504,22 @@ def _redis_client():
             client.ping()
             _redis_prepare_usage_on_boot(client)
             _REDIS_CLIENT = client
-            print(f"[redis] connected. max_connections={max_connections}")
         except Exception as exc:
-            print(f"[redis] disabled: {type(exc).__name__}: {exc}")
             _REDIS_CLIENT = None
     return _REDIS_CLIENT
 
-
 def _nsfw_enabled() -> bool:
-    # NSFW filter disabled: this project is distributed without the content filter.
     return False
 
-
 def _nsfw_policy_applies(mode: str) -> bool:
-    # NSFW filter disabled.
     return False
 
-
 def _normalize_ip(ip: str) -> str:
     ip = (ip or "").strip()
     if not ip:
         return ""
     if "," in ip:
         ip = ip.split(",", 1)[0].strip()
-    # Strip :port for IPv4-like literals.
     if "." in ip and ip.count(":") == 1:
         host, _, maybe_port = ip.rpartition(":")
         if host and maybe_port.isdigit():
@@ -575,7 +528,6 @@ def _normalize_ip(ip: str) -> str:
         ip = ip[1:-1].strip()
     return ip if 0 < len(ip) <= 128 else ""
 
-
 def _request_ip(request: Any = None) -> str:
     if request is None:
         return ""
@@ -599,16 +551,13 @@ def _request_ip(request: Any = None) -> str:
         pass
     return ""
 
-
 def _usage_entry_key(ip: str) -> str:
     key = _normalize_ip(ip)
     return key if key else "__unknown__"
 
-
 def _usage_key(ip: str) -> str:
     return f"ovf:usage:{_usage_entry_key(ip)}"
 
-
 def _usage_country_stats_key(metric: str = "video") -> str:
     m = str(metric or "video").strip().lower()
     if m == "auto":
@@ -617,136 +566,39 @@ def _usage_country_stats_key(metric: str = "video") -> str:
         return "ovf:usage:global:country_nsfw_total"
     return "ovf:usage:global:country_video_total"
 
-
 def _usage_global_video_total_key() -> str:
     return "ovf:usage:global:video_total"
 
-
 def _usage_country_ip_set_key(country_code: str) -> str:
     return f"ovf:usage:global:country_ips:{country_code}"
 
-
 def _stats_country(country_code: str) -> str:
     cc = (country_code or "").strip().upper()
     if len(cc) == 2 and cc.isalpha():
         return cc
     return "UNKNOWN"
 
-
 def _usage_window_key(ip: str, window_seconds: int, now: float) -> str:
     bucket = int(float(now) // max(1, int(window_seconds)))
     return f"ovf:usage_window:auto:{_usage_entry_key(ip)}:{bucket}"
 
-
 def _geo_key(ip: str) -> str:
     return f"ovf:geo:{_usage_entry_key(ip)}"
 
-
 def _usage_ttl_seconds() -> int:
     return max(300, int((os.getenv("REDIS_USAGE_TTL_SECONDS") or str(7 * 24 * 3600)).strip() or str(7 * 24 * 3600)))
 
-
 def _geo_ttl_seconds() -> int:
     return max(3600, int((os.getenv("REDIS_GEO_TTL_SECONDS") or str(180 * 24 * 3600)).strip() or str(180 * 24 * 3600)))
 
-
 def _set_local_country_cache(ip: str, country: str, now_ts: Optional[float] = None) -> None:
     now_ts = float(now_ts if now_ts is not None else time.time())
     with _USAGE_STATE_LOCK:
         _COUNTRY_CACHE[ip] = country
         _COUNTRY_CACHE_TS[ip] = now_ts
 
-
 def _request_country(request: Any = None, ip: str = "") -> str:
-    # PRIVACY BUILD: no header-country reads, no external geo lookups (ipwho.is/ipapi.co).
     return ""
-    keys = tuple(
-        getattr(
-            APP_CONFIG,
-            "IP_COUNTRY_HEADER_KEYS",
-            (
-                "cf-ipcountry",
-                "x-vercel-ip-country",
-                "x-hf-country",
-                "x-hf-ip-country",
-                "x-country-code",
-            ),
-        )
-        or ()
-    )
-
-    headers = {}
-    if request is not None:
-        try:
-            headers = {str(k).lower(): str(v) for k, v in dict(getattr(request, "headers", {}) or {}).items()}
-        except Exception:
-            headers = {}
-
-    normalized_ip = _normalize_ip(ip or _request_ip(request))
-
-    for key in keys:
-        v = (headers.get(str(key).lower()) or "").strip().upper()
-        if len(v) == 2 and v.isalpha():
-            if normalized_ip:
-                _set_local_country_cache(normalized_ip, v)
-                client = _redis_client()
-                if client is not None:
-                    try:
-                        pipe = client.pipeline()
-                        pipe.hset(_geo_key(normalized_ip), mapping={"country": v, "updated_at": str(int(time.time()))})
-                        pipe.expire(_geo_key(normalized_ip), _geo_ttl_seconds())
-                        pipe.execute()
-                    except Exception as exc:
-                        print(f"[redis] geo save from header skipped: {type(exc).__name__}: {exc}")
-            return v
-
-    if not normalized_ip:
-        return ""
-
-    now = time.time()
-    ttl = max(60, int(getattr(APP_CONFIG, "IP_COUNTRY_CACHE_TTL_SECONDS")))
-    with _USAGE_STATE_LOCK:
-        if (now - float(_COUNTRY_CACHE_TS.get(normalized_ip, 0.0))) < ttl:
-            return str(_COUNTRY_CACHE.get(normalized_ip, "") or "").upper()
-
-    client = _redis_client()
-    if client is not None:
-        try:
-            cached = str(client.hget(_geo_key(normalized_ip), "country") or "").strip().upper()
-            if len(cached) == 2 and cached.isalpha():
-                _set_local_country_cache(normalized_ip, cached, now)
-                return cached
-        except Exception as exc:
-            print(f"[redis] geo read skipped: {type(exc).__name__}: {exc}")
-
-    if not bool(getattr(APP_CONFIG, "IP_COUNTRY_ENABLE_GEO_LOOKUP")):
-        return ""
-    if normalized_ip.startswith(("10.", "192.168.", "127.")) or normalized_ip in {"::1"}:
-        return ""
-
-    timeout = max(1, int(getattr(APP_CONFIG, "IP_COUNTRY_LOOKUP_TIMEOUT_SECONDS")))
-    country = ""
-    for url in (f"https://ipwho.is/{normalized_ip}", f"https://ipapi.co/{normalized_ip}/json/"):
-        try:
-            data = _http_json("GET", url, timeout=timeout)
-            country = str((data.get("country_code") or "")).strip().upper()
-            if len(country) == 2 and country.isalpha():
-                break
-            country = ""
-        except Exception:
-            country = ""
-
-    _set_local_country_cache(normalized_ip, country, now)
-    if country and client is not None:
-        try:
-            pipe = client.pipeline()
-            pipe.hset(_geo_key(normalized_ip), mapping={"country": country, "updated_at": str(int(now))})
-            pipe.expire(_geo_key(normalized_ip), _geo_ttl_seconds())
-            pipe.execute()
-        except Exception as exc:
-            print(f"[redis] geo save skipped: {type(exc).__name__}: {exc}")
-    return country
-
 
 def _snapshot_usage_counts(ip: str) -> Tuple[int, int, int]:
     client = _redis_client()
@@ -760,15 +612,12 @@ def _snapshot_usage_counts(ip: str) -> Tuple[int, int, int]:
             int(vals[2] or 0),
         )
     except Exception as exc:
-        print(f"[redis] usage snapshot unavailable: {type(exc).__name__}: {exc}")
         return (0, 0, 0)
 
-
 def _usage_country(ip: str, fallback_country_code: str = "") -> str:
     cc = (fallback_country_code or "").strip().upper()
     if cc:
         return cc
-
     client = _redis_client()
     if client is not None:
         try:
@@ -777,445 +626,72 @@ def _usage_country(ip: str, fallback_country_code: str = "") -> str:
                 return cc
         except Exception:
             pass
-
     return ""
 
-
 def _log_usage_snapshot(event: str, ip: str, country_code: str = "") -> None:
-    # PRIVACY BUILD: no console logging of IPs/countries.
     return
-    a, v, n = _snapshot_usage_counts(ip)
-    ip_text = _normalize_ip(ip) or "unknown"
-    cc = _usage_country(ip, country_code)
-    print(
-        f"用量统计 事件={event} IP={ip_text} 国家={cc or 'unknown'} "
-        f"自动分镜次数={a} 视频生成次数={v} NSFW次数={n}"
-    )
-
 
 def _log_global_country_video_stats_if_needed(client, global_total: int) -> None:
-    interval_default = int(getattr(APP_CONFIG, "COUNTRY_GENERATION_STATS_INTERVAL", 20))
-    interval = max(1, int((os.getenv("COUNTRY_GENERATION_STATS_INTERVAL") or str(interval_default)).strip() or str(interval_default)))
-    if global_total <= 0 or (global_total % interval) != 0:
-        return
-    try:
-        raw_video = client.hgetall(_usage_country_stats_key("video")) or {}
-        raw_auto = client.hgetall(_usage_country_stats_key("auto")) or {}
-        raw_nsfw = client.hgetall(_usage_country_stats_key("nsfw")) or {}
-    except Exception as exc:
-        print(f"[redis] global country stats skipped: {type(exc).__name__}: {exc}")
-        return
-
-    country_set = set()
-    for raw in (raw_video, raw_auto, raw_nsfw):
-        for cc in raw.keys():
-            country_set.add(_stats_country(str(cc)))
-
-    stats: List[Tuple[str, int, int, int, int]] = []
-    if country_set:
-        pipe = client.pipeline()
-        ordered_countries = sorted(country_set)
-        for cc in ordered_countries:
-            pipe.scard(_usage_country_ip_set_key(cc))
-        ip_counts = pipe.execute()
-        ip_count_map = {}
-        for idx, cc in enumerate(ordered_countries):
-            try:
-                ip_count_map[cc] = int(ip_counts[idx] or 0)
-            except Exception:
-                ip_count_map[cc] = 0
-    else:
-        ip_count_map = {}
-
-    for cc in country_set:
-        try:
-            video_count = int(raw_video.get(cc, 0) or 0)
-        except Exception:
-            video_count = 0
-        try:
-            auto_count = int(raw_auto.get(cc, 0) or 0)
-        except Exception:
-            auto_count = 0
-        try:
-            nsfw_count = int(raw_nsfw.get(cc, 0) or 0)
-        except Exception:
-            nsfw_count = 0
-        ip_count = int(ip_count_map.get(cc, 0) or 0)
-        if video_count > 0 or auto_count > 0 or nsfw_count > 0:
-            stats.append((cc, video_count, auto_count, nsfw_count, ip_count))
-
-    stats.sort(key=lambda item: (item[1], item[2], item[3]), reverse=True)
-    if not stats:
-        return
-
-    print("=" * 60)
-    print(f"📊 Global generation by country (total={global_total}, interval={interval})")
-    for cc, video_count, auto_count, nsfw_count, ip_count in stats:
-        pct = (float(video_count) / float(global_total)) * 100.0 if global_total > 0 else 0.0
-        print(
-            f"  {cc}: video={video_count} ({pct:.1f}%), "
-            f"auto-prompt={auto_count}, nsfw={nsfw_count}, unique_ip={ip_count}"
-        )
-    print("=" * 60)
-
+    return
 
 def _allow_auto_prompt_and_record(ip: str, country_code: str = "") -> Tuple[bool, str]:
-    country_code = (country_code or "").strip().upper()
-    now = time.time()
-    window_seconds = max(1, int(getattr(APP_CONFIG, "AUTO_PROMPT_WINDOW_SECONDS")))
-    per_window_limit = max(1, int(getattr(APP_CONFIG, "AUTO_PROMPT_MAX_PER_WINDOW")))
-    country_limits = dict(
-        getattr(APP_CONFIG, "AUTO_PROMPT_COUNTRY_TOTAL_LIMITS") or {}
-    )
-    limit_msg = str(getattr(APP_CONFIG, "AUTO_PROMPT_LIMIT_MESSAGE", "") or "").strip()
-    if (not limit_msg) or any("\u4e00" <= ch <= "\u9fff" for ch in limit_msg):
-        limit_msg = "Auto-prompt is temporarily unavailable. Please enter an English prompt manually."
-
-    client = _redis_client()
-    if client is None:
-        print("[redis] auto-prompt limit skipped: redis unavailable")
-        return True, ""
-
-    try:
-        _redis_maybe_flush_all(client)
-        usage_key = _usage_key(ip)
-        window_key = _usage_window_key(ip, window_seconds, now)
-
-        window_count = int(client.incr(window_key) or 0)
-        if window_count == 1:
-            client.expire(window_key, window_seconds + 5)
-        if window_count > per_window_limit:
-            try:
-                client.decr(window_key)
-            except Exception:
-                pass
-            return False, limit_msg
-
-        cc = country_code
-        if not cc:
-            cc = str(client.hget(usage_key, "country") or "").strip().upper()
-
-        total_limit = None
-        if cc:
-            try:
-                total_limit = int(country_limits.get(cc))
-            except Exception:
-                total_limit = None
-        if total_limit is not None and total_limit >= 0:
-            current_total = int(client.hget(usage_key, "auto_prompt_total") or 0)
-            if current_total >= int(total_limit):
-                try:
-                    client.decr(window_key)
-                except Exception:
-                    pass
-                return False, limit_msg
-
-        stats_country = _stats_country(cc)
-        pipe = client.pipeline()
-        if country_code:
-            pipe.hset(usage_key, "country", country_code)
-        pipe.hincrby(usage_key, "auto_prompt_total", 1)
-        pipe.hincrby(_usage_country_stats_key("auto"), stats_country, 1)
-        pipe.sadd(_usage_country_ip_set_key(stats_country), _usage_entry_key(ip))
-        pipe.expire(usage_key, _usage_ttl_seconds())
-        pipe.execute()
-        return True, ""
-    except Exception as exc:
-        print(f"[redis] auto-prompt limit skipped on error: {type(exc).__name__}: {exc}")
-        return True, ""
-
+    return True, ""
 
 def _record_video_generation(ip: str, country_code: str = "") -> None:
-    country_code = (country_code or "").strip().upper()
-    client = _redis_client()
-    if client is None:
-        print("[redis] record video skipped: redis unavailable")
-        return
-    try:
-        _redis_maybe_flush_all(client)
-        usage_key = _usage_key(ip)
-        stats_country = _stats_country(country_code)
-        pipe = client.pipeline()
-        if country_code:
-            pipe.hset(usage_key, "country", country_code)
-        pipe.hincrby(usage_key, "video_total", 1)
-        pipe.hincrby(_usage_country_stats_key("video"), stats_country, 1)
-        pipe.sadd(_usage_country_ip_set_key(stats_country), _usage_entry_key(ip))
-        pipe.incr(_usage_global_video_total_key())
-        pipe.expire(usage_key, _usage_ttl_seconds())
-        results = pipe.execute()
-        # `incr(global_total)` is always the penultimate pipeline op (before expire).
-        global_total = int(results[-2] or 0)
-        _log_global_country_video_stats_if_needed(client, global_total)
-    except Exception as exc:
-        print(f"[redis] record video skipped on error: {type(exc).__name__}: {exc}")
-
+    return
 
 def _record_nsfw_hit(ip: str, country_code: str = "") -> int:
-    country_code = (country_code or "").strip().upper()
-    client = _redis_client()
-    if client is None:
-        print("[redis] record nsfw skipped: redis unavailable")
-        return 0
-    try:
-        _redis_maybe_flush_all(client)
-        usage_key = _usage_key(ip)
-        stats_country = _stats_country(country_code)
-        pipe = client.pipeline()
-        if country_code:
-            pipe.hset(usage_key, "country", country_code)
-        pipe.hincrby(usage_key, "nsfw_total", 1)
-        pipe.hincrby(_usage_country_stats_key("nsfw"), stats_country, 1)
-        pipe.sadd(_usage_country_ip_set_key(stats_country), _usage_entry_key(ip))
-        pipe.expire(usage_key, _usage_ttl_seconds())
-        results = pipe.execute()
-        total = int(results[1] or 0)
-        return total
-    except Exception as exc:
-        print(f"[redis] record nsfw skipped on error: {type(exc).__name__}: {exc}")
-        return 0
-
+    return 0
 
 def _nsfw_counter_endpoint() -> Optional[str]:
-    candidates = [
-        (os.getenv("SELFIT_NSFW_ENDPOINT") or "").strip(),
-        (os.getenv("OMNI_NSFW_ENDPOINT") or "").strip(),
-        str(getattr(APP_CONFIG, "NSFW_COUNTER_ENDPOINT") or "").strip(),
-        (_get_legacy_api_base() or "").strip(),
-    ]
-    for raw in candidates:
-        if not raw:
-            continue
-        if not raw.startswith("http://") and not raw.startswith("https://"):
-            continue
-        url = raw.rstrip("/")
-        if not url.endswith("/nsfw_vf"):
-            # If caller only gave host, append default endpoint path.
-            if url.count("/") <= 2:
-                url = url + "/nsfw_vf"
-        return url
     return None
 
-
 def _nsfw_counter_key(ip: str) -> str:
-    normalized = _normalize_ip(ip)
-    return normalized if normalized else "__unknown__"
-
+    return "__unknown__"
 
 def _nsfw_remote_inc_total(ip: str) -> Optional[int]:
-    endpoint = _nsfw_counter_endpoint()
-    ip = _normalize_ip(ip)
-    if not endpoint or not ip:
-        return None
-    timeout = int(getattr(APP_CONFIG, "NSFW_REMOTE_TIMEOUT_SECONDS"))
-    data = _http_json("POST", endpoint, payload={"ip": ip}, timeout=timeout)
-    if int(data.get("code", -1)) != 0:
-        raise RuntimeError(f"nsfw inc failed: {data.get('message')}")
-    return int(((data.get("data") or {}).get("nsfw_total") or 0))
-
+    return None
 
 def _nsfw_remote_register_nsfw(ip: str) -> Optional[int]:
-    key = _nsfw_counter_key(ip)
-    if key != "__unknown__":
-        try:
-            total = _nsfw_remote_inc_total(key)
-            if total is not None:
-                return int(total)
-        except Exception as exc:
-            print(f"[nsfw] remote inc failed: {type(exc).__name__}: {exc}")
-            if not bool(getattr(APP_CONFIG, "NSFW_FAIL_OPEN")):
-                raise
     return None
 
-
 def _nsfw_keyword_match(label: str) -> bool:
-    text = (label or "").strip().lower()
-    keywords = tuple(getattr(APP_CONFIG, "NSFW_LABEL_KEYWORDS"))
-    return any(k and k in text for k in keywords)
-
+    return False
 
 def _get_nsfw_pipeline():
-    global _NSFW_PIPELINE
-    with _NSFW_STATE_LOCK:
-        if _NSFW_PIPELINE is None:
-            from transformers import pipeline
-
-            model_id = (os.getenv("NSFW_MODEL_ID") or getattr(APP_CONFIG, "NSFW_MODEL_ID")).strip()
-            _NSFW_PIPELINE = pipeline("image-classification", model=model_id, device=-1)
-        return _NSFW_PIPELINE
-
+    return None
 
 def _nsfw_predict_label_from_pil(pil_image) -> str:
-    pipe = _get_nsfw_pipeline()
-    out = pipe(pil_image, top_k=1)
-    if not out:
-        return "unknown"
-    best = out[0] if isinstance(out, list) else out
-    return str(best.get("label") or "unknown")
-
+    return "unknown"
 
 def _video_frames_for_nsfw(video_path: str):
-    try:
-        import cv2
-        from PIL import Image
-    except Exception:
-        return []
-    if not video_path or not os.path.exists(video_path):
-        return []
-
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        return []
-    frames = []
-    try:
-        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0)
-        ratios = tuple(getattr(APP_CONFIG, "NSFW_SAMPLE_RATIOS"))
-        if frame_count > 0:
-            idxs = []
-            for ratio in ratios[:2]:
-                try:
-                    idx = int(frame_count * float(ratio))
-                except Exception:
-                    idx = int(frame_count * 0.5)
-                idxs.append(max(0, min(frame_count - 1, idx)))
-            for idx in idxs:
-                cap.set(cv2.CAP_PROP_POS_FRAMES, int(idx))
-                ok, frame = cap.read()
-                if ok and frame is not None:
-                    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                    frames.append(Image.fromarray(frame))
-        if frames:
-            return frames
-
-        # Fallback for formats where CAP_PROP_FRAME_COUNT is unreliable.
-        raw_frames = []
-        while True:
-            ok, frame = cap.read()
-            if not ok or frame is None:
-                break
-            raw_frames.append(frame)
-            if len(raw_frames) > 512:
-                break
-        if not raw_frames:
-            return []
-        total = len(raw_frames)
-        idxs = []
-        for ratio in ratios[:2]:
-            try:
-                idx = int(total * float(ratio))
-            except Exception:
-                idx = int(total * 0.5)
-            idxs.append(max(0, min(total - 1, idx)))
-        for idx in idxs:
-            frame = cv2.cvtColor(raw_frames[idx], cv2.COLOR_BGR2RGB)
-            frames.append(Image.fromarray(frame))
-        return frames
-    finally:
-        try:
-            cap.release()
-        except Exception:
-            pass
-
+    return []
 
 def _nsfw_check_video(video_path: str) -> Tuple[bool, str]:
-    frames = _video_frames_for_nsfw(video_path)
-    if not frames:
-        return False, "nsfw=unknown(frame_extract_failed)"
-
-    labels = []
-    names = ("mid", "p80")
-    for i, frame in enumerate(frames[:2]):
-        label = _nsfw_predict_label_from_pil(frame)
-        labels.append((names[i] if i < len(names) else f"f{i}", label))
-    flagged = any(_nsfw_keyword_match(lbl) for _, lbl in labels)
-    detail = ", ".join(f"{k}={v}" for k, v in labels) if labels else "none"
-    return flagged, f"nsfw={flagged} ({detail})"
-
+    return False, ""
 
 def _nsfw_blur_preview_from_video(video_path: str) -> Optional[str]:
-    frames = _video_frames_for_nsfw(video_path)
-    if not frames:
-        return None
-    target = frames[1] if len(frames) > 1 else frames[0]
-    try:
-        from PIL import ImageFilter
-    except Exception:
-        return None
-    try:
-        base = target.convert("RGB")
-        blurred = base.filter(ImageFilter.GaussianBlur(radius=32))
-        merged = base.blend(blurred, alpha=0.8)
-        out_path = _output_dir() / f"nsfw_blur_{int(time.time() * 1000)}.jpg"
-        merged.save(out_path, format="JPEG", quality=88)
-        return str(out_path)
-    except Exception:
-        return None
-
+    return None
 
 def _nsfw_warning_card_html() -> str:
-    return (
-        "<div style='margin-top:10px;padding:0;'>"
-        "<div style='border:1px solid #f59e0b;border-radius:16px;overflow:hidden;"
-        "box-shadow:0 6px 18px rgba(245,158,11,0.18);background:#fff7ed;'>"
-        "<div style='background:linear-gradient(135deg,#f59e0b 0%,#f97316 100%);padding:10px 14px;'>"
-        "<div style='color:white;font-weight:700;font-size:14px;'>⚠️ NSFW Warning</div>"
-        "</div>"
-        "<div style='padding:12px 14px;color:#7c2d12;font-size:13px;line-height:1.55;'>"
-        "<div>Sensitive content detected. Please adjust prompts for safer output.</div>"
-        "<div style='margin-top:8px;color:#92400e;'>According to Hugging Face content policy "
-        "(<a href='https://huggingface.co/content-policy' target='_blank' "
-        "style='color:#b45309;font-weight:700;text-decoration:none;'>https://huggingface.co/content-policy</a>), "
-        "this Space includes mandatory safety filtering. Repeated inappropriate content may cause your account "
-        "to lose access to this Space.</div>"
-        "</div>"
-        "</div>"
-        "</div>"
-    )
-
+    return ""
 
 def _nsfw_blocked_card_html() -> str:
-    return (
-        "<div style='margin-top:10px;padding:0;'>"
-        "<div style='border:1px solid #ef4444;border-radius:16px;overflow:hidden;"
-        "box-shadow:0 8px 24px rgba(239,68,68,0.18);background:#fef2f2;'>"
-        "<div style='background:linear-gradient(135deg,#ef4444 0%,#dc2626 100%);padding:10px 14px;'>"
-        "<div style='color:white;font-weight:700;font-size:14px;'>🚫 NSFW Blocked</div>"
-        "</div>"
-        "<div style='padding:12px 14px;color:#7f1d1d;font-size:13px;line-height:1.55;'>"
-        "<div>This output has been hidden by policy. Please switch to a safer prompt.</div>"
-        "<div style='margin-top:8px;color:#991b1b;'>According to Hugging Face content policy "
-        "(<a href='https://huggingface.co/content-policy' target='_blank' "
-        "style='color:#b91c1c;font-weight:700;text-decoration:none;'>https://huggingface.co/content-policy</a>), "
-        "this Space includes mandatory safety filtering. Repeated inappropriate content may cause your account "
-        "to lose access to this Space.</div>"
-        "<div style='margin-top:8px;color:#991b1b;'>A blurred preview may be shown below.</div>"
-        "</div>"
-        "</div>"
-        "</div>"
-    )
-
+    return ""
 
 def _nsfw_card_update_for_status(status_text: str):
-    text = str(status_text or "")
-    if "NSFW blocked:" in text:
-        return gr.update(value=_nsfw_blocked_card_html(), visible=True)
-    if "NSFW warning:" in text:
-        return gr.update(value=_nsfw_warning_card_html(), visible=True)
     return gr.update(value="", visible=False)
 
-
 def _nsfw_preview_update(path: Optional[str]):
     p = str(path or "").strip()
     if p and Path(p).exists():
         return gr.update(value=p, visible=True)
     return gr.update(value=None, visible=False)
 
-
 def _public_generation_status(status_text: str) -> str:
     lines = [str(raw or "").strip() for raw in str(status_text or "").splitlines() if str(raw or "").strip()]
     if not lines:
         return "ZeroGPU elapsed: --"
-
     elapsed_line = "ZeroGPU elapsed: --"
     detail_lines: List[str] = []
     for line in lines:
@@ -1223,64 +699,22 @@ def _public_generation_status(status_text: str) -> str:
             elapsed_line = line
         else:
             detail_lines.append(line)
-
     if not detail_lines:
         return elapsed_line
-
     detail = detail_lines[0]
     if len(detail) > 320:
         detail = detail[:317] + "..."
     return f"{detail}\n{elapsed_line}"
 
-
 def _should_show_like_tip(ip: str) -> bool:
-    normalized_ip = _normalize_ip(ip)
-    if not normalized_ip:
-        return False
-    _auto_total, video_total, _nsfw_total = _snapshot_usage_counts(normalized_ip)
-    return int(video_total) >= 2
-
+    return False
 
 def _download_upsell_card_html(show_like_tip: bool = False) -> str:
-    like_tip_html = ""
-    if show_like_tip:
-        like_tip_html = (
-            "<div style='margin-bottom:8px;font-weight:700;color:#1f1f7a;'>"
-            "If this Space helps you, please give us a ❤️ on Hugging Face."
-            "</div>"
-        )
-    return (
-        "<div style='margin-top:10px;padding:0;'>"
-        "<div style='border:1px solid #c7d2fe;border-radius:16px;overflow:hidden;"
-        "box-shadow:0 8px 22px rgba(99,102,241,0.16);background:linear-gradient(135deg,#eef2ff 0%,#e0e7ff 100%);'>"
-        "<div style='padding:14px 16px;color:#312e81;font-size:13px;line-height:1.7;text-align:center;'>"
-        + like_tip_html
-        + "This Space is currently in Lite mode.<br/>Visit our Official Site for unbound creativity, commercial licensing, and 20s cinematic video."
-        "</div>"
-        "<div style='display:flex;justify-content:center;padding:0 16px 16px 16px;'>"
-        "<a href='https://omnieditor.net/image-to-video' target='_blank' style='display:inline-flex;"
-        "align-items:center;justify-content:center;min-width:280px;padding:12px 36px;border-radius:12px;"
-        "background:linear-gradient(135deg,#ff8a65 0%,#f6c453 100%);color:white;text-decoration:none;"
-        "font-weight:800;font-size:14px;box-shadow:0 6px 18px rgba(245,158,11,0.28);'>"
-        "Visit Official Site"
-        "</a>"
-        "</div>"
-        "</div>"
-        "</div>"
-    )
-
+    return ""
 
 def _download_upsell_update(video_path: Optional[str], status_text: str = "", show_like_tip: bool = False):
-    text = str(status_text or "")
-    if "NSFW blocked:" in text or "NSFW warning:" in text:
-        return gr.update(value=_download_upsell_card_html(show_like_tip=show_like_tip), visible=True)
-
-    p = str(video_path or "").strip()
-    if p and Path(p).exists():
-        return gr.update(value=_download_upsell_card_html(show_like_tip=show_like_tip), visible=True)
     return gr.update(value="", visible=False)
 
-
 def _normalize_scene_parts(content: str, scene_count: int, fallback_prompt: str) -> List[str]:
     parts = [p.strip() for p in (content or "").split("¥") if p.strip()]
     if not parts:
@@ -1290,79 +724,70 @@ def _normalize_scene_parts(content: str, scene_count: int, fallback_prompt: str)
         normalized.append(normalized[-1])
     return normalized
 
-
 def _llm_generate_scene_prompt_text(
     mode: str,
     prompt_text: str,
     scene_count: int,
     seconds_per_scene: int,
 ) -> str:
-    # PRIVACY BUILD: no external LLM API (omnifilm.net) - prompt text never leaves this server.
-    # Auto-scene falls back to local scene splitting.
-    text, _note = _ensure_scene_prompt_text(prompt_text or "", scene_count)
-    return text
-    worker_token = _get_worker_api_token()
-    if not worker_token:
-        raise RuntimeError("WORKER_API_TOKEN is missing")
-
-    mode_norm = (mode or "").strip().lower()
-    preset = "i2v-prompt" if mode_norm == "i2v" else "t2v-prompt"
-    payload = {
-        "preset": preset,
-        "payload": {
-            "prompt_text": (prompt_text or "").strip(),
-            "scene_count": max(1, min(int(scene_count or 1), 4)),
-            "seconds_per_scene": max(1, int(seconds_per_scene or 5)),
-        },
-        "priority": 0,
-    }
-    last_err = "unknown llm error"
-    for base in _llm_api_base_candidates():
-        headers = {
-            "Authorization": f"Bearer {worker_token}",
-            "Origin": base,
-            "Referer": base + "/",
-        }
-        try:
-            submit_url = f"{base}/api/llm-tasks/submit"
-            submit_data = _http_json("POST", submit_url, payload=payload, headers=headers, timeout=30)
-            if int(submit_data.get("code", -1)) != 0:
-                raise RuntimeError(f"submit failed: {submit_data.get('message')}")
-            task_id = (
-                (submit_data.get("data") or {}).get("task_id")
-                or (submit_data.get("data") or {}).get("id")
-            )
-            if not task_id:
-                raise RuntimeError("submit succeeded but task_id missing")
-
-            status_url = f"{base}/api/llm-tasks/status/{task_id}"
-            deadline = time.time() + 45
-            while time.time() < deadline:
-                status_data = _http_json("GET", status_url, headers=headers, timeout=30)
-                if int(status_data.get("code", -1)) != 0:
-                    raise RuntimeError(f"status failed: {status_data.get('message')}")
-                task = (status_data.get("data") or {}).get("task") or {}
-                status = str(task.get("status") or "").lower().strip()
-                if status == "succeeded":
-                    result_obj = task.get("result")
-                    if result_obj is None and isinstance(task.get("result_json"), str):
-                        try:
-                            result_obj = json.loads(task["result_json"])
-                        except Exception:
-                            result_obj = task["result_json"]
-                    text = _extract_result_text(result_obj)
-                    if not text:
-                        raise RuntimeError("llm succeeded but result text is empty")
-                    return text
-                if status in {"failed", "dead", "cancelled"}:
-                    raise RuntimeError(task.get("error_text") or f"llm task {status}")
-                time.sleep(1.0)
-            raise RuntimeError("llm task timeout (45s)")
-        except Exception as exc:
-            last_err = f"{base}: {exc}"
-            continue
-    raise RuntimeError(last_err)
-
+    if scene_count <= 1:
+        text, _note = _ensure_scene_prompt_text(prompt_text or "", scene_count)
+        return text
+
+    model, tokenizer = _load_qwen_model()
+    system_prompt = (
+        "You are a cinematic video prompt generator. "
+        f"You MUST output EXACTLY {scene_count} scenes. "
+        "Separate each scene using the '¥' character. "
+        "Example format: Scene 1 description ¥ Scene 2 description"
+    )
+    user_prompt = f"Expand this prompt into {scene_count} continuous cinematic scenes: {prompt_text}"
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt}
+    ]
+    text_input = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True
+    )
+    model_inputs = tokenizer([text_input], return_tensors="pt")
+    
+    # Increase max_new_tokens to allow the model to finish its reasoning process
+    generated_ids = model.generate(
+        **model_inputs,
+        max_new_tokens=1536
+    )
+    generated_ids = [
+        output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
+    ]
+    response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
+    
+    # Strictly remove the <think> section
+    if "</think>" in response:
+        response = response.split("</think>")[-1].strip()
+    else:
+        import re
+        response = re.sub(r'<think>.*', '', response, flags=re.DOTALL).strip()
+        
+    # Fallback to the original prompt if the response is empty
+    if not response.strip():
+        response = " ¥ ".join([prompt_text] * scene_count)
+    
+    import re
+    if '¥' not in response and scene_count > 1:
+        parts = re.split(r'(?i)scene\s*\d+:', response)
+        parts = [p.strip() for p in parts if p.strip()]
+        if len(parts) >= scene_count:
+            response = ' ¥ '.join(parts[:scene_count])
+        else:
+            sentences = [s.strip() for s in response.split('.') if s.strip()]
+            if len(sentences) >= scene_count:
+                chunk_size = max(1, len(sentences) // scene_count)
+                chunks = [' '.join(sentences[i:i+chunk_size]) for i in range(0, len(sentences), chunk_size)]
+                response = ' ¥ '.join(chunks[:scene_count])
+            
+    return response
 
 def _auto_prompt_for_mode(mode: str, prompt_text: str, scene_count: int, seconds_per_scene: int) -> Tuple[str, str]:
     prompt_text = (prompt_text or "").strip()
@@ -1370,7 +795,6 @@ def _auto_prompt_for_mode(mode: str, prompt_text: str, scene_count: int, seconds
     scenes = _normalize_scene_parts(llm_text, scene_count, prompt_text)
     return "¥".join(scenes), f"auto-prompt ok: {scene_count} scenes"
 
-
 def _ensure_scene_prompt_text(prompt_text: str, scene_count: int) -> Tuple[str, str]:
     prompt_text = (prompt_text or "").strip()
     if scene_count <= 1:
@@ -1378,7 +802,6 @@ def _ensure_scene_prompt_text(prompt_text: str, scene_count: int) -> Tuple[str,
     scenes = _normalize_scene_parts(prompt_text, scene_count, prompt_text)
     return "¥".join(scenes), "scene prompt: expanded from base prompt"
 
-
 def _normalize_scene_inputs(scene_count: int, base_prompt: str, scenes: List[str]) -> List[str]:
     scene_count = max(1, min(int(scene_count), 4))
     base_prompt = (base_prompt or "").strip()
@@ -1393,7 +816,6 @@ def _normalize_scene_inputs(scene_count: int, base_prompt: str, scenes: List[str
             normalized[i] = normalized[i - 1] if i > 0 and normalized[i - 1] else base_prompt
     return normalized[:scene_count]
 
-
 def _scene_values_for_ui(scene_count: int, scene_array: List[str]) -> Tuple[str, str, str, str]:
     vals = list(scene_array or [])
     while len(vals) < 4:
@@ -1404,19 +826,8 @@ def _scene_values_for_ui(scene_count: int, scene_array: List[str]) -> Tuple[str,
         vals[count] = vals[count] if count < len(vals) else ""
     return vals[0], vals[1], vals[2], vals[3]
 
-
 def _ui_generate_scenes(mode: str, prompt_text: str, scene_count: int, seconds_per_scene: int, request: Any = None):
     count = max(1, min(int(scene_count or 1), 4))
-    ip = _request_ip(request)
-    cc = _request_country(request, ip=ip)
-    ok, deny_msg = _allow_auto_prompt_and_record(ip, cc)
-    if not ok:
-        _log_usage_snapshot("auto-prompt受限", ip, cc)
-        fallback = _normalize_scene_inputs(count, "", ["", "", "", ""])
-        s1, s2, s3, s4 = _scene_values_for_ui(count, fallback)
-        return s1, s2, s3, s4, deny_msg
-
-    _log_usage_snapshot("auto-prompt执行", ip, cc)
     try:
         joined, note = _auto_prompt_for_mode(mode, prompt_text, count, int(seconds_per_scene or 3))
         scenes = _normalize_scene_parts(joined, count, prompt_text)
@@ -1427,11 +838,9 @@ def _ui_generate_scenes(mode: str, prompt_text: str, scene_count: int, seconds_p
         s1, s2, s3, s4 = _scene_values_for_ui(count, fallback)
         return s1, s2, s3, s4, f"auto-prompt failed: {exc}"
 
-
 def _workflow_pack_path(wf_dir: Path, workflow_name: str) -> Path:
     return wf_dir / f"{workflow_name}{WORKFLOW_PACK_SUFFIX}"
 
-
 def _decode_packed_workflow(raw: bytes) -> str:
     if not raw.startswith(WORKFLOW_PACK_MARKER):
         raise RuntimeError("invalid workflow pack marker")
@@ -1439,16 +848,13 @@ def _decode_packed_workflow(raw: bytes) -> str:
     decoded = zlib.decompress(payload)
     return decoded.decode("utf-8")
 
-
 def _materialize_workflow_from_pack(wf_dir: Path, workflow_name: str) -> Tuple[bool, str]:
     json_path = wf_dir / workflow_name
     if json_path.exists():
         return True, "workflow json already exists"
-
     packed_path = _workflow_pack_path(wf_dir, workflow_name)
     if not packed_path.exists():
         return False, f"packed workflow not found: {packed_path}"
-
     try:
         text = _decode_packed_workflow(packed_path.read_bytes())
         data = json.loads(text)
@@ -1458,7 +864,6 @@ def _materialize_workflow_from_pack(wf_dir: Path, workflow_name: str) -> Tuple[b
     except Exception as exc:
         return False, f"failed to materialize {workflow_name}: {type(exc).__name__}: {exc}"
 
-
 def _materialize_packed_workflows(wf_dir: Path) -> None:
     if not wf_dir.exists():
         return
@@ -1467,20 +872,15 @@ def _materialize_packed_workflows(wf_dir: Path) -> None:
         ok, detail = _materialize_workflow_from_pack(wf_dir, name)
         if ok and detail.startswith("materialized"):
             notes.append(detail)
-    if notes:
-        print(f"[workflow] packed workflows restored in {wf_dir}: {notes}")
-
 
 def _download_workflow_files_from_hf(dest_dir: Path) -> str:
     try:
         from huggingface_hub import hf_hub_download
     except Exception as exc:
         return f"workflow hf download unavailable: {type(exc).__name__}: {exc}"
-
     repo_id = _workflow_repo_id()
     token = _get_hf_token()
     dest_dir.mkdir(parents=True, exist_ok=True)
-
     got = []
     misses = []
     candidate_filenames = {
@@ -1492,7 +892,6 @@ def _download_workflow_files_from_hf(dest_dir: Path) -> str:
         )
         for name in WORKFLOW_FILES
     }
-
     for name in WORKFLOW_FILES:
         resolved = False
         for candidate in candidate_filenames[name]:
@@ -1520,15 +919,10 @@ def _download_workflow_files_from_hf(dest_dir: Path) -> str:
                 continue
         if not resolved:
             misses.append(name)
-
     if misses:
-        return (
-            f"workflow hf download partial from space:{repo_id}; "
-            f"downloaded={got or 'none'} missing={misses}"
-        )
+        return f"workflow hf download partial from space:{repo_id}; downloaded={got or 'none'} missing={misses}"
     return f"workflow hf download ok from space:{repo_id}; downloaded={got}"
 
-
 def _expected_model_paths() -> Dict[str, Path]:
     entries = parse_model_entries()
     root = _model_root_dir()
@@ -1537,13 +931,11 @@ def _expected_model_paths() -> Dict[str, Path]:
         out[key] = root / MODEL_KEY_TO_SUBDIR[key] / filename
     return out
 
-
 def check_required_models_status() -> str:
     try:
         entries = parse_model_entries()
     except Exception as exc:
         return f"OMNI_VIDEOS invalid: {type(exc).__name__}: {exc}"
-
     root = _model_root_dir()
     lines = [f"model root: {root}"]
     for key, path in _expected_model_paths().items():
@@ -1553,18 +945,15 @@ def check_required_models_status() -> str:
         lines.append(f"- {key}: {'ok' if exists else 'missing'} -> {path.name} ({source})")
     return "\n".join(lines)
 
-
 def download_missing_models() -> str:
     try:
         from huggingface_hub import hf_hub_download
     except Exception as exc:
         return f"huggingface_hub unavailable: {type(exc).__name__}: {exc}"
-
     try:
         entries = parse_model_entries()
     except Exception as exc:
         return f"OMNI_VIDEOS invalid: {type(exc).__name__}: {exc}"
-
     token = _get_hf_token()
     results = []
     for key, path in _expected_model_paths().items():
@@ -1585,8 +974,6 @@ def download_missing_models() -> str:
                     local_dir=str(path.parent),
                 )
             )
-            # Some repos use nested paths like "split_files/vae/xxx.safetensors".
-            # We always copy to the exact expected filename/location.
             if downloaded.resolve() != path.resolve():
                 shutil.copy2(downloaded, path)
                 saved = path
@@ -1597,20 +984,17 @@ def download_missing_models() -> str:
             results.append(f"- {key}: download failed ({type(exc).__name__}: {exc})")
     return "\n".join(results)
 
-
 def ensure_models_ready_on_startup() -> str:
     try:
         entries = parse_model_entries()
     except Exception as exc:
         return f"skip auto-download: OMNI_VIDEOS invalid ({type(exc).__name__}: {exc})"
-
     missing_keys = []
     for key, path in _expected_model_paths().items():
         if not path.exists():
             missing_keys.append(key)
     if not missing_keys:
         return "all required models already present"
-
     lines = [f"missing models at startup: {', '.join(missing_keys)}"]
     lines.append(download_missing_models())
     final_missing = [key for key, path in _expected_model_paths().items() if not path.exists()]
@@ -1620,7 +1004,6 @@ def ensure_models_ready_on_startup() -> str:
         lines.append("all required models are ready")
     return "\n".join(lines)
 
-
 def _set_model_prep_state(*, running: Optional[bool] = None, status: Optional[str] = None) -> None:
     global _MODEL_PREP_RUNNING, _MODEL_PREP_STATUS
     with _MODEL_PREP_LOCK:
@@ -1629,12 +1012,10 @@ def _set_model_prep_state(*, running: Optional[bool] = None, status: Optional[st
         if status is not None:
             _MODEL_PREP_STATUS = status
 
-
 def _get_model_prep_state() -> Tuple[bool, str]:
     with _MODEL_PREP_LOCK:
         return _MODEL_PREP_RUNNING, _MODEL_PREP_STATUS
 
-
 def _run_model_prep_job() -> None:
     try:
         with _PREP_IO_LOCK:
@@ -1643,30 +1024,24 @@ def _run_model_prep_job() -> None:
         result = f"startup model preparation failed: {type(exc).__name__}: {exc}"
     _set_model_prep_state(running=False, status=result)
 
-
 def kickoff_model_prepare_background() -> str:
     if _all_models_present():
         _set_model_prep_state(running=False, status="all required models already present")
         return "all required models already present"
-
     running, status = _get_model_prep_state()
     if running:
         return f"background model preparation already running\n{status}"
-
     _set_model_prep_state(running=True, status="background model preparation started")
     worker = threading.Thread(target=_run_model_prep_job, name="model-prep", daemon=True)
     worker.start()
     return "background model preparation started"
 
-
 def ensure_models_ready_for_generation() -> Tuple[bool, str]:
     if _all_models_present():
         return True, "all required models are ready"
-
     running, status = _get_model_prep_state()
     if running:
         return False, "models are preparing in background\n" + status
-
     _set_model_prep_state(running=True, status="on-demand model preparation started")
     try:
         with _PREP_IO_LOCK:
@@ -1674,12 +1049,10 @@ def ensure_models_ready_for_generation() -> Tuple[bool, str]:
     except Exception as exc:
         result = f"on-demand model preparation failed: {type(exc).__name__}: {exc}"
     _set_model_prep_state(running=False, status=result)
-
     if _all_models_present():
         return True, result
     return False, result
 
-
 def _set_runtime_prep_state(*, running: Optional[bool] = None, status: Optional[str] = None) -> None:
     global _RUNTIME_PREP_RUNNING, _RUNTIME_PREP_STATUS
     with _RUNTIME_PREP_LOCK:
@@ -1688,12 +1061,10 @@ def _set_runtime_prep_state(*, running: Optional[bool] = None, status: Optional[
         if status is not None:
             _RUNTIME_PREP_STATUS = status
 
-
 def _get_runtime_prep_state() -> Tuple[bool, str]:
     with _RUNTIME_PREP_LOCK:
         return _RUNTIME_PREP_RUNNING, _RUNTIME_PREP_STATUS
 
-
 def _has_comfy_runtime() -> bool:
     comfy_dir = _comfy_dir()
     required = (
@@ -1706,7 +1077,6 @@ def _has_comfy_runtime() -> bool:
     )
     return all(path.exists() for path in required)
 
-
 def _runtime_missing_paths() -> list[str]:
     comfy_dir = _comfy_dir()
     required = (
@@ -1719,7 +1089,6 @@ def _runtime_missing_paths() -> list[str]:
     )
     return [str(path.relative_to(comfy_dir)) for path in required if not path.exists()]
 
-
 def _run_git(cmd: list[str], cwd: Optional[Path] = None) -> Tuple[bool, str]:
     try:
         result = subprocess.run(
@@ -1731,14 +1100,12 @@ def _run_git(cmd: list[str], cwd: Optional[Path] = None) -> Tuple[bool, str]:
         )
     except Exception as exc:
         return False, f"{type(exc).__name__}: {exc}"
-
     merged = "\n".join([result.stdout.strip(), result.stderr.strip()]).strip()
     merged = _redact_sensitive(merged)
     if result.returncode != 0:
         return False, merged or f"git command failed (exit={result.returncode})"
     return True, merged
 
-
 def _runtime_git_head(comfy_dir: Path) -> str:
     ok, detail = _run_git(["git", "-C", str(comfy_dir), "rev-parse", "--short", "HEAD"])
     if not ok:
@@ -1748,30 +1115,22 @@ def _runtime_git_head(comfy_dir: Path) -> str:
         return "unknown"
     return detail.splitlines()[-1]
 
-
 def _download_runtime_on_demand() -> str:
-    # PUBLIC BUILD: the Comfy runtime repo (selfitcamera/ComfyUIVideo) is
-    # public, so cloning works anonymously without a GitHub token.
     repo = _runtime_git_repo()
     revision = _runtime_git_revision()
     comfy_dir = _comfy_dir()
     models_dir = comfy_dir / "models"
     models_backup = _repo_dir() / ".runtime_models_backup"
     clone_url = _runtime_git_clone_url()
-    print(f"[runtime] syncing Comfy runtime from github:{repo}@{revision}")
-
     if models_backup.exists():
         shutil.rmtree(models_backup, ignore_errors=True)
-
     if comfy_dir.exists() and not (comfy_dir / ".git").exists():
         if models_dir.exists():
             try:
                 shutil.move(str(models_dir), str(models_backup))
-                print("[runtime] preserved existing models directory before git clone.")
             except Exception as exc:
                 return f"runtime clone failed while preserving models: {type(exc).__name__}: {exc}"
         shutil.rmtree(comfy_dir, ignore_errors=True)
-
     if not comfy_dir.exists():
         comfy_dir.parent.mkdir(parents=True, exist_ok=True)
         if _is_commit_hash(revision):
@@ -1808,7 +1167,6 @@ def _download_runtime_on_demand() -> str:
         ok, detail = _run_git(["git", "-C", str(comfy_dir), "reset", "--hard", "FETCH_HEAD"])
         if not ok:
             return f"runtime sync failed (reset): {detail}"
-
     if models_backup.exists():
         restored_models_dir = comfy_dir / "models"
         try:
@@ -1818,18 +1176,13 @@ def _download_runtime_on_demand() -> str:
             else:
                 restored_models_dir.parent.mkdir(parents=True, exist_ok=True)
                 shutil.move(str(models_backup), str(restored_models_dir))
-            print("[runtime] restored preserved models directory after git sync.")
         except Exception as exc:
             return f"runtime sync finished but restoring models failed: {type(exc).__name__}: {exc}"
-
     if _has_comfy_runtime():
-        print(f"[runtime] current runtime commit: {_runtime_git_head(comfy_dir)}")
-        print("[runtime] Comfy runtime git sync finished.")
         return f"runtime ready from github:{repo}@{revision}"
     missing = _runtime_missing_paths()
     return "runtime git sync finished but files are still missing: " + ", ".join(missing)
 
-
 def _run_runtime_prep_job() -> None:
     try:
         with _PREP_IO_LOCK:
@@ -1838,30 +1191,24 @@ def _run_runtime_prep_job() -> None:
         result = f"startup runtime preparation failed: {type(exc).__name__}: {exc}"
     _set_runtime_prep_state(running=False, status=result)
 
-
 def kickoff_runtime_prepare_background() -> str:
     if _has_comfy_runtime():
         _set_runtime_prep_state(running=False, status="runtime already present")
         return "runtime already present"
-
     running, status = _get_runtime_prep_state()
     if running:
         return f"background runtime preparation already running\n{status}"
-
     _set_runtime_prep_state(running=True, status="background runtime preparation started")
     worker = threading.Thread(target=_run_runtime_prep_job, name="runtime-prep", daemon=True)
     worker.start()
     return "background runtime preparation started"
 
-
 def ensure_runtime_ready_for_generation() -> Tuple[bool, str]:
     if _has_comfy_runtime():
         return True, "runtime already present"
-
     running, status = _get_runtime_prep_state()
     if running:
         return False, "runtime is preparing in background\n" + status
-
     _set_runtime_prep_state(running=True, status="on-demand runtime preparation started")
     try:
         with _PREP_IO_LOCK:
@@ -1869,18 +1216,15 @@ def ensure_runtime_ready_for_generation() -> Tuple[bool, str]:
     except Exception as exc:
         result = f"on-demand runtime preparation failed: {type(exc).__name__}: {exc}"
     _set_runtime_prep_state(running=False, status=result)
-
     if _has_comfy_runtime():
         return True, result
     return False, result
 
-
 def resolve_placeholders(obj):
     names = parse_model_names()
     resolved = _deep_resolve_placeholders(obj, names)
     return _apply_model_name_aliases(resolved, names)
 
-
 def _install_comfyapi_src_shims() -> None:
     if "src" not in sys.modules:
         pkg = types.ModuleType("src")
@@ -1890,8 +1234,7 @@ def _install_comfyapi_src_shims() -> None:
     if mod is None:
         mod = types.ModuleType("src.model_names")
         sys.modules["src.model_names"] = mod
-    mod.resolve_placeholders = resolve_placeholders  # type: ignore[attr-defined]
-
+    mod.resolve_placeholders = resolve_placeholders
 
 def _drop_conflicting_modules(base_dir: Path) -> None:
     checks = {
@@ -1914,7 +1257,6 @@ def _drop_conflicting_modules(base_dir: Path) -> None:
             if key == root_name or key.startswith(root_name + "."):
                 del sys.modules[key]
 
-
 def _get_comfy_client():
     global _COMFY_CLIENT
     if _COMFY_CLIENT is not None:
@@ -1926,6 +1268,21 @@ def _get_comfy_client():
 
     _install_comfyapi_src_shims()
     _drop_conflicting_modules(comfy_dir)
+
+    try:
+        config_path = comfy_dir / "custom_nodes" / "was-node-suite-comfyui" / "was_suite_config.json"
+        if config_path.parent.exists():
+            config_data = {}
+            if config_path.exists():
+                try:
+                    config_data = json.loads(config_path.read_text(encoding="utf-8"))
+                except Exception:
+                    pass
+            config_data["ffmpeg_bin_path"] = "/usr/bin/ffmpeg"
+            config_path.write_text(json.dumps(config_data, indent=4), encoding="utf-8")
+    except Exception:
+        pass
+
     comfy_dir_str = str(comfy_dir)
     if comfy_dir_str not in sys.path:
         sys.path.insert(0, comfy_dir_str)
@@ -1953,14 +1310,12 @@ def _get_comfy_client():
     )
     return _COMFY_CLIENT
 
-
 def _resolve_model_name(value: str, names: Dict[str, str]) -> str:
     key = PLACEHOLDER_TO_KEY.get((value or "").strip())
     if not key:
         return value
     return names.get(key, value)
 
-
 def _deep_resolve_placeholders(obj, names: Dict[str, str]):
     if isinstance(obj, dict):
         return {k: _deep_resolve_placeholders(v, names) for k, v in obj.items()}
@@ -1970,7 +1325,6 @@ def _deep_resolve_placeholders(obj, names: Dict[str, str]):
         return _resolve_model_name(obj, names)
     return obj
 
-
 def _pick_unet_key(node: Dict, original_name: str) -> str:
     title = ((node.get("_meta") or {}).get("title") or "")
     text = f"{title} {original_name}".lower()
@@ -1978,7 +1332,6 @@ def _pick_unet_key(node: Dict, original_name: str) -> str:
         return "unet_q6kl"
     return "unet_q6kh"
 
-
 def _apply_model_name_aliases(obj, names: Dict[str, str]):
     if not isinstance(obj, dict):
         return obj
@@ -1989,19 +1342,16 @@ def _apply_model_name_aliases(obj, names: Dict[str, str]):
         inputs = node.get("inputs")
         if not isinstance(inputs, dict):
             continue
-
         if "vae_name" in inputs and isinstance(inputs.get("vae_name"), str):
             inputs["vae_name"] = names["vae"]
         if "clip_name" in inputs and isinstance(inputs.get("clip_name"), str):
             inputs["clip_name"] = names["text_encoder"]
-
         if "unet_name" in inputs and isinstance(inputs.get("unet_name"), str):
             if class_type in ("UnetLoaderGGUF", "UnetLoaderGGUFAdvanced", "UNETLoader"):
                 key = _pick_unet_key(node, inputs["unet_name"])
                 inputs["unet_name"] = names[key]
     return obj
 
-
 def _collect_placeholders(obj, out: set[str]) -> None:
     if isinstance(obj, dict):
         for v in obj.values():
@@ -2014,23 +1364,17 @@ def _collect_placeholders(obj, out: set[str]) -> None:
     if isinstance(obj, str) and obj in PLACEHOLDER_TO_KEY:
         out.add(obj)
 
-
 def _workflow_dir() -> Path:
     repo_dir = _repo_dir()
     candidates = (
         repo_dir / "src" / "workflows",
     )
-
     for wf_dir in candidates:
         _materialize_packed_workflows(wf_dir)
         if all((wf_dir / name).exists() for name in WORKFLOW_FILES):
-            print(f"[workflow] using workflow dir: {wf_dir}")
             return wf_dir
-
     primary = candidates[0]
     primary.mkdir(parents=True, exist_ok=True)
-
-    # Last-resort discovery in case Space checkout layout changes unexpectedly.
     found = {}
     search_roots = [repo_dir / "src", repo_dir / "workflows", repo_dir]
     for name in WORKFLOW_FILES:
@@ -2041,7 +1385,6 @@ def _workflow_dir() -> Path:
             if matches:
                 found[name] = matches[0]
                 break
-
     if len(found) == len(WORKFLOW_FILES):
         parents = {}
         for path in found.values():
@@ -2052,35 +1395,20 @@ def _workflow_dir() -> Path:
             if not dst_path.exists() and src_path.exists():
                 shutil.copy2(src_path, dst_path)
         if all((primary / name).exists() for name in WORKFLOW_FILES):
-            print(f"[workflow] discovered fallback files and rebuilt: {primary}")
             return primary
         if all((best_parent / name).exists() for name in WORKFLOW_FILES):
-            print(f"[workflow] using discovered workflow dir: {best_parent}")
             return best_parent
-
-    hf_status = _download_workflow_files_from_hf(primary)
-    print(f"[workflow] {hf_status}")
-    if all((primary / name).exists() for name in WORKFLOW_FILES):
-        print(f"[workflow] rebuilt workflows from hf into: {primary}")
-        return primary
-
-    print("[workflow] missing workflow files; checked candidates:")
-    for wf_dir in candidates:
-        missing = [name for name in WORKFLOW_FILES if not (wf_dir / name).exists()]
-        print(f"[workflow] - {wf_dir} missing={missing}")
+    _download_workflow_files_from_hf(primary)
     return primary
 
-
 def validate_workflow_placeholders() -> str:
     try:
         names = parse_model_names()
     except Exception as exc:
         return f"OMNI_VIDEOS invalid: {type(exc).__name__}: {exc}"
-
     wf_dir = _workflow_dir()
     missing = []
     unresolved_msgs = []
-
     for wf_name in WORKFLOW_FILES:
         wf_path = wf_dir / wf_name
         if not wf_path.exists():
@@ -2091,7 +1419,6 @@ def validate_workflow_placeholders() -> str:
         except Exception as exc:
             unresolved_msgs.append(f"{wf_name}: invalid json ({type(exc).__name__})")
             continue
-
         resolved = _deep_resolve_placeholders(data, names)
         unresolved = set()
         _collect_placeholders(resolved, unresolved)
@@ -2099,17 +1426,14 @@ def validate_workflow_placeholders() -> str:
             unresolved_msgs.append(f"{wf_name}: unresolved placeholders={sorted(unresolved)}")
         else:
             unresolved_msgs.append(f"{wf_name}: ok")
-
     lines = []
     if missing:
         lines.append(f"missing workflow files: {', '.join(missing)}")
     lines.extend(unresolved_msgs)
     return "\n".join(lines) if lines else "no workflow files found"
 
-
 def _env_status_text() -> str:
     lines = []
-
     raw = (os.getenv("OMNI_VIDEOS") or "").strip()
     if not raw:
         lines.append("- OMNI_VIDEOS: missing")
@@ -2119,27 +1443,23 @@ def _env_status_text() -> str:
             lines.append(f"- OMNI_VIDEOS: ok ({parsed['vae']}, {parsed['text_encoder']})")
         except Exception as exc:
             lines.append(f"- OMNI_VIDEOS: invalid ({type(exc).__name__})")
-
     one_key = (os.getenv("ONE_KEY") or "").strip()
     lines.append("- ONE_KEY: configured" if one_key else "- ONE_KEY: missing")
     lines.append("- WORKER_API_TOKEN: configured" if _get_worker_api_token() else "- WORKER_API_TOKEN: missing")
     lines.append("- GITHUB_TOKEN: configured" if _get_github_token() else "- GITHUB_TOKEN: missing")
     return "\n".join(lines)
 
-
 @spaces.GPU(duration=20)
 def healthcheck_gpu(name: str) -> str:
     who = (name or "").strip() or "world"
     return f"Omni-Video-Factory bootstrap is running. Hello, {who}!"
 
-
 def _all_models_present() -> bool:
     try:
         return all(path.exists() for path in _expected_model_paths().values())
     except Exception:
         return False
 
-
 def _maybe_file_path(value) -> str:
     if isinstance(value, str):
         return value
@@ -2150,13 +1470,11 @@ def _maybe_file_path(value) -> str:
                 return got
     return ""
 
-
 def _output_dir() -> Path:
     out = _repo_dir() / "datas" / "outputs"
     out.mkdir(parents=True, exist_ok=True)
     return out
 
-
 def _scene_count() -> int:
     default_scene = int(getattr(APP_CONFIG, "DEFAULT_SCENE_COUNT"))
     raw = (os.getenv("OMNI_SCENE_COUNT") or str(default_scene)).strip()
@@ -2166,7 +1484,6 @@ def _scene_count() -> int:
         value = default_scene
     return max(1, min(value, 4))
 
-
 def _vid_resolution_default() -> int:
     raw = (os.getenv("OMNI_VID_RES") or "384").strip()
     try:
@@ -2177,13 +1494,11 @@ def _vid_resolution_default() -> int:
         return 384
     return value
 
-
 def _aspect_ratio_default() -> str:
     raw = (os.getenv("OMNI_ASPECT_RATIO") or "3:4").strip()
     allowed = {"16:9", "4:3", "1:1", "3:4", "9:16"}
     return raw if raw in allowed else "3:4"
 
-
 def _seconds_per_scene_default() -> int:
     raw = (os.getenv("OMNI_SECONDS_PER_SCENE") or "3").strip()
     try:
@@ -2192,7 +1507,6 @@ def _seconds_per_scene_default() -> int:
         value = 3
     return 5 if value >= 5 else 3
 
-
 def _allowed_scene_counts(resolution: int) -> List[int]:
     rules = {
         384: [1, 2, 3, 4],
@@ -2200,7 +1514,6 @@ def _allowed_scene_counts(resolution: int) -> List[int]:
     }
     return rules.get(int(resolution), [1])
 
-
 def _normalize_generation_options(
     mode: str,
     scene_count: Optional[int],
@@ -2220,27 +1533,21 @@ def _normalize_generation_options(
             scenes = _scene_count()
     if scenes not in allowed_scenes:
         scenes = allowed_scenes[-1]
-
     secs = int(seconds_per_scene) if seconds_per_scene else _seconds_per_scene_default()
     secs = 5 if secs >= 5 else 3
-    # Keep v2v aligned with UI options even though it does not use scene branches.
     if mode == "v2v":
         scenes = 1
-
     notes = f"config: res={res}, scenes={scenes}, seconds_per_scene={secs}"
     return scenes, res, secs, notes
 
-
 def _frames_for_seconds(seconds_per_scene: int) -> int:
     return 81 if int(seconds_per_scene) >= 5 else 49
 
-
 def _round_to_multiple(value: int, multiple: int = 16) -> int:
     if multiple <= 1:
         return int(value)
     return int((int(value) + multiple - 1) // multiple * multiple)
 
-
 def _compute_t2v_dims(aspect_ratio: str, resolution: int) -> Tuple[int, int]:
     res = int(resolution)
     aspect_map = {
@@ -2251,15 +1558,12 @@ def _compute_t2v_dims(aspect_ratio: str, resolution: int) -> Tuple[int, int]:
         "9:16": (9, 16),
     }
     w_ratio, h_ratio = aspect_map.get(aspect_ratio, (3, 4))
-    # Keep target pixel area anchored to resolution^2, then apply aspect ratio.
     target_area = max(256, int(res) * int(res))
     width = int((target_area * (w_ratio / h_ratio)) ** 0.5)
     height = int((target_area * (h_ratio / w_ratio)) ** 0.5)
     return _round_to_multiple(width, 16), _round_to_multiple(height, 16)
 
-
 def _gpu_duration_default() -> int:
-    # Fixed override for ZeroGPU request duration.
     default_fixed = int(getattr(APP_CONFIG, "GPU_DEFAULT_FIXED_SECONDS"))
     raw = (os.getenv("OMNI_GPU_SECONDS") or str(default_fixed)).strip()
     try:
@@ -2270,7 +1574,6 @@ def _gpu_duration_default() -> int:
     max_secs = int(getattr(APP_CONFIG, "GPU_MAX_SECONDS"))
     return max(min_secs, min(value, max_secs))
 
-
 def _estimated_runtime_seconds(
     mode: str,
     scene_count: Optional[int],
@@ -2283,7 +1586,6 @@ def _estimated_runtime_seconds(
         resolution=resolution,
         seconds_per_scene=seconds_per_scene,
     )
-    # Packed config is JSON-based, so dict keys may become strings ("384"/"512"/"800").
     raw_base_by_res = dict(getattr(APP_CONFIG, "GPU_BASE_SECONDS_BY_RES") or {})
     base_by_res: Dict[int, float] = {}
     for key, value in raw_base_by_res.items():
@@ -2299,7 +1601,6 @@ def _estimated_runtime_seconds(
     mode_multiplier = float(mode_multiplier_map.get(str(mode or "").lower().strip(), 1.0))
     return max(10.0, base * scene_multiplier * seconds_multiplier * mode_multiplier)
 
-
 def _dynamic_gpu_duration(
     mode: str,
     prompt: str,
@@ -2312,9 +1613,8 @@ def _dynamic_gpu_duration(
     aspect_ratio: str = "3:4",
     client_ip: Optional[str] = None,
     client_country: Optional[str] = None,
+    target_fps: int = 16,
 ) -> int:
-    _ = client_ip
-    _ = client_country
     raw_fixed = (os.getenv("OMNI_GPU_SECONDS") or "").strip()
     if raw_fixed:
         try:
@@ -2323,7 +1623,6 @@ def _dynamic_gpu_duration(
             return max(min_secs, min(int(raw_fixed), max_secs))
         except (TypeError, ValueError):
             pass
-
     estimated = _estimated_runtime_seconds(mode, scene_count, resolution, seconds_per_scene)
     ratio_default = float(getattr(APP_CONFIG, "GPU_BUFFER_RATIO_DEFAULT"))
     extra_default = float(getattr(APP_CONFIG, "GPU_BUFFER_SECONDS_DEFAULT"))
@@ -2342,6 +1641,34 @@ def _dynamic_gpu_duration(
     max_secs = int(getattr(APP_CONFIG, "GPU_MAX_SECONDS"))
     return max(min_secs, min(requested, max_secs))
 
+def _patch_workflow_settings(target_fps: int) -> None:
+    wf_dir = _workflow_dir()
+    for wf_name in WORKFLOW_FILES:
+        wf_path = wf_dir / wf_name
+        if not wf_path.exists():
+            continue
+        try:
+            data = json.loads(wf_path.read_text(encoding="utf-8"))
+            changed = False
+            for key, node in data.items():
+                class_type = str(node.get("class_type", ""))
+                if class_type == "VHS_VideoCombine":
+                    if "inputs" in node:
+                        if "frame_rate" in node["inputs"] and node["inputs"]["frame_rate"] != target_fps:
+                            node["inputs"]["frame_rate"] = target_fps
+                            changed = True
+                        if "crf" in node["inputs"] and node["inputs"]["crf"] != 0:
+                            node["inputs"]["crf"] = 0
+                            changed = True
+                if "VFI" in class_type or class_type == "RIFE VFI":
+                    if "inputs" in node:
+                        if "multiplier" in node["inputs"] and node["inputs"]["multiplier"] != 2:
+                            node["inputs"]["multiplier"] = 2
+                            changed = True
+            if changed:
+                wf_path.write_text(json.dumps(data, indent=4), encoding="utf-8")
+        except Exception:
+            pass
 
 @spaces.GPU(duration=_dynamic_gpu_duration)
 def run_generation_real(
@@ -2356,7 +1683,15 @@ def run_generation_real(
     aspect_ratio: str = "3:4",
     client_ip: Optional[str] = None,
     client_country: Optional[str] = None,
+    target_fps: int = 16,
 ):
+    os.environ["OMNI_TARGET_FPS"] = str(target_fps)
+    os.environ["OMNI_BASE_FPS"] = "16"
+    os.environ["OMNI_FRAME_MULTIPLIER"] = "2"
+    os.environ["OMNI_CRF"] = "0"
+    
+    _patch_workflow_settings(target_fps)
+    
     started_at = time.perf_counter()
     warming_up_message = "warming up, please retry in 15-30 seconds"
 
@@ -2370,10 +1705,7 @@ def run_generation_real(
     prompt = (prompt or "").strip()
     if not prompt:
         return _status_text("prompt is empty"), None, None
-
-    _record_video_generation(client_ip or "", client_country or "")
-    _log_usage_snapshot("点击生成", client_ip or "", client_country or "")
-
+    
     models_ok, prep_status = ensure_models_ready_for_generation()
     if not models_ok:
         return (
@@ -2463,35 +1795,8 @@ def run_generation_real(
         return _status_text(f"{mode} finished but output missing: {final_path}"), None, None
 
     status_lines: List[str] = []
-    if _nsfw_enabled() and _nsfw_policy_applies(mode):
-        try:
-            is_nsfw, _nsfw_detail = _nsfw_check_video(final_path)
-            if is_nsfw:
-                nsfw_total = _record_nsfw_hit(client_ip or "", client_country or "")
-                _log_usage_snapshot("NSFW命中", client_ip or "", client_country or "")
-                block_after = int(getattr(APP_CONFIG, "NSFW_BLOCK_AFTER_HITS"))
-                warn_after = int(getattr(APP_CONFIG, "NSFW_WARN_AFTER_HITS"))
-                if int(nsfw_total) >= max(1, warn_after):
-                    status_lines.append("NSFW warning: policy filter triggered.")
-
-                local_should_block = int(nsfw_total) >= max(1, block_after)
-                remote_total = _nsfw_remote_register_nsfw(client_ip or "")
-                remote_limit = int(getattr(APP_CONFIG, "NSFW_REMOTE_BLOCK_AFTER_TOTAL"))
-                remote_should_block = (remote_total is not None) and (int(remote_total) > int(remote_limit))
-
-                if local_should_block or remote_should_block:
-                    preview_path = _nsfw_blur_preview_from_video(final_path)
-                    try:
-                        Path(final_path).unlink(missing_ok=True)
-                    except Exception:
-                        pass
-                    status_lines.append("NSFW blocked: video has been hidden by policy.")
-                    return _status_text("\n".join(status_lines)), None, preview_path
-        except Exception as exc:
-            status_lines.append(f"NSFW check error: {type(exc).__name__}: {exc}")
     return _status_text("\n".join(status_lines)), final_path, None
 
-
 def build_demo() -> gr.Blocks:
     banner_subtitle = "Please give us a ❤️ if you find it helpful. No usage limits beyond your ZeroGPU daily quota."
     manual_prompt_min_chars = 10
@@ -2510,7 +1815,7 @@ def build_demo() -> gr.Blocks:
             f"""
             <div style="text-align: center; margin: 20px auto 10px auto; max-width: 800px;">
                 <h1 style="color: #2c3e50; margin: 0; font-size: 3.5em; font-weight: 800; letter-spacing: 3px; text-shadow: 2px 2px 4px rgba(0,0,0,0.1);">
-                    🎬 {getattr(APP_CONFIG, "APP_TITLE")}
+                    🎬 {getattr(APP_CONFIG, "APP_TITLE", "Omni Video Factory")}
                 </h1>
             </div>
             <style>
@@ -2616,6 +1921,7 @@ def build_demo() -> gr.Blocks:
             seconds_per_scene,
             resolution,
             aspect_ratio,
+            target_fps,
             base_prompt,
             s1,
             s2,
@@ -2639,6 +1945,7 @@ def build_demo() -> gr.Blocks:
                 str(aspect_ratio),
                 ip,
                 cc,
+                int(target_fps),
             )
             show_like_tip = _should_show_like_tip(ip)
             return (
@@ -2653,6 +1960,7 @@ def build_demo() -> gr.Blocks:
             scene_count,
             seconds_per_scene,
             resolution,
+            target_fps,
             image_file,
             base_prompt,
             s1,
@@ -2677,6 +1985,7 @@ def build_demo() -> gr.Blocks:
                 "3:4",
                 ip,
                 cc,
+                int(target_fps),
             )
             show_like_tip = _should_show_like_tip(ip)
             return (
@@ -2692,6 +2001,7 @@ def build_demo() -> gr.Blocks:
             seconds_per_scene,
             resolution,
             aspect_ratio,
+            target_fps,
             base_prompt,
             s1,
             s2,
@@ -2707,6 +2017,7 @@ def build_demo() -> gr.Blocks:
                 seconds_per_scene,
                 resolution,
                 aspect_ratio,
+                target_fps,
                 base_prompt,
                 s1,
                 s2,
@@ -2719,6 +2030,7 @@ def build_demo() -> gr.Blocks:
             scene_count,
             seconds_per_scene,
             resolution,
+            target_fps,
             image_file,
             base_prompt,
             s1,
@@ -2734,6 +2046,7 @@ def build_demo() -> gr.Blocks:
                 scene_count,
                 seconds_per_scene,
                 resolution,
+                target_fps,
                 image_file,
                 base_prompt,
                 s1,
@@ -2743,7 +2056,7 @@ def build_demo() -> gr.Blocks:
                 request,
             )
 
-        def _submit_v2v(prompt, video_file, resolution, seconds_per_scene, aspect_ratio, request: gr.Request):
+        def _submit_v2v(prompt, video_file, resolution, seconds_per_scene, aspect_ratio, target_fps, request: gr.Request):
             ip = _request_ip(request)
             cc = _request_country(request, ip=ip)
             status, video, preview = run_generation_real(
@@ -2758,6 +2071,7 @@ def build_demo() -> gr.Blocks:
                 str(aspect_ratio),
                 ip,
                 cc,
+                int(target_fps),
             )
             show_like_tip = _should_show_like_tip(ip)
             return (
@@ -2780,6 +2094,7 @@ def build_demo() -> gr.Blocks:
                     scene_count_i2v = gr.Radio([1, 2, 3, 4], value=default_scene, label="Scene Count")
                     seconds_i2v = gr.Radio([3, 5], value=_seconds_per_scene_default(), label="Seconds per Scene")
                     resolution_i2v = gr.Radio([384, 512], value=default_resolution, label="Resolution")
+                    target_fps_i2v = gr.Radio([16, 32, 64, 128], value=16, label="Target FPS (Frame Interpolation)")
                     resolution_note_i2v = gr.Markdown(_resolution_note_text(default_resolution))
 
                     image_i2v = gr.File(label="Image file", file_types=["image"])
@@ -2836,12 +2151,12 @@ def build_demo() -> gr.Blocks:
             )
             run_btn_i2v_manual.click(
                 _submit_i2v_manual,
-                inputs=[scene_count_i2v, seconds_i2v, resolution_i2v, image_i2v, base_prompt_i2v, s1_i2v_manual, s2_i2v_manual, s3_i2v_manual, s4_i2v_manual],
+                inputs=[scene_count_i2v, seconds_i2v, resolution_i2v, target_fps_i2v, image_i2v, base_prompt_i2v, s1_i2v_manual, s2_i2v_manual, s3_i2v_manual, s4_i2v_manual],
                 outputs=[status_i2v, out_video_i2v, nsfw_card_i2v, nsfw_preview_i2v, download_card_i2v],
             )
             run_btn_i2v_auto.click(
                 _submit_i2v,
-                inputs=[scene_count_i2v, seconds_i2v, resolution_i2v, image_i2v, base_prompt_i2v, s1_i2v_auto, s2_i2v_auto, s3_i2v_auto, s4_i2v_auto],
+                inputs=[scene_count_i2v, seconds_i2v, resolution_i2v, target_fps_i2v, image_i2v, base_prompt_i2v, s1_i2v_auto, s2_i2v_auto, s3_i2v_auto, s4_i2v_auto],
                 outputs=[status_i2v, out_video_i2v, nsfw_card_i2v, nsfw_preview_i2v, download_card_i2v],
             )
 
@@ -2851,6 +2166,7 @@ def build_demo() -> gr.Blocks:
                     scene_count_t2v = gr.Radio([1, 2, 3, 4], value=default_scene, label="Scene Count")
                     seconds_t2v = gr.Radio([3, 5], value=_seconds_per_scene_default(), label="Seconds per Scene")
                     resolution_t2v = gr.Radio([384, 512], value=default_resolution, label="Resolution")
+                    target_fps_t2v = gr.Radio([16, 32, 64, 128], value=16, label="Target FPS (Frame Interpolation)")
                     resolution_note_t2v = gr.Markdown(_resolution_note_text(default_resolution))
                     aspect_ratio_t2v = gr.Radio(["16:9", "4:3", "1:1", "3:4", "9:16"], value=default_ratio, label="Aspect Ratio")
                     dims_hint_t2v = gr.Markdown(f"T2V dims: **{d_w}x{d_h}**")
@@ -2909,12 +2225,12 @@ def build_demo() -> gr.Blocks:
             )
             run_btn_t2v_manual.click(
                 _submit_t2v_manual,
-                inputs=[scene_count_t2v, seconds_t2v, resolution_t2v, aspect_ratio_t2v, base_prompt_t2v, s1_t2v_manual, s2_t2v_manual, s3_t2v_manual, s4_t2v_manual],
+                inputs=[scene_count_t2v, seconds_t2v, resolution_t2v, aspect_ratio_t2v, target_fps_t2v, base_prompt_t2v, s1_t2v_manual, s2_t2v_manual, s3_t2v_manual, s4_t2v_manual],
                 outputs=[status_t2v, out_video_t2v, nsfw_card_t2v, nsfw_preview_t2v, download_card_t2v],
             )
             run_btn_t2v_auto.click(
                 _submit_t2v,
-                inputs=[scene_count_t2v, seconds_t2v, resolution_t2v, aspect_ratio_t2v, base_prompt_t2v, s1_t2v_auto, s2_t2v_auto, s3_t2v_auto, s4_t2v_auto],
+                inputs=[scene_count_t2v, seconds_t2v, resolution_t2v, aspect_ratio_t2v, target_fps_t2v, base_prompt_t2v, s1_t2v_auto, s2_t2v_auto, s3_t2v_auto, s4_t2v_auto],
                 outputs=[status_t2v, out_video_t2v, nsfw_card_t2v, nsfw_preview_t2v, download_card_t2v],
             )
 
@@ -2924,6 +2240,7 @@ def build_demo() -> gr.Blocks:
                     seconds_v2v = gr.Radio([3, 5], value=_seconds_per_scene_default(), label="Additional Seconds")
                     resolution_v2v = gr.Radio([384, 512], value=default_resolution, label="Resolution")
                     aspect_ratio_v2v = gr.Radio(["16:9", "4:3", "1:1", "3:4", "9:16"], value=default_ratio, label="Aspect Ratio")
+                    target_fps_v2v = gr.Radio([16, 32, 64, 128], value=16, label="Target FPS (Frame Interpolation)")
                     prompt_v2v = gr.Textbox(label="Prompt", value="Enhance this clip with cinematic lighting", lines=3)
                     video_v2v = gr.File(label="Video file", file_types=["video"])
                     run_btn_v2v = gr.Button("Submit Generate V2V", variant="primary")
@@ -2937,7 +2254,7 @@ def build_demo() -> gr.Blocks:
 
             run_btn_v2v.click(
                 _submit_v2v,
-                inputs=[prompt_v2v, video_v2v, resolution_v2v, seconds_v2v, aspect_ratio_v2v],
+                inputs=[prompt_v2v, video_v2v, resolution_v2v, seconds_v2v, aspect_ratio_v2v, target_fps_v2v],
                 outputs=[status_v2v, out_video_v2v, nsfw_card_v2v, nsfw_preview_v2v, download_card_v2v],
             )
         gr.HTML(
@@ -2994,4 +2311,4 @@ def build_demo() -> gr.Blocks:
             </div>
             """
         )
-    return demo
+    return demo