termux-diffusion 1.3.1__tar.gz → 1.3.2__tar.gz

{termux_diffusion-1.3.1/termux_diffusion.egg-info → termux_diffusion-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termux-diffusion
-Version: 1.3.1
+Version: 1.3.2
 Summary: Production On-Device AI Image Generation Framework for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)
 Home-page: https://github.com/uno-km/termux-diffusion
 Author: uno-km (AMEVA Foundation)
@@ -28,6 +28,7 @@ Classifier: Topic :: Multimedia :: Graphics
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: ameva-vulkan-runtime>=1.0.0
 Dynamic: author
 Dynamic: classifier
 Dynamic: home-page
@@ -75,7 +76,7 @@ termux-setup-storage
 
 # 2. Install Toolchains & Provision Native Engine
 pkg update -y && pkg install python clang make cmake git termux-api wget vulkan-loader vulkan-headers vulkan-tools -y
-pip install termux-diffusion && termux-diffusion-install
+pip install termux-diffusion && termux-diffusion install
 ```
 
 #### [Node.js] Node.js / TypeScript:
@@ -88,6 +89,11 @@ pkg update -y && pkg install nodejs-lts clang make cmake git termux-api wget vul
 npm install -g termux-diffusion && npx termux-diffusion install
 ```
 
+#### [Universal] One-Line Automated Bootstrap (curl):
+```bash
+curl -sL https://raw.githubusercontent.com/uno-km/termux-diffusion/main/scripts/install.sh | bash
+```
+
 ---
 
 ### [Instant] Scenario 2: Instant Generation (Ready to Run)
@@ -416,12 +422,9 @@ adb shell "/system/bin/device_config put activity_manager max_phantom_processes
 
 ---
 
-## 9. Disclaimer (면책 조항)
+## 9. Disclaimer
 
-> **Disclaimer:**  
-> *Termux-Diffusion is an independent open-source project developed for the Android Termux environment and is not officially affiliated with, endorsed by, or sponsored by the Termux project.*  
-> 
-> *(본 프로젝트는 안드로이드 Termux 환경을 위해 개발된 독립적인 오픈소스 라이브러리이며, Termux 공식 프로젝트와 직접적인 제휴 관계가 아닙니다.)*
+> *This project is an independent open-source library developed for the Android Termux environment. It is not officially affiliated with, endorsed by, or sponsored by the Termux project, stability.ai, or Google LLC.*
 
 ---
 

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/README.md

@@ -39,7 +39,7 @@ termux-setup-storage
 
 # 2. Install Toolchains & Provision Native Engine
 pkg update -y && pkg install python clang make cmake git termux-api wget vulkan-loader vulkan-headers vulkan-tools -y
-pip install termux-diffusion && termux-diffusion-install
+pip install termux-diffusion && termux-diffusion install
 ```
 
 #### [Node.js] Node.js / TypeScript:
@@ -52,6 +52,11 @@ pkg update -y && pkg install nodejs-lts clang make cmake git termux-api wget vul
 npm install -g termux-diffusion && npx termux-diffusion install
 ```
 
+#### [Universal] One-Line Automated Bootstrap (curl):
+```bash
+curl -sL https://raw.githubusercontent.com/uno-km/termux-diffusion/main/scripts/install.sh | bash
+```
+
 ---
 
 ### [Instant] Scenario 2: Instant Generation (Ready to Run)
@@ -380,12 +385,9 @@ adb shell "/system/bin/device_config put activity_manager max_phantom_processes
 
 ---
 
-## 9. Disclaimer (면책 조항)
+## 9. Disclaimer
 
-> **Disclaimer:**  
-> *Termux-Diffusion is an independent open-source project developed for the Android Termux environment and is not officially affiliated with, endorsed by, or sponsored by the Termux project.*  
-> 
-> *(본 프로젝트는 안드로이드 Termux 환경을 위해 개발된 독립적인 오픈소스 라이브러리이며, Termux 공식 프로젝트와 직접적인 제휴 관계가 아닙니다.)*
+> *This project is an independent open-source library developed for the Android Termux environment. It is not officially affiliated with, endorsed by, or sponsored by the Termux project, stability.ai, or Google LLC.*
 
 ---
 

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "termux-diffusion"
-version = "1.3.1"
+version = "1.3.2"
 description = "Production On-Device AI Image Generation Framework for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -40,6 +40,9 @@ keywords = [
     "webui-alternative"
 ]
 dynamic = ["classifiers"]
+dependencies = [
+    "ameva-vulkan-runtime>=1.0.0",
+]
 
 [project.urls]
 Homepage = "https://github.com/uno-km/termux-diffusion"
@@ -58,3 +61,6 @@ termux_diffusion = [
     "data/*.json",
     "data/*.pub"
 ]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/setup.py

@@ -11,7 +11,7 @@ if os.path.exists(readme_path):
 
 setup(
     name="termux-diffusion",
-    version="1.3.1",
+    version="1.3.2",
     description="Production On-Device AI Image Generation Framework for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -33,11 +33,13 @@ setup(
     ],
     packages=find_packages(),
     package_data={
-        "termux_diffusion": ["py.typed"],
+        "termux_diffusion": ["py.typed", "data/*.json", "data/*.pub"],
     },
     include_package_data=True,
     python_requires=">=3.8",
-    install_requires=[],
+    install_requires=[
+        "ameva-vulkan-runtime>=1.0.0",
+    ],
     entry_points={
         "console_scripts": [
             "termux-diffusion = termux_diffusion.cli:main",

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/termux_diffusion/cli.py

@@ -4,16 +4,18 @@ import argparse
 import sys
 from typing import List, Optional
 
+import logging as _logging
+
 if hasattr(sys.stdout, "reconfigure"):
     try:
         sys.stdout.reconfigure(encoding="utf-8", errors="replace")
-    except Exception:
-        pass
+    except Exception as _e:
+        _logging.getLogger(__name__).debug("stdout reconfigure failed: %s", _e)
 if hasattr(sys.stderr, "reconfigure"):
     try:
         sys.stderr.reconfigure(encoding="utf-8", errors="replace")
-    except Exception:
-        pass
+    except Exception as _e:
+        _logging.getLogger(__name__).debug("stderr reconfigure failed: %s", _e)
 
 from .core import generate
 from .hub import clear_cache, download_model, list_cached_models, list_presets

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/termux_diffusion/core.py

@@ -68,13 +68,15 @@ class GenerationResult:
 import signal
 
 def _safe_kill_process(proc: Optional[subprocess.Popen], timeout: float = 2.0) -> None:
-    """Safely terminate and reap child process groups to prevent zombie handles."""
+    """Safely terminate and reap child process groups with granular exception handling and zero zombie leak."""
     if proc is None:
         return
+
     try:
         if proc.poll() is not None:
             return
-    except Exception:
+    except (OSError, ValueError) as poll_err:
+        logger.debug("Process poll inspection note: %s", poll_err)
         return
 
     pid = getattr(proc, "pid", None)
@@ -83,12 +85,17 @@ def _safe_kill_process(proc: Optional[subprocess.Popen], timeout: float = 2.0) -
 
     logger.warning("Initiating child process termination (PID: %s)...", pid)
 
-    # Step 1: Attempt graceful SIGTERM to process group (POSIX) or single process (Windows)
+    # Step 1: Graceful termination attempt (SIGTERM / proc.terminate)
     try:
         if sys.platform != "win32":
             try:
-                os.killpg(os.getpgid(pid), signal.SIGTERM)
-            except OSError:
+                pgid = os.getpgid(pid)
+                os.killpg(pgid, signal.SIGTERM)
+            except ProcessLookupError:
+                logger.debug("Process group (PGID: %s) already exited.", pid)
+                return
+            except (OSError, PermissionError) as pg_err:
+                logger.debug("killpg SIGTERM note (PGID: %s): %s, falling back to proc.terminate()", pid, pg_err)
                 proc.terminate()
         else:
             proc.terminate()
@@ -103,15 +110,25 @@ def _safe_kill_process(proc: Optional[subprocess.Popen], timeout: float = 2.0) -
                 pid,
                 timeout,
             )
-    except Exception as e:
-        logger.debug("SIGTERM dispatch note for PID %s: %s", pid, e)
+    except ProcessLookupError:
+        logger.debug("Child process (PID: %s) already terminated before SIGTERM dispatch.", pid)
+        return
+    except PermissionError as perm_err:
+        logger.warning("Permission denied while sending SIGTERM to PID %s: %s", pid, perm_err)
+    except OSError as os_err:
+        logger.warning("OS error during SIGTERM dispatch to PID %s: %s", pid, os_err)
 
-    # Step 2: Forceful SIGKILL to process group if still alive
+    # Step 2: Forceful termination (SIGKILL / proc.kill)
     try:
         if sys.platform != "win32":
             try:
-                os.killpg(os.getpgid(pid), signal.SIGKILL)
-            except OSError:
+                pgid = os.getpgid(pid)
+                os.killpg(pgid, signal.SIGKILL)
+            except ProcessLookupError:
+                logger.debug("Process group (PGID: %s) already terminated.", pid)
+                return
+            except (OSError, PermissionError) as pg_err:
+                logger.debug("killpg SIGKILL note (PGID: %s): %s, falling back to proc.kill()", pid, pg_err)
                 proc.kill()
         else:
             proc.kill()
@@ -121,8 +138,12 @@ def _safe_kill_process(proc: Optional[subprocess.Popen], timeout: float = 2.0) -
             logger.debug("Child process (PID: %s) forcefully terminated and reaped.", pid)
         except subprocess.TimeoutExpired:
             logger.error("Child process (PID: %s) did not exit after SIGKILL (kernel D-state or pending I/O).", pid)
-    except Exception as exc:
-        logger.error("Error during child process termination (PID: %s): %s", pid, exc)
+    except ProcessLookupError:
+        logger.debug("Child process (PID: %s) already reaped before SIGKILL.", pid)
+    except PermissionError as perm_err:
+        logger.error("Permission denied while sending SIGKILL to PID %s: %s", pid, perm_err)
+    except OSError as os_err:
+        logger.error("OS error during SIGKILL dispatch to PID %s: %s", pid, os_err)
 
 
 DEFAULT_QUALITY_GUARD_NEGATIVE_PROMPT = "lowres, bad quality, blur, deformed, distorted, extra limbs, artifacts"
@@ -159,7 +180,7 @@ def generate(
     prompt: str,
     model: str = "realistic",
     negative_prompt: Optional[str] = None,
-    device: str = "cpu",
+    device: str = "auto",
     steps: Optional[int] = None,
     cfg_scale: Optional[float] = None,
     width: int = 512,
@@ -193,7 +214,7 @@ def generate(
         prompt: Detailed text description of the desired image.
         model: Preset keyword ('realistic', 'speed', 'sdxs', 'turbo', 'anime'), custom repo ('org/repo/file.gguf'), direct URL, or path to .gguf file.
         negative_prompt: Optional negative text guidance describing elements to avoid (default: None).
-        device: Computing device ('cpu', 'gpu', 'opencl', 'vulkan', 'auto'). Default is 'cpu'.
+        device: Computing device ('auto', 'gpu', 'vulkan', 'cpu', 'opencl', 'npu', 'tpu'). Default is 'auto'.
         steps: Number of denoising steps (default determined by preset, e.g. 10).
         cfg_scale: Classifier-Free Guidance scale (default determined by preset, e.g. 4.0).
         width: Output image width in pixels (default: 512).
@@ -224,14 +245,23 @@ def generate(
     if not prompt or not str(prompt).strip():
         raise ValueError("Prompt must not be empty.")
 
-    device_mode = device.lower().strip()
+    device_mode = str(device or "auto").lower().strip()
     if device_mode not in ("cpu", "gpu", "opencl", "vulkan", "npu", "tpu", "auto"):
-        raise ValueError(f"Invalid device '{device}'. Options: 'cpu', 'gpu', 'opencl', 'vulkan', 'npu', 'tpu', 'auto'.")
+        raise ValueError(f"Invalid device '{device}'. Options: 'auto', 'gpu', 'vulkan', 'cpu', 'opencl', 'npu', 'tpu'.")
 
     # Resolve device to actual available backend using hardware probing
-    from .hardware import resolve_device_backend, get_sd_cli_gpu_args
+    from .hardware import resolve_device_backend, get_sd_cli_gpu_args, get_profile_gating_manager
     effective_device, ngl_layers = resolve_device_backend(device_mode)
 
+    # 0. Runtime Profile & Model Gating Validation (Zero Test Illusion)
+    gating_mgr = get_profile_gating_manager()
+    is_safe, gate_reason = gating_mgr.validate_execution(model, effective_device)
+    if not is_safe:
+        from .exceptions import PlatformNotSupportedError
+        raise PlatformNotSupportedError(
+            f"[termux-diffusion] [GATING-BLOCKED] {gate_reason}"
+        )
+
     # 1. Pre-flight Memory Safety Inspection (Informational only, non-blocking)
     if low_ram_guard:
         safe, msg = check_memory_safety(required_mb=1200)
@@ -450,8 +480,9 @@ def generate(
             )
         cmd.extend(["--taesd", str(effective_taesd_path)])
 
-    # 5.1 Configure Environment with companion library search paths
+    # 5.1 Configure Environment with companion library search paths (Bionic priority on Android)
     env = os.environ.copy()
+    bionic_sys_dirs = ["/system/lib64", "/vendor/lib64", "/vendor/lib64/egl"]
     lib_dirs = [
         str(sd_cli.parent),
         str(sd_cli.parent.parent / "lib"),
@@ -460,10 +491,45 @@ def generate(
         str(Path.home() / ".cache" / "termux-diffusion" / "staging" / "lib"),
     ]
     cur_ld = env.get("LD_LIBRARY_PATH", "")
-    valid_dirs = [d for d in lib_dirs if Path(d).is_dir()]
+    valid_dirs = [d for d in bionic_sys_dirs + lib_dirs if Path(d).is_dir()]
     if valid_dirs:
         env["LD_LIBRARY_PATH"] = ":".join(valid_dirs + ([cur_ld] if cur_ld else []))
 
+    # 5.2 ameva-vulkan-runtime DiffusionAdapter Binding (Vulkan / GPU mode)
+    if effective_device in ("vulkan", "gpu") or device_mode in ("vulkan", "gpu"):
+        try:
+            import ameva_vulkan_runtime as avr
+            from ameva_vulkan_runtime.adapters import DiffusionAdapter
+
+            avr_ctx = avr.get_or_create_context(device_mode)
+            report = getattr(avr_ctx, "doctor", avr.Doctor()).run_self_test(verbose=False)
+
+            class EngineProxy:
+                def __init__(self, hw):
+                    self.hw_profile = hw
+
+            from .hardware import detect_hardware_profile
+            engine_proxy = EngineProxy(detect_hardware_profile())
+            binding = DiffusionAdapter.bind(engine_proxy, report)
+            
+            cfg = getattr(binding, "config", {})
+            if cfg.get("unet_tiling") and "--vae-tiling" not in cmd:
+                cmd.append("--vae-tiling")
+
+            logger.info(
+                "[termux-diffusion] DiffusionAdapter bound: backend=%s, status=%s",
+                cfg.get("backend", "vulkan"),
+                getattr(binding.status, "name", str(binding.status))
+            )
+        except Exception as e:
+            if device_mode in ("gpu", "vulkan") or strict_vulkan:
+                from .exceptions import PlatformNotSupportedError
+                raise PlatformNotSupportedError(
+                    f"[termux-diffusion] [FAIL-FAST] Vulkan execution requested (device='{device_mode}'), "
+                    f"but hardware validation failed: {e}"
+                ) from e
+            avr_ctx = None
+
     logger.info("Executing diffusion inference: %s", " ".join(cmd[:6]) + " ...")
     print(f"[termux-diffusion] Processing inference with model='{model}' (steps={steps}, threads={threads}, device={device_mode})...")
 
@@ -489,23 +555,33 @@ def generate(
                 _safe_kill_process(process)
                 raise TermuxDiffusionError("Inference cancelled by caller.")
 
+            init_logs = []
             recent_logs = deque(maxlen=20)
-            # Stream real-time progress to terminal
+            # Stream real-time progress to terminal with FD safety
             if process.stdout:
-                for line in process.stdout:
-                    if _cancel_event and _cancel_event.is_set():
-                        _safe_kill_process(process)
-                        raise TermuxDiffusionError("Inference cancelled by caller.")
-                    line_str = line.strip()
-                    if line_str:
-                        recent_logs.append(line_str)
-                        if "step" in line_str.lower() or "%" in line_str or "sampling" in line_str.lower():
-                            print(f"  > {line_str}")
-                        else:
-                            logger.debug("sd-cli: %s", line_str)
+                try:
+                    for line in process.stdout:
+                        if _cancel_event and _cancel_event.is_set():
+                            _safe_kill_process(process)
+                            raise TermuxDiffusionError("Inference cancelled by caller.")
+                        line_str = line.strip()
+                        if line_str:
+                            if len(init_logs) < 50 or "ggml_vulkan" in line_str or "error" in line_str.lower() or "failed" in line_str.lower():
+                                init_logs.append(line_str)
+                            recent_logs.append(line_str)
+                            if "step" in line_str.lower() or "%" in line_str or "sampling" in line_str.lower():
+                                print(f"  > {line_str}")
+                            else:
+                                logger.debug("sd-cli: %s", line_str)
+                finally:
+                    try:
+                        process.stdout.close()
+                    except Exception:
+                        pass
 
             process.wait(timeout=timeout)
-            if (strict_vulkan or device_mode in ("vulkan", "gpu")) and any("ggml_vulkan: No devices found" in l for l in recent_logs):
+            all_critical_logs = init_logs + list(recent_logs)
+            if (strict_vulkan or device_mode in ("vulkan", "gpu")) and any("ggml_vulkan: No devices found" in l for l in all_critical_logs):
                 raise TermuxDiffusionError(
                     "Strict Vulkan execution mode requested (--strict-vulkan or device='vulkan'), but Vulkan physical device discovery failed: 'ggml_vulkan: No devices found'."
                 )
@@ -582,7 +658,7 @@ def generate(
         prompt=prompt,
         negative_prompt=negative_prompt,
         model=model,
-        device=device_mode,
+        device=effective_device,
         steps=steps,
         cfg_scale=cfg_scale,
         width=width,

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/termux_diffusion/downloader.py

@@ -8,63 +8,13 @@ import logging
 from pathlib import Path
 from typing import Optional
 
-from .exceptions import TermuxDiffusionError
+from .exceptions import DownloadError, InstallLockError, TermuxDiffusionError
+from .locking import InstallLock
 from .manifest import verify_file_sha256
 
 logger = logging.getLogger("termux_diffusion.downloader")
 
 
-class InstallLockError(TermuxDiffusionError):
-    """Raised when install lock cannot be acquired due to concurrent process."""
-    pass
-
-
-class DownloadError(TermuxDiffusionError):
-    """Raised when file download, size, or SHA-256 verification fails."""
-    pass
-
-
-class InstallLock:
-    """File lock manager to prevent concurrent installation processes."""
-    def __init__(self, lock_file: Path, timeout_sec: float = 5.0):
-        self.lock_file = lock_file
-        self.timeout_sec = timeout_sec
-        self._acquired = False
-
-    def acquire(self):
-        self.lock_file.parent.mkdir(parents=True, exist_ok=True)
-        start = time.time()
-        while time.time() - start < self.timeout_sec:
-            try:
-                # O_CREAT | O_EXCL atomic creation
-                fd = os.open(str(self.lock_file), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
-                os.write(fd, f"pid={os.getpid()}\n".encode("utf-8"))
-                os.close(fd)
-                self._acquired = True
-                return
-            except FileExistsError:
-                time.sleep(0.2)
-        raise InstallLockError(
-            f"E_CONCURRENCY_LOCK: Another installation process holds the lock file at {self.lock_file}. "
-            f"If stale, remove {self.lock_file} and retry."
-        )
-
-    def release(self):
-        if self._acquired and self.lock_file.exists():
-            try:
-                self.lock_file.unlink(missing_ok=True)
-            except Exception as e:
-                logger.warning("Failed deleting lock file: %s", e)
-            self._acquired = False
-
-    def __enter__(self):
-        self.acquire()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.release()
-
-
 def atomic_download_file(
     url: str,
     dest_path: Path,

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/termux_diffusion/exceptions.py

@@ -61,6 +61,12 @@ class ModelDownloadError(TermuxDiffusionError):
     pass
 
 
+class DownloadError(TermuxDiffusionError):
+    """Raised when file download, size, or SHA-256 verification fails."""
+    def __init__(self, message: str, code: str = ErrorCode.ARTIFACT_DOWNLOAD):
+        super().__init__(message, code=code)
+
+
 class ProvisioningError(TermuxDiffusionError):
     """Raised when the native C++ engine (sd-cli) fails to build or provision."""
     def __init__(self, message: str, code: str = ErrorCode.SOURCE_BUILD):

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/termux_diffusion/hardware.py

@@ -67,13 +67,18 @@ class HardwareProfile:
 # 1. CPU & GPU Feature Detection
 # ------------------------------------------------------------------------------
 
+# [중요] Vulkan ICD 탐색 순서: Android Bionic ICD 최우선.
+# Termux Mesa($PREFIX/lib/libvulkan.so)를 시스템 ICD보다 먼저 로드하면
+# Bionic linker 이중 dispatch 테이블 충돌로 SIGABRT 가 발생합니다.
+# ameva-vulkan-runtime 의 ICD 탐색 정책과 동일하게 유지합니다.
 _VULKAN_LIB_SEARCH_PATHS = [
-    os.path.join(os.environ.get("PREFIX", "/data/data/com.termux/files/usr"), "lib", "libvulkan.so"),
-    os.path.join(os.environ.get("PREFIX", "/data/data/com.termux/files/usr"), "lib64", "libvulkan.so"),
-    "/system/lib64/libvulkan.so",
+    "/system/lib64/libvulkan.so",   # Android Bionic ICD (최우선 — A35/S25/S21 모두 존재)
     "/system/lib/libvulkan.so",
     "/vendor/lib64/libvulkan.so",
     "/vendor/lib/libvulkan.so",
+    # Termux Mesa: 시스템 ICD 가 없는 순수 Linux/PRoot 환경 전용 fallback
+    os.path.join(os.environ.get("PREFIX", "/data/data/com.termux/files/usr"), "lib64", "libvulkan.so"),
+    os.path.join(os.environ.get("PREFIX", "/data/data/com.termux/files/usr"), "lib", "libvulkan.so"),
 ]
 
 _OPENCL_LIB_SEARCH_PATHS = [
@@ -87,6 +92,18 @@ _OPENCL_LIB_SEARCH_PATHS = [
 ]
 
 
+def _find_vulkan_driver_path() -> Optional[str]:
+    """Find the first genuinely accessible Vulkan driver library on the filesystem."""
+    for p in _VULKAN_LIB_SEARCH_PATHS:
+        p_obj = Path(p)
+        try:
+            if p_obj.is_file() and p_obj.stat().st_size >= 1024:
+                return str(p_obj.resolve())
+        except (OSError, PermissionError):
+            continue
+    return None
+
+
 def _read_cpuinfo_features() -> List[str]:
     """Parse /proc/cpuinfo to extract ARM CPU feature flags."""
     cpuinfo_path = Path("/proc/cpuinfo")
@@ -106,8 +123,13 @@ def _read_cpuinfo_features() -> List[str]:
         return []
 
 
+from .platform import is_android_termux
+
+
 def _detect_soc_name() -> str:
     """Identify the SoC model from Android system properties."""
+    if not is_android_termux():
+        return "Unknown"
     prop_keys = [
         "ro.soc.model",
         "ro.chipname",
@@ -132,8 +154,30 @@ def _detect_soc_name() -> str:
     return "Unknown"
 
 
+def _detect_device_model() -> str:
+    """Identify Android device model for hardware profile matching."""
+    if not is_android_termux():
+        return "Unknown"
+    for prop in ["ro.product.model", "ro.product.device", "ro.build.product"]:
+        try:
+            result = subprocess.run(
+                ["getprop", prop],
+                capture_output=True,
+                text=True,
+                timeout=2.0,
+            )
+            val = result.stdout.strip()
+            if val and val != "unknown":
+                return val
+        except Exception:
+            continue
+    return "Unknown"
+
+
 def _detect_gpu_name() -> str:
     """Identify the GPU model from Android properties and hardware nodes."""
+    if not is_android_termux():
+        return "Unknown"
     # 1. Check Adreno kgsl sysfs node
     kgsl_model = Path("/sys/class/kgsl/kgsl-3d0/gpu_model")
     if kgsl_model.exists():
@@ -166,33 +210,34 @@ def _detect_gpu_name() -> str:
 
 
 def _probe_vulkan_driver() -> Optional[GPUDriverInfo]:
-    """Probe for a usable Vulkan driver by checking library paths on disk."""
-    for lib_path in _VULKAN_LIB_SEARCH_PATHS:
-        p = Path(lib_path)
-        if p.is_file():
-            try:
-                size = p.stat().st_size
-                if size < 1024:
-                    continue
-                gpu_name = _detect_gpu_name()
-                return GPUDriverInfo(
-                    name=f"Vulkan Driver ({gpu_name})",
-                    vendor=gpu_name,
-                    api="Vulkan",
-                    library_path=lib_path,
-                    version="",
-                    usable=True,
-                )
-            except PermissionError as pe:
-                logger.warning(
-                    "Vulkan driver found at '%s' but access was denied (SELinux permission): %s",
-                    lib_path,
-                    pe,
-                )
-                continue
-            except OSError as oe:
-                logger.debug("Vulkan driver stat note on '%s': %s", lib_path, oe)
-                continue
+    """Probe for a usable Vulkan driver via ameva-vulkan-runtime SSOT."""
+    try:
+        import ameva_vulkan_runtime as avr
+        report = avr.Doctor().run_self_test(verbose=False)
+        if report.overall_success or report.recommended_backend in ("vulkan", "vulkan_driver_only") or getattr(report, "passed_stages", 0) >= 7:
+            return GPUDriverInfo(
+                name=f"Vulkan Driver ({report.device_name})",
+                vendor=report.device_name,
+                api=f"Vulkan {getattr(report, 'driver_version', '1.3')}",
+                library_path=getattr(report, "loader_path", "") or _find_vulkan_driver_path() or "/system/lib64/libvulkan.so",
+                version=getattr(report, "driver_version", ""),
+                usable=True,
+            )
+    except Exception as e:
+        logger.debug("[termux-diffusion] ameva-vulkan-runtime probe exception: %s", e)
+
+    # 안전 폴백: 시스템 기본 Bionic 경로 검사
+    detected_path = _find_vulkan_driver_path()
+    if detected_path and Path(detected_path).is_file():
+        gpu_name = _detect_gpu_name()
+        return GPUDriverInfo(
+            name=f"Vulkan Driver ({gpu_name})",
+            vendor=gpu_name,
+            api="Vulkan",
+            library_path=detected_path,
+            version="",
+            usable=True,
+        )
     return None
 
 
@@ -428,3 +473,100 @@ def format_hardware_report(profile: HardwareProfile) -> str:
         lines.append(f"CMake Build Flags: {' '.join(profile.cmake_extra_flags)}")
     lines.append("=" * 40)
     return "\n".join(lines)
+
+
+# ------------------------------------------------------------------------------
+# 4. Profile Gating Manager (Runtime Model/Preset Safety)
+# ------------------------------------------------------------------------------
+
+import json
+
+@dataclass
+class ProfileGatingManager:
+    """Manages runtime matching against validated-vulkan-profiles.json for safe device/model execution."""
+    profiles: List[Dict] = field(default_factory=list)
+
+    @classmethod
+    def load_from_json(cls, json_path: Optional[Path] = None) -> "ProfileGatingManager":
+        if json_path is None:
+            json_path = Path(__file__).parent / "data" / "validated-vulkan-profiles.json"
+        if json_path.is_file():
+            try:
+                data = json.loads(json_path.read_text(encoding="utf-8"))
+                return cls(profiles=data.get("profiles", []))
+            except Exception as e:
+                logger.warning("Failed to load validated-vulkan-profiles.json: %s", e)
+        return cls(profiles=[])
+
+    def find_matching_profile(self, model_name: str, soc_name: str = "", gpu_name: str = "") -> Optional[Dict]:
+        model_clean = model_name.strip().upper()
+        soc_clean = soc_name.strip().upper()
+        gpu_clean = gpu_name.strip().upper()
+
+        for prof in self.profiles:
+            target_model = prof.get("device_model", "").strip().upper()
+            if target_model and (target_model == model_clean or target_model in model_clean or model_clean in target_model):
+                return prof
+            aliases = [a.strip().upper() for a in prof.get("device_aliases", [])]
+            if any(a == model_clean or a in model_clean for a in aliases):
+                return prof
+
+        # Fallback matching by SoC / GPU
+        for prof in self.profiles:
+            prof_soc = prof.get("soc", "").strip().upper()
+            prof_gpu = prof.get("gpu", "").strip().upper()
+            if prof_soc and soc_clean and (prof_soc in soc_clean or soc_clean in prof_soc):
+                return prof
+            if prof_gpu and gpu_clean and (prof_gpu in gpu_clean or gpu_clean in prof_gpu):
+                return prof
+        return None
+
+    def validate_execution(self, preset_or_model: str, device: str) -> Tuple[bool, Optional[str]]:
+        """Validate if the requested model/preset and device backend are safe for current hardware."""
+        device_clean = device.lower().strip()
+        if device_clean not in ("vulkan", "gpu"):
+            return True, None
+
+        dev_model = _detect_device_model()
+        soc_name = _detect_soc_name()
+        gpu_name = _detect_gpu_name()
+        matched = self.find_matching_profile(dev_model, soc_name, gpu_name)
+        if not matched:
+            return True, None
+
+        # 1. Check blocked list
+        blocked = matched.get("blocked", [])
+        preset_clean = preset_or_model.lower().strip()
+        for blk in blocked:
+            fam = blk.get("model_family", "").lower()
+            backend = blk.get("backend", "").lower()
+            if backend in (device_clean, "all") and fam in preset_clean:
+                reason = blk.get("reason", "Incompatible hardware backend configuration")
+                return False, (
+                    f"Model '{preset_or_model}' is blocked on device '{matched.get('device_model')}' "
+                    f"under backend '{device_clean}' due to: {reason}."
+                )
+
+        # 2. Check preset gating if preset exists in profile
+        presets = matched.get("presets", {})
+        if preset_clean in presets:
+            p_info = presets[preset_clean]
+            if p_info.get("status") == "pending_device_validation" and not p_info.get("auto_activation", True):
+                return False, (
+                    f"Preset '{preset_clean}' is currently pending device validation on '{matched.get('device_model')}' "
+                    f"and auto_activation is disabled."
+                )
+
+        return True, None
+
+
+_gating_manager: Optional[ProfileGatingManager] = None
+
+
+def get_profile_gating_manager() -> ProfileGatingManager:
+    """Get singleton instance of ProfileGatingManager."""
+    global _gating_manager
+    if _gating_manager is None:
+        _gating_manager = ProfileGatingManager.load_from_json()
+    return _gating_manager
+

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/termux_diffusion/installer.py

@@ -85,32 +85,52 @@ def fetch_prebuilt_binary(backend: str = "auto", install_mode: str = "prebuilt-f
     lock_file = get_default_cache_dir() / "install.lock"
 
     with InstallLock(lock_file, timeout_sec=5.0):
-        # 1. Try Vulkan Prebuilt (Multi-SoC Aware: Adreno vs Mali)
+        # 1. Try Vulkan Prebuilt (Multi-SoC Aware: Adreno vs Mali via validated profiles)
         if backend in ("auto", "vulkan"):
             vulkan_bin = bin_dir / "sd-cli-vulkan"
             print("[termux-diffusion] Attempting Prebuilt Vulkan Engine installation...")
             try:
                 if not vulkan_bin.is_file():
-                    from .hardware import detect_hardware_profile
+                    from .hardware import detect_hardware_profile, get_profile_gating_manager, _detect_device_model
                     hw = detect_hardware_profile()
-                    is_mali = "mali" in hw.gpu_name.lower() or "exynos" in hw.soc_name.lower()
+                    gating_mgr = get_profile_gating_manager()
+                    dev_model = _detect_device_model()
+                    matched = gating_mgr.find_matching_profile(dev_model, hw.soc_name, hw.gpu_name)
                     
-                    if is_mali:
-                        # Galaxy S21 / S20 Mali Prebuilt
-                        pkg_url = "https://github.com/uno-km/termux-diffusion/releases/download/v1.3.1-vulkan-mali-experimental/termux-diffusion-vulkan-prebuilt-v1.3.1-android-arm64-mali-compat-v2.tar.gz"
-                        pkg_sha256 = "65e4e305241b22385313e386afbcd12722061041280d00a44dfdc3ff23aa17b8"
+                    if matched and matched.get("package_tarball") and matched.get("package_sha256"):
+                        pkg_tag = matched.get("package_tag", "v1.3.1-vulkan-experimental")
+                        pkg_tarball = matched.get("package_tarball")
+                        pkg_url = f"https://github.com/uno-km/termux-diffusion/releases/download/{pkg_tag}/{pkg_tarball}"
+                        pkg_sha256 = matched.get("package_sha256")
                     else:
-                        # Galaxy S25 / Snapdragon Adreno Prebuilt
-                        pkg_url = "https://github.com/uno-km/termux-diffusion/releases/download/v1.3.1-vulkan-experimental/termux-diffusion-vulkan-prebuilt-v1.3.1-android-arm64-adreno.tar.gz"
-                        pkg_sha256 = "d1f0a2656a33d0929cfd3335e01feeabf9c3a1e34a0ae0eacc04ddb3701ece92"
+                        is_mali = "mali" in hw.gpu_name.lower() or "exynos" in hw.soc_name.lower()
+                        if is_mali:
+                            pkg_url = "https://github.com/uno-km/termux-diffusion/releases/download/v1.3.1-vulkan-mali-experimental/termux-diffusion-vulkan-prebuilt-v1.3.1-android-arm64-mali-compat-v2.tar.gz"
+                            pkg_sha256 = "65e4e305241b22385313e386afbcd12722061041280d00a44dfdc3ff23aa17b8"
+                        else:
+                            pkg_url = "https://github.com/uno-km/termux-diffusion/releases/download/v1.3.1-vulkan-experimental/termux-diffusion-vulkan-prebuilt-v1.3.1-android-arm64-adreno.tar.gz"
+                            pkg_sha256 = "d1f0a2656a33d0929cfd3335e01feeabf9c3a1e34a0ae0eacc04ddb3701ece92"
 
                     tar_dest = bin_dir / "vulkan-prebuilt.tar.gz"
                     try:
                         atomic_download_file(pkg_url, tar_dest, expected_sha256=pkg_sha256)
                         import tarfile
+                        extract_target = get_default_cache_dir()
                         with tarfile.open(tar_dest, "r:gz") as tar:
-                            tar.extractall(path=get_default_cache_dir())
+                            # 경로 탈출(Directory Traversal) 방지 검증
+                            for member in tar.getmembers():
+                                member_path = os.path.realpath(
+                                    os.path.join(extract_target, member.name)
+                                )
+                                if not member_path.startswith(os.path.realpath(extract_target)):
+                                    raise ProvisioningError(
+                                        f"[termux-diffusion] E_TAR_PATH_ESCAPE: tarball 내 "
+                                        f"경로 탈출 시도가 감지되어 추출을 중단했습니다: {member.name}"
+                                    )
+                            tar.extractall(path=extract_target)
                         tar_dest.unlink(missing_ok=True)
+                    except ProvisioningError:
+                        raise
                     except Exception as dl_err:
                         logger.debug("Vulkan prebuilt download skipped/failed: %s", dl_err)
 
@@ -302,42 +322,15 @@ def provision_engine(
         except Exception as e:
             logger.warning("ggml-vulkan patch note: %s", e)
 
-    # Bionic Healer: Patch vulkan-shaders-gen.cpp for Android Termux
+    # Bionic Path Fix: Patch vulkan-shaders-gen.cpp for Android Termux temporary directory
     vulkan_gen = repo_dir / "ggml" / "src" / "ggml-vulkan" / "vulkan-shaders" / "vulkan-shaders-gen.cpp"
     if vulkan_gen.is_file():
         try:
             gen_content = vulkan_gen.read_text(encoding="utf-8")
             if 'output_dir = "/tmp"' in gen_content:
                 gen_content = gen_content.replace('output_dir = "/tmp"', 'output_dir = "."')
-            
-            old_err_block = (
-                "        int exit_code = execute_command(cmd, stdout_str, stderr_str);\n"
-                "        if (exit_code != 0 || !stderr_str.empty()) {\n"
-                '            std::cerr << "cannot compile " << name << " (exit code " << exit_code << ")\\n\\n";\n'
-                "            for (const auto& part : cmd) {\n"
-                '                std::cerr << part << " ";\n'
-                "            }\n"
-                '            std::cerr << "\\n\\n" << stderr_str << std::endl;\n'
-                "            compile_failed = true;\n"
-                "            return;\n"
-                "        }"
-            )
-            new_err_block = (
-                "        int exit_code = execute_command(cmd, stdout_str, stderr_str);\n"
-                "        if (exit_code != 0 || !stderr_str.empty()) {\n"
-                "            uint32_t dummy_spv[] = {0x07230203, 0x00010000, 0x00080001, 1, 0};\n"
-                "            std::ofstream f(out_path, std::ios::binary);\n"
-                "            f.write(reinterpret_cast<const char*>(dummy_spv), sizeof(dummy_spv));\n"
-                "            f.close();\n"
-                "            std::lock_guard<std::mutex> guard(lock);\n"
-                "            shader_fnames.push_back(std::make_pair(name, out_path));\n"
-                "            return;\n"
-                "        }"
-            )
-            if old_err_block in gen_content:
-                gen_content = gen_content.replace(old_err_block, new_err_block)
             vulkan_gen.write_text(gen_content, encoding="utf-8")
-            logger.info("Patched vulkan-shaders-gen.cpp with Universal Mobile GPU Healer.")
+            logger.info("Configured vulkan-shaders-gen.cpp for mobile working directory.")
         except Exception as e:
             logger.warning("vulkan-shaders-gen patch note: %s", e)
 

termux_diffusion-1.3.2/termux_diffusion/locking.py

@@ -0,0 +1,96 @@
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+
+from .exceptions import InstallLockError
+
+logger = logging.getLogger("termux_diffusion.locking")
+
+
+class InstallLock:
+    """File lock manager controlling full installer state machine execution with stale PID auto-recovery."""
+    def __init__(self, lock_file: Path, timeout_sec: float = 5.0):
+        self.lock_file = lock_file
+        self.timeout_sec = timeout_sec
+        self._acquired = False
+
+    def _is_pid_alive(self, pid: int) -> bool:
+        if pid <= 0:
+            return False
+        if sys.platform == "win32":
+            try:
+                import ctypes
+                PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+                h = ctypes.windll.kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
+                if h:
+                    ctypes.windll.kernel32.CloseHandle(h)
+                    return True
+                return False
+            except Exception:
+                return True
+        else:
+            try:
+                os.kill(pid, 0)
+                return True
+            except (OSError, ProcessLookupError):
+                return False
+
+    def _check_and_clear_stale_lock(self) -> bool:
+        """Check if existing lock file belongs to a deceased process, removing it if stale."""
+        if not self.lock_file.exists():
+            return True
+        try:
+            content = self.lock_file.read_text(encoding="utf-8")
+            for line in content.splitlines():
+                if line.startswith("pid="):
+                    pid_str = line.split("=", 1)[1].strip()
+                    if pid_str.isdigit():
+                        pid = int(pid_str)
+                        if not self._is_pid_alive(pid):
+                            logger.warning(
+                                "[termux-diffusion] Stale installation lock detected (PID: %d is dead). Auto-reclaiming lock.",
+                                pid,
+                            )
+                            self.lock_file.unlink(missing_ok=True)
+                            return True
+        except Exception as e:
+            logger.debug("Stale lock inspection note: %s", e)
+        return False
+
+    def acquire(self):
+        self.lock_file.parent.mkdir(parents=True, exist_ok=True)
+        self._check_and_clear_stale_lock()
+        start = time.time()
+        while time.time() - start < self.timeout_sec:
+            try:
+                fd = os.open(str(self.lock_file), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+                os.write(fd, f"pid={os.getpid()}\nstarted_at={time.time()}\n".encode("utf-8"))
+                os.close(fd)
+                self._acquired = True
+                return
+            except FileExistsError:
+                if self._check_and_clear_stale_lock():
+                    continue
+                time.sleep(0.2)
+        raise InstallLockError(
+            f"E_INSTALL_LOCKED: Installation process locked by another running process ({self.lock_file})."
+        )
+
+    def release(self):
+        if self._acquired and self.lock_file.exists():
+            try:
+                self.lock_file.unlink(missing_ok=True)
+            except Exception as e:
+                logger.warning("Failed removing install.lock: %s", e)
+            self._acquired = False
+
+    def __enter__(self):
+        self.acquire()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.release()
+

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/termux_diffusion/npu.py

@@ -8,8 +8,8 @@ for mobile NPU/TPU chipsets on Android Termux:
 - Android Standard Neural Networks API (NNAPI)
 
 Architectural Note:
-In v1.1.x, inference is driven by the native Bionic sd-cli engine using Vulkan GPU
-(-ngl 99) and ARM64 NEON CPU acceleration. Direct Qualcomm QNN / Hexagon NPU subgraph
+In v1.3+, inference is driven by the native Bionic sd-cli engine using Vulkan GPU
+(--backend vulkan0) and ARM64 NEON CPU acceleration. Direct Qualcomm QNN / Hexagon NPU subgraph
 partitioning is the architectural blueprint for the upcoming v2.0 runtime.
 """
 
@@ -228,8 +228,8 @@ def get_optimal_heterogeneous_pipeline(device: str = "auto") -> Dict[str, str]:
     """Determine the compute processor allocation for each diffusion pipeline component.
     
     Note:
-        In v1.1, diffusion inference is executed via the native Bionic sd-cli engine using
-        Vulkan GPU compute (-ngl 99) and ARM64 NEON CPU math. Direct Qualcomm QNN / Hexagon
+        In v1.3+, diffusion inference is executed via the native Bionic sd-cli engine using
+        Vulkan GPU compute (--backend vulkan0) and ARM64 NEON CPU math. Direct Qualcomm QNN / Hexagon
         NPU subgraph partitioning is the architectural target for the upcoming v2.0 runtime.
     """
     req = device.lower().strip()
@@ -245,7 +245,7 @@ def get_optimal_heterogeneous_pipeline(device: str = "auto") -> Dict[str, str]:
     else:
         return {
             "text_encoder": "CPU / GPU (ARM NEON / Vulkan)",
-            "denoiser_unet": "GPU (Vulkan Compute / -ngl 99)",
+            "denoiser_unet": "GPU (Vulkan Compute / --backend vulkan0)",
             "vae_decoder": "GPU (Vulkan Compute FP16)",
             "scheduler": "CPU (Single-Core Fast Math)",
             "summary": "GPU-Accelerated [Vulkan Compute Shader Pipeline]"

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/termux_diffusion/platform.py

@@ -19,8 +19,22 @@ TERMUX_PREFIX = os.environ.get("PREFIX", "/data/data/com.termux/files/usr")
 TERMUX_HOME = os.environ.get("HOME", "/data/data/com.termux/files/home")
 
 
+# [B방안] Platform SSOT: ameva-vulkan-runtime.platform 에서 공유 구현을 가져옵니다.
+try:
+    from ameva_vulkan_runtime.platform import is_termux as _ameva_is_termux
+    _AMEVA_PLATFORM_AVAILABLE = True
+except ImportError:
+    _AMEVA_PLATFORM_AVAILABLE = False
+
+
 def is_android_termux() -> bool:
-    """Check whether the current runtime environment is native Android Termux."""
+    """Check whether the current runtime environment is native Android Termux.
+
+    [B방안] ameva-vulkan-runtime.platform.is_termux() 를 SSOT 로 사용하며,
+    미설치 환경에서는 인라인 구현으로 안전하게 폴백합니다.
+    """
+    if _AMEVA_PLATFORM_AVAILABLE:
+        return _ameva_is_termux()
     if os.environ.get("TERMUX_VERSION") or os.environ.get("TERMUX_APP_PID"):
         return True
     if os.path.exists("/data/data/com.termux"):

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/termux_diffusion/selftest.py

@@ -113,24 +113,37 @@ def run_binary_self_test(
         return result
 
     # --------------------------------------------------------------------------
-    # Stage 2 & 3: Backend Probe & Compute Queue Test
+    # Stage 2 & 3: Backend Probe & Compute Queue Test (Real Hardware Probe)
     # --------------------------------------------------------------------------
     if expected_backend == "cpu":
-        # Pure CPU binary dependency check
         has_readelf, deps = check_dynamic_library_dependencies(binary_path)
         vulkan_deps = [d for d in deps if "libvulkan.so" in d or "libOpenCL.so" in d]
         if vulkan_deps:
             logger.warning("CPU binary has unwanted GPU library linkage: %s", vulkan_deps)
         result.stage2_probe_passed = True
         result.stage3_compute_passed = True
-        print("[termux-diffusion] Stage 1-3 Self-Test: CPU Baseline Binary validated successfully.")
         _SELF_TEST_CACHE[cache_key] = result
         return result
 
-    # Vulkan backend self-test
+    # [수정] Vulkan 백엔드 실측 검증: ameva-vulkan-runtime 연동
     print(f"[termux-diffusion] Stage 2 Self-Test: Vulkan runtime validation ({binary_path.name})...")
-    result.stage2_probe_passed = True
-    result.stage3_compute_passed = True
-    print("[termux-diffusion] Stage 1-3 Self-Test: Vulkan Backend validated successfully.")
+    try:
+        import ameva_vulkan_runtime as avr
+        doc = avr.Doctor()
+        if doc.quick_probe():
+            result.stage2_probe_passed = True
+            result.stage3_compute_passed = True
+            print(f"[termux-diffusion] Stage 1-3 Self-Test: Vulkan Backend ({doc.quick_probe_device() or 'GPU'}) validated.")
+        else:
+            result.stage2_probe_passed = False
+            result.stage3_compute_passed = False
+            result.error_code = "E_VULKAN_PROBE_FAILED"
+            result.error_message = "Vulkan ICD loader or hardware compute queue is unavailable on this device."
+    except Exception as exc:
+        result.stage2_probe_passed = False
+        result.stage3_compute_passed = False
+        result.error_code = "E_VULKAN_EXCEPTION"
+        result.error_message = f"Vulkan probe exception: {exc}"
+
     _SELF_TEST_CACHE[cache_key] = result
     return result

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2/termux_diffusion.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termux-diffusion
-Version: 1.3.1
+Version: 1.3.2
 Summary: Production On-Device AI Image Generation Framework for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)
 Home-page: https://github.com/uno-km/termux-diffusion
 Author: uno-km (AMEVA Foundation)
@@ -28,6 +28,7 @@ Classifier: Topic :: Multimedia :: Graphics
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: ameva-vulkan-runtime>=1.0.0
 Dynamic: author
 Dynamic: classifier
 Dynamic: home-page
@@ -75,7 +76,7 @@ termux-setup-storage
 
 # 2. Install Toolchains & Provision Native Engine
 pkg update -y && pkg install python clang make cmake git termux-api wget vulkan-loader vulkan-headers vulkan-tools -y
-pip install termux-diffusion && termux-diffusion-install
+pip install termux-diffusion && termux-diffusion install
 ```
 
 #### [Node.js] Node.js / TypeScript:
@@ -88,6 +89,11 @@ pkg update -y && pkg install nodejs-lts clang make cmake git termux-api wget vul
 npm install -g termux-diffusion && npx termux-diffusion install
 ```
 
+#### [Universal] One-Line Automated Bootstrap (curl):
+```bash
+curl -sL https://raw.githubusercontent.com/uno-km/termux-diffusion/main/scripts/install.sh | bash
+```
+
 ---
 
 ### [Instant] Scenario 2: Instant Generation (Ready to Run)
@@ -416,12 +422,9 @@ adb shell "/system/bin/device_config put activity_manager max_phantom_processes
 
 ---
 
-## 9. Disclaimer (면책 조항)
+## 9. Disclaimer
 
-> **Disclaimer:**  
-> *Termux-Diffusion is an independent open-source project developed for the Android Termux environment and is not officially affiliated with, endorsed by, or sponsored by the Termux project.*  
-> 
-> *(본 프로젝트는 안드로이드 Termux 환경을 위해 개발된 독립적인 오픈소스 라이브러리이며, Termux 공식 프로젝트와 직접적인 제휴 관계가 아닙니다.)*
+> *This project is an independent open-source library developed for the Android Termux environment. It is not officially affiliated with, endorsed by, or sponsored by the Termux project, stability.ai, or Google LLC.*
 
 ---
 

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/termux_diffusion.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ termux_diffusion.egg-info/PKG-INFO
 termux_diffusion.egg-info/SOURCES.txt
 termux_diffusion.egg-info/dependency_links.txt
 termux_diffusion.egg-info/entry_points.txt
+termux_diffusion.egg-info/requires.txt
 termux_diffusion.egg-info/top_level.txt
 termux_diffusion/data/bootstrap-manifest.json
 termux_diffusion/data/release-public-keys.json

termux_diffusion-1.3.2/termux_diffusion.egg-info/requires.txt

@@ -0,0 +1 @@
+ameva-vulkan-runtime>=1.0.0

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/tests/test_core.py

@@ -527,6 +527,7 @@ def test_strict_vulkan_failure_raises(tmp_path):
         ]
         mock_proc.returncode = 0
         mock_proc.wait = lambda timeout=None: 0
+        mock_proc.communicate.return_value = ("", "")
         return mock_proc
 
     with patch("termux_diffusion.hardware.resolve_device_backend", return_value=("vulkan", 99)), \

{termux_diffusion-1.3.1 → termux_diffusion-1.3.2}/tests/test_presets.py

@@ -109,3 +109,20 @@ def test_a53_mali_profile_and_preset_gating():
     assert "balanced" in a53_prof["presets"]
     assert a53_prof["presets"]["balanced"]["status"] == "pending_device_validation"
     assert a53_prof["presets"]["balanced"]["auto_activation"] is False
+
+
+def test_runtime_profile_gating_manager():
+    from termux_diffusion.hardware import get_profile_gating_manager
+    mgr = get_profile_gating_manager()
+    assert len(mgr.profiles) > 0
+
+    # 1. Matching Galaxy S25
+    s25_prof = mgr.find_matching_profile("SM-S931N")
+    assert s25_prof is not None
+    assert s25_prof["gpu"] == "Adreno (TM) 830"
+
+    # 2. Matching Galaxy A35 alias
+    a35_prof = mgr.find_matching_profile("a35x")
+    assert a35_prof is not None
+    assert a35_prof["gpu"] == "Mali-G68"
+

termux_diffusion-1.3.1/termux_diffusion/locking.py

@@ -1,50 +0,0 @@
-"""Process-wide installation lock manager for termux-diffusion."""
-
-import os
-import time
-import logging
-from pathlib import Path
-from typing import Optional
-
-from .exceptions import InstallLockError
-
-logger = logging.getLogger("termux_diffusion.locking")
-
-
-class InstallLock:
-    """File lock manager controlling full installer state machine execution."""
-    def __init__(self, lock_file: Path, timeout_sec: float = 5.0):
-        self.lock_file = lock_file
-        self.timeout_sec = timeout_sec
-        self._acquired = False
-
-    def acquire(self):
-        self.lock_file.parent.mkdir(parents=True, exist_ok=True)
-        start = time.time()
-        while time.time() - start < self.timeout_sec:
-            try:
-                fd = os.open(str(self.lock_file), os.O_CREAT | os.O_EXCL | os.O_WRONLY)
-                os.write(fd, f"pid={os.getpid()}\nstarted_at={time.time()}\n".encode("utf-8"))
-                os.close(fd)
-                self._acquired = True
-                return
-            except FileExistsError:
-                time.sleep(0.2)
-        raise InstallLockError(
-            f"E_INSTALL_LOCKED: Installation process locked by another running process ({self.lock_file})."
-        )
-
-    def release(self):
-        if self._acquired and self.lock_file.exists():
-            try:
-                self.lock_file.unlink(missing_ok=True)
-            except Exception as e:
-                logger.warning("Failed removing install.lock: %s", e)
-            self._acquired = False
-
-    def __enter__(self):
-        self.acquire()
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.release()