feat: add model download API gated behind --enable-download-api

Add a new server-side download API that allows frontends and desktop apps
to download models directly into ComfyUI's models directory, eliminating
the need for DOM scraping of the frontend UI.

New files:
- app/download_manager.py: Async download manager with streaming downloads,
  pause/resume/cancel, manual redirect following with per-hop host validation,
  sidecar metadata for safe resume, and concurrency limiting.

API endpoints (all under /download/, also mirrored at /api/download/):
- POST /download/model - Start a download (url, directory, filename)
- GET /download/status - List all downloads (filterable by client_id)
- GET /download/status/{id} - Get single download status
- POST /download/pause/{id} - Pause (cancels transfer, keeps temp)
- POST /download/resume/{id} - Resume (new request with Range header)
- POST /download/cancel/{id} - Cancel and clean up temp files

Security:
- Gated behind --enable-download-api CLI flag (403 if disabled)
- HTTPS-only with exact host allowlist (huggingface.co, civitai.com + CDNs)
- Manual redirect following with per-hop host validation (no SSRF)
- Path traversal protection via realpath + commonpath
- Extension allowlist (.safetensors, .sft)
- Filename sanitization (no separators, .., control chars)
- Destination re-checked before final rename
- Progress events scoped to initiating client_id

Closes Comfy-Org/ComfyUI-Desktop-2.0-Beta#293

Amp-Thread-ID: https://ampcode.com/threads/T-019d2344-139e-77a5-9f24-1cbb3b26a8ec
Co-authored-by: Amp <amp@ampcode.com>

.ci/windows_intel_base_files/run_intel_gpu.bat

@@ -1,2 +0,0 @@
-.\python_embeded\python.exe -s ComfyUI\main.py --windows-standalone-build
-pause

.github/workflows/release-stable-all.yml

@@ -20,12 +20,29 @@ jobs:
       git_tag: ${{ inputs.git_tag }}
       cache_tag: "cu130"
       python_minor: "13"
-      python_patch: "12"
+      python_patch: "11"
       rel_name: "nvidia"
       rel_extra_name: ""
       test_release: true
     secrets: inherit
 
+  release_nvidia_cu128:
+    permissions:
+      contents: "write"
+      packages: "write"
+      pull-requests: "read"
+    name: "Release NVIDIA cu128"
+    uses: ./.github/workflows/stable-release.yml
+    with:
+      git_tag: ${{ inputs.git_tag }}
+      cache_tag: "cu128"
+      python_minor: "12"
+      python_patch: "10"
+      rel_name: "nvidia"
+      rel_extra_name: "_cu128"
+      test_release: true
+    secrets: inherit
+
   release_nvidia_cu126:
     permissions:
       contents: "write"
@@ -59,20 +76,3 @@ jobs:
       rel_extra_name: ""
       test_release: false
     secrets: inherit
-
-  release_xpu:
-    permissions:
-      contents: "write"
-      packages: "write"
-      pull-requests: "read"
-    name: "Release Intel XPU"
-    uses: ./.github/workflows/stable-release.yml
-    with:
-      git_tag: ${{ inputs.git_tag }}
-      cache_tag: "xpu"
-      python_minor: "13"
-      python_patch: "12"
-      rel_name: "intel"
-      rel_extra_name: ""
-      test_release: true
-    secrets: inherit

.github/workflows/tag-dispatch-cloud.yml

@@ -1,45 +0,0 @@
-name: Tag Dispatch to Cloud
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  dispatch-cloud:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Send repository dispatch to cloud
-        env:
-          DISPATCH_TOKEN: ${{ secrets.CLOUD_REPO_DISPATCH_TOKEN }}
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          set -euo pipefail
-
-          if [ -z "${DISPATCH_TOKEN:-}" ]; then
-            echo "::error::CLOUD_REPO_DISPATCH_TOKEN is required but not set."
-            exit 1
-          fi
-
-          RELEASE_URL="https://github.com/${{ github.repository }}/releases/tag/${RELEASE_TAG}"
-
-          PAYLOAD="$(jq -n \
-            --arg release_tag "$RELEASE_TAG" \
-            --arg release_url "$RELEASE_URL" \
-            '{
-              event_type: "comfyui_tag_pushed",
-              client_payload: {
-                release_tag: $release_tag,
-                release_url: $release_url
-              }
-            }')"
-
-          curl -fsSL \
-            -X POST \
-            -H "Accept: application/vnd.github+json" \
-            -H "Content-Type: application/json" \
-            -H "Authorization: Bearer ${DISPATCH_TOKEN}" \
-            https://api.github.com/repos/Comfy-Org/cloud/dispatches \
-            -d "$PAYLOAD"
-
-          echo "✅ Dispatched ComfyUI tag ${RELEASE_TAG} to Comfy-Org/cloud"

.gitignore

@@ -21,6 +21,6 @@ venv*/
 *.log
 web_custom_versions/
 .DS_Store
+openapi.yaml
 filtered-openapi.yaml
 uv.lock
-.pyisolate_venvs/

QUANTIZATION.md

@@ -139,9 +139,9 @@ Example:
   "_quantization_metadata": {
     "format_version": "1.0",
     "layers": {
-      "model.layers.0.mlp.up_proj": {"format": "float8_e4m3fn"},
-      "model.layers.0.mlp.down_proj": {"format": "float8_e4m3fn"},
-      "model.layers.1.mlp.up_proj": {"format": "float8_e4m3fn"}
+      "model.layers.0.mlp.up_proj": "float8_e4m3fn",
+      "model.layers.0.mlp.down_proj": "float8_e4m3fn",
+      "model.layers.1.mlp.up_proj": "float8_e4m3fn"
     }
   }
 }
@@ -165,4 +165,4 @@ Activation quantization (e.g., for FP8 Tensor Core operations) requires `input_s
 3. **Compute scales**: Derive `input_scale` from collected statistics
 4. **Store in checkpoint**: Save `input_scale` parameters alongside weights
 
-The calibration dataset should be representative of your target use case. For diffusion models, this typically means a diverse set of prompts and generation parameters.
+The calibration dataset should be representative of your target use case. For diffusion models, this typically means a diverse set of prompts and generation parameters.

README.md

@@ -61,7 +61,6 @@ See what ComfyUI can do with the [newer template workflows](https://comfy.org/wo
 
 ## Features
 - Nodes/graph/flowchart interface to experiment and create complex Stable Diffusion workflows without needing to code anything.
-- NOTE: There are many more models supported than the list below, if you want to see what is supported see our templates list inside ComfyUI.
 - Image Models
    - SD1.x, SD2.x ([unCLIP](https://comfyanonymous.github.io/ComfyUI_examples/unclip/))
    - [SDXL](https://comfyanonymous.github.io/ComfyUI_examples/sdxl/), [SDXL Turbo](https://comfyanonymous.github.io/ComfyUI_examples/sdturbo/)
@@ -137,7 +136,7 @@ ComfyUI follows a weekly release cycle targeting Monday but this regularly chang
    - Builds a new release using the latest stable core version
 
 3. **[ComfyUI Frontend](https://github.com/Comfy-Org/ComfyUI_frontend)**
-   - Every 2+ weeks frontend updates are merged into the core repository
+   - Weekly frontend updates are merged into the core repository
    - Features are frozen for the upcoming core release
    - Development continues for the next release cycle
 
@@ -195,9 +194,7 @@ The portable above currently comes with python 3.13 and pytorch cuda 13.0. Updat
 
 #### Alternative Downloads:
 
-[Portable for AMD GPUs](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_amd.7z)
-
-[Experimental portable for Intel GPUs](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_intel.7z)
+[Experimental portable for AMD GPUs](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_amd.7z)
 
 [Portable with pytorch cuda 12.6 and python 3.12](https://github.com/comfyanonymous/ComfyUI/releases/latest/download/ComfyUI_windows_portable_nvidia_cu126.7z) (Supports Nvidia 10 series and older GPUs).
 
@@ -235,7 +232,7 @@ Put your VAE in: models/vae
 
 AMD users can install rocm and pytorch with pip if you don't have it already installed, this is the command to install the stable version:
 
-```pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm7.2```
+```pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm7.1```
 
 This is the command to install the nightly with ROCm 7.2 which might have some performance improvements:
 
@@ -278,7 +275,7 @@ Nvidia users should install stable pytorch using this command:
 
 This is the command to install pytorch nightly instead which might have performance improvements.
 
-```pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu132```
+```pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu130```
 
 #### Troubleshooting
 

api_server/routes/internal/internal_routes.py

@@ -67,7 +67,7 @@ class InternalRoutes:
                 (entry for entry in os.scandir(directory) if is_visible_file(entry)),
                 key=lambda entry: -entry.stat().st_mtime
             )
-            return web.json_response([f"{entry.name} [{directory_type}]" for entry in sorted_files], status=200)
+            return web.json_response([entry.name for entry in sorted_files], status=200)
 
 
     def get_app(self):

app/assets/services/path_utils.py

@@ -93,13 +93,12 @@ def compute_relative_filename(file_path: str) -> str | None:
 
 def get_asset_category_and_relative_path(
     file_path: str,
-) -> tuple[Literal["input", "output", "temp", "models"], str]:
+) -> tuple[Literal["input", "output", "models"], str]:
     """Determine which root category a file path belongs to.
 
     Categories:
       - 'input': under folder_paths.get_input_directory()
       - 'output': under folder_paths.get_output_directory()
-      - 'temp': under folder_paths.get_temp_directory()
       - 'models': under any base path from get_comfy_models_folders()
 
     Returns:
@@ -130,12 +129,7 @@ def get_asset_category_and_relative_path(
     if _check_is_within(fp_abs, output_base):
         return "output", _compute_relative(fp_abs, output_base)
 
-    # 3) temp
-    temp_base = os.path.abspath(folder_paths.get_temp_directory())
-    if _check_is_within(fp_abs, temp_base):
-        return "temp", _compute_relative(fp_abs, temp_base)
-
-    # 4) models (check deepest matching base to avoid ambiguity)
+    # 3) models (check deepest matching base to avoid ambiguity)
     best: tuple[int, str, str] | None = None  # (base_len, bucket, rel_inside_bucket)
     for bucket, bases in get_comfy_models_folders():
         for b in bases:
@@ -152,7 +146,7 @@ def get_asset_category_and_relative_path(
         return "models", os.path.relpath(os.path.join(os.sep, combined), os.sep)
 
     raise ValueError(
-        f"Path is not within input, output, temp, or configured model bases: {file_path}"
+        f"Path is not within input, output, or configured model bases: {file_path}"
     )
 
 

app/download_manager.py

@@ -0,0 +1,507 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import time
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional, TYPE_CHECKING
+from urllib.parse import urlsplit
+
+import aiohttp
+from yarl import URL
+
+import folder_paths
+
+if TYPE_CHECKING:
+    from server import PromptServer
+
+logger = logging.getLogger(__name__)
+
+ALLOWED_HTTPS_HOSTS = frozenset({
+    "huggingface.co",
+    "cdn-lfs.huggingface.co",
+    "cdn-lfs-us-1.huggingface.co",
+    "cdn-lfs-eu-1.huggingface.co",
+    "civitai.com",
+    "api.civitai.com",
+})
+
+ALLOWED_EXTENSIONS = frozenset({".safetensors", ".sft"})
+
+MAX_CONCURRENT_DOWNLOADS = 3
+MAX_TERMINAL_TASKS = 50
+MAX_REDIRECTS = 10
+
+DOWNLOAD_TEMP_SUFFIX = ".download_tmp"
+DOWNLOAD_META_SUFFIX = ".download_meta"
+
+
+class DownloadStatus(str, Enum):
+    PENDING = "pending"
+    DOWNLOADING = "downloading"
+    PAUSED = "paused"
+    COMPLETED = "completed"
+    ERROR = "error"
+    CANCELLED = "cancelled"
+
+
+ACTIVE_STATUSES = frozenset({
+    DownloadStatus.PENDING,
+    DownloadStatus.DOWNLOADING,
+    DownloadStatus.PAUSED,
+})
+
+TERMINAL_STATUSES = frozenset({
+    DownloadStatus.COMPLETED,
+    DownloadStatus.ERROR,
+    DownloadStatus.CANCELLED,
+})
+
+
+@dataclass
+class DownloadTask:
+    id: str
+    url: str
+    filename: str
+    directory: str
+    save_path: str
+    temp_path: str
+    meta_path: str
+    status: DownloadStatus = DownloadStatus.PENDING
+    progress: float = 0.0
+    received_bytes: int = 0
+    total_bytes: int = 0
+    speed_bytes_per_sec: float = 0.0
+    eta_seconds: float = 0.0
+    error: Optional[str] = None
+    created_at: float = field(default_factory=time.time)
+    client_id: Optional[str] = None
+    _worker: Optional[asyncio.Task] = field(default=None, repr=False)
+    _stop_reason: Optional[str] = field(default=None, repr=False)
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "url": self.url,
+            "filename": self.filename,
+            "directory": self.directory,
+            "status": self.status.value,
+            "progress": self.progress,
+            "received_bytes": self.received_bytes,
+            "total_bytes": self.total_bytes,
+            "speed_bytes_per_sec": self.speed_bytes_per_sec,
+            "eta_seconds": self.eta_seconds,
+            "error": self.error,
+            "created_at": self.created_at,
+        }
+
+
+class DownloadManager:
+    def __init__(self, server: PromptServer):
+        self.server = server
+        self.tasks: dict[str, DownloadTask] = {}
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._semaphore = asyncio.Semaphore(MAX_CONCURRENT_DOWNLOADS)
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        if self._session is None or self._session.closed:
+            timeout = aiohttp.ClientTimeout(total=None, connect=30, sock_read=60)
+            self._session = aiohttp.ClientSession(timeout=timeout)
+        return self._session
+
+    async def close(self):
+        workers = [t._worker for t in self.tasks.values() if t._worker and not t._worker.done()]
+        for w in workers:
+            w.cancel()
+        if workers:
+            await asyncio.gather(*workers, return_exceptions=True)
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+    # -- Validation --
+
+    @staticmethod
+    def _validate_url(url: str) -> Optional[str]:
+        try:
+            parts = urlsplit(url)
+        except Exception:
+            return "Invalid URL"
+
+        if parts.username or parts.password:
+            return "Credentials in URL are not allowed"
+
+        host = (parts.hostname or "").lower()
+        scheme = parts.scheme.lower()
+
+        if scheme != "https":
+            return "Only HTTPS URLs are allowed"
+
+        if host not in ALLOWED_HTTPS_HOSTS:
+            return f"Host '{host}' is not in the allowed list"
+
+        if parts.port not in (None, 443):
+            return "Custom ports are not allowed for remote downloads"
+
+        return None
+
+    @staticmethod
+    def _validate_filename(filename: str) -> Optional[str]:
+        if not filename:
+            return "Filename must not be empty"
+        ext = os.path.splitext(filename)[1].lower()
+        if ext not in ALLOWED_EXTENSIONS:
+            return f"File extension '{ext}' not allowed. Allowed: {', '.join(sorted(ALLOWED_EXTENSIONS))}"
+        if os.path.sep in filename or (os.path.altsep and os.path.altsep in filename):
+            return "Filename must not contain path separators"
+        if ".." in filename:
+            return "Filename must not contain '..'"
+        for ch in filename:
+            if ord(ch) < 32:
+                return "Filename must not contain control characters"
+        return None
+
+    @staticmethod
+    def _validate_directory(directory: str) -> Optional[str]:
+        if directory not in folder_paths.folder_names_and_paths:
+            valid = ', '.join(sorted(folder_paths.folder_names_and_paths.keys()))
+            return f"Unknown model directory '{directory}'. Valid directories: {valid}"
+        return None
+
+    @staticmethod
+    def _resolve_save_path(directory: str, filename: str) -> tuple[str, str, str]:
+        """Returns (save_path, temp_path, meta_path) for a download."""
+        paths = folder_paths.folder_names_and_paths[directory][0]
+        base_dir = paths[0]
+        os.makedirs(base_dir, exist_ok=True)
+
+        save_path = os.path.join(base_dir, filename)
+        temp_path = save_path + DOWNLOAD_TEMP_SUFFIX
+        meta_path = save_path + DOWNLOAD_META_SUFFIX
+
+        real_save = os.path.realpath(save_path)
+        real_base = os.path.realpath(base_dir)
+        if os.path.commonpath([real_save, real_base]) != real_base:
+            raise ValueError("Resolved path escapes the model directory")
+
+        return save_path, temp_path, meta_path
+
+    # -- Sidecar metadata for resume validation --
+
+    @staticmethod
+    def _write_meta(meta_path: str, url: str, task_id: str):
+        try:
+            with open(meta_path, "w") as f:
+                json.dump({"url": url, "task_id": task_id}, f)
+        except OSError:
+            pass
+
+    @staticmethod
+    def _read_meta(meta_path: str) -> Optional[dict]:
+        try:
+            with open(meta_path, "r") as f:
+                return json.load(f)
+        except (OSError, json.JSONDecodeError):
+            return None
+
+    @staticmethod
+    def _cleanup_files(*paths: str):
+        for p in paths:
+            try:
+                if os.path.exists(p):
+                    os.remove(p)
+            except OSError:
+                pass
+
+    # -- Task management --
+
+    def _prune_terminal_tasks(self):
+        terminal = [
+            (tid, t) for tid, t in self.tasks.items()
+            if t.status in TERMINAL_STATUSES
+        ]
+        if len(terminal) > MAX_TERMINAL_TASKS:
+            terminal.sort(key=lambda x: x[1].created_at)
+            to_remove = len(terminal) - MAX_TERMINAL_TASKS
+            for tid, _ in terminal[:to_remove]:
+                del self.tasks[tid]
+
+    async def start_download(
+        self, url: str, directory: str, filename: str, client_id: Optional[str] = None
+    ) -> tuple[Optional[DownloadTask], Optional[str]]:
+        err = self._validate_url(url)
+        if err:
+            return None, err
+
+        err = self._validate_filename(filename)
+        if err:
+            return None, err
+
+        err = self._validate_directory(directory)
+        if err:
+            return None, err
+
+        try:
+            save_path, temp_path, meta_path = self._resolve_save_path(directory, filename)
+        except ValueError as e:
+            return None, str(e)
+
+        if os.path.exists(save_path):
+            return None, f"File already exists: {directory}/{filename}"
+
+        # Reject duplicate active download by URL
+        for task in self.tasks.values():
+            if task.url == url and task.status in ACTIVE_STATUSES:
+                return None, f"Download already in progress for this URL (id: {task.id})"
+
+        # Reject duplicate active download by destination path (#4)
+        for task in self.tasks.values():
+            if task.save_path == save_path and task.status in ACTIVE_STATUSES:
+                return None, f"Download already in progress for {directory}/{filename} (id: {task.id})"
+
+        # Clean stale temp/meta if no active task owns them (#9)
+        existing_meta = self._read_meta(meta_path)
+        if existing_meta:
+            owning_task = self.tasks.get(existing_meta.get("task_id", ""))
+            if not owning_task or owning_task.status in TERMINAL_STATUSES:
+                if existing_meta.get("url") != url:
+                    self._cleanup_files(temp_path, meta_path)
+
+        task = DownloadTask(
+            id=uuid.uuid4().hex[:12],
+            url=url,
+            filename=filename,
+            directory=directory,
+            save_path=save_path,
+            temp_path=temp_path,
+            meta_path=meta_path,
+            client_id=client_id,
+        )
+        self.tasks[task.id] = task
+        self._prune_terminal_tasks()
+
+        task._worker = asyncio.create_task(self._run_download(task))
+        return task, None
+
+    # -- Redirect-safe fetch (#1, #2, #3) --
+
+    async def _fetch_with_validated_redirects(
+        self, session: aiohttp.ClientSession, url: str, headers: dict
+    ) -> aiohttp.ClientResponse:
+        """Follow redirects manually, validating each hop against the allowlist."""
+        current_url = url
+        for _ in range(MAX_REDIRECTS + 1):
+            resp = await session.get(current_url, headers=headers, allow_redirects=False)
+            if resp.status not in (301, 302, 303, 307, 308):
+                return resp
+
+            location = resp.headers.get("Location")
+            await resp.release()
+            if not location:
+                raise ValueError("Redirect without Location header")
+
+            resolved = URL(current_url).join(URL(location))
+            current_url = str(resolved)
+
+            # Validate the redirect target host
+            parts = urlsplit(current_url)
+            host = (parts.hostname or "").lower()
+            scheme = parts.scheme.lower()
+
+            if scheme != "https":
+                raise ValueError(f"Redirect to non-HTTPS URL: {current_url}")
+            if host not in ALLOWED_HTTPS_HOSTS:
+                # Allow CDN hosts that HuggingFace/CivitAI commonly redirect to
+                raise ValueError(f"Redirect to disallowed host: {host}")
+
+            # 303 means GET with no Range
+            if resp.status == 303:
+                headers = {k: v for k, v in headers.items() if k.lower() != "range"}
+
+        raise ValueError(f"Too many redirects (>{MAX_REDIRECTS})")
+
+    # -- Download worker --
+
+    async def _run_download(self, task: DownloadTask):
+        try:
+            async with self._semaphore:
+                await self._run_download_inner(task)
+        except asyncio.CancelledError:
+            if task._stop_reason == "pause":
+                task.status = DownloadStatus.PAUSED
+                task.speed_bytes_per_sec = 0
+                task.eta_seconds = 0
+                await self._send_progress(task)
+            else:
+                task.status = DownloadStatus.CANCELLED
+                await self._send_progress(task)
+                self._cleanup_files(task.temp_path, task.meta_path)
+        except Exception as e:
+            task.status = DownloadStatus.ERROR
+            task.error = str(e)
+            await self._send_progress(task)
+            logger.exception("Download error for %s", task.url)
+
+    async def _run_download_inner(self, task: DownloadTask):
+        session = await self._get_session()
+        headers = {}
+
+        # Resume support with sidecar validation (#9)
+        if os.path.exists(task.temp_path):
+            meta = self._read_meta(task.meta_path)
+            if meta and meta.get("url") == task.url:
+                existing_size = os.path.getsize(task.temp_path)
+                if existing_size > 0:
+                    headers["Range"] = f"bytes={existing_size}-"
+                    task.received_bytes = existing_size
+            else:
+                self._cleanup_files(task.temp_path, task.meta_path)
+
+        self._write_meta(task.meta_path, task.url, task.id)
+        task.status = DownloadStatus.DOWNLOADING
+        await self._send_progress(task)
+
+        resp = await self._fetch_with_validated_redirects(session, task.url, headers)
+        try:
+            if resp.status == 416:
+                content_range = resp.headers.get("Content-Range", "")
+                if content_range:
+                    total_str = content_range.split("/")[-1]
+                    if total_str != "*":
+                        total = int(total_str)
+                        if task.received_bytes >= total:
+                            if not os.path.exists(task.save_path):
+                                os.rename(task.temp_path, task.save_path)
+                                self._cleanup_files(task.meta_path)
+                            task.status = DownloadStatus.COMPLETED
+                            task.progress = 1.0
+                            task.total_bytes = total
+                            await self._send_progress(task)
+                            return
+                raise ValueError(f"HTTP 416 Range Not Satisfiable")
+
+            if resp.status not in (200, 206):
+                task.status = DownloadStatus.ERROR
+                task.error = f"HTTP {resp.status}"
+                await self._send_progress(task)
+                return
+
+            if resp.status == 200:
+                task.received_bytes = 0
+
+            content_length = resp.content_length
+            if resp.status == 206 and content_length:
+                task.total_bytes = task.received_bytes + content_length
+            elif resp.status == 200 and content_length:
+                task.total_bytes = content_length
+
+            mode = "ab" if resp.status == 206 else "wb"
+            speed_window_start = time.monotonic()
+            speed_window_bytes = 0
+            last_progress_time = 0.0
+
+            with open(task.temp_path, mode) as f:
+                async for chunk in resp.content.iter_chunked(1024 * 64):
+                    f.write(chunk)
+                    task.received_bytes += len(chunk)
+                    speed_window_bytes += len(chunk)
+
+                    now = time.monotonic()
+                    elapsed = now - speed_window_start
+                    if elapsed > 0.5:
+                        task.speed_bytes_per_sec = speed_window_bytes / elapsed
+                        if task.total_bytes > 0 and task.speed_bytes_per_sec > 0:
+                            remaining = task.total_bytes - task.received_bytes
+                            task.eta_seconds = remaining / task.speed_bytes_per_sec
+                        speed_window_start = now
+                        speed_window_bytes = 0
+
+                    if task.total_bytes > 0:
+                        task.progress = task.received_bytes / task.total_bytes
+
+                    if now - last_progress_time >= 0.25:
+                        await self._send_progress(task)
+                        last_progress_time = now
+        finally:
+            resp.release()
+
+        # Final cancel check before committing (#7)
+        if task._stop_reason is not None:
+            raise asyncio.CancelledError()
+
+        # Re-check destination before finalizing (#10)
+        if os.path.exists(task.save_path):
+            task.status = DownloadStatus.ERROR
+            task.error = f"Destination file appeared during download: {task.directory}/{task.filename}"
+            await self._send_progress(task)
+            return
+
+        os.replace(task.temp_path, task.save_path)
+        self._cleanup_files(task.meta_path)
+        task.status = DownloadStatus.COMPLETED
+        task.progress = 1.0
+        task.speed_bytes_per_sec = 0
+        task.eta_seconds = 0
+        await self._send_progress(task)
+        logger.info("Download complete: %s/%s", task.directory, task.filename)
+
+    # -- Progress (#8, #14) --
+
+    async def _send_progress(self, task: DownloadTask):
+        try:
+            self.server.send_sync("download_progress", task.to_dict(), task.client_id)
+        except Exception:
+            logger.exception("Failed to send download progress event")
+
+    # -- Control operations (#5, #6, #13) --
+
+    def pause_download(self, task_id: str) -> Optional[str]:
+        task = self.tasks.get(task_id)
+        if not task:
+            return "Download not found"
+        if task.status not in (DownloadStatus.PENDING, DownloadStatus.DOWNLOADING):
+            return f"Cannot pause download in state '{task.status.value}'"
+        task._stop_reason = "pause"
+        if task._worker and not task._worker.done():
+            task._worker.cancel()
+        return None
+
+    def resume_download(self, task_id: str) -> Optional[str]:
+        task = self.tasks.get(task_id)
+        if not task:
+            return "Download not found"
+        if task.status != DownloadStatus.PAUSED:
+            return f"Cannot resume download in state '{task.status.value}'"
+        task._stop_reason = None
+        task.status = DownloadStatus.PENDING
+        task._worker = asyncio.create_task(self._run_download(task))
+        return None
+
+    def cancel_download(self, task_id: str) -> Optional[str]:
+        task = self.tasks.get(task_id)
+        if not task:
+            return "Download not found"
+        if task.status in TERMINAL_STATUSES:
+            return f"Cannot cancel download in state '{task.status.value}'"
+        task._stop_reason = "cancel"
+        if task._worker and not task._worker.done():
+            task._worker.cancel()
+        else:
+            task.status = DownloadStatus.CANCELLED
+            self._cleanup_files(task.temp_path, task.meta_path)
+        return None
+
+    # -- Query --
+
+    def get_all_tasks(self, client_id: Optional[str] = None) -> list[dict]:
+        tasks = self.tasks.values()
+        if client_id is not None:
+            tasks = [t for t in tasks if t.client_id == client_id]
+        return [t.to_dict() for t in tasks]
+
+    def get_task(self, task_id: str) -> Optional[dict]:
+        task = self.tasks.get(task_id)
+        return task.to_dict() if task else None

blueprints/.glsl/Color_Balance_15.frag

@@ -1,90 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform float u_float0;
-uniform float u_float1;
-uniform float u_float2;
-uniform float u_float3;
-uniform float u_float4;
-uniform float u_float5;
-uniform float u_float6;
-uniform float u_float7;
-uniform float u_float8;
-uniform bool u_bool0;
-
-in vec2 v_texCoord;
-out vec4 fragColor;
-
-vec3 rgb2hsl(vec3 c) {
-    float maxC = max(c.r, max(c.g, c.b));
-    float minC = min(c.r, min(c.g, c.b));
-    float l = (maxC + minC) * 0.5;
-    if (maxC == minC) return vec3(0.0, 0.0, l);
-    float d = maxC - minC;
-    float s = l > 0.5 ? d / (2.0 - maxC - minC) : d / (maxC + minC);
-    float h;
-    if (maxC == c.r) {
-        h = (c.g - c.b) / d + (c.g < c.b ? 6.0 : 0.0);
-    } else if (maxC == c.g) {
-        h = (c.b - c.r) / d + 2.0;
-    } else {
-        h = (c.r - c.g) / d + 4.0;
-    }
-    h /= 6.0;
-    return vec3(h, s, l);
-}
-
-float hue2rgb(float p, float q, float t) {
-    if (t < 0.0) t += 1.0;
-    if (t > 1.0) t -= 1.0;
-    if (t < 1.0 / 6.0) return p + (q - p) * 6.0 * t;
-    if (t < 1.0 / 2.0) return q;
-    if (t < 2.0 / 3.0) return p + (q - p) * (2.0 / 3.0 - t) * 6.0;
-    return p;
-}
-
-vec3 hsl2rgb(vec3 hsl) {
-    float h = hsl.x, s = hsl.y, l = hsl.z;
-    if (s == 0.0) return vec3(l);
-    float q = l < 0.5 ? l * (1.0 + s) : l + s - l * s;
-    float p = 2.0 * l - q;
-    return vec3(
-        hue2rgb(p, q, h + 1.0 / 3.0),
-        hue2rgb(p, q, h),
-        hue2rgb(p, q, h - 1.0 / 3.0)
-    );
-}
-
-void main() {
-    vec4 tex = texture(u_image0, v_texCoord);
-    vec3 color = tex.rgb;
-
-    vec3 shadows = vec3(u_float0, u_float1, u_float2) * 0.01;
-    vec3 midtones = vec3(u_float3, u_float4, u_float5) * 0.01;
-    vec3 highlights = vec3(u_float6, u_float7, u_float8) * 0.01;
-
-    float maxC = max(color.r, max(color.g, color.b));
-    float minC = min(color.r, min(color.g, color.b));
-    float lightness = (maxC + minC) * 0.5;
-
-    // GIMP weight curves: linear ramps with constants a=0.25, b=0.333, scale=0.7
-    const float a = 0.25;
-    const float b = 0.333;
-    const float scale = 0.7;
-
-    float sw = clamp((lightness - b) / -a + 0.5, 0.0, 1.0) * scale;
-    float mw = clamp((lightness - b) / a + 0.5, 0.0, 1.0) *
-               clamp((lightness + b - 1.0) / -a + 0.5, 0.0, 1.0) * scale;
-    float hw = clamp((lightness + b - 1.0) / a + 0.5, 0.0, 1.0) * scale;
-
-    color += sw * shadows + mw * midtones + hw * highlights;
-
-    if (u_bool0) {
-        vec3 hsl = rgb2hsl(clamp(color, 0.0, 1.0));
-        hsl.z = lightness;
-        color = hsl2rgb(hsl);
-    }
-
-    fragColor = vec4(clamp(color, 0.0, 1.0), tex.a);
-}

blueprints/.glsl/Color_Curves_8.frag

@@ -1,49 +0,0 @@
-#version 300 es
-precision highp float;
-
-uniform sampler2D u_image0;
-uniform sampler2D u_curve0;  // RGB master curve (256x1 LUT)
-uniform sampler2D u_curve1;  // Red channel curve
-uniform sampler2D u_curve2;  // Green channel curve
-uniform sampler2D u_curve3;  // Blue channel curve
-
-in vec2 v_texCoord;
-layout(location = 0) out vec4 fragColor0;
-
-// GIMP-compatible curve lookup with manual linear interpolation.
-// Matches gimp_curve_map_value_inline() from gimpcurve-map.c:
-//   index = value * (n_samples - 1)
-//   f = fract(index)
-//   result = (1-f) * samples[floor] + f * samples[ceil]
-//
-// Uses texelFetch (NEAREST) to avoid GPU half-texel offset issues
-// that occur with texture() + GL_LINEAR on small 256x1 LUTs.
-float applyCurve(sampler2D curve, float value) {
-    value = clamp(value, 0.0, 1.0);
-
-    float pos = value * 255.0;
-    int lo = int(floor(pos));
-    int hi = min(lo + 1, 255);
-    float f = pos - float(lo);
-
-    float a = texelFetch(curve, ivec2(lo, 0), 0).r;
-    float b = texelFetch(curve, ivec2(hi, 0), 0).r;
-
-    return a + f * (b - a);
-}
-
-void main() {
-    vec4 color = texture(u_image0, v_texCoord);
-
-    // GIMP order: per-channel curves first, then RGB master curve.
-    // See gimp_curve_map_pixels() default case in gimpcurve-map.c:
-    //   dest = colors_curve( channel_curve( src ) )
-    float tmp_r = applyCurve(u_curve1, color.r);
-    float tmp_g = applyCurve(u_curve2, color.g);
-    float tmp_b = applyCurve(u_curve3, color.b);
-    color.r = applyCurve(u_curve0, tmp_r);
-    color.g = applyCurve(u_curve0, tmp_g);
-    color.b = applyCurve(u_curve0, tmp_b);
-
-    fragColor0 = vec4(color.rgb, color.a);
-}

blueprints/.glsl/Glow_30.frag

@@ -2,6 +2,7 @@
 precision mediump float;
 
 uniform sampler2D u_image0;
+uniform vec2 u_resolution;
 uniform int u_int0;      // Blend mode
 uniform int u_int1;      // Color tint
 uniform float u_float0;  // Intensity
@@ -74,7 +75,7 @@ void main() {
     float t0 = threshold - 0.15;
     float t1 = threshold + 0.15;
     
-    vec2 texelSize = 1.0 / vec2(textureSize(u_image0, 0));
+    vec2 texelSize = 1.0 / u_resolution;
     float radius2 = radius * radius;
     
     float sampleScale = clamp(radius * 0.75, 0.35, 1.0);

blueprints/.glsl/Image_Blur_1.frag

@@ -12,6 +12,7 @@ const int RADIAL_SAMPLES = 12;
 const float RADIAL_STRENGTH = 0.0003;
 
 uniform sampler2D u_image0;
+uniform vec2 u_resolution;
 uniform int u_int0;      // Blur type (BLUR_GAUSSIAN, BLUR_BOX, BLUR_RADIAL)
 uniform float u_float0;  // Blur radius/amount
 uniform int u_pass;      // Pass index (0 = horizontal, 1 = vertical)
@@ -24,7 +25,7 @@ float gaussian(float x, float sigma) {
 }
 
 void main() {
-    vec2 texelSize = 1.0 / vec2(textureSize(u_image0, 0));
+    vec2 texelSize = 1.0 / u_resolution;
     float radius = max(u_float0, 0.0);
 
     // Radial (angular) blur - single pass, doesn't use separable

blueprints/.glsl/Sharpen_23.frag

@@ -2,13 +2,14 @@
 precision highp float;
 
 uniform sampler2D u_image0;
+uniform vec2 u_resolution;
 uniform float u_float0;  // strength [0.0 – 2.0] typical: 0.3–1.0
 
 in vec2 v_texCoord;
 layout(location = 0) out vec4 fragColor0;
 
 void main() {
-    vec2 texel = 1.0 / vec2(textureSize(u_image0, 0));
+    vec2 texel = 1.0 / u_resolution;
     
     // Sample center and neighbors
     vec4 center = texture(u_image0, v_texCoord);

blueprints/.glsl/Unsharp_Mask_26.frag

@@ -2,6 +2,7 @@
 precision highp float;
 
 uniform sampler2D u_image0;
+uniform vec2 u_resolution;
 uniform float u_float0;  // amount    [0.0 - 3.0]  typical: 0.5-1.5
 uniform float u_float1;  // radius    [0.5 - 10.0] blur radius in pixels
 uniform float u_float2;  // threshold [0.0 - 0.1]  min difference to sharpen
@@ -18,7 +19,7 @@ float getLuminance(vec3 color) {
 }
 
 void main() {
-    vec2 texel = 1.0 / vec2(textureSize(u_image0, 0));
+    vec2 texel = 1.0 / u_resolution;
     float radius = max(u_float1, 0.5);
     float amount = u_float0;
     float threshold = u_float2;

blueprints/Color Curves.json

@@ -1,615 +0,0 @@
-{
-  "revision": 0,
-  "last_node_id": 10,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 10,
-      "type": "d5c462c8-1372-4af8-84f2-547c83470d04",
-      "pos": [
-        3610,
-        -2630
-      ],
-      "size": [
-        270,
-        420
-      ],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [
-        {
-          "label": "image",
-          "localized_name": "images.image0",
-          "name": "images.image0",
-          "type": "IMAGE",
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "label": "IMAGE",
-          "localized_name": "IMAGE0",
-          "name": "IMAGE0",
-          "type": "IMAGE",
-          "links": []
-        }
-      ],
-      "properties": {
-        "proxyWidgets": [
-          [
-            "4",
-            "curve"
-          ],
-          [
-            "5",
-            "curve"
-          ],
-          [
-            "6",
-            "curve"
-          ],
-          [
-            "7",
-            "curve"
-          ]
-        ]
-      },
-      "widgets_values": [],
-      "title": "Color Curves"
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "d5c462c8-1372-4af8-84f2-547c83470d04",
-        "version": 1,
-        "state": {
-          "lastGroupId": 0,
-          "lastNodeId": 9,
-          "lastLinkId": 38,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "Color Curves",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            2660,
-            -4500,
-            120,
-            60
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            4270,
-            -4500,
-            120,
-            60
-          ]
-        },
-        "inputs": [
-          {
-            "id": "abc345b7-f55e-4f32-a11d-3aa4c2b0936b",
-            "name": "images.image0",
-            "type": "IMAGE",
-            "linkIds": [
-              29,
-              34
-            ],
-            "localized_name": "images.image0",
-            "label": "image",
-            "pos": [
-              2760,
-              -4480
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "eb0ec079-46da-4408-8263-9ef85569d33d",
-            "name": "IMAGE0",
-            "type": "IMAGE",
-            "linkIds": [
-              28
-            ],
-            "localized_name": "IMAGE0",
-            "label": "IMAGE",
-            "pos": [
-              4290,
-              -4480
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 4,
-            "type": "CurveEditor",
-            "pos": [
-              3060,
-              -4500
-            ],
-            "size": [
-              270,
-              200
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "curve",
-                "localized_name": "curve",
-                "name": "curve",
-                "type": "CURVE",
-                "widget": {
-                  "name": "curve"
-                },
-                "link": null
-              },
-              {
-                "label": "histogram",
-                "localized_name": "histogram",
-                "name": "histogram",
-                "type": "HISTOGRAM",
-                "shape": 7,
-                "link": 35
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "CURVE",
-                "name": "CURVE",
-                "type": "CURVE",
-                "links": [
-                  30
-                ]
-              }
-            ],
-            "title": "RGB Master",
-            "properties": {
-              "Node name for S&R": "CurveEditor"
-            },
-            "widgets_values": []
-          },
-          {
-            "id": 5,
-            "type": "CurveEditor",
-            "pos": [
-              3060,
-              -4250
-            ],
-            "size": [
-              270,
-              200
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "curve",
-                "localized_name": "curve",
-                "name": "curve",
-                "type": "CURVE",
-                "widget": {
-                  "name": "curve"
-                },
-                "link": null
-              },
-              {
-                "label": "histogram",
-                "localized_name": "histogram",
-                "name": "histogram",
-                "type": "HISTOGRAM",
-                "shape": 7,
-                "link": 36
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "CURVE",
-                "name": "CURVE",
-                "type": "CURVE",
-                "links": [
-                  31
-                ]
-              }
-            ],
-            "title": "Red",
-            "properties": {
-              "Node name for S&R": "CurveEditor"
-            },
-            "widgets_values": []
-          },
-          {
-            "id": 6,
-            "type": "CurveEditor",
-            "pos": [
-              3060,
-              -4000
-            ],
-            "size": [
-              270,
-              200
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "curve",
-                "localized_name": "curve",
-                "name": "curve",
-                "type": "CURVE",
-                "widget": {
-                  "name": "curve"
-                },
-                "link": null
-              },
-              {
-                "label": "histogram",
-                "localized_name": "histogram",
-                "name": "histogram",
-                "type": "HISTOGRAM",
-                "shape": 7,
-                "link": 37
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "CURVE",
-                "name": "CURVE",
-                "type": "CURVE",
-                "links": [
-                  32
-                ]
-              }
-            ],
-            "title": "Green",
-            "properties": {
-              "Node name for S&R": "CurveEditor"
-            },
-            "widgets_values": []
-          },
-          {
-            "id": 7,
-            "type": "CurveEditor",
-            "pos": [
-              3060,
-              -3750
-            ],
-            "size": [
-              270,
-              200
-            ],
-            "flags": {},
-            "order": 3,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "curve",
-                "localized_name": "curve",
-                "name": "curve",
-                "type": "CURVE",
-                "widget": {
-                  "name": "curve"
-                },
-                "link": null
-              },
-              {
-                "label": "histogram",
-                "localized_name": "histogram",
-                "name": "histogram",
-                "type": "HISTOGRAM",
-                "shape": 7,
-                "link": 38
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "CURVE",
-                "name": "CURVE",
-                "type": "CURVE",
-                "links": [
-                  33
-                ]
-              }
-            ],
-            "title": "Blue",
-            "properties": {
-              "Node name for S&R": "CurveEditor"
-            },
-            "widgets_values": []
-          },
-          {
-            "id": 8,
-            "type": "GLSLShader",
-            "pos": [
-              3590,
-              -4500
-            ],
-            "size": [
-              420,
-              500
-            ],
-            "flags": {},
-            "order": 4,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "image0",
-                "localized_name": "images.image0",
-                "name": "images.image0",
-                "type": "IMAGE",
-                "link": 29
-              },
-              {
-                "label": "image1",
-                "localized_name": "images.image1",
-                "name": "images.image1",
-                "shape": 7,
-                "type": "IMAGE",
-                "link": null
-              },
-              {
-                "label": "u_curve0",
-                "localized_name": "curves.u_curve0",
-                "name": "curves.u_curve0",
-                "shape": 7,
-                "type": "CURVE",
-                "link": 30
-              },
-              {
-                "label": "u_curve1",
-                "localized_name": "curves.u_curve1",
-                "name": "curves.u_curve1",
-                "shape": 7,
-                "type": "CURVE",
-                "link": 31
-              },
-              {
-                "label": "u_curve2",
-                "localized_name": "curves.u_curve2",
-                "name": "curves.u_curve2",
-                "shape": 7,
-                "type": "CURVE",
-                "link": 32
-              },
-              {
-                "label": "u_curve3",
-                "localized_name": "curves.u_curve3",
-                "name": "curves.u_curve3",
-                "shape": 7,
-                "type": "CURVE",
-                "link": 33
-              },
-              {
-                "localized_name": "fragment_shader",
-                "name": "fragment_shader",
-                "type": "STRING",
-                "widget": {
-                  "name": "fragment_shader"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "size_mode",
-                "name": "size_mode",
-                "type": "COMFY_DYNAMICCOMBO_V3",
-                "widget": {
-                  "name": "size_mode"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "IMAGE0",
-                "name": "IMAGE0",
-                "type": "IMAGE",
-                "links": [
-                  28
-                ]
-              },
-              {
-                "localized_name": "IMAGE1",
-                "name": "IMAGE1",
-                "type": "IMAGE",
-                "links": null
-              },
-              {
-                "localized_name": "IMAGE2",
-                "name": "IMAGE2",
-                "type": "IMAGE",
-                "links": null
-              },
-              {
-                "localized_name": "IMAGE3",
-                "name": "IMAGE3",
-                "type": "IMAGE",
-                "links": null
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "GLSLShader"
-            },
-            "widgets_values": [
-              "#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform sampler2D u_curve0;  // RGB master curve (256x1 LUT)\nuniform sampler2D u_curve1;  // Red channel curve\nuniform sampler2D u_curve2;  // Green channel curve\nuniform sampler2D u_curve3;  // Blue channel curve\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\n\n// GIMP-compatible curve lookup with manual linear interpolation.\n// Matches gimp_curve_map_value_inline() from gimpcurve-map.c:\n//   index = value * (n_samples - 1)\n//   f = fract(index)\n//   result = (1-f) * samples[floor] + f * samples[ceil]\n//\n// Uses texelFetch (NEAREST) to avoid GPU half-texel offset issues\n// that occur with texture() + GL_LINEAR on small 256x1 LUTs.\nfloat applyCurve(sampler2D curve, float value) {\n    value = clamp(value, 0.0, 1.0);\n\n    float pos = value * 255.0;\n    int lo = int(floor(pos));\n    int hi = min(lo + 1, 255);\n    float f = pos - float(lo);\n\n    float a = texelFetch(curve, ivec2(lo, 0), 0).r;\n    float b = texelFetch(curve, ivec2(hi, 0), 0).r;\n\n    return a + f * (b - a);\n}\n\nvoid main() {\n    vec4 color = texture(u_image0, v_texCoord);\n\n    // GIMP order: per-channel curves first, then RGB master curve.\n    // See gimp_curve_map_pixels() default case in gimpcurve-map.c:\n    //   dest = colors_curve( channel_curve( src ) )\n    float tmp_r = applyCurve(u_curve1, color.r);\n    float tmp_g = applyCurve(u_curve2, color.g);\n    float tmp_b = applyCurve(u_curve3, color.b);\n    color.r = applyCurve(u_curve0, tmp_r);\n    color.g = applyCurve(u_curve0, tmp_g);\n    color.b = applyCurve(u_curve0, tmp_b);\n\n    fragColor0 = vec4(color.rgb, color.a);\n}\n",
-              "from_input"
-            ]
-          },
-          {
-            "id": 9,
-            "type": "ImageHistogram",
-            "pos": [
-              2800,
-              -4300
-            ],
-            "size": [
-              210,
-              150
-            ],
-            "flags": {},
-            "order": 5,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "image",
-                "localized_name": "image",
-                "name": "image",
-                "type": "IMAGE",
-                "link": 34
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "HISTOGRAM",
-                "name": "rgb",
-                "type": "HISTOGRAM",
-                "links": [
-                  35
-                ]
-              },
-              {
-                "localized_name": "HISTOGRAM",
-                "name": "luminance",
-                "type": "HISTOGRAM",
-                "links": []
-              },
-              {
-                "localized_name": "HISTOGRAM",
-                "name": "red",
-                "type": "HISTOGRAM",
-                "links": [
-                  36
-                ]
-              },
-              {
-                "localized_name": "HISTOGRAM",
-                "name": "green",
-                "type": "HISTOGRAM",
-                "links": [
-                  37
-                ]
-              },
-              {
-                "localized_name": "HISTOGRAM",
-                "name": "blue",
-                "type": "HISTOGRAM",
-                "links": [
-                  38
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "ImageHistogram"
-            },
-            "widgets_values": []
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 29,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 8,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 28,
-            "origin_id": 8,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 30,
-            "origin_id": 4,
-            "origin_slot": 0,
-            "target_id": 8,
-            "target_slot": 2,
-            "type": "CURVE"
-          },
-          {
-            "id": 31,
-            "origin_id": 5,
-            "origin_slot": 0,
-            "target_id": 8,
-            "target_slot": 3,
-            "type": "CURVE"
-          },
-          {
-            "id": 32,
-            "origin_id": 6,
-            "origin_slot": 0,
-            "target_id": 8,
-            "target_slot": 4,
-            "type": "CURVE"
-          },
-          {
-            "id": 33,
-            "origin_id": 7,
-            "origin_slot": 0,
-            "target_id": 8,
-            "target_slot": 5,
-            "type": "CURVE"
-          },
-          {
-            "id": 34,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 9,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 35,
-            "origin_id": 9,
-            "origin_slot": 0,
-            "target_id": 4,
-            "target_slot": 1,
-            "type": "HISTOGRAM"
-          },
-          {
-            "id": 36,
-            "origin_id": 9,
-            "origin_slot": 2,
-            "target_id": 5,
-            "target_slot": 1,
-            "type": "HISTOGRAM"
-          },
-          {
-            "id": 37,
-            "origin_id": 9,
-            "origin_slot": 3,
-            "target_id": 6,
-            "target_slot": 1,
-            "type": "HISTOGRAM"
-          },
-          {
-            "id": 38,
-            "origin_id": 9,
-            "origin_slot": 4,
-            "target_id": 7,
-            "target_slot": 1,
-            "type": "HISTOGRAM"
-          }
-        ],
-        "extra": {
-          "workflowRendererVersion": "LG"
-        },
-        "category": "Image Tools/Color adjust"
-      }
-    ]
-  }
-}

blueprints/Image Channels.json

@@ -1,322 +1 @@
-{
-  "revision": 0,
-  "last_node_id": 29,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 29,
-      "type": "4c9d6ea4-b912-40e5-8766-6793a9758c53",
-      "pos": [
-        1970,
-        -230
-      ],
-      "size": [
-        180,
-        86
-      ],
-      "flags": {},
-      "order": 5,
-      "mode": 0,
-      "inputs": [
-        {
-          "label": "image",
-          "localized_name": "images.image0",
-          "name": "images.image0",
-          "type": "IMAGE",
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "label": "R",
-          "localized_name": "IMAGE0",
-          "name": "IMAGE0",
-          "type": "IMAGE",
-          "links": []
-        },
-        {
-          "label": "G",
-          "localized_name": "IMAGE1",
-          "name": "IMAGE1",
-          "type": "IMAGE",
-          "links": []
-        },
-        {
-          "label": "B",
-          "localized_name": "IMAGE2",
-          "name": "IMAGE2",
-          "type": "IMAGE",
-          "links": []
-        },
-        {
-          "label": "A",
-          "localized_name": "IMAGE3",
-          "name": "IMAGE3",
-          "type": "IMAGE",
-          "links": []
-        }
-      ],
-      "title": "Image Channels",
-      "properties": {
-        "proxyWidgets": []
-      },
-      "widgets_values": []
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "4c9d6ea4-b912-40e5-8766-6793a9758c53",
-        "version": 1,
-        "state": {
-          "lastGroupId": 0,
-          "lastNodeId": 28,
-          "lastLinkId": 39,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "Image Channels",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            1820,
-            -185,
-            120,
-            60
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            2460,
-            -215,
-            120,
-            120
-          ]
-        },
-        "inputs": [
-          {
-            "id": "3522932b-2d86-4a1f-a02a-cb29f3a9d7fe",
-            "name": "images.image0",
-            "type": "IMAGE",
-            "linkIds": [
-              39
-            ],
-            "localized_name": "images.image0",
-            "label": "image",
-            "pos": [
-              1920,
-              -165
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "605cb9c3-b065-4d9b-81d2-3ec331889b2b",
-            "name": "IMAGE0",
-            "type": "IMAGE",
-            "linkIds": [
-              26
-            ],
-            "localized_name": "IMAGE0",
-            "label": "R",
-            "pos": [
-              2480,
-              -195
-            ]
-          },
-          {
-            "id": "fb44a77e-0522-43e9-9527-82e7465b3596",
-            "name": "IMAGE1",
-            "type": "IMAGE",
-            "linkIds": [
-              27
-            ],
-            "localized_name": "IMAGE1",
-            "label": "G",
-            "pos": [
-              2480,
-              -175
-            ]
-          },
-          {
-            "id": "81460ee6-0131-402a-874f-6bf3001fc4ff",
-            "name": "IMAGE2",
-            "type": "IMAGE",
-            "linkIds": [
-              28
-            ],
-            "localized_name": "IMAGE2",
-            "label": "B",
-            "pos": [
-              2480,
-              -155
-            ]
-          },
-          {
-            "id": "ae690246-80d4-4951-b1d9-9306d8a77417",
-            "name": "IMAGE3",
-            "type": "IMAGE",
-            "linkIds": [
-              29
-            ],
-            "localized_name": "IMAGE3",
-            "label": "A",
-            "pos": [
-              2480,
-              -135
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 23,
-            "type": "GLSLShader",
-            "pos": [
-              2000,
-              -330
-            ],
-            "size": [
-              400,
-              172
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "image",
-                "localized_name": "images.image0",
-                "name": "images.image0",
-                "type": "IMAGE",
-                "link": 39
-              },
-              {
-                "localized_name": "fragment_shader",
-                "name": "fragment_shader",
-                "type": "STRING",
-                "widget": {
-                  "name": "fragment_shader"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "size_mode",
-                "name": "size_mode",
-                "type": "COMFY_DYNAMICCOMBO_V3",
-                "widget": {
-                  "name": "size_mode"
-                },
-                "link": null
-              },
-              {
-                "label": "image1",
-                "localized_name": "images.image1",
-                "name": "images.image1",
-                "shape": 7,
-                "type": "IMAGE",
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "label": "R",
-                "localized_name": "IMAGE0",
-                "name": "IMAGE0",
-                "type": "IMAGE",
-                "links": [
-                  26
-                ]
-              },
-              {
-                "label": "G",
-                "localized_name": "IMAGE1",
-                "name": "IMAGE1",
-                "type": "IMAGE",
-                "links": [
-                  27
-                ]
-              },
-              {
-                "label": "B",
-                "localized_name": "IMAGE2",
-                "name": "IMAGE2",
-                "type": "IMAGE",
-                "links": [
-                  28
-                ]
-              },
-              {
-                "label": "A",
-                "localized_name": "IMAGE3",
-                "name": "IMAGE3",
-                "type": "IMAGE",
-                "links": [
-                  29
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "GLSLShader"
-            },
-            "widgets_values": [
-              "#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\nlayout(location = 1) out vec4 fragColor1;\nlayout(location = 2) out vec4 fragColor2;\nlayout(location = 3) out vec4 fragColor3;\n\nvoid main() {\n  vec4 color = texture(u_image0, v_texCoord);\n  // Output each channel as grayscale to separate render targets\n  fragColor0 = vec4(vec3(color.r), 1.0);  // Red channel\n  fragColor1 = vec4(vec3(color.g), 1.0);  // Green channel\n  fragColor2 = vec4(vec3(color.b), 1.0);  // Blue channel\n  fragColor3 = vec4(vec3(color.a), 1.0);  // Alpha channel\n}\n",
-              "from_input"
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 39,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 23,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 26,
-            "origin_id": 23,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 27,
-            "origin_id": 23,
-            "origin_slot": 1,
-            "target_id": -20,
-            "target_slot": 1,
-            "type": "IMAGE"
-          },
-          {
-            "id": 28,
-            "origin_id": 23,
-            "origin_slot": 2,
-            "target_id": -20,
-            "target_slot": 2,
-            "type": "IMAGE"
-          },
-          {
-            "id": 29,
-            "origin_id": 23,
-            "origin_slot": 3,
-            "target_id": -20,
-            "target_slot": 3,
-            "type": "IMAGE"
-          }
-        ],
-        "extra": {
-          "workflowRendererVersion": "LG"
-        },
-        "category": "Image Tools/Color adjust"
-      }
-    ]
-  }
-}
+{"revision": 0, "last_node_id": 29, "last_link_id": 0, "nodes": [{"id": 29, "type": "4c9d6ea4-b912-40e5-8766-6793a9758c53", "pos": [1970, -230], "size": [180, 86], "flags": {}, "order": 5, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": null}], "outputs": [{"label": "R", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": []}, {"label": "G", "localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": []}, {"label": "B", "localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": []}, {"label": "A", "localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": []}], "title": "Image Channels", "properties": {"proxyWidgets": []}, "widgets_values": []}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "4c9d6ea4-b912-40e5-8766-6793a9758c53", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 28, "lastLinkId": 39, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Image Channels", "inputNode": {"id": -10, "bounding": [1820, -185, 120, 60]}, "outputNode": {"id": -20, "bounding": [2460, -215, 120, 120]}, "inputs": [{"id": "3522932b-2d86-4a1f-a02a-cb29f3a9d7fe", "name": "images.image0", "type": "IMAGE", "linkIds": [39], "localized_name": "images.image0", "label": "image", "pos": [1920, -165]}], "outputs": [{"id": "605cb9c3-b065-4d9b-81d2-3ec331889b2b", "name": "IMAGE0", "type": "IMAGE", "linkIds": [26], "localized_name": "IMAGE0", "label": "R", "pos": [2480, -195]}, {"id": "fb44a77e-0522-43e9-9527-82e7465b3596", "name": "IMAGE1", "type": "IMAGE", "linkIds": [27], "localized_name": "IMAGE1", "label": "G", "pos": [2480, -175]}, {"id": "81460ee6-0131-402a-874f-6bf3001fc4ff", "name": "IMAGE2", "type": "IMAGE", "linkIds": [28], "localized_name": "IMAGE2", "label": "B", "pos": [2480, -155]}, {"id": "ae690246-80d4-4951-b1d9-9306d8a77417", "name": "IMAGE3", "type": "IMAGE", "linkIds": [29], "localized_name": "IMAGE3", "label": "A", "pos": [2480, -135]}], "widgets": [], "nodes": [{"id": 23, "type": "GLSLShader", "pos": [2000, -330], "size": [400, 172], "flags": {}, "order": 0, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": 39}, {"localized_name": "fragment_shader", "name": "fragment_shader", "type": "STRING", "widget": {"name": "fragment_shader"}, "link": null}, {"localized_name": "size_mode", "name": "size_mode", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "size_mode"}, "link": null}, {"label": "image1", "localized_name": "images.image1", "name": "images.image1", "shape": 7, "type": "IMAGE", "link": null}], "outputs": [{"label": "R", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": [26]}, {"label": "G", "localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": [27]}, {"label": "B", "localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": [28]}, {"label": "A", "localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": [29]}], "properties": {"Node name for S&R": "GLSLShader"}, "widgets_values": ["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\nlayout(location = 1) out vec4 fragColor1;\nlayout(location = 2) out vec4 fragColor2;\nlayout(location = 3) out vec4 fragColor3;\n\nvoid main() {\n  vec4 color = texture(u_image0, v_texCoord);\n  // Output each channel as grayscale to separate render targets\n  fragColor0 = vec4(vec3(color.r), 1.0);  // Red channel\n  fragColor1 = vec4(vec3(color.g), 1.0);  // Green channel\n  fragColor2 = vec4(vec3(color.b), 1.0);  // Blue channel\n  fragColor3 = vec4(vec3(color.a), 1.0);  // Alpha channel\n}\n", "from_input"]}], "groups": [], "links": [{"id": 39, "origin_id": -10, "origin_slot": 0, "target_id": 23, "target_slot": 0, "type": "IMAGE"}, {"id": 26, "origin_id": 23, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "IMAGE"}, {"id": 27, "origin_id": 23, "origin_slot": 1, "target_id": -20, "target_slot": 1, "type": "IMAGE"}, {"id": 28, "origin_id": 23, "origin_slot": 2, "target_id": -20, "target_slot": 2, "type": "IMAGE"}, {"id": 29, "origin_id": 23, "origin_slot": 3, "target_id": -20, "target_slot": 3, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}, "category": "Image Tools/Color adjust"}]}}

blueprints/Prompt Enhance.json

@@ -1,278 +1 @@
-{
-  "revision": 0,
-  "last_node_id": 15,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 15,
-      "type": "24d8bbfd-39d4-4774-bff0-3de40cc7a471",
-      "pos": [
-        -1490,
-        2040
-      ],
-      "size": [
-        400,
-        260
-      ],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "prompt",
-          "type": "STRING",
-          "widget": {
-            "name": "prompt"
-          },
-          "link": null
-        },
-        {
-          "label": "reference images",
-          "name": "images",
-          "type": "IMAGE",
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "name": "STRING",
-          "type": "STRING",
-          "links": null
-        }
-      ],
-      "title": "Prompt Enhance",
-      "properties": {
-        "proxyWidgets": [
-          [
-            "-1",
-            "prompt"
-          ]
-        ],
-        "cnr_id": "comfy-core",
-        "ver": "0.14.1"
-      },
-      "widgets_values": [
-        ""
-      ]
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "24d8bbfd-39d4-4774-bff0-3de40cc7a471",
-        "version": 1,
-        "state": {
-          "lastGroupId": 0,
-          "lastNodeId": 15,
-          "lastLinkId": 14,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "Prompt Enhance",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            -2170,
-            2110,
-            138.876953125,
-            80
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            -640,
-            2110,
-            120,
-            60
-          ]
-        },
-        "inputs": [
-          {
-            "id": "aeab7216-00e0-4528-a09b-bba50845c5a6",
-            "name": "prompt",
-            "type": "STRING",
-            "linkIds": [
-              11
-            ],
-            "pos": [
-              -2051.123046875,
-              2130
-            ]
-          },
-          {
-            "id": "7b73fd36-aa31-4771-9066-f6c83879994b",
-            "name": "images",
-            "type": "IMAGE",
-            "linkIds": [
-              14
-            ],
-            "label": "reference images",
-            "pos": [
-              -2051.123046875,
-              2150
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "c7b0d930-68a1-48d1-b496-0519e5837064",
-            "name": "STRING",
-            "type": "STRING",
-            "linkIds": [
-              13
-            ],
-            "pos": [
-              -620,
-              2130
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 11,
-            "type": "GeminiNode",
-            "pos": [
-              -1560,
-              1990
-            ],
-            "size": [
-              470,
-              470
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "images",
-                "name": "images",
-                "shape": 7,
-                "type": "IMAGE",
-                "link": 14
-              },
-              {
-                "localized_name": "audio",
-                "name": "audio",
-                "shape": 7,
-                "type": "AUDIO",
-                "link": null
-              },
-              {
-                "localized_name": "video",
-                "name": "video",
-                "shape": 7,
-                "type": "VIDEO",
-                "link": null
-              },
-              {
-                "localized_name": "files",
-                "name": "files",
-                "shape": 7,
-                "type": "GEMINI_INPUT_FILES",
-                "link": null
-              },
-              {
-                "localized_name": "prompt",
-                "name": "prompt",
-                "type": "STRING",
-                "widget": {
-                  "name": "prompt"
-                },
-                "link": 11
-              },
-              {
-                "localized_name": "model",
-                "name": "model",
-                "type": "COMBO",
-                "widget": {
-                  "name": "model"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "seed",
-                "name": "seed",
-                "type": "INT",
-                "widget": {
-                  "name": "seed"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "system_prompt",
-                "name": "system_prompt",
-                "shape": 7,
-                "type": "STRING",
-                "widget": {
-                  "name": "system_prompt"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "STRING",
-                "name": "STRING",
-                "type": "STRING",
-                "links": [
-                  13
-                ]
-              }
-            ],
-            "properties": {
-              "cnr_id": "comfy-core",
-              "ver": "0.14.1",
-              "Node name for S&R": "GeminiNode"
-            },
-            "widgets_values": [
-              "",
-              "gemini-3-pro-preview",
-              42,
-              "randomize",
-              "You are an expert in prompt writing.\nBased on the input, rewrite the user's input into a detailed prompt.\nincluding camera settings, lighting, composition, and style.\nReturn the prompt only"
-            ],
-            "color": "#432",
-            "bgcolor": "#653"
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 11,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 11,
-            "target_slot": 4,
-            "type": "STRING"
-          },
-          {
-            "id": 13,
-            "origin_id": 11,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "STRING"
-          },
-          {
-            "id": 14,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 11,
-            "target_slot": 0,
-            "type": "IMAGE"
-          }
-        ],
-        "extra": {
-          "workflowRendererVersion": "LG"
-        },
-        "category": "Text generation/Prompt enhance"
-      }
-    ]
-  },
-  "extra": {}
-}
+{"revision": 0, "last_node_id": 15, "last_link_id": 0, "nodes": [{"id": 15, "type": "24d8bbfd-39d4-4774-bff0-3de40cc7a471", "pos": [-1490, 2040], "size": [400, 260], "flags": {}, "order": 0, "mode": 0, "inputs": [{"name": "prompt", "type": "STRING", "widget": {"name": "prompt"}, "link": null}, {"label": "reference images", "name": "images", "type": "IMAGE", "link": null}], "outputs": [{"name": "STRING", "type": "STRING", "links": null}], "title": "Prompt Enhance", "properties": {"proxyWidgets": [["-1", "prompt"]], "cnr_id": "comfy-core", "ver": "0.14.1"}, "widgets_values": [""]}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "24d8bbfd-39d4-4774-bff0-3de40cc7a471", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 15, "lastLinkId": 14, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Prompt Enhance", "inputNode": {"id": -10, "bounding": [-2170, 2110, 138.876953125, 80]}, "outputNode": {"id": -20, "bounding": [-640, 2110, 120, 60]}, "inputs": [{"id": "aeab7216-00e0-4528-a09b-bba50845c5a6", "name": "prompt", "type": "STRING", "linkIds": [11], "pos": [-2051.123046875, 2130]}, {"id": "7b73fd36-aa31-4771-9066-f6c83879994b", "name": "images", "type": "IMAGE", "linkIds": [14], "label": "reference images", "pos": [-2051.123046875, 2150]}], "outputs": [{"id": "c7b0d930-68a1-48d1-b496-0519e5837064", "name": "STRING", "type": "STRING", "linkIds": [13], "pos": [-620, 2130]}], "widgets": [], "nodes": [{"id": 11, "type": "GeminiNode", "pos": [-1560, 1990], "size": [470, 470], "flags": {}, "order": 0, "mode": 0, "inputs": [{"localized_name": "images", "name": "images", "shape": 7, "type": "IMAGE", "link": 14}, {"localized_name": "audio", "name": "audio", "shape": 7, "type": "AUDIO", "link": null}, {"localized_name": "video", "name": "video", "shape": 7, "type": "VIDEO", "link": null}, {"localized_name": "files", "name": "files", "shape": 7, "type": "GEMINI_INPUT_FILES", "link": null}, {"localized_name": "prompt", "name": "prompt", "type": "STRING", "widget": {"name": "prompt"}, "link": 11}, {"localized_name": "model", "name": "model", "type": "COMBO", "widget": {"name": "model"}, "link": null}, {"localized_name": "seed", "name": "seed", "type": "INT", "widget": {"name": "seed"}, "link": null}, {"localized_name": "system_prompt", "name": "system_prompt", "shape": 7, "type": "STRING", "widget": {"name": "system_prompt"}, "link": null}], "outputs": [{"localized_name": "STRING", "name": "STRING", "type": "STRING", "links": [13]}], "properties": {"cnr_id": "comfy-core", "ver": "0.14.1", "Node name for S&R": "GeminiNode"}, "widgets_values": ["", "gemini-3-pro-preview", 42, "randomize", "You are an expert in prompt writing.\nBased on the input, rewrite the user's input into a detailed prompt.\nincluding camera settings, lighting, composition, and style.\nReturn the prompt only"], "color": "#432", "bgcolor": "#653"}], "groups": [], "links": [{"id": 11, "origin_id": -10, "origin_slot": 0, "target_id": 11, "target_slot": 4, "type": "STRING"}, {"id": 13, "origin_id": 11, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "STRING"}, {"id": 14, "origin_id": -10, "origin_slot": 1, "target_id": 11, "target_slot": 0, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}, "category": "Text generation/Prompt enhance"}]}, "extra": {}}

blueprints/Sharpen.json

@@ -1,309 +1 @@
-{
-  "revision": 0,
-  "last_node_id": 25,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 25,
-      "type": "621ba4e2-22a8-482d-a369-023753198b7b",
-      "pos": [
-        4610,
-        -790
-      ],
-      "size": [
-        230,
-        58
-      ],
-      "flags": {},
-      "order": 4,
-      "mode": 0,
-      "inputs": [
-        {
-          "label": "image",
-          "localized_name": "images.image0",
-          "name": "images.image0",
-          "type": "IMAGE",
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "label": "IMAGE",
-          "localized_name": "IMAGE0",
-          "name": "IMAGE0",
-          "type": "IMAGE",
-          "links": []
-        }
-      ],
-      "title": "Sharpen",
-      "properties": {
-        "proxyWidgets": [
-          [
-            "24",
-            "value"
-          ]
-        ]
-      },
-      "widgets_values": []
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "621ba4e2-22a8-482d-a369-023753198b7b",
-        "version": 1,
-        "state": {
-          "lastGroupId": 0,
-          "lastNodeId": 24,
-          "lastLinkId": 36,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "Sharpen",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            4090,
-            -825,
-            120,
-            60
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            5150,
-            -825,
-            120,
-            60
-          ]
-        },
-        "inputs": [
-          {
-            "id": "37011fb7-14b7-4e0e-b1a0-6a02e8da1fd7",
-            "name": "images.image0",
-            "type": "IMAGE",
-            "linkIds": [
-              34
-            ],
-            "localized_name": "images.image0",
-            "label": "image",
-            "pos": [
-              4190,
-              -805
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "e9182b3f-635c-4cd4-a152-4b4be17ae4b9",
-            "name": "IMAGE0",
-            "type": "IMAGE",
-            "linkIds": [
-              35
-            ],
-            "localized_name": "IMAGE0",
-            "label": "IMAGE",
-            "pos": [
-              5170,
-              -805
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 24,
-            "type": "PrimitiveFloat",
-            "pos": [
-              4280,
-              -1240
-            ],
-            "size": [
-              270,
-              58
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "strength",
-                "localized_name": "value",
-                "name": "value",
-                "type": "FLOAT",
-                "widget": {
-                  "name": "value"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "FLOAT",
-                "name": "FLOAT",
-                "type": "FLOAT",
-                "links": [
-                  36
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "PrimitiveFloat",
-              "min": 0,
-              "max": 3,
-              "precision": 2,
-              "step": 0.05
-            },
-            "widgets_values": [
-              0.5
-            ]
-          },
-          {
-            "id": 23,
-            "type": "GLSLShader",
-            "pos": [
-              4570,
-              -1240
-            ],
-            "size": [
-              370,
-              192
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "image0",
-                "localized_name": "images.image0",
-                "name": "images.image0",
-                "type": "IMAGE",
-                "link": 34
-              },
-              {
-                "label": "image1",
-                "localized_name": "images.image1",
-                "name": "images.image1",
-                "shape": 7,
-                "type": "IMAGE",
-                "link": null
-              },
-              {
-                "label": "u_float0",
-                "localized_name": "floats.u_float0",
-                "name": "floats.u_float0",
-                "shape": 7,
-                "type": "FLOAT",
-                "link": 36
-              },
-              {
-                "label": "u_float1",
-                "localized_name": "floats.u_float1",
-                "name": "floats.u_float1",
-                "shape": 7,
-                "type": "FLOAT",
-                "link": null
-              },
-              {
-                "label": "u_int0",
-                "localized_name": "ints.u_int0",
-                "name": "ints.u_int0",
-                "shape": 7,
-                "type": "INT",
-                "link": null
-              },
-              {
-                "localized_name": "fragment_shader",
-                "name": "fragment_shader",
-                "type": "STRING",
-                "widget": {
-                  "name": "fragment_shader"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "size_mode",
-                "name": "size_mode",
-                "type": "COMFY_DYNAMICCOMBO_V3",
-                "widget": {
-                  "name": "size_mode"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "IMAGE0",
-                "name": "IMAGE0",
-                "type": "IMAGE",
-                "links": [
-                  35
-                ]
-              },
-              {
-                "localized_name": "IMAGE1",
-                "name": "IMAGE1",
-                "type": "IMAGE",
-                "links": null
-              },
-              {
-                "localized_name": "IMAGE2",
-                "name": "IMAGE2",
-                "type": "IMAGE",
-                "links": null
-              },
-              {
-                "localized_name": "IMAGE3",
-                "name": "IMAGE3",
-                "type": "IMAGE",
-                "links": null
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "GLSLShader"
-            },
-            "widgets_values": [
-              "#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform float u_float0;  // strength [0.0 – 2.0] typical: 0.3–1.0\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\n\nvoid main() {\n    vec2 texel = 1.0 / vec2(textureSize(u_image0, 0));\n    \n    // Sample center and neighbors\n    vec4 center = texture(u_image0, v_texCoord);\n    vec4 top    = texture(u_image0, v_texCoord + vec2( 0.0, -texel.y));\n    vec4 bottom = texture(u_image0, v_texCoord + vec2( 0.0,  texel.y));\n    vec4 left   = texture(u_image0, v_texCoord + vec2(-texel.x,  0.0));\n    vec4 right  = texture(u_image0, v_texCoord + vec2( texel.x,  0.0));\n    \n    // Edge enhancement (Laplacian)\n    vec4 edges = center * 4.0 - top - bottom - left - right;\n    \n    // Add edges back scaled by strength\n    vec4 sharpened = center + edges * u_float0;\n    \n    fragColor0 = vec4(clamp(sharpened.rgb, 0.0, 1.0), center.a);\n}",
-              "from_input"
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 36,
-            "origin_id": 24,
-            "origin_slot": 0,
-            "target_id": 23,
-            "target_slot": 2,
-            "type": "FLOAT"
-          },
-          {
-            "id": 34,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 23,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 35,
-            "origin_id": 23,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "IMAGE"
-          }
-        ],
-        "extra": {
-          "workflowRendererVersion": "LG"
-        },
-        "category": "Image Tools/Sharpen"
-      }
-    ]
-  }
-}
+{"revision": 0, "last_node_id": 25, "last_link_id": 0, "nodes": [{"id": 25, "type": "621ba4e2-22a8-482d-a369-023753198b7b", "pos": [4610, -790], "size": [230, 58], "flags": {}, "order": 4, "mode": 0, "inputs": [{"label": "image", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": null}], "outputs": [{"label": "IMAGE", "localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": []}], "title": "Sharpen", "properties": {"proxyWidgets": [["24", "value"]]}, "widgets_values": []}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "621ba4e2-22a8-482d-a369-023753198b7b", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 24, "lastLinkId": 36, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Sharpen", "inputNode": {"id": -10, "bounding": [4090, -825, 120, 60]}, "outputNode": {"id": -20, "bounding": [5150, -825, 120, 60]}, "inputs": [{"id": "37011fb7-14b7-4e0e-b1a0-6a02e8da1fd7", "name": "images.image0", "type": "IMAGE", "linkIds": [34], "localized_name": "images.image0", "label": "image", "pos": [4190, -805]}], "outputs": [{"id": "e9182b3f-635c-4cd4-a152-4b4be17ae4b9", "name": "IMAGE0", "type": "IMAGE", "linkIds": [35], "localized_name": "IMAGE0", "label": "IMAGE", "pos": [5170, -805]}], "widgets": [], "nodes": [{"id": 24, "type": "PrimitiveFloat", "pos": [4280, -1240], "size": [270, 58], "flags": {}, "order": 0, "mode": 0, "inputs": [{"label": "strength", "localized_name": "value", "name": "value", "type": "FLOAT", "widget": {"name": "value"}, "link": null}], "outputs": [{"localized_name": "FLOAT", "name": "FLOAT", "type": "FLOAT", "links": [36]}], "properties": {"Node name for S&R": "PrimitiveFloat", "min": 0, "max": 3, "precision": 2, "step": 0.05}, "widgets_values": [0.5]}, {"id": 23, "type": "GLSLShader", "pos": [4570, -1240], "size": [370, 192], "flags": {}, "order": 1, "mode": 0, "inputs": [{"label": "image0", "localized_name": "images.image0", "name": "images.image0", "type": "IMAGE", "link": 34}, {"label": "image1", "localized_name": "images.image1", "name": "images.image1", "shape": 7, "type": "IMAGE", "link": null}, {"label": "u_float0", "localized_name": "floats.u_float0", "name": "floats.u_float0", "shape": 7, "type": "FLOAT", "link": 36}, {"label": "u_float1", "localized_name": "floats.u_float1", "name": "floats.u_float1", "shape": 7, "type": "FLOAT", "link": null}, {"label": "u_int0", "localized_name": "ints.u_int0", "name": "ints.u_int0", "shape": 7, "type": "INT", "link": null}, {"localized_name": "fragment_shader", "name": "fragment_shader", "type": "STRING", "widget": {"name": "fragment_shader"}, "link": null}, {"localized_name": "size_mode", "name": "size_mode", "type": "COMFY_DYNAMICCOMBO_V3", "widget": {"name": "size_mode"}, "link": null}], "outputs": [{"localized_name": "IMAGE0", "name": "IMAGE0", "type": "IMAGE", "links": [35]}, {"localized_name": "IMAGE1", "name": "IMAGE1", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE2", "name": "IMAGE2", "type": "IMAGE", "links": null}, {"localized_name": "IMAGE3", "name": "IMAGE3", "type": "IMAGE", "links": null}], "properties": {"Node name for S&R": "GLSLShader"}, "widgets_values": ["#version 300 es\nprecision highp float;\n\nuniform sampler2D u_image0;\nuniform vec2 u_resolution;\nuniform float u_float0;  // strength [0.0 – 2.0] typical: 0.3–1.0\n\nin vec2 v_texCoord;\nlayout(location = 0) out vec4 fragColor0;\n\nvoid main() {\n    vec2 texel = 1.0 / u_resolution;\n    \n    // Sample center and neighbors\n    vec4 center = texture(u_image0, v_texCoord);\n    vec4 top    = texture(u_image0, v_texCoord + vec2( 0.0, -texel.y));\n    vec4 bottom = texture(u_image0, v_texCoord + vec2( 0.0,  texel.y));\n    vec4 left   = texture(u_image0, v_texCoord + vec2(-texel.x,  0.0));\n    vec4 right  = texture(u_image0, v_texCoord + vec2( texel.x,  0.0));\n    \n    // Edge enhancement (Laplacian)\n    vec4 edges = center * 4.0 - top - bottom - left - right;\n    \n    // Add edges back scaled by strength\n    vec4 sharpened = center + edges * u_float0;\n    \n    fragColor0 = vec4(clamp(sharpened.rgb, 0.0, 1.0), center.a);\n}", "from_input"]}], "groups": [], "links": [{"id": 36, "origin_id": 24, "origin_slot": 0, "target_id": 23, "target_slot": 2, "type": "FLOAT"}, {"id": 34, "origin_id": -10, "origin_slot": 0, "target_id": 23, "target_slot": 0, "type": "IMAGE"}, {"id": 35, "origin_id": 23, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "IMAGE"}], "extra": {"workflowRendererVersion": "LG"}, "category": "Image Tools/Sharpen"}]}}

blueprints/Video Upscale(GAN x4).json

@@ -1,420 +1 @@
-{
-  "revision": 0,
-  "last_node_id": 13,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 13,
-      "type": "cf95b747-3e17-46cb-8097-cac60ff9b2e1",
-      "pos": [
-        1120,
-        330
-      ],
-      "size": [
-        240,
-        58
-      ],
-      "flags": {},
-      "order": 3,
-      "mode": 0,
-      "inputs": [
-        {
-          "localized_name": "video",
-          "name": "video",
-          "type": "VIDEO",
-          "link": null
-        },
-        {
-          "name": "model_name",
-          "type": "COMBO",
-          "widget": {
-            "name": "model_name"
-          },
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "localized_name": "VIDEO",
-          "name": "VIDEO",
-          "type": "VIDEO",
-          "links": []
-        }
-      ],
-      "title": "Video Upscale(GAN x4)",
-      "properties": {
-        "proxyWidgets": [
-          [
-            "-1",
-            "model_name"
-          ]
-        ],
-        "cnr_id": "comfy-core",
-        "ver": "0.14.1"
-      },
-      "widgets_values": [
-        "RealESRGAN_x4plus.safetensors"
-      ]
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "cf95b747-3e17-46cb-8097-cac60ff9b2e1",
-        "version": 1,
-        "state": {
-          "lastGroupId": 0,
-          "lastNodeId": 13,
-          "lastLinkId": 19,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "Video Upscale(GAN x4)",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            550,
-            460,
-            120,
-            80
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            1490,
-            460,
-            120,
-            60
-          ]
-        },
-        "inputs": [
-          {
-            "id": "666d633e-93e7-42dc-8d11-2b7b99b0f2a6",
-            "name": "video",
-            "type": "VIDEO",
-            "linkIds": [
-              10
-            ],
-            "localized_name": "video",
-            "pos": [
-              650,
-              480
-            ]
-          },
-          {
-            "id": "2e23a087-caa8-4d65-99e6-662761aa905a",
-            "name": "model_name",
-            "type": "COMBO",
-            "linkIds": [
-              19
-            ],
-            "pos": [
-              650,
-              500
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "0c1768ea-3ec2-412f-9af6-8e0fa36dae70",
-            "name": "VIDEO",
-            "type": "VIDEO",
-            "linkIds": [
-              15
-            ],
-            "localized_name": "VIDEO",
-            "pos": [
-              1510,
-              480
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 2,
-            "type": "ImageUpscaleWithModel",
-            "pos": [
-              1110,
-              450
-            ],
-            "size": [
-              320,
-              46
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "upscale_model",
-                "name": "upscale_model",
-                "type": "UPSCALE_MODEL",
-                "link": 1
-              },
-              {
-                "localized_name": "image",
-                "name": "image",
-                "type": "IMAGE",
-                "link": 14
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "IMAGE",
-                "name": "IMAGE",
-                "type": "IMAGE",
-                "links": [
-                  13
-                ]
-              }
-            ],
-            "properties": {
-              "cnr_id": "comfy-core",
-              "ver": "0.10.0",
-              "Node name for S&R": "ImageUpscaleWithModel"
-            }
-          },
-          {
-            "id": 11,
-            "type": "CreateVideo",
-            "pos": [
-              1110,
-              550
-            ],
-            "size": [
-              320,
-              78
-            ],
-            "flags": {},
-            "order": 3,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "images",
-                "name": "images",
-                "type": "IMAGE",
-                "link": 13
-              },
-              {
-                "localized_name": "audio",
-                "name": "audio",
-                "shape": 7,
-                "type": "AUDIO",
-                "link": 16
-              },
-              {
-                "localized_name": "fps",
-                "name": "fps",
-                "type": "FLOAT",
-                "widget": {
-                  "name": "fps"
-                },
-                "link": 12
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "VIDEO",
-                "name": "VIDEO",
-                "type": "VIDEO",
-                "links": [
-                  15
-                ]
-              }
-            ],
-            "properties": {
-              "cnr_id": "comfy-core",
-              "ver": "0.10.0",
-              "Node name for S&R": "CreateVideo"
-            },
-            "widgets_values": [
-              30
-            ]
-          },
-          {
-            "id": 10,
-            "type": "GetVideoComponents",
-            "pos": [
-              1110,
-              330
-            ],
-            "size": [
-              320,
-              70
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "video",
-                "name": "video",
-                "type": "VIDEO",
-                "link": 10
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "images",
-                "name": "images",
-                "type": "IMAGE",
-                "links": [
-                  14
-                ]
-              },
-              {
-                "localized_name": "audio",
-                "name": "audio",
-                "type": "AUDIO",
-                "links": [
-                  16
-                ]
-              },
-              {
-                "localized_name": "fps",
-                "name": "fps",
-                "type": "FLOAT",
-                "links": [
-                  12
-                ]
-              }
-            ],
-            "properties": {
-              "cnr_id": "comfy-core",
-              "ver": "0.10.0",
-              "Node name for S&R": "GetVideoComponents"
-            }
-          },
-          {
-            "id": 1,
-            "type": "UpscaleModelLoader",
-            "pos": [
-              750,
-              450
-            ],
-            "size": [
-              280,
-              60
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "model_name",
-                "name": "model_name",
-                "type": "COMBO",
-                "widget": {
-                  "name": "model_name"
-                },
-                "link": 19
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "UPSCALE_MODEL",
-                "name": "UPSCALE_MODEL",
-                "type": "UPSCALE_MODEL",
-                "links": [
-                  1
-                ]
-              }
-            ],
-            "properties": {
-              "cnr_id": "comfy-core",
-              "ver": "0.10.0",
-              "Node name for S&R": "UpscaleModelLoader",
-              "models": [
-                {
-                  "name": "RealESRGAN_x4plus.safetensors",
-                  "url": "https://huggingface.co/Comfy-Org/Real-ESRGAN_repackaged/resolve/main/RealESRGAN_x4plus.safetensors",
-                  "directory": "upscale_models"
-                }
-              ]
-            },
-            "widgets_values": [
-              "RealESRGAN_x4plus.safetensors"
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 1,
-            "origin_id": 1,
-            "origin_slot": 0,
-            "target_id": 2,
-            "target_slot": 0,
-            "type": "UPSCALE_MODEL"
-          },
-          {
-            "id": 14,
-            "origin_id": 10,
-            "origin_slot": 0,
-            "target_id": 2,
-            "target_slot": 1,
-            "type": "IMAGE"
-          },
-          {
-            "id": 13,
-            "origin_id": 2,
-            "origin_slot": 0,
-            "target_id": 11,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 16,
-            "origin_id": 10,
-            "origin_slot": 1,
-            "target_id": 11,
-            "target_slot": 1,
-            "type": "AUDIO"
-          },
-          {
-            "id": 12,
-            "origin_id": 10,
-            "origin_slot": 2,
-            "target_id": 11,
-            "target_slot": 2,
-            "type": "FLOAT"
-          },
-          {
-            "id": 10,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 10,
-            "target_slot": 0,
-            "type": "VIDEO"
-          },
-          {
-            "id": 15,
-            "origin_id": 11,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "VIDEO"
-          },
-          {
-            "id": 19,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 1,
-            "target_slot": 0,
-            "type": "COMBO"
-          }
-        ],
-        "extra": {
-          "workflowRendererVersion": "LG"
-        },
-        "category": "Video generation and editing/Enhance video"
-      }
-    ]
-  },
-  "extra": {}
-}
+{"revision": 0, "last_node_id": 13, "last_link_id": 0, "nodes": [{"id": 13, "type": "cf95b747-3e17-46cb-8097-cac60ff9b2e1", "pos": [1120, 330], "size": [240, 58], "flags": {}, "order": 3, "mode": 0, "inputs": [{"localized_name": "video", "name": "video", "type": "VIDEO", "link": null}, {"name": "model_name", "type": "COMBO", "widget": {"name": "model_name"}, "link": null}], "outputs": [{"localized_name": "VIDEO", "name": "VIDEO", "type": "VIDEO", "links": []}], "title": "Video Upscale(GAN x4)", "properties": {"proxyWidgets": [["-1", "model_name"]], "cnr_id": "comfy-core", "ver": "0.14.1"}, "widgets_values": ["RealESRGAN_x4plus.safetensors"]}], "links": [], "version": 0.4, "definitions": {"subgraphs": [{"id": "cf95b747-3e17-46cb-8097-cac60ff9b2e1", "version": 1, "state": {"lastGroupId": 0, "lastNodeId": 13, "lastLinkId": 19, "lastRerouteId": 0}, "revision": 0, "config": {}, "name": "Video Upscale(GAN x4)", "inputNode": {"id": -10, "bounding": [550, 460, 120, 80]}, "outputNode": {"id": -20, "bounding": [1490, 460, 120, 60]}, "inputs": [{"id": "666d633e-93e7-42dc-8d11-2b7b99b0f2a6", "name": "video", "type": "VIDEO", "linkIds": [10], "localized_name": "video", "pos": [650, 480]}, {"id": "2e23a087-caa8-4d65-99e6-662761aa905a", "name": "model_name", "type": "COMBO", "linkIds": [19], "pos": [650, 500]}], "outputs": [{"id": "0c1768ea-3ec2-412f-9af6-8e0fa36dae70", "name": "VIDEO", "type": "VIDEO", "linkIds": [15], "localized_name": "VIDEO", "pos": [1510, 480]}], "widgets": [], "nodes": [{"id": 2, "type": "ImageUpscaleWithModel", "pos": [1110, 450], "size": [320, 46], "flags": {}, "order": 1, "mode": 0, "inputs": [{"localized_name": "upscale_model", "name": "upscale_model", "type": "UPSCALE_MODEL", "link": 1}, {"localized_name": "image", "name": "image", "type": "IMAGE", "link": 14}], "outputs": [{"localized_name": "IMAGE", "name": "IMAGE", "type": "IMAGE", "links": [13]}], "properties": {"cnr_id": "comfy-core", "ver": "0.10.0", "Node name for S&R": "ImageUpscaleWithModel"}}, {"id": 11, "type": "CreateVideo", "pos": [1110, 550], "size": [320, 78], "flags": {}, "order": 3, "mode": 0, "inputs": [{"localized_name": "images", "name": "images", "type": "IMAGE", "link": 13}, {"localized_name": "audio", "name": "audio", "shape": 7, "type": "AUDIO", "link": 16}, {"localized_name": "fps", "name": "fps", "type": "FLOAT", "widget": {"name": "fps"}, "link": 12}], "outputs": [{"localized_name": "VIDEO", "name": "VIDEO", "type": "VIDEO", "links": [15]}], "properties": {"cnr_id": "comfy-core", "ver": "0.10.0", "Node name for S&R": "CreateVideo"}, "widgets_values": [30]}, {"id": 10, "type": "GetVideoComponents", "pos": [1110, 330], "size": [320, 70], "flags": {}, "order": 2, "mode": 0, "inputs": [{"localized_name": "video", "name": "video", "type": "VIDEO", "link": 10}], "outputs": [{"localized_name": "images", "name": "images", "type": "IMAGE", "links": [14]}, {"localized_name": "audio", "name": "audio", "type": "AUDIO", "links": [16]}, {"localized_name": "fps", "name": "fps", "type": "FLOAT", "links": [12]}], "properties": {"cnr_id": "comfy-core", "ver": "0.10.0", "Node name for S&R": "GetVideoComponents"}}, {"id": 1, "type": "UpscaleModelLoader", "pos": [750, 450], "size": [280, 60], "flags": {}, "order": 0, "mode": 0, "inputs": [{"localized_name": "model_name", "name": "model_name", "type": "COMBO", "widget": {"name": "model_name"}, "link": 19}], "outputs": [{"localized_name": "UPSCALE_MODEL", "name": "UPSCALE_MODEL", "type": "UPSCALE_MODEL", "links": [1]}], "properties": {"cnr_id": "comfy-core", "ver": "0.10.0", "Node name for S&R": "UpscaleModelLoader", "models": [{"name": "RealESRGAN_x4plus.safetensors", "url": "https://huggingface.co/Comfy-Org/Real-ESRGAN_repackaged/resolve/main/RealESRGAN_x4plus.safetensors", "directory": "upscale_models"}]}, "widgets_values": ["RealESRGAN_x4plus.safetensors"]}], "groups": [], "links": [{"id": 1, "origin_id": 1, "origin_slot": 0, "target_id": 2, "target_slot": 0, "type": "UPSCALE_MODEL"}, {"id": 14, "origin_id": 10, "origin_slot": 0, "target_id": 2, "target_slot": 1, "type": "IMAGE"}, {"id": 13, "origin_id": 2, "origin_slot": 0, "target_id": 11, "target_slot": 0, "type": "IMAGE"}, {"id": 16, "origin_id": 10, "origin_slot": 1, "target_id": 11, "target_slot": 1, "type": "AUDIO"}, {"id": 12, "origin_id": 10, "origin_slot": 2, "target_id": 11, "target_slot": 2, "type": "FLOAT"}, {"id": 10, "origin_id": -10, "origin_slot": 0, "target_id": 10, "target_slot": 0, "type": "VIDEO"}, {"id": 15, "origin_id": 11, "origin_slot": 0, "target_id": -20, "target_slot": 0, "type": "VIDEO"}, {"id": 19, "origin_id": -10, "origin_slot": 1, "target_id": 1, "target_slot": 0, "type": "COMBO"}], "extra": {"workflowRendererVersion": "LG"}, "category": "Video generation and editing/Enhance video"}]}, "extra": {}}

comfy/cli_args.py

@@ -110,13 +110,11 @@ parser.add_argument("--preview-method", type=LatentPreviewMethod, default=Latent
 
 parser.add_argument("--preview-size", type=int, default=512, help="Sets the maximum preview size for sampler nodes.")
 
-CACHE_RAM_AUTO_GB = -1.0
-
 cache_group = parser.add_mutually_exclusive_group()
 cache_group.add_argument("--cache-classic", action="store_true", help="Use the old style (aggressive) caching.")
 cache_group.add_argument("--cache-lru", type=int, default=0, help="Use LRU caching with a maximum of N node results cached. May use more RAM/VRAM.")
 cache_group.add_argument("--cache-none", action="store_true", help="Reduced RAM/VRAM usage at the expense of executing every node for each run.")
-cache_group.add_argument("--cache-ram", nargs='?', const=CACHE_RAM_AUTO_GB, type=float, default=0, help="Use RAM pressure caching with the specified headroom threshold. If available RAM drops below the threshold the cache removes large items to free RAM. Default (when no value is provided): 25%% of system RAM (min 4GB, max 32GB).")
+cache_group.add_argument("--cache-ram", nargs='?', const=4.0, type=float, default=0, help="Use RAM pressure caching with the specified headroom threshold. If available RAM drops below the threhold the cache remove large items to free RAM. Default 4GB")
 
 attn_group = parser.add_mutually_exclusive_group()
 attn_group.add_argument("--use-split-cross-attention", action="store_true", help="Use the split cross attention optimization. Ignored when xformers is used.")
@@ -184,8 +182,6 @@ parser.add_argument("--disable-api-nodes", action="store_true", help="Disable lo
 
 parser.add_argument("--multi-user", action="store_true", help="Enables per-user storage.")
 
-parser.add_argument("--use-process-isolation", action="store_true", help="Enable process isolation for custom nodes with pyproject.toml manifests containing a [tool.comfy.isolation] section.")
-
 parser.add_argument("--verbose", default='INFO', const='DEBUG', nargs="?", choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], help='Set the logging level')
 parser.add_argument("--log-stdout", action="store_true", help="Send normal process output to stdout instead of stderr (default).")
 
@@ -228,6 +224,8 @@ parser.add_argument("--user-directory", type=is_valid_directory, default=None, h
 
 parser.add_argument("--enable-compress-response-body", action="store_true", help="Enable compressing response body.")
 
+parser.add_argument("--enable-download-api", action="store_true", help="Enable the model download API. When set, ComfyUI exposes endpoints that allow downloading model files directly into the models directory. Only HTTPS downloads from allowed hosts (huggingface.co, civitai.com) are permitted.")
+
 parser.add_argument(
     "--comfy-api-base",
     type=str,

comfy/hooks.py

@@ -14,9 +14,6 @@ if TYPE_CHECKING:
 import comfy.lora
 import comfy.model_management
 import comfy.patcher_extension
-from comfy.cli_args import args
-import uuid
-import os
 from node_helpers import conditioning_set_values
 
 # #######################################################################################################
@@ -64,37 +61,8 @@ class EnumHookScope(enum.Enum):
     HookedOnly = "hooked_only"
 
 
-_ISOLATION_HOOKREF_MODE = args.use_process_isolation or os.environ.get("PYISOLATE_CHILD") == "1"
-
-
 class _HookRef:
-    def __init__(self):
-        if _ISOLATION_HOOKREF_MODE:
-            self._pyisolate_id = str(uuid.uuid4())
-
-    def _ensure_pyisolate_id(self):
-        pyisolate_id = getattr(self, "_pyisolate_id", None)
-        if pyisolate_id is None:
-            pyisolate_id = str(uuid.uuid4())
-            self._pyisolate_id = pyisolate_id
-        return pyisolate_id
-
-    def __eq__(self, other):
-        if not _ISOLATION_HOOKREF_MODE:
-            return self is other
-        if not isinstance(other, _HookRef):
-            return False
-        return self._ensure_pyisolate_id() == other._ensure_pyisolate_id()
-
-    def __hash__(self):
-        if not _ISOLATION_HOOKREF_MODE:
-            return id(self)
-        return hash(self._ensure_pyisolate_id())
-
-    def __str__(self):
-        if not _ISOLATION_HOOKREF_MODE:
-            return super().__str__()
-        return f"PYISOLATE_HOOKREF:{self._ensure_pyisolate_id()}"
+    pass
 
 
 def default_should_register(hook: Hook, model: ModelPatcher, model_options: dict, target_dict: dict[str], registered: HookGroup):
@@ -200,8 +168,6 @@ class WeightHook(Hook):
                 key_map = comfy.lora.model_lora_keys_clip(model.model, key_map)
             else:
                 key_map = comfy.lora.model_lora_keys_unet(model.model, key_map)
-            if self.weights is None:
-                self.weights = {}
             weights = comfy.lora.load_lora(self.weights, key_map, log_missing=False)
         else:
             if target == EnumWeightTarget.Clip:

comfy/isolation/__init__.py

@@ -1,436 +0,0 @@
-# pylint: disable=consider-using-from-import,cyclic-import,global-statement,global-variable-not-assigned,import-outside-toplevel,logging-fstring-interpolation
-from __future__ import annotations
-import asyncio
-import inspect
-import logging
-import os
-import time
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Dict, List, Optional, Set, TYPE_CHECKING
-_IMPORT_TORCH = os.environ.get("PYISOLATE_IMPORT_TORCH", "1") == "1"
-
-load_isolated_node = None
-find_manifest_directories = None
-build_stub_class = None
-get_class_types_for_extension = None
-scan_shm_forensics = None
-start_shm_forensics = None
-
-if _IMPORT_TORCH:
-    import folder_paths
-    from .extension_loader import load_isolated_node
-    from .manifest_loader import find_manifest_directories
-    from .runtime_helpers import build_stub_class, get_class_types_for_extension
-    from .shm_forensics import scan_shm_forensics, start_shm_forensics
-
-if TYPE_CHECKING:
-    from pyisolate import ExtensionManager
-    from .extension_wrapper import ComfyNodeExtension
-
-LOG_PREFIX = "]["
-isolated_node_timings: List[tuple[float, Path, int]] = []
-
-if _IMPORT_TORCH:
-    PYISOLATE_VENV_ROOT = Path(folder_paths.base_path) / ".pyisolate_venvs"
-    PYISOLATE_VENV_ROOT.mkdir(parents=True, exist_ok=True)
-
-logger = logging.getLogger(__name__)
-_WORKFLOW_BOUNDARY_MIN_FREE_VRAM_BYTES = 2 * 1024 * 1024 * 1024
-_MODEL_PATCHER_IDLE_TIMEOUT_MS = 120000
-
-
-def initialize_proxies() -> None:
-    from .child_hooks import is_child_process
-
-    is_child = is_child_process()
-
-    if is_child:
-        from .child_hooks import initialize_child_process
-
-        initialize_child_process()
-    else:
-        from .host_hooks import initialize_host_process
-
-        initialize_host_process()
-        if start_shm_forensics is not None:
-            start_shm_forensics()
-
-
-@dataclass(frozen=True)
-class IsolatedNodeSpec:
-    node_name: str
-    display_name: str
-    stub_class: type
-    module_path: Path
-
-
-_ISOLATED_NODE_SPECS: List[IsolatedNodeSpec] = []
-_CLAIMED_PATHS: Set[Path] = set()
-_ISOLATION_SCAN_ATTEMPTED = False
-_EXTENSION_MANAGERS: List["ExtensionManager"] = []
-_RUNNING_EXTENSIONS: Dict[str, "ComfyNodeExtension"] = {}
-_ISOLATION_BACKGROUND_TASK: Optional["asyncio.Task[List[IsolatedNodeSpec]]"] = None
-_EARLY_START_TIME: Optional[float] = None
-
-
-def start_isolation_loading_early(loop: "asyncio.AbstractEventLoop") -> None:
-    global _ISOLATION_BACKGROUND_TASK, _EARLY_START_TIME
-    if _ISOLATION_BACKGROUND_TASK is not None:
-        return
-    _EARLY_START_TIME = time.perf_counter()
-    _ISOLATION_BACKGROUND_TASK = loop.create_task(initialize_isolation_nodes())
-
-
-async def await_isolation_loading() -> List[IsolatedNodeSpec]:
-    global _ISOLATION_BACKGROUND_TASK, _EARLY_START_TIME
-    if _ISOLATION_BACKGROUND_TASK is not None:
-        specs = await _ISOLATION_BACKGROUND_TASK
-        return specs
-    return await initialize_isolation_nodes()
-
-
-async def initialize_isolation_nodes() -> List[IsolatedNodeSpec]:
-    global _ISOLATED_NODE_SPECS, _ISOLATION_SCAN_ATTEMPTED, _CLAIMED_PATHS
-
-    if _ISOLATED_NODE_SPECS:
-        return _ISOLATED_NODE_SPECS
-
-    if _ISOLATION_SCAN_ATTEMPTED:
-        return []
-
-    _ISOLATION_SCAN_ATTEMPTED = True
-    if find_manifest_directories is None or load_isolated_node is None or build_stub_class is None:
-        return []
-    manifest_entries = find_manifest_directories()
-    _CLAIMED_PATHS = {entry[0].resolve() for entry in manifest_entries}
-
-    if not manifest_entries:
-        return []
-
-    os.environ["PYISOLATE_ISOLATION_ACTIVE"] = "1"
-    concurrency_limit = max(1, (os.cpu_count() or 4) // 2)
-    semaphore = asyncio.Semaphore(concurrency_limit)
-
-    async def load_with_semaphore(
-        node_dir: Path, manifest: Path
-    ) -> List[IsolatedNodeSpec]:
-        async with semaphore:
-            load_start = time.perf_counter()
-            spec_list = await load_isolated_node(
-                node_dir,
-                manifest,
-                logger,
-                lambda name, info, extension: build_stub_class(
-                    name,
-                    info,
-                    extension,
-                    _RUNNING_EXTENSIONS,
-                    logger,
-                ),
-                PYISOLATE_VENV_ROOT,
-                _EXTENSION_MANAGERS,
-            )
-            spec_list = [
-                IsolatedNodeSpec(
-                    node_name=node_name,
-                    display_name=display_name,
-                    stub_class=stub_cls,
-                    module_path=node_dir,
-                )
-                for node_name, display_name, stub_cls in spec_list
-            ]
-            isolated_node_timings.append(
-                (time.perf_counter() - load_start, node_dir, len(spec_list))
-            )
-            return spec_list
-
-    tasks = [
-        load_with_semaphore(node_dir, manifest)
-        for node_dir, manifest in manifest_entries
-    ]
-    results = await asyncio.gather(*tasks, return_exceptions=True)
-
-    specs: List[IsolatedNodeSpec] = []
-    for result in results:
-        if isinstance(result, Exception):
-            logger.error(
-                "%s Isolated node failed during startup; continuing: %s",
-                LOG_PREFIX,
-                result,
-            )
-            continue
-        specs.extend(result)
-
-    _ISOLATED_NODE_SPECS = specs
-    return list(_ISOLATED_NODE_SPECS)
-
-
-def _get_class_types_for_extension(extension_name: str) -> Set[str]:
-    """Get all node class types (node names) belonging to an extension."""
-    extension = _RUNNING_EXTENSIONS.get(extension_name)
-    if not extension:
-        return set()
-
-    ext_path = Path(extension.module_path)
-    class_types = set()
-    for spec in _ISOLATED_NODE_SPECS:
-        if spec.module_path.resolve() == ext_path.resolve():
-            class_types.add(spec.node_name)
-
-    return class_types
-
-
-async def notify_execution_graph(needed_class_types: Set[str], caches: list | None = None) -> None:
-    """Evict running extensions not needed for current execution.
-
-    When *caches* is provided, cache entries for evicted extensions' node
-    class_types are invalidated to prevent stale ``RemoteObjectHandle``
-    references from surviving in the output cache.
-    """
-    await wait_for_model_patcher_quiescence(
-        timeout_ms=_MODEL_PATCHER_IDLE_TIMEOUT_MS,
-        fail_loud=True,
-        marker="ISO:notify_graph_wait_idle",
-    )
-
-    evicted_class_types: Set[str] = set()
-
-    async def _stop_extension(
-        ext_name: str, extension: "ComfyNodeExtension", reason: str
-    ) -> None:
-        # Collect class_types BEFORE stopping so we can invalidate cache entries.
-        ext_class_types = _get_class_types_for_extension(ext_name)
-        evicted_class_types.update(ext_class_types)
-        logger.info("%s ISO:eject_start ext=%s reason=%s", LOG_PREFIX, ext_name, reason)
-        logger.debug("%s ISO:stop_start ext=%s", LOG_PREFIX, ext_name)
-        stop_result = extension.stop()
-        if inspect.isawaitable(stop_result):
-            await stop_result
-        _RUNNING_EXTENSIONS.pop(ext_name, None)
-        logger.debug("%s ISO:stop_done ext=%s", LOG_PREFIX, ext_name)
-        if scan_shm_forensics is not None:
-            scan_shm_forensics("ISO:stop_extension", refresh_model_context=True)
-
-    if scan_shm_forensics is not None:
-        scan_shm_forensics("ISO:notify_graph_start", refresh_model_context=True)
-    isolated_class_types_in_graph = needed_class_types.intersection(
-        {spec.node_name for spec in _ISOLATED_NODE_SPECS}
-    )
-    graph_uses_isolation = bool(isolated_class_types_in_graph)
-    logger.debug(
-        "%s ISO:notify_graph_start running=%d needed=%d",
-        LOG_PREFIX,
-        len(_RUNNING_EXTENSIONS),
-        len(needed_class_types),
-    )
-    if graph_uses_isolation:
-        for ext_name, extension in list(_RUNNING_EXTENSIONS.items()):
-            ext_class_types = _get_class_types_for_extension(ext_name)
-
-            # If NONE of this extension's nodes are in the execution graph -> evict.
-            if not ext_class_types.intersection(needed_class_types):
-                await _stop_extension(
-                    ext_name,
-                    extension,
-                    "isolated custom_node not in execution graph, evicting",
-                )
-    else:
-        logger.debug(
-            "%s ISO:notify_graph_skip_evict running=%d reason=no isolated nodes in graph",
-            LOG_PREFIX,
-            len(_RUNNING_EXTENSIONS),
-        )
-
-    # Isolated child processes add steady VRAM pressure; reclaim host-side models
-    # at workflow boundaries so subsequent host nodes (e.g. CLIP encode) keep headroom.
-    try:
-        import comfy.model_management as model_management
-
-        device = model_management.get_torch_device()
-        if getattr(device, "type", None) == "cuda":
-            required = max(
-                model_management.minimum_inference_memory(),
-                _WORKFLOW_BOUNDARY_MIN_FREE_VRAM_BYTES,
-            )
-            free_before = model_management.get_free_memory(device)
-            if free_before < required and _RUNNING_EXTENSIONS and graph_uses_isolation:
-                for ext_name, extension in list(_RUNNING_EXTENSIONS.items()):
-                    await _stop_extension(
-                        ext_name,
-                        extension,
-                        f"boundary low-vram restart (free={int(free_before)} target={int(required)})",
-                    )
-            if model_management.get_free_memory(device) < required:
-                model_management.unload_all_models()
-            model_management.cleanup_models_gc()
-            model_management.cleanup_models()
-            if model_management.get_free_memory(device) < required:
-                model_management.free_memory(required, device, for_dynamic=False)
-                model_management.soft_empty_cache()
-    except Exception:
-        logger.debug(
-            "%s workflow-boundary host VRAM relief failed", LOG_PREFIX, exc_info=True
-        )
-    finally:
-        # Invalidate cached outputs for evicted extensions so stale
-        # RemoteObjectHandle references are not served from cache.
-        if evicted_class_types and caches:
-            total_invalidated = 0
-            for cache in caches:
-                if hasattr(cache, "invalidate_by_class_types"):
-                    total_invalidated += cache.invalidate_by_class_types(
-                        evicted_class_types
-                    )
-            if total_invalidated > 0:
-                logger.info(
-                    "%s ISO:cache_invalidated count=%d class_types=%s",
-                    LOG_PREFIX,
-                    total_invalidated,
-                    evicted_class_types,
-                )
-        scan_shm_forensics("ISO:notify_graph_done", refresh_model_context=True)
-        logger.debug(
-            "%s ISO:notify_graph_done running=%d", LOG_PREFIX, len(_RUNNING_EXTENSIONS)
-        )
-
-
-async def flush_running_extensions_transport_state() -> int:
-    await wait_for_model_patcher_quiescence(
-        timeout_ms=_MODEL_PATCHER_IDLE_TIMEOUT_MS,
-        fail_loud=True,
-        marker="ISO:flush_transport_wait_idle",
-    )
-    total_flushed = 0
-    for ext_name, extension in list(_RUNNING_EXTENSIONS.items()):
-        flush_fn = getattr(extension, "flush_transport_state", None)
-        if not callable(flush_fn):
-            continue
-        try:
-            flushed = await flush_fn()
-            if isinstance(flushed, int):
-                total_flushed += flushed
-                if flushed > 0:
-                    logger.debug(
-                        "%s %s workflow-end flush released=%d",
-                        LOG_PREFIX,
-                        ext_name,
-                        flushed,
-                    )
-        except Exception:
-            logger.debug(
-                "%s %s workflow-end flush failed", LOG_PREFIX, ext_name, exc_info=True
-            )
-    scan_shm_forensics(
-        "ISO:flush_running_extensions_transport_state", refresh_model_context=True
-    )
-    return total_flushed
-
-
-async def wait_for_model_patcher_quiescence(
-    timeout_ms: int = _MODEL_PATCHER_IDLE_TIMEOUT_MS,
-    *,
-    fail_loud: bool = False,
-    marker: str = "ISO:wait_model_patcher_idle",
-) -> bool:
-    try:
-        from comfy.isolation.model_patcher_proxy_registry import ModelPatcherRegistry
-
-        registry = ModelPatcherRegistry()
-        start = time.perf_counter()
-        idle = await registry.wait_all_idle(timeout_ms)
-        elapsed_ms = (time.perf_counter() - start) * 1000.0
-        if idle:
-            logger.debug(
-                "%s %s idle=1 timeout_ms=%d elapsed_ms=%.3f",
-                LOG_PREFIX,
-                marker,
-                timeout_ms,
-                elapsed_ms,
-            )
-            return True
-
-        states = await registry.get_all_operation_states()
-        logger.error(
-            "%s %s idle_timeout timeout_ms=%d elapsed_ms=%.3f states=%s",
-            LOG_PREFIX,
-            marker,
-            timeout_ms,
-            elapsed_ms,
-            states,
-        )
-        if fail_loud:
-            raise TimeoutError(
-                f"ModelPatcherRegistry did not quiesce within {timeout_ms} ms"
-            )
-        return False
-    except Exception:
-        if fail_loud:
-            raise
-        logger.debug("%s %s failed", LOG_PREFIX, marker, exc_info=True)
-        return False
-
-
-def get_claimed_paths() -> Set[Path]:
-    return _CLAIMED_PATHS
-
-
-def update_rpc_event_loops(loop: "asyncio.AbstractEventLoop | None" = None) -> None:
-    """Update all active RPC instances with the current event loop.
-
-    This MUST be called at the start of each workflow execution to ensure
-    RPC calls are scheduled on the correct event loop. This handles the case
-    where asyncio.run() creates a new event loop for each workflow.
-
-    Args:
-        loop: The event loop to use. If None, uses asyncio.get_running_loop().
-    """
-    if loop is None:
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = asyncio.get_event_loop()
-
-    update_count = 0
-
-    # Update RPCs from ExtensionManagers
-    for manager in _EXTENSION_MANAGERS:
-        if not hasattr(manager, "extensions"):
-            continue
-        for name, extension in manager.extensions.items():
-            if hasattr(extension, "rpc") and extension.rpc is not None:
-                if hasattr(extension.rpc, "update_event_loop"):
-                    extension.rpc.update_event_loop(loop)
-                    update_count += 1
-                    logger.debug(f"{LOG_PREFIX}Updated loop on extension '{name}'")
-
-    # Also update RPCs from running extensions (they may have direct RPC refs)
-    for name, extension in _RUNNING_EXTENSIONS.items():
-        if hasattr(extension, "rpc") and extension.rpc is not None:
-            if hasattr(extension.rpc, "update_event_loop"):
-                extension.rpc.update_event_loop(loop)
-                update_count += 1
-                logger.debug(f"{LOG_PREFIX}Updated loop on running extension '{name}'")
-
-    if update_count > 0:
-        logger.debug(f"{LOG_PREFIX}Updated event loop on {update_count} RPC instances")
-    else:
-        logger.debug(
-            f"{LOG_PREFIX}No RPC instances found to update (managers={len(_EXTENSION_MANAGERS)}, running={len(_RUNNING_EXTENSIONS)})"
-        )
-
-
-__all__ = [
-    "LOG_PREFIX",
-    "initialize_proxies",
-    "initialize_isolation_nodes",
-    "start_isolation_loading_early",
-    "await_isolation_loading",
-    "notify_execution_graph",
-    "flush_running_extensions_transport_state",
-    "wait_for_model_patcher_quiescence",
-    "get_claimed_paths",
-    "update_rpc_event_loops",
-    "IsolatedNodeSpec",
-    "get_class_types_for_extension",
-]

comfy/isolation/adapter.py

@@ -1,864 +0,0 @@
-# pylint: disable=import-outside-toplevel,logging-fstring-interpolation,protected-access,raise-missing-from,useless-return,wrong-import-position
-from __future__ import annotations
-
-import logging
-import os
-import inspect
-from pathlib import Path
-from typing import Any, Dict, List, Optional, cast
-
-from pyisolate.interfaces import IsolationAdapter, SerializerRegistryProtocol  # type: ignore[import-untyped]
-from pyisolate._internal.rpc_protocol import AsyncRPC, ProxiedSingleton  # type: ignore[import-untyped]
-
-_IMPORT_TORCH = os.environ.get("PYISOLATE_IMPORT_TORCH", "1") == "1"
-
-# Singleton proxies that do NOT transitively import torch/PIL/psutil/aiohttp.
-# Safe to import in sealed workers without host framework modules.
-from comfy.isolation.proxies.folder_paths_proxy import FolderPathsProxy
-from comfy.isolation.proxies.helper_proxies import HelperProxiesService
-from comfy.isolation.proxies.web_directory_proxy import WebDirectoryProxy
-
-# Singleton proxies that transitively import torch, PIL, or heavy host modules.
-# Only available when torch/host framework is present.
-CLIPProxy = None
-CLIPRegistry = None
-ModelPatcherProxy = None
-ModelPatcherRegistry = None
-ModelSamplingProxy = None
-ModelSamplingRegistry = None
-VAEProxy = None
-VAERegistry = None
-FirstStageModelRegistry = None
-ModelManagementProxy = None
-PromptServerService = None
-ProgressProxy = None
-UtilsProxy = None
-_HAS_TORCH_PROXIES = False
-if _IMPORT_TORCH:
-    from comfy.isolation.clip_proxy import CLIPProxy, CLIPRegistry
-    from comfy.isolation.model_patcher_proxy import (
-        ModelPatcherProxy,
-        ModelPatcherRegistry,
-    )
-    from comfy.isolation.model_sampling_proxy import (
-        ModelSamplingProxy,
-        ModelSamplingRegistry,
-    )
-    from comfy.isolation.vae_proxy import VAEProxy, VAERegistry, FirstStageModelRegistry
-    from comfy.isolation.proxies.model_management_proxy import ModelManagementProxy
-    from comfy.isolation.proxies.prompt_server_impl import PromptServerService
-    from comfy.isolation.proxies.progress_proxy import ProgressProxy
-    from comfy.isolation.proxies.utils_proxy import UtilsProxy
-    _HAS_TORCH_PROXIES = True
-
-logger = logging.getLogger(__name__)
-
-# Force /dev/shm for shared memory (bwrap makes /tmp private)
-import tempfile
-
-if os.path.exists("/dev/shm"):
-    # Only override if not already set or if default is not /dev/shm
-    current_tmp = tempfile.gettempdir()
-    if not current_tmp.startswith("/dev/shm"):
-        logger.debug(
-            f"Configuring shared memory: Changing TMPDIR from {current_tmp} to /dev/shm"
-        )
-        os.environ["TMPDIR"] = "/dev/shm"
-        tempfile.tempdir = None  # Clear cache to force re-evaluation
-
-
-class ComfyUIAdapter(IsolationAdapter):
-    # ComfyUI-specific IsolationAdapter implementation
-
-    @property
-    def identifier(self) -> str:
-        return "comfyui"
-
-    def get_path_config(self, module_path: str) -> Optional[Dict[str, Any]]:
-        if "ComfyUI" in module_path and "custom_nodes" in module_path:
-            parts = module_path.split("ComfyUI")
-            if len(parts) > 1:
-                comfy_root = parts[0] + "ComfyUI"
-                return {
-                    "preferred_root": comfy_root,
-                    "additional_paths": [
-                        os.path.join(comfy_root, "custom_nodes"),
-                        os.path.join(comfy_root, "comfy"),
-                    ],
-                    "filtered_subdirs": ["comfy", "app", "comfy_execution", "utils"],
-                }
-        return None
-
-    def get_sandbox_system_paths(self) -> Optional[List[str]]:
-        """Returns required application paths to mount in the sandbox."""
-        # By inspecting where our adapter is loaded from, we can determine the comfy root
-        adapter_file = inspect.getfile(self.__class__)
-        # adapter_file = /home/johnj/ComfyUI/comfy/isolation/adapter.py
-        comfy_root = os.path.dirname(os.path.dirname(os.path.dirname(adapter_file)))
-        if os.path.exists(comfy_root):
-            return [comfy_root]
-        return None
-
-    def setup_child_environment(self, snapshot: Dict[str, Any]) -> None:
-        comfy_root = snapshot.get("preferred_root")
-        if not comfy_root:
-            return
-
-        requirements_path = Path(comfy_root) / "requirements.txt"
-        if requirements_path.exists():
-            import re
-
-            for line in requirements_path.read_text().splitlines():
-                line = line.strip()
-                if not line or line.startswith("#"):
-                    continue
-                pkg_name = re.split(r"[<>=!~\[]", line)[0].strip()
-                if pkg_name:
-                    logging.getLogger(pkg_name).setLevel(logging.ERROR)
-
-    def register_serializers(self, registry: SerializerRegistryProtocol) -> None:
-        if not _IMPORT_TORCH:
-            # Sealed worker without torch — register torch-free TensorValue handler
-            # so IMAGE/MASK/LATENT tensors arrive as numpy arrays, not raw dicts.
-            import numpy as np
-
-            _TORCH_DTYPE_TO_NUMPY = {
-                "torch.float32": np.float32,
-                "torch.float64": np.float64,
-                "torch.float16": np.float16,
-                "torch.bfloat16": np.float32,  # numpy has no bfloat16; upcast
-                "torch.int32": np.int32,
-                "torch.int64": np.int64,
-                "torch.int16": np.int16,
-                "torch.int8": np.int8,
-                "torch.uint8": np.uint8,
-                "torch.bool": np.bool_,
-            }
-
-            def _deserialize_tensor_value(data: Dict[str, Any]) -> Any:
-                dtype_str = data["dtype"]
-                np_dtype = _TORCH_DTYPE_TO_NUMPY.get(dtype_str, np.float32)
-                shape = tuple(data["tensor_size"])
-                arr = np.array(data["data"], dtype=np_dtype).reshape(shape)
-                return arr
-
-            _NUMPY_TO_TORCH_DTYPE = {
-                np.float32: "torch.float32",
-                np.float64: "torch.float64",
-                np.float16: "torch.float16",
-                np.int32: "torch.int32",
-                np.int64: "torch.int64",
-                np.int16: "torch.int16",
-                np.int8: "torch.int8",
-                np.uint8: "torch.uint8",
-                np.bool_: "torch.bool",
-            }
-
-            def _serialize_tensor_value(obj: Any) -> Dict[str, Any]:
-                arr = np.asarray(obj, dtype=np.float32) if obj.dtype not in _NUMPY_TO_TORCH_DTYPE else np.asarray(obj)
-                dtype_str = _NUMPY_TO_TORCH_DTYPE.get(arr.dtype.type, "torch.float32")
-                return {
-                    "__type__": "TensorValue",
-                    "dtype": dtype_str,
-                    "tensor_size": list(arr.shape),
-                    "requires_grad": False,
-                    "data": arr.tolist(),
-                }
-
-            registry.register("TensorValue", _serialize_tensor_value, _deserialize_tensor_value, data_type=True)
-            # ndarray output from sealed workers serializes as TensorValue for host torch reconstruction
-            registry.register("ndarray", _serialize_tensor_value, _deserialize_tensor_value, data_type=True)
-            return
-
-        import torch
-
-        def serialize_device(obj: Any) -> Dict[str, Any]:
-            return {"__type__": "device", "device_str": str(obj)}
-
-        def deserialize_device(data: Dict[str, Any]) -> Any:
-            return torch.device(data["device_str"])
-
-        registry.register("device", serialize_device, deserialize_device)
-
-        _VALID_DTYPES = {
-            "float16", "float32", "float64", "bfloat16",
-            "int8", "int16", "int32", "int64",
-            "uint8", "bool",
-        }
-
-        def serialize_dtype(obj: Any) -> Dict[str, Any]:
-            return {"__type__": "dtype", "dtype_str": str(obj)}
-
-        def deserialize_dtype(data: Dict[str, Any]) -> Any:
-            dtype_name = data["dtype_str"].replace("torch.", "")
-            if dtype_name not in _VALID_DTYPES:
-                raise ValueError(f"Invalid dtype: {data['dtype_str']}")
-            return getattr(torch, dtype_name)
-
-        registry.register("dtype", serialize_dtype, deserialize_dtype)
-
-        from comfy_api.latest._io import FolderType
-        from comfy_api.latest._ui import SavedImages, SavedResult
-
-        def serialize_saved_result(obj: Any) -> Dict[str, Any]:
-            return {
-                "__type__": "SavedResult",
-                "filename": obj.filename,
-                "subfolder": obj.subfolder,
-                "folder_type": obj.type.value,
-            }
-
-        def deserialize_saved_result(data: Dict[str, Any]) -> Any:
-            if isinstance(data, SavedResult):
-                return data
-            folder_type = data["folder_type"] if "folder_type" in data else data["type"]
-            return SavedResult(
-                filename=data["filename"],
-                subfolder=data["subfolder"],
-                type=FolderType(folder_type),
-            )
-
-        registry.register(
-            "SavedResult",
-            serialize_saved_result,
-            deserialize_saved_result,
-            data_type=True,
-        )
-
-        def serialize_saved_images(obj: Any) -> Dict[str, Any]:
-            return {
-                "__type__": "SavedImages",
-                "results": [serialize_saved_result(result) for result in obj.results],
-                "is_animated": obj.is_animated,
-            }
-
-        def deserialize_saved_images(data: Dict[str, Any]) -> Any:
-            return SavedImages(
-                results=[deserialize_saved_result(result) for result in data["results"]],
-                is_animated=data.get("is_animated", False),
-            )
-
-        registry.register(
-            "SavedImages",
-            serialize_saved_images,
-            deserialize_saved_images,
-            data_type=True,
-        )
-
-        def serialize_model_patcher(obj: Any) -> Dict[str, Any]:
-            # Child-side: must already have _instance_id (proxy)
-            if os.environ.get("PYISOLATE_CHILD") == "1":
-                if hasattr(obj, "_instance_id"):
-                    return {"__type__": "ModelPatcherRef", "model_id": obj._instance_id}
-                raise RuntimeError(
-                    f"ModelPatcher in child lacks _instance_id: "
-                    f"{type(obj).__module__}.{type(obj).__name__}"
-                )
-            # Host-side: register with registry
-            if hasattr(obj, "_instance_id"):
-                return {"__type__": "ModelPatcherRef", "model_id": obj._instance_id}
-            model_id = ModelPatcherRegistry().register(obj)
-            return {"__type__": "ModelPatcherRef", "model_id": model_id}
-
-        def deserialize_model_patcher(data: Any) -> Any:
-            """Deserialize ModelPatcher refs; pass through already-materialized objects."""
-            if isinstance(data, dict):
-                return ModelPatcherProxy(
-                    data["model_id"], registry=None, manage_lifecycle=False
-                )
-            return data
-
-        def deserialize_model_patcher_ref(data: Dict[str, Any]) -> Any:
-            """Context-aware ModelPatcherRef deserializer for both host and child."""
-            is_child = os.environ.get("PYISOLATE_CHILD") == "1"
-            if is_child:
-                return ModelPatcherProxy(
-                    data["model_id"], registry=None, manage_lifecycle=False
-                )
-            else:
-                return ModelPatcherRegistry()._get_instance(data["model_id"])
-
-        # Register ModelPatcher type for serialization
-        registry.register(
-            "ModelPatcher", serialize_model_patcher, deserialize_model_patcher
-        )
-        # Register ModelPatcherProxy type (already a proxy, just return ref)
-        registry.register(
-            "ModelPatcherProxy", serialize_model_patcher, deserialize_model_patcher
-        )
-        # Register ModelPatcherRef for deserialization (context-aware: host or child)
-        registry.register("ModelPatcherRef", None, deserialize_model_patcher_ref)
-
-        def serialize_clip(obj: Any) -> Dict[str, Any]:
-            if hasattr(obj, "_instance_id"):
-                return {"__type__": "CLIPRef", "clip_id": obj._instance_id}
-            clip_id = CLIPRegistry().register(obj)
-            return {"__type__": "CLIPRef", "clip_id": clip_id}
-
-        def deserialize_clip(data: Any) -> Any:
-            if isinstance(data, dict):
-                return CLIPProxy(data["clip_id"], registry=None, manage_lifecycle=False)
-            return data
-
-        def deserialize_clip_ref(data: Dict[str, Any]) -> Any:
-            """Context-aware CLIPRef deserializer for both host and child."""
-            is_child = os.environ.get("PYISOLATE_CHILD") == "1"
-            if is_child:
-                return CLIPProxy(data["clip_id"], registry=None, manage_lifecycle=False)
-            else:
-                return CLIPRegistry()._get_instance(data["clip_id"])
-
-        # Register CLIP type for serialization
-        registry.register("CLIP", serialize_clip, deserialize_clip)
-        # Register CLIPProxy type (already a proxy, just return ref)
-        registry.register("CLIPProxy", serialize_clip, deserialize_clip)
-        # Register CLIPRef for deserialization (context-aware: host or child)
-        registry.register("CLIPRef", None, deserialize_clip_ref)
-
-        def serialize_vae(obj: Any) -> Dict[str, Any]:
-            if hasattr(obj, "_instance_id"):
-                return {"__type__": "VAERef", "vae_id": obj._instance_id}
-            vae_id = VAERegistry().register(obj)
-            return {"__type__": "VAERef", "vae_id": vae_id}
-
-        def deserialize_vae(data: Any) -> Any:
-            if isinstance(data, dict):
-                return VAEProxy(data["vae_id"])
-            return data
-
-        def deserialize_vae_ref(data: Dict[str, Any]) -> Any:
-            """Context-aware VAERef deserializer for both host and child."""
-            is_child = os.environ.get("PYISOLATE_CHILD") == "1"
-            if is_child:
-                # Child: create a proxy
-                return VAEProxy(data["vae_id"])
-            else:
-                # Host: lookup real VAE from registry
-                return VAERegistry()._get_instance(data["vae_id"])
-
-        # Register VAE type for serialization
-        registry.register("VAE", serialize_vae, deserialize_vae)
-        # Register VAEProxy type (already a proxy, just return ref)
-        registry.register("VAEProxy", serialize_vae, deserialize_vae)
-        # Register VAERef for deserialization (context-aware: host or child)
-        registry.register("VAERef", None, deserialize_vae_ref)
-
-        # ModelSampling serialization - handles ModelSampling* types
-        # copyreg removed - no pickle fallback allowed
-
-        def serialize_model_sampling(obj: Any) -> Dict[str, Any]:
-            # Proxy with _instance_id — return ref (works from both host and child)
-            if hasattr(obj, "_instance_id"):
-                return {"__type__": "ModelSamplingRef", "ms_id": obj._instance_id}
-            # Child-side: object created locally in child (e.g. ModelSamplingAdvanced
-            # in nodes_z_image_turbo.py). Serialize as inline data so the host can
-            # reconstruct the real torch.nn.Module.
-            if os.environ.get("PYISOLATE_CHILD") == "1":
-                import base64
-                import io as _io
-
-                # Identify base classes from comfy.model_sampling
-                bases = []
-                for base in type(obj).__mro__:
-                    if base.__module__ == "comfy.model_sampling" and base.__name__ != "object":
-                        bases.append(base.__name__)
-                # Serialize state_dict as base64 safetensors-like
-                sd = obj.state_dict()
-                sd_serialized = {}
-                for k, v in sd.items():
-                    buf = _io.BytesIO()
-                    torch.save(v, buf)
-                    sd_serialized[k] = base64.b64encode(buf.getvalue()).decode("ascii")
-                # Capture plain attrs (shift, multiplier, sigma_data, etc.)
-                plain_attrs = {}
-                for k, v in obj.__dict__.items():
-                    if k.startswith("_"):
-                        continue
-                    if isinstance(v, (bool, int, float, str)):
-                        plain_attrs[k] = v
-                return {
-                    "__type__": "ModelSamplingInline",
-                    "bases": bases,
-                    "state_dict": sd_serialized,
-                    "attrs": plain_attrs,
-                }
-            # Host-side: register with ModelSamplingRegistry and return JSON-safe dict
-            ms_id = ModelSamplingRegistry().register(obj)
-            return {"__type__": "ModelSamplingRef", "ms_id": ms_id}
-
-        def deserialize_model_sampling(data: Any) -> Any:
-            """Deserialize ModelSampling refs or inline data."""
-            if isinstance(data, dict):
-                if data.get("__type__") == "ModelSamplingInline":
-                    return _reconstruct_model_sampling_inline(data)
-                return ModelSamplingProxy(data["ms_id"])
-            return data
-
-        def _reconstruct_model_sampling_inline(data: Dict[str, Any]) -> Any:
-            """Reconstruct a ModelSampling object on the host from inline child data."""
-            import comfy.model_sampling as _ms
-            import base64
-            import io as _io
-
-            # Resolve base classes
-            base_classes = []
-            for name in data["bases"]:
-                cls = getattr(_ms, name, None)
-                if cls is not None:
-                    base_classes.append(cls)
-            if not base_classes:
-                raise RuntimeError(
-                    f"Cannot reconstruct ModelSampling: no known bases in {data['bases']}"
-                )
-            # Create dynamic class matching the child's class hierarchy
-            ReconstructedSampling = type("ReconstructedSampling", tuple(base_classes), {})
-            obj = ReconstructedSampling.__new__(ReconstructedSampling)
-            torch.nn.Module.__init__(obj)
-            # Restore plain attributes first
-            for k, v in data.get("attrs", {}).items():
-                setattr(obj, k, v)
-            # Restore state_dict (buffers like sigmas)
-            for k, v_b64 in data.get("state_dict", {}).items():
-                buf = _io.BytesIO(base64.b64decode(v_b64))
-                tensor = torch.load(buf, weights_only=True)
-                # Register as buffer so it's part of state_dict
-                parts = k.split(".")
-                if len(parts) == 1:
-                    cast(Any, obj).register_buffer(parts[0], tensor)  # pylint: disable=no-member
-                else:
-                    setattr(obj, parts[0], tensor)
-            # Register on host so future references use proxy pattern.
-            # Skip in child process — register() is async RPC and cannot be
-            # called synchronously during deserialization.
-            if os.environ.get("PYISOLATE_CHILD") != "1":
-                ModelSamplingRegistry().register(obj)
-            return obj
-
-        def deserialize_model_sampling_ref(data: Dict[str, Any]) -> Any:
-            """Context-aware ModelSamplingRef deserializer for both host and child."""
-            is_child = os.environ.get("PYISOLATE_CHILD") == "1"
-            if is_child:
-                return ModelSamplingProxy(data["ms_id"])
-            else:
-                return ModelSamplingRegistry()._get_instance(data["ms_id"])
-
-        # Register all ModelSampling* and StableCascadeSampling classes dynamically
-        import comfy.model_sampling
-
-        for ms_cls in vars(comfy.model_sampling).values():
-            if not isinstance(ms_cls, type):
-                continue
-            if not issubclass(ms_cls, torch.nn.Module):
-                continue
-            if not (ms_cls.__name__.startswith("ModelSampling") or ms_cls.__name__ == "StableCascadeSampling"):
-                continue
-            registry.register(
-                ms_cls.__name__,
-                serialize_model_sampling,
-                deserialize_model_sampling,
-            )
-        registry.register(
-            "ModelSamplingProxy", serialize_model_sampling, deserialize_model_sampling
-        )
-        # Register ModelSamplingRef for deserialization (context-aware: host or child)
-        registry.register("ModelSamplingRef", None, deserialize_model_sampling_ref)
-        # Register ModelSamplingInline for deserialization (child→host inline transfer)
-        registry.register(
-            "ModelSamplingInline", None, lambda data: _reconstruct_model_sampling_inline(data)
-        )
-
-        def serialize_cond(obj: Any) -> Dict[str, Any]:
-            type_key = f"{type(obj).__module__}.{type(obj).__name__}"
-            return {
-                "__type__": type_key,
-                "cond": obj.cond,
-            }
-
-        def deserialize_cond(data: Dict[str, Any]) -> Any:
-            import importlib
-
-            type_key = data["__type__"]
-            module_name, class_name = type_key.rsplit(".", 1)
-            module = importlib.import_module(module_name)
-            cls = getattr(module, class_name)
-            return cls(data["cond"])
-
-        def _serialize_public_state(obj: Any) -> Dict[str, Any]:
-            state: Dict[str, Any] = {}
-            for key, value in obj.__dict__.items():
-                if key.startswith("_"):
-                    continue
-                if callable(value):
-                    continue
-                state[key] = value
-            return state
-
-        def serialize_latent_format(obj: Any) -> Dict[str, Any]:
-            type_key = f"{type(obj).__module__}.{type(obj).__name__}"
-            return {
-                "__type__": type_key,
-                "state": _serialize_public_state(obj),
-            }
-
-        def deserialize_latent_format(data: Dict[str, Any]) -> Any:
-            import importlib
-
-            type_key = data["__type__"]
-            module_name, class_name = type_key.rsplit(".", 1)
-            module = importlib.import_module(module_name)
-            cls = getattr(module, class_name)
-            obj = cls()
-            for key, value in data.get("state", {}).items():
-                prop = getattr(type(obj), key, None)
-                if isinstance(prop, property) and prop.fset is None:
-                    continue
-                setattr(obj, key, value)
-            return obj
-
-        import comfy.conds
-
-        for cond_cls in vars(comfy.conds).values():
-            if not isinstance(cond_cls, type):
-                continue
-            if not issubclass(cond_cls, comfy.conds.CONDRegular):
-                continue
-            type_key = f"{cond_cls.__module__}.{cond_cls.__name__}"
-            registry.register(type_key, serialize_cond, deserialize_cond)
-            registry.register(cond_cls.__name__, serialize_cond, deserialize_cond)
-
-        import comfy.latent_formats
-
-        for latent_cls in vars(comfy.latent_formats).values():
-            if not isinstance(latent_cls, type):
-                continue
-            if not issubclass(latent_cls, comfy.latent_formats.LatentFormat):
-                continue
-            type_key = f"{latent_cls.__module__}.{latent_cls.__name__}"
-            registry.register(
-                type_key, serialize_latent_format, deserialize_latent_format
-            )
-            registry.register(
-                latent_cls.__name__, serialize_latent_format, deserialize_latent_format
-            )
-
-        # V3 API: unwrap NodeOutput.args
-        def deserialize_node_output(data: Any) -> Any:
-            return getattr(data, "args", data)
-
-        registry.register("NodeOutput", None, deserialize_node_output)
-
-        # KSAMPLER serializer: stores sampler name instead of function object
-        # sampler_function is a callable which gets filtered out by JSONSocketTransport
-        def serialize_ksampler(obj: Any) -> Dict[str, Any]:
-            func_name = obj.sampler_function.__name__
-            # Map function name back to sampler name
-            if func_name == "sample_unipc":
-                sampler_name = "uni_pc"
-            elif func_name == "sample_unipc_bh2":
-                sampler_name = "uni_pc_bh2"
-            elif func_name == "dpm_fast_function":
-                sampler_name = "dpm_fast"
-            elif func_name == "dpm_adaptive_function":
-                sampler_name = "dpm_adaptive"
-            elif func_name.startswith("sample_"):
-                sampler_name = func_name[7:]  # Remove "sample_" prefix
-            else:
-                sampler_name = func_name
-            return {
-                "__type__": "KSAMPLER",
-                "sampler_name": sampler_name,
-                "extra_options": obj.extra_options,
-                "inpaint_options": obj.inpaint_options,
-            }
-
-        def deserialize_ksampler(data: Dict[str, Any]) -> Any:
-            import comfy.samplers
-
-            return comfy.samplers.ksampler(
-                data["sampler_name"],
-                data.get("extra_options", {}),
-                data.get("inpaint_options", {}),
-            )
-
-        registry.register("KSAMPLER", serialize_ksampler, deserialize_ksampler)
-
-        from comfy.isolation.model_patcher_proxy_utils import register_hooks_serializers
-
-        register_hooks_serializers(registry)
-
-        # -- File3D (comfy_api.latest._util.geometry_types) ---------------------
-        # Origin: comfy_api by ComfyOrg (Alexander Piskun), PR #12129
-
-        def serialize_file3d(obj: Any) -> Dict[str, Any]:
-            import base64
-            return {
-                "__type__": "File3D",
-                "format": obj.format,
-                "data": base64.b64encode(obj.get_bytes()).decode("ascii"),
-            }
-
-        def deserialize_file3d(data: Any) -> Any:
-            import base64
-            from io import BytesIO
-            from comfy_api.latest._util.geometry_types import File3D
-            return File3D(BytesIO(base64.b64decode(data["data"])), file_format=data["format"])
-
-        registry.register("File3D", serialize_file3d, deserialize_file3d, data_type=True)
-
-        # -- VIDEO (comfy_api.latest._input_impl.video_types) -------------------
-        # Origin: ComfyAPI Core v0.0.2 by ComfyOrg (guill), PR #8962
-
-        def serialize_video(obj: Any) -> Dict[str, Any]:
-            components = obj.get_components()
-            images = components.images.detach() if components.images.requires_grad else components.images
-            result: Dict[str, Any] = {
-                "__type__": "VIDEO",
-                "images": images,
-                "frame_rate_num": components.frame_rate.numerator,
-                "frame_rate_den": components.frame_rate.denominator,
-            }
-            if components.audio is not None:
-                waveform = components.audio["waveform"]
-                if waveform.requires_grad:
-                    waveform = waveform.detach()
-                result["audio_waveform"] = waveform
-                result["audio_sample_rate"] = components.audio["sample_rate"]
-            if components.metadata is not None:
-                result["metadata"] = components.metadata
-            return result
-
-        def deserialize_video(data: Any) -> Any:
-            from fractions import Fraction
-            from comfy_api.latest._input_impl.video_types import VideoFromComponents
-            from comfy_api.latest._util.video_types import VideoComponents
-            audio = None
-            if "audio_waveform" in data:
-                audio = {"waveform": data["audio_waveform"], "sample_rate": data["audio_sample_rate"]}
-            components = VideoComponents(
-                images=data["images"],
-                frame_rate=Fraction(data["frame_rate_num"], data["frame_rate_den"]),
-                audio=audio,
-                metadata=data.get("metadata"),
-            )
-            return VideoFromComponents(components)
-
-        registry.register("VIDEO", serialize_video, deserialize_video, data_type=True)
-        registry.register("VideoFromFile", serialize_video, deserialize_video, data_type=True)
-        registry.register("VideoFromComponents", serialize_video, deserialize_video, data_type=True)
-
-    def setup_web_directory(self, module: Any) -> None:
-        """Detect WEB_DIRECTORY on a module and populate/register it.
-
-        Called by the sealed worker after loading the node module.
-        Mirrors extension_wrapper.py:216-227 for host-coupled nodes.
-        Does NOT import extension_wrapper.py (it has `import torch` at module level).
-        """
-        import shutil
-
-        web_dir_attr = getattr(module, "WEB_DIRECTORY", None)
-        if web_dir_attr is None:
-            return
-
-        module_dir = os.path.dirname(os.path.abspath(module.__file__))
-        web_dir_path = os.path.abspath(os.path.join(module_dir, web_dir_attr))
-
-        # Read extension name from pyproject.toml
-        ext_name = os.path.basename(module_dir)
-        pyproject = os.path.join(module_dir, "pyproject.toml")
-        if os.path.exists(pyproject):
-            try:
-                import tomllib
-            except ImportError:
-                import tomli as tomllib  # type: ignore[no-redef]
-            try:
-                with open(pyproject, "rb") as f:
-                    data = tomllib.load(f)
-                name = data.get("project", {}).get("name")
-                if name:
-                    ext_name = name
-            except Exception:
-                pass
-
-        # Populate web dir if empty (mirrors _run_prestartup_web_copy)
-        if not (os.path.isdir(web_dir_path) and any(os.scandir(web_dir_path))):
-            os.makedirs(web_dir_path, exist_ok=True)
-
-            # Module-defined copy spec
-            copy_spec = getattr(module, "_PRESTARTUP_WEB_COPY", None)
-            if copy_spec is not None and callable(copy_spec):
-                try:
-                    copy_spec(web_dir_path)
-                except Exception as e:
-                    logger.warning("][ _PRESTARTUP_WEB_COPY failed: %s", e)
-
-            # Fallback: comfy_3d_viewers
-            try:
-                from comfy_3d_viewers import copy_viewer, VIEWER_FILES
-                for viewer in VIEWER_FILES:
-                    try:
-                        copy_viewer(viewer, web_dir_path)
-                    except Exception:
-                        pass
-            except ImportError:
-                pass
-
-            # Fallback: comfy_dynamic_widgets
-            try:
-                from comfy_dynamic_widgets import get_js_path
-                src = os.path.realpath(get_js_path())
-                if os.path.exists(src):
-                    dst_dir = os.path.join(web_dir_path, "js")
-                    os.makedirs(dst_dir, exist_ok=True)
-                    shutil.copy2(src, os.path.join(dst_dir, "dynamic_widgets.js"))
-            except ImportError:
-                pass
-
-        if os.path.isdir(web_dir_path) and any(os.scandir(web_dir_path)):
-            WebDirectoryProxy.register_web_dir(ext_name, web_dir_path)
-            logger.info(
-                "][ Adapter: registered web dir for %s (%d files)",
-                ext_name,
-                sum(1 for _ in Path(web_dir_path).rglob("*") if _.is_file()),
-            )
-
-    @staticmethod
-    def register_host_event_handlers(extension: Any) -> None:
-        """Register host-side event handlers for an isolated extension.
-
-        Wires ``"progress"`` events from the child to ``comfy.utils.PROGRESS_BAR_HOOK``
-        so the ComfyUI frontend receives progress bar updates.
-        """
-        register_event_handler = inspect.getattr_static(
-            extension, "register_event_handler", None
-        )
-        if not callable(register_event_handler):
-            return
-
-        def _host_progress_handler(payload: dict) -> None:
-            import comfy.utils
-
-            hook = comfy.utils.PROGRESS_BAR_HOOK
-            if hook is not None:
-                hook(
-                    payload.get("value", 0),
-                    payload.get("total", 0),
-                    payload.get("preview"),
-                    payload.get("node_id"),
-                )
-
-        extension.register_event_handler("progress", _host_progress_handler)
-
-    def setup_child_event_hooks(self, extension: Any) -> None:
-        """Wire PROGRESS_BAR_HOOK in the child to emit_event on the extension.
-
-        Host-coupled only — sealed workers do not have comfy.utils (torch).
-        """
-        is_child = os.environ.get("PYISOLATE_CHILD") == "1"
-        logger.info("][ ISO:setup_child_event_hooks called, PYISOLATE_CHILD=%s", is_child)
-        if not is_child:
-            return
-
-        if not _IMPORT_TORCH:
-            logger.info("][ ISO:setup_child_event_hooks skipped — sealed worker (no torch)")
-            return
-
-        import comfy.utils
-
-        def _event_progress_hook(value, total, preview=None, node_id=None):
-            logger.debug("][ ISO:event_progress value=%s/%s node_id=%s", value, total, node_id)
-            extension.emit_event("progress", {
-                "value": value,
-                "total": total,
-                "node_id": node_id,
-            })
-
-        comfy.utils.PROGRESS_BAR_HOOK = _event_progress_hook
-        logger.info("][ ISO:PROGRESS_BAR_HOOK wired to event channel")
-
-    def provide_rpc_services(self) -> List[type[ProxiedSingleton]]:
-        # Always available — no torch/PIL dependency
-        services: List[type[ProxiedSingleton]] = [
-            FolderPathsProxy,
-            HelperProxiesService,
-            WebDirectoryProxy,
-        ]
-        # Torch/PIL-dependent proxies
-        if _HAS_TORCH_PROXIES:
-            services.extend([
-                PromptServerService,
-                ModelManagementProxy,
-                UtilsProxy,
-                ProgressProxy,
-                VAERegistry,
-                CLIPRegistry,
-                ModelPatcherRegistry,
-                ModelSamplingRegistry,
-                FirstStageModelRegistry,
-            ])
-        return services
-
-    def handle_api_registration(self, api: ProxiedSingleton, rpc: AsyncRPC) -> None:
-        # Resolve the real name whether it's an instance or the Singleton class itself
-        api_name = api.__name__ if isinstance(api, type) else api.__class__.__name__
-
-        if api_name == "FolderPathsProxy":
-            import folder_paths
-
-            # Replace module-level functions with proxy methods
-            # This is aggressive but necessary for transparent proxying
-            # Handle both instance and class cases
-            instance = api() if isinstance(api, type) else api
-            for name in dir(instance):
-                if not name.startswith("_"):
-                    setattr(folder_paths, name, getattr(instance, name))
-
-            # Fence: isolated children get writable temp inside sandbox
-            if os.environ.get("PYISOLATE_CHILD") == "1":
-                import tempfile
-                _child_temp = os.path.join(tempfile.gettempdir(), "comfyui_temp")
-                os.makedirs(_child_temp, exist_ok=True)
-                folder_paths.temp_directory = _child_temp
-
-            return
-
-        if api_name == "ModelManagementProxy":
-            if _IMPORT_TORCH:
-                import comfy.model_management
-
-                instance = api() if isinstance(api, type) else api
-                # Replace module-level functions with proxy methods
-                for name in dir(instance):
-                    if not name.startswith("_"):
-                        setattr(comfy.model_management, name, getattr(instance, name))
-            return
-
-        if api_name == "UtilsProxy":
-            if not _IMPORT_TORCH:
-                logger.info("][ ISO:UtilsProxy handle_api_registration skipped — sealed worker (no torch)")
-                return
-
-            import comfy.utils
-
-            # Static Injection of RPC mechanism to ensure Child can access it
-            # independent of instance lifecycle.
-            api.set_rpc(rpc)
-
-            is_child = os.environ.get("PYISOLATE_CHILD") == "1"
-            logger.info("][ ISO:UtilsProxy handle_api_registration PYISOLATE_CHILD=%s", is_child)
-
-            # Progress hook wiring moved to setup_child_event_hooks via event channel
-
-            return
-
-        if api_name == "PromptServerService":
-            if not _IMPORT_TORCH:
-                return
-            import server
-            from comfy.isolation.proxies.prompt_server_impl import PromptServerStub
-
-            stub = PromptServerStub()
-            if (
-                hasattr(server, "PromptServer")
-                and getattr(server.PromptServer, "instance", None) is not stub
-            ):
-                server.PromptServer.instance = stub

comfy/isolation/child_hooks.py

@@ -1,122 +0,0 @@
-# pylint: disable=import-outside-toplevel,logging-fstring-interpolation
-# Child process initialization for PyIsolate
-import logging
-import os
-
-logger = logging.getLogger(__name__)
-
-
-def is_child_process() -> bool:
-    return os.environ.get("PYISOLATE_CHILD") == "1"
-
-
-def _load_extra_model_paths() -> None:
-    """Load extra_model_paths.yaml so the child's folder_paths has the same search paths as the host.
-
-    The host loads this in main.py:143-145. The child is spawned by
-    pyisolate's uds_client.py and never runs main.py, so folder_paths
-    only has the base model directories. Any isolated node calling
-    folder_paths.get_filename_list() in define_schema() would get empty
-    results for folders whose files live in extra_model_paths locations.
-    """
-    import folder_paths  # noqa: F401 — side-effect import; load_extra_path_config writes to folder_paths internals
-    from utils.extra_config import load_extra_path_config
-
-    extra_config_path = os.path.join(
-        os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-        "extra_model_paths.yaml",
-    )
-    if os.path.isfile(extra_config_path):
-        load_extra_path_config(extra_config_path)
-
-
-def initialize_child_process() -> None:
-    if os.environ.get("PYISOLATE_IMPORT_TORCH", "1") != "0":
-        _load_extra_model_paths()
-    _setup_child_loop_bridge()
-
-    # Manual RPC injection
-    try:
-        from pyisolate._internal.rpc_protocol import get_child_rpc_instance
-
-        rpc = get_child_rpc_instance()
-        if rpc:
-            _setup_proxy_callers(rpc)
-        else:
-            _setup_proxy_callers()
-    except Exception as e:
-        logger.error(f"][ child_hooks Manual RPC Injection failed: {e}")
-        _setup_proxy_callers()
-
-    _setup_logging()
-
-
-def _setup_child_loop_bridge() -> None:
-    import asyncio
-
-    main_loop = None
-    try:
-        main_loop = asyncio.get_running_loop()
-    except RuntimeError:
-        try:
-            main_loop = asyncio.get_event_loop()
-        except RuntimeError:
-            pass
-
-    if main_loop is None:
-        return
-
-    try:
-        from .proxies.base import set_global_loop
-
-        set_global_loop(main_loop)
-    except ImportError:
-        pass
-
-
-def _setup_prompt_server_stub(rpc=None) -> None:
-    try:
-        from .proxies.prompt_server_impl import PromptServerStub
-
-        if rpc:
-            PromptServerStub.set_rpc(rpc)
-        elif hasattr(PromptServerStub, "clear_rpc"):
-            PromptServerStub.clear_rpc()
-        else:
-            PromptServerStub._rpc = None  # type: ignore[attr-defined]
-
-    except Exception as e:
-        logger.error(f"Failed to setup PromptServerStub: {e}")
-
-
-def _setup_proxy_callers(rpc=None) -> None:
-    try:
-        from .proxies.folder_paths_proxy import FolderPathsProxy
-        from .proxies.helper_proxies import HelperProxiesService
-        from .proxies.model_management_proxy import ModelManagementProxy
-        from .proxies.progress_proxy import ProgressProxy
-        from .proxies.prompt_server_impl import PromptServerStub
-        from .proxies.utils_proxy import UtilsProxy
-
-        if rpc is None:
-            FolderPathsProxy.clear_rpc()
-            HelperProxiesService.clear_rpc()
-            ModelManagementProxy.clear_rpc()
-            ProgressProxy.clear_rpc()
-            PromptServerStub.clear_rpc()
-            UtilsProxy.clear_rpc()
-            return
-
-        FolderPathsProxy.set_rpc(rpc)
-        HelperProxiesService.set_rpc(rpc)
-        ModelManagementProxy.set_rpc(rpc)
-        ProgressProxy.set_rpc(rpc)
-        PromptServerStub.set_rpc(rpc)
-        UtilsProxy.set_rpc(rpc)
-
-    except Exception as e:
-        logger.error(f"Failed to setup child singleton proxy callers: {e}")
-
-
-def _setup_logging() -> None:
-    logging.getLogger().setLevel(logging.INFO)

comfy/isolation/clip_proxy.py

@@ -1,327 +0,0 @@
-# pylint: disable=attribute-defined-outside-init,import-outside-toplevel,logging-fstring-interpolation
-# CLIP Proxy implementation
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any, Optional
-
-from comfy.isolation.proxies.base import (
-    IS_CHILD_PROCESS,
-    BaseProxy,
-    BaseRegistry,
-    detach_if_grad,
-)
-
-if TYPE_CHECKING:
-    from comfy.isolation.model_patcher_proxy import ModelPatcherProxy
-
-
-class CondStageModelRegistry(BaseRegistry[Any]):
-    _type_prefix = "cond_stage_model"
-
-    async def get_property(self, instance_id: str, name: str) -> Any:
-        obj = self._get_instance(instance_id)
-        return getattr(obj, name)
-
-
-class CondStageModelProxy(BaseProxy[CondStageModelRegistry]):
-    _registry_class = CondStageModelRegistry
-    __module__ = "comfy.sd"
-
-    def __getattr__(self, name: str) -> Any:
-        try:
-            return self._call_rpc("get_property", name)
-        except Exception as e:
-            raise AttributeError(
-                f"'{self.__class__.__name__}' object has no attribute '{name}'"
-            ) from e
-
-    def __repr__(self) -> str:
-        return f"<CondStageModelProxy {self._instance_id}>"
-
-
-class TokenizerRegistry(BaseRegistry[Any]):
-    _type_prefix = "tokenizer"
-
-    async def get_property(self, instance_id: str, name: str) -> Any:
-        obj = self._get_instance(instance_id)
-        return getattr(obj, name)
-
-
-class TokenizerProxy(BaseProxy[TokenizerRegistry]):
-    _registry_class = TokenizerRegistry
-    __module__ = "comfy.sd"
-
-    def __getattr__(self, name: str) -> Any:
-        try:
-            return self._call_rpc("get_property", name)
-        except Exception as e:
-            raise AttributeError(
-                f"'{self.__class__.__name__}' object has no attribute '{name}'"
-            ) from e
-
-    def __repr__(self) -> str:
-        return f"<TokenizerProxy {self._instance_id}>"
-
-
-logger = logging.getLogger(__name__)
-
-
-class CLIPRegistry(BaseRegistry[Any]):
-    _type_prefix = "clip"
-    _allowed_setters = {
-        "layer_idx",
-        "tokenizer_options",
-        "use_clip_schedule",
-        "apply_hooks_to_conds",
-    }
-
-    async def get_ram_usage(self, instance_id: str) -> int:
-        return self._get_instance(instance_id).get_ram_usage()
-
-    async def get_patcher_id(self, instance_id: str) -> str:
-        from comfy.isolation.model_patcher_proxy import ModelPatcherRegistry
-
-        return ModelPatcherRegistry().register(self._get_instance(instance_id).patcher)
-
-    async def get_cond_stage_model_id(self, instance_id: str) -> str:
-        return CondStageModelRegistry().register(
-            self._get_instance(instance_id).cond_stage_model
-        )
-
-    async def get_tokenizer_id(self, instance_id: str) -> str:
-        return TokenizerRegistry().register(self._get_instance(instance_id).tokenizer)
-
-    async def load_model(self, instance_id: str) -> None:
-        self._get_instance(instance_id).load_model()
-
-    async def clip_layer(self, instance_id: str, layer_idx: int) -> None:
-        self._get_instance(instance_id).clip_layer(layer_idx)
-
-    async def set_tokenizer_option(
-        self, instance_id: str, option_name: str, value: Any
-    ) -> None:
-        self._get_instance(instance_id).set_tokenizer_option(option_name, value)
-
-    async def get_property(self, instance_id: str, name: str) -> Any:
-        return getattr(self._get_instance(instance_id), name)
-
-    async def set_property(self, instance_id: str, name: str, value: Any) -> None:
-        if name not in self._allowed_setters:
-            raise PermissionError(f"Setting '{name}' is not allowed via RPC")
-        setattr(self._get_instance(instance_id), name, value)
-
-    async def tokenize(
-        self, instance_id: str, text: str, return_word_ids: bool = False, **kwargs: Any
-    ) -> Any:
-        return self._get_instance(instance_id).tokenize(
-            text, return_word_ids=return_word_ids, **kwargs
-        )
-
-    async def encode(self, instance_id: str, text: str) -> Any:
-        return detach_if_grad(self._get_instance(instance_id).encode(text))
-
-    async def encode_from_tokens(
-        self,
-        instance_id: str,
-        tokens: Any,
-        return_pooled: bool = False,
-        return_dict: bool = False,
-    ) -> Any:
-        return detach_if_grad(
-            self._get_instance(instance_id).encode_from_tokens(
-                tokens, return_pooled=return_pooled, return_dict=return_dict
-            )
-        )
-
-    async def encode_from_tokens_scheduled(
-        self,
-        instance_id: str,
-        tokens: Any,
-        unprojected: bool = False,
-        add_dict: Optional[dict] = None,
-        show_pbar: bool = True,
-    ) -> Any:
-        add_dict = add_dict or {}
-        return detach_if_grad(
-            self._get_instance(instance_id).encode_from_tokens_scheduled(
-                tokens, unprojected=unprojected, add_dict=add_dict, show_pbar=show_pbar
-            )
-        )
-
-    async def add_patches(
-        self,
-        instance_id: str,
-        patches: Any,
-        strength_patch: float = 1.0,
-        strength_model: float = 1.0,
-    ) -> Any:
-        return self._get_instance(instance_id).add_patches(
-            patches, strength_patch=strength_patch, strength_model=strength_model
-        )
-
-    async def get_key_patches(self, instance_id: str) -> Any:
-        return self._get_instance(instance_id).get_key_patches()
-
-    async def load_sd(
-        self, instance_id: str, sd: dict, full_model: bool = False
-    ) -> Any:
-        return self._get_instance(instance_id).load_sd(sd, full_model=full_model)
-
-    async def get_sd(self, instance_id: str) -> Any:
-        return self._get_instance(instance_id).get_sd()
-
-    async def clone(self, instance_id: str) -> str:
-        return self.register(self._get_instance(instance_id).clone())
-
-
-class CLIPProxy(BaseProxy[CLIPRegistry]):
-    _registry_class = CLIPRegistry
-    __module__ = "comfy.sd"
-
-    def get_ram_usage(self) -> int:
-        return self._call_rpc("get_ram_usage")
-
-    @property
-    def patcher(self) -> "ModelPatcherProxy":
-        from comfy.isolation.model_patcher_proxy import ModelPatcherProxy
-
-        if not hasattr(self, "_patcher_proxy"):
-            patcher_id = self._call_rpc("get_patcher_id")
-            self._patcher_proxy = ModelPatcherProxy(patcher_id, manage_lifecycle=False)
-        return self._patcher_proxy
-
-    @patcher.setter
-    def patcher(self, value: Any) -> None:
-        from comfy.isolation.model_patcher_proxy import ModelPatcherProxy
-
-        if isinstance(value, ModelPatcherProxy):
-            self._patcher_proxy = value
-        else:
-            logger.warning(
-                f"Attempted to set CLIPProxy.patcher to non-proxy object: {value}"
-            )
-
-    @property
-    def cond_stage_model(self) -> CondStageModelProxy:
-        if not hasattr(self, "_cond_stage_model_proxy"):
-            csm_id = self._call_rpc("get_cond_stage_model_id")
-            self._cond_stage_model_proxy = CondStageModelProxy(
-                csm_id, manage_lifecycle=False
-            )
-        return self._cond_stage_model_proxy
-
-    @property
-    def tokenizer(self) -> TokenizerProxy:
-        if not hasattr(self, "_tokenizer_proxy"):
-            tok_id = self._call_rpc("get_tokenizer_id")
-            self._tokenizer_proxy = TokenizerProxy(tok_id, manage_lifecycle=False)
-        return self._tokenizer_proxy
-
-    def load_model(self) -> ModelPatcherProxy:
-        self._call_rpc("load_model")
-        return self.patcher
-
-    @property
-    def layer_idx(self) -> Optional[int]:
-        return self._call_rpc("get_property", "layer_idx")
-
-    @layer_idx.setter
-    def layer_idx(self, value: Optional[int]) -> None:
-        self._call_rpc("set_property", "layer_idx", value)
-
-    @property
-    def tokenizer_options(self) -> dict:
-        return self._call_rpc("get_property", "tokenizer_options")
-
-    @tokenizer_options.setter
-    def tokenizer_options(self, value: dict) -> None:
-        self._call_rpc("set_property", "tokenizer_options", value)
-
-    @property
-    def use_clip_schedule(self) -> bool:
-        return self._call_rpc("get_property", "use_clip_schedule")
-
-    @use_clip_schedule.setter
-    def use_clip_schedule(self, value: bool) -> None:
-        self._call_rpc("set_property", "use_clip_schedule", value)
-
-    @property
-    def apply_hooks_to_conds(self) -> Any:
-        return self._call_rpc("get_property", "apply_hooks_to_conds")
-
-    @apply_hooks_to_conds.setter
-    def apply_hooks_to_conds(self, value: Any) -> None:
-        self._call_rpc("set_property", "apply_hooks_to_conds", value)
-
-    def clip_layer(self, layer_idx: int) -> None:
-        return self._call_rpc("clip_layer", layer_idx)
-
-    def set_tokenizer_option(self, option_name: str, value: Any) -> None:
-        return self._call_rpc("set_tokenizer_option", option_name, value)
-
-    def tokenize(self, text: str, return_word_ids: bool = False, **kwargs: Any) -> Any:
-        return self._call_rpc(
-            "tokenize", text, return_word_ids=return_word_ids, **kwargs
-        )
-
-    def encode(self, text: str) -> Any:
-        return self._call_rpc("encode", text)
-
-    def encode_from_tokens(
-        self, tokens: Any, return_pooled: bool = False, return_dict: bool = False
-    ) -> Any:
-        res = self._call_rpc(
-            "encode_from_tokens",
-            tokens,
-            return_pooled=return_pooled,
-            return_dict=return_dict,
-        )
-        if return_pooled and isinstance(res, list) and not return_dict:
-            return tuple(res)
-        return res
-
-    def encode_from_tokens_scheduled(
-        self,
-        tokens: Any,
-        unprojected: bool = False,
-        add_dict: Optional[dict] = None,
-        show_pbar: bool = True,
-    ) -> Any:
-        add_dict = add_dict or {}
-        return self._call_rpc(
-            "encode_from_tokens_scheduled",
-            tokens,
-            unprojected=unprojected,
-            add_dict=add_dict,
-            show_pbar=show_pbar,
-        )
-
-    def add_patches(
-        self, patches: Any, strength_patch: float = 1.0, strength_model: float = 1.0
-    ) -> Any:
-        return self._call_rpc(
-            "add_patches",
-            patches,
-            strength_patch=strength_patch,
-            strength_model=strength_model,
-        )
-
-    def get_key_patches(self) -> Any:
-        return self._call_rpc("get_key_patches")
-
-    def load_sd(self, sd: dict, full_model: bool = False) -> Any:
-        return self._call_rpc("load_sd", sd, full_model=full_model)
-
-    def get_sd(self) -> Any:
-        return self._call_rpc("get_sd")
-
-    def clone(self) -> CLIPProxy:
-        new_id = self._call_rpc("clone")
-        return CLIPProxy(new_id, self._registry, manage_lifecycle=not IS_CHILD_PROCESS)
-
-
-if not IS_CHILD_PROCESS:
-    _CLIP_REGISTRY_SINGLETON = CLIPRegistry()
-    _COND_STAGE_MODEL_REGISTRY_SINGLETON = CondStageModelRegistry()
-    _TOKENIZER_REGISTRY_SINGLETON = TokenizerRegistry()

comfy/isolation/custom_node_serializers.py

@@ -1,16 +0,0 @@
-"""Compatibility shim for the indexed serializer path."""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-def register_custom_node_serializers(_registry: Any) -> None:
-    """Legacy no-op shim.
-
-    Serializer registration now lives directly in the active isolation adapter.
-    This module remains importable because the isolation index still references it.
-    """
-    return None
-
-__all__ = ["register_custom_node_serializers"]

comfy/isolation/extension_loader.py

@@ -1,540 +0,0 @@
-# pylint: disable=cyclic-import,import-outside-toplevel,redefined-outer-name
-from __future__ import annotations
-
-import logging
-import os
-import inspect
-import sys
-import types
-import platform
-from pathlib import Path
-from typing import Any, Callable, Dict, List, Tuple
-
-import pyisolate
-from pyisolate import ExtensionManager, ExtensionManagerConfig
-from packaging.requirements import InvalidRequirement, Requirement
-from packaging.utils import canonicalize_name
-
-from .manifest_loader import is_cache_valid, load_from_cache, save_to_cache
-from .host_policy import load_host_policy
-
-try:
-    import tomllib
-except ImportError:
-    import tomli as tomllib  # type: ignore[no-redef]
-
-logger = logging.getLogger(__name__)
-
-
-def _register_web_directory(extension_name: str, node_dir: Path) -> None:
-    """Register an isolated extension's web directory on the host side."""
-    import nodes
-
-    # Method 1: pyproject.toml [tool.comfy] web field
-    pyproject = node_dir / "pyproject.toml"
-    if pyproject.exists():
-        try:
-            with pyproject.open("rb") as f:
-                data = tomllib.load(f)
-            web_dir_name = data.get("tool", {}).get("comfy", {}).get("web")
-            if web_dir_name:
-                web_dir_path = str(node_dir / web_dir_name)
-                if os.path.isdir(web_dir_path):
-                    nodes.EXTENSION_WEB_DIRS[extension_name] = web_dir_path
-                    logger.debug(
-                        "][ Registered web dir for isolated %s: %s",
-                        extension_name,
-                        web_dir_path,
-                    )
-                    return
-        except Exception:
-            pass
-
-    # Method 2: __init__.py WEB_DIRECTORY constant (parse without importing)
-    init_file = node_dir / "__init__.py"
-    if init_file.exists():
-        try:
-            source = init_file.read_text()
-            for line in source.splitlines():
-                stripped = line.strip()
-                if stripped.startswith("WEB_DIRECTORY"):
-                    # Parse: WEB_DIRECTORY = "./web" or WEB_DIRECTORY = "web"
-                    _, _, value = stripped.partition("=")
-                    value = value.strip().strip("\"'")
-                    if value:
-                        web_dir_path = str((node_dir / value).resolve())
-                        if os.path.isdir(web_dir_path):
-                            nodes.EXTENSION_WEB_DIRS[extension_name] = web_dir_path
-                            logger.debug(
-                                "][ Registered web dir for isolated %s: %s",
-                                extension_name,
-                                web_dir_path,
-                            )
-                            return
-        except Exception:
-            pass
-
-
-def _get_extension_type(execution_model: str) -> type[Any]:
-    if execution_model == "sealed_worker":
-        return pyisolate.SealedNodeExtension
-
-    from .extension_wrapper import ComfyNodeExtension
-
-    return ComfyNodeExtension
-
-
-async def _stop_extension_safe(extension: Any, extension_name: str) -> None:
-    try:
-        stop_result = extension.stop()
-        if inspect.isawaitable(stop_result):
-            await stop_result
-    except Exception:
-        logger.debug("][ %s stop failed", extension_name, exc_info=True)
-
-
-def _normalize_dependency_spec(dep: str, base_paths: list[Path]) -> str:
-    req, sep, marker = dep.partition(";")
-    req = req.strip()
-    marker_suffix = f";{marker}" if sep else ""
-
-    def _resolve_local_path(local_path: str) -> Path | None:
-        for base in base_paths:
-            candidate = (base / local_path).resolve()
-            if candidate.exists():
-                return candidate
-        return None
-
-    if req.startswith("./") or req.startswith("../"):
-        resolved = _resolve_local_path(req)
-        if resolved is not None:
-            return f"{resolved}{marker_suffix}"
-
-    if req.startswith("file://"):
-        raw = req[len("file://") :]
-        if raw.startswith("./") or raw.startswith("../"):
-            resolved = _resolve_local_path(raw)
-            if resolved is not None:
-                return f"file://{resolved}{marker_suffix}"
-
-    return dep
-
-
-def _dependency_name_from_spec(dep: str) -> str | None:
-    stripped = dep.strip()
-    if not stripped or stripped == "-e" or stripped.startswith("-e "):
-        return None
-    if stripped.startswith(("/", "./", "../", "file://")):
-        return None
-
-    try:
-        return canonicalize_name(Requirement(stripped).name)
-    except InvalidRequirement:
-        return None
-
-
-def _parse_cuda_wheels_config(
-    tool_config: dict[str, object], dependencies: list[str]
-) -> dict[str, object] | None:
-    raw_config = tool_config.get("cuda_wheels")
-    if raw_config is None:
-        return None
-    if not isinstance(raw_config, dict):
-        raise ExtensionLoadError("[tool.comfy.isolation.cuda_wheels] must be a table")
-
-    index_url = raw_config.get("index_url")
-    index_urls = raw_config.get("index_urls")
-    if index_urls is not None:
-        if not isinstance(index_urls, list) or not all(
-            isinstance(u, str) and u.strip() for u in index_urls
-        ):
-            raise ExtensionLoadError(
-                "[tool.comfy.isolation.cuda_wheels.index_urls] must be a list of non-empty strings"
-            )
-    elif not isinstance(index_url, str) or not index_url.strip():
-        raise ExtensionLoadError(
-            "[tool.comfy.isolation.cuda_wheels.index_url] must be a non-empty string"
-        )
-
-    packages = raw_config.get("packages")
-    if not isinstance(packages, list) or not all(
-        isinstance(package_name, str) and package_name.strip()
-        for package_name in packages
-    ):
-        raise ExtensionLoadError(
-            "[tool.comfy.isolation.cuda_wheels.packages] must be a list of non-empty strings"
-        )
-
-    declared_dependencies = {
-        dependency_name
-        for dep in dependencies
-        if (dependency_name := _dependency_name_from_spec(dep)) is not None
-    }
-    normalized_packages = [canonicalize_name(package_name) for package_name in packages]
-    missing = [
-        package_name
-        for package_name in normalized_packages
-        if package_name not in declared_dependencies
-    ]
-    if missing:
-        missing_joined = ", ".join(sorted(missing))
-        raise ExtensionLoadError(
-            "[tool.comfy.isolation.cuda_wheels.packages] references undeclared dependencies: "
-            f"{missing_joined}"
-        )
-
-    package_map = raw_config.get("package_map", {})
-    if not isinstance(package_map, dict):
-        raise ExtensionLoadError(
-            "[tool.comfy.isolation.cuda_wheels.package_map] must be a table"
-        )
-
-    normalized_package_map: dict[str, str] = {}
-    for dependency_name, index_package_name in package_map.items():
-        if not isinstance(dependency_name, str) or not dependency_name.strip():
-            raise ExtensionLoadError(
-                "[tool.comfy.isolation.cuda_wheels.package_map] keys must be non-empty strings"
-            )
-        if not isinstance(index_package_name, str) or not index_package_name.strip():
-            raise ExtensionLoadError(
-                "[tool.comfy.isolation.cuda_wheels.package_map] values must be non-empty strings"
-            )
-        canonical_dependency_name = canonicalize_name(dependency_name)
-        if canonical_dependency_name not in normalized_packages:
-            raise ExtensionLoadError(
-                "[tool.comfy.isolation.cuda_wheels.package_map] can only override packages listed in "
-                "[tool.comfy.isolation.cuda_wheels.packages]"
-            )
-        normalized_package_map[canonical_dependency_name] = index_package_name.strip()
-
-    result: dict = {
-        "packages": normalized_packages,
-        "package_map": normalized_package_map,
-    }
-    if index_urls is not None:
-        result["index_urls"] = [u.rstrip("/") + "/" for u in index_urls]
-    else:
-        result["index_url"] = index_url.rstrip("/") + "/"
-    return result
-
-
-def get_enforcement_policy() -> Dict[str, bool]:
-    return {
-        "force_isolated": os.environ.get("PYISOLATE_ENFORCE_ISOLATED") == "1",
-        "force_sandbox": os.environ.get("PYISOLATE_ENFORCE_SANDBOX") == "1",
-    }
-
-
-class ExtensionLoadError(RuntimeError):
-    pass
-
-
-def register_dummy_module(extension_name: str, node_dir: Path) -> None:
-    normalized_name = extension_name.replace("-", "_").replace(".", "_")
-    if normalized_name not in sys.modules:
-        dummy_module = types.ModuleType(normalized_name)
-        dummy_module.__file__ = str(node_dir / "__init__.py")
-        dummy_module.__path__ = [str(node_dir)]
-        dummy_module.__package__ = normalized_name
-        sys.modules[normalized_name] = dummy_module
-
-
-def _is_stale_node_cache(cached_data: Dict[str, Dict]) -> bool:
-    for details in cached_data.values():
-        if not isinstance(details, dict):
-            return True
-        if details.get("is_v3") and "schema_v1" not in details:
-            return True
-    return False
-
-
-async def load_isolated_node(
-    node_dir: Path,
-    manifest_path: Path,
-    logger: logging.Logger,
-    build_stub_class: Callable[[str, Dict[str, object], Any], type],
-    venv_root: Path,
-    extension_managers: List[ExtensionManager],
-) -> List[Tuple[str, str, type]]:
-    try:
-        with manifest_path.open("rb") as handle:
-            manifest_data = tomllib.load(handle)
-    except Exception as e:
-        logger.warning(f"][ Failed to parse {manifest_path}: {e}")
-        return []
-
-    # Parse [tool.comfy.isolation]
-    tool_config = manifest_data.get("tool", {}).get("comfy", {}).get("isolation", {})
-    can_isolate = tool_config.get("can_isolate", False)
-    share_torch = tool_config.get("share_torch", False)
-    package_manager = tool_config.get("package_manager", "uv")
-    is_conda = package_manager == "conda"
-    execution_model = tool_config.get("execution_model")
-    if execution_model is None:
-        execution_model = "sealed_worker" if is_conda else "host-coupled"
-
-    if "sealed_host_ro_paths" in tool_config:
-        raise ValueError(
-            "Manifest field 'sealed_host_ro_paths' is not allowed. "
-            "Configure [tool.comfy.host].sealed_worker_ro_import_paths in host policy."
-        )
-
-    # Conda-specific manifest fields
-    conda_channels: list[str] = (
-        tool_config.get("conda_channels", []) if is_conda else []
-    )
-    conda_dependencies: list[str] = (
-        tool_config.get("conda_dependencies", []) if is_conda else []
-    )
-    conda_platforms: list[str] = (
-        tool_config.get("conda_platforms", []) if is_conda else []
-    )
-    conda_python: str = (
-        tool_config.get("conda_python", "*") if is_conda else "*"
-    )
-
-    # Parse [project] dependencies
-    project_config = manifest_data.get("project", {})
-    dependencies = project_config.get("dependencies", [])
-    if not isinstance(dependencies, list):
-        dependencies = []
-
-    # Get extension name (default to folder name if not in project.name)
-    extension_name = project_config.get("name", node_dir.name)
-
-    # LOGIC: Isolation Decision
-    policy = get_enforcement_policy()
-    isolated = can_isolate or policy["force_isolated"]
-
-    if not isolated:
-        return []
-
-    import folder_paths
-
-    base_paths = [Path(folder_paths.base_path), node_dir]
-    dependencies = [
-        _normalize_dependency_spec(dep, base_paths) if isinstance(dep, str) else dep
-        for dep in dependencies
-    ]
-    cuda_wheels = _parse_cuda_wheels_config(tool_config, dependencies)
-
-    manager_config = ExtensionManagerConfig(venv_root_path=str(venv_root))
-    extension_type = _get_extension_type(execution_model)
-    manager: ExtensionManager = pyisolate.ExtensionManager(
-        extension_type, manager_config
-    )
-    extension_managers.append(manager)
-
-    host_policy = load_host_policy(Path(folder_paths.base_path))
-
-    sandbox_config = {}
-    is_linux = platform.system() == "Linux"
-
-    if is_conda:
-        share_torch = False
-        share_cuda_ipc = False
-    else:
-        share_cuda_ipc = share_torch and is_linux
-
-    if is_linux and isolated:
-        sandbox_config = {
-            "network": host_policy["allow_network"],
-            "writable_paths": host_policy["writable_paths"],
-            "readonly_paths": host_policy["readonly_paths"],
-        }
-
-    extension_config: dict = {
-        "name": extension_name,
-        "module_path": str(node_dir),
-        "isolated": True,
-        "dependencies": dependencies,
-        "share_torch": share_torch,
-        "share_cuda_ipc": share_cuda_ipc,
-        "sandbox_mode": host_policy["sandbox_mode"],
-        "sandbox": sandbox_config,
-    }
-
-    share_torch_no_deps = tool_config.get("share_torch_no_deps", [])
-    if share_torch_no_deps:
-        if not isinstance(share_torch_no_deps, list) or not all(
-            isinstance(dep, str) and dep.strip() for dep in share_torch_no_deps
-        ):
-            raise ExtensionLoadError(
-                "[tool.comfy.isolation.share_torch_no_deps] must be a list of non-empty strings"
-            )
-        extension_config["share_torch_no_deps"] = share_torch_no_deps
-
-    _is_sealed = execution_model == "sealed_worker"
-    _is_sandboxed = host_policy["sandbox_mode"] != "disabled" and is_linux
-    logger.info(
-        "][ Loading isolated node: %s (torch_share [%s], sealed [%s], sandboxed [%s])",
-        extension_name,
-        "x" if share_torch else " ",
-        "x" if _is_sealed else " ",
-        "x" if _is_sandboxed else " ",
-    )
-
-    if cuda_wheels is not None:
-        extension_config["cuda_wheels"] = cuda_wheels
-
-    extra_index_urls = tool_config.get("extra_index_urls", [])
-    if extra_index_urls:
-        if not isinstance(extra_index_urls, list) or not all(
-            isinstance(u, str) and u.strip() for u in extra_index_urls
-        ):
-            raise ExtensionLoadError(
-                "[tool.comfy.isolation.extra_index_urls] must be a list of non-empty strings"
-            )
-        extension_config["extra_index_urls"] = extra_index_urls
-
-    # Conda-specific keys
-    if is_conda:
-        extension_config["package_manager"] = "conda"
-        extension_config["conda_channels"] = conda_channels
-        extension_config["conda_dependencies"] = conda_dependencies
-        extension_config["conda_python"] = conda_python
-        find_links = tool_config.get("find_links", [])
-        if find_links:
-            extension_config["find_links"] = find_links
-        if conda_platforms:
-            extension_config["conda_platforms"] = conda_platforms
-
-    if execution_model != "host-coupled":
-        extension_config["execution_model"] = execution_model
-    if execution_model == "sealed_worker":
-        policy_ro_paths = host_policy.get("sealed_worker_ro_import_paths", [])
-        if isinstance(policy_ro_paths, list) and policy_ro_paths:
-            extension_config["sealed_host_ro_paths"] = list(policy_ro_paths)
-        # Sealed workers keep the host RPC service inventory even when the
-        # child resolves no API classes locally.
-
-    extension = manager.load_extension(extension_config)
-    register_dummy_module(extension_name, node_dir)
-
-    # Register host-side event handlers via adapter
-    from .adapter import ComfyUIAdapter
-    ComfyUIAdapter.register_host_event_handlers(extension)
-
-    # Register web directory on the host — only when sandbox is disabled.
-    # In sandbox mode, serving untrusted JS to the browser is not safe.
-    if host_policy["sandbox_mode"] == "disabled":
-        _register_web_directory(extension_name, node_dir)
-
-    # Register for proxied web serving — the child's web dir may have
-    # content that doesn't exist on the host (e.g., pip-installed viewer
-    # bundles). The WebDirectoryCache will lazily fetch via RPC.
-    from .proxies.web_directory_proxy import WebDirectoryProxy, get_web_directory_cache
-
-    class ChildWebDirectoryProxy:
-        def __init__(self, host_extension):
-            self._host_extension = host_extension
-            self._caller = None
-
-        def _get_caller(self):
-            self._host_extension.proxy
-            rpc = self._host_extension._extension.rpc
-            caller = rpc.create_caller(WebDirectoryProxy, WebDirectoryProxy.get_remote_id())
-            if self._caller is not caller:
-                self._caller = caller
-            return self._caller
-
-        def list_web_files(self, extension_name: str):
-            from .proxies.base import run_sync_rpc_coro
-            return run_sync_rpc_coro(self._get_caller().list_web_files(extension_name))
-
-        def get_web_file(self, extension_name: str, relative_path: str):
-            from .proxies.base import run_sync_rpc_coro
-            return run_sync_rpc_coro(
-                self._get_caller().get_web_file(extension_name, relative_path)
-            )
-
-    cache = get_web_directory_cache()
-    cache.register_proxy(extension_name, ChildWebDirectoryProxy(extension))
-
-    # Try cache first (lazy spawn)
-    if is_cache_valid(node_dir, manifest_path, venv_root):
-        cached_data = load_from_cache(node_dir, venv_root)
-        if cached_data:
-            if _is_stale_node_cache(cached_data):
-                pass
-            else:
-                try:
-                    flushed = await extension.flush_pending_routes()
-                    logger.info("][ %s flushed %d routes", extension_name, flushed)
-                except Exception as exc:
-                    logger.warning("][ %s route flush failed: %s", extension_name, exc)
-                specs: List[Tuple[str, str, type]] = []
-                for node_name, details in cached_data.items():
-                    stub_cls = build_stub_class(node_name, details, extension)
-                    specs.append(
-                        (node_name, details.get("display_name", node_name), stub_cls)
-                    )
-                return specs
-    # Cache miss - spawn process and get metadata
-
-    try:
-        remote_nodes: Dict[str, str] = await extension.list_nodes()
-    except Exception as exc:
-        logger.warning(
-            "][ %s metadata discovery failed, skipping isolated load: %s",
-            extension_name,
-            exc,
-        )
-        await _stop_extension_safe(extension, extension_name)
-        return []
-
-    if not remote_nodes:
-        logger.debug("][ %s exposed no isolated nodes; skipping", extension_name)
-        await _stop_extension_safe(extension, extension_name)
-        return []
-
-    specs: List[Tuple[str, str, type]] = []
-    cache_data: Dict[str, Dict] = {}
-
-    for node_name, display_name in remote_nodes.items():
-        try:
-            details = await extension.get_node_details(node_name)
-        except Exception as exc:
-            logger.warning(
-                "][ %s failed to load metadata for %s, skipping node: %s",
-                extension_name,
-                node_name,
-                exc,
-            )
-            continue
-        details["display_name"] = display_name
-        cache_data[node_name] = details
-        stub_cls = build_stub_class(node_name, details, extension)
-        specs.append((node_name, display_name, stub_cls))
-
-    if not specs:
-        logger.warning(
-            "][ %s produced no usable nodes after metadata scan; skipping",
-            extension_name,
-        )
-        await _stop_extension_safe(extension, extension_name)
-        return []
-
-    # Save metadata to cache for future runs
-    save_to_cache(node_dir, venv_root, cache_data, manifest_path)
-    logger.debug(f"][ {extension_name} metadata cached")
-
-    # Re-check web directory AFTER child has populated it
-    if host_policy["sandbox_mode"] == "disabled":
-        _register_web_directory(extension_name, node_dir)
-
-    # Flush any routes the child buffered during module import — must happen
-    # before router freeze and before we kill the child process.
-    try:
-        flushed = await extension.flush_pending_routes()
-        logger.info("][ %s flushed %d routes", extension_name, flushed)
-    except Exception as exc:
-        logger.warning("][ %s route flush failed: %s", extension_name, exc)
-
-    # EJECT: Kill process after getting metadata (will respawn on first execution)
-    await _stop_extension_safe(extension, extension_name)
-
-    return specs
-
-
-__all__ = ["ExtensionLoadError", "register_dummy_module", "load_isolated_node"]

comfy/isolation/extension_wrapper.py

@@ -1,942 +0,0 @@
-# pylint: disable=consider-using-from-import,cyclic-import,import-outside-toplevel,logging-fstring-interpolation,protected-access,wrong-import-position
-from __future__ import annotations
-
-import asyncio
-import torch
-
-
-class AttrDict(dict):
-    def __getattr__(self, item):
-        try:
-            return self[item]
-        except KeyError as e:
-            raise AttributeError(item) from e
-
-    def copy(self):
-        return AttrDict(super().copy())
-
-
-import importlib
-import inspect
-import json
-import logging
-import os
-import sys
-import uuid
-from dataclasses import asdict
-from typing import Any, Dict, List, Tuple
-
-from pyisolate import ExtensionBase
-
-from comfy_api.internal import _ComfyNodeInternal
-
-LOG_PREFIX = "]["
-V3_DISCOVERY_TIMEOUT = 30
-_PRE_EXEC_MIN_FREE_VRAM_BYTES = 2 * 1024 * 1024 * 1024
-
-logger = logging.getLogger(__name__)
-
-
-def _run_prestartup_web_copy(module: Any, module_dir: str, web_dir_path: str) -> None:
-    """Run the web asset copy step that prestartup_script.py used to do.
-
-    If the module's web/ directory is empty and the module had a
-    prestartup_script.py that copied assets from pip packages, this
-    function replicates that work inside the child process.
-
-    Generic pattern: reads _PRESTARTUP_WEB_COPY from the module if
-    defined, otherwise falls back to detecting common asset packages.
-    """
-    import shutil
-
-    # Already populated — nothing to do
-    if os.path.isdir(web_dir_path) and any(os.scandir(web_dir_path)):
-        return
-
-    os.makedirs(web_dir_path, exist_ok=True)
-
-    # Try module-defined copy spec first (generic hook for any node pack)
-    copy_spec = getattr(module, "_PRESTARTUP_WEB_COPY", None)
-    if copy_spec is not None and callable(copy_spec):
-        try:
-            copy_spec(web_dir_path)
-            logger.info(
-                "%s Ran _PRESTARTUP_WEB_COPY for %s", LOG_PREFIX, module_dir
-            )
-            return
-        except Exception as e:
-            logger.warning(
-                "%s _PRESTARTUP_WEB_COPY failed for %s: %s",
-                LOG_PREFIX, module_dir, e,
-            )
-
-    # Fallback: detect comfy_3d_viewers and run copy_viewer()
-    try:
-        from comfy_3d_viewers import copy_viewer, VIEWER_FILES
-        viewers = list(VIEWER_FILES.keys())
-        for viewer in viewers:
-            try:
-                copy_viewer(viewer, web_dir_path)
-            except Exception:
-                pass
-        if any(os.scandir(web_dir_path)):
-            logger.info(
-                "%s Copied %d viewer types from comfy_3d_viewers to %s",
-                LOG_PREFIX, len(viewers), web_dir_path,
-            )
-    except ImportError:
-        pass
-
-    # Fallback: detect comfy_dynamic_widgets
-    try:
-        from comfy_dynamic_widgets import get_js_path
-        src = os.path.realpath(get_js_path())
-        if os.path.exists(src):
-            dst_dir = os.path.join(web_dir_path, "js")
-            os.makedirs(dst_dir, exist_ok=True)
-            dst = os.path.join(dst_dir, "dynamic_widgets.js")
-            shutil.copy2(src, dst)
-    except ImportError:
-        pass
-
-
-def _read_extension_name(module_dir: str) -> str:
-    """Read extension name from pyproject.toml, falling back to directory name."""
-    pyproject = os.path.join(module_dir, "pyproject.toml")
-    if os.path.exists(pyproject):
-        try:
-            import tomllib
-        except ImportError:
-            import tomli as tomllib  # type: ignore[no-redef]
-        try:
-            with open(pyproject, "rb") as f:
-                data = tomllib.load(f)
-            name = data.get("project", {}).get("name")
-            if name:
-                return name
-        except Exception:
-            pass
-    return os.path.basename(module_dir)
-
-
-def _flush_tensor_transport_state(marker: str) -> int:
-    try:
-        from pyisolate import flush_tensor_keeper  # type: ignore[attr-defined]
-    except Exception:
-        return 0
-    if not callable(flush_tensor_keeper):
-        return 0
-    flushed = flush_tensor_keeper()
-    if flushed > 0:
-        logger.debug(
-            "%s %s flush_tensor_keeper released=%d", LOG_PREFIX, marker, flushed
-        )
-    return flushed
-
-
-def _relieve_child_vram_pressure(marker: str) -> None:
-    import comfy.model_management as model_management
-
-    model_management.cleanup_models_gc()
-    model_management.cleanup_models()
-
-    device = model_management.get_torch_device()
-    if not hasattr(device, "type") or device.type == "cpu":
-        return
-
-    required = max(
-        model_management.minimum_inference_memory(),
-        _PRE_EXEC_MIN_FREE_VRAM_BYTES,
-    )
-    if model_management.get_free_memory(device) < required:
-        model_management.free_memory(required, device, for_dynamic=True)
-        if model_management.get_free_memory(device) < required:
-            model_management.free_memory(required, device, for_dynamic=False)
-        model_management.cleanup_models()
-        model_management.soft_empty_cache()
-        logger.debug("%s %s free_memory target=%d", LOG_PREFIX, marker, required)
-
-
-def _sanitize_for_transport(value):
-    primitives = (str, int, float, bool, type(None))
-    if isinstance(value, primitives):
-        return value
-
-    cls_name = value.__class__.__name__
-    if cls_name == "FlexibleOptionalInputType":
-        return {
-            "__pyisolate_flexible_optional__": True,
-            "type": _sanitize_for_transport(getattr(value, "type", "*")),
-        }
-    if cls_name == "AnyType":
-        return {"__pyisolate_any_type__": True, "value": str(value)}
-    if cls_name == "ByPassTypeTuple":
-        return {
-            "__pyisolate_bypass_tuple__": [
-                _sanitize_for_transport(v) for v in tuple(value)
-            ]
-        }
-
-    if isinstance(value, dict):
-        return {k: _sanitize_for_transport(v) for k, v in value.items()}
-    if isinstance(value, tuple):
-        return {"__pyisolate_tuple__": [_sanitize_for_transport(v) for v in value]}
-    if isinstance(value, list):
-        return [_sanitize_for_transport(v) for v in value]
-
-    return str(value)
-
-
-# Re-export RemoteObjectHandle from pyisolate for backward compatibility
-# The canonical definition is now in pyisolate._internal.remote_handle
-from pyisolate._internal.remote_handle import RemoteObjectHandle  # noqa: E402,F401
-
-
-class ComfyNodeExtension(ExtensionBase):
-    def __init__(self) -> None:
-        super().__init__()
-        self.node_classes: Dict[str, type] = {}
-        self.display_names: Dict[str, str] = {}
-        self.node_instances: Dict[str, Any] = {}
-        self.remote_objects: Dict[str, Any] = {}
-        self._route_handlers: Dict[str, Any] = {}
-        self._module: Any = None
-        self._metadata_ready = asyncio.Event()
-
-    async def on_module_loaded(self, module: Any) -> None:
-        try:
-            self._module = module
-
-            # Registries are initialized in host_hooks.py initialize_host_process()
-            # They auto-register via ProxiedSingleton when instantiated
-            # NO additional setup required here - if a registry is missing from host_hooks, it WILL fail
-
-            self.node_classes = getattr(module, "NODE_CLASS_MAPPINGS", {}) or {}
-            self.display_names = getattr(module, "NODE_DISPLAY_NAME_MAPPINGS", {}) or {}
-            self._register_module_routes(module)
-
-            # Register web directory with WebDirectoryProxy (child-side)
-            web_dir_attr = getattr(module, "WEB_DIRECTORY", None)
-            if web_dir_attr is not None:
-                module_dir = os.path.dirname(os.path.abspath(module.__file__))
-                web_dir_path = os.path.abspath(os.path.join(module_dir, web_dir_attr))
-                ext_name = _read_extension_name(module_dir)
-
-                # If web dir is empty, run the copy step that prestartup_script.py did
-                _run_prestartup_web_copy(module, module_dir, web_dir_path)
-
-                if os.path.isdir(web_dir_path) and any(os.scandir(web_dir_path)):
-                    from comfy.isolation.proxies.web_directory_proxy import WebDirectoryProxy
-                    WebDirectoryProxy.register_web_dir(ext_name, web_dir_path)
-
-            try:
-                from comfy_api.latest import ComfyExtension
-
-                for name, obj in inspect.getmembers(module):
-                    if not (
-                        inspect.isclass(obj)
-                        and issubclass(obj, ComfyExtension)
-                        and obj is not ComfyExtension
-                    ):
-                        continue
-                    if not obj.__module__.startswith(module.__name__):
-                        continue
-                    try:
-                        ext_instance = obj()
-                        try:
-                            await asyncio.wait_for(
-                                ext_instance.on_load(), timeout=V3_DISCOVERY_TIMEOUT
-                            )
-                        except asyncio.TimeoutError:
-                            logger.error(
-                                "%s V3 Extension %s timed out in on_load()",
-                                LOG_PREFIX,
-                                name,
-                            )
-                            continue
-                        try:
-                            v3_nodes = await asyncio.wait_for(
-                                ext_instance.get_node_list(), timeout=V3_DISCOVERY_TIMEOUT
-                            )
-                        except asyncio.TimeoutError:
-                            logger.error(
-                                "%s V3 Extension %s timed out in get_node_list()",
-                                LOG_PREFIX,
-                                name,
-                            )
-                            continue
-                        for node_cls in v3_nodes:
-                            if hasattr(node_cls, "GET_SCHEMA"):
-                                schema = node_cls.GET_SCHEMA()
-                                self.node_classes[schema.node_id] = node_cls
-                                if schema.display_name:
-                                    self.display_names[schema.node_id] = schema.display_name
-                    except Exception as e:
-                        logger.error("%s V3 Extension %s failed: %s", LOG_PREFIX, name, e)
-            except ImportError:
-                pass
-
-            module_name = getattr(module, "__name__", "isolated_nodes")
-            for node_cls in self.node_classes.values():
-                if hasattr(node_cls, "__module__") and "/" in str(node_cls.__module__):
-                    node_cls.__module__ = module_name
-
-            self.node_instances = {}
-        finally:
-            self._metadata_ready.set()
-
-    def _register_module_routes(self, module: Any) -> None:
-        """Bridge legacy module-level ROUTES declarations into isolated routing."""
-        routes = getattr(module, "ROUTES", None) or []
-        if not routes:
-            return
-
-        from comfy.isolation.proxies.prompt_server_impl import PromptServerStub
-
-        prompt_server = PromptServerStub()
-        route_table = getattr(prompt_server, "routes", None)
-        if route_table is None:
-            logger.warning("%s Route registration unavailable for %s", LOG_PREFIX, module)
-            return
-
-        for route_spec in routes:
-            if not isinstance(route_spec, dict):
-                logger.warning("%s Ignoring non-dict ROUTES entry: %r", LOG_PREFIX, route_spec)
-                continue
-
-            method = str(route_spec.get("method", "")).strip().upper()
-            path = str(route_spec.get("path", "")).strip()
-            handler_ref = route_spec.get("handler")
-            if not method or not path:
-                logger.warning("%s Ignoring incomplete route spec: %r", LOG_PREFIX, route_spec)
-                continue
-
-            if isinstance(handler_ref, str):
-                handler = getattr(module, handler_ref, None)
-            else:
-                handler = handler_ref
-            if not callable(handler):
-                logger.warning(
-                    "%s Ignoring route with missing handler %r for %s %s",
-                    LOG_PREFIX,
-                    handler_ref,
-                    method,
-                    path,
-                )
-                continue
-
-            decorator = getattr(route_table, method.lower(), None)
-            if not callable(decorator):
-                logger.warning("%s Unsupported route method %s for %s", LOG_PREFIX, method, path)
-                continue
-
-            decorator(path)(handler)
-            self._route_handlers[f"{method} {path}"] = handler
-            logger.info("%s buffered legacy route %s %s", LOG_PREFIX, method, path)
-
-    async def list_nodes(self) -> Dict[str, str]:
-        await asyncio.wait_for(
-            self._metadata_ready.wait(), timeout=V3_DISCOVERY_TIMEOUT
-        )
-        return {name: self.display_names.get(name, name) for name in self.node_classes}
-
-    async def get_node_info(self, node_name: str) -> Dict[str, Any]:
-        return await self.get_node_details(node_name)
-
-    async def get_node_details(self, node_name: str) -> Dict[str, Any]:
-        await asyncio.wait_for(
-            self._metadata_ready.wait(), timeout=V3_DISCOVERY_TIMEOUT
-        )
-        node_cls = self._get_node_class(node_name)
-        is_v3 = issubclass(node_cls, _ComfyNodeInternal)
-
-        input_types_raw = (
-            node_cls.INPUT_TYPES() if hasattr(node_cls, "INPUT_TYPES") else {}
-        )
-        output_is_list = getattr(node_cls, "OUTPUT_IS_LIST", None)
-        if output_is_list is not None:
-            output_is_list = tuple(bool(x) for x in output_is_list)
-
-        details: Dict[str, Any] = {
-            "input_types": _sanitize_for_transport(input_types_raw),
-            "return_types": tuple(
-                str(t) for t in getattr(node_cls, "RETURN_TYPES", ())
-            ),
-            "return_names": getattr(node_cls, "RETURN_NAMES", None),
-            "function": str(getattr(node_cls, "FUNCTION", "execute")),
-            "category": str(getattr(node_cls, "CATEGORY", "")),
-            "output_node": bool(getattr(node_cls, "OUTPUT_NODE", False)),
-            "output_is_list": output_is_list,
-            "is_v3": is_v3,
-        }
-
-        if is_v3:
-            try:
-                schema = node_cls.GET_SCHEMA()
-                schema_v1 = asdict(schema.get_v1_info(node_cls))
-                try:
-                    schema_v3 = asdict(schema.get_v3_info(node_cls))
-                except (AttributeError, TypeError):
-                    schema_v3 = self._build_schema_v3_fallback(schema)
-                details.update(
-                    {
-                        "schema_v1": schema_v1,
-                        "schema_v3": schema_v3,
-                        "hidden": [h.value for h in (schema.hidden or [])],
-                        "description": getattr(schema, "description", ""),
-                        "deprecated": bool(getattr(node_cls, "DEPRECATED", False)),
-                        "experimental": bool(getattr(node_cls, "EXPERIMENTAL", False)),
-                        "api_node": bool(getattr(node_cls, "API_NODE", False)),
-                        "input_is_list": bool(
-                            getattr(node_cls, "INPUT_IS_LIST", False)
-                        ),
-                        "not_idempotent": bool(
-                            getattr(node_cls, "NOT_IDEMPOTENT", False)
-                        ),
-                        "accept_all_inputs": bool(
-                            getattr(node_cls, "ACCEPT_ALL_INPUTS", False)
-                        ),
-                    }
-                )
-            except Exception as exc:
-                logger.warning(
-                    "%s V3 schema serialization failed for %s: %s",
-                    LOG_PREFIX,
-                    node_name,
-                    exc,
-                )
-        return details
-
-    def _build_schema_v3_fallback(self, schema) -> Dict[str, Any]:
-        input_dict: Dict[str, Any] = {}
-        output_dict: Dict[str, Any] = {}
-        hidden_list: List[str] = []
-
-        if getattr(schema, "inputs", None):
-            for inp in schema.inputs:
-                self._add_schema_io_v3(inp, input_dict)
-        if getattr(schema, "outputs", None):
-            for out in schema.outputs:
-                self._add_schema_io_v3(out, output_dict)
-        if getattr(schema, "hidden", None):
-            for h in schema.hidden:
-                hidden_list.append(getattr(h, "value", str(h)))
-
-        return {
-            "input": input_dict,
-            "output": output_dict,
-            "hidden": hidden_list,
-            "name": getattr(schema, "node_id", None),
-            "display_name": getattr(schema, "display_name", None),
-            "description": getattr(schema, "description", None),
-            "category": getattr(schema, "category", None),
-            "output_node": getattr(schema, "is_output_node", False),
-            "deprecated": getattr(schema, "is_deprecated", False),
-            "experimental": getattr(schema, "is_experimental", False),
-            "api_node": getattr(schema, "is_api_node", False),
-        }
-
-    def _add_schema_io_v3(self, io_obj: Any, target: Dict[str, Any]) -> None:
-        io_id = getattr(io_obj, "id", None)
-        if io_id is None:
-            return
-
-        io_type_fn = getattr(io_obj, "get_io_type", None)
-        io_type = (
-            io_type_fn() if callable(io_type_fn) else getattr(io_obj, "io_type", None)
-        )
-
-        as_dict_fn = getattr(io_obj, "as_dict", None)
-        payload = as_dict_fn() if callable(as_dict_fn) else {}
-
-        target[str(io_id)] = (io_type, payload)
-
-    async def get_input_types(self, node_name: str) -> Dict[str, Any]:
-        node_cls = self._get_node_class(node_name)
-        if hasattr(node_cls, "INPUT_TYPES"):
-            return node_cls.INPUT_TYPES()
-        return {}
-
-    async def execute_node(self, node_name: str, **inputs: Any) -> Tuple[Any, ...]:
-        logger.debug(
-            "%s ISO:child_execute_start ext=%s node=%s input_keys=%d",
-            LOG_PREFIX,
-            getattr(self, "name", "?"),
-            node_name,
-            len(inputs),
-        )
-        if os.environ.get("PYISOLATE_CHILD") == "1":
-            _relieve_child_vram_pressure("EXT:pre_execute")
-
-        resolved_inputs = self._resolve_remote_objects(inputs)
-
-        instance = self._get_node_instance(node_name)
-        node_cls = self._get_node_class(node_name)
-
-        # V3 API nodes expect hidden parameters in cls.hidden, not as kwargs
-        # Hidden params come through RPC as string keys like "Hidden.prompt"
-        from comfy_api.latest._io import Hidden, HiddenHolder
-
-        # Map string representations back to Hidden enum keys
-        hidden_string_map = {
-            "Hidden.unique_id": Hidden.unique_id,
-            "Hidden.prompt": Hidden.prompt,
-            "Hidden.extra_pnginfo": Hidden.extra_pnginfo,
-            "Hidden.dynprompt": Hidden.dynprompt,
-            "Hidden.auth_token_comfy_org": Hidden.auth_token_comfy_org,
-            "Hidden.api_key_comfy_org": Hidden.api_key_comfy_org,
-            # Uppercase enum VALUE forms — V3 execution engine passes these
-            "UNIQUE_ID": Hidden.unique_id,
-            "PROMPT": Hidden.prompt,
-            "EXTRA_PNGINFO": Hidden.extra_pnginfo,
-            "DYNPROMPT": Hidden.dynprompt,
-            "AUTH_TOKEN_COMFY_ORG": Hidden.auth_token_comfy_org,
-            "API_KEY_COMFY_ORG": Hidden.api_key_comfy_org,
-        }
-
-        # Find and extract hidden parameters (both enum and string form)
-        hidden_found = {}
-        keys_to_remove = []
-
-        for key in list(resolved_inputs.keys()):
-            # Check string form first (from RPC serialization)
-            if key in hidden_string_map:
-                hidden_found[hidden_string_map[key]] = resolved_inputs[key]
-                keys_to_remove.append(key)
-            # Also check enum form (direct calls)
-            elif isinstance(key, Hidden):
-                hidden_found[key] = resolved_inputs[key]
-                keys_to_remove.append(key)
-
-        # Remove hidden params from kwargs
-        for key in keys_to_remove:
-            resolved_inputs.pop(key)
-
-        # Set hidden on node class if any hidden params found
-        if hidden_found:
-            if not hasattr(node_cls, "hidden") or node_cls.hidden is None:
-                node_cls.hidden = HiddenHolder.from_dict(hidden_found)
-            else:
-                # Update existing hidden holder
-                for key, value in hidden_found.items():
-                    setattr(node_cls.hidden, key.value.lower(), value)
-
-        # INPUT_IS_LIST: ComfyUI's executor passes all inputs as lists when this
-        # flag is set.  The isolation RPC delivers unwrapped values, so we must
-        # wrap each input in a single-element list to match the contract.
-        if getattr(node_cls, "INPUT_IS_LIST", False):
-            resolved_inputs = {k: [v] for k, v in resolved_inputs.items()}
-
-        function_name = getattr(node_cls, "FUNCTION", "execute")
-        if not hasattr(instance, function_name):
-            raise AttributeError(f"Node {node_name} missing callable '{function_name}'")
-
-        handler = getattr(instance, function_name)
-
-        try:
-            import torch
-            if asyncio.iscoroutinefunction(handler):
-                with torch.inference_mode():
-                    result = await handler(**resolved_inputs)
-            else:
-                import functools
-
-                def _run_with_inference_mode(**kwargs):
-                    with torch.inference_mode():
-                        return handler(**kwargs)
-
-                loop = asyncio.get_running_loop()
-                result = await loop.run_in_executor(
-                    None, functools.partial(_run_with_inference_mode, **resolved_inputs)
-                )
-        except Exception:
-            logger.exception(
-                "%s ISO:child_execute_error ext=%s node=%s",
-                LOG_PREFIX,
-                getattr(self, "name", "?"),
-                node_name,
-            )
-            raise
-
-        if type(result).__name__ == "NodeOutput":
-            node_output_dict = {
-                "__node_output__": True,
-                "args": self._wrap_unpicklable_objects(result.args),
-            }
-            if result.ui is not None:
-                node_output_dict["ui"] = self._wrap_unpicklable_objects(result.ui)
-            if getattr(result, "expand", None) is not None:
-                node_output_dict["expand"] = result.expand
-            if getattr(result, "block_execution", None) is not None:
-                node_output_dict["block_execution"] = result.block_execution
-            return node_output_dict
-        if self._is_comfy_protocol_return(result):
-            wrapped = self._wrap_unpicklable_objects(result)
-            return wrapped
-
-        if not isinstance(result, tuple):
-            result = (result,)
-        wrapped = self._wrap_unpicklable_objects(result)
-        return wrapped
-
-    async def flush_pending_routes(self) -> int:
-        """Flush buffered route registrations to host via RPC. Called by host after node discovery."""
-        from comfy.isolation.proxies.prompt_server_impl import PromptServerStub
-        return await PromptServerStub.flush_child_routes()
-
-    async def flush_transport_state(self) -> int:
-        if os.environ.get("PYISOLATE_CHILD") != "1":
-            return 0
-        logger.debug(
-            "%s ISO:child_flush_start ext=%s", LOG_PREFIX, getattr(self, "name", "?")
-        )
-        flushed = _flush_tensor_transport_state("EXT:workflow_end")
-        try:
-            from comfy.isolation.model_patcher_proxy_registry import (
-                ModelPatcherRegistry,
-            )
-
-            registry = ModelPatcherRegistry()
-            removed = registry.sweep_pending_cleanup()
-            if removed > 0:
-                logger.debug(
-                    "%s EXT:workflow_end registry sweep removed=%d", LOG_PREFIX, removed
-                )
-        except Exception:
-            logger.debug(
-                "%s EXT:workflow_end registry sweep failed", LOG_PREFIX, exc_info=True
-            )
-        logger.debug(
-            "%s ISO:child_flush_done ext=%s flushed=%d",
-            LOG_PREFIX,
-            getattr(self, "name", "?"),
-            flushed,
-        )
-        return flushed
-
-    async def get_remote_object(self, object_id: str) -> Any:
-        """Retrieve a remote object by ID for host-side deserialization."""
-        if object_id not in self.remote_objects:
-            raise KeyError(f"Remote object {object_id} not found")
-
-        return self.remote_objects[object_id]
-
-    def _store_remote_object_handle(self, obj: Any) -> RemoteObjectHandle:
-        object_id = str(uuid.uuid4())
-        self.remote_objects[object_id] = obj
-        return RemoteObjectHandle(object_id, type(obj).__name__)
-
-    async def call_remote_object_method(
-        self,
-        object_id: str,
-        method_name: str,
-        *args: Any,
-        **kwargs: Any,
-    ) -> Any:
-        """Invoke a method or attribute-backed accessor on a child-owned object."""
-        obj = await self.get_remote_object(object_id)
-
-        if method_name == "get_patcher_attr":
-            return getattr(obj, args[0])
-        if method_name == "get_model_options":
-            return getattr(obj, "model_options")
-        if method_name == "set_model_options":
-            setattr(obj, "model_options", args[0])
-            return None
-        if method_name == "get_object_patches":
-            return getattr(obj, "object_patches")
-        if method_name == "get_patches":
-            return getattr(obj, "patches")
-        if method_name == "get_wrappers":
-            return getattr(obj, "wrappers")
-        if method_name == "get_callbacks":
-            return getattr(obj, "callbacks")
-        if method_name == "get_load_device":
-            return getattr(obj, "load_device")
-        if method_name == "get_offload_device":
-            return getattr(obj, "offload_device")
-        if method_name == "get_hook_mode":
-            return getattr(obj, "hook_mode")
-        if method_name == "get_parent":
-            parent = getattr(obj, "parent", None)
-            if parent is None:
-                return None
-            return self._store_remote_object_handle(parent)
-        if method_name == "get_inner_model_attr":
-            attr_name = args[0]
-            if hasattr(obj.model, attr_name):
-                return getattr(obj.model, attr_name)
-            if hasattr(obj, attr_name):
-                return getattr(obj, attr_name)
-            return None
-        if method_name == "inner_model_apply_model":
-            return obj.model.apply_model(*args[0], **args[1])
-        if method_name == "inner_model_extra_conds_shapes":
-            return obj.model.extra_conds_shapes(*args[0], **args[1])
-        if method_name == "inner_model_extra_conds":
-            return obj.model.extra_conds(*args[0], **args[1])
-        if method_name == "inner_model_memory_required":
-            return obj.model.memory_required(*args[0], **args[1])
-        if method_name == "process_latent_in":
-            return obj.model.process_latent_in(*args[0], **args[1])
-        if method_name == "process_latent_out":
-            return obj.model.process_latent_out(*args[0], **args[1])
-        if method_name == "scale_latent_inpaint":
-            return obj.model.scale_latent_inpaint(*args[0], **args[1])
-        if method_name.startswith("get_"):
-            attr_name = method_name[4:]
-            if hasattr(obj, attr_name):
-                return getattr(obj, attr_name)
-
-        target = getattr(obj, method_name)
-        if callable(target):
-            result = target(*args, **kwargs)
-            if inspect.isawaitable(result):
-                result = await result
-            if type(result).__name__ == "ModelPatcher":
-                return self._store_remote_object_handle(result)
-            return result
-        if args or kwargs:
-            raise TypeError(f"{method_name} is not callable on remote object {object_id}")
-        return target
-
-    def _wrap_unpicklable_objects(self, data: Any) -> Any:
-        if isinstance(data, (str, int, float, bool, type(None))):
-            return data
-        if isinstance(data, torch.Tensor):
-            tensor = data.detach() if data.requires_grad else data
-            if os.environ.get("PYISOLATE_CHILD") == "1" and tensor.device.type != "cpu":
-                return tensor.cpu()
-            return tensor
-
-        # Special-case clip vision outputs: preserve attribute access by packing fields
-        if hasattr(data, "penultimate_hidden_states") or hasattr(
-            data, "last_hidden_state"
-        ):
-            fields = {}
-            for attr in (
-                "penultimate_hidden_states",
-                "last_hidden_state",
-                "image_embeds",
-                "text_embeds",
-            ):
-                if hasattr(data, attr):
-                    try:
-                        fields[attr] = self._wrap_unpicklable_objects(
-                            getattr(data, attr)
-                        )
-                    except Exception:
-                        pass
-            if fields:
-                return {"__pyisolate_attribute_container__": True, "data": fields}
-
-        # Avoid converting arbitrary objects with stateful methods (models, etc.)
-        # They will be handled via RemoteObjectHandle below.
-
-        type_name = type(data).__name__
-        if type_name == "ModelPatcherProxy":
-            return {"__type__": "ModelPatcherRef", "model_id": data._instance_id}
-        if type_name == "CLIPProxy":
-            return {"__type__": "CLIPRef", "clip_id": data._instance_id}
-        if type_name == "VAEProxy":
-            return {"__type__": "VAERef", "vae_id": data._instance_id}
-        if type_name == "ModelSamplingProxy":
-            return {"__type__": "ModelSamplingRef", "ms_id": data._instance_id}
-
-        if isinstance(data, (list, tuple)):
-            wrapped = [self._wrap_unpicklable_objects(item) for item in data]
-            return tuple(wrapped) if isinstance(data, tuple) else wrapped
-        if isinstance(data, dict):
-            converted_dict = {
-                k: self._wrap_unpicklable_objects(v) for k, v in data.items()
-            }
-            return {"__pyisolate_attrdict__": True, "data": converted_dict}
-
-        from pyisolate._internal.serialization_registry import SerializerRegistry
-
-        registry = SerializerRegistry.get_instance()
-        if registry.is_data_type(type_name):
-            serializer = registry.get_serializer(type_name)
-            if serializer:
-                return serializer(data)
-
-        return self._store_remote_object_handle(data)
-
-    def _resolve_remote_objects(self, data: Any) -> Any:
-        if isinstance(data, RemoteObjectHandle):
-            if data.object_id not in self.remote_objects:
-                raise KeyError(f"Remote object {data.object_id} not found")
-            return self.remote_objects[data.object_id]
-
-        if isinstance(data, dict):
-            ref_type = data.get("__type__")
-            if ref_type in ("CLIPRef", "ModelPatcherRef", "VAERef"):
-                from pyisolate._internal.model_serialization import (
-                    deserialize_proxy_result,
-                )
-
-                return deserialize_proxy_result(data)
-            if ref_type == "ModelSamplingRef":
-                from pyisolate._internal.model_serialization import (
-                    deserialize_proxy_result,
-                )
-
-                return deserialize_proxy_result(data)
-            return {k: self._resolve_remote_objects(v) for k, v in data.items()}
-
-        if isinstance(data, (list, tuple)):
-            resolved = [self._resolve_remote_objects(item) for item in data]
-            return tuple(resolved) if isinstance(data, tuple) else resolved
-        return data
-
-    def _get_node_class(self, node_name: str) -> type:
-        if node_name not in self.node_classes:
-            raise KeyError(f"Unknown node: {node_name}")
-        return self.node_classes[node_name]
-
-    def _get_node_instance(self, node_name: str) -> Any:
-        if node_name not in self.node_instances:
-            if node_name not in self.node_classes:
-                raise KeyError(f"Unknown node: {node_name}")
-            self.node_instances[node_name] = self.node_classes[node_name]()
-        return self.node_instances[node_name]
-
-    async def before_module_loaded(self) -> None:
-        try:
-            from comfy.isolation import initialize_proxies
-
-            initialize_proxies()
-        except Exception as e:
-            logger.error(
-                "%s before_module_loaded initialize_proxies FAILED: %s", LOG_PREFIX, e
-            )
-
-        await super().before_module_loaded()
-        try:
-            from comfy_api.latest import ComfyAPI_latest
-            from .proxies.progress_proxy import ProgressProxy
-
-            ComfyAPI_latest.Execution = ProgressProxy
-            # ComfyAPI_latest.execution = ProgressProxy()  # Eliminated to avoid Singleton collision
-            # fp_proxy = FolderPathsProxy()                 # Eliminated to avoid Singleton collision
-            # latest_ui.folder_paths = fp_proxy
-            # latest_resources.folder_paths = fp_proxy
-        except Exception:
-            pass
-
-    async def call_route_handler(
-        self,
-        handler_module: str,
-        handler_func: str,
-        request_data: Dict[str, Any],
-    ) -> Any:
-        cache_key = f"{handler_module}.{handler_func}"
-        if cache_key not in self._route_handlers:
-            if self._module is not None and hasattr(self._module, "__file__"):
-                node_dir = os.path.dirname(self._module.__file__)
-                if node_dir not in sys.path:
-                    sys.path.insert(0, node_dir)
-            try:
-                module = importlib.import_module(handler_module)
-                self._route_handlers[cache_key] = getattr(module, handler_func)
-            except (ImportError, AttributeError) as e:
-                raise ValueError(f"Route handler not found: {cache_key}") from e
-
-        handler = self._route_handlers[cache_key]
-        mock_request = MockRequest(request_data)
-
-        if asyncio.iscoroutinefunction(handler):
-            result = await handler(mock_request)
-        else:
-            result = handler(mock_request)
-        return self._serialize_response(result)
-
-    def _is_comfy_protocol_return(self, result: Any) -> bool:
-        """
-        Check if the result matches the ComfyUI 'Protocol Return' schema.
-
-        A Protocol Return is a dictionary containing specific reserved keys that
-        ComfyUI's execution engine interprets as instructions (UI updates,
-        Workflow expansion, etc.) rather than purely data outputs.
-
-        Schema:
-           - Must be a dict
-           - Must contain at least one of: 'ui', 'result', 'expand'
-        """
-        if not isinstance(result, dict):
-            return False
-        return any(key in result for key in ("ui", "result", "expand"))
-
-    def _serialize_response(self, response: Any) -> Dict[str, Any]:
-        if response is None:
-            return {"type": "text", "body": "", "status": 204}
-        if isinstance(response, dict):
-            return {"type": "json", "body": response, "status": 200}
-        if isinstance(response, str):
-            return {"type": "text", "body": response, "status": 200}
-        if hasattr(response, "text") and hasattr(response, "status"):
-            return {
-                "type": "text",
-                "body": response.text
-                if hasattr(response, "text")
-                else str(response.body),
-                "status": response.status,
-                "headers": dict(response.headers)
-                if hasattr(response, "headers")
-                else {},
-            }
-        if hasattr(response, "body") and hasattr(response, "status"):
-            body = response.body
-            if isinstance(body, bytes):
-                try:
-                    return {
-                        "type": "text",
-                        "body": body.decode("utf-8"),
-                        "status": response.status,
-                    }
-                except UnicodeDecodeError:
-                    return {
-                        "type": "binary",
-                        "body": body.hex(),
-                        "status": response.status,
-                    }
-            return {"type": "json", "body": body, "status": response.status}
-        return {"type": "text", "body": str(response), "status": 200}
-
-
-class MockRequest:
-    def __init__(self, data: Dict[str, Any]):
-        self.method = data.get("method", "GET")
-        self.path = data.get("path", "/")
-        self.query = data.get("query", {})
-        self._body = data.get("body", {})
-        self._text = data.get("text", "")
-        self.headers = data.get("headers", {})
-        self.content_type = data.get(
-            "content_type", self.headers.get("Content-Type", "application/json")
-        )
-        self.match_info = data.get("match_info", {})
-
-    async def json(self) -> Any:
-        if isinstance(self._body, dict):
-            return self._body
-        if isinstance(self._body, str):
-            return json.loads(self._body)
-        return {}
-
-    async def post(self) -> Dict[str, Any]:
-        if isinstance(self._body, dict):
-            return self._body
-        return {}
-
-    async def text(self) -> str:
-        if self._text:
-            return self._text
-        if isinstance(self._body, str):
-            return self._body
-        if isinstance(self._body, dict):
-            return json.dumps(self._body)
-        return ""
-
-    async def read(self) -> bytes:
-        return (await self.text()).encode("utf-8")

comfy/isolation/host_hooks.py

@@ -1,25 +0,0 @@
-# pylint: disable=import-outside-toplevel
-# Host process initialization for PyIsolate
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-def initialize_host_process() -> None:
-    from .proxies.folder_paths_proxy import FolderPathsProxy
-    from .proxies.helper_proxies import HelperProxiesService
-    from .proxies.model_management_proxy import ModelManagementProxy
-    from .proxies.progress_proxy import ProgressProxy
-    from .proxies.prompt_server_impl import PromptServerService
-    from .proxies.utils_proxy import UtilsProxy
-    from .proxies.web_directory_proxy import WebDirectoryProxy
-    from .vae_proxy import VAERegistry
-
-    FolderPathsProxy()
-    HelperProxiesService()
-    ModelManagementProxy()
-    ProgressProxy()
-    PromptServerService()
-    UtilsProxy()
-    WebDirectoryProxy()
-    VAERegistry()

comfy/isolation/host_policy.py

@@ -1,180 +0,0 @@
-# pylint: disable=logging-fstring-interpolation
-from __future__ import annotations
-
-import logging
-import os
-from pathlib import Path
-from pathlib import PurePosixPath
-from typing import Dict, List, TypedDict
-
-try:
-    import tomllib
-except ImportError:
-    import tomli as tomllib  # type: ignore[no-redef]
-
-logger = logging.getLogger(__name__)
-
-HOST_POLICY_PATH_ENV = "COMFY_HOST_POLICY_PATH"
-VALID_SANDBOX_MODES = frozenset({"required", "disabled"})
-FORBIDDEN_WRITABLE_PATHS = frozenset({"/tmp"})
-
-
-class HostSecurityPolicy(TypedDict):
-    sandbox_mode: str
-    allow_network: bool
-    writable_paths: List[str]
-    readonly_paths: List[str]
-    sealed_worker_ro_import_paths: List[str]
-    whitelist: Dict[str, str]
-
-
-DEFAULT_POLICY: HostSecurityPolicy = {
-    "sandbox_mode": "required",
-    "allow_network": False,
-    "writable_paths": ["/dev/shm"],
-    "readonly_paths": [],
-    "sealed_worker_ro_import_paths": [],
-    "whitelist": {},
-}
-
-
-def _default_policy() -> HostSecurityPolicy:
-    return {
-        "sandbox_mode": DEFAULT_POLICY["sandbox_mode"],
-        "allow_network": DEFAULT_POLICY["allow_network"],
-        "writable_paths": list(DEFAULT_POLICY["writable_paths"]),
-        "readonly_paths": list(DEFAULT_POLICY["readonly_paths"]),
-        "sealed_worker_ro_import_paths": list(DEFAULT_POLICY["sealed_worker_ro_import_paths"]),
-        "whitelist": dict(DEFAULT_POLICY["whitelist"]),
-    }
-
-
-def _normalize_writable_paths(paths: list[object]) -> list[str]:
-    normalized_paths: list[str] = []
-    for raw_path in paths:
-        # Host-policy paths are contract-style POSIX paths; keep representation
-        # stable across Windows/Linux so tests and config behavior stay consistent.
-        normalized_path = str(PurePosixPath(str(raw_path).replace("\\", "/")))
-        if normalized_path in FORBIDDEN_WRITABLE_PATHS:
-            continue
-        normalized_paths.append(normalized_path)
-    return normalized_paths
-
-
-def _load_whitelist_file(file_path: Path, config_path: Path) -> Dict[str, str]:
-    if not file_path.is_absolute():
-        file_path = config_path.parent / file_path
-    if not file_path.exists():
-        logger.warning("whitelist_file %s not found, skipping.", file_path)
-        return {}
-    entries: Dict[str, str] = {}
-    for line in file_path.read_text().splitlines():
-        line = line.strip()
-        if not line or line.startswith("#"):
-            continue
-        entries[line] = "*"
-    logger.debug("Loaded %d whitelist entries from %s", len(entries), file_path)
-    return entries
-
-
-def _normalize_sealed_worker_ro_import_paths(raw_paths: object) -> list[str]:
-    if not isinstance(raw_paths, list):
-        raise ValueError(
-            "tool.comfy.host.sealed_worker_ro_import_paths must be a list of absolute paths."
-        )
-
-    normalized_paths: list[str] = []
-    seen: set[str] = set()
-    for raw_path in raw_paths:
-        if not isinstance(raw_path, str) or not raw_path.strip():
-            raise ValueError(
-                "tool.comfy.host.sealed_worker_ro_import_paths entries must be non-empty strings."
-            )
-        normalized_path = str(PurePosixPath(raw_path.replace("\\", "/")))
-        # Accept both POSIX absolute paths (/home/...) and Windows drive-letter paths (D:/...)
-        is_absolute = normalized_path.startswith("/") or (
-            len(normalized_path) >= 3 and normalized_path[1] == ":" and normalized_path[2] == "/"
-        )
-        if not is_absolute:
-            raise ValueError(
-                "tool.comfy.host.sealed_worker_ro_import_paths entries must be absolute paths."
-            )
-        if normalized_path not in seen:
-            seen.add(normalized_path)
-            normalized_paths.append(normalized_path)
-
-    return normalized_paths
-
-
-def load_host_policy(comfy_root: Path) -> HostSecurityPolicy:
-    config_override = os.environ.get(HOST_POLICY_PATH_ENV)
-    config_path = Path(config_override) if config_override else comfy_root / "pyproject.toml"
-    policy = _default_policy()
-
-    if not config_path.exists():
-        logger.debug("Host policy file missing at %s, using defaults.", config_path)
-        return policy
-
-    try:
-        with config_path.open("rb") as f:
-            data = tomllib.load(f)
-    except Exception:
-        logger.warning(
-            "Failed to parse host policy from %s, using defaults.",
-            config_path,
-            exc_info=True,
-        )
-        return policy
-
-    tool_config = data.get("tool", {}).get("comfy", {}).get("host", {})
-    if not isinstance(tool_config, dict):
-        logger.debug("No [tool.comfy.host] section found, using defaults.")
-        return policy
-
-    sandbox_mode = tool_config.get("sandbox_mode")
-    if isinstance(sandbox_mode, str):
-        normalized_sandbox_mode = sandbox_mode.strip().lower()
-        if normalized_sandbox_mode in VALID_SANDBOX_MODES:
-            policy["sandbox_mode"] = normalized_sandbox_mode
-        else:
-            logger.warning(
-                "Invalid host sandbox_mode %r in %s, using default %r.",
-                sandbox_mode,
-                config_path,
-                DEFAULT_POLICY["sandbox_mode"],
-            )
-
-    if "allow_network" in tool_config:
-        policy["allow_network"] = bool(tool_config["allow_network"])
-
-    if "writable_paths" in tool_config:
-        policy["writable_paths"] = _normalize_writable_paths(tool_config["writable_paths"])
-
-    if "readonly_paths" in tool_config:
-        policy["readonly_paths"] = [str(p) for p in tool_config["readonly_paths"]]
-
-    if "sealed_worker_ro_import_paths" in tool_config:
-        policy["sealed_worker_ro_import_paths"] = _normalize_sealed_worker_ro_import_paths(
-            tool_config["sealed_worker_ro_import_paths"]
-        )
-
-    whitelist_file = tool_config.get("whitelist_file")
-    if isinstance(whitelist_file, str):
-        policy["whitelist"].update(_load_whitelist_file(Path(whitelist_file), config_path))
-
-    whitelist_raw = tool_config.get("whitelist")
-    if isinstance(whitelist_raw, dict):
-        policy["whitelist"].update({str(k): str(v) for k, v in whitelist_raw.items()})
-
-    os.environ["PYISOLATE_SANDBOX_MODE"] = policy["sandbox_mode"]
-
-    logger.debug(
-        "Loaded Host Policy: %d whitelisted nodes, Sandbox=%s, Network=%s",
-        len(policy["whitelist"]),
-        policy["sandbox_mode"],
-        policy["allow_network"],
-    )
-    return policy
-
-
-__all__ = ["HostSecurityPolicy", "load_host_policy", "DEFAULT_POLICY"]

comfy/isolation/manifest_loader.py

@@ -1,221 +0,0 @@
-# pylint: disable=import-outside-toplevel
-from __future__ import annotations
-
-import hashlib
-import json
-import logging
-import os
-import sys
-import tempfile
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-
-import folder_paths
-
-try:
-    import tomllib
-except ImportError:
-    import tomli as tomllib  # type: ignore[no-redef]
-
-LOG_PREFIX = "]["
-logger = logging.getLogger(__name__)
-
-CACHE_SUBDIR = "cache"
-CACHE_KEY_FILE = "cache_key"
-CACHE_DATA_FILE = "node_info.json"
-CACHE_KEY_LENGTH = 16
-_NESTED_SCAN_ROOT = "packages"
-_IGNORED_MANIFEST_DIRS = {".git", ".venv", "__pycache__"}
-
-
-def _read_manifest(manifest_path: Path) -> dict[str, Any] | None:
-    try:
-        with manifest_path.open("rb") as f:
-            data = tomllib.load(f)
-        if isinstance(data, dict):
-            return data
-    except Exception:
-        return None
-    return None
-
-
-def _is_isolation_manifest(data: dict[str, Any]) -> bool:
-    return (
-        "tool" in data
-        and "comfy" in data["tool"]
-        and "isolation" in data["tool"]["comfy"]
-    )
-
-
-def _discover_nested_manifests(entry: Path) -> List[Tuple[Path, Path]]:
-    packages_root = entry / _NESTED_SCAN_ROOT
-    if not packages_root.exists() or not packages_root.is_dir():
-        return []
-
-    nested: List[Tuple[Path, Path]] = []
-    for manifest in sorted(packages_root.rglob("pyproject.toml")):
-        node_dir = manifest.parent
-        if any(part in _IGNORED_MANIFEST_DIRS for part in node_dir.parts):
-            continue
-
-        data = _read_manifest(manifest)
-        if not data or not _is_isolation_manifest(data):
-            continue
-
-        isolation = data["tool"]["comfy"]["isolation"]
-        if isolation.get("standalone") is True:
-            nested.append((node_dir, manifest))
-
-    return nested
-
-
-def find_manifest_directories() -> List[Tuple[Path, Path]]:
-    """Find custom node directories containing a valid pyproject.toml with [tool.comfy.isolation]."""
-    manifest_dirs: List[Tuple[Path, Path]] = []
-
-    # Standard custom_nodes paths
-    for base_path in folder_paths.get_folder_paths("custom_nodes"):
-        base = Path(base_path)
-        if not base.exists() or not base.is_dir():
-            continue
-
-        for entry in base.iterdir():
-            if not entry.is_dir():
-                continue
-
-            # Look for pyproject.toml
-            manifest = entry / "pyproject.toml"
-            if not manifest.exists():
-                continue
-
-            data = _read_manifest(manifest)
-            if not data or not _is_isolation_manifest(data):
-                continue
-
-            manifest_dirs.append((entry, manifest))
-            manifest_dirs.extend(_discover_nested_manifests(entry))
-
-    return manifest_dirs
-
-
-def compute_cache_key(node_dir: Path, manifest_path: Path) -> str:
-    """Hash manifest + .py mtimes + Python version + PyIsolate version."""
-    hasher = hashlib.sha256()
-
-    try:
-        # Hashing the manifest content ensures config changes invalidate cache
-        hasher.update(manifest_path.read_bytes())
-    except OSError:
-        hasher.update(b"__manifest_read_error__")
-
-    try:
-        py_files = sorted(node_dir.rglob("*.py"))
-        for py_file in py_files:
-            rel_path = py_file.relative_to(node_dir)
-            if "__pycache__" in str(rel_path) or ".venv" in str(rel_path):
-                continue
-            hasher.update(str(rel_path).encode("utf-8"))
-            try:
-                hasher.update(str(py_file.stat().st_mtime).encode("utf-8"))
-            except OSError:
-                hasher.update(b"__file_stat_error__")
-    except OSError:
-        hasher.update(b"__dir_scan_error__")
-
-    hasher.update(sys.version.encode("utf-8"))
-
-    try:
-        import pyisolate
-
-        hasher.update(pyisolate.__version__.encode("utf-8"))
-    except (ImportError, AttributeError):
-        hasher.update(b"__pyisolate_unknown__")
-
-    return hasher.hexdigest()[:CACHE_KEY_LENGTH]
-
-
-def get_cache_path(node_dir: Path, venv_root: Path) -> Tuple[Path, Path]:
-    """Return (cache_key_file, cache_data_file) in venv_root/{node}/cache/."""
-    cache_dir = venv_root / node_dir.name / CACHE_SUBDIR
-    return (cache_dir / CACHE_KEY_FILE, cache_dir / CACHE_DATA_FILE)
-
-
-def is_cache_valid(node_dir: Path, manifest_path: Path, venv_root: Path) -> bool:
-    """Return True only if stored cache key matches current computed key."""
-    try:
-        cache_key_file, cache_data_file = get_cache_path(node_dir, venv_root)
-        if not cache_key_file.exists() or not cache_data_file.exists():
-            return False
-        current_key = compute_cache_key(node_dir, manifest_path)
-        stored_key = cache_key_file.read_text(encoding="utf-8").strip()
-        return current_key == stored_key
-    except Exception as e:
-        logger.debug(
-            "%s Cache validation error for %s: %s", LOG_PREFIX, node_dir.name, e
-        )
-        return False
-
-
-def load_from_cache(node_dir: Path, venv_root: Path) -> Optional[Dict[str, Any]]:
-    """Load node metadata from cache, return None on any error."""
-    try:
-        _, cache_data_file = get_cache_path(node_dir, venv_root)
-        if not cache_data_file.exists():
-            return None
-        data = json.loads(cache_data_file.read_text(encoding="utf-8"))
-        if not isinstance(data, dict):
-            return None
-        return data
-    except Exception:
-        return None
-
-
-def save_to_cache(
-    node_dir: Path, venv_root: Path, node_data: Dict[str, Any], manifest_path: Path
-) -> None:
-    """Save node metadata and cache key atomically."""
-    try:
-        cache_key_file, cache_data_file = get_cache_path(node_dir, venv_root)
-        cache_dir = cache_key_file.parent
-        cache_dir.mkdir(parents=True, exist_ok=True)
-        cache_key = compute_cache_key(node_dir, manifest_path)
-
-        # Atomic write: data
-        tmp_data_fd, tmp_data_path = tempfile.mkstemp(dir=str(cache_dir), suffix=".tmp")
-        try:
-            with os.fdopen(tmp_data_fd, "w", encoding="utf-8") as f:
-                json.dump(node_data, f, indent=2)
-            os.replace(tmp_data_path, cache_data_file)
-        except Exception:
-            try:
-                os.unlink(tmp_data_path)
-            except OSError:
-                pass
-            raise
-
-        # Atomic write: key
-        tmp_key_fd, tmp_key_path = tempfile.mkstemp(dir=str(cache_dir), suffix=".tmp")
-        try:
-            with os.fdopen(tmp_key_fd, "w", encoding="utf-8") as f:
-                f.write(cache_key)
-            os.replace(tmp_key_path, cache_key_file)
-        except Exception:
-            try:
-                os.unlink(tmp_key_path)
-            except OSError:
-                pass
-            raise
-
-    except Exception as e:
-        logger.warning("%s Cache save failed for %s: %s", LOG_PREFIX, node_dir.name, e)
-
-
-__all__ = [
-    "LOG_PREFIX",
-    "find_manifest_directories",
-    "compute_cache_key",
-    "get_cache_path",
-    "is_cache_valid",
-    "load_from_cache",
-    "save_to_cache",
-]

comfy/isolation/model_patcher_proxy.py

@@ -1,891 +0,0 @@
-# pylint: disable=bare-except,consider-using-from-import,import-outside-toplevel,protected-access
-# RPC proxy for ModelPatcher (parent process)
-from __future__ import annotations
-
-import logging
-from typing import Any, Optional, List, Set, Dict, Callable
-
-from comfy.isolation.proxies.base import (
-    IS_CHILD_PROCESS,
-    BaseProxy,
-)
-from comfy.isolation.model_patcher_proxy_registry import (
-    ModelPatcherRegistry,
-    AutoPatcherEjector,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class ModelPatcherProxy(BaseProxy[ModelPatcherRegistry]):
-    _registry_class = ModelPatcherRegistry
-    __module__ = "comfy.model_patcher"
-    _APPLY_MODEL_GUARD_PADDING_BYTES = 32 * 1024 * 1024
-
-    def _spawn_related_proxy(self, instance_id: str) -> "ModelPatcherProxy":
-        proxy = ModelPatcherProxy(
-            instance_id,
-            self._registry,
-            manage_lifecycle=not IS_CHILD_PROCESS,
-        )
-        if getattr(self, "_rpc_caller", None) is not None:
-            proxy._rpc_caller = self._rpc_caller
-        return proxy
-
-    def _get_rpc(self) -> Any:
-        if self._rpc_caller is None:
-            from pyisolate._internal.rpc_protocol import get_child_rpc_instance
-
-            rpc = get_child_rpc_instance()
-            if rpc is not None:
-                self._rpc_caller = rpc.create_caller(
-                    self._registry_class, self._registry_class.get_remote_id()
-                )
-            else:
-                self._rpc_caller = self._registry
-        return self._rpc_caller
-
-    def get_all_callbacks(self, call_type: str = None) -> Any:
-        return self._call_rpc("get_all_callbacks", call_type)
-
-    def get_all_wrappers(self, wrapper_type: str = None) -> Any:
-        return self._call_rpc("get_all_wrappers", wrapper_type)
-
-    def _load_list(self, *args, **kwargs) -> Any:
-        return self._call_rpc("load_list_internal", *args, **kwargs)
-
-    def prepare_hook_patches_current_keyframe(
-        self, t: Any, hook_group: Any, model_options: Any
-    ) -> None:
-        self._call_rpc(
-            "prepare_hook_patches_current_keyframe", t, hook_group, model_options
-        )
-
-    def add_hook_patches(
-        self,
-        hook: Any,
-        patches: Any,
-        strength_patch: float = 1.0,
-        strength_model: float = 1.0,
-    ) -> None:
-        self._call_rpc(
-            "add_hook_patches", hook, patches, strength_patch, strength_model
-        )
-
-    def clear_cached_hook_weights(self) -> None:
-        self._call_rpc("clear_cached_hook_weights")
-
-    def get_combined_hook_patches(self, hooks: Any) -> Any:
-        return self._call_rpc("get_combined_hook_patches", hooks)
-
-    def get_additional_models_with_key(self, key: str) -> Any:
-        return self._call_rpc("get_additional_models_with_key", key)
-
-    @property
-    def object_patches(self) -> Any:
-        return self._call_rpc("get_object_patches")
-
-    @property
-    def patches(self) -> Any:
-        res = self._call_rpc("get_patches")
-        if isinstance(res, dict):
-            new_res = {}
-            for k, v in res.items():
-                new_list = []
-                for item in v:
-                    if isinstance(item, list):
-                        new_list.append(tuple(item))
-                    else:
-                        new_list.append(item)
-                new_res[k] = new_list
-            return new_res
-        return res
-
-    @property
-    def pinned(self) -> Set:
-        val = self._call_rpc("get_patcher_attr", "pinned")
-        return set(val) if val is not None else set()
-
-    @property
-    def hook_patches(self) -> Dict:
-        val = self._call_rpc("get_patcher_attr", "hook_patches")
-        if val is None:
-            return {}
-        try:
-            from comfy.hooks import _HookRef
-            import json
-
-            new_val = {}
-            for k, v in val.items():
-                if isinstance(k, str):
-                    if k.startswith("PYISOLATE_HOOKREF:"):
-                        ref_id = k.split(":", 1)[1]
-                        h = _HookRef()
-                        h._pyisolate_id = ref_id
-                        new_val[h] = v
-                    elif k.startswith("__pyisolate_key__"):
-                        try:
-                            json_str = k[len("__pyisolate_key__") :]
-                            data = json.loads(json_str)
-                            ref_id = None
-                            if isinstance(data, list):
-                                for item in data:
-                                    if (
-                                        isinstance(item, list)
-                                        and len(item) == 2
-                                        and item[0] == "id"
-                                    ):
-                                        ref_id = item[1]
-                                        break
-                            if ref_id:
-                                h = _HookRef()
-                                h._pyisolate_id = ref_id
-                                new_val[h] = v
-                            else:
-                                new_val[k] = v
-                        except Exception:
-                            new_val[k] = v
-                    else:
-                        new_val[k] = v
-                else:
-                    new_val[k] = v
-            return new_val
-        except ImportError:
-            return val
-
-    def set_hook_mode(self, hook_mode: Any) -> None:
-        self._call_rpc("set_hook_mode", hook_mode)
-
-    def register_all_hook_patches(
-        self,
-        hooks: Any,
-        target_dict: Any,
-        model_options: Any = None,
-        registered: Any = None,
-    ) -> None:
-        self._call_rpc(
-            "register_all_hook_patches", hooks, target_dict, model_options, registered
-        )
-
-    def is_clone(self, other: Any) -> bool:
-        if isinstance(other, ModelPatcherProxy):
-            return self._call_rpc("is_clone_by_id", other._instance_id)
-        return False
-
-    def clone(self) -> ModelPatcherProxy:
-        new_id = self._call_rpc("clone")
-        return self._spawn_related_proxy(new_id)
-
-    def clone_has_same_weights(self, clone: Any) -> bool:
-        if isinstance(clone, ModelPatcherProxy):
-            return self._call_rpc("clone_has_same_weights_by_id", clone._instance_id)
-        if not IS_CHILD_PROCESS:
-            return self._call_rpc("is_clone", clone)
-        return False
-
-    def get_model_object(self, name: str) -> Any:
-        return self._call_rpc("get_model_object", name)
-
-    @property
-    def model_options(self) -> dict:
-        data = self._call_rpc("get_model_options")
-        import json
-
-        def _decode_keys(obj):
-            if isinstance(obj, dict):
-                new_d = {}
-                for k, v in obj.items():
-                    if isinstance(k, str) and k.startswith("__pyisolate_key__"):
-                        try:
-                            json_str = k[17:]
-                            val = json.loads(json_str)
-                            if isinstance(val, list):
-                                val = tuple(val)
-                            new_d[val] = _decode_keys(v)
-                        except:
-                            new_d[k] = _decode_keys(v)
-                    else:
-                        new_d[k] = _decode_keys(v)
-                return new_d
-            if isinstance(obj, list):
-                return [_decode_keys(x) for x in obj]
-            return obj
-
-        return _decode_keys(data)
-
-    @model_options.setter
-    def model_options(self, value: dict) -> None:
-        self._call_rpc("set_model_options", value)
-
-    def apply_hooks(self, hooks: Any) -> Any:
-        return self._call_rpc("apply_hooks", hooks)
-
-    def prepare_state(self, timestep: Any) -> Any:
-        return self._call_rpc("prepare_state", timestep)
-
-    def restore_hook_patches(self) -> None:
-        self._call_rpc("restore_hook_patches")
-
-    def unpatch_hooks(self, whitelist_keys_set: Optional[Set[str]] = None) -> None:
-        self._call_rpc("unpatch_hooks", whitelist_keys_set)
-
-    def model_patches_to(self, device: Any) -> Any:
-        return self._call_rpc("model_patches_to", device)
-
-    def partially_load(
-        self, device: Any, extra_memory: Any, force_patch_weights: bool = False
-    ) -> Any:
-        return self._call_rpc(
-            "partially_load", device, extra_memory, force_patch_weights
-        )
-
-    def partially_unload(
-        self, device_to: Any, memory_to_free: int = 0, force_patch_weights: bool = False
-    ) -> int:
-        return self._call_rpc(
-            "partially_unload", device_to, memory_to_free, force_patch_weights
-        )
-
-    def load(
-        self,
-        device_to: Any = None,
-        lowvram_model_memory: int = 0,
-        force_patch_weights: bool = False,
-        full_load: bool = False,
-    ) -> None:
-        self._call_rpc(
-            "load", device_to, lowvram_model_memory, force_patch_weights, full_load
-        )
-
-    def patch_model(
-        self,
-        device_to: Any = None,
-        lowvram_model_memory: int = 0,
-        load_weights: bool = True,
-        force_patch_weights: bool = False,
-    ) -> Any:
-        self._call_rpc(
-            "patch_model",
-            device_to,
-            lowvram_model_memory,
-            load_weights,
-            force_patch_weights,
-        )
-        return self
-
-    def unpatch_model(
-        self, device_to: Any = None, unpatch_weights: bool = True
-    ) -> None:
-        self._call_rpc("unpatch_model", device_to, unpatch_weights)
-
-    def detach(self, unpatch_all: bool = True) -> Any:
-        self._call_rpc("detach", unpatch_all)
-        return self.model
-
-    def _cpu_tensor_bytes(self, obj: Any) -> int:
-        import torch
-
-        if isinstance(obj, torch.Tensor):
-            if obj.device.type == "cpu":
-                return obj.nbytes
-            return 0
-        if isinstance(obj, dict):
-            return sum(self._cpu_tensor_bytes(v) for v in obj.values())
-        if isinstance(obj, (list, tuple)):
-            return sum(self._cpu_tensor_bytes(v) for v in obj)
-        return 0
-
-    def _ensure_apply_model_headroom(self, required_bytes: int) -> bool:
-        if required_bytes <= 0:
-            return True
-
-        import torch
-        import comfy.model_management as model_management
-
-        target_raw = self.load_device
-        try:
-            if isinstance(target_raw, torch.device):
-                target = target_raw
-            elif isinstance(target_raw, str):
-                target = torch.device(target_raw)
-            elif isinstance(target_raw, int):
-                target = torch.device(f"cuda:{target_raw}")
-            else:
-                target = torch.device(target_raw)
-        except Exception:
-            return True
-
-        if target.type != "cuda":
-            return True
-
-        required = required_bytes + self._APPLY_MODEL_GUARD_PADDING_BYTES
-        if model_management.get_free_memory(target) >= required:
-            return True
-
-        model_management.cleanup_models_gc()
-        model_management.cleanup_models()
-        model_management.soft_empty_cache()
-
-        if model_management.get_free_memory(target) < required:
-            model_management.free_memory(required, target, for_dynamic=True)
-            model_management.soft_empty_cache()
-
-        if model_management.get_free_memory(target) < required:
-            # Escalate to non-dynamic unloading before dispatching CUDA transfer.
-            model_management.free_memory(required, target, for_dynamic=False)
-            model_management.soft_empty_cache()
-
-        if model_management.get_free_memory(target) < required:
-            model_management.load_models_gpu(
-                [self],
-                minimum_memory_required=required,
-            )
-
-        return model_management.get_free_memory(target) >= required
-
-    def apply_model(self, *args, **kwargs) -> Any:
-        import torch
-
-        def _preferred_device() -> Any:
-            for value in args:
-                if isinstance(value, torch.Tensor):
-                    return value.device
-            for value in kwargs.values():
-                if isinstance(value, torch.Tensor):
-                    return value.device
-            return None
-
-        def _move_result_to_device(obj: Any, device: Any) -> Any:
-            if device is None:
-                return obj
-            if isinstance(obj, torch.Tensor):
-                return obj.to(device) if obj.device != device else obj
-            if isinstance(obj, dict):
-                return {k: _move_result_to_device(v, device) for k, v in obj.items()}
-            if isinstance(obj, list):
-                return [_move_result_to_device(v, device) for v in obj]
-            if isinstance(obj, tuple):
-                return tuple(_move_result_to_device(v, device) for v in obj)
-            return obj
-
-        # DynamicVRAM models must keep load/offload decisions in host process.
-        # Child-side CUDA staging here can deadlock before first inference RPC.
-        if self.is_dynamic():
-            out = self._call_rpc("inner_model_apply_model", args, kwargs)
-            return _move_result_to_device(out, _preferred_device())
-
-        required_bytes = self._cpu_tensor_bytes(args) + self._cpu_tensor_bytes(kwargs)
-        self._ensure_apply_model_headroom(required_bytes)
-        target_device = self.load_device
-
-        def _to_cuda(obj: Any) -> Any:
-            if isinstance(obj, torch.Tensor) and obj.device.type == "cpu":
-                return obj.to(target_device)
-            if isinstance(obj, dict):
-                return {k: _to_cuda(v) for k, v in obj.items()}
-            if isinstance(obj, list):
-                return [_to_cuda(v) for v in obj]
-            if isinstance(obj, tuple):
-                return tuple(_to_cuda(v) for v in obj)
-            return obj
-
-        try:
-            args_cuda = _to_cuda(args)
-            kwargs_cuda = _to_cuda(kwargs)
-        except torch.OutOfMemoryError:
-            self._ensure_apply_model_headroom(required_bytes)
-            args_cuda = _to_cuda(args)
-            kwargs_cuda = _to_cuda(kwargs)
-
-        out = self._call_rpc("inner_model_apply_model", args_cuda, kwargs_cuda)
-        return _move_result_to_device(out, _preferred_device())
-
-    def model_state_dict(self, filter_prefix: Optional[str] = None) -> Any:
-        keys = self._call_rpc("model_state_dict", filter_prefix)
-        return dict.fromkeys(keys, None)
-
-    def add_patches(self, *args: Any, **kwargs: Any) -> Any:
-        res = self._call_rpc("add_patches", *args, **kwargs)
-        if isinstance(res, list):
-            return [tuple(x) if isinstance(x, list) else x for x in res]
-        return res
-
-    def get_key_patches(self, filter_prefix: Optional[str] = None) -> Any:
-        return self._call_rpc("get_key_patches", filter_prefix)
-
-    def patch_weight_to_device(self, key, device_to=None, inplace_update=False):
-        self._call_rpc("patch_weight_to_device", key, device_to, inplace_update)
-
-    def pin_weight_to_device(self, key):
-        self._call_rpc("pin_weight_to_device", key)
-
-    def unpin_weight(self, key):
-        self._call_rpc("unpin_weight", key)
-
-    def unpin_all_weights(self):
-        self._call_rpc("unpin_all_weights")
-
-    def calculate_weight(self, patches, weight, key, intermediate_dtype=None):
-        return self._call_rpc(
-            "calculate_weight", patches, weight, key, intermediate_dtype
-        )
-
-    def inject_model(self) -> None:
-        self._call_rpc("inject_model")
-
-    def eject_model(self) -> None:
-        self._call_rpc("eject_model")
-
-    def use_ejected(self, skip_and_inject_on_exit_only: bool = False) -> Any:
-        return AutoPatcherEjector(
-            self, skip_and_inject_on_exit_only=skip_and_inject_on_exit_only
-        )
-
-    @property
-    def is_injected(self) -> bool:
-        return self._call_rpc("get_is_injected")
-
-    @property
-    def skip_injection(self) -> bool:
-        return self._call_rpc("get_skip_injection")
-
-    @skip_injection.setter
-    def skip_injection(self, value: bool) -> None:
-        self._call_rpc("set_skip_injection", value)
-
-    def clean_hooks(self) -> None:
-        self._call_rpc("clean_hooks")
-
-    def pre_run(self) -> None:
-        self._call_rpc("pre_run")
-
-    def cleanup(self) -> None:
-        try:
-            self._call_rpc("cleanup")
-        except Exception:
-            logger.debug(
-                "ModelPatcherProxy cleanup RPC failed for %s",
-                self._instance_id,
-                exc_info=True,
-            )
-        finally:
-            super().cleanup()
-
-    @property
-    def model(self) -> _InnerModelProxy:
-        return _InnerModelProxy(self)
-
-    def __getattr__(self, name: str) -> Any:
-        _whitelisted_attrs = {
-            "hook_patches_backup",
-            "hook_backup",
-            "cached_hook_patches",
-            "current_hooks",
-            "forced_hooks",
-            "is_clip",
-            "patches_uuid",
-            "pinned",
-            "attachments",
-            "additional_models",
-            "injections",
-            "hook_patches",
-            "model_lowvram",
-            "model_loaded_weight_memory",
-            "backup",
-            "object_patches_backup",
-            "weight_wrapper_patches",
-            "weight_inplace_update",
-            "force_cast_weights",
-        }
-        if name in _whitelisted_attrs:
-            return self._call_rpc("get_patcher_attr", name)
-        raise AttributeError(
-            f"'{type(self).__name__}' object has no attribute '{name}'"
-        )
-
-    def load_lora(
-        self,
-        lora_path: str,
-        strength_model: float,
-        clip: Optional[Any] = None,
-        strength_clip: float = 1.0,
-    ) -> tuple:
-        clip_id = None
-        if clip is not None:
-            clip_id = getattr(clip, "_instance_id", getattr(clip, "_clip_id", None))
-        result = self._call_rpc(
-            "load_lora", lora_path, strength_model, clip_id, strength_clip
-        )
-        new_model = None
-        if result.get("model_id"):
-            new_model = self._spawn_related_proxy(result["model_id"])
-        new_clip = None
-        if result.get("clip_id"):
-            from comfy.isolation.clip_proxy import CLIPProxy
-
-            new_clip = CLIPProxy(result["clip_id"])
-        return (new_model, new_clip)
-
-    @property
-    def load_device(self) -> Any:
-        return self._call_rpc("get_load_device")
-
-    @property
-    def offload_device(self) -> Any:
-        return self._call_rpc("get_offload_device")
-
-    @property
-    def device(self) -> Any:
-        return self.load_device
-
-    def current_loaded_device(self) -> Any:
-        return self._call_rpc("current_loaded_device")
-
-    @property
-    def size(self) -> int:
-        return self._call_rpc("get_size")
-
-    def model_size(self) -> Any:
-        return self._call_rpc("model_size")
-
-    def loaded_size(self) -> Any:
-        return self._call_rpc("loaded_size")
-
-    def get_ram_usage(self) -> int:
-        return self._call_rpc("get_ram_usage")
-
-    def lowvram_patch_counter(self) -> int:
-        return self._call_rpc("lowvram_patch_counter")
-
-    def memory_required(self, input_shape: Any) -> Any:
-        return self._call_rpc("memory_required", input_shape)
-
-    def get_operation_state(self) -> Dict[str, Any]:
-        state = self._call_rpc("get_operation_state")
-        return state if isinstance(state, dict) else {}
-
-    def wait_for_idle(self, timeout_ms: int = 0) -> bool:
-        return bool(self._call_rpc("wait_for_idle", timeout_ms))
-
-    def is_dynamic(self) -> bool:
-        return bool(self._call_rpc("is_dynamic"))
-
-    def get_free_memory(self, device: Any) -> Any:
-        return self._call_rpc("get_free_memory", device)
-
-    def partially_unload_ram(self, ram_to_unload: int) -> Any:
-        return self._call_rpc("partially_unload_ram", ram_to_unload)
-
-    def model_dtype(self) -> Any:
-        res = self._call_rpc("model_dtype")
-        if isinstance(res, str) and res.startswith("torch."):
-            try:
-                import torch
-
-                attr = res.split(".")[-1]
-                if hasattr(torch, attr):
-                    return getattr(torch, attr)
-            except ImportError:
-                pass
-        return res
-
-    @property
-    def hook_mode(self) -> Any:
-        return self._call_rpc("get_hook_mode")
-
-    @hook_mode.setter
-    def hook_mode(self, value: Any) -> None:
-        self._call_rpc("set_hook_mode", value)
-
-    def set_model_sampler_cfg_function(
-        self, sampler_cfg_function: Any, disable_cfg1_optimization: bool = False
-    ) -> None:
-        self._call_rpc(
-            "set_model_sampler_cfg_function",
-            sampler_cfg_function,
-            disable_cfg1_optimization,
-        )
-
-    def set_model_sampler_post_cfg_function(
-        self, post_cfg_function: Any, disable_cfg1_optimization: bool = False
-    ) -> None:
-        self._call_rpc(
-            "set_model_sampler_post_cfg_function",
-            post_cfg_function,
-            disable_cfg1_optimization,
-        )
-
-    def set_model_sampler_pre_cfg_function(
-        self, pre_cfg_function: Any, disable_cfg1_optimization: bool = False
-    ) -> None:
-        self._call_rpc(
-            "set_model_sampler_pre_cfg_function",
-            pre_cfg_function,
-            disable_cfg1_optimization,
-        )
-
-    def set_model_sampler_calc_cond_batch_function(self, fn: Any) -> None:
-        self._call_rpc("set_model_sampler_calc_cond_batch_function", fn)
-
-    def set_model_unet_function_wrapper(self, unet_wrapper_function: Any) -> None:
-        self._call_rpc("set_model_unet_function_wrapper", unet_wrapper_function)
-
-    def set_model_denoise_mask_function(self, denoise_mask_function: Any) -> None:
-        self._call_rpc("set_model_denoise_mask_function", denoise_mask_function)
-
-    def set_model_patch(self, patch: Any, name: str) -> None:
-        self._call_rpc("set_model_patch", patch, name)
-
-    def set_model_patch_replace(
-        self,
-        patch: Any,
-        name: str,
-        block_name: str,
-        number: int,
-        transformer_index: Optional[int] = None,
-    ) -> None:
-        self._call_rpc(
-            "set_model_patch_replace",
-            patch,
-            name,
-            block_name,
-            number,
-            transformer_index,
-        )
-
-    def set_model_attn1_patch(self, patch: Any) -> None:
-        self.set_model_patch(patch, "attn1_patch")
-
-    def set_model_attn2_patch(self, patch: Any) -> None:
-        self.set_model_patch(patch, "attn2_patch")
-
-    def set_model_attn1_replace(
-        self,
-        patch: Any,
-        block_name: str,
-        number: int,
-        transformer_index: Optional[int] = None,
-    ) -> None:
-        self.set_model_patch_replace(
-            patch, "attn1", block_name, number, transformer_index
-        )
-
-    def set_model_attn2_replace(
-        self,
-        patch: Any,
-        block_name: str,
-        number: int,
-        transformer_index: Optional[int] = None,
-    ) -> None:
-        self.set_model_patch_replace(
-            patch, "attn2", block_name, number, transformer_index
-        )
-
-    def set_model_attn1_output_patch(self, patch: Any) -> None:
-        self.set_model_patch(patch, "attn1_output_patch")
-
-    def set_model_attn2_output_patch(self, patch: Any) -> None:
-        self.set_model_patch(patch, "attn2_output_patch")
-
-    def set_model_input_block_patch(self, patch: Any) -> None:
-        self.set_model_patch(patch, "input_block_patch")
-
-    def set_model_input_block_patch_after_skip(self, patch: Any) -> None:
-        self.set_model_patch(patch, "input_block_patch_after_skip")
-
-    def set_model_output_block_patch(self, patch: Any) -> None:
-        self.set_model_patch(patch, "output_block_patch")
-
-    def set_model_emb_patch(self, patch: Any) -> None:
-        self.set_model_patch(patch, "emb_patch")
-
-    def set_model_forward_timestep_embed_patch(self, patch: Any) -> None:
-        self.set_model_patch(patch, "forward_timestep_embed_patch")
-
-    def set_model_double_block_patch(self, patch: Any) -> None:
-        self.set_model_patch(patch, "double_block")
-
-    def set_model_post_input_patch(self, patch: Any) -> None:
-        self.set_model_patch(patch, "post_input")
-
-    def set_model_rope_options(
-        self,
-        scale_x=1.0,
-        shift_x=0.0,
-        scale_y=1.0,
-        shift_y=0.0,
-        scale_t=1.0,
-        shift_t=0.0,
-        **kwargs: Any,
-    ) -> None:
-        options = {
-            "scale_x": scale_x,
-            "shift_x": shift_x,
-            "scale_y": scale_y,
-            "shift_y": shift_y,
-            "scale_t": scale_t,
-            "shift_t": shift_t,
-        }
-        options.update(kwargs)
-        self._call_rpc("set_model_rope_options", options)
-
-    def set_model_compute_dtype(self, dtype: Any) -> None:
-        self._call_rpc("set_model_compute_dtype", dtype)
-
-    def add_object_patch(self, name: str, obj: Any) -> None:
-        self._call_rpc("add_object_patch", name, obj)
-
-    def add_weight_wrapper(self, name: str, function: Any) -> None:
-        self._call_rpc("add_weight_wrapper", name, function)
-
-    def add_wrapper_with_key(self, wrapper_type: Any, key: str, fn: Any) -> None:
-        self._call_rpc("add_wrapper_with_key", wrapper_type, key, fn)
-
-    def add_wrapper(self, wrapper_type: str, wrapper: Callable) -> None:
-        self.add_wrapper_with_key(wrapper_type, None, wrapper)
-
-    def remove_wrappers_with_key(self, wrapper_type: str, key: str) -> None:
-        self._call_rpc("remove_wrappers_with_key", wrapper_type, key)
-
-    @property
-    def wrappers(self) -> Any:
-        return self._call_rpc("get_wrappers")
-
-    def add_callback_with_key(self, call_type: str, key: str, callback: Any) -> None:
-        self._call_rpc("add_callback_with_key", call_type, key, callback)
-
-    def add_callback(self, call_type: str, callback: Any) -> None:
-        self.add_callback_with_key(call_type, None, callback)
-
-    def remove_callbacks_with_key(self, call_type: str, key: str) -> None:
-        self._call_rpc("remove_callbacks_with_key", call_type, key)
-
-    @property
-    def callbacks(self) -> Any:
-        return self._call_rpc("get_callbacks")
-
-    def set_attachments(self, key: str, attachment: Any) -> None:
-        self._call_rpc("set_attachments", key, attachment)
-
-    def get_attachment(self, key: str) -> Any:
-        return self._call_rpc("get_attachment", key)
-
-    def remove_attachments(self, key: str) -> None:
-        self._call_rpc("remove_attachments", key)
-
-    def set_injections(self, key: str, injections: Any) -> None:
-        self._call_rpc("set_injections", key, injections)
-
-    def get_injections(self, key: str) -> Any:
-        return self._call_rpc("get_injections", key)
-
-    def remove_injections(self, key: str) -> None:
-        self._call_rpc("remove_injections", key)
-
-    def set_additional_models(self, key: str, models: Any) -> None:
-        ids = [m._instance_id for m in models]
-        self._call_rpc("set_additional_models", key, ids)
-
-    def remove_additional_models(self, key: str) -> None:
-        self._call_rpc("remove_additional_models", key)
-
-    def get_nested_additional_models(self) -> Any:
-        return self._call_rpc("get_nested_additional_models")
-
-    def get_additional_models(self) -> List[ModelPatcherProxy]:
-        ids = self._call_rpc("get_additional_models")
-        return [self._spawn_related_proxy(mid) for mid in ids]
-
-    def model_patches_models(self) -> Any:
-        return self._call_rpc("model_patches_models")
-
-    @property
-    def parent(self) -> Any:
-        return self._call_rpc("get_parent")
-
-    def model_mmap_residency(self, free: bool = False) -> tuple:
-        result = self._call_rpc("model_mmap_residency", free)
-        if isinstance(result, list):
-            return tuple(result)
-        return result
-
-    def pinned_memory_size(self) -> int:
-        return self._call_rpc("pinned_memory_size")
-
-    def get_non_dynamic_delegate(self) -> ModelPatcherProxy:
-        new_id = self._call_rpc("get_non_dynamic_delegate")
-        return self._spawn_related_proxy(new_id)
-
-    def disable_model_cfg1_optimization(self) -> None:
-        self._call_rpc("disable_model_cfg1_optimization")
-
-    def set_model_noise_refiner_patch(self, patch: Any) -> None:
-        self.set_model_patch(patch, "noise_refiner")
-
-
-class _InnerModelProxy:
-    def __init__(self, parent: ModelPatcherProxy):
-        self._parent = parent
-        self._model_sampling = None
-
-    def __getattr__(self, name: str) -> Any:
-        if name.startswith("_"):
-            raise AttributeError(name)
-        if name == "model_config":
-            from types import SimpleNamespace
-
-            data = self._parent._call_rpc("get_inner_model_attr", name)
-            if isinstance(data, dict):
-                return SimpleNamespace(**data)
-            return data
-        if name in (
-            "latent_format",
-            "model_type",
-            "current_weight_patches_uuid",
-        ):
-            return self._parent._call_rpc("get_inner_model_attr", name)
-        if name == "load_device":
-            return self._parent._call_rpc("get_inner_model_attr", "load_device")
-        if name == "device":
-            return self._parent._call_rpc("get_inner_model_attr", "device")
-        if name == "current_patcher":
-            proxy = ModelPatcherProxy(
-                self._parent._instance_id,
-                self._parent._registry,
-                manage_lifecycle=False,
-            )
-            if getattr(self._parent, "_rpc_caller", None) is not None:
-                proxy._rpc_caller = self._parent._rpc_caller
-            return proxy
-        if name == "model_sampling":
-            if self._model_sampling is None:
-                self._model_sampling = self._parent._call_rpc(
-                    "get_model_object", "model_sampling"
-                )
-            return self._model_sampling
-        if name == "extra_conds_shapes":
-            return lambda *a, **k: self._parent._call_rpc(
-                "inner_model_extra_conds_shapes", a, k
-            )
-        if name == "extra_conds":
-            return lambda *a, **k: self._parent._call_rpc(
-                "inner_model_extra_conds", a, k
-            )
-        if name == "memory_required":
-            return lambda *a, **k: self._parent._call_rpc(
-                "inner_model_memory_required", a, k
-            )
-        if name == "apply_model":
-            # Delegate to parent's method to get the CPU->CUDA optimization
-            return self._parent.apply_model
-        if name == "process_latent_in":
-            return lambda *a, **k: self._parent._call_rpc("process_latent_in", a, k)
-        if name == "process_latent_out":
-            return lambda *a, **k: self._parent._call_rpc("process_latent_out", a, k)
-        if name == "scale_latent_inpaint":
-            return lambda *a, **k: self._parent._call_rpc("scale_latent_inpaint", a, k)
-        if name == "diffusion_model":
-            return self._parent._call_rpc("get_inner_model_attr", "diffusion_model")
-        if name == "state_dict":
-            return lambda: self._parent.model_state_dict()
-        raise AttributeError(f"'{name}' not supported on isolated InnerModel")

comfy/isolation/model_patcher_proxy_utils.py

@@ -1,150 +0,0 @@
-# pylint: disable=import-outside-toplevel,logging-fstring-interpolation,protected-access
-# Isolation utilities and serializers for ModelPatcherProxy
-from __future__ import annotations
-
-import logging
-import os
-from typing import Any
-
-from comfy.cli_args import args
-
-logger = logging.getLogger(__name__)
-
-
-def maybe_wrap_model_for_isolation(model_patcher: Any) -> Any:
-    from comfy.isolation.model_patcher_proxy_registry import ModelPatcherRegistry
-    from comfy.isolation.model_patcher_proxy import ModelPatcherProxy
-
-    is_child = os.environ.get("PYISOLATE_CHILD") == "1"
-    isolation_active = args.use_process_isolation or is_child
-
-    if not isolation_active:
-        return model_patcher
-    if is_child:
-        return model_patcher
-    if isinstance(model_patcher, ModelPatcherProxy):
-        return model_patcher
-
-    registry = ModelPatcherRegistry()
-    model_id = registry.register(model_patcher)
-    logger.debug(f"Isolated ModelPatcher: {model_id}")
-    return ModelPatcherProxy(model_id, registry, manage_lifecycle=True)
-
-
-def register_hooks_serializers(registry=None):
-    from pyisolate._internal.serialization_registry import SerializerRegistry
-    import comfy.hooks
-
-    if registry is None:
-        registry = SerializerRegistry.get_instance()
-
-    def serialize_enum(obj):
-        return {"__enum__": f"{type(obj).__name__}.{obj.name}"}
-
-    def deserialize_enum(data):
-        cls_name, val_name = data["__enum__"].split(".")
-        cls = getattr(comfy.hooks, cls_name)
-        return cls[val_name]
-
-    registry.register("EnumHookType", serialize_enum, deserialize_enum)
-    registry.register("EnumHookScope", serialize_enum, deserialize_enum)
-    registry.register("EnumHookMode", serialize_enum, deserialize_enum)
-    registry.register("EnumWeightTarget", serialize_enum, deserialize_enum)
-
-    def serialize_hook_group(obj):
-        return {"__type__": "HookGroup", "hooks": obj.hooks}
-
-    def deserialize_hook_group(data):
-        hg = comfy.hooks.HookGroup()
-        for h in data["hooks"]:
-            hg.add(h)
-        return hg
-
-    registry.register("HookGroup", serialize_hook_group, deserialize_hook_group)
-
-    def serialize_dict_state(obj):
-        d = obj.__dict__.copy()
-        d["__type__"] = type(obj).__name__
-        if "custom_should_register" in d:
-            del d["custom_should_register"]
-        return d
-
-    def deserialize_dict_state_generic(cls):
-        def _deserialize(data):
-            h = cls()
-            h.__dict__.update(data)
-            return h
-
-        return _deserialize
-
-    def deserialize_hook_keyframe(data):
-        h = comfy.hooks.HookKeyframe(strength=data.get("strength", 1.0))
-        h.__dict__.update(data)
-        return h
-
-    registry.register("HookKeyframe", serialize_dict_state, deserialize_hook_keyframe)
-
-    def deserialize_hook_keyframe_group(data):
-        h = comfy.hooks.HookKeyframeGroup()
-        h.__dict__.update(data)
-        return h
-
-    registry.register(
-        "HookKeyframeGroup", serialize_dict_state, deserialize_hook_keyframe_group
-    )
-
-    def deserialize_hook(data):
-        h = comfy.hooks.Hook()
-        h.__dict__.update(data)
-        return h
-
-    registry.register("Hook", serialize_dict_state, deserialize_hook)
-
-    def deserialize_weight_hook(data):
-        h = comfy.hooks.WeightHook()
-        h.__dict__.update(data)
-        return h
-
-    registry.register("WeightHook", serialize_dict_state, deserialize_weight_hook)
-
-    def serialize_set(obj):
-        return {"__set__": list(obj)}
-
-    def deserialize_set(data):
-        return set(data["__set__"])
-
-    registry.register("set", serialize_set, deserialize_set)
-
-    try:
-        from comfy.weight_adapter.lora import LoRAAdapter
-
-        def serialize_lora(obj):
-            return {"weights": {}, "loaded_keys": list(obj.loaded_keys)}
-
-        def deserialize_lora(data):
-            return LoRAAdapter(set(data["loaded_keys"]), data["weights"])
-
-        registry.register("LoRAAdapter", serialize_lora, deserialize_lora)
-    except Exception:
-        pass
-
-    try:
-        from comfy.hooks import _HookRef
-        import uuid
-
-        def serialize_hook_ref(obj):
-            return {
-                "__hook_ref__": True,
-                "id": getattr(obj, "_pyisolate_id", str(uuid.uuid4())),
-            }
-
-        def deserialize_hook_ref(data):
-            h = _HookRef()
-            h._pyisolate_id = data.get("id", str(uuid.uuid4()))
-            return h
-
-        registry.register("_HookRef", serialize_hook_ref, deserialize_hook_ref)
-    except ImportError:
-        pass
-    except Exception as e:
-        logger.warning(f"Failed to register _HookRef: {e}")

comfy/isolation/model_sampling_proxy.py

@@ -1,360 +0,0 @@
-# pylint: disable=import-outside-toplevel
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import threading
-import time
-from typing import Any
-
-from comfy.isolation.proxies.base import (
-    BaseProxy,
-    BaseRegistry,
-    detach_if_grad,
-    get_thread_loop,
-    run_coro_in_new_loop,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def _describe_value(obj: Any) -> str:
-    try:
-        import torch
-    except Exception:
-        torch = None
-    try:
-        if torch is not None and isinstance(obj, torch.Tensor):
-            return (
-                "Tensor(shape=%s,dtype=%s,device=%s,id=%s)"
-                % (tuple(obj.shape), obj.dtype, obj.device, id(obj))
-            )
-    except Exception:
-        pass
-    return "%s(id=%s)" % (type(obj).__name__, id(obj))
-
-
-def _prefer_device(*tensors: Any) -> Any:
-    try:
-        import torch
-    except Exception:
-        return None
-    for t in tensors:
-        if isinstance(t, torch.Tensor) and t.is_cuda:
-            return t.device
-    for t in tensors:
-        if isinstance(t, torch.Tensor):
-            return t.device
-    return None
-
-
-def _to_device(obj: Any, device: Any) -> Any:
-    try:
-        import torch
-    except Exception:
-        return obj
-    if device is None:
-        return obj
-    if isinstance(obj, torch.Tensor):
-        if obj.device != device:
-            return obj.to(device)
-        return obj
-    if isinstance(obj, (list, tuple)):
-        converted = [_to_device(x, device) for x in obj]
-        return type(obj)(converted) if isinstance(obj, tuple) else converted
-    if isinstance(obj, dict):
-        return {k: _to_device(v, device) for k, v in obj.items()}
-    return obj
-
-
-def _to_cpu_for_rpc(obj: Any) -> Any:
-    try:
-        import torch
-    except Exception:
-        return obj
-    if isinstance(obj, torch.Tensor):
-        t = obj.detach() if obj.requires_grad else obj
-        if t.is_cuda:
-            return t.to("cpu")
-        return t
-    if isinstance(obj, (list, tuple)):
-        converted = [_to_cpu_for_rpc(x) for x in obj]
-        return type(obj)(converted) if isinstance(obj, tuple) else converted
-    if isinstance(obj, dict):
-        return {k: _to_cpu_for_rpc(v) for k, v in obj.items()}
-    return obj
-
-
-class ModelSamplingRegistry(BaseRegistry[Any]):
-    _type_prefix = "modelsampling"
-
-    async def calculate_input(self, instance_id: str, sigma: Any, noise: Any) -> Any:
-        sampling = self._get_instance(instance_id)
-        return detach_if_grad(sampling.calculate_input(sigma, noise))
-
-    async def calculate_denoised(
-        self, instance_id: str, sigma: Any, model_output: Any, model_input: Any
-    ) -> Any:
-        sampling = self._get_instance(instance_id)
-        return detach_if_grad(
-            sampling.calculate_denoised(sigma, model_output, model_input)
-        )
-
-    async def noise_scaling(
-        self,
-        instance_id: str,
-        sigma: Any,
-        noise: Any,
-        latent_image: Any,
-        max_denoise: bool = False,
-    ) -> Any:
-        sampling = self._get_instance(instance_id)
-        return detach_if_grad(
-            sampling.noise_scaling(sigma, noise, latent_image, max_denoise=max_denoise)
-        )
-
-    async def inverse_noise_scaling(
-        self, instance_id: str, sigma: Any, latent: Any
-    ) -> Any:
-        sampling = self._get_instance(instance_id)
-        return detach_if_grad(sampling.inverse_noise_scaling(sigma, latent))
-
-    async def timestep(self, instance_id: str, sigma: Any) -> Any:
-        sampling = self._get_instance(instance_id)
-        return sampling.timestep(sigma)
-
-    async def sigma(self, instance_id: str, timestep: Any) -> Any:
-        sampling = self._get_instance(instance_id)
-        return sampling.sigma(timestep)
-
-    async def percent_to_sigma(self, instance_id: str, percent: float) -> Any:
-        sampling = self._get_instance(instance_id)
-        return sampling.percent_to_sigma(percent)
-
-    async def get_sigma_min(self, instance_id: str) -> Any:
-        sampling = self._get_instance(instance_id)
-        return detach_if_grad(sampling.sigma_min)
-
-    async def get_sigma_max(self, instance_id: str) -> Any:
-        sampling = self._get_instance(instance_id)
-        return detach_if_grad(sampling.sigma_max)
-
-    async def get_sigma_data(self, instance_id: str) -> Any:
-        sampling = self._get_instance(instance_id)
-        return detach_if_grad(sampling.sigma_data)
-
-    async def get_sigmas(self, instance_id: str) -> Any:
-        sampling = self._get_instance(instance_id)
-        return detach_if_grad(sampling.sigmas)
-
-    async def set_sigmas(self, instance_id: str, sigmas: Any) -> None:
-        sampling = self._get_instance(instance_id)
-        sampling.set_sigmas(sigmas)
-
-
-class ModelSamplingProxy(BaseProxy[ModelSamplingRegistry]):
-    _registry_class = ModelSamplingRegistry
-    __module__ = "comfy.isolation.model_sampling_proxy"
-
-    def _get_rpc(self) -> Any:
-        if self._rpc_caller is None:
-            from pyisolate._internal.rpc_protocol import get_child_rpc_instance
-
-            rpc = get_child_rpc_instance()
-            if rpc is not None:
-                self._rpc_caller = rpc.create_caller(
-                    ModelSamplingRegistry, ModelSamplingRegistry.get_remote_id()
-                )
-            else:
-                registry = ModelSamplingRegistry()
-
-                class _LocalCaller:
-                    def calculate_input(
-                        self, instance_id: str, sigma: Any, noise: Any
-                    ) -> Any:
-                        return registry.calculate_input(instance_id, sigma, noise)
-
-                    def calculate_denoised(
-                        self,
-                        instance_id: str,
-                        sigma: Any,
-                        model_output: Any,
-                        model_input: Any,
-                    ) -> Any:
-                        return registry.calculate_denoised(
-                            instance_id, sigma, model_output, model_input
-                        )
-
-                    def noise_scaling(
-                        self,
-                        instance_id: str,
-                        sigma: Any,
-                        noise: Any,
-                        latent_image: Any,
-                        max_denoise: bool = False,
-                    ) -> Any:
-                        return registry.noise_scaling(
-                            instance_id, sigma, noise, latent_image, max_denoise
-                        )
-
-                    def inverse_noise_scaling(
-                        self, instance_id: str, sigma: Any, latent: Any
-                    ) -> Any:
-                        return registry.inverse_noise_scaling(
-                            instance_id, sigma, latent
-                        )
-
-                    def timestep(self, instance_id: str, sigma: Any) -> Any:
-                        return registry.timestep(instance_id, sigma)
-
-                    def sigma(self, instance_id: str, timestep: Any) -> Any:
-                        return registry.sigma(instance_id, timestep)
-
-                    def percent_to_sigma(self, instance_id: str, percent: float) -> Any:
-                        return registry.percent_to_sigma(instance_id, percent)
-
-                    def get_sigma_min(self, instance_id: str) -> Any:
-                        return registry.get_sigma_min(instance_id)
-
-                    def get_sigma_max(self, instance_id: str) -> Any:
-                        return registry.get_sigma_max(instance_id)
-
-                    def get_sigma_data(self, instance_id: str) -> Any:
-                        return registry.get_sigma_data(instance_id)
-
-                    def get_sigmas(self, instance_id: str) -> Any:
-                        return registry.get_sigmas(instance_id)
-
-                    def set_sigmas(self, instance_id: str, sigmas: Any) -> None:
-                        return registry.set_sigmas(instance_id, sigmas)
-
-                self._rpc_caller = _LocalCaller()
-        return self._rpc_caller
-
-    def _call(self, method_name: str, *args: Any) -> Any:
-        rpc = self._get_rpc()
-        method = getattr(rpc, method_name)
-        result = method(self._instance_id, *args)
-        timeout_ms = self._rpc_timeout_ms()
-        start_epoch = time.time()
-        start_perf = time.perf_counter()
-        thread_id = threading.get_ident()
-        call_id = "%s:%s:%s:%.6f" % (
-            self._instance_id,
-            method_name,
-            thread_id,
-            start_perf,
-        )
-        logger.debug(
-            "ISO:modelsampling_rpc_start method=%s instance_id=%s call_id=%s start_ts=%.6f thread=%s timeout_ms=%s",
-            method_name,
-            self._instance_id,
-            call_id,
-            start_epoch,
-            thread_id,
-            timeout_ms,
-        )
-        if asyncio.iscoroutine(result):
-            result = asyncio.wait_for(result, timeout=timeout_ms / 1000.0)
-            try:
-                asyncio.get_running_loop()
-                out = run_coro_in_new_loop(result)
-            except RuntimeError:
-                loop = get_thread_loop()
-                out = loop.run_until_complete(result)
-        else:
-            out = result
-        logger.debug(
-            "ISO:modelsampling_rpc_after_await method=%s instance_id=%s call_id=%s out=%s",
-            method_name,
-            self._instance_id,
-            call_id,
-            _describe_value(out),
-        )
-        elapsed_ms = (time.perf_counter() - start_perf) * 1000.0
-        logger.debug(
-            "ISO:modelsampling_rpc_end method=%s instance_id=%s call_id=%s elapsed_ms=%.3f thread=%s",
-            method_name,
-            self._instance_id,
-            call_id,
-            elapsed_ms,
-            thread_id,
-        )
-        logger.debug(
-            "ISO:modelsampling_rpc_return method=%s instance_id=%s call_id=%s",
-            method_name,
-            self._instance_id,
-            call_id,
-        )
-        return out
-
-    @staticmethod
-    def _rpc_timeout_ms() -> int:
-        raw = os.environ.get(
-            "COMFY_ISOLATION_MODEL_SAMPLING_RPC_TIMEOUT_MS",
-            os.environ.get("COMFY_ISOLATION_LOAD_RPC_TIMEOUT_MS", "30000"),
-        )
-        try:
-            timeout_ms = int(raw)
-        except ValueError:
-            timeout_ms = 30000
-        return max(1, timeout_ms)
-
-    @property
-    def sigma_min(self) -> Any:
-        return self._call("get_sigma_min")
-
-    @property
-    def sigma_max(self) -> Any:
-        return self._call("get_sigma_max")
-
-    @property
-    def sigma_data(self) -> Any:
-        return self._call("get_sigma_data")
-
-    @property
-    def sigmas(self) -> Any:
-        return self._call("get_sigmas")
-
-    def calculate_input(self, sigma: Any, noise: Any) -> Any:
-        return self._call("calculate_input", sigma, noise)
-
-    def calculate_denoised(
-        self, sigma: Any, model_output: Any, model_input: Any
-    ) -> Any:
-        return self._call("calculate_denoised", sigma, model_output, model_input)
-
-    def noise_scaling(
-        self, sigma: Any, noise: Any, latent_image: Any, max_denoise: bool = False
-    ) -> Any:
-        preferred_device = _prefer_device(noise, latent_image)
-        out = self._call(
-            "noise_scaling",
-            _to_cpu_for_rpc(sigma),
-            _to_cpu_for_rpc(noise),
-            _to_cpu_for_rpc(latent_image),
-            max_denoise,
-        )
-        return _to_device(out, preferred_device)
-
-    def inverse_noise_scaling(self, sigma: Any, latent: Any) -> Any:
-        preferred_device = _prefer_device(latent)
-        out = self._call(
-            "inverse_noise_scaling",
-            _to_cpu_for_rpc(sigma),
-            _to_cpu_for_rpc(latent),
-        )
-        return _to_device(out, preferred_device)
-
-    def timestep(self, sigma: Any) -> Any:
-        return self._call("timestep", sigma)
-
-    def sigma(self, timestep: Any) -> Any:
-        return self._call("sigma", timestep)
-
-    def percent_to_sigma(self, percent: float) -> Any:
-        return self._call("percent_to_sigma", percent)
-
-    def set_sigmas(self, sigmas: Any) -> None:
-        return self._call("set_sigmas", sigmas)

comfy/isolation/proxies/__init__.py

@@ -1,17 +0,0 @@
-from .base import (
-    IS_CHILD_PROCESS,
-    BaseProxy,
-    BaseRegistry,
-    detach_if_grad,
-    get_thread_loop,
-    run_coro_in_new_loop,
-)
-
-__all__ = [
-    "IS_CHILD_PROCESS",
-    "BaseRegistry",
-    "BaseProxy",
-    "get_thread_loop",
-    "run_coro_in_new_loop",
-    "detach_if_grad",
-]

comfy/isolation/proxies/base.py

@@ -1,301 +0,0 @@
-# pylint: disable=global-statement,import-outside-toplevel,protected-access
-from __future__ import annotations
-
-import asyncio
-import concurrent.futures
-import logging
-import os
-import threading
-import time
-import weakref
-from typing import Any, Callable, Dict, Generic, Optional, TypeVar
-
-try:
-    from pyisolate import ProxiedSingleton
-except ImportError:
-
-    class ProxiedSingleton:  # type: ignore[no-redef]
-        pass
-
-
-logger = logging.getLogger(__name__)
-
-IS_CHILD_PROCESS = os.environ.get("PYISOLATE_CHILD") == "1"
-_thread_local = threading.local()
-T = TypeVar("T")
-
-
-def get_thread_loop() -> asyncio.AbstractEventLoop:
-    loop = getattr(_thread_local, "loop", None)
-    if loop is None or loop.is_closed():
-        loop = asyncio.new_event_loop()
-        _thread_local.loop = loop
-    return loop
-
-
-def run_coro_in_new_loop(coro: Any) -> Any:
-    result_box: Dict[str, Any] = {}
-    exc_box: Dict[str, BaseException] = {}
-
-    def runner() -> None:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        try:
-            result_box["value"] = loop.run_until_complete(coro)
-        except Exception as exc:  # noqa: BLE001
-            exc_box["exc"] = exc
-        finally:
-            loop.close()
-
-    t = threading.Thread(target=runner, daemon=True)
-    t.start()
-    t.join()
-    if "exc" in exc_box:
-        raise exc_box["exc"]
-    return result_box.get("value")
-
-
-def detach_if_grad(obj: Any) -> Any:
-    try:
-        import torch
-    except Exception:
-        return obj
-
-    if isinstance(obj, torch.Tensor):
-        return obj.detach() if obj.requires_grad else obj
-    if isinstance(obj, (list, tuple)):
-        return type(obj)(detach_if_grad(x) for x in obj)
-    if isinstance(obj, dict):
-        return {k: detach_if_grad(v) for k, v in obj.items()}
-    return obj
-
-
-class BaseRegistry(ProxiedSingleton, Generic[T]):
-    _type_prefix: str = "base"
-
-    def __init__(self) -> None:
-        if hasattr(ProxiedSingleton, "__init__") and ProxiedSingleton is not object:
-            super().__init__()
-        self._registry: Dict[str, T] = {}
-        self._id_map: Dict[int, str] = {}
-        self._counter = 0
-        self._lock = threading.Lock()
-
-    def register(self, instance: T) -> str:
-        with self._lock:
-            obj_id = id(instance)
-            if obj_id in self._id_map:
-                return self._id_map[obj_id]
-            instance_id = f"{self._type_prefix}_{self._counter}"
-            self._counter += 1
-            self._registry[instance_id] = instance
-            self._id_map[obj_id] = instance_id
-        return instance_id
-
-    def unregister_sync(self, instance_id: str) -> None:
-        with self._lock:
-            instance = self._registry.pop(instance_id, None)
-            if instance:
-                self._id_map.pop(id(instance), None)
-
-    def _get_instance(self, instance_id: str) -> T:
-        if IS_CHILD_PROCESS:
-            raise RuntimeError(
-                f"[{self.__class__.__name__}] _get_instance called in child"
-            )
-        with self._lock:
-            instance = self._registry.get(instance_id)
-        if instance is None:
-            raise ValueError(f"{instance_id} not found")
-        return instance
-
-
-_GLOBAL_LOOP: Optional[asyncio.AbstractEventLoop] = None
-
-
-def set_global_loop(loop: asyncio.AbstractEventLoop) -> None:
-    global _GLOBAL_LOOP
-    _GLOBAL_LOOP = loop
-
-
-def run_sync_rpc_coro(coro: Any, timeout_ms: Optional[int] = None) -> Any:
-    if timeout_ms is not None:
-        coro = asyncio.wait_for(coro, timeout=timeout_ms / 1000.0)
-
-    try:
-        if _GLOBAL_LOOP is not None and _GLOBAL_LOOP.is_running():
-            try:
-                curr_loop = asyncio.get_running_loop()
-                if curr_loop is _GLOBAL_LOOP:
-                    pass
-            except RuntimeError:
-                future = asyncio.run_coroutine_threadsafe(coro, _GLOBAL_LOOP)
-                return future.result(
-                    timeout=(timeout_ms / 1000.0) if timeout_ms is not None else None
-                )
-
-        try:
-            asyncio.get_running_loop()
-            return run_coro_in_new_loop(coro)
-        except RuntimeError:
-            loop = get_thread_loop()
-            return loop.run_until_complete(coro)
-    except asyncio.TimeoutError as exc:
-        raise TimeoutError(f"Isolation RPC timeout (timeout_ms={timeout_ms})") from exc
-    except concurrent.futures.TimeoutError as exc:
-        raise TimeoutError(f"Isolation RPC timeout (timeout_ms={timeout_ms})") from exc
-
-
-def call_singleton_rpc(
-    caller: Any,
-    method_name: str,
-    *args: Any,
-    timeout_ms: Optional[int] = None,
-    **kwargs: Any,
-) -> Any:
-    if caller is None:
-        raise RuntimeError(f"No RPC caller available for {method_name}")
-    method = getattr(caller, method_name)
-    return run_sync_rpc_coro(method(*args, **kwargs), timeout_ms=timeout_ms)
-
-
-class BaseProxy(Generic[T]):
-    _registry_class: type = BaseRegistry  # type: ignore[type-arg]
-    __module__: str = "comfy.isolation.proxies.base"
-    _TIMEOUT_RPC_METHODS = frozenset(
-        {
-            "partially_load",
-            "partially_unload",
-            "load",
-            "patch_model",
-            "unpatch_model",
-            "inner_model_apply_model",
-            "memory_required",
-            "model_dtype",
-            "inner_model_memory_required",
-            "inner_model_extra_conds_shapes",
-            "inner_model_extra_conds",
-            "process_latent_in",
-            "process_latent_out",
-            "scale_latent_inpaint",
-        }
-    )
-
-    def __init__(
-        self,
-        instance_id: str,
-        registry: Optional[Any] = None,
-        manage_lifecycle: bool = False,
-    ) -> None:
-        self._instance_id = instance_id
-        self._rpc_caller: Optional[Any] = None
-        self._registry = registry if registry is not None else self._registry_class()
-        self._manage_lifecycle = manage_lifecycle
-        self._cleaned_up = False
-        if manage_lifecycle and not IS_CHILD_PROCESS:
-            self._finalizer = weakref.finalize(
-                self, self._registry.unregister_sync, instance_id
-            )
-
-    def _get_rpc(self) -> Any:
-        if self._rpc_caller is None:
-            from pyisolate._internal.rpc_protocol import get_child_rpc_instance
-
-            rpc = get_child_rpc_instance()
-            if rpc is None:
-                raise RuntimeError(f"[{self.__class__.__name__}] No RPC in child")
-            self._rpc_caller = rpc.create_caller(
-                self._registry_class, self._registry_class.get_remote_id()
-            )
-        return self._rpc_caller
-
-    def _rpc_timeout_ms_for_method(self, method_name: str) -> Optional[int]:
-        if method_name not in self._TIMEOUT_RPC_METHODS:
-            return None
-        try:
-            timeout_ms = int(
-                os.environ.get("COMFY_ISOLATION_LOAD_RPC_TIMEOUT_MS", "120000")
-            )
-        except ValueError:
-            timeout_ms = 120000
-        return max(1, timeout_ms)
-
-    def _call_rpc(self, method_name: str, *args: Any, **kwargs: Any) -> Any:
-        rpc = self._get_rpc()
-        method = getattr(rpc, method_name)
-        timeout_ms = self._rpc_timeout_ms_for_method(method_name)
-        coro = method(self._instance_id, *args, **kwargs)
-        if timeout_ms is not None:
-            coro = asyncio.wait_for(coro, timeout=timeout_ms / 1000.0)
-
-        start_epoch = time.time()
-        start_perf = time.perf_counter()
-        thread_id = threading.get_ident()
-        try:
-            running_loop = asyncio.get_running_loop()
-            loop_id: Optional[int] = id(running_loop)
-        except RuntimeError:
-            loop_id = None
-        logger.debug(
-            "ISO:rpc_start proxy=%s method=%s instance_id=%s start_ts=%.6f "
-            "thread=%s loop=%s timeout_ms=%s",
-            self.__class__.__name__,
-            method_name,
-            self._instance_id,
-            start_epoch,
-            thread_id,
-            loop_id,
-            timeout_ms,
-        )
-
-        try:
-            return run_sync_rpc_coro(coro, timeout_ms=timeout_ms)
-        except TimeoutError as exc:
-            raise TimeoutError(
-                f"Isolation RPC timeout in {self.__class__.__name__}.{method_name} "
-                f"(instance_id={self._instance_id}, timeout_ms={timeout_ms})"
-            ) from exc
-        finally:
-            end_epoch = time.time()
-            elapsed_ms = (time.perf_counter() - start_perf) * 1000.0
-            logger.debug(
-                "ISO:rpc_end proxy=%s method=%s instance_id=%s end_ts=%.6f "
-                "elapsed_ms=%.3f thread=%s loop=%s",
-                self.__class__.__name__,
-                method_name,
-                self._instance_id,
-                end_epoch,
-                elapsed_ms,
-                thread_id,
-                loop_id,
-            )
-
-    def __getstate__(self) -> Dict[str, Any]:
-        return {"_instance_id": self._instance_id}
-
-    def __setstate__(self, state: Dict[str, Any]) -> None:
-        self._instance_id = state["_instance_id"]
-        self._rpc_caller = None
-        self._registry = self._registry_class()
-        self._manage_lifecycle = False
-        self._cleaned_up = False
-
-    def cleanup(self) -> None:
-        if self._cleaned_up or IS_CHILD_PROCESS:
-            return
-        self._cleaned_up = True
-        finalizer = getattr(self, "_finalizer", None)
-        if finalizer is not None:
-            finalizer.detach()
-        self._registry.unregister_sync(self._instance_id)
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__} {self._instance_id}>"
-
-
-def create_rpc_method(method_name: str) -> Callable[..., Any]:
-    def method(self: BaseProxy[Any], *args: Any, **kwargs: Any) -> Any:
-        return self._call_rpc(method_name, *args, **kwargs)
-
-    method.__name__ = method_name
-    return method

comfy/isolation/proxies/folder_paths_proxy.py

@@ -1,206 +0,0 @@
-from __future__ import annotations
-import logging
-import os
-
-from typing import Any, Dict, Optional
-
-from pyisolate import ProxiedSingleton
-
-from .base import call_singleton_rpc
-
-_fp_logger = logging.getLogger(__name__)
-
-
-def _folder_paths():
-    import folder_paths
-
-    return folder_paths
-
-
-def _is_child_process() -> bool:
-    return os.environ.get("PYISOLATE_CHILD") == "1"
-
-
-def _serialize_folder_names_and_paths(data: dict[str, tuple[list[str], set[str]]]) -> dict[str, dict[str, list[str]]]:
-    return {
-        key: {"paths": list(paths), "extensions": sorted(list(extensions))}
-        for key, (paths, extensions) in data.items()
-    }
-
-
-def _deserialize_folder_names_and_paths(data: dict[str, dict[str, list[str]]]) -> dict[str, tuple[list[str], set[str]]]:
-    return {
-        key: (list(value.get("paths", [])), set(value.get("extensions", [])))
-        for key, value in data.items()
-    }
-
-
-class FolderPathsProxy(ProxiedSingleton):
-    """
-    Dynamic proxy for folder_paths.
-    Uses __getattr__ for most lookups, with explicit handling for
-    mutable collections to ensure efficient by-value transfer.
-    """
-
-    _rpc: Optional[Any] = None
-
-    @classmethod
-    def set_rpc(cls, rpc: Any) -> None:
-        cls._rpc = rpc.create_caller(cls, cls.get_remote_id())
-
-    @classmethod
-    def clear_rpc(cls) -> None:
-        cls._rpc = None
-
-    @classmethod
-    def _get_caller(cls) -> Any:
-        if cls._rpc is None:
-            raise RuntimeError("FolderPathsProxy RPC caller is not configured")
-        return cls._rpc
-
-    def __getattr__(self, name):
-        if _is_child_process():
-            property_rpc = {
-                "models_dir": "rpc_get_models_dir",
-                "folder_names_and_paths": "rpc_get_folder_names_and_paths",
-                "extension_mimetypes_cache": "rpc_get_extension_mimetypes_cache",
-                "filename_list_cache": "rpc_get_filename_list_cache",
-            }
-            rpc_name = property_rpc.get(name)
-            if rpc_name is not None:
-                return call_singleton_rpc(self._get_caller(), rpc_name)
-            raise AttributeError(name)
-        return getattr(_folder_paths(), name)
-
-    @property
-    def folder_names_and_paths(self) -> Dict:
-        if _is_child_process():
-            payload = call_singleton_rpc(self._get_caller(), "rpc_get_folder_names_and_paths")
-            return _deserialize_folder_names_and_paths(payload)
-        return _folder_paths().folder_names_and_paths
-
-    @property
-    def extension_mimetypes_cache(self) -> Dict:
-        if _is_child_process():
-            return dict(call_singleton_rpc(self._get_caller(), "rpc_get_extension_mimetypes_cache"))
-        return dict(_folder_paths().extension_mimetypes_cache)
-
-    @property
-    def filename_list_cache(self) -> Dict:
-        if _is_child_process():
-            return dict(call_singleton_rpc(self._get_caller(), "rpc_get_filename_list_cache"))
-        return dict(_folder_paths().filename_list_cache)
-
-    @property
-    def models_dir(self) -> str:
-        if _is_child_process():
-            return str(call_singleton_rpc(self._get_caller(), "rpc_get_models_dir"))
-        return _folder_paths().models_dir
-
-    def get_temp_directory(self) -> str:
-        if _is_child_process():
-            return call_singleton_rpc(self._get_caller(), "rpc_get_temp_directory")
-        return _folder_paths().get_temp_directory()
-
-    def get_input_directory(self) -> str:
-        if _is_child_process():
-            return call_singleton_rpc(self._get_caller(), "rpc_get_input_directory")
-        return _folder_paths().get_input_directory()
-
-    def get_output_directory(self) -> str:
-        if _is_child_process():
-            return call_singleton_rpc(self._get_caller(), "rpc_get_output_directory")
-        return _folder_paths().get_output_directory()
-
-    def get_user_directory(self) -> str:
-        if _is_child_process():
-            return call_singleton_rpc(self._get_caller(), "rpc_get_user_directory")
-        return _folder_paths().get_user_directory()
-
-    def get_annotated_filepath(self, name: str, default_dir: str | None = None) -> str:
-        if _is_child_process():
-            return call_singleton_rpc(
-                self._get_caller(), "rpc_get_annotated_filepath", name, default_dir
-            )
-        return _folder_paths().get_annotated_filepath(name, default_dir)
-
-    def exists_annotated_filepath(self, name: str) -> bool:
-        if _is_child_process():
-            return bool(
-                call_singleton_rpc(self._get_caller(), "rpc_exists_annotated_filepath", name)
-            )
-        return bool(_folder_paths().exists_annotated_filepath(name))
-
-    def add_model_folder_path(
-        self, folder_name: str, full_folder_path: str, is_default: bool = False
-    ) -> None:
-        if _is_child_process():
-            call_singleton_rpc(
-                self._get_caller(),
-                "rpc_add_model_folder_path",
-                folder_name,
-                full_folder_path,
-                is_default,
-            )
-            return None
-        _folder_paths().add_model_folder_path(folder_name, full_folder_path, is_default)
-        return None
-
-    def get_folder_paths(self, folder_name: str) -> list[str]:
-        if _is_child_process():
-            return list(call_singleton_rpc(self._get_caller(), "rpc_get_folder_paths", folder_name))
-        return list(_folder_paths().get_folder_paths(folder_name))
-
-    def get_filename_list(self, folder_name: str) -> list[str]:
-        if _is_child_process():
-            return list(call_singleton_rpc(self._get_caller(), "rpc_get_filename_list", folder_name))
-        return list(_folder_paths().get_filename_list(folder_name))
-
-    def get_full_path(self, folder_name: str, filename: str) -> str | None:
-        if _is_child_process():
-            return call_singleton_rpc(self._get_caller(), "rpc_get_full_path", folder_name, filename)
-        return _folder_paths().get_full_path(folder_name, filename)
-
-    async def rpc_get_models_dir(self) -> str:
-        return _folder_paths().models_dir
-
-    async def rpc_get_folder_names_and_paths(self) -> dict[str, dict[str, list[str]]]:
-        return _serialize_folder_names_and_paths(_folder_paths().folder_names_and_paths)
-
-    async def rpc_get_extension_mimetypes_cache(self) -> dict[str, Any]:
-        return dict(_folder_paths().extension_mimetypes_cache)
-
-    async def rpc_get_filename_list_cache(self) -> dict[str, Any]:
-        return dict(_folder_paths().filename_list_cache)
-
-    async def rpc_get_temp_directory(self) -> str:
-        return _folder_paths().get_temp_directory()
-
-    async def rpc_get_input_directory(self) -> str:
-        return _folder_paths().get_input_directory()
-
-    async def rpc_get_output_directory(self) -> str:
-        return _folder_paths().get_output_directory()
-
-    async def rpc_get_user_directory(self) -> str:
-        return _folder_paths().get_user_directory()
-
-    async def rpc_get_annotated_filepath(self, name: str, default_dir: str | None = None) -> str:
-        return _folder_paths().get_annotated_filepath(name, default_dir)
-
-    async def rpc_exists_annotated_filepath(self, name: str) -> bool:
-        return _folder_paths().exists_annotated_filepath(name)
-
-    async def rpc_add_model_folder_path(
-        self, folder_name: str, full_folder_path: str, is_default: bool = False
-    ) -> None:
-        _folder_paths().add_model_folder_path(folder_name, full_folder_path, is_default)
-
-    async def rpc_get_folder_paths(self, folder_name: str) -> list[str]:
-        return _folder_paths().get_folder_paths(folder_name)
-
-    async def rpc_get_filename_list(self, folder_name: str) -> list[str]:
-        return _folder_paths().get_filename_list(folder_name)
-
-    async def rpc_get_full_path(self, folder_name: str, filename: str) -> str | None:
-        return _folder_paths().get_full_path(folder_name, filename)

comfy/isolation/proxies/helper_proxies.py

@@ -1,158 +0,0 @@
-from __future__ import annotations
-
-import os
-from typing import Any, Dict, Optional
-
-from pyisolate import ProxiedSingleton
-
-from .base import call_singleton_rpc
-
-
-class AnyTypeProxy(str):
-    """Replacement for custom AnyType objects used by some nodes."""
-
-    def __new__(cls, value: str = "*"):
-        return super().__new__(cls, value)
-
-    def __ne__(self, other):  # type: ignore[override]
-        return False
-
-
-class FlexibleOptionalInputProxy(dict):
-    """Replacement for FlexibleOptionalInputType to allow dynamic inputs."""
-
-    def __init__(self, flex_type, data: Optional[Dict[str, object]] = None):
-        super().__init__()
-        self.type = flex_type
-        if data:
-            self.update(data)
-
-    def __getitem__(self, key):  # type: ignore[override]
-        return (self.type,)
-
-    def __contains__(self, key):  # type: ignore[override]
-        return True
-
-
-class ByPassTypeTupleProxy(tuple):
-    """Replacement for ByPassTypeTuple to mirror wildcard fallback behavior."""
-
-    def __new__(cls, values):
-        return super().__new__(cls, values)
-
-    def __getitem__(self, index):  # type: ignore[override]
-        if index >= len(self):
-            return AnyTypeProxy("*")
-        return super().__getitem__(index)
-
-
-def _restore_special_value(value: Any) -> Any:
-    if isinstance(value, dict):
-        if value.get("__pyisolate_any_type__"):
-            return AnyTypeProxy(value.get("value", "*"))
-        if value.get("__pyisolate_flexible_optional__"):
-            flex_type = _restore_special_value(value.get("type"))
-            data_raw = value.get("data")
-            data = (
-                {k: _restore_special_value(v) for k, v in data_raw.items()}
-                if isinstance(data_raw, dict)
-                else {}
-            )
-            return FlexibleOptionalInputProxy(flex_type, data)
-        if value.get("__pyisolate_tuple__") is not None:
-            return tuple(
-                _restore_special_value(v) for v in value["__pyisolate_tuple__"]
-            )
-        if value.get("__pyisolate_bypass_tuple__") is not None:
-            return ByPassTypeTupleProxy(
-                tuple(
-                    _restore_special_value(v)
-                    for v in value["__pyisolate_bypass_tuple__"]
-                )
-            )
-        return {k: _restore_special_value(v) for k, v in value.items()}
-    if isinstance(value, list):
-        return [_restore_special_value(v) for v in value]
-    return value
-
-
-def _serialize_special_value(value: Any) -> Any:
-    if isinstance(value, AnyTypeProxy):
-        return {"__pyisolate_any_type__": True, "value": str(value)}
-    if isinstance(value, FlexibleOptionalInputProxy):
-        return {
-            "__pyisolate_flexible_optional__": True,
-            "type": _serialize_special_value(value.type),
-            "data": {k: _serialize_special_value(v) for k, v in value.items()},
-        }
-    if isinstance(value, ByPassTypeTupleProxy):
-        return {
-            "__pyisolate_bypass_tuple__": [_serialize_special_value(v) for v in value]
-        }
-    if isinstance(value, tuple):
-        return {"__pyisolate_tuple__": [_serialize_special_value(v) for v in value]}
-    if isinstance(value, list):
-        return [_serialize_special_value(v) for v in value]
-    if isinstance(value, dict):
-        return {k: _serialize_special_value(v) for k, v in value.items()}
-    return value
-
-
-def _restore_input_types_local(raw: Dict[str, object]) -> Dict[str, object]:
-    if not isinstance(raw, dict):
-        return raw  # type: ignore[return-value]
-
-    restored: Dict[str, object] = {}
-    for section, entries in raw.items():
-        if isinstance(entries, dict) and entries.get("__pyisolate_flexible_optional__"):
-            restored[section] = _restore_special_value(entries)
-        elif isinstance(entries, dict):
-            restored[section] = {
-                k: _restore_special_value(v) for k, v in entries.items()
-            }
-        else:
-            restored[section] = _restore_special_value(entries)
-    return restored
-
-
-class HelperProxiesService(ProxiedSingleton):
-    _rpc: Optional[Any] = None
-
-    @classmethod
-    def set_rpc(cls, rpc: Any) -> None:
-        cls._rpc = rpc.create_caller(cls, cls.get_remote_id())
-
-    @classmethod
-    def clear_rpc(cls) -> None:
-        cls._rpc = None
-
-    @classmethod
-    def _get_caller(cls) -> Any:
-        if cls._rpc is None:
-            raise RuntimeError("HelperProxiesService RPC caller is not configured")
-        return cls._rpc
-
-    async def rpc_restore_input_types(self, raw: Dict[str, object]) -> Dict[str, object]:
-        restored = _restore_input_types_local(raw)
-        return _serialize_special_value(restored)
-
-
-def restore_input_types(raw: Dict[str, object]) -> Dict[str, object]:
-    """Restore serialized INPUT_TYPES payload back into ComfyUI-compatible objects."""
-    if os.environ.get("PYISOLATE_CHILD") == "1":
-        payload = call_singleton_rpc(
-            HelperProxiesService._get_caller(),
-            "rpc_restore_input_types",
-            raw,
-        )
-        return _restore_input_types_local(payload)
-    return _restore_input_types_local(raw)
-
-
-__all__ = [
-    "AnyTypeProxy",
-    "FlexibleOptionalInputProxy",
-    "ByPassTypeTupleProxy",
-    "HelperProxiesService",
-    "restore_input_types",
-]

comfy/isolation/proxies/model_management_proxy.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-import os
-from typing import Any, Optional
-
-from pyisolate import ProxiedSingleton
-
-from .base import call_singleton_rpc
-
-
-def _mm():
-    import comfy.model_management
-
-    return comfy.model_management
-
-
-def _is_child_process() -> bool:
-    return os.environ.get("PYISOLATE_CHILD") == "1"
-
-
-class TorchDeviceProxy:
-    def __init__(self, device_str: str):
-        self._device_str = device_str
-        if ":" in device_str:
-            device_type, index = device_str.split(":", 1)
-            self.type = device_type
-            self.index = int(index)
-        else:
-            self.type = device_str
-            self.index = None
-
-    def __str__(self) -> str:
-        return self._device_str
-
-    def __repr__(self) -> str:
-        return f"TorchDeviceProxy({self._device_str!r})"
-
-
-def _serialize_value(value: Any) -> Any:
-    value_type = type(value)
-    if value_type.__module__ == "torch" and value_type.__name__ == "device":
-        return {"__pyisolate_torch_device__": str(value)}
-    if isinstance(value, TorchDeviceProxy):
-        return {"__pyisolate_torch_device__": str(value)}
-    if isinstance(value, tuple):
-        return {"__pyisolate_tuple__": [_serialize_value(item) for item in value]}
-    if isinstance(value, list):
-        return [_serialize_value(item) for item in value]
-    if isinstance(value, dict):
-        return {key: _serialize_value(inner) for key, inner in value.items()}
-    return value
-
-
-def _deserialize_value(value: Any) -> Any:
-    if isinstance(value, dict):
-        if "__pyisolate_torch_device__" in value:
-            return TorchDeviceProxy(value["__pyisolate_torch_device__"])
-        if "__pyisolate_tuple__" in value:
-            return tuple(_deserialize_value(item) for item in value["__pyisolate_tuple__"])
-        return {key: _deserialize_value(inner) for key, inner in value.items()}
-    if isinstance(value, list):
-        return [_deserialize_value(item) for item in value]
-    return value
-
-
-def _normalize_argument(value: Any) -> Any:
-    if isinstance(value, TorchDeviceProxy):
-        import torch
-
-        return torch.device(str(value))
-    if isinstance(value, dict):
-        if "__pyisolate_torch_device__" in value:
-            import torch
-
-            return torch.device(value["__pyisolate_torch_device__"])
-        if "__pyisolate_tuple__" in value:
-            return tuple(_normalize_argument(item) for item in value["__pyisolate_tuple__"])
-        return {key: _normalize_argument(inner) for key, inner in value.items()}
-    if isinstance(value, list):
-        return [_normalize_argument(item) for item in value]
-    return value
-
-
-class ModelManagementProxy(ProxiedSingleton):
-    """
-    Exact-relay proxy for comfy.model_management.
-    Child calls never import comfy.model_management directly; they serialize
-    arguments, relay to host, and deserialize the host result back.
-    """
-
-    _rpc: Optional[Any] = None
-
-    @classmethod
-    def set_rpc(cls, rpc: Any) -> None:
-        cls._rpc = rpc.create_caller(cls, cls.get_remote_id())
-
-    @classmethod
-    def clear_rpc(cls) -> None:
-        cls._rpc = None
-
-    @classmethod
-    def _get_caller(cls) -> Any:
-        if cls._rpc is None:
-            raise RuntimeError("ModelManagementProxy RPC caller is not configured")
-        return cls._rpc
-
-    def _relay_call(self, method_name: str, *args: Any, **kwargs: Any) -> Any:
-        payload = call_singleton_rpc(
-            self._get_caller(),
-            "rpc_call",
-            method_name,
-            _serialize_value(args),
-            _serialize_value(kwargs),
-        )
-        return _deserialize_value(payload)
-
-    @property
-    def VRAMState(self):
-        return _mm().VRAMState
-
-    @property
-    def CPUState(self):
-        return _mm().CPUState
-
-    @property
-    def OOM_EXCEPTION(self):
-        return _mm().OOM_EXCEPTION
-
-    def __getattr__(self, name: str):
-        if _is_child_process():
-            def child_method(*args: Any, **kwargs: Any) -> Any:
-                return self._relay_call(name, *args, **kwargs)
-
-            return child_method
-        return getattr(_mm(), name)
-
-    async def rpc_call(self, method_name: str, args: Any, kwargs: Any) -> Any:
-        normalized_args = _normalize_argument(_deserialize_value(args))
-        normalized_kwargs = _normalize_argument(_deserialize_value(kwargs))
-        method = getattr(_mm(), method_name)
-        result = method(*normalized_args, **normalized_kwargs)
-        return _serialize_value(result)

comfy/isolation/proxies/progress_proxy.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-from typing import Any, Optional
-
-try:
-    from pyisolate import ProxiedSingleton
-except ImportError:
-
-    class ProxiedSingleton:
-        pass
-
-from .base import call_singleton_rpc
-
-
-def _get_progress_state():
-    from comfy_execution.progress import get_progress_state
-
-    return get_progress_state()
-
-
-def _is_child_process() -> bool:
-    return os.environ.get("PYISOLATE_CHILD") == "1"
-
-logger = logging.getLogger(__name__)
-
-
-class ProgressProxy(ProxiedSingleton):
-    _rpc: Optional[Any] = None
-
-    @classmethod
-    def set_rpc(cls, rpc: Any) -> None:
-        cls._rpc = rpc.create_caller(cls, cls.get_remote_id())
-
-    @classmethod
-    def clear_rpc(cls) -> None:
-        cls._rpc = None
-
-    @classmethod
-    def _get_caller(cls) -> Any:
-        if cls._rpc is None:
-            raise RuntimeError("ProgressProxy RPC caller is not configured")
-        return cls._rpc
-
-    def set_progress(
-        self,
-        value: float,
-        max_value: float,
-        node_id: Optional[str] = None,
-        image: Any = None,
-    ) -> None:
-        if _is_child_process():
-            call_singleton_rpc(
-                self._get_caller(),
-                "rpc_set_progress",
-                value,
-                max_value,
-                node_id,
-                image,
-            )
-            return None
-
-        _get_progress_state().update_progress(
-            node_id=node_id,
-            value=value,
-            max_value=max_value,
-            image=image,
-        )
-        return None
-
-    async def rpc_set_progress(
-        self,
-        value: float,
-        max_value: float,
-        node_id: Optional[str] = None,
-        image: Any = None,
-    ) -> None:
-        _get_progress_state().update_progress(
-            node_id=node_id,
-            value=value,
-            max_value=max_value,
-            image=image,
-        )
-
-
-__all__ = ["ProgressProxy"]

comfy/isolation/proxies/prompt_server_impl.py

@@ -1,306 +0,0 @@
-# pylint: disable=import-outside-toplevel,logging-fstring-interpolation,redefined-outer-name,reimported,super-init-not-called
-"""Stateless RPC Implementation for PromptServer.
-
-Replaces the legacy PromptServerProxy (Singleton) with a clean Service/Stub architecture.
-- Host: PromptServerService (RPC Handler)
-- Child: PromptServerStub (Interface Implementation)
-"""
-
-from __future__ import annotations
-
-import os
-from typing import Any, Dict, Optional, Callable
-
-import logging
-
-# IMPORTS
-from pyisolate import ProxiedSingleton
-from .base import call_singleton_rpc
-
-logger = logging.getLogger(__name__)
-LOG_PREFIX = "[Isolation:C<->H]"
-
-# ...
-
-# =============================================================================
-# CHILD SIDE: PromptServerStub
-# =============================================================================
-
-
-class PromptServerStub:
-    """Stateless Stub for PromptServer."""
-
-    # Masquerade as the real server module
-    __module__ = "server"
-
-    _instance: Optional["PromptServerStub"] = None
-    _rpc: Optional[Any] = None  # This will be the Caller object
-    _source_file: Optional[str] = None
-
-    def __init__(self):
-        self.routes = RouteStub(self)
-
-    @classmethod
-    def set_rpc(cls, rpc: Any) -> None:
-        """Inject RPC client (called by adapter.py or manually)."""
-        # Create caller for HOST Service
-        # Assuming Host Service is registered as "PromptServerService" (class name)
-        # We target the Host Service Class
-        target_id = "PromptServerService"
-        # We need to pass a class to create_caller? Usually yes.
-        # But we don't have the Service class imported here necessarily (if running on child).
-        # pyisolate check verify_service type?
-        # If we pass PromptServerStub as the 'class', it might mismatch if checking types.
-        # But we can try passing PromptServerStub if it mirrors the service name? No, stub is PromptServerStub.
-        # We need a dummy class with right name?
-        # Or just rely on string ID if create_caller supports it?
-        # Standard: rpc.create_caller(PromptServerStub, target_id)
-        # But wait, PromptServerStub is the *Local* class.
-        # We want to call *Remote* class.
-        # If we use PromptServerStub as the type, returning object will be typed as PromptServerStub?
-        # The first arg is 'service_cls'.
-        cls._rpc = rpc.create_caller(
-            PromptServerService, target_id
-        )  # We import Service below?
-
-    @classmethod
-    def clear_rpc(cls) -> None:
-        cls._rpc = None
-
-    # We need PromptServerService available for the create_caller call?
-    # Or just use the Stub class if ID matches?
-    # prompt_server_impl.py defines BOTH. So PromptServerService IS available!
-
-    @property
-    def instance(self) -> "PromptServerStub":
-        return self
-
-    # ... Compatibility ...
-    @classmethod
-    def _get_source_file(cls) -> str:
-        if cls._source_file is None:
-            import folder_paths
-
-            cls._source_file = os.path.join(folder_paths.base_path, "server.py")
-        return cls._source_file
-
-    @property
-    def __file__(self) -> str:
-        return self._get_source_file()
-
-    # --- Properties ---
-    @property
-    def client_id(self) -> Optional[str]:
-        return "isolated_client"
-
-    @property
-    def supports(self) -> set:
-        return {"custom_nodes_from_web"}
-
-    @property
-    def app(self):
-        return _AppStub(self)
-
-    @property
-    def prompt_queue(self):
-        raise RuntimeError(
-            "PromptServer.prompt_queue is not accessible in isolated nodes."
-        )
-
-    # --- UI Communication (RPC Delegates) ---
-    async def send_sync(
-        self, event: str, data: Dict[str, Any], sid: Optional[str] = None
-    ) -> None:
-        if self._rpc:
-            await self._rpc.ui_send_sync(event, data, sid)
-
-    async def send(
-        self, event: str, data: Dict[str, Any], sid: Optional[str] = None
-    ) -> None:
-        if self._rpc:
-            await self._rpc.ui_send(event, data, sid)
-
-    def send_progress_text(self, text: str, node_id: str, sid=None) -> None:
-        if self._rpc:
-            # Fire and forget likely needed. If method is async on host, caller invocation returns coroutine.
-            # We must schedule it?
-            # Or use fire_remote equivalent?
-            # Caller object usually proxies calls. If host method is async, it returns coro.
-            # If we are sync here (send_progress_text checks imply sync usage), we must background it.
-            # But UtilsProxy hook wrapper creates task.
-            # Does send_progress_text need to be sync? Yes, node code calls it sync.
-            import asyncio
-
-            try:
-                loop = asyncio.get_running_loop()
-                loop.create_task(self._rpc.ui_send_progress_text(text, node_id, sid))
-            except RuntimeError:
-                call_singleton_rpc(self._rpc, "ui_send_progress_text", text, node_id, sid)
-
-    # --- Route Registration Logic ---
-    _pending_child_routes: list = []
-
-    def register_route(self, method: str, path: str, handler: Callable):
-        """Buffer route registration. Routes are flushed via flush_child_routes()."""
-        PromptServerStub._pending_child_routes.append((method, path, handler))
-        logger.info("%s Buffered isolated route %s %s", LOG_PREFIX, method, path)
-
-    @classmethod
-    async def flush_child_routes(cls):
-        """Send all buffered route registrations to host via RPC. Call from on_module_loaded."""
-        if not cls._rpc:
-            return 0
-        flushed = 0
-        for method, path, handler in cls._pending_child_routes:
-            try:
-                await cls._rpc.register_route_rpc(method, path, handler)
-                flushed += 1
-            except Exception as e:
-                logger.error("%s Child route flush failed %s %s: %s", LOG_PREFIX, method, path, e)
-        cls._pending_child_routes = []
-        return flushed
-
-
-class RouteStub:
-    """Simulates aiohttp.web.RouteTableDef."""
-
-    def __init__(self, stub: PromptServerStub):
-        self._stub = stub
-
-    def get(self, path: str):
-        def decorator(handler):
-            self._stub.register_route("GET", path, handler)
-            return handler
-
-        return decorator
-
-    def post(self, path: str):
-        def decorator(handler):
-            self._stub.register_route("POST", path, handler)
-            return handler
-
-        return decorator
-
-    def patch(self, path: str):
-        def decorator(handler):
-            self._stub.register_route("PATCH", path, handler)
-            return handler
-
-        return decorator
-
-    def put(self, path: str):
-        def decorator(handler):
-            self._stub.register_route("PUT", path, handler)
-            return handler
-
-        return decorator
-
-    def delete(self, path: str):
-        def decorator(handler):
-            self._stub.register_route("DELETE", path, handler)
-            return handler
-
-        return decorator
-
-
-# =============================================================================
-# HOST SIDE: PromptServerService
-# =============================================================================
-
-
-class PromptServerService(ProxiedSingleton):
-    """Host-side RPC Service for PromptServer."""
-
-    def __init__(self):
-        pass
-
-    @property
-    def server(self):
-        from server import PromptServer
-
-        return PromptServer.instance
-
-    async def ui_send_sync(
-        self, event: str, data: Dict[str, Any], sid: Optional[str] = None
-    ):
-        await self.server.send_sync(event, data, sid)
-
-    async def ui_send(
-        self, event: str, data: Dict[str, Any], sid: Optional[str] = None
-    ):
-        await self.server.send(event, data, sid)
-
-    async def ui_send_progress_text(self, text: str, node_id: str, sid=None):
-        # Made async to be awaitable by RPC layer
-        self.server.send_progress_text(text, node_id, sid)
-
-    async def register_route_rpc(self, method: str, path: str, child_handler_proxy):
-        """RPC Target: Register a route that forwards to the Child."""
-        from aiohttp import web
-        logger.info("%s Registering isolated route %s %s", LOG_PREFIX, method, path)
-
-        async def route_wrapper(request: web.Request) -> web.Response:
-            # 1. Capture request data
-            req_data = {
-                "method": request.method,
-                "path": request.path,
-                "query": dict(request.query),
-            }
-            if request.can_read_body:
-                req_data["text"] = await request.text()
-
-            try:
-                # 2. Call Child Handler via RPC (child_handler_proxy is async callable)
-                result = await child_handler_proxy(req_data)
-
-                # 3. Serialize Response
-                return self._serialize_response(result)
-            except Exception as e:
-                logger.error(f"{LOG_PREFIX} Isolated Route Error: {e}")
-                return web.Response(status=500, text=str(e))
-
-        self.server.app.router.add_route(method, path, route_wrapper)
-        logger.info("%s Registered isolated route %s %s", LOG_PREFIX, method, path)
-
-    def _serialize_response(self, result: Any) -> Any:
-        """Helper to convert Child result -> web.Response"""
-        from aiohttp import web
-        if isinstance(result, web.Response):
-            return result
-        # Handle dict (json)
-        if isinstance(result, dict):
-            return web.json_response(result)
-        # Handle string
-        if isinstance(result, str):
-            return web.Response(text=result)
-        # Fallback
-        return web.Response(text=str(result))
-
-
-class _RouterStub:
-    """Captures router.add_route and router.add_static calls in isolation child."""
-
-    def __init__(self, stub):
-        self._stub = stub
-
-    def add_route(self, method, path, handler, **kwargs):
-        self._stub.register_route(method, path, handler)
-
-    def add_static(self, prefix, path, **kwargs):
-        # Static file serving not supported in isolation — silently skip
-        pass
-
-
-class _AppStub:
-    """Captures PromptServer.app access patterns in isolation child."""
-
-    def __init__(self, stub):
-        self.router = _RouterStub(stub)
-        self.frozen = False
-
-    def add_routes(self, routes):
-        # aiohttp route table — iterate and register each
-        for route in routes:
-            if hasattr(route, "method") and hasattr(route, "handler"):
-                self.router.add_route(route.method, route.path, route.handler)
-            # StaticDef and other non-method routes — silently skip

comfy/isolation/proxies/utils_proxy.py

@@ -1,64 +0,0 @@
-# pylint: disable=cyclic-import,import-outside-toplevel
-from __future__ import annotations
-
-from typing import Optional, Any
-from pyisolate import ProxiedSingleton
-
-import os
-
-
-def _comfy_utils():
-    import comfy.utils
-    return comfy.utils
-
-
-class UtilsProxy(ProxiedSingleton):
-    """
-    Proxy for comfy.utils.
-    Primarily handles the PROGRESS_BAR_HOOK to ensure progress updates
-    from isolated nodes reach the host.
-    """
-
-    # _instance and __new__ removed to rely on SingletonMetaclass
-    _rpc: Optional[Any] = None
-
-    @classmethod
-    def set_rpc(cls, rpc: Any) -> None:
-        # Create caller using class name as ID (standard for Singletons)
-        cls._rpc = rpc.create_caller(cls, "UtilsProxy")
-
-    @classmethod
-    def clear_rpc(cls) -> None:
-        cls._rpc = None
-
-    async def progress_bar_hook(
-        self,
-        value: int,
-        total: int,
-        preview: Optional[bytes] = None,
-        node_id: Optional[str] = None,
-    ) -> Any:
-        """
-        Host-side implementation: forwards the call to the real global hook.
-        Child-side: this method call is intercepted by RPC and sent to host.
-        """
-        if os.environ.get("PYISOLATE_CHILD") == "1":
-            if UtilsProxy._rpc is None:
-                raise RuntimeError("UtilsProxy RPC caller is not configured")
-            return await UtilsProxy._rpc.progress_bar_hook(
-                value, total, preview, node_id
-            )
-
-        # Host Execution
-        utils = _comfy_utils()
-        if utils.PROGRESS_BAR_HOOK is not None:
-            return utils.PROGRESS_BAR_HOOK(value, total, preview, node_id)
-        return None
-
-    def set_progress_bar_global_hook(self, hook: Any) -> None:
-        """Forward hook registration (though usually not needed from child)."""
-        if os.environ.get("PYISOLATE_CHILD") == "1":
-            raise RuntimeError(
-                "UtilsProxy.set_progress_bar_global_hook is not available in child without exact relay support"
-            )
-        _comfy_utils().set_progress_bar_global_hook(hook)

comfy/isolation/proxies/web_directory_proxy.py

@@ -1,229 +0,0 @@
-"""WebDirectoryProxy — serves isolated node web assets via RPC.
-
-Child side: enumerates and reads files from the extension's web/ directory.
-Host side: gets an RPC proxy that fetches file listings and contents on demand.
-
-Only files with allowed extensions (.js, .html, .css) are served.
-Directory traversal is rejected. File contents are base64-encoded for
-safe JSON-RPC transport.
-"""
-
-from __future__ import annotations
-
-import base64
-import binascii
-import logging
-import os
-from pathlib import Path, PurePosixPath
-from typing import Any, Dict, List
-
-from pyisolate import ProxiedSingleton
-
-logger = logging.getLogger(__name__)
-
-ALLOWED_EXTENSIONS = frozenset({".js", ".html", ".css"})
-
-MIME_TYPES = {
-    ".js": "application/javascript",
-    ".html": "text/html",
-    ".css": "text/css",
-}
-
-
-class WebDirectoryProxy(ProxiedSingleton):
-    """Proxy for serving isolated extension web directories.
-
-    On the child side, this class has direct filesystem access to the
-    extension's web/ directory.  On the host side, callers get an RPC
-    proxy whose method calls are forwarded to the child.
-    """
-
-    # {extension_name: absolute_path_to_web_dir}
-    _web_dirs: dict[str, str] = {}
-
-    @classmethod
-    def register_web_dir(cls, extension_name: str, web_dir_path: str) -> None:
-        """Register an extension's web directory (child-side only)."""
-        cls._web_dirs[extension_name] = web_dir_path
-        logger.info(
-            "][ WebDirectoryProxy: registered %s -> %s",
-            extension_name,
-            web_dir_path,
-        )
-
-    def list_web_files(self, extension_name: str) -> List[Dict[str, str]]:
-        """Return a list of servable files in the extension's web directory.
-
-        Each entry is {"relative_path": "js/foo.js", "content_type": "application/javascript"}.
-        Only files with allowed extensions are included.
-        """
-        web_dir = self._web_dirs.get(extension_name)
-        if not web_dir:
-            return []
-
-        root = Path(web_dir)
-        if not root.is_dir():
-            return []
-
-        result: List[Dict[str, str]] = []
-        for path in sorted(root.rglob("*")):
-            if not path.is_file():
-                continue
-            ext = path.suffix.lower()
-            if ext not in ALLOWED_EXTENSIONS:
-                continue
-            rel = path.relative_to(root)
-            result.append({
-                "relative_path": str(PurePosixPath(rel)),
-                "content_type": MIME_TYPES[ext],
-            })
-        return result
-
-    def get_web_file(
-        self, extension_name: str, relative_path: str
-    ) -> Dict[str, Any]:
-        """Return the contents of a single web file as base64.
-
-        Raises ValueError for traversal attempts or disallowed file types.
-        Returns {"content": <base64 str>, "content_type": <MIME str>}.
-        """
-        _validate_path(relative_path)
-
-        web_dir = self._web_dirs.get(extension_name)
-        if not web_dir:
-            raise FileNotFoundError(
-                f"No web directory registered for {extension_name}"
-            )
-
-        root = Path(web_dir).resolve()
-        target = (root / relative_path).resolve()
-
-        # Ensure resolved path is under the web directory
-        if os.path.commonpath([str(root), str(target)]) != str(root):
-            raise ValueError(f"Path escapes web directory: {relative_path}")
-
-        if not target.is_file():
-            raise FileNotFoundError(f"File not found: {relative_path}")
-
-        ext = target.suffix.lower()
-        if ext not in ALLOWED_EXTENSIONS:
-            raise ValueError(f"Disallowed file type: {ext}")
-
-        content_type = MIME_TYPES[ext]
-        raw = target.read_bytes()
-
-        return {
-            "content": base64.b64encode(raw).decode("ascii"),
-            "content_type": content_type,
-        }
-
-
-def _validate_path(relative_path: str) -> None:
-    """Reject directory traversal and absolute paths."""
-    if os.path.isabs(relative_path):
-        raise ValueError(f"Absolute paths are not allowed: {relative_path}")
-    if ".." in PurePosixPath(relative_path).parts:
-        raise ValueError(f"Directory traversal is not allowed: {relative_path}")
-
-
-# ---------------------------------------------------------------------------
-# Host-side cache and aiohttp handler
-# ---------------------------------------------------------------------------
-
-
-class WebDirectoryCache:
-    """Host-side in-memory cache for proxied web directory contents.
-
-    Populated lazily via RPC calls to the child's WebDirectoryProxy.
-    Once a file is cached, subsequent requests are served from memory.
-    """
-
-    def __init__(self) -> None:
-        # {extension_name: {relative_path: {"content": bytes, "content_type": str}}}
-        self._file_cache: dict[str, dict[str, dict[str, Any]]] = {}
-        # {extension_name: [{"relative_path": str, "content_type": str}, ...]}
-        self._listing_cache: dict[str, list[dict[str, str]]] = {}
-        # {extension_name: WebDirectoryProxy (RPC proxy instance)}
-        self._proxies: dict[str, Any] = {}
-
-    def register_proxy(self, extension_name: str, proxy: Any) -> None:
-        """Register an RPC proxy for an extension's web directory."""
-        self._proxies[extension_name] = proxy
-        logger.info(
-            "][ WebDirectoryCache: registered proxy for %s", extension_name
-        )
-
-    @property
-    def extension_names(self) -> list[str]:
-        return list(self._proxies.keys())
-
-    def list_files(self, extension_name: str) -> list[dict[str, str]]:
-        """List servable files for an extension (cached after first call)."""
-        if extension_name not in self._listing_cache:
-            proxy = self._proxies.get(extension_name)
-            if proxy is None:
-                return []
-            try:
-                self._listing_cache[extension_name] = proxy.list_web_files(
-                    extension_name
-                )
-            except Exception:
-                logger.warning(
-                    "][ WebDirectoryCache: failed to list files for %s",
-                    extension_name,
-                    exc_info=True,
-                )
-                return []
-        return self._listing_cache[extension_name]
-
-    def get_file(
-        self, extension_name: str, relative_path: str
-    ) -> dict[str, Any] | None:
-        """Get file content (cached after first fetch). Returns None on miss."""
-        ext_cache = self._file_cache.get(extension_name)
-        if ext_cache and relative_path in ext_cache:
-            return ext_cache[relative_path]
-
-        proxy = self._proxies.get(extension_name)
-        if proxy is None:
-            return None
-
-        try:
-            result = proxy.get_web_file(extension_name, relative_path)
-        except (FileNotFoundError, ValueError):
-            return None
-        except Exception:
-            logger.warning(
-                "][ WebDirectoryCache: failed to fetch %s/%s",
-                extension_name,
-                relative_path,
-                exc_info=True,
-            )
-            return None
-
-        try:
-            decoded = {
-                "content": base64.b64decode(result["content"], validate=True),
-                "content_type": result["content_type"],
-            }
-        except (binascii.Error, KeyError, TypeError):
-            logger.warning(
-                "][ WebDirectoryCache: invalid payload for %s/%s",
-                extension_name,
-                relative_path,
-                exc_info=True,
-            )
-            return None
-
-        if extension_name not in self._file_cache:
-            self._file_cache[extension_name] = {}
-        self._file_cache[extension_name][relative_path] = decoded
-        return decoded
-
-
-# Global cache instance — populated during isolation loading
-_web_directory_cache = WebDirectoryCache()
-
-
-def get_web_directory_cache() -> WebDirectoryCache:
-    return _web_directory_cache

comfy/isolation/rpc_bridge.py

@@ -1,49 +0,0 @@
-import asyncio
-import logging
-import threading
-
-logger = logging.getLogger(__name__)
-
-
-class RpcBridge:
-    """Minimal helper to run coroutines synchronously inside isolated processes.
-
-    If an event loop is already running, the coroutine is executed on a fresh
-    thread with its own loop to avoid nested run_until_complete errors.
-    """
-
-    def run_sync(self, maybe_coro):
-        if not asyncio.iscoroutine(maybe_coro):
-            return maybe_coro
-
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = None
-
-        if loop and loop.is_running():
-            result_container = {}
-            exc_container = {}
-
-            def _runner():
-                try:
-                    new_loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(new_loop)
-                    result_container["value"] = new_loop.run_until_complete(maybe_coro)
-                except Exception as exc:  # pragma: no cover
-                    exc_container["error"] = exc
-                finally:
-                    try:
-                        new_loop.close()
-                    except Exception:
-                        pass
-
-            t = threading.Thread(target=_runner, daemon=True)
-            t.start()
-            t.join()
-
-            if "error" in exc_container:
-                raise exc_container["error"]
-            return result_container.get("value")
-
-        return asyncio.run(maybe_coro)

comfy/isolation/runtime_helpers.py

@@ -1,471 +0,0 @@
-# pylint: disable=consider-using-from-import,import-outside-toplevel,no-member
-from __future__ import annotations
-
-import copy
-import logging
-import os
-from pathlib import Path
-from typing import Any, Dict, List, Set, TYPE_CHECKING
-
-from .proxies.helper_proxies import restore_input_types
-from .shm_forensics import scan_shm_forensics
-
-_IMPORT_TORCH = os.environ.get("PYISOLATE_IMPORT_TORCH", "1") == "1"
-
-_ComfyNodeInternal = object
-latest_io = None
-
-if _IMPORT_TORCH:
-    from comfy_api.internal import _ComfyNodeInternal
-    from comfy_api.latest import _io as latest_io
-
-if TYPE_CHECKING:
-    from .extension_wrapper import ComfyNodeExtension
-
-LOG_PREFIX = "]["
-_PRE_EXEC_MIN_FREE_VRAM_BYTES = 2 * 1024 * 1024 * 1024
-
-
-class _RemoteObjectRegistryCaller:
-    def __init__(self, extension: Any) -> None:
-        self._extension = extension
-
-    def __getattr__(self, method_name: str) -> Any:
-        async def _call(instance_id: str, *args: Any, **kwargs: Any) -> Any:
-            return await self._extension.call_remote_object_method(
-                instance_id,
-                method_name,
-                *args,
-                **kwargs,
-            )
-
-        return _call
-
-
-def _wrap_remote_handles_as_host_proxies(value: Any, extension: Any) -> Any:
-    from pyisolate._internal.remote_handle import RemoteObjectHandle
-
-    if isinstance(value, RemoteObjectHandle):
-        if value.type_name == "ModelPatcher":
-            from comfy.isolation.model_patcher_proxy import ModelPatcherProxy
-
-            proxy = ModelPatcherProxy(value.object_id, manage_lifecycle=False)
-            proxy._rpc_caller = _RemoteObjectRegistryCaller(extension)  # type: ignore[attr-defined]
-            proxy._pyisolate_remote_handle = value  # type: ignore[attr-defined]
-            return proxy
-        if value.type_name == "VAE":
-            from comfy.isolation.vae_proxy import VAEProxy
-
-            proxy = VAEProxy(value.object_id, manage_lifecycle=False)
-            proxy._rpc_caller = _RemoteObjectRegistryCaller(extension)  # type: ignore[attr-defined]
-            proxy._pyisolate_remote_handle = value  # type: ignore[attr-defined]
-            return proxy
-        if value.type_name == "CLIP":
-            from comfy.isolation.clip_proxy import CLIPProxy
-
-            proxy = CLIPProxy(value.object_id, manage_lifecycle=False)
-            proxy._rpc_caller = _RemoteObjectRegistryCaller(extension)  # type: ignore[attr-defined]
-            proxy._pyisolate_remote_handle = value  # type: ignore[attr-defined]
-            return proxy
-        if value.type_name == "ModelSampling":
-            from comfy.isolation.model_sampling_proxy import ModelSamplingProxy
-
-            proxy = ModelSamplingProxy(value.object_id, manage_lifecycle=False)
-            proxy._rpc_caller = _RemoteObjectRegistryCaller(extension)  # type: ignore[attr-defined]
-            proxy._pyisolate_remote_handle = value  # type: ignore[attr-defined]
-            return proxy
-        return value
-
-    if isinstance(value, dict):
-        return {
-            k: _wrap_remote_handles_as_host_proxies(v, extension) for k, v in value.items()
-        }
-
-    if isinstance(value, (list, tuple)):
-        wrapped = [_wrap_remote_handles_as_host_proxies(item, extension) for item in value]
-        return type(value)(wrapped)
-
-    return value
-
-
-def _resource_snapshot() -> Dict[str, int]:
-    fd_count = -1
-    shm_sender_files = 0
-    try:
-        fd_count = len(os.listdir("/proc/self/fd"))
-    except Exception:
-        pass
-    try:
-        shm_root = Path("/dev/shm")
-        if shm_root.exists():
-            prefix = f"torch_{os.getpid()}_"
-            shm_sender_files = sum(1 for _ in shm_root.glob(f"{prefix}*"))
-    except Exception:
-        pass
-    return {"fd_count": fd_count, "shm_sender_files": shm_sender_files}
-
-
-def _tensor_transport_summary(value: Any) -> Dict[str, int]:
-    summary: Dict[str, int] = {
-        "tensor_count": 0,
-        "cpu_tensors": 0,
-        "cuda_tensors": 0,
-        "shared_cpu_tensors": 0,
-        "tensor_bytes": 0,
-    }
-    try:
-        import torch
-    except Exception:
-        return summary
-
-    def visit(node: Any) -> None:
-        if isinstance(node, torch.Tensor):
-            summary["tensor_count"] += 1
-            summary["tensor_bytes"] += int(node.numel() * node.element_size())
-            if node.device.type == "cpu":
-                summary["cpu_tensors"] += 1
-                if node.is_shared():
-                    summary["shared_cpu_tensors"] += 1
-            elif node.device.type == "cuda":
-                summary["cuda_tensors"] += 1
-            return
-        if isinstance(node, dict):
-            for v in node.values():
-                visit(v)
-            return
-        if isinstance(node, (list, tuple)):
-            for v in node:
-                visit(v)
-
-    visit(value)
-    return summary
-
-
-def _extract_hidden_unique_id(inputs: Dict[str, Any]) -> str | None:
-    for key, value in inputs.items():
-        key_text = str(key)
-        if "unique_id" in key_text:
-            return str(value)
-    return None
-
-
-def _flush_tensor_transport_state(marker: str, logger: logging.Logger) -> None:
-    try:
-        from pyisolate import flush_tensor_keeper  # type: ignore[attr-defined]
-    except Exception:
-        return
-    if not callable(flush_tensor_keeper):
-        return
-    flushed = flush_tensor_keeper()
-    if flushed > 0:
-        logger.debug(
-            "%s %s flush_tensor_keeper released=%d", LOG_PREFIX, marker, flushed
-        )
-
-
-def _relieve_host_vram_pressure(marker: str, logger: logging.Logger) -> None:
-    import comfy.model_management as model_management
-
-    model_management.cleanup_models_gc()
-    model_management.cleanup_models()
-
-    device = model_management.get_torch_device()
-    if not hasattr(device, "type") or device.type == "cpu":
-        return
-
-    required = max(
-        model_management.minimum_inference_memory(),
-        _PRE_EXEC_MIN_FREE_VRAM_BYTES,
-    )
-    if model_management.get_free_memory(device) < required:
-        model_management.free_memory(required, device, for_dynamic=True)
-        if model_management.get_free_memory(device) < required:
-            model_management.free_memory(required, device, for_dynamic=False)
-        model_management.cleanup_models()
-        model_management.soft_empty_cache()
-        logger.debug("%s %s free_memory target=%d", LOG_PREFIX, marker, required)
-
-
-def _detach_shared_cpu_tensors(value: Any) -> Any:
-    try:
-        import torch
-    except Exception:
-        return value
-
-    if isinstance(value, torch.Tensor):
-        if value.device.type == "cpu" and value.is_shared():
-            clone = value.clone()
-            if value.requires_grad:
-                clone.requires_grad_(True)
-            return clone
-        return value
-    if isinstance(value, list):
-        return [_detach_shared_cpu_tensors(v) for v in value]
-    if isinstance(value, tuple):
-        return tuple(_detach_shared_cpu_tensors(v) for v in value)
-    if isinstance(value, dict):
-        return {k: _detach_shared_cpu_tensors(v) for k, v in value.items()}
-    return value
-
-
-def build_stub_class(
-    node_name: str,
-    info: Dict[str, object],
-    extension: "ComfyNodeExtension",
-    running_extensions: Dict[str, "ComfyNodeExtension"],
-    logger: logging.Logger,
-) -> type:
-    if latest_io is None:
-        raise RuntimeError("comfy_api.latest._io is required to build isolation stubs")
-    is_v3 = bool(info.get("is_v3", False))
-    function_name = "_pyisolate_execute"
-    restored_input_types = restore_input_types(info.get("input_types", {}))
-
-    async def _execute(self, **inputs):
-        from comfy.isolation import _RUNNING_EXTENSIONS
-
-        # Update BOTH the local dict AND the module-level dict
-        running_extensions[extension.name] = extension
-        _RUNNING_EXTENSIONS[extension.name] = extension
-        prev_child = None
-        node_unique_id = _extract_hidden_unique_id(inputs)
-        summary = _tensor_transport_summary(inputs)
-        resources = _resource_snapshot()
-        logger.debug(
-            "%s ISO:execute_start ext=%s node=%s uid=%s",
-            LOG_PREFIX,
-            extension.name,
-            node_name,
-            node_unique_id or "-",
-        )
-        logger.debug(
-            "%s ISO:execute_start ext=%s node=%s uid=%s tensors=%d cpu=%d cuda=%d shared_cpu=%d bytes=%d fds=%d sender_shm=%d",
-            LOG_PREFIX,
-            extension.name,
-            node_name,
-            node_unique_id or "-",
-            summary["tensor_count"],
-            summary["cpu_tensors"],
-            summary["cuda_tensors"],
-            summary["shared_cpu_tensors"],
-            summary["tensor_bytes"],
-            resources["fd_count"],
-            resources["shm_sender_files"],
-        )
-        scan_shm_forensics("RUNTIME:execute_start", refresh_model_context=True)
-        try:
-            if os.environ.get("PYISOLATE_CHILD") != "1":
-                _relieve_host_vram_pressure("RUNTIME:pre_execute", logger)
-                scan_shm_forensics("RUNTIME:pre_execute", refresh_model_context=True)
-            from pyisolate._internal.model_serialization import (
-                serialize_for_isolation,
-                deserialize_from_isolation,
-            )
-
-            prev_child = os.environ.pop("PYISOLATE_CHILD", None)
-            logger.debug(
-                "%s ISO:serialize_start ext=%s node=%s uid=%s",
-                LOG_PREFIX,
-                extension.name,
-                node_name,
-                node_unique_id or "-",
-            )
-            # Unwrap NodeOutput-like dicts before serialization.
-            # OUTPUT_NODE nodes return {"ui": {...}, "result": (outputs...)}
-            # and the executor may pass this dict as input to downstream nodes.
-            unwrapped_inputs = {}
-            for k, v in inputs.items():
-                if isinstance(v, dict) and "result" in v and ("ui" in v or "__node_output__" in v):
-                    result = v.get("result")
-                    if isinstance(result, (tuple, list)) and len(result) > 0:
-                        unwrapped_inputs[k] = result[0]
-                    else:
-                        unwrapped_inputs[k] = result
-                else:
-                    unwrapped_inputs[k] = v
-            serialized = serialize_for_isolation(unwrapped_inputs)
-            logger.debug(
-                "%s ISO:serialize_done ext=%s node=%s uid=%s",
-                LOG_PREFIX,
-                extension.name,
-                node_name,
-                node_unique_id or "-",
-            )
-            logger.debug(
-                "%s ISO:dispatch_start ext=%s node=%s uid=%s",
-                LOG_PREFIX,
-                extension.name,
-                node_name,
-                node_unique_id or "-",
-            )
-            result = await extension.execute_node(node_name, **serialized)
-            logger.debug(
-                "%s ISO:dispatch_done ext=%s node=%s uid=%s",
-                LOG_PREFIX,
-                extension.name,
-                node_name,
-                node_unique_id or "-",
-            )
-            # Reconstruct NodeOutput if the child serialized one
-            if isinstance(result, dict) and result.get("__node_output__"):
-                from comfy_api.latest import io as latest_io
-                args_raw = result.get("args", ())
-                deserialized_args = await deserialize_from_isolation(args_raw, extension)
-                deserialized_args = _wrap_remote_handles_as_host_proxies(
-                    deserialized_args, extension
-                )
-                deserialized_args = _detach_shared_cpu_tensors(deserialized_args)
-                ui_raw = result.get("ui")
-                deserialized_ui = None
-                if ui_raw is not None:
-                    deserialized_ui = await deserialize_from_isolation(ui_raw, extension)
-                    deserialized_ui = _wrap_remote_handles_as_host_proxies(
-                        deserialized_ui, extension
-                    )
-                    deserialized_ui = _detach_shared_cpu_tensors(deserialized_ui)
-                scan_shm_forensics("RUNTIME:post_execute", refresh_model_context=True)
-                return latest_io.NodeOutput(
-                    *deserialized_args,
-                    ui=deserialized_ui,
-                    expand=result.get("expand"),
-                    block_execution=result.get("block_execution"),
-                )
-            # OUTPUT_NODE: if sealed worker returned a tuple/list whose first
-            # element is a {"ui": ...} dict, unwrap it for the executor.
-            if (isinstance(result, (tuple, list)) and len(result) == 1
-                    and isinstance(result[0], dict) and "ui" in result[0]):
-                return result[0]
-            deserialized = await deserialize_from_isolation(result, extension)
-            deserialized = _wrap_remote_handles_as_host_proxies(deserialized, extension)
-            scan_shm_forensics("RUNTIME:post_execute", refresh_model_context=True)
-            return _detach_shared_cpu_tensors(deserialized)
-        except ImportError:
-            return await extension.execute_node(node_name, **inputs)
-        except Exception:
-            logger.exception(
-                "%s ISO:execute_error ext=%s node=%s uid=%s",
-                LOG_PREFIX,
-                extension.name,
-                node_name,
-                node_unique_id or "-",
-            )
-            raise
-        finally:
-            if prev_child is not None:
-                os.environ["PYISOLATE_CHILD"] = prev_child
-            logger.debug(
-                "%s ISO:execute_end ext=%s node=%s uid=%s",
-                LOG_PREFIX,
-                extension.name,
-                node_name,
-                node_unique_id or "-",
-            )
-            scan_shm_forensics("RUNTIME:execute_end", refresh_model_context=True)
-
-    def _input_types(
-        cls,
-        include_hidden: bool = True,
-        return_schema: bool = False,
-        live_inputs: Any = None,
-    ):
-        if not is_v3:
-            return restored_input_types
-
-        inputs_copy = copy.deepcopy(restored_input_types)
-        if not include_hidden:
-            inputs_copy.pop("hidden", None)
-
-        v3_data: Dict[str, Any] = {"hidden_inputs": {}}
-        dynamic = inputs_copy.pop("dynamic_paths", None)
-        if dynamic is not None:
-            v3_data["dynamic_paths"] = dynamic
-
-        if return_schema:
-            hidden_vals = info.get("hidden", []) or []
-            hidden_enums = []
-            for h in hidden_vals:
-                try:
-                    hidden_enums.append(latest_io.Hidden(h))
-                except Exception:
-                    hidden_enums.append(h)
-
-            class SchemaProxy:
-                hidden = hidden_enums
-
-            return inputs_copy, SchemaProxy, v3_data
-        return inputs_copy
-
-    def _validate_class(cls):
-        return True
-
-    def _get_node_info_v1(cls):
-        node_info = copy.deepcopy(info.get("schema_v1", {}))
-        relative_python_module = node_info.get("python_module")
-        if not isinstance(relative_python_module, str) or not relative_python_module:
-            relative_python_module = f"custom_nodes.{extension.name}"
-        node_info["python_module"] = relative_python_module
-        return node_info
-
-    def _get_base_class(cls):
-        return latest_io.ComfyNode
-
-    attributes: Dict[str, object] = {
-        "FUNCTION": function_name,
-        "CATEGORY": info.get("category", ""),
-        "OUTPUT_NODE": info.get("output_node", False),
-        "RETURN_TYPES": tuple(info.get("return_types", ()) or ()),
-        "RETURN_NAMES": info.get("return_names"),
-        function_name: _execute,
-        "_pyisolate_extension": extension,
-        "_pyisolate_node_name": node_name,
-        "INPUT_TYPES": classmethod(_input_types),
-    }
-
-    output_is_list = info.get("output_is_list")
-    if output_is_list is not None:
-        attributes["OUTPUT_IS_LIST"] = tuple(output_is_list)
-
-    if is_v3:
-        attributes["VALIDATE_CLASS"] = classmethod(_validate_class)
-        attributes["GET_NODE_INFO_V1"] = classmethod(_get_node_info_v1)
-        attributes["GET_BASE_CLASS"] = classmethod(_get_base_class)
-        attributes["DESCRIPTION"] = info.get("description", "")
-        attributes["EXPERIMENTAL"] = info.get("experimental", False)
-        attributes["DEPRECATED"] = info.get("deprecated", False)
-        attributes["API_NODE"] = info.get("api_node", False)
-        attributes["NOT_IDEMPOTENT"] = info.get("not_idempotent", False)
-        attributes["ACCEPT_ALL_INPUTS"] = info.get("accept_all_inputs", False)
-        attributes["_ACCEPT_ALL_INPUTS"] = info.get("accept_all_inputs", False)
-        attributes["INPUT_IS_LIST"] = info.get("input_is_list", False)
-
-    class_name = f"PyIsolate_{node_name}".replace(" ", "_")
-    bases = (_ComfyNodeInternal,) if is_v3 else ()
-    stub_cls = type(class_name, bases, attributes)
-
-    if is_v3:
-        try:
-            stub_cls.VALIDATE_CLASS()
-        except Exception as e:
-            logger.error("%s VALIDATE_CLASS failed: %s - %s", LOG_PREFIX, node_name, e)
-
-    return stub_cls
-
-
-def get_class_types_for_extension(
-    extension_name: str,
-    running_extensions: Dict[str, "ComfyNodeExtension"],
-    specs: List[Any],
-) -> Set[str]:
-    extension = running_extensions.get(extension_name)
-    if not extension:
-        return set()
-
-    ext_path = Path(extension.module_path)
-    class_types = set()
-    for spec in specs:
-        if spec.module_path.resolve() == ext_path.resolve():
-            class_types.add(spec.node_name)
-    return class_types
-
-
-__all__ = ["build_stub_class", "get_class_types_for_extension"]

comfy/isolation/shm_forensics.py

@@ -1,217 +0,0 @@
-# pylint: disable=consider-using-from-import,import-outside-toplevel
-from __future__ import annotations
-
-import atexit
-import hashlib
-import logging
-import os
-from pathlib import Path
-from typing import Any, Dict, List, Set
-
-LOG_PREFIX = "]["
-logger = logging.getLogger(__name__)
-
-
-def _shm_debug_enabled() -> bool:
-    return os.environ.get("COMFY_ISO_SHM_DEBUG") == "1"
-
-
-class _SHMForensicsTracker:
-    def __init__(self) -> None:
-        self._started = False
-        self._tracked_files: Set[str] = set()
-        self._current_model_context: Dict[str, str] = {
-            "id": "unknown",
-            "name": "unknown",
-            "hash": "????",
-        }
-
-    @staticmethod
-    def _snapshot_shm() -> Set[str]:
-        shm_path = Path("/dev/shm")
-        if not shm_path.exists():
-            return set()
-        return {f.name for f in shm_path.glob("torch_*")}
-
-    def start(self) -> None:
-        if self._started or not _shm_debug_enabled():
-            return
-        self._tracked_files = self._snapshot_shm()
-        self._started = True
-        logger.debug(
-            "%s SHM:forensics_enabled tracked=%d", LOG_PREFIX, len(self._tracked_files)
-        )
-
-    def stop(self) -> None:
-        if not self._started:
-            return
-        self.scan("shutdown", refresh_model_context=True)
-        self._started = False
-        logger.debug("%s SHM:forensics_disabled", LOG_PREFIX)
-
-    def _compute_model_hash(self, model_patcher: Any) -> str:
-        try:
-            model_instance_id = getattr(model_patcher, "_instance_id", None)
-            if model_instance_id is not None:
-                model_id_text = str(model_instance_id)
-                return model_id_text[-4:] if len(model_id_text) >= 4 else model_id_text
-
-            import torch
-
-            real_model = (
-                model_patcher.model
-                if hasattr(model_patcher, "model")
-                else model_patcher
-            )
-            tensor = None
-            if hasattr(real_model, "parameters"):
-                for p in real_model.parameters():
-                    if torch.is_tensor(p) and p.numel() > 0:
-                        tensor = p
-                        break
-
-            if tensor is None:
-                return "0000"
-
-            flat = tensor.flatten()
-            values = []
-            indices = [0, flat.shape[0] // 2, flat.shape[0] - 1]
-            for i in indices:
-                if i < flat.shape[0]:
-                    values.append(flat[i].item())
-
-            size = 0
-            if hasattr(model_patcher, "model_size"):
-                size = model_patcher.model_size()
-            sample_str = f"{values}_{id(model_patcher):016x}_{size}"
-            return hashlib.sha256(sample_str.encode()).hexdigest()[-4:]
-        except Exception:
-            return "err!"
-
-    def _get_models_snapshot(self) -> List[Dict[str, Any]]:
-        try:
-            import comfy.model_management as model_management
-        except Exception:
-            return []
-
-        snapshot: List[Dict[str, Any]] = []
-        try:
-            for loaded_model in model_management.current_loaded_models:
-                model = loaded_model.model
-                if model is None:
-                    continue
-                if str(getattr(loaded_model, "device", "")) != "cuda:0":
-                    continue
-
-                name = (
-                    model.model.__class__.__name__
-                    if hasattr(model, "model")
-                    else type(model).__name__
-                )
-                model_hash = self._compute_model_hash(model)
-                model_instance_id = getattr(model, "_instance_id", None)
-                if model_instance_id is None:
-                    model_instance_id = model_hash
-                snapshot.append(
-                    {
-                        "name": str(name),
-                        "id": str(model_instance_id),
-                        "hash": str(model_hash or "????"),
-                        "used": bool(getattr(loaded_model, "currently_used", False)),
-                    }
-                )
-        except Exception:
-            return []
-
-        return snapshot
-
-    def _update_model_context(self) -> None:
-        snapshot = self._get_models_snapshot()
-        selected = None
-
-        used_models = [m for m in snapshot if m.get("used") and m.get("id")]
-        if used_models:
-            selected = used_models[-1]
-        else:
-            live_models = [m for m in snapshot if m.get("id")]
-            if live_models:
-                selected = live_models[-1]
-
-        if selected is None:
-            self._current_model_context = {
-                "id": "unknown",
-                "name": "unknown",
-                "hash": "????",
-            }
-            return
-
-        self._current_model_context = {
-            "id": str(selected.get("id", "unknown")),
-            "name": str(selected.get("name", "unknown")),
-            "hash": str(selected.get("hash", "????") or "????"),
-        }
-
-    def scan(self, marker: str, refresh_model_context: bool = True) -> None:
-        if not self._started or not _shm_debug_enabled():
-            return
-
-        if refresh_model_context:
-            self._update_model_context()
-
-        current = self._snapshot_shm()
-        added = current - self._tracked_files
-        removed = self._tracked_files - current
-        self._tracked_files = current
-
-        if not added and not removed:
-            logger.debug("%s SHM:scan marker=%s changes=0", LOG_PREFIX, marker)
-            return
-
-        for filename in sorted(added):
-            logger.info("%s SHM:created | %s", LOG_PREFIX, filename)
-            model_id = self._current_model_context["id"]
-            if model_id == "unknown":
-                logger.error(
-                    "%s SHM:model_association_missing | file=%s | reason=no_active_model_context",
-                    LOG_PREFIX,
-                    filename,
-                )
-            else:
-                logger.info(
-                    "%s SHM:model_association | model=%s | file=%s | name=%s | hash=%s",
-                    LOG_PREFIX,
-                    model_id,
-                    filename,
-                    self._current_model_context["name"],
-                    self._current_model_context["hash"],
-                )
-
-        for filename in sorted(removed):
-            logger.info("%s SHM:deleted | %s", LOG_PREFIX, filename)
-
-        logger.debug(
-            "%s SHM:scan marker=%s created=%d deleted=%d active=%d",
-            LOG_PREFIX,
-            marker,
-            len(added),
-            len(removed),
-            len(self._tracked_files),
-        )
-
-
-_TRACKER = _SHMForensicsTracker()
-
-
-def start_shm_forensics() -> None:
-    _TRACKER.start()
-
-
-def scan_shm_forensics(marker: str, refresh_model_context: bool = True) -> None:
-    _TRACKER.scan(marker, refresh_model_context=refresh_model_context)
-
-
-def stop_shm_forensics() -> None:
-    _TRACKER.stop()
-
-
-atexit.register(stop_shm_forensics)

comfy/isolation/vae_proxy.py

@@ -1,214 +0,0 @@
-# pylint: disable=attribute-defined-outside-init
-import logging
-from typing import Any
-
-from comfy.isolation.proxies.base import (
-    IS_CHILD_PROCESS,
-    BaseProxy,
-    BaseRegistry,
-    detach_if_grad,
-)
-from comfy.isolation.model_patcher_proxy import ModelPatcherProxy, ModelPatcherRegistry
-
-logger = logging.getLogger(__name__)
-
-
-class FirstStageModelRegistry(BaseRegistry[Any]):
-    _type_prefix = "first_stage_model"
-
-    async def get_property(self, instance_id: str, name: str) -> Any:
-        obj = self._get_instance(instance_id)
-        return getattr(obj, name)
-
-    async def has_property(self, instance_id: str, name: str) -> bool:
-        obj = self._get_instance(instance_id)
-        return hasattr(obj, name)
-
-
-class FirstStageModelProxy(BaseProxy[FirstStageModelRegistry]):
-    _registry_class = FirstStageModelRegistry
-    __module__ = "comfy.ldm.models.autoencoder"
-
-    def __getattr__(self, name: str) -> Any:
-        try:
-            return self._call_rpc("get_property", name)
-        except Exception as e:
-            raise AttributeError(
-                f"'{self.__class__.__name__}' object has no attribute '{name}'"
-            ) from e
-
-    def __repr__(self) -> str:
-        return f"<FirstStageModelProxy {self._instance_id}>"
-
-
-class VAERegistry(BaseRegistry[Any]):
-    _type_prefix = "vae"
-
-    async def get_patcher_id(self, instance_id: str) -> str:
-        vae = self._get_instance(instance_id)
-        return ModelPatcherRegistry().register(vae.patcher)
-
-    async def get_first_stage_model_id(self, instance_id: str) -> str:
-        vae = self._get_instance(instance_id)
-        return FirstStageModelRegistry().register(vae.first_stage_model)
-
-    async def encode(self, instance_id: str, pixels: Any) -> Any:
-        return detach_if_grad(self._get_instance(instance_id).encode(pixels))
-
-    async def encode_tiled(
-        self,
-        instance_id: str,
-        pixels: Any,
-        tile_x: int = 512,
-        tile_y: int = 512,
-        overlap: int = 64,
-    ) -> Any:
-        return detach_if_grad(
-            self._get_instance(instance_id).encode_tiled(
-                pixels, tile_x=tile_x, tile_y=tile_y, overlap=overlap
-            )
-        )
-
-    async def decode(self, instance_id: str, samples: Any, **kwargs: Any) -> Any:
-        return detach_if_grad(self._get_instance(instance_id).decode(samples, **kwargs))
-
-    async def decode_tiled(
-        self,
-        instance_id: str,
-        samples: Any,
-        tile_x: int = 64,
-        tile_y: int = 64,
-        overlap: int = 16,
-        **kwargs: Any,
-    ) -> Any:
-        return detach_if_grad(
-            self._get_instance(instance_id).decode_tiled(
-                samples, tile_x=tile_x, tile_y=tile_y, overlap=overlap, **kwargs
-            )
-        )
-
-    async def get_property(self, instance_id: str, name: str) -> Any:
-        return getattr(self._get_instance(instance_id), name)
-
-    async def memory_used_encode(self, instance_id: str, shape: Any, dtype: Any) -> int:
-        return self._get_instance(instance_id).memory_used_encode(shape, dtype)
-
-    async def memory_used_decode(self, instance_id: str, shape: Any, dtype: Any) -> int:
-        return self._get_instance(instance_id).memory_used_decode(shape, dtype)
-
-    async def process_input(self, instance_id: str, image: Any) -> Any:
-        return detach_if_grad(self._get_instance(instance_id).process_input(image))
-
-    async def process_output(self, instance_id: str, image: Any) -> Any:
-        return detach_if_grad(self._get_instance(instance_id).process_output(image))
-
-
-class VAEProxy(BaseProxy[VAERegistry]):
-    _registry_class = VAERegistry
-    __module__ = "comfy.sd"
-
-    @property
-    def patcher(self) -> ModelPatcherProxy:
-        if not hasattr(self, "_patcher_proxy"):
-            patcher_id = self._call_rpc("get_patcher_id")
-            self._patcher_proxy = ModelPatcherProxy(patcher_id, manage_lifecycle=False)
-        return self._patcher_proxy
-
-    @property
-    def first_stage_model(self) -> FirstStageModelProxy:
-        if not hasattr(self, "_first_stage_model_proxy"):
-            fsm_id = self._call_rpc("get_first_stage_model_id")
-            self._first_stage_model_proxy = FirstStageModelProxy(
-                fsm_id, manage_lifecycle=False
-            )
-        return self._first_stage_model_proxy
-
-    @property
-    def vae_dtype(self) -> Any:
-        return self._get_property("vae_dtype")
-
-    def encode(self, pixels: Any) -> Any:
-        return self._call_rpc("encode", pixels)
-
-    def encode_tiled(
-        self, pixels: Any, tile_x: int = 512, tile_y: int = 512, overlap: int = 64
-    ) -> Any:
-        return self._call_rpc("encode_tiled", pixels, tile_x, tile_y, overlap)
-
-    def decode(self, samples: Any, **kwargs: Any) -> Any:
-        return self._call_rpc("decode", samples, **kwargs)
-
-    def decode_tiled(
-        self,
-        samples: Any,
-        tile_x: int = 64,
-        tile_y: int = 64,
-        overlap: int = 16,
-        **kwargs: Any,
-    ) -> Any:
-        return self._call_rpc(
-            "decode_tiled", samples, tile_x, tile_y, overlap, **kwargs
-        )
-
-    def get_sd(self) -> Any:
-        return self._call_rpc("get_sd")
-
-    def _get_property(self, name: str) -> Any:
-        return self._call_rpc("get_property", name)
-
-    @property
-    def latent_dim(self) -> int:
-        return self._get_property("latent_dim")
-
-    @property
-    def latent_channels(self) -> int:
-        return self._get_property("latent_channels")
-
-    @property
-    def downscale_ratio(self) -> Any:
-        return self._get_property("downscale_ratio")
-
-    @property
-    def upscale_ratio(self) -> Any:
-        return self._get_property("upscale_ratio")
-
-    @property
-    def output_channels(self) -> int:
-        return self._get_property("output_channels")
-
-    @property
-    def not_video(self) -> bool:
-        return self._get_property("not_video")
-
-    @property
-    def device(self) -> Any:
-        return self._get_property("device")
-
-    @property
-    def working_dtypes(self) -> Any:
-        return self._get_property("working_dtypes")
-
-    @property
-    def disable_offload(self) -> bool:
-        return self._get_property("disable_offload")
-
-    @property
-    def size(self) -> Any:
-        return self._get_property("size")
-
-    def memory_used_encode(self, shape: Any, dtype: Any) -> int:
-        return self._call_rpc("memory_used_encode", shape, dtype)
-
-    def memory_used_decode(self, shape: Any, dtype: Any) -> int:
-        return self._call_rpc("memory_used_decode", shape, dtype)
-
-    def process_input(self, image: Any) -> Any:
-        return self._call_rpc("process_input", image)
-
-    def process_output(self, image: Any) -> Any:
-        return self._call_rpc("process_output", image)
-
-
-if not IS_CHILD_PROCESS:
-    _VAE_REGISTRY_SINGLETON = VAERegistry()
-    _FIRST_STAGE_MODEL_REGISTRY_SINGLETON = FirstStageModelRegistry()

comfy/k_diffusion/sampling.py

@@ -1,5 +1,4 @@
 import math
-import os
 from functools import partial
 
 from scipy import integrate
@@ -13,8 +12,8 @@ from . import deis
 from . import sa_solver
 import comfy.model_patcher
 import comfy.model_sampling
+
 import comfy.memory_management
-from comfy.cli_args import args
 from comfy.utils import model_trange as trange
 
 def append_zero(x):
@@ -192,13 +191,6 @@ def sample_euler(model, x, sigmas, extra_args=None, callback=None, disable=None,
     """Implements Algorithm 2 (Euler steps) from Karras et al. (2022)."""
     extra_args = {} if extra_args is None else extra_args
     s_in = x.new_ones([x.shape[0]])
-    isolation_active = args.use_process_isolation or os.environ.get("PYISOLATE_CHILD") == "1"
-    if isolation_active:
-        target_device = sigmas.device
-        if x.device != target_device:
-            x = x.to(target_device)
-        s_in = s_in.to(target_device)
-
     for i in trange(len(sigmas) - 1, disable=disable):
         if s_churn > 0:
             gamma = min(s_churn / (len(sigmas) - 1), 2 ** 0.5 - 1) if s_tmin <= sigmas[i] <= s_tmax else 0.

comfy/latent_formats.py

@@ -224,7 +224,6 @@ class Flux2(LatentFormat):
 
         self.latent_rgb_factors_bias = [-0.0329, -0.0718, -0.0851]
         self.latent_rgb_factors_reshape = lambda t: t.reshape(t.shape[0], 32, 2, 2, t.shape[-2], t.shape[-1]).permute(0, 1, 4, 2, 5, 3).reshape(t.shape[0], 32, t.shape[-2] * 2, t.shape[-1] * 2)
-        self.taesd_decoder_name = "taef2_decoder"
 
     def process_in(self, latent):
         return latent
@@ -784,10 +783,3 @@ class ZImagePixelSpace(ChromaRadiance):
     No VAE encoding/decoding — the model operates directly on RGB pixels.
     """
     pass
-
-class CogVideoX(LatentFormat):
-    latent_channels = 16
-    latent_dimensions = 3
-
-    def __init__(self):
-        self.scale_factor = 1.15258426

comfy/ldm/ace/ace_step15.py

@@ -611,7 +611,6 @@ class AceStepDiTModel(nn.Module):
         intermediate_size,
         patch_size,
         audio_acoustic_hidden_dim,
-        condition_dim=None,
         layer_types=None,
         sliding_window=128,
         rms_norm_eps=1e-6,
@@ -641,7 +640,7 @@ class AceStepDiTModel(nn.Module):
 
         self.time_embed = TimestepEmbedding(256, hidden_size, dtype=dtype, device=device, operations=operations)
         self.time_embed_r = TimestepEmbedding(256, hidden_size, dtype=dtype, device=device, operations=operations)
-        self.condition_embedder = Linear(condition_dim, hidden_size, dtype=dtype, device=device)
+        self.condition_embedder = Linear(hidden_size, hidden_size, dtype=dtype, device=device)
 
         if layer_types is None:
             layer_types = ["full_attention"] * num_layers
@@ -1036,9 +1035,6 @@ class AceStepConditionGenerationModel(nn.Module):
         fsq_dim=2048,
         fsq_levels=[8, 8, 8, 5, 5, 5],
         fsq_input_num_quantizers=1,
-        encoder_hidden_size=2048,
-        encoder_intermediate_size=6144,
-        encoder_num_heads=16,
         audio_model=None,
         dtype=None,
         device=None,
@@ -1058,24 +1054,24 @@ class AceStepConditionGenerationModel(nn.Module):
 
         self.decoder = AceStepDiTModel(
             in_channels, hidden_size, num_dit_layers, num_heads, num_kv_heads, head_dim,
-            intermediate_size, patch_size, audio_acoustic_hidden_dim, condition_dim=encoder_hidden_size,
+            intermediate_size, patch_size, audio_acoustic_hidden_dim,
             layer_types=layer_types, sliding_window=sliding_window, rms_norm_eps=rms_norm_eps,
             dtype=dtype, device=device, operations=operations
         )
         self.encoder = AceStepConditionEncoder(
-            text_hidden_dim, timbre_hidden_dim, encoder_hidden_size, num_lyric_layers, num_timbre_layers,
-            encoder_num_heads, num_kv_heads, head_dim, encoder_intermediate_size, rms_norm_eps,
+            text_hidden_dim, timbre_hidden_dim, hidden_size, num_lyric_layers, num_timbre_layers,
+            num_heads, num_kv_heads, head_dim, intermediate_size, rms_norm_eps,
             dtype=dtype, device=device, operations=operations
         )
         self.tokenizer = AceStepAudioTokenizer(
-            audio_acoustic_hidden_dim, encoder_hidden_size, pool_window_size, fsq_dim=fsq_dim, fsq_levels=fsq_levels, fsq_input_num_quantizers=fsq_input_num_quantizers, num_layers=num_tokenizer_layers, head_dim=head_dim, rms_norm_eps=rms_norm_eps,
+            audio_acoustic_hidden_dim, hidden_size, pool_window_size, fsq_dim=fsq_dim, fsq_levels=fsq_levels, fsq_input_num_quantizers=fsq_input_num_quantizers, num_layers=num_tokenizer_layers, head_dim=head_dim, rms_norm_eps=rms_norm_eps,
             dtype=dtype, device=device, operations=operations
         )
         self.detokenizer = AudioTokenDetokenizer(
-            encoder_hidden_size, pool_window_size, audio_acoustic_hidden_dim, num_layers=2, head_dim=head_dim,
+            hidden_size, pool_window_size, audio_acoustic_hidden_dim, num_layers=2, head_dim=head_dim,
             dtype=dtype, device=device, operations=operations
         )
-        self.null_condition_emb = nn.Parameter(torch.empty(1, 1, encoder_hidden_size, dtype=dtype, device=device))
+        self.null_condition_emb = nn.Parameter(torch.empty(1, 1, hidden_size, dtype=dtype, device=device))
 
     def prepare_condition(
         self,