termux-diffusion 1.6.8__tar.gz → 1.7.0__tar.gz

{termux_diffusion-1.6.8/termux_diffusion.egg-info → termux_diffusion-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termux-diffusion
-Version: 1.6.8
+Version: 1.7.0
 Summary: Pure CPU On-Device Stable Diffusion Runtime for Android Termux (ARM64 Bionic NEON SIMD)
 Home-page: https://github.com/uno-km/termux-diffusion
 Author: uno-km (AMEVA Foundation)

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "termux-diffusion"
-version = "1.6.8"
+version = "1.7.0"
 description = "Pure CPU On-Device Stable Diffusion Runtime for Android Termux (ARM64 Bionic NEON SIMD)"
 readme = "README.pypi.md"
 requires-python = ">=3.8"

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0}/setup.py

@@ -11,7 +11,7 @@ if os.path.exists(readme_path):
 
 setup(
     name="termux-diffusion",
-    version="1.5.2",
+    version="1.6.9",
     description="On-device Stable Diffusion runtime utilizing device resources for Android Termux & Samsung Galaxy (Dual-Engine Python & Node.js)",
     long_description=long_description,
     long_description_content_type="text/markdown",

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0}/termux_diffusion/__init__.py

@@ -31,7 +31,15 @@ from .hub import (
     resolve_model_path,
     set_cache_dir,
 )
-from .installer import locate_sd_cli, provision_engine, run_doctor
+from .engine import (
+    DiffusionEngine,
+    DiffusionRuntime,
+    get_binary_path,
+    locate_sd_cli,
+    load,
+)
+from .doctor import run_doctor
+from .installer import provision_engine
 from .platform import (
     TermuxWakeLock,
     check_memory_safety,
@@ -78,6 +86,10 @@ __all__ = [
     "clear_cache",
     "list_presets",
     "DEFAULT_PRESETS",
+    "DiffusionEngine",
+    "DiffusionRuntime",
+    "load",
+    "get_binary_path",
     "locate_sd_cli",
     "provision_engine",
     "run_doctor",
@@ -103,20 +115,3 @@ __all__ = [
     "InferenceTimeoutError",
 ]
 
-
-
-class DiffusionEngine:
-    """Standardized Engine wrapper for termux-diffusion."""
-    def __init__(self, model: str = "default", device: str = "auto", **kwargs):
-        self.model = model
-        self.device = device
-        self.kwargs = kwargs
-
-    def generate(self, prompt: str, **kwargs):
-        merged = {**self.kwargs, **kwargs}
-        return generate(prompt, model=self.model, device=self.device, **merged)
-
-
-def load(model: str = "default", device: str = "auto", **kwargs) -> DiffusionEngine:
-    """Standard Unified Engine Factory for termux-diffusion."""
-    return DiffusionEngine(model=model, device=device, **kwargs)

termux_diffusion-1.7.0/termux_diffusion/_version.py

@@ -0,0 +1 @@
+__version__ = "1.7.0"

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0}/termux_diffusion/cli.py

@@ -20,7 +20,9 @@ if hasattr(sys.stderr, "reconfigure"):
 from .core import generate
 from .hub import clear_cache, download_model, list_cached_models, list_presets
 from .exceptions import TermuxDiffusionError, ErrorCode, ExitCode
-from .installer import provision_engine, run_doctor
+from .engine import DiffusionEngine, get_binary_path
+from .doctor import run_doctor
+from .installer import provision_engine
 
 
 def main(argv: Optional[List[str]] = None) -> int:

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0}/termux_diffusion/core.py

@@ -14,7 +14,8 @@ from typing import Optional, Union
 
 from .exceptions import InferenceTimeoutError, OOMRiskError, ProvisioningError, TermuxDiffusionError
 from .hub import DEFAULT_PRESETS, list_presets, resolve_model_path
-from .installer import locate_sd_cli, provision_engine
+from .engine import get_binary_path, locate_sd_cli
+from .installer import provision_engine
 from .platform import (
     TermuxWakeLock,
     check_memory_safety,
@@ -486,7 +487,7 @@ def generate(
 
     # 5.1 Configure Environment with companion library search paths (Termux native isolation)
     from .platform import get_clean_execution_env
-    env = get_clean_execution_env()
+    env = get_clean_execution_env(backend=effective_device)
     # Bypass debug CPU shadow checks on mobile Vulkan to unlock 10x throughput
     env.setdefault("GGML_VULKAN_SKIP_CHECKS", "999999999")
 
@@ -513,6 +514,14 @@ def generate(
 
             # Auto-inject mobile Vulkan HAL shim (Samsung GOS & BDA sanitizer) into process environment
             env = DiffusionAdapter.get_execution_env(env)
+            # Re-sanitize LD_LIBRARY_PATH to eliminate Termux /usr/lib symbol collisions on Android Bionic
+            cur_ld = env.get("LD_LIBRARY_PATH", "")
+            prefix_str = str(Path(os.environ.get("PREFIX", "/data/data/com.termux/files/usr")) / "lib")
+            parts = [p for p in cur_ld.split(":") if p and not p.startswith(prefix_str)]
+            if parts:
+                env["LD_LIBRARY_PATH"] = ":".join(parts)
+            else:
+                env.pop("LD_LIBRARY_PATH", None)
 
             logger.info(
                 "[termux-diffusion] DiffusionAdapter bound: backend=%s, status=%s, LD_PRELOAD=%s",

termux_diffusion-1.7.0/termux_diffusion/doctor.py

@@ -0,0 +1,120 @@
+"""
+termux_diffusion.doctor
+=======================
+Pre-flight diagnostics, hardware topology inspection, and system verification for termux-diffusion.
+"""
+
+import os
+import sys
+import shutil
+import logging
+from pathlib import Path
+from typing import Optional
+
+from .platform import (
+    is_android_termux,
+    is_arm64,
+    get_memory_info,
+    check_memory_safety,
+)
+
+logger = logging.getLogger("termux_diffusion.doctor")
+
+
+def run_doctor() -> bool:
+    """Run comprehensive 8-tier pre-flight diagnostic checks for Samsung Galaxy Termux setup."""
+    from .engine import get_binary_path
+
+    print("=" * 65)
+    print("[Doctor] [termux-diffusion] Pre-flight Diagnostic Doctor")
+    print("=" * 65)
+
+    all_passed = True
+
+    # 1. Platform Check
+    is_termux = is_android_termux()
+    arm_arch = is_arm64()
+    print(f"1. Platform: {'Android Termux [OK]' if is_termux else 'Non-Termux Host (Emulation Mode) [INFO]'}")
+    print(f"2. Architecture: {'ARM64 / aarch64 [OK]' if arm_arch else f'Host {sys.platform} ({os.name}) [INFO]'}")
+
+    # 3. Memory & RAM Plus
+    mem = get_memory_info()
+    safe, msg = check_memory_safety(required_mb=1200)
+    print(f"3. System Memory: {mem['mem_total_mb']}MB RAM + {mem['swap_total_mb']}MB Swap ({'Safe [OK]' if safe else 'Warning [WARN]'})")
+    if not safe:
+        print(f"   -> {msg}")
+
+    # 4. Storage & Samsung Gallery
+    storage_ok = os.path.exists(os.path.expanduser("~/storage"))
+    print(f"4. Android Storage Permission: {'Configured [OK]' if storage_ok else 'Missing [WARN] (Run termux-setup-storage)'}")
+
+    # 5. Compiler Toolchain
+    clang_ok = bool(shutil.which("clang") or shutil.which("gcc") or shutil.which("clang++"))
+    cmake_ok = bool(shutil.which("cmake"))
+    git_ok = bool(shutil.which("git"))
+    print(f"5. Build Tools: clang ({'[OK]' if clang_ok else '[FAIL]'}), cmake ({'[OK]' if cmake_ok else '[FAIL]'}), git ({'[OK]' if git_ok else '[FAIL]'})")
+    if not (clang_ok and cmake_ok and git_ok) and is_termux:
+        all_passed = False
+        print("   -> Run: pkg install clang cmake git termux-api -y")
+
+    # 6. Engine Binary
+    engine = get_binary_path()
+    print(f"6. Native C++ Engine (sd-cli): {str(engine) + ' [OK]' if engine else 'Not Provisioned [FAIL] (Run termux-diffusion install)'}")
+    if not engine:
+        all_passed = False
+
+    # 7. Model Cache Status
+    from .hub import list_cached_models
+    cached = list_cached_models()
+    print(f"7. Cached GGUF Models: {len(cached)} model(s) available locally.")
+    for m in cached:
+        valid_tag = " [GGUF Valid [OK]]" if m.get("is_valid_gguf") else " [Header [WARN]]"
+        print(f"   -> {m['name']} ({m['size_mb']} MB){valid_tag}")
+
+    # 8. Hardware Acceleration (GPU / NPU / TPU / Vulkan / OpenCL)
+    try:
+        from ameva_runtime.vulkan.adapters import find_system_vulkan_driver_dir
+        discovered_vulkan = find_system_vulkan_driver_dir()
+    except ImportError:
+        discovered_vulkan = None
+
+    from .hardware import detect_hardware_profile
+    hw = detect_hardware_profile()
+    print("8. Hardware Acceleration Profile:")
+    print(f"   SoC: {hw.soc_name}, GPU Architecture: {hw.gpu_name}")
+    print(f"   GPU Vulkan: {'Available [OK]' if (hw.vulkan_available or discovered_vulkan) else 'Not Found [WARN]'}")
+    if discovered_vulkan:
+        print(f"     -> Vulkan Driver (ameva-runtime): {discovered_vulkan}")
+    elif hw.vulkan_driver:
+        print(f"     -> Vulkan Driver: {hw.vulkan_driver.library_path}")
+    print(f"   GPU OpenCL: {'Available [OK]' if hw.opencl_available else 'Not Found [WARN]'}")
+    if hw.opencl_driver:
+        print(f"     -> OpenCL Driver: {hw.opencl_driver.library_path}")
+    if hw.npu_profile and hw.npu_profile.available:
+        print("   NPU / TPU Hardware: Detected [INFO]")
+        print(f"     -> Architecture: {hw.npu_profile.dsp_architecture} ({hw.npu_profile.tops_rating} TOPS)")
+        print(f"     -> Driver: {hw.npu_profile.driver_library}")
+        print("     -> Runtime: Native QNN C++ execution scheduled for v2.0")
+    else:
+        print("   NPU / TPU Hardware: Not Detected [INFO] (GPU Vulkan & CPU NEON Active)")
+    print(f"   CPU ISA SIMD: DotProd={'[OK]' if hw.has_dotprod else '[FAIL]'} "
+          f"FP16={'[OK]' if hw.has_fp16 else '[FAIL]'} "
+          f"I8MM={'[OK]' if hw.has_i8mm else '[FAIL]'} "
+          f"SVE={'[OK]' if hw.has_sve else '[FAIL]'}")
+    print(f"   Active Compute Pipeline: {hw.recommended_backend.value.upper()} "
+          f"(Offload Layers: {hw.recommended_ngl})")
+
+    # 9. Android 12+ Background Stability Guard (Phantom Process Killer)
+    if is_termux:
+        print("9. Android 12+ Background Guard:")
+        print("   -> Tip: If generation crashes when Termux is in background, enable")
+        print("          'Developer Options > Disable child process restrictions'")
+        print("          or run: adb shell \"/system/bin/device_config put activity_manager max_phantom_processes 2147483647\"")
+
+    print("=" * 65)
+    if all_passed:
+        print("All core diagnostics passed. System is ready for AI image generation.")
+    else:
+        print("Some diagnostics need attention. Run 'termux-diffusion install' to resolve.")
+    print("=" * 65)
+    return all_passed

termux_diffusion-1.7.0/termux_diffusion/engine.py

@@ -0,0 +1,162 @@
+"""
+termux_diffusion.engine
+=======================
+High-performance C++ core engine locator, backend dispatcher, and high-level DiffusionEngine wrapper.
+Strict Zero-Silent-Fallback and Anti-Deception compliant architecture matching AMEVA standards.
+"""
+
+import os
+import sys
+import shutil
+import logging
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from .platform import (
+    TERMUX_PREFIX,
+    is_android_termux,
+    get_default_cache_dir,
+)
+
+logger = logging.getLogger("termux_diffusion.engine")
+
+
+def get_engine_bin_dir() -> Path:
+    """Return canonical directory where termux-diffusion binaries reside ($PREFIX/bin SSOT)."""
+    prefix = os.environ.get("PREFIX") or TERMUX_PREFIX
+    if is_android_termux() or os.path.exists(prefix):
+        bin_dir = Path(prefix) / "bin"
+    else:
+        bin_dir = get_default_cache_dir() / "bin"
+    bin_dir.mkdir(parents=True, exist_ok=True)
+    return bin_dir
+
+
+def get_engine_lib_dir() -> Path:
+    """Return canonical directory where native shared libraries reside ($PREFIX/lib SSOT)."""
+    prefix = os.environ.get("PREFIX") or TERMUX_PREFIX
+    if is_android_termux() or os.path.exists(prefix):
+        lib_dir = Path(prefix) / "lib"
+    else:
+        lib_dir = get_default_cache_dir() / "lib"
+    lib_dir.mkdir(parents=True, exist_ok=True)
+    return lib_dir
+
+
+def get_binary_path(backend: str = "auto") -> Optional[Path]:
+    """Find authoritative absolute path of sd-cli executable strictly isolated by compute backend.
+    
+    Zero-Silent-Fallback Rules:
+    - 'gpu' / 'vulkan': Exclusively search for native Vulkan binary (sd-cli-vulkan).
+                        Never fallback to CPU binary. Return None if unprovisioned.
+    - 'cpu' / default:  Exclusively search for pure CPU NEON binary (sd-cli-cpu, sd-cli).
+    """
+    home = Path(os.environ.get("HOME", os.path.expanduser("~")))
+    prefix_bin = Path(TERMUX_PREFIX) / "bin"
+    bin_dir = get_engine_bin_dir()
+    ameva_diff_dir = home / ".local" / "share" / "ameva" / "current" / "diffusion"
+
+    req_backend = str(backend or "auto").strip().lower()
+
+    # --------------------------------------------------------------------------
+    # 1. GPU / Vulkan Route: Pure Vulkan GPU Binary (sd-cli-vulkan)
+    # --------------------------------------------------------------------------
+    if req_backend in ("vulkan", "gpu"):
+        vulkan_candidates = [
+            # AMEVA 2-Tier isolated current deployment
+            ameva_diff_dir / "sd-cli-vulkan",
+            # Termux prefix binary
+            prefix_bin / "sd-cli-vulkan",
+            bin_dir / "sd-cli-vulkan",
+            # User local binary
+            home / ".local" / "bin" / "sd-cli-vulkan",
+        ]
+        for p in vulkan_candidates:
+            if p.is_file() and (os.access(p, os.X_OK) or os.name == "nt"):
+                return p.resolve()
+
+        # System PATH search strictly for 'sd-cli-vulkan'
+        which_vk = shutil.which("sd-cli-vulkan")
+        if which_vk and (os.access(which_vk, os.X_OK) or os.name == "nt"):
+            return Path(which_vk).resolve()
+
+        # Zero-Silent-Fallback: If Vulkan binary is absent, NEVER return CPU binary!
+        return None
+
+    # --------------------------------------------------------------------------
+    # 2. CPU Baseline Route: Pure CPU NEON Binary (sd-cli-cpu, sd-cli)
+    # --------------------------------------------------------------------------
+    cpu_candidates = [
+        bin_dir / "sd-cli-cpu",
+        prefix_bin / "sd-cli-cpu",
+        bin_dir / "sd-cli-source-cpu",
+        bin_dir / "sd-cli",
+        prefix_bin / "sd-cli",
+        home / ".local" / "bin" / "sd-cli-cpu",
+        home / ".local" / "bin" / "sd-cli",
+    ]
+    for p in cpu_candidates:
+        if p.is_file() and (os.access(p, os.X_OK) or os.name == "nt"):
+            return p.resolve()
+
+    # System PATH search for CPU binary
+    for name in ("sd-cli", "sd-cli.exe", "sd", "sd.exe"):
+        which_path = shutil.which(name)
+        if which_path and (os.access(which_path, os.X_OK) or os.name == "nt"):
+            return Path(which_path).resolve()
+
+    return None
+
+
+def locate_sd_cli(backend: Optional[str] = None) -> Optional[Path]:
+    """Backward-compatible alias for get_binary_path."""
+    return get_binary_path(backend=backend or "auto")
+
+
+class DiffusionEngine:
+    """High-level Python SDK Engine for On-Device Stable Diffusion inference.
+    Follows canonical AMEVA component architecture matching LlamaRuntime and BitNetEngine.
+    """
+
+    def __init__(
+        self,
+        model: str = "realistic",
+        backend: str = "auto",
+        device: Optional[str] = None,
+        **kwargs: Any,
+    ):
+        self.model = model
+        self.device = device or backend or "auto"
+        self.requested_backend = self.device.strip().lower()
+        self.bin_dir = get_engine_bin_dir()
+        self.lib_dir = get_engine_lib_dir()
+        self.kwargs = kwargs
+
+    def get_binary_path(self, backend: Optional[str] = None) -> Optional[Path]:
+        """Resolve authoritative binary path for active or specified backend."""
+        target_backend = backend if backend is not None else self.requested_backend
+        return get_binary_path(backend=target_backend)
+
+    def generate(self, prompt: str, **kwargs: Any) -> Any:
+        """Execute text-to-image generation delegating to core pipeline."""
+        from .core import generate
+        merged = {**self.kwargs, **kwargs}
+        merged.setdefault("device", self.requested_backend)
+        merged.setdefault("model", self.model)
+        return generate(prompt=prompt, **merged)
+
+    @staticmethod
+    def doctor() -> bool:
+        """Run comprehensive pre-flight diagnostic checks."""
+        from .doctor import run_doctor
+        return run_doctor()
+
+
+def load(model: str = "realistic", device: str = "auto", **kwargs: Any) -> DiffusionEngine:
+    """Standard Unified Engine Factory for termux-diffusion matching AMEVA multi-modal standards."""
+    return DiffusionEngine(model=model, device=device, **kwargs)
+
+
+# Backward-compatible alias matching LlamaRuntime
+DiffusionRuntime = DiffusionEngine
+

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0}/termux_diffusion/hub.py

@@ -114,6 +114,53 @@ DEFAULT_PRESETS = MappingProxyType({
         "default_steps": 20,
         "default_cfg": 6.0,
     },
+    "counterfeit-v3-lcm": {
+        "repo_id": "mzwing/Anything-LCM-GGUF",
+        "filename": "anything_v30-LCM.q4_0.gguf",
+        "alias": "counterfeit-v3-lcm.gguf",
+        "description": "Counterfeit / Anime LCM (Q4_0) - High-quality 4~6 step Anime & Illustration generation",
+        "size_mb": 1566,
+        "default_steps": 6,
+        "default_cfg": 1.5,
+        "default_sampler": "lcm",
+    },
+    "anything-v5-lcm": {
+        "repo_id": "mzwing/Anything-LCM-GGUF",
+        "filename": "anything_v30-LCM.q4_0.gguf",
+        "alias": "anything-v5-lcm.gguf",
+        "description": "Anything V5 / V3 LCM (Q4_0) - 4~6 step Stylized Anime art",
+        "size_mb": 1566,
+        "default_steps": 6,
+        "default_cfg": 1.5,
+        "default_sampler": "lcm",
+    },
+    "ghostmix-lcm": {
+        "repo_id": "void-gryph/ghostmix-GGUF",
+        "filename": "ghostmix.Q4_K_M.gguf",
+        "alias": "ghostmix.gguf",
+        "description": "GhostMix (Q4_K_M) - 2.5D Semi-realistic Anime illustration",
+        "size_mb": 484,
+        "default_steps": 15,
+        "default_cfg": 6.0,
+    },
+    "cyberrealistic-lcm": {
+        "repo_id": "void-gryph/cyberrealistic-GGUF",
+        "filename": "cyberrealistic.Q4_K_M.gguf",
+        "alias": "cyberrealistic.gguf",
+        "description": "CyberRealistic (Q4_K_M) - High-detail photorealistic portraits",
+        "size_mb": 484,
+        "default_steps": 15,
+        "default_cfg": 6.0,
+    },
+    "bk-sdm-tiny": {
+        "repo_id": "concedo/sdxs-512-tinySDdistilled-GGUF",
+        "filename": "sdxs-512-tinySDdistilled_Q8_0.gguf",
+        "alias": "sdxs.gguf",
+        "description": "BK-SDM Tiny Fallback (SDXS Distilled Q8_0) - Ultra-lightweight on-device diffusion",
+        "size_mb": 651,
+        "default_steps": 1,
+        "default_cfg": 1.0,
+    },
 })
 
 _registry_lock = threading.Lock()

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0}/termux_diffusion/installer.py

@@ -33,6 +33,13 @@ from .platform import (
     is_arm64,
 )
 
+from .engine import (
+    get_engine_bin_dir,
+    get_engine_lib_dir,
+    get_binary_path,
+    locate_sd_cli,
+)
+
 from ._version import __version__
 
 logger = logging.getLogger("termux_diffusion.installer")
@@ -60,11 +67,11 @@ def get_candidate_prebuilt_urls(filename: str = "sd-cli-cpu-android-arm64.tar.gz
     urls: List[str] = []
     if custom_base := os.environ.get("TERMUX_DIFFUSION_RELEASE_BASE") or os.environ.get("AMEVA_RELEASE_BASE"):
         urls.append(f"{custom_base.rstrip('/')}/{filename}")
-    if custom_tag := os.environ.get("TERMUX_DIFFUSION_RELEASE_TAG") or os.environ.get("AMEVA_RELEASE_TAG"):
-        tag = custom_tag if custom_tag.startswith("v") else f"v{custom_tag}"
-        urls.append(f"https://github.com/uno-km/termux-diffusion/releases/download/{tag}/{filename}")
-    urls.append(f"https://github.com/uno-km/termux-diffusion/releases/download/v{__version__}/{filename}")
+    # Tier 2: GitHub Releases latest canonical endpoint (Zero-Hardcoding SSOT)
     urls.append(f"{TERMUX_DIFFUSION_RELEASE_LATEST}/{filename}")
+
+    # Tier 3: Installed package dynamic version matching
+    urls.append(f"https://github.com/uno-km/termux-diffusion/releases/download/v{__version__}/{filename}")
     return urls
 
 
@@ -79,7 +86,8 @@ def activate_binary(bin_dir: Path, target_name: str) -> Path:
     allowed = {
         "sd-cli-cpu",
         "sd-cli-source-cpu",
-        "sd-cli"
+        "sd-cli",
+        "sd-cli-vulkan",
     }
     if target_name not in allowed:
         raise ValueError(f"Unauthorized activation target: {target_name}")
@@ -201,59 +209,6 @@ def fetch_prebuilt_binary(install_mode: str = "prebuilt-first") -> Optional[Path
     return None
 
 
-def get_engine_bin_dir() -> Path:
-    """Return directory where compiled termux-diffusion binaries reside ($PREFIX/bin SSOT)."""
-    prefix = os.environ.get("PREFIX") or "/data/data/com.termux/files/usr"
-    if is_android_termux() or os.path.exists(prefix):
-        bin_dir = Path(prefix) / "bin"
-    else:
-        bin_dir = get_default_cache_dir() / "bin"
-    bin_dir.mkdir(parents=True, exist_ok=True)
-    return bin_dir
-
-
-def get_engine_lib_dir() -> Path:
-    """Return directory where native shared libraries reside ($PREFIX/lib SSOT)."""
-    prefix = os.environ.get("PREFIX") or "/data/data/com.termux/files/usr"
-    if is_android_termux() or os.path.exists(prefix):
-        lib_dir = Path(prefix) / "lib"
-    else:
-        lib_dir = get_default_cache_dir() / "lib"
-    lib_dir.mkdir(parents=True, exist_ok=True)
-    return lib_dir
-
-
-def locate_sd_cli(backend: Optional[str] = None) -> Optional[Path]:
-    """Locate the compiled sd-cli executable binary across standard locations."""
-    bin_dir = get_engine_bin_dir()
-    candidates = ("sd-cli-cpu", "sd-cli-source-cpu", "sd-cli", "sd-cli.exe", "sd", "sd.exe")
-
-    for fname in candidates:
-        cached_bin = bin_dir / fname
-        if cached_bin.is_file() and (os.access(cached_bin, os.X_OK) or os.name == "nt"):
-            return cached_bin.resolve()
-
-    # 2. System PATH
-    for name in ("sd-cli", "sd-cli.exe", "sd", "sd.exe"):
-        which_path = shutil.which(name)
-        if which_path and (os.access(which_path, os.X_OK) or os.name == "nt"):
-            return Path(which_path).resolve()
-
-    # 3. Termux prefix bin
-    for name in ("sd-cli", "sd"):
-        termux_bin = Path(TERMUX_PREFIX) / "bin" / name
-        if termux_bin.is_file() and (os.access(termux_bin, os.X_OK) or os.name == "nt"):
-            return termux_bin.resolve()
-
-    # 4. Standard user local binary paths
-    for name in ("sd-cli", "sd-cli.exe"):
-        local_bin = Path(os.path.expanduser(f"~/.local/bin/{name}"))
-        if local_bin.is_file() and (os.access(local_bin, os.X_OK) or os.name == "nt"):
-            return local_bin.resolve()
-
-    return None
-
-
 def provision_engine(
     force: bool = False,
     install_mode: str = "prebuilt-first",
@@ -474,98 +429,6 @@ def provision_engine(
     return target_bin.resolve()
 
 
-def run_doctor() -> bool:
-    """Run comprehensive 8-tier pre-flight diagnostic checks for Samsung Galaxy Termux setup."""
-    print("=" * 65)
-    print("[Doctor] [termux-diffusion] Pre-flight Diagnostic Doctor")
-    print("=" * 65)
-
-    all_passed = True
-
-    # 1. Platform Check
-    is_termux = is_android_termux()
-    arm_arch = is_arm64()
-    print(f"1. Platform: {'Android Termux [OK]' if is_termux else 'Non-Termux Host (Emulation Mode) [INFO]'}")
-    print(f"2. Architecture: {'ARM64 / aarch64 [OK]' if arm_arch else f'Host {sys.platform} ({os.name}) [INFO]'}")
-
-    # 3. Memory & RAM Plus
-    mem = get_memory_info()
-    safe, msg = check_memory_safety(required_mb=1200)
-    print(f"3. System Memory: {mem['mem_total_mb']}MB RAM + {mem['swap_total_mb']}MB Swap ({'Safe [OK]' if safe else 'Warning [WARN]'})")
-    if not safe:
-        print(f"   -> {msg}")
-
-    # 4. Storage & Samsung Gallery
-    storage_ok = os.path.exists(os.path.expanduser("~/storage"))
-    print(f"4. Android Storage Permission: {'Configured [OK]' if storage_ok else 'Missing [WARN] (Run termux-setup-storage)'}")
-
-    # 5. Compiler Toolchain
-    clang_ok = bool(shutil.which("clang") or shutil.which("gcc") or shutil.which("clang++"))
-    cmake_ok = bool(shutil.which("cmake"))
-    git_ok = bool(shutil.which("git"))
-    print(f"5. Build Tools: clang ({'[OK]' if clang_ok else '[FAIL]'}), cmake ({'[OK]' if cmake_ok else '[FAIL]'}), git ({'[OK]' if git_ok else '[FAIL]'})")
-    if not (clang_ok and cmake_ok and git_ok) and is_termux:
-        all_passed = False
-        print("   -> Run: pkg install clang cmake git termux-api -y")
-
-    # 6. Engine Binary
-    engine = locate_sd_cli()
-    print(f"6. Native C++ Engine (sd-cli): {str(engine) + ' [OK]' if engine else 'Not Provisioned [FAIL] (Run termux-diffusion-install)'}")
-    if not engine:
-        all_passed = False
-
-    # 7. Model Cache Status
-    from .hub import list_cached_models
-    cached = list_cached_models()
-    print(f"7. Cached GGUF Models: {len(cached)} model(s) available locally.")
-    for m in cached:
-        valid_tag = " [GGUF Valid [OK]]" if m.get("is_valid_gguf") else " [Header [WARN]]"
-        print(f"   -> {m['name']} ({m['size_mb']} MB){valid_tag}")
-
-    # 8. Hardware Acceleration (GPU / NPU / TPU / Vulkan / OpenCL)
-    try:
-        from ameva_runtime.vulkan.adapters import find_system_vulkan_driver_dir, DiffusionAdapter
-        discovered_vulkan = find_system_vulkan_driver_dir()
-    except ImportError:
-        discovered_vulkan = None
-
-    from .hardware import detect_hardware_profile, format_hardware_report
-    hw = detect_hardware_profile()
-    print(f"8. Hardware Acceleration Profile:")
-    print(f"   SoC: {hw.soc_name}, GPU Architecture: {hw.gpu_name}")
-    print(f"   GPU Vulkan: {'Available [OK]' if (hw.vulkan_available or discovered_vulkan) else 'Not Found [WARN]'}")
-    if discovered_vulkan:
-        print(f"     -> Vulkan Driver (ameva-runtime): {discovered_vulkan}")
-    elif hw.vulkan_driver:
-        print(f"     -> Vulkan Driver: {hw.vulkan_driver.library_path}")
-    print(f"   GPU OpenCL: {'Available [OK]' if hw.opencl_available else 'Not Found [WARN]'}")
-    if hw.opencl_driver:
-        print(f"     -> OpenCL Driver: {hw.opencl_driver.library_path}")
-    if hw.npu_profile and hw.npu_profile.available:
-        print(f"   NPU / TPU Hardware: Detected [INFO]")
-        print(f"     -> Architecture: {hw.npu_profile.dsp_architecture} ({hw.npu_profile.tops_rating} TOPS)")
-        print(f"     -> Driver: {hw.npu_profile.driver_library}")
-        print(f"     -> Runtime: Native QNN C++ execution scheduled for v2.0")
-    else:
-        print(f"   NPU / TPU Hardware: Not Detected [INFO] (GPU Vulkan & CPU NEON Active)")
-    print(f"   CPU ISA SIMD: DotProd={'[OK]' if hw.has_dotprod else '[FAIL]'} "
-          f"FP16={'[OK]' if hw.has_fp16 else '[FAIL]'} "
-          f"I8MM={'[OK]' if hw.has_i8mm else '[FAIL]'} "
-          f"SVE={'[OK]' if hw.has_sve else '[FAIL]'}")
-    print(f"   Active Compute Pipeline: {hw.recommended_backend.value.upper()} "
-          f"(Offload Layers: {hw.recommended_ngl})")
-
-    # 9. Android 12+ Background Stability Guard (Phantom Process Killer)
-    if is_termux:
-        print("9. Android 12+ Background Guard:")
-        print("   -> Tip: If generation crashes when Termux is in background, enable")
-        print("          'Developer Options > Disable child process restrictions'")
-        print("          or run: adb shell \"/system/bin/device_config put activity_manager max_phantom_processes 2147483647\"")
-
-    print("=" * 65)
-    if all_passed:
-        print("All core diagnostics passed. System is ready for AI image generation.")
-    else:
-        print("Some diagnostics need attention. Run 'termux-diffusion-install' to resolve.")
-    print("=" * 65)
-    return all_passed
+# Re-export diagnostic utilities from .doctor for backward compatibility
+from .doctor import run_doctor
+

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0}/termux_diffusion/platform.py

@@ -19,11 +19,19 @@ TERMUX_PREFIX = os.environ.get("PREFIX") or "/data/data/com.termux/files/usr"
 TERMUX_HOME = os.environ.get("HOME") or "/data/data/com.termux/files/home"
 
 
-def get_clean_execution_env(base_env: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+def get_clean_execution_env(
+    base_env: Optional[Dict[str, str]] = None,
+    backend: str = "cpu",
+) -> Dict[str, str]:
     """Construct clean execution environment for Termux binaries with proper library search paths.
 
     Guarantees $PREFIX, $PREFIX/lib, and companion directories are correctly populated
     while preventing Android system library collision (/system/, /vendor/, etc.).
+
+    Zero-Collision Rule:
+    For native Bionic Vulkan binaries (backend in ('vulkan', 'gpu')), Termux $PREFIX/lib is
+    strictly excluded from LD_LIBRARY_PATH to eliminate symbol collisions with Android Bionic
+    system libraries (/system/lib64/libunwindstack.so, etc.).
     """
     env = (base_env or os.environ).copy()
     prefix = os.environ.get("PREFIX") or "/data/data/com.termux/files/usr"
@@ -36,16 +44,28 @@ def get_clean_execution_env(base_env: Optional[Dict[str, str]] = None) -> Dict[s
     if bin_dir not in cur_path.split(":"):
         env["PATH"] = f"{bin_dir}:{cur_path}" if cur_path else bin_dir
 
+    req_backend = str(backend or "cpu").strip().lower()
+    is_vulkan_route = req_backend in ("vulkan", "gpu")
+
     forbidden_prefixes = ("/system/", "/vendor/", "/apex/", "/system_ext/", "/odm/", "/product/")
     cur_ld = env.get("LD_LIBRARY_PATH", "")
     existing_parts = [p for p in cur_ld.split(":") if p and not any(p.startswith(fp) for fp in forbidden_prefixes)]
 
-    lib_candidates = [
-        str(Path(prefix) / "lib"),
-        str(Path.home() / ".cache" / "termux-diffusion" / "lib"),
-        str(Path.home() / ".cache" / "termux-diffusion" / "staging" / "lib"),
-        str(Path.home() / ".local" / "lib"),
-    ]
+    if is_vulkan_route:
+        # Strictly isolate Vulkan binaries from Termux /usr/lib to prevent libc++ ABI crash
+        lib_candidates = [
+            str(Path.home() / ".local" / "share" / "ameva" / "current" / "diffusion"),
+            str(Path.home() / ".cache" / "termux-diffusion" / "lib"),
+        ]
+        # Filter out prefix/lib from existing parts for Vulkan
+        existing_parts = [p for p in existing_parts if not p.startswith(str(Path(prefix) / "lib"))]
+    else:
+        lib_candidates = [
+            str(Path(prefix) / "lib"),
+            str(Path.home() / ".cache" / "termux-diffusion" / "lib"),
+            str(Path.home() / ".cache" / "termux-diffusion" / "staging" / "lib"),
+            str(Path.home() / ".local" / "lib"),
+        ]
 
     merged: List[str] = []
     for d in lib_candidates + existing_parts:
@@ -54,6 +74,8 @@ def get_clean_execution_env(base_env: Optional[Dict[str, str]] = None) -> Dict[s
 
     if merged:
         env["LD_LIBRARY_PATH"] = ":".join(merged)
+    elif is_vulkan_route and "LD_LIBRARY_PATH" in env:
+        env.pop("LD_LIBRARY_PATH", None)
 
     # Detect libegl_shim.so for Android Mali/Samsung GOS Vulkan HAL compatibility
     shim_candidates = [

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0}/termux_diffusion/selftest.py

@@ -72,7 +72,7 @@ def run_binary_self_test(
 
     # Build environment with clean Termux companion library search paths
     from .platform import get_clean_execution_env
-    env = get_clean_execution_env()
+    env = get_clean_execution_env(backend=expected_backend)
 
     # --------------------------------------------------------------------------
     # Stage 1: Load Test (sd-cli --help)

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0/termux_diffusion.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termux-diffusion
-Version: 1.6.8
+Version: 1.7.0
 Summary: Pure CPU On-Device Stable Diffusion Runtime for Android Termux (ARM64 Bionic NEON SIMD)
 Home-page: https://github.com/uno-km/termux-diffusion
 Author: uno-km (AMEVA Foundation)

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0}/termux_diffusion.egg-info/SOURCES.txt

@@ -9,7 +9,9 @@ termux_diffusion/_version.py
 termux_diffusion/adapter.py
 termux_diffusion/cli.py
 termux_diffusion/core.py
+termux_diffusion/doctor.py
 termux_diffusion/downloader.py
+termux_diffusion/engine.py
 termux_diffusion/exceptions.py
 termux_diffusion/hardware.py
 termux_diffusion/hub.py
@@ -33,6 +35,8 @@ termux_diffusion/data/bootstrap-manifest.json
 termux_diffusion/data/release-public-keys.json
 termux_diffusion/data/validated-vulkan-profiles.json
 tests/test_core.py
+tests/test_doctor.py
+tests/test_engine.py
 tests/test_hardware.py
 tests/test_hub.py
 tests/test_installer.py

termux_diffusion-1.7.0/tests/test_doctor.py

@@ -0,0 +1,13 @@
+"""Unit tests for pre-flight doctor diagnostics in termux-diffusion."""
+
+from unittest.mock import patch
+from termux_diffusion.doctor import run_doctor
+
+
+def test_doctor_execution(capsys):
+    res = run_doctor()
+    captured = capsys.readouterr()
+    assert "Pre-flight Diagnostic Doctor" in captured.out
+    assert "Platform:" in captured.out
+    assert "Native C++ Engine" in captured.out
+    assert isinstance(res, bool)

termux_diffusion-1.7.0/tests/test_engine.py

@@ -0,0 +1,98 @@
+"""Unit tests for DiffusionEngine, backend-specific binary locator, and Zero-Silent-Fallback rules."""
+
+import os
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+import pytest
+
+from termux_diffusion.engine import (
+    DiffusionEngine,
+    DiffusionRuntime,
+    get_binary_path,
+    locate_sd_cli,
+    get_engine_bin_dir,
+    get_engine_lib_dir,
+    load,
+)
+
+
+def test_engine_directories():
+    bin_dir = get_engine_bin_dir()
+    lib_dir = get_engine_lib_dir()
+    assert isinstance(bin_dir, Path)
+    assert isinstance(lib_dir, Path)
+    assert bin_dir.is_dir()
+    assert lib_dir.is_dir()
+
+
+def test_get_binary_path_cpu_returns_path_or_none():
+    res = get_binary_path(backend="cpu")
+    assert res is None or isinstance(res, Path)
+
+
+def test_zero_silent_fallback_vulkan_never_returns_cpu_binary(tmp_path):
+    """Zero-Silent-Fallback Core Test:
+    When backend is 'vulkan' or 'gpu', but only CPU binary (sd-cli) exists,
+    get_binary_path MUST return None and NEVER fall back to the CPU binary."""
+    mock_bin_dir = tmp_path / "bin"
+    mock_bin_dir.mkdir(parents=True)
+    cpu_bin = mock_bin_dir / "sd-cli"
+    cpu_bin.touch(mode=0o755)
+
+    with patch("termux_diffusion.engine.get_engine_bin_dir", return_value=mock_bin_dir), \
+         patch("shutil.which", return_value=None):
+        vk_result = get_binary_path(backend="vulkan")
+        assert vk_result is None, "Vulkan backend must return None when sd-cli-vulkan is missing, never fallback to sd-cli"
+
+        gpu_result = get_binary_path(backend="gpu")
+        assert gpu_result is None, "GPU backend must return None when sd-cli-vulkan is missing"
+
+
+def test_vulkan_binary_located_when_present(tmp_path):
+    """Verify that when sd-cli-vulkan is present, it is resolved correctly."""
+    mock_bin_dir = tmp_path / "bin"
+    mock_bin_dir.mkdir(parents=True)
+    vk_bin = mock_bin_dir / "sd-cli-vulkan"
+    vk_bin.touch(mode=0o755)
+
+    with patch("termux_diffusion.engine.get_engine_bin_dir", return_value=mock_bin_dir), \
+         patch("termux_diffusion.engine.TERMUX_PREFIX", str(tmp_path)):
+        res = get_binary_path(backend="vulkan")
+        assert res is not None
+        assert res.name == "sd-cli-vulkan"
+
+
+def test_locate_sd_cli_backward_compatibility():
+    res = locate_sd_cli("cpu")
+    assert res is None or isinstance(res, Path)
+
+
+def test_diffusion_engine_initialization_and_methods():
+    engine = DiffusionEngine(model="realistic", device="cpu", width=256, height=256)
+    assert engine.model == "realistic"
+    assert engine.device == "cpu"
+    assert engine.requested_backend == "cpu"
+    assert engine.kwargs == {"width": 256, "height": 256}
+
+    # Factory function load()
+    loaded_engine = load(model="anime", device="vulkan")
+    assert isinstance(loaded_engine, DiffusionEngine)
+    assert loaded_engine.model == "anime"
+    assert loaded_engine.device == "vulkan"
+
+    # Alias DiffusionRuntime
+    assert DiffusionRuntime is DiffusionEngine
+
+
+def test_diffusion_engine_generate_delegation():
+    engine = DiffusionEngine(model="sdxs", device="cpu")
+    with patch("termux_diffusion.core.generate") as mock_gen:
+        mock_gen.return_value = Path("/tmp/output.png")
+        res = engine.generate("test prompt", steps=4)
+        assert res == Path("/tmp/output.png")
+        mock_gen.assert_called_once_with(
+            prompt="test prompt",
+            model="sdxs",
+            device="cpu",
+            steps=4,
+        )

{termux_diffusion-1.6.8 → termux_diffusion-1.7.0}/tests/test_hardware.py

@@ -162,3 +162,22 @@ def test_adreno_650_gpu_failfast_e003():
                 assert "AMEVA-DIFFUSION-E003" in str(exc_info.value)
                 assert "storageBuffer8BitAccess" in str(exc_info.value)
 
+
+def test_adreno_830_gpu_supported_with_vulkan_driver():
+    """Verify that Adreno 830 with Vulkan driver resolves to vulkan backend after v2.7.2 shader repair."""
+    mock_ameva = MagicMock()
+    with patch("termux_diffusion.hardware._resolve_ameva_runtime", return_value=mock_ameva):
+        with patch("termux_diffusion.hardware._detect_gpu_name", return_value="Adreno (TM) 830"):
+            with patch("termux_diffusion.hardware._detect_soc_name", return_value="SM8750"):
+                with patch("termux_diffusion.hardware.detect_hardware_profile") as mock_prof:
+                    prof = MagicMock()
+                    prof.vulkan_available = True
+                    prof.recommended_backend = MagicMock(value="vulkan")
+                    prof.recommended_ngl = 99
+                    mock_prof.return_value = prof
+                    backend, ngl = resolve_device_backend("gpu")
+                    assert backend == "vulkan"
+                    assert ngl == 99
+
+
+

termux_diffusion-1.6.8/termux_diffusion/_version.py

@@ -1 +0,0 @@
-__version__ = "1.6.8"