termux-tts 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.4.0] - 2026-09-07
+
+### Added
+- Direct integration with `TtsAdapter` from `ameva_runtime.adapters` SSOT.
+- Dual-tier VITS Vulkan neural engine routing with strict Fail-Fast error semantics.
+- English localization for all diagnostics, logs, and exception messages.
+
+---
+
 ## [1.1.5] - 2026-09-05
 
 ### Changed

package/binding_node/index.js

@@ -12,6 +12,8 @@ class TTSEngine {
         this.preset = options.preset || 'balanced';
         this.sampleRate = options.sampleRate || 22050;
         this.engine = options.engine || 'auto';
+        this.device = options.device || (options.gpu ? 'gpu' : 'auto');
+        this.tier = options.tier || null;
         this.model = options.model || null;
     }
 
@@ -24,6 +26,8 @@ class TTSEngine {
         const speed = typeof options.speed === 'number' ? options.speed : 1.0;
         const preset = options.preset || this.preset;
         const engineType = options.engine || this.engine;
+        const deviceType = options.device || (options.gpu ? 'gpu' : this.device);
+        const tierType = options.tier || this.tier;
         const modelPath = options.model || this.model;
 
         const payload = JSON.stringify({
@@ -34,6 +38,8 @@ class TTSEngine {
             speed: speed,
             preset: preset,
             engine: engineType,
+            device: deviceType,
+            tier: tierType,
             model: modelPath
         });
 
@@ -49,7 +55,9 @@ try:
         language=data.get('language', 'ko'),
         preset=data.get('preset', 'balanced'),
         sample_rate=data.get('sample_rate', 22050),
-        engine=data.get('engine', 'auto')
+        engine=data.get('engine', 'auto'),
+        device=data.get('device', 'auto'),
+        tier=data.get('tier', None)
     )
     res = engine.synthesize(data['text'], output=data['output'], speed=float(data.get('speed', 1.0)))
     result = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termux-tts",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "On-device Text-to-Speech framework utilizing device resources (DSP Formant Vocoder, ONNX Neural Runtime & Android Native Voice)",
   "main": "index.js",
   "bin": {

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "termux-tts"
-version = "1.3.0"
+version = "1.4.0"
 description = "On-device 4-Tier Text-to-Speech framework utilizing device resources (DSP Formant Vocoder, C++ Sherpa-ONNX Neural, Android Native & Expressive)"
 readme = "README.pypi.md"
 requires-python = ">=3.10"

package/termux_tts/__init__.py

@@ -29,7 +29,7 @@ from .exceptions import (
 ONNXNeuralEngine = SherpaNeuralEngine
 ONNXResult = SherpaResult
 
-__version__ = "1.3.0"
+__version__ = "1.4.0"
 __all__ = [
     "TTSEngine",
     "load",

package/termux_tts/cli.py

@@ -29,7 +29,11 @@ def main():
     )
     synth_parser.add_argument("-m", "--model", default=None, help="Path to model file or directory")
     synth_parser.add_argument("-p", "--preset", default="balanced", choices=["fast", "balanced", "expressive", "ultra"])
-    synth_parser.add_argument("-d", "--device", default="auto", choices=["auto", "gpu", "vulkan", "cpu"])
+    synth_parser.add_argument("-d", "--device", default="auto", choices=["auto", "gpu", "vulkan", "cpu"], help="Compute target device")
+    synth_parser.add_argument("-b", "--backend", dest="device", choices=["auto", "gpu", "vulkan", "cpu"], help="Alias for --device")
+    synth_parser.add_argument("--gpu", dest="device", action="store_const", const="gpu", help="Enable hardware GPU acceleration")
+    synth_parser.add_argument("--cpu", dest="device", action="store_const", const="cpu", help="Force CPU compute mode")
+    synth_parser.add_argument("--tier", default=None, choices=["high", "medium", "balanced", "fast", "ultra"], help="Target model tier (high=Studio FP16, medium=Balanced)")
     synth_parser.add_argument("-s", "--speed", type=float, default=1.0, help="Speech speed multiplier (0.5 to 2.0)")
     synth_parser.add_argument("--threads", type=int, default=4, help="Compute worker threads (ARM NEON)")
     synth_parser.add_argument("--volume", type=int, default=None, help="Set Android media volume (1 to 15)")
@@ -78,6 +82,7 @@ def main():
             device=args.device,
             threads=args.threads,
             engine=args.engine,
+            tier=getattr(args, "tier", None),
         ) as engine:
             res = engine.synthesize(args.text, output=args.output, speed=args.speed)
             backend_name = getattr(res, "backend", "UNKNOWN")

package/termux_tts/control/component.py

@@ -224,9 +224,10 @@ class TTSControl(ComponentControl):
         """기존 TTSEngine doctor() 호출 — 12단계 Vulkan Doctor 포함."""
         lite = self.doctor_lite()
         try:
-            from termux_tts.vulkan_probe import VulkanDoctor
-            vd = VulkanDoctor()
-            lite["vulkan"] = vd.probe() if hasattr(vd, "probe") else {"note": "probe() not available"}
+            from termux_tts.engine import doctor
+            doc_rep = doctor()
+            lite["doctor"] = doc_rep
+            lite["vulkan"] = doc_rep.get("doctor_report") or {"status": doc_rep.get("status")}
         except Exception as e:
             lite["vulkan_error"] = str(e)
         lite["doctor_level"] = "full"

package/termux_tts/engine.py

@@ -22,7 +22,12 @@ from .engine_dsp import ParametricDSPEngine, DSPResult, QUALITY_PRESETS
 from .engine_sherpa import SherpaNeuralEngine, SherpaResult
 from .engine_vulkan import VulkanNeuralEngine, VulkanResult
 from .engine_expressive import ExpressiveEngine, ExpressiveResult
-from .vulkan_probe import VulkanDoctor
+from .hardware import (
+    resolve_device_backend,
+    bind_tts_hardware,
+    _resolve_ameva_runtime,
+    ERROR_AMEVA_TTS_E001,
+)
 
 logger = logging.getLogger("termux_tts.engine")
 
@@ -39,6 +44,7 @@ class TTSEngine:
         threads: int = 4,
         sample_rate: Optional[int] = None,
         engine_type: str = "auto",
+        model_tier: Optional[str] = None,
     ):
         self.language = language.lower()
         self.preset = preset.lower()
@@ -47,32 +53,26 @@ class TTSEngine:
         self.model_path = model_path
         self.threads = threads
         self.sample_rate = sample_rate
-        self.device = self.requested_device
-        self.backend = "auto"
+        self.model_tier = model_tier
         self._is_closed = False
 
-        if self.requested_device in ("vulkan", "gpu"):
-            doc = VulkanDoctor()
-            if not doc.is_vulkan_available:
-                raise VulkanInitializationError(
-                    f"[FAIL-FAST] Explicit GPU backend requested ('{self.requested_device}'), "
-                    "but Vulkan hardware runtime is unavailable. Use '--device cpu' or '--device auto'."
-                )
+        # 1. Resolve effective device and engine_type via safe hardware gateway
+        self.device, effective_engine = resolve_device_backend(
+            self.requested_device, self.requested_engine_type
+        )
+        if self.requested_engine_type == "auto" and effective_engine != "auto":
+            self.requested_engine_type = effective_engine
+
+        self.backend = "auto"
 
-        # Attempt ameva-runtime hardware binding if available
+        # 2. Attempt ameva-runtime hardware binding if available
         self._binding_plan = self._bind_hardware()
 
         self.native_engine = NativeAndroidEngine(language=language)
         self.synth_engine = self._resolve_synth_engine()
 
     def _bind_hardware(self):
-        try:
-            from ameva_runtime.adapters.tts import TtsAdapter
-            binding = TtsAdapter.bind(engine=self, requested_backend=self.requested_device)
-            return binding
-        except Exception as e:
-            logger.debug("Hardware adapter binding skipped: %s", e)
-            return None
+        return bind_tts_hardware(self, self.requested_device)
 
     def _resolve_synth_engine(self):
         t = self.requested_engine_type
@@ -86,6 +86,7 @@ class TTSEngine:
                     device=self.requested_device,
                     threads=self.threads,
                     sample_rate=self.sample_rate or 22050,
+                    model_tier=self.model_tier,
                 )
             except (VulkanInitializationError, TTSModelLoadError) as err:
                 if t in ("vulkan", "gpu", "ncnn") or self.requested_device in ("vulkan", "gpu"):
@@ -214,6 +215,7 @@ def load(
     threads: int = 4,
     sample_rate: Optional[int] = None,
     engine: str = "auto",
+    tier: Optional[str] = None,
 ) -> TTSEngine:
     return TTSEngine(
         model_path=model,
@@ -223,28 +225,31 @@ def load(
         threads=threads,
         sample_rate=sample_rate,
         engine_type=engine,
+        model_tier=tier,
     )
 
 
 def doctor() -> Dict[str, Any]:
-    try:
-        from ameva_runtime import vulkan as avr
-        from ameva_runtime.vulkan.adapters import TtsAdapter
-        doc = avr.Doctor()
-        rep = doc.run_self_test(verbose=False)
-        return {
-            "doctor_report": rep,
-            "overall_success": getattr(rep, "overall_success", False),
-            "passed_stages": getattr(rep, "passed_stages", 0),
-            "recommended_backend": getattr(rep, "recommended_backend", "cpu"),
-            "status": "DIAGNOSED_VIA_AMEVA",
-        }
-    except Exception as e:
-        return {
-            "doctor_report": None,
-            "overall_success": False,
-            "passed_stages": 0,
-            "recommended_backend": "cpu_neon",
-            "error": str(e),
-            "status": "FALLBACK_CPU",
-        }
+    ameva_mod = _resolve_ameva_runtime()
+    if ameva_mod is not None:
+        try:
+            from ameva_runtime.adapters import TtsAdapter
+            adapter = TtsAdapter()
+            rep = adapter.resolve_diagnostic_report()
+            return {
+                "doctor_report": rep,
+                "overall_success": getattr(rep, "overall_success", False),
+                "passed_stages": getattr(rep, "passed_stages", 0),
+                "recommended_backend": getattr(rep, "recommended_backend", "cpu_neon"),
+                "status": "DIAGNOSED_VIA_AMEVA",
+            }
+        except Exception as e:
+            logger.debug("AMEVA Doctor invocation exception: %s", e)
+
+    return {
+        "doctor_report": None,
+        "overall_success": False,
+        "passed_stages": 0,
+        "recommended_backend": "cpu_neon",
+        "status": "NO_AMEVA_RUNTIME",
+    }

package/termux_tts/engine_dsp.py

@@ -14,7 +14,6 @@ from typing import Optional
 from .exceptions import TTSInferenceError, VulkanInitializationError
 from .tokenizer import PhoneticTokenizer
 from .audio import AudioBuffer
-from .vulkan_probe import VulkanDoctor
 
 def _detect_cpu_backend() -> str:
     """Detect current host CPU architecture dynamically."""
@@ -171,21 +170,30 @@ class ParametricDSPEngine:
         self.tokenizer = PhoneticTokenizer(language=language)
         self._is_closed = False
 
-        self.doctor = VulkanDoctor()
-        self.diag_info = self.doctor.probe_all() if self.requested_device != "cpu" else {}
+        self.is_vulkan_available = False
+        self.diag_info = {}
+        if self.requested_device != "cpu":
+            try:
+                from ameva_runtime.adapters import TtsAdapter
+                rep = TtsAdapter.resolve_diagnostic_report()
+                self.is_vulkan_available = bool(getattr(rep, "overall_success", False) or getattr(rep, "recommended_backend", "") == "vulkan")
+                self.diag_info = {"recommended_backend": rep.recommended_backend, "passed_stages": rep.passed_stages}
+            except Exception as e:
+                import logging
+                logging.getLogger("termux_tts.engine_dsp").debug("TtsAdapter diagnostic check exception: %s", e)
         self.backend = self._resolve_backend()
 
     def _resolve_backend(self) -> str:
         cpu_b = _detect_cpu_backend()
         if self.requested_device in ("vulkan", "gpu"):
-            if self.doctor.is_vulkan_available:
+            if self.is_vulkan_available:
                 return "VULKAN_GPU"
             raise VulkanInitializationError(
                 f"[FAIL-FAST] Explicit GPU backend requested ('{self.requested_device}'), "
                 "but Vulkan hardware runtime is unavailable. Use '--device cpu' or '--device auto'."
             )
         elif self.requested_device == "auto":
-            return "VULKAN_GPU" if self.doctor.is_vulkan_available else cpu_b
+            return "VULKAN_GPU" if self.is_vulkan_available else cpu_b
         return cpu_b
 
     def synthesize(self, text: str, output: Optional[str] = None, speed: float = 1.0, preset: Optional[str] = None) -> DSPResult:

package/termux_tts/engine_onnx.py

@@ -4,6 +4,5 @@ Python onnxruntime is permanently deprecated in favor of C++ isolated SherpaNeur
 """
 from .engine_sherpa import SherpaNeuralEngine as ONNXNeuralEngine
 from .engine_sherpa import SherpaResult as ONNXResult
-from .vulkan_probe import VulkanDoctor
 
-__all__ = ["ONNXNeuralEngine", "ONNXResult", "VulkanDoctor"]
+__all__ = ["ONNXNeuralEngine", "ONNXResult"]

package/termux_tts/engine_vulkan.py

@@ -69,17 +69,19 @@ class VulkanNeuralEngine:
         device: str = "vulkan",
         threads: int = 1,
         sample_rate: int = 22050,
+        model_tier: Optional[str] = None,
     ):
         self.language = language.lower()
         self.requested_device = device.lower()
         self.threads = threads
         self.sample_rate = sample_rate
+        self.model_tier = (model_tier or "high").lower()
         self._is_closed = False
 
         # 1. Locate Vulkan binary
         self.binary = self._find_binary()
 
-        # 2. Locate VITS NCNN model directory
+        # 2. Locate VITS NCNN model directory with tier awareness
         self.model_dir = self._resolve_model_dir(model_path)
         self.model_name = Path(self.model_dir).name
         self.backend = "VULKAN_GPU_NCNN_VITS"
@@ -88,15 +90,19 @@ class VulkanNeuralEngine:
         """Locate sherpa-ncnn-offline-tts executable or fail-fast."""
         for candidate in self.CANDIDATE_BINARIES:
             found = shutil.which(candidate) if not os.path.isabs(candidate) else candidate
-            if found and os.path.isfile(found) and os.access(found, os.X_OK):
+            if found and os.path.isfile(found) and (os.access(found, os.X_OK) or os.name == "nt"):
                 return str(found)
         raise VulkanInitializationError(
-            "[FAIL-FAST] 'sherpa-ncnn-offline-tts' Vulkan binary not found. "
-            "Please run 'termux-tts install' to automatically download and provision the Vulkan engine."
+            "[ERROR: AMEVA-TTS-E001] 'sherpa-ncnn-offline-tts' Vulkan binary not found.\n"
+            "Cause: Hardware acceleration runtime or native Vulkan engine is not installed.\n"
+            "Action Required: Run one-click provisioning via:\n"
+            "  $ termux-tts install --tier high\n"
+            "  (Or run without GPU: termux-tts synth -e dsp -t \"...\")\n"
+            "Documentation: https://uno-km.vercel.app/lib/tts/"
         )
 
     def _resolve_model_dir(self, model_path: Optional[str]) -> str:
-        """Locate directory containing config.json and *.ncnn.bin files."""
+        """Locate directory containing config.json and *.ncnn.bin files with tier awareness."""
         search_dirs: List[Path] = []
         if model_path:
             p = Path(model_path).expanduser().resolve()
@@ -104,20 +110,32 @@ class VulkanNeuralEngine:
                 raise TTSModelLoadError(f"[FAIL-FAST] Explicit model path not found: '{model_path}'")
             search_dirs = [p]
         else:
+            preferred_dir_keyword = "amy-medium" if self.model_tier == "medium" else "lessac-high"
+            
+            # Prioritize tier-specific matching directories first
             for s in self.STANDARD_MODEL_DIRS:
                 if s.exists():
-                    search_dirs.append(s)
+                    if preferred_dir_keyword in s.name.lower():
+                        search_dirs.insert(0, s)
+                    else:
+                        search_dirs.append(s)
                     for child in s.glob("ncnn-vits*"):
                         if child.is_dir():
-                            search_dirs.append(child)
+                            if preferred_dir_keyword in child.name.lower():
+                                search_dirs.insert(0, child)
+                            else:
+                                search_dirs.append(child)
 
         for d in search_dirs:
             if (d / "config.json").exists() and (d / "decoder.ncnn.bin").exists():
                 return str(d)
 
         raise TTSModelLoadError(
-            "[FAIL-FAST] No valid VITS NCNN model directory found. "
-            "Please run 'termux-tts install --tier high' to automatically download model assets."
+            f"[ERROR: AMEVA-TTS-E001] No valid VITS NCNN model directory found (tier: '{self.model_tier}').\n"
+            f"Cause: Model weights not found in standard directories.\n"
+            f"Action Required: Run one-click provisioning via:\n"
+            f"  $ termux-tts install --tier {self.model_tier}\n"
+            f"Documentation: https://uno-km.vercel.app/lib/tts/"
         )
 
     def synthesize(
@@ -140,18 +158,30 @@ class VulkanNeuralEngine:
             temp_wav = tmp_file.name
 
         try:
-            cmd = [
-                self.binary,
-                f"--vits-model-dir={self.model_dir}",
-                "--use-vulkan-compute=1",
-                f"--num-threads={self.threads}",
-                f"--output-filename={temp_wav}",
-                clean_text
-            ]
-
-            env = os.environ.copy()
-            env["LD_LIBRARY_PATH"] = f"/system/lib64:{env.get('LD_LIBRARY_PATH', '')}"
-            env["AMEVA_VK_DSP_ACCEL"] = "1"
+            try:
+                from ameva_runtime.adapters.tts import TtsAdapter
+                cmd = TtsAdapter.build_cli_args(
+                    executable=self.binary,
+                    model_dir=self.model_dir,
+                    text=clean_text,
+                    output_filename=temp_wav,
+                    threads=self.threads,
+                    use_vulkan=True,
+                )
+                is_mali = "mali" in str(getattr(self, "gpu_device", "")).lower()
+                env = TtsAdapter.get_execution_env(is_mali=is_mali)
+            except Exception:
+                cmd = [
+                    self.binary,
+                    f"--vits-model-dir={self.model_dir}",
+                    "--use-vulkan-compute=1",
+                    f"--num-threads={self.threads}",
+                    f"--output-filename={temp_wav}",
+                    clean_text
+                ]
+                env = os.environ.copy()
+                env["LD_LIBRARY_PATH"] = f"/system/lib64:{env.get('LD_LIBRARY_PATH', '')}"
+                env["AMEVA_VK_DSP_ACCEL"] = "1"
 
             proc = subprocess.run(
                 cmd,

package/termux_tts/hardware.py

@@ -0,0 +1,121 @@
+"""
+Hardware abstraction gateway and dynamic ameva-runtime soft-dependency resolver for termux-tts.
+Provides strict Zero-Silent-Fallback [AMEVA-TTS-E001] compliance, hardware-agnostic routing,
+and seamless fallback to Tier 1 DSP Formant / Tier 2 Native voice when running standalone.
+"""
+from __future__ import annotations
+
+import importlib.util
+import logging
+import sys
+from typing import Optional, Tuple, Any
+
+from .exceptions import VulkanInitializationError
+
+logger = logging.getLogger("termux_tts.hardware")
+
+ERROR_AMEVA_TTS_E001 = (
+    "[FAIL-FAST] [ERROR: AMEVA-TTS-E001] GPU acceleration requires 'ameva-runtime' and provisioned Vulkan assets.\n"
+    "Cause: Hardware acceleration runtime or native Vulkan engine is not installed.\n"
+    "Action Required: Run one-click provisioning via:\n"
+    "  $ termux-tts install --tier high\n"
+    "  (Or run without GPU: termux-tts synth -e dsp -t \"...\")\n"
+    "Documentation: https://uno-km.vercel.app/lib/tts/"
+)
+
+
+def _resolve_ameva_runtime() -> Optional[Any]:
+    """Check for ameva_runtime availability without top-level static dependency.
+
+    Returns the ameva_runtime module if installed, otherwise None.
+    """
+    try:
+        spec = importlib.util.find_spec("ameva_runtime")
+        if spec is not None:
+            import ameva_runtime
+            return ameva_runtime
+    except (ImportError, AttributeError):
+        pass
+    return None
+
+
+def resolve_device_backend(
+    requested_device: str,
+    requested_engine: str = "auto",
+) -> Tuple[str, str]:
+    """Resolve user requested device/engine into (device, engine_type) with fail-fast compliance.
+
+    Returns:
+        Tuple[str, str]: (device, engine_type) e.g. ('vulkan', 'vulkan') or ('cpu', 'dsp')
+    """
+    req_dev = (requested_device or "auto").lower().strip()
+    req_eng = (requested_engine or "auto").lower().strip()
+    ameva_mod = _resolve_ameva_runtime()
+
+    # Explicit GPU/Vulkan requested
+    if req_dev in ("vulkan", "gpu") or req_eng in ("vulkan", "gpu", "ncnn"):
+        if ameva_mod is None:
+            raise VulkanInitializationError(ERROR_AMEVA_TTS_E001)
+
+        # Check Vulkan doctor from ameva_runtime TtsAdapter
+        try:
+            from ameva_runtime.adapters import TtsAdapter
+            adapter = TtsAdapter()
+            report = adapter.resolve_diagnostic_report()
+            is_vk = getattr(report, "overall_success", False) or getattr(report, "recommended_backend", "") == "vulkan"
+            if not is_vk:
+                raise VulkanInitializationError(
+                    f"[FAIL-FAST] [ERROR: AMEVA-TTS-E002] Vulkan hardware acceleration is not supported on this device.\n"
+                    f"Cause: No usable Vulkan physical device or ICD driver library found.\n"
+                    f"Action Required: Use CPU or DSP synthesis via '--device cpu' or '--engine dsp'."
+                )
+        except VulkanInitializationError:
+            raise
+        except Exception as e:
+            logger.debug("TtsAdapter diagnostic exception: %s", e)
+            raise VulkanInitializationError(
+                f"[FAIL-FAST] [ERROR: AMEVA-TTS-E002] Vulkan hardware acceleration check failed: {e}\n"
+                f"Action Required: Use CPU or DSP synthesis via '--device cpu' or '--engine dsp'."
+            ) from e
+
+        return "vulkan", "vulkan"
+
+    # Auto mode: probe if ameva-runtime is available
+    if req_dev == "auto":
+        if ameva_mod is None:
+            sys.stdout.write(
+                "[INFO] ameva-runtime GPU engine is not provisioned. Operating in Tier 1 (Parametric DSP Formant) mode.\n"
+            )
+            sys.stdout.flush()
+            return "cpu", req_eng
+
+        try:
+            from ameva_runtime.adapters import TtsAdapter
+            adapter = TtsAdapter()
+            report = adapter.resolve_diagnostic_report()
+            is_vk = getattr(report, "overall_success", False) or getattr(report, "recommended_backend", "") == "vulkan"
+            bin_path = adapter.resolve_binary_path()
+            if is_vk and bin_path and req_eng in ("auto", "neural", "vits"):
+                return "vulkan", "vulkan"
+        except Exception as e:
+            logger.debug("TtsAdapter auto-routing probe exception: %s", e)
+
+        return "cpu", req_eng
+
+    # Explicit CPU
+    return "cpu", req_eng
+
+
+def bind_tts_hardware(engine: Any, requested_device: str) -> Optional[Any]:
+    """Safely invoke AMEVA-Runtime TtsAdapter if present to configure engine instance."""
+    ameva_mod = _resolve_ameva_runtime()
+    if ameva_mod is None:
+        return None
+
+    try:
+        from ameva_runtime.adapters.tts import TtsAdapter
+        binding = TtsAdapter.bind(engine=engine, requested_backend=requested_device)
+        return binding
+    except Exception as e:
+        logger.debug("Hardware adapter binding skipped: %s", e)
+        return None

package/termux_tts/vulkan_probe.py

@@ -1,49 +0,0 @@
-"""
-[DEPRECATED] This file is deprecated. 12-Stage Vulkan diagnostics are 100% delegated to ameva-runtime.
-"""
-from typing import Dict, Any
-
-class VulkanDoctor:
-    """Legacy compatibility bridge delegating directly to ameva-runtime."""
-    def __init__(self):
-        self.is_vulkan_available = False
-        self.ameva_runtime_bound = True
-        self.report = None
-        self._check_availability()
-
-    def _check_availability(self) -> None:
-        try:
-            from ameva_runtime import vulkan as avr
-            self.is_vulkan_available = bool(avr.is_available())
-        except Exception:
-            self.is_vulkan_available = False
-
-    def probe_all(self) -> Dict[str, Any]:
-        try:
-            from ameva_runtime import vulkan as avr
-            doc = avr.Doctor()
-            rep = doc.run_self_test(verbose=False)
-            self.report = rep
-            rec = getattr(rep, "recommended_backend", "")
-            passed = getattr(rep, "passed_stages", 0)
-            self.is_vulkan_available = bool(
-                getattr(rep, "overall_success", False)
-                or rec in ("vulkan", "vulkan_driver_only")
-                or passed >= 7
-                or avr.is_available()
-            )
-            device_name = getattr(rep, "device_name", None) or doc.quick_probe_device() or "Mali-G68"
-            return {
-                "overall_success": self.is_vulkan_available,
-                "passed_stages": passed,
-                "recommended_backend": rec or "vulkan",
-                "status": "BOUND_AMEVA_VULKAN",
-                "DeviceName": device_name,
-                "DeviceModel": device_name,
-            }
-        except Exception as e:
-            self.is_vulkan_available = False
-            return {"overall_success": False, "passed_stages": 0, "status": "FALLBACK_CPU", "error": str(e)}
-
-    def probe(self) -> Dict[str, Any]:
-        return self.probe_all()