Merge branch 'master' into cursor/mark-deprecated-cloud-endpoints-e81e

2026-07-21 23:41:28 +08:00 · 2026-05-12 09:11:38 -07:00 · 2026-05-11 11:45:42 -07:00 · 2026-05-08 19:48:32 -07:00 · 2026-05-08 18:30:11 -07:00 · 2026-05-08 15:19:04 -07:00
393 changed files with 14986 additions and 86674 deletions
@@ -1,4 +1,5 @@
-As of the time of writing this you need a recent driver. Updating to the latest driver is recommended.
+As of the time of writing this you need this driver for best results:
+https://www.amd.com/en/resources/support-articles/release-notes/RN-AMDGPU-WINDOWS-PYTORCH-7-1-1.html

 HOW TO RUN:

@@ -6,9 +7,9 @@ If you have a AMD gpu:

 run_amd_gpu.bat

-If you have memory issues you can try enabling the new dynamic memory management by running comfyui with:
+If you have memory issues you can try disabling the smart memory management by running comfyui with:

-run_amd_gpu_enable_dynamic_vram.bat
+run_amd_gpu_disable_smart_memory.bat

 IF YOU GET A RED ERROR IN THE UI MAKE SURE YOU HAVE A MODEL/CHECKPOINT IN: ComfyUI\models\checkpoints

@@ -4,12 +4,12 @@ early_access: false
 tone_instructions: "Only comment on issues introduced by this PR's changes. Do not flag pre-existing problems in moved, re-indented, or reformatted code."

 reviews:
-  profile: "assertive"
-  request_changes_workflow: true
+  profile: "chill"
+  request_changes_workflow: false
  high_level_summary: false
  poem: false
  review_status: false
-  review_details: true
+  review_details: false
  commit_status: true
  collapse_walkthrough: true
  changed_files_summary: false
@@ -39,14 +39,6 @@ reviews:
    - path: "**"
      instructions: |
        IMPORTANT: Only comment on issues directly introduced by this PR's code changes.
-        Treat AGENTS.md as mandatory repository policy, not optional style guidance.
-        Flag PR changes that violate AGENTS.md even when the code is otherwise functional.
-        In particular, enforce architecture boundaries, dtype/device/memory rules,
-        interface contracts, import style, no unnecessary try/except blocks, no inline
-        imports, no outbound internet paths in core ComfyUI, and narrow scoped fixes.
-        Prefer direct findings over suggestions when a rule is violated. Only ignore
-        AGENTS.md when it clearly conflicts with a newer explicit maintainer instruction
-        in the PR.
        Do NOT flag pre-existing issues in code that was merely moved, re-indented,
        de-indented, or reformatted without logic changes. If code appears in the diff
        only due to whitespace or structural reformatting (e.g., removing a `with:` block),
@@ -131,10 +123,5 @@ chat:

 knowledge_base:
  opt_out: false
-  code_guidelines:
-    enabled: true
-    filePatterns:
-      - files: "AGENTS.md"
-        applyTo: "**"
  learnings:
    scope: "auto"
@@ -1,519 +0,0 @@
-name: Backport Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      commit:
-        description: 'Full 40-char SHA of the tip commit of the backport source branch (the PR head commit that passed tests). The branch is resolved from this SHA and must be unique.'
-        required: true
-        type: string
-
-permissions:
-  contents: read
-  pull-requests: read
-  checks: read
-
-jobs:
-  backport-release:
-    name: Create backport release
-    runs-on: ubuntu-latest
-    environment: backport release
-
-    steps:
-      - name: Generate GitHub App token
-        id: app-token
-        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1
-        with:
-          app-id: ${{ secrets.FEN_RELEASE_APP_ID }}
-          private-key: ${{ secrets.FEN_RELEASE_PRIVATE_KEY }}
-
-      - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd
-        with:
-          token: ${{ steps.app-token.outputs.token }}
-          fetch-depth: 0
-          fetch-tags: true
-
-      - name: Configure git
-        run: |
-          git config user.name  "fen-release[bot]"
-          git config user.email "fen-release[bot]@users.noreply.github.com"
-
-      - name: Resolve source branch from commit SHA
-        id: resolve
-        env:
-          SOURCE_COMMIT:  ${{ inputs.commit }}
-          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
-        run: |
-          set -euo pipefail
-
-          # Require a full 40-char lowercase-hex SHA. Short SHAs are ambiguous
-          # and we will be comparing this value against API responses (PR head
-          # SHA, ref tips) that always return the full form.
-          if [[ ! "${SOURCE_COMMIT}" =~ ^[0-9a-f]{40}$ ]]; then
-            echo "::error::Input commit '${SOURCE_COMMIT}' is not a full 40-char lowercase hex SHA."
-            exit 1
-          fi
-
-          # Fetch all remote branches so we can search for which one(s) point
-          # at this SHA. `actions/checkout` with fetch-depth: 0 fetches full
-          # history of the checked-out ref but does not necessarily populate
-          # every refs/remotes/origin/*, so do it explicitly.
-          git fetch --prune origin '+refs/heads/*:refs/remotes/origin/*'
-
-          # Verify the commit actually exists in this repo's object DB.
-          if ! git cat-file -e "${SOURCE_COMMIT}^{commit}" 2>/dev/null; then
-            echo "::error::Commit ${SOURCE_COMMIT} was not found in the repository."
-            exit 1
-          fi
-
-          # Find every remote branch whose tip == SOURCE_COMMIT. Exactly one
-          # branch must point at it. If zero, the commit isn't anyone's tip
-          # (likely stale, force-pushed past, or never the PR head). If more
-          # than one, the (branch -> SHA) mapping is ambiguous and we refuse
-          # to guess — the operator must give us a unique branch to release.
-          mapfile -t matching_branches < <(
-            git for-each-ref \
-              --format='%(refname:strip=3)' \
-              --points-at="${SOURCE_COMMIT}" \
-              refs/remotes/origin/ \
-              | grep -vx 'HEAD' || true
-          )
-
-          if [[ "${#matching_branches[@]}" -eq 0 ]]; then
-            echo "::error::No branch on origin has ${SOURCE_COMMIT} as its tip."
-            echo "::error::Either the branch was updated after you copied this SHA, or this commit was never the head of a branch."
-            exit 1
-          fi
-
-          if [[ "${#matching_branches[@]}" -gt 1 ]]; then
-            echo "::error::More than one branch on origin has ${SOURCE_COMMIT} as its tip; cannot pick one:"
-            for b in "${matching_branches[@]}"; do
-              echo "::error::  - ${b}"
-            done
-            echo "::error::Refusing to proceed with an ambiguous source branch."
-            exit 1
-          fi
-
-          source_branch="${matching_branches[0]}"
-
-          if [[ "${source_branch}" == "${DEFAULT_BRANCH}" ]]; then
-            echo "::error::Source branch must not be the default branch ('${DEFAULT_BRANCH}')."
-            exit 1
-          fi
-
-          echo "Resolved commit ${SOURCE_COMMIT} to branch '${source_branch}'."
-          echo "source_branch=${source_branch}" >> "$GITHUB_OUTPUT"
-
-      - name: Determine latest stable release
-        id: latest
-        env:
-          GH_TOKEN: ${{ steps.app-token.outputs.token }}
-        run: |
-          set -euo pipefail
-
-          # List all tags matching vMAJOR.MINOR.PATCH and pick the highest by numeric
-          # comparison of each component. We DO NOT use `sort -V` because it treats
-          # v0.19.99 as higher than v0.20.1.
-          latest_tag="$(
-            git tag --list 'v[0-9]*.[0-9]*.[0-9]*' \
-              | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' \
-              | awk -F'[v.]' '{ printf "%010d %010d %010d %s\n", $2, $3, $4, $0 }' \
-              | sort -k1,1n -k2,2n -k3,3n \
-              | tail -n1 \
-              | awk '{print $4}'
-          )"
-
-          if [[ -z "${latest_tag}" ]]; then
-            echo "::error::No stable release tags (vMAJOR.MINOR.PATCH) were found."
-            exit 1
-          fi
-
-          # Parse components
-          ver="${latest_tag#v}"
-          major="${ver%%.*}"
-          rest="${ver#*.}"
-          minor="${rest%%.*}"
-          patch="${rest#*.}"
-
-          new_patch=$((patch + 1))
-          new_version="v${major}.${minor}.${new_patch}"
-          release_branch="release/v${major}.${minor}"
-
-          latest_sha="$(git rev-list -n 1 "refs/tags/${latest_tag}")"
-
-          echo "latest_tag=${latest_tag}"             >> "$GITHUB_OUTPUT"
-          echo "latest_sha=${latest_sha}"             >> "$GITHUB_OUTPUT"
-          echo "major=${major}"                       >> "$GITHUB_OUTPUT"
-          echo "minor=${minor}"                       >> "$GITHUB_OUTPUT"
-          echo "patch=${patch}"                       >> "$GITHUB_OUTPUT"
-          echo "new_version=${new_version}"           >> "$GITHUB_OUTPUT"
-          echo "new_version_no_v=${major}.${minor}.${new_patch}" >> "$GITHUB_OUTPUT"
-          echo "release_branch=${release_branch}"     >> "$GITHUB_OUTPUT"
-
-          echo "Latest stable release: ${latest_tag} (${latest_sha})"
-          echo "New version will be:   ${new_version}"
-          echo "Release branch:        ${release_branch}"
-
-      - name: Validate source branch is cut directly from the latest stable release
-        env:
-          SOURCE_BRANCH:   ${{ steps.resolve.outputs.source_branch }}
-          SOURCE_COMMIT:   ${{ inputs.commit }}
-          LATEST_TAG_SHA:  ${{ steps.latest.outputs.latest_sha }}
-          LATEST_TAG:      ${{ steps.latest.outputs.latest_tag }}
-        run: |
-          set -euo pipefail
-
-          # Use the user-provided SHA directly rather than re-resolving the branch
-          # tip — the resolve step already proved the branch tip equals SOURCE_COMMIT,
-          # and pinning to the SHA here makes the rest of the job TOCTOU-safe against
-          # someone pushing to the branch mid-run.
-          source_sha="${SOURCE_COMMIT}"
-
-          # Walking first-parent from the source tip must reach LATEST_TAG_SHA.
-          # We capture rev-list into a variable and grep against a here-string
-          # rather than piping `rev-list | grep -q`: under `set -o pipefail`,
-          # `grep -q` would exit on first match and SIGPIPE the still-streaming
-          # `rev-list`, propagating exit 141 as a spurious "not found".
-          first_parent_chain="$(git rev-list --first-parent "${source_sha}")"
-          if ! grep -Fxq "${LATEST_TAG_SHA}" <<< "${first_parent_chain}"; then
-            echo "::error::Source branch '${SOURCE_BRANCH}' is not cut from '${LATEST_TAG}'."
-            echo "::error::Its first-parent history does not include ${LATEST_TAG_SHA}."
-            exit 1
-          fi
-
-          # Additionally, every commit added on top of the tag (the set we are
-          # about to publish) must itself be a descendant of the tag along
-          # first-parent — i.e. no sibling commits from master sneak in via a
-          # non-first-parent path. Enforce by requiring that the symmetric
-          # difference is empty in one direction: commits in source that are
-          # NOT first-parent-reachable from source starting at the tag.
-          # We do this by intersecting:
-          #   A = commits reachable from source but not from tag (full DAG)
-          #   B = commits on the first-parent chain from source down to tag
-          # and requiring A == B.
-          all_added="$(git rev-list "${LATEST_TAG_SHA}..${source_sha}" | sort)"
-          first_parent_added="$(
-            git rev-list --first-parent "${LATEST_TAG_SHA}..${source_sha}" | sort
-          )"
-
-          if [[ "${all_added}" != "${first_parent_added}" ]]; then
-            echo "::error::Source branch '${SOURCE_BRANCH}' contains commits not on its first-parent chain from '${LATEST_TAG}'."
-            echo "::error::This usually means the branch was cut from master (not from the tag) or contains a merge from master."
-            echo "Commits reachable but not on first-parent chain:"
-            comm -23 <(printf '%s\n' "${all_added}") <(printf '%s\n' "${first_parent_added}") \
-              | while read -r sha; do
-                  echo "  $(git log -1 --format='%h %s' "${sha}")"
-                done
-            exit 1
-          fi
-
-          added_count="$(printf '%s\n' "${all_added}" | grep -c . || true)"
-          echo "Source branch is cut directly from ${LATEST_TAG} with ${added_count} commit(s) on top."
-
-      - name: Validate PR exists, is open, named correctly, has latest commit, and checks pass
-        env:
-          GH_TOKEN:      ${{ steps.app-token.outputs.token }}
-          SOURCE_BRANCH: ${{ steps.resolve.outputs.source_branch }}
-          SOURCE_COMMIT: ${{ inputs.commit }}
-          NEW_VERSION:   ${{ steps.latest.outputs.new_version }}
-          REPO:          ${{ github.repository }}
-        run: |
-          set -euo pipefail
-
-          expected_title="ComfyUI backport release ${NEW_VERSION}"
-
-          # Find open PRs from this branch into master. The --state open filter
-          # is load-bearing: a closed/merged PR with passing checks must not be
-          # accepted as authorization for a new release.
-          pr_json="$(
-            gh pr list \
-              --repo "${REPO}" \
-              --state open \
-              --head "${SOURCE_BRANCH}" \
-              --base master \
-              --json number,title,headRefOid,state \
-              --limit 10
-          )"
-
-          pr_count="$(echo "${pr_json}" | jq 'length')"
-          if [[ "${pr_count}" -eq 0 ]]; then
-            echo "::error::No open PR found from '${SOURCE_BRANCH}' into 'master'. The PR must exist and be open."
-            exit 1
-          fi
-
-          # Pick the PR matching the expected title
-          pr_number="$(echo "${pr_json}" | jq -r --arg t "${expected_title}" '
-            map(select(.title == $t)) | .[0].number // empty
-          ')"
-          pr_head_sha="$(echo "${pr_json}" | jq -r --arg t "${expected_title}" '
-            map(select(.title == $t)) | .[0].headRefOid // empty
-          ')"
-
-          if [[ -z "${pr_number}" ]]; then
-            echo "::error::No open PR from '${SOURCE_BRANCH}' into 'master' is titled '${expected_title}'."
-            echo "Found PRs:"
-            echo "${pr_json}" | jq -r '.[] | "  #\(.number): \(.title)"'
-            exit 1
-          fi
-
-          # The PR's current head commit must equal the SHA the operator gave us.
-          # This is what closes the door on releasing stale code: if anyone has
-          # pushed to the branch since the operator validated tests passed, the
-          # PR head will have advanced past SOURCE_COMMIT and we abort. (The
-          # resolve step already proved the branch tip == SOURCE_COMMIT; this
-          # ties that same SHA to the PR that authorizes the release.)
-          if [[ "${pr_head_sha}" != "${SOURCE_COMMIT}" ]]; then
-            echo "::error::PR #${pr_number} head commit is ${pr_head_sha}, but the operator-provided commit is ${SOURCE_COMMIT}."
-            echo "::error::The PR has new commits since this release was authorized. Re-run with the new head SHA after verifying its checks."
-            exit 1
-          fi
-
-          echo "Found open PR #${pr_number} titled '${expected_title}' at head ${pr_head_sha} (matches operator-provided commit)."
-
-          # Verify all check runs on the head commit have completed successfully.
-          # A check is considered passing if conclusion is success, neutral, or skipped.
-          checks_json="$(
-            gh api \
-              --paginate \
-              "repos/${REPO}/commits/${pr_head_sha}/check-runs" \
-              --jq '.check_runs[] | {name: .name, status: .status, conclusion: .conclusion}'
-          )"
-
-          if [[ -z "${checks_json}" ]]; then
-            echo "::error::No check runs found on PR head commit ${pr_head_sha}."
-            exit 1
-          fi
-
-          echo "Check runs on ${pr_head_sha}:"
-          echo "${checks_json}" | jq -s '.'
-
-          failing="$(echo "${checks_json}" | jq -s '
-            map(select(
-              .status != "completed"
-              or (.conclusion as $c
-                  | ["success","neutral","skipped"]
-                  | index($c) | not)
-            ))
-          ')"
-
-          failing_count="$(echo "${failing}" | jq 'length')"
-          if [[ "${failing_count}" -gt 0 ]]; then
-            echo "::error::One or more checks have not passed on PR head commit ${pr_head_sha}:"
-            echo "${failing}" | jq -r '.[] | "  - \(.name): status=\(.status) conclusion=\(.conclusion)"'
-            exit 1
-          fi
-
-          echo "All checks have passed on ${pr_head_sha}."
-
-      - name: Prepare release branch
-        id: prepare
-        env:
-          GH_TOKEN:        ${{ steps.app-token.outputs.token }}
-          REPO:            ${{ github.repository }}
-          RELEASE_BRANCH:  ${{ steps.latest.outputs.release_branch }}
-          LATEST_TAG:      ${{ steps.latest.outputs.latest_tag }}
-          LATEST_TAG_SHA:  ${{ steps.latest.outputs.latest_sha }}
-          PATCH:           ${{ steps.latest.outputs.patch }}
-        run: |
-          set -euo pipefail
-
-          # Try to fetch the release branch. If patch == 0, it shouldn't exist yet
-          # and we'll create it from the latest stable tag. If patch > 0, it must
-          # already exist and its tip must equal the latest stable tag commit (i.e.
-          # the previous patch release).
-          if git ls-remote --exit-code --heads origin "${RELEASE_BRANCH}" >/dev/null 2>&1; then
-            echo "Release branch '${RELEASE_BRANCH}' already exists on origin."
-            git fetch origin "refs/heads/${RELEASE_BRANCH}:refs/remotes/origin/${RELEASE_BRANCH}"
-            git checkout -B "${RELEASE_BRANCH}" "refs/remotes/origin/${RELEASE_BRANCH}"
-
-            current_tip="$(git rev-parse HEAD)"
-            if [[ "${current_tip}" != "${LATEST_TAG_SHA}" ]]; then
-              echo "::error::Release branch '${RELEASE_BRANCH}' tip (${current_tip}) is not at the latest stable release '${LATEST_TAG}' (${LATEST_TAG_SHA})."
-              echo "::error::Refusing to release on top of a divergent branch."
-              exit 1
-            fi
-            echo "branch_existed=true" >> "$GITHUB_OUTPUT"
-          else
-            if [[ "${PATCH}" != "0" ]]; then
-              echo "::error::Release branch '${RELEASE_BRANCH}' does not exist on origin, but the latest stable release '${LATEST_TAG}' has patch=${PATCH} (>0). This is inconsistent."
-              exit 1
-            fi
-            echo "Release branch '${RELEASE_BRANCH}' does not exist. Creating from ${LATEST_TAG}."
-            git checkout -B "${RELEASE_BRANCH}" "refs/tags/${LATEST_TAG}"
-            echo "branch_existed=false" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Fast-forward merge source branch into release branch
-        env:
-          SOURCE_BRANCH:  ${{ steps.resolve.outputs.source_branch }}
-          SOURCE_COMMIT:  ${{ inputs.commit }}
-          RELEASE_BRANCH: ${{ steps.latest.outputs.release_branch }}
-        run: |
-          set -euo pipefail
-
-          # --ff-only guarantees no merge commit is created. If a fast-forward is
-          # not possible (i.e. the release branch has commits the source branch
-          # doesn't), the merge will fail and we abort. Because we already validated
-          # that the source branch is rooted on the latest stable tag, and the
-          # release branch tip equals that same tag, this fast-forward should
-          # always succeed for a well-formed backport branch.
-          #
-          # We merge the operator-provided SHA, not the branch ref, so a push to
-          # the branch in the window between resolve and now cannot smuggle new
-          # commits into the release.
-          if ! git merge --ff-only "${SOURCE_COMMIT}"; then
-            echo "::error::Cannot fast-forward '${RELEASE_BRANCH}' to ${SOURCE_COMMIT} (tip of '${SOURCE_BRANCH}'). A merge commit would be required. Aborting."
-            exit 1
-          fi
-
-          echo "Fast-forwarded '${RELEASE_BRANCH}' to ${SOURCE_COMMIT} (tip of '${SOURCE_BRANCH}')."
-
-      - name: Bump version files
-        env:
-          NEW_VERSION_NO_V: ${{ steps.latest.outputs.new_version_no_v }}
-        run: |
-          set -euo pipefail
-
-          if [[ ! -f comfyui_version.py ]]; then
-            echo "::error::comfyui_version.py not found in repo root."
-            exit 1
-          fi
-          if [[ ! -f pyproject.toml ]]; then
-            echo "::error::pyproject.toml not found in repo root."
-            exit 1
-          fi
-
-          # Replace the version string in comfyui_version.py.
-          # Expected format:  __version__ = "X.Y.Z"
-          python3 - "$NEW_VERSION_NO_V" <<'PY'
-          import re, sys, pathlib
-          new = sys.argv[1]
-
-          p = pathlib.Path("comfyui_version.py")
-          src = p.read_text()
-          new_src, n = re.subn(
-              r'(__version__\s*=\s*[\'"])[^\'"]+([\'"])',
-              lambda m: f'{m.group(1)}{new}{m.group(2)}',
-              src,
-              count=1,
-          )
-          if n != 1:
-              sys.exit("Could not find __version__ assignment in comfyui_version.py")
-          p.write_text(new_src)
-
-          p = pathlib.Path("pyproject.toml")
-          src = p.read_text()
-          # Replace the first `version = "..."` inside [project] or [tool.poetry].
-          new_src, n = re.subn(
-              r'(?m)^(version\s*=\s*")[^"]+(")',
-              lambda m: f'{m.group(1)}{new}{m.group(2)}',
-              src,
-              count=1,
-          )
-          if n != 1:
-              sys.exit("Could not find version assignment in pyproject.toml")
-          p.write_text(new_src)
-          PY
-
-          echo "Updated version to ${NEW_VERSION_NO_V} in comfyui_version.py and pyproject.toml."
-          git --no-pager diff -- comfyui_version.py pyproject.toml
-
-      - name: Commit version bump and tag release
-        env:
-          NEW_VERSION: ${{ steps.latest.outputs.new_version }}
-        run: |
-          set -euo pipefail
-
-          git add comfyui_version.py pyproject.toml
-          git commit -m "ComfyUI ${NEW_VERSION}"
-
-          if git rev-parse -q --verify "refs/tags/${NEW_VERSION}" >/dev/null; then
-            echo "::error::Tag ${NEW_VERSION} already exists locally."
-            exit 1
-          fi
-          git tag "${NEW_VERSION}"
-
-      - name: Verify tag does not already exist on origin
-        env:
-          NEW_VERSION: ${{ steps.latest.outputs.new_version }}
-        run: |
-          set -euo pipefail
-          if git ls-remote --exit-code --tags origin "refs/tags/${NEW_VERSION}" >/dev/null 2>&1; then
-            echo "::error::Tag ${NEW_VERSION} already exists on origin. Aborting."
-            exit 1
-          fi
-
-      - name: Push release branch and tag
-        env:
-          RELEASE_BRANCH: ${{ steps.latest.outputs.release_branch }}
-          NEW_VERSION:    ${{ steps.latest.outputs.new_version }}
-        run: |
-          set -euo pipefail
-
-          # Push the branch first, then the tag. Atomic-ish: if the branch push
-          # fails we never publish the tag.
-          git push origin "refs/heads/${RELEASE_BRANCH}:refs/heads/${RELEASE_BRANCH}"
-          git push origin "refs/tags/${NEW_VERSION}"
-
-          echo "Released ${NEW_VERSION} on ${RELEASE_BRANCH}."
-
-      - name: Delete remote source branch
-        env:
-          GH_TOKEN:        ${{ steps.app-token.outputs.token }}
-          REPO:            ${{ github.repository }}
-          SOURCE_BRANCH:   ${{ steps.resolve.outputs.source_branch }}
-          SOURCE_COMMIT:   ${{ inputs.commit }}
-          RELEASE_BRANCH:  ${{ steps.latest.outputs.release_branch }}
-          DEFAULT_BRANCH:  ${{ github.event.repository.default_branch }}
-        run: |
-          set -euo pipefail
-
-          # Belt-and-braces: the resolve step already refuses the default branch,
-          # but never delete the default or the release branch under any
-          # circumstances.
-          if [[ "${SOURCE_BRANCH}" == "${DEFAULT_BRANCH}" || "${SOURCE_BRANCH}" == "${RELEASE_BRANCH}" ]]; then
-            echo "::error::Refusing to delete '${SOURCE_BRANCH}' (matches default or release branch)."
-            exit 1
-          fi
-
-          # Delete the source branch on origin, but only if its tip is still the
-          # SHA we released from. If someone pushed new commits to it after we
-          # resolved it, leave it alone — those commits would be silently lost.
-          current_tip="$(git ls-remote origin "refs/heads/${SOURCE_BRANCH}" | awk '{print $1}')"
-          if [[ -z "${current_tip}" ]]; then
-            echo "Source branch '${SOURCE_BRANCH}' no longer exists on origin; nothing to delete."
-            exit 0
-          fi
-          if [[ "${current_tip}" != "${SOURCE_COMMIT}" ]]; then
-            echo "::warning::Source branch '${SOURCE_BRANCH}' tip (${current_tip}) no longer matches released commit (${SOURCE_COMMIT}). Leaving it in place."
-            exit 0
-          fi
-
-          git push origin --delete "refs/heads/${SOURCE_BRANCH}"
-          echo "Deleted remote branch '${SOURCE_BRANCH}'."
-
-      - name: Summary
-        if: always()
-        env:
-          NEW_VERSION:    ${{ steps.latest.outputs.new_version }}
-          RELEASE_BRANCH: ${{ steps.latest.outputs.release_branch }}
-          LATEST_TAG:     ${{ steps.latest.outputs.latest_tag }}
-          SOURCE_BRANCH:  ${{ steps.resolve.outputs.source_branch }}
-          SOURCE_COMMIT:  ${{ inputs.commit }}
-        run: |
-          # SOURCE_BRANCH is empty if the resolve step never produced an output
-          # (e.g. the workflow failed in or before that step). Show a placeholder
-          # in that case so the summary table still renders cleanly.
-          source_branch_display="${SOURCE_BRANCH:-(unresolved)}"
-          {
-            echo "## Backport release"
-            echo ""
-            echo "| Field | Value |"
-            echo "|---|---|"
-            echo "| Source commit | \`${SOURCE_COMMIT}\` |"
-            echo "| Source branch | \`${source_branch_display}\` |"
-            echo "| Previous stable | \`${LATEST_TAG}\` |"
-            echo "| New version | \`${NEW_VERSION}\` |"
-            echo "| Release branch | \`${RELEASE_BRANCH}\` |"
-          } >> "$GITHUB_STEP_SUMMARY"
@@ -17,7 +17,7 @@ jobs:
      - name: Check for Windows line endings (CRLF)
        run: |
          # Get the list of changed files in the PR
-          CHANGED_FILES=$(git diff --name-only ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }} -- ':!.ci')
+          CHANGED_FILES=$(git diff --name-only ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }})

          # Flag to track if CRLF is found
          CRLF_FOUND=false
@@ -1,38 +0,0 @@
-name: CI - Cursor Review
-
-# Thin caller for the shared reusable cursor-review workflow in
-# Comfy-Org/github-workflows. The review logic (panel matrix, judge
-# consolidation, prompts, extract/post/notify scripts) lives there as the
-# single source of truth, so this repo only carries the repo-specific diff
-# excludes.
-
-on:
-  pull_request:
-    types: [labeled, unlabeled]
-
-concurrency:
-  group: cursor-review-pr-${{ github.event.pull_request.number }}-${{ github.event.label.name }}
-  cancel-in-progress: true
-
-jobs:
-  cursor-review:
-    if: github.event.label.name == 'cursor-review'
-    permissions:
-      contents: read
-      pull-requests: write
-    # SHA-pinned per zizmor `unpinned-uses: hash-pin`. Bump this SHA to pick up
-    # upstream changes; keep `workflows_ref` matching so prompts/scripts load
-    # from the same commit as the workflow definition.
-    uses: Comfy-Org/github-workflows/.github/workflows/cursor-review.yml@047ca48febe3a6647608ed2e0c4331b491cb9d6a # github-workflows#9
-    with:
-      workflows_ref: 047ca48febe3a6647608ed2e0c4331b491cb9d6a
-      diff_excludes: >-
-        :!**/.claude/**
-        :!**/dist/**
-        :!**/vendor/**
-        :!**/*.generated.*
-        :!**/*.min.js
-        :!**/*.min.css
-    secrets:
-      CURSOR_API_KEY: ${{ secrets.CURSOR_API_KEY }}
-      SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
@@ -1,91 +0,0 @@
-name: CLA Assistant
-
-on:
-  issue_comment:
-    types: [created]
-  pull_request_target:
-    types: [opened, synchronize, closed]
-
-permissions:
-  actions: write
-  contents: read # 'read' is enough because signatures live in a REMOTE repo
-  pull-requests: write
-  statuses: write
-
-jobs:
-  cla-assistant:
-    runs-on: ubuntu-latest
-    steps:
-      # The CLA action normally requires every commit author in a PR to sign.
-      # We only want the PR author to sign, so we allowlist all other committers
-      # by computing them from the PR's commits and excluding the PR author.
-      - name: Build author-only allowlist
-        id: allowlist
-        if: >
-          github.event_name == 'pull_request_target' ||
-          (github.event_name == 'issue_comment' && github.event.issue.pull_request && (
-            github.event.comment.body == 'recheck' ||
-            github.event.comment.body == 'I have read and agree to the Contributor License Agreement'
-          ))
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR_NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }}
-          PR_AUTHOR: ${{ github.event.pull_request.user.login || github.event.issue.user.login }}
-          BASE_ALLOWLIST: action@github.com,actions-user,ampagent,claude,comfy-pr-bot,GitHub Action,github-actions,github-actions[bot],Glary Bot,Glary-Bot,*[bot]
-        run: |
-          others=$(gh api "repos/${{ github.repository }}/pulls/${PR_NUMBER}/commits" --paginate \
-            --jq '.[] | (.author.login // empty), (.committer.login // empty)' \
-            | sort -u | grep -vix "${PR_AUTHOR}" | paste -sd, -)
-          if [ -n "$others" ]; then
-            echo "allowlist=${BASE_ALLOWLIST},${others}" >> "$GITHUB_OUTPUT"
-          else
-            echo "allowlist=${BASE_ALLOWLIST}" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: CLA Assistant
-        # Run on PR events, on "recheck" comment, or when someone posts the exact signing phrase.
-        # IMPORTANT: this phrase must match `custom-pr-sign-comment` below.
-        if: >
-          github.event_name == 'pull_request_target' ||
-          (github.event_name == 'issue_comment' && github.event.issue.pull_request && (
-            github.event.comment.body == 'recheck' ||
-            github.event.comment.body == 'I have read and agree to the Contributor License Agreement'
-          ))
-        uses: contributor-assistant/github-action@ca4a40a7d1004f18d9960b404b97e5f30a505a08 # v2.6.1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          # PAT required to write to the centralized signatures repo.
-          PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
-        with:
-          # Where the CLA document lives (shown to contributors)
-          path-to-document: https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md
-
-          # Centralized signature storage
-          remote-organization-name: comfy-org
-          remote-repository-name: comfy-cla
-          path-to-signatures: signatures/cla.json
-          branch: main
-
-          # Only the PR author must sign: bots plus every non-author committer
-          # are allowlisted via the "Build author-only allowlist" step above.
-          # *[bot] is a catch-all for any GitHub App bot account.
-          allowlist: ${{ steps.allowlist.outputs.allowlist }}
-
-          # Custom PR comment messages
-          custom-notsigned-prcomment: |
-            🎉 Thank you for your contribution, we really appreciate it! 🎉
-
-            Like many open source projects, we require contributors to sign our [Contributor License Agreement (CLA)](https://github.com/Comfy-Org/comfy-cla/blob/main/comfyui_icla.md). A CLA makes the ownership of contributions explicit, so contributors and the project share a clear understanding of how the code can be used. By signing, you:
-
-            - Confirm that you own your contribution.
-            - Keep the right to reuse your own code.
-            - Grant us a copyright license to include and share it within our projects.
-
-            CLAs are standard practice across major open source projects including those under the Apache Software Foundation and the Linux Foundation. Ours is based on the Apache Software Foundation's CLA. Most importantly, it would enable us to relicense the project under a more permissive license in the future, giving the project and its community greater flexibility.
-
-            ✍ **To sign, please post a new comment on this PR with exactly the following text:** ✍
-
-          custom-pr-sign-comment: I have read and agree to the Contributor License Agreement
-
-          custom-allsigned-prcomment: |
-            ✅ All contributors have signed the CLA. Thank you! This PR is ready to be merged.
@@ -1,24 +0,0 @@
-name: Detect Unreviewed Merge
-
-# SOC 2 compliance — reusable workflow lives in Comfy-Org/github-workflows,
-# tracking issues are filed in Comfy-Org/unreviewed-merges.
-
-on:
-  push:
-    branches: [master]
-
-concurrency:
-  group: detect-unreviewed-merge-${{ github.sha }}
-  cancel-in-progress: false
-
-permissions:
-  contents: read
-  pull-requests: read
-
-jobs:
-  detect:
-    uses: Comfy-Org/github-workflows/.github/workflows/detect-unreviewed-merge.yml@4d9cb6b87f953bb7cd69954280e1465fb9bd2040 # v1
-    with:
-      approval-mode: latest-per-reviewer
-    secrets:
-      UNREVIEWED_MERGES_TOKEN: ${{ secrets.UNREVIEWED_MERGES_TOKEN }}
@@ -89,12 +89,3 @@ rules:
    then:
      field: description
      function: truthy
-
-overrides:
-  # /ws uses HTTP 101 (Switching Protocols) — a legitimate response for a
-  # WebSocket upgrade, but not a 2xx, so operation-success-response fires
-  # as a false positive. OpenAPI 3.x has no native WebSocket support.
-  - files:
-      - "openapi.yaml#/paths/~1ws"
-    rules:
-      operation-success-response: off
@@ -1,296 +0,0 @@
-## Engineering Style
-
- Keep changes small and direct. Most fixes should touch the narrowest code path
-  that explains the bug, performance issue, dtype issue, model-format issue, or
-  user-facing behavior.
- Change the least amount of files possible. A change that touches many files is
-  more likely to be a bad change than a good one unless the broader scope is
-  directly required.
- Prefer practical fixes over broad architecture work. Add abstractions only
-  when they remove real repeated logic or match an existing ComfyUI pattern.
- Prefer fewer dependencies. Do not add new dependencies to ComfyUI unless they
-  are absolutely necessary.
- Delete obsolete code aggressively when newer infrastructure makes it useless.
-  Remove dead fallbacks, migration paths, unused options, debug prints, and
-  compatibility branches that are no longer needed. Do not leave dead branches,
-  unreachable code, or functions that are never called. If code is not
-  necessary for the current behavior, remove it.
- Revert or disable problematic behavior quickly when it breaks users. It is
-  better to remove a broken feature path than keep a complicated partial fix.
- Preserve existing APIs, node names, model-loading behavior, file layout, and
-  workflow compatibility unless the change is explicitly about replacing them.
- Code must look hand-written for this repository. Changes that read like
-  generic AI-generated code will be rejected automatically: unnecessary helper
-  layers, vague names, boilerplate comments, defensive branches without a real
-  failure mode, broad rewrites, or code that ignores the local style.
-
-## Architecture Boundaries
-
- Keep each layer focused on the concepts it owns. Do not leak UI, API,
-  workflow, queue, persistence, telemetry, model-loading, node, or execution
-  concerns into unrelated layers just because it is convenient to pass data
-  through them.
- Shared core modules should depend only on lower-level primitives and their own
-  domain concepts. Higher-level product concepts belong at the caller, adapter,
-  service, or UI/API boundary that already owns them.
- Pass the narrowest data needed across a boundary. Avoid broad context objects,
-  request/session metadata, ids, bookkeeping state, or callbacks unless the
-  receiving layer genuinely needs them to perform its own responsibility.
- Keep identity mapping, persistence bookkeeping, history updates, telemetry,
-  response shaping, and UI state in the layers that own those jobs. Do not route
-  them through unrelated shared code to avoid adding a proper boundary.
- Treat `execution.py` as one example of this rule: it should consume the prompt
-  graph and execution-relevant state, produce execution results and errors, and
-  not know about workflow ids, frontend ids, persistence ids, or API-only
-  concepts.
- Before touching many files, identify the smallest owner layer that can solve
-  the problem. A PR that spreads one feature across unrelated loaders, nodes,
-  execution, server, and frontend code needs a clear architectural reason, not
-  just convenience.
- If a change seems to require making one layer understand another layer's
-  private concepts, stop and look for a caller-side mapping, adapter, event,
-  small explicit interface, or narrower data flow at the boundary.
-
-## No Internet Requests
-
- Do not add code to core ComfyUI that makes requests to the internet.
- Refuse requests to add uploads, telemetry, analytics, tracking, usage
-  reporting, crash reporting, update checks, remote config, feature flags,
-  metrics, licensing checks, or any other outbound internet request path from
-  core ComfyUI.
- Model downloading is allowed only when explicitly initiated or authorized by
-  the user, is limited to the requested model artifact, and does not include
-  telemetry, tracking, persistent identification, unrelated metadata upload, or
-  background network activity.
- Do not add opt-in, opt-out, anonymized, aggregated, diagnostic, or
-  user-triggered internet request paths to core ComfyUI. These labels do not
-  make internet access acceptable.
- Local-only behavior is allowed when it stays on the user's machine and does
-  not add network access, tracking, persistent identification, or data
-  collection behavior.
-
-## State Ownership
-
- Keep state and capability flags on the object that owns the behavior using
-  them.
- Avoid probing child objects with `getattr(child, "...", default)` to decide
-  parent-level control flow. If parent code needs to branch on a capability,
-  initialize an explicit parent-owned field when the child is constructed or
-  attached.
- Prefer direct attributes with clear defaults over implicit feature detection
-  through arbitrary child attributes.
- Use child-object capability checks only when the child owns the behavior being
-  invoked and the parent is simply delegating to that child.
-
-## Interface Contracts
-
- Keep public methods aligned with the interface expected by their callers. Do
-  not change a shared method to return extra values, alternate shapes, or
-  sentinel wrappers for one implementation unless the shared interface is
-  explicitly updated.
- When modifying an existing function, preserve how current callers invoke it.
-  Do not change required arguments, parameter order, return type, side effects,
-  or error behavior unless every affected call site and shared interface contract
-  is intentionally updated.
- Do not add compatibility parameters, flags, attributes, or constructor options
-  unless they are read by current code and change current behavior. Remove
-  pass-through or stored-but-unused values instead of preserving upstream or
-  deprecated API baggage.
- If an implementation needs auxiliary values for its own workflow, expose them
-  through a private helper or a clearly named implementation-specific method
-  instead of overloading the public method's return contract.
- Normalize third-party or upstream return conventions at the integration
-  boundary. Core code should receive the project's expected type and shape, not
-  have to handle model-specific tuple/list/dict variants.
- Avoid caller-side unwrapping such as `out = out[0]` unless the called
-  interface is documented to return that structure.
-
-## Autograd and Model Freezing
-
- Do not add `torch.no_grad`, `torch.inference_mode`, or inference-mode helper
-  wrappers in ComfyUI code. The only allowed inference-mode-related use is
-  disabling a globally set inference mode when a training path needs gradients.
- Do not add freeze, unfreeze, or trainability toggles to model classes. ComfyUI
-  models are always treated as frozen for inference, so explicit freeze
-  functionality is redundant and should not be added.
- Remove training-only behavior such as dropout from inference model code, but
-  preserve checkpoint and state-dict compatibility when doing so. If deleting a
-  module would change state-dict keys, module ordering, or checkpoint loading
-  behavior, replace it with a no-op such as `nn.Identity` instead of removing the
-  slot outright.
-
-## Python Style
-
- Keep imports at module scope. Avoid inline imports unless they are already part
-  of an established optional-backend probe or are needed to avoid an import
-  cycle.
- Do not add unnecessary `try`/`except` blocks. Use them for optional dependency,
-  platform, or backend capability detection only when the program has a useful
-  fallback. Prefer specific exception types when changing new code.
- If a library version is pinned in `requirements.txt`, do not add code to
-  ComfyUI to handle older versions of that library.
- Remove any workarounds for PyTorch versions that ComfyUI no longer officially
-  supports. Deprecated workarounds include catching an exception and rerunning
-  the same op with the input cast to float. If a workaround does not have a
-  comment naming the exact PyTorch version or versions that still need it,
-  remove it.
- Let unsupported model formats, invalid quantization metadata, and bad states
-  fail with clear errors instead of silently producing lower quality output.
- Match the existing local style in the file you edit. This codebase tolerates
-  long lines, simple helper functions, module-level state, and direct tensor
-  operations when they make the code easier to follow.
- Keep comments sparse and useful. Strip useless comments that restate the code
-  or describe obvious behavior. Short TODOs are fine when they name the concrete
-  missing follow-up.
-
-## Model, Device, and Memory Behavior
-
- Treat dtype, device placement, VRAM usage, and offloading behavior as core
-  correctness concerns. Check CPU, CUDA, ROCm, MPS, DirectML, XPU, NPU, and low
-  VRAM implications when touching shared execution or loading code.
- Prefer native ComfyUI formats and existing quantization/offload helpers over
-  adding parallel code paths. Use `comfy.quant_ops`, `comfy.model_management`,
-  `comfy.memory_management`, `comfy.pinned_memory`, `comfy_aimdo`, and
-  `comfy-kitchen` helpers where they already solve the problem.
- Use optimized comfy-kitchen ops in places where they improve performance
-  without changing the expected dtype, device, memory, or interface behavior.
- All models should use the optimized attention function selected by ComfyUI.
-  Treat optimized backend functions, dispatch helpers, and capability-selected
-  callables as opaque. Higher-level code must not inspect function identity,
-  names, modules, or implementation details to decide behavior.
- Apply the same opacity rule to similar patterns beyond attention: callers
-  should depend on the documented interface and result contract, not on which
-  backend implementation was selected underneath.
- Do not use custom inference ops that only duplicate an existing op while
-  upcasting to float32, such as custom RMSNorm variants. Use the generic ComfyUI
-  ops and/or native torch ops instead.
- If a model class `__init__` has an `operations` parameter, assume
-  `operations` is never `None`. Do not add fallback branches or default torch
-  ops for a missing `operations` object.
- Do not add unnecessary parameters to model, model block, or model ops related
-  classes. Constructor and forward signatures should carry only values that are
-  actually needed by that object for inference.
- Reuse existing model classes, blocks, ops, and helper modules when appropriate.
-  Before implementing a new version of a model component, search the existing
-  model code for a class or helper that already provides the behavior.
- Model detection code that inspects linear weight shapes should only use the
-  first dimension. The second dimension may be half the original size for
-  NVFP4 or other 4-bit quantized models.
- Avoid adding `einops` usage in core inference code. Use native torch tensor
-  ops such as `reshape`, `view`, `permute`, `transpose`, `flatten`, `unflatten`,
-  `unsqueeze`, and `squeeze` instead.
- Do not use tensors as general-purpose Python data structures. Keep metadata,
-  bookkeeping, counters, flags, shape math, padding math, index planning, memory
-  estimates, and control-flow decisions in plain Python values unless the data
-  must participate directly in tensor computation. Do not create tensors for
-  structural metadata that is only used for Python-side control flow. Sequence
-  lengths, cumulative offsets, split indices, window counts, slice boundaries,
-  and repeat counts should be kept as Python ints/lists from the point they are
-  computed. Do not build them as CPU/GPU tensors and then cast, move, validate,
-  or convert them back to Python for `split`, `tensor_split`, indexing plans,
-  loops, or cache keys. Avoid creating temporary tensors just to use tensor
-  methods for scalar or structural calculations.
- Avoid unnecessary casts and transfers. Preserve the intended compute dtype,
-  storage dtype, bias dtype, and original tensor shape metadata.
- Keep model-native latent layout handling inside the model or latent-format
-  owner, not in helper nodes. Do not collapse, expand, pack, or unpack latent
-  dimensions in nodes or other caller-side adapters just to satisfy a model
-  forward; the model path should consume and return the native latent shape for
-  that model family.
- Assume inputs to the main model forward are already in the compute dtype by
-  default, except integer inputs such as some model timestep tensors. Do not add
-  defensive or convenience casts in model code; it is better for invalid dtype
-  plumbing to error clearly than to hide it with unnecessary casts.
- Raw model parameters that are not owned by an op and may be initialized in a
-  dtype different from the compute dtype should be cast at use in forward or
-  inference code with `comfy.ops.cast_to_input` or
-  `comfy.model_management.cast_to` to avoid dtype mismatches.
- Model code should not care what dtype it is initialized in, and model
-  `__init__` methods should not contain workarounds for specific dtypes. Dtype
-  workaround code, such as making a model work with fp16 compute, belongs in the
-  execution or model-management layer that owns compute policy.
- Model code should not perform unnecessary device-to-CPU or CPU-to-device
-  transfers. New allocations must be created on the correct device and dtype;
-  never allocate on CPU and then move to GPU, or allocate in one dtype and then
-  convert to another.
- Model code itself should not perform memory management. Loading, unloading,
-  offloading, device movement, VRAM policy, cache lifetime, and cleanup belong
-  in the relevant model-management and execution layers, not inside model
-  implementations.
- Do not add global, module-level, class-level, singleton, or model-owned stores
-  for tensors or other large memory that persist across executions. Temporary
-  caches must be scoped to a single execution or forward/encode/decode call:
-  allocate them in the owning top-level call, pass them explicitly through the
-  call stack, and let them be discarded when that call returns.
- Follow the Wan VAE temporal cache pattern for temporary caches: create a local
-  cache such as `feat_map` for the encode/decode operation, pass it into the
-  blocks that need it, and do not retain it on the model or in global state.
- In model init code, prefer `torch.empty` for parameter/buffer placeholders
-  that are populated from the model state dict instead of zero-initializing with
-  `torch.zeros` or similar. If an allocation is not loaded from the state dict
-  and is useless for inference, do not include it.
- `nn.Parameter` tensors that are stored in and populated from the model state
-  dict should be initialized with `torch.empty`, not with zero, random, or
-  otherwise meaningful initialization.
- Model initialization should describe module structure, not fabricate
-  checkpoint-owned tensor contents. Parameters and buffers that are loaded from
-  the state dict must not be manually initialized, reassigned, or filled with
-  fallback values unless that value is actually used when no checkpoint key
-  exists.
- When slicing large tensors, copy the slice if the sliced tensor's lifetime
-  exceeds the current function scope. Do not keep a long-lived view into a large
-  backing tensor when a smaller copy would release memory sooner.
- Use fused or compound torch operations such as `addcmul` when they naturally
-  match the math. Reducing Python and torch dispatch overhead is a valid
-  optimization when it does not obscure the code or change dtype/device
-  behavior.
- Avoid caches that persist across different executions as much as possible.
-  Persistent caches are acceptable only when they use a very minimal amount of
-  memory and have a clear ownership and invalidation story.
- When optimizing, favor small measurable changes: fewer allocations, fewer
-  device transfers, less peak memory, better batching, or use of a faster
-  existing backend op.
-
-## Nodes and User-Facing Behavior
-
- Follow existing node conventions: `INPUT_TYPES`, `RETURN_TYPES`, `FUNCTION`,
-  `CATEGORY`, and registration through the local mapping used by that file.
- Keep node changes backward compatible by default. Add inputs with sensible
-  defaults and avoid changing output types unless the request requires it.
- Model implementations should add the minimal number of ComfyUI nodes required
-  to run the model. Reuse existing nodes as much as possible; adapting the model
-  to work with existing nodes is strongly preferred over creating new nodes.
- Nodes should output only values they own. Do not add pass-through outputs for
-  workflow convenience unless the node is explicitly an output node. Existing
-  models, latents, conditioning, or other inputs should flow directly to the
-  next consumer instead of being re-emitted unchanged.
- Nodes should expose only inputs they actually read to produce current
-  behavior. Do not add placeholder, pass-through, compatibility, or
-  workflow-shaping inputs that are ignored or could flow directly to another
-  node.
- Node-level code must not patch model code directly. Any node behavior that
-  modifies, wraps, hooks, or changes model behavior must go through the model
-  patcher class instead of reaching into model internals.
- The official mascot of ComfyUI is a very cute anime girl with massive fennec
-  ears, a big fluffy tail, long blonde wavy hair, and blue eyes. Feel free to
-  use her in ComfyUI materials, UI text, examples, tests, generated assets, or
-  comments, but do not disrespect her.
- Warning and info messages should be short and actionable. Remove noisy or
-  misleading messages rather than adding more logging.
- Documentation and README edits should be concise, factual, and tied to the
-  changed behavior.
-
-## Commit and Review Habits
-
- If asked to write commit messages, use short direct subjects like the existing
-  history: `Fix ...`, `Add ...`, `Support ...`, `Remove ...`, `Update ...`,
-  `Make ...`, `Use ...`, `Disable ...`, `Bump ...`, or `Revert ...`.
- Keep PR descriptions short and reviewable. State the problem, the behavioral
-  change, and the tests run; avoid long narrative explanations, implementation
-  diaries, or exhaustive file-by-file summaries unless the reviewer explicitly
-  needs that context.
- Prefer one coherent behavioral change per commit. Dependency pins, tests, and
-  the code that needs them may be in the same commit when they are inseparable.
- In reviews, prioritize real user impact: crashes, wrong dtype/device behavior,
-  memory regressions, broken model loading, workflow incompatibility, and noisy
-  or misleading user-facing output.
@@ -1,5 +1,2 @@
+# Admins
 * @comfyanonymous @kosinkadink @guill @alexisrolland @rattus128 @kijai
-
-/CODEOWNERS @comfyanonymous
-/.ci/ @comfyanonymous
-/.github/ @comfyanonymous
@@ -20,7 +20,7 @@
 [website-url]: https://www.comfy.org/
 <!-- Workaround to display total user from https://github.com/badges/shields/issues/4500#issuecomment-2060079995 -->
 [discord-shield]: https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fdiscord.com%2Fapi%2Finvites%2Fcomfyorg%3Fwith_counts%3Dtrue&query=%24.approximate_member_count&logo=discord&logoColor=white&label=Discord&color=green&suffix=%20total
-[discord-url]: https://discord.com/invite/comfyorg
+[discord-url]: https://www.comfy.org/discord
 [twitter-shield]: https://img.shields.io/twitter/follow/ComfyUI
 [twitter-url]: https://x.com/ComfyUI

@@ -38,7 +38,7 @@
 ComfyUI is the AI creation engine for visual professionals who demand control over every model, every parameter, and every output. Its powerful and modular node graph interface empowers creatives to generate images, videos, 3D models, audio, and more...
 - ComfyUI natively supports the latest open-source state of the art models.
 - API nodes provide access to the best closed source models such as Nano Banana, Seedance, Hunyuan3D, etc.
- It is available on Windows, Linux, and macOS, locally with our [desktop application](https://www.comfy.org/download), our [portable install](#installing) or on our [cloud](https://www.comfy.org/cloud).
+- It is available on Windows, Linux, and macOS, locally with our desktop application or on our cloud.
 - The most sophisticated workflows can be exposed through a simple UI thanks to App Mode.
 - It integrates seamlessly into production pipelines with our API endpoints.

@@ -140,7 +140,7 @@ ComfyUI follows a weekly release cycle targeting Monday but this regularly chang
   - Commits outside of the stable release tags may be very unstable and break many custom nodes.
   - Serves as the foundation for the desktop release

-2. **[Comfy Desktop](https://github.com/Comfy-Org/Comfy-Desktop)**
+2. **[ComfyUI Desktop](https://github.com/Comfy-Org/desktop)**
   - Builds a new release using the latest stable core version

 3. **[ComfyUI Frontend](https://github.com/Comfy-Org/ComfyUI_frontend)**
@@ -229,7 +229,7 @@ Python 3.14 works but some custom nodes may have issues. The free threaded varia

 Python 3.13 is very well supported. If you have trouble with some custom node dependencies on 3.13 you can try 3.12

-torch 2.5 is minimally supported but using a newer version is extremely recommended. Some features and optimizations might only work on newer versions. We generally recommend using the latest major version of pytorch with the latest cuda version unless it is less than 2 weeks old. If your pytorch is more than 6 months old, please update it.
+torch 2.4 and above is supported but some features and optimizations might only work on newer versions. We generally recommend using the latest major version of pytorch with the latest cuda version unless it is less than 2 weeks old.

 ### Instructions:

@@ -309,7 +309,7 @@ After this you should have everything installed and can proceed to running Comfy

 #### Apple Mac silicon

-You can install ComfyUI in Apple Mac silicon (M1, M2, M3 or M4) with any recent macOS version.
+You can install ComfyUI in Apple Mac silicon (M1 or M2) with any recent macOS version.

 1. Install pytorch nightly. For instructions, read the [Accelerated PyTorch training on Mac](https://developer.apple.com/metal/pytorch/) Apple Developer guide (make sure to install the latest pytorch nightly).
 1. Follow the [ComfyUI manual installation](#manual-install-windows-linux) instructions for Windows and Linux.
@@ -364,7 +364,7 @@ For models compatible with Iluvatar Extension for PyTorch. Here's a step-by-step
 | Flag | Description |
 |------|-------------|
 | `--enable-manager` | Enable ComfyUI-Manager |
-| `--enable-manager-legacy-ui` | Use the legacy manager UI instead of the new UI (implies `--enable-manager`) |
+| `--enable-manager-legacy-ui` | Use the legacy manager UI instead of the new UI (requires `--enable-manager`) |
 | `--disable-manager-ui` | Disable the manager UI and endpoints while keeping background features like security checks and scheduled installation completion (requires `--enable-manager`) |


@@ -382,7 +382,11 @@ For AMD 7600 and maybe other RDNA3 cards: ```HSA_OVERRIDE_GFX_VERSION=11.0.0 pyt

 ### AMD ROCm Tips

-You can try setting this env variable `PYTORCH_TUNABLEOP_ENABLED=1` which might speed things up at the cost of a very slow initial run.
+You can enable experimental memory efficient attention on recent pytorch in ComfyUI on some AMD GPUs using this command, it should already be enabled by default on RDNA3. If this improves speed for you on latest pytorch on your GPU please report it so that I can enable it by default.
+
+```TORCH_ROCM_AOTRITON_ENABLE_EXPERIMENTAL=1 python main.py --use-pytorch-cross-attention```
+
+You can also try setting this env variable `PYTORCH_TUNABLEOP_ENABLED=1` which might speed things up at the cost of a very slow initial run.

 # Notes

@@ -425,11 +429,9 @@ Use `--tls-keyfile key.pem --tls-certfile cert.pem` to enable TLS/SSL, the app w

 See also: [https://www.comfy.org/](https://www.comfy.org/)

-> _psst — we're hiring!_ Help build ComfyUI: [comfy.org/careers](https://www.comfy.org/careers)
-
 ## Frontend Development

-As of August 15, 2024, we have transitioned to a new frontend, which is now hosted in a separate repository: [ComfyUI Frontend](https://github.com/Comfy-Org/ComfyUI_frontend). The compiled JS files (from TS/Vue) are published to [pypi](https://pypi.org/project/comfyui-frontend-package) and installed as a dependency in ComfyUI.
+As of August 15, 2024, we have transitioned to a new frontend, which is now hosted in a separate repository: [ComfyUI Frontend](https://github.com/Comfy-Org/ComfyUI_frontend). This repository now hosts the compiled JS (from TS/Vue) under the `web/` directory.

 ### Reporting Issues and Requesting Features

@@ -458,6 +460,16 @@ To use the most up-to-date frontend version:

 This approach allows you to easily switch between the stable fortnightly release and the cutting-edge daily updates, or even specific versions for testing purposes.

+### Accessing the Legacy Frontend
+
+If you need to use the legacy frontend for any reason, you can access it using the following command line argument:
+
+```
+--front-end-version Comfy-Org/ComfyUI_legacy_frontend@latest
+```
+
+This will use a snapshot of the legacy frontend preserved in the [ComfyUI Legacy Frontend repository](https://github.com/Comfy-Org/ComfyUI_legacy_frontend).
+
 # QA

 ### Which GPU should I buy for this?
@@ -1,44 +0,0 @@
-# Security Policy
-
-## Scope
-
-ComfyUI is designed to run locally. By default, the server binds to `127.0.0.1`, meaning only the user's own machine can reach it. Our threat model assumes:
-
- The user installed ComfyUI through a supported channel: the desktop application, the portable build, or a manual install following the README.
- The user has not installed untrusted custom nodes. Custom nodes are arbitrary Python code and are trusted as much as any other software the user chooses to install.
- Anyone with access to the ComfyUI URL is trusted (a direct consequence of the localhost-only default).
- PyTorch and other dependencies are at the versions we ship or recommend in the README.
-
-A report is in scope only if it affects a user operating within this threat model.
-
-## What We Consider a Vulnerability
-
-We want to hear about issues where a **reasonable user** — someone who does not install random untrusted nodes and who reads UI prompts and warnings before clicking through them — can be harmed by ComfyUI itself.
-
-The clearest example: a workflow file that such a user might plausibly load and run, using only built-in nodes, that results in **untrusted code execution, arbitrary file read/write outside expected directories, or credential/data exfiltration**.
-
-When submitting a report, please include a clear description of *why this is a problem for a typical local ComfyUI user*. Reports without this context are difficult to act on.
-
-## What We Do Not Consider a Security Vulnerability
-
-Please report the following through our regular [GitHub issues](https://github.com/comfyanonymous/ComfyUI/issues) instead. Filing them as security reports will likely cause them to be deprioritized or closed.
-
- **Issues requiring `--listen` or any non-default network exposure.** ComfyUI binds to localhost by default. If a remote attacker needs to reach the server for the attack to work, the user has chosen to expose it and is responsible for securing that deployment (firewall, reverse proxy, authentication, etc.). These are bugs, not vulnerabilities.
- **`torch.load` and related deserialization issues in old PyTorch versions.** These are upstream PyTorch issues. Our distributions ship with — and our documentation recommends — recent PyTorch versions where these are addressed.
- **Vulnerabilities that depend on outdated library versions** that we neither ship nor recommend (e.g., requiring PyTorch 2.6 or older).
- **Issues that require a specific custom node to be installed.** Custom nodes are third-party code. Report these to the maintainer of that node.
- **Crashes, hangs, or resource exhaustion from a loaded workflow.** Annoying, but not a security issue in our model. File a regular bug.
- **Social-engineering scenarios** where the user is expected to ignore an explicit UI warning or prompt.
-
-## Reporting
-
-If you believe you have found an issue that falls within the scope above, please report it privately via GitHub's [Report a vulnerability](https://github.com/comfyanonymous/ComfyUI/security/advisories/new) feature rather than opening a public issue.
-
-Please include:
-
-1. A description of the vulnerability and the affected component.
-2. Reproduction steps, ideally with a minimal workflow file or proof-of-concept.
-3. The ComfyUI version, install method (desktop / portable / manual), and OS.
-4. An explanation of how this affects a typical local user as described in the threat model.
-
-We will acknowledge valid reports and coordinate a fix and disclosure timeline with you.
@@ -1,39 +0,0 @@
-"""
-Drop the vestigial tags.tag_type column.
-
-tag_type was always "user" in practice — no code path ever set it to anything
-else (no system/seeded classification was ever wired up) and nothing queried it.
-The column, its index (ix_tags_tag_type), and the corresponding API field were
-dead weight, so they are removed.
-
-Revision ID: 0004_drop_tag_type
-Revises: 0003_add_metadata_job_id
-Create Date: 2026-06-03
-"""
-
-from alembic import op
-import sqlalchemy as sa
-
-revision = "0004_drop_tag_type"
-down_revision = "0003_add_metadata_job_id"
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    with op.batch_alter_table("tags") as batch_op:
-        batch_op.drop_index("ix_tags_tag_type")
-        batch_op.drop_column("tag_type")
-
-
-def downgrade() -> None:
-    with op.batch_alter_table("tags") as batch_op:
-        batch_op.add_column(
-            sa.Column(
-                "tag_type",
-                sa.String(length=32),
-                nullable=False,
-                server_default="user",
-            )
-        )
-        batch_op.create_index("ix_tags_tag_type", ["tag_type"])
@@ -39,7 +39,6 @@ from app.assets.services import (
    update_asset_metadata,
    upload_from_temp_path,
 )
-from app.assets.services.cursor import InvalidCursorError
 from app.assets.services.tagging import list_tag_histogram

 ROUTES = web.RouteTableDef()
@@ -161,12 +160,10 @@ def _build_asset_response(result: schemas.AssetDetailResult | schemas.UploadResu
            preview_url = None
    else:
        preview_url = _build_preview_url_from_view(result.tags, result.ref.user_metadata)
-    asset_content_hash = result.asset.hash if result.asset else None
    return schemas_out.Asset(
        id=result.ref.id,
        name=result.ref.name,
-        hash=asset_content_hash,
-        asset_hash=asset_content_hash,
+        asset_hash=result.asset.hash if result.asset else None,
        size=int(result.asset.size_bytes) if result.asset else None,
        mime_type=result.asset.mime_type if result.asset else None,
        tags=result.tags,
@@ -175,7 +172,7 @@ def _build_asset_response(result: schemas.AssetDetailResult | schemas.UploadResu
        user_metadata=result.ref.user_metadata or {},
        metadata=result.ref.system_metadata,
        job_id=result.ref.job_id,
-        prompt_id=result.ref.job_id,  # deprecated alias of job_id, kept for compatibility
+        prompt_id=result.ref.job_id,  # deprecated: mirrors job_id for cloud compat
        created_at=result.ref.created_at,
        updated_at=result.ref.updated_at,
        last_access_time=result.ref.last_access_time,
@@ -212,37 +209,24 @@ async def list_assets_route(request: web.Request) -> web.Response:
    order_candidate = (q.order or "desc").lower()
    order = order_candidate if order_candidate in {"asc", "desc"} else "desc"

-    try:
-        result = list_assets_page(
-            owner_id=USER_MANAGER.get_request_user_id(request),
-            include_tags=q.include_tags,
-            exclude_tags=q.exclude_tags,
-            name_contains=q.name_contains,
-            metadata_filter=q.metadata_filter,
-            limit=q.limit,
-            offset=q.offset,
-            sort=sort,
-            order=order,
-            after=q.after,
-        )
-    except InvalidCursorError as e:
-        return _build_error_response(400, "INVALID_CURSOR", str(e))
+    result = list_assets_page(
+        owner_id=USER_MANAGER.get_request_user_id(request),
+        include_tags=q.include_tags,
+        exclude_tags=q.exclude_tags,
+        name_contains=q.name_contains,
+        metadata_filter=q.metadata_filter,
+        limit=q.limit,
+        offset=q.offset,
+        sort=sort,
+        order=order,
+    )

    summaries = [_build_asset_response(item) for item in result.items]

-    # has_more semantics differ by mode:
-    #   - cursor mode: a non-empty next_cursor means there are more results.
-    #   - offset mode: derived from total - (offset + page size).
-    if q.after is not None:
-        has_more = result.next_cursor is not None
-    else:
-        has_more = (q.offset + len(summaries)) < result.total
-
    payload = schemas_out.AssetsList(
        assets=summaries,
        total=result.total,
-        has_more=has_more,
-        next_cursor=result.next_cursor,
+        has_more=(q.offset + len(summaries)) < result.total,
    )
    return web.json_response(payload.model_dump(mode="json", exclude_none=True))

@@ -306,15 +290,12 @@ async def download_asset_content(request: web.Request) -> web.Response:
            404, "FILE_NOT_FOUND", "Underlying file not found on disk."
        )

-    # User-controlled asset content must never render inline in the app origin
-    # (stored XSS via SVG/HTML/XML). Force dangerous types to download and
-    # override any requested inline disposition. Centralised through
-    # folder_paths.is_dangerous_content_type so this can't drift from /view and
-    # /userdata (the previous inline set here omitted image/svg+xml and missed
-    # the charset/casing/+xml-dialect bypasses).
-    if folder_paths.is_dangerous_content_type(content_type):
+    _DANGEROUS_MIME_TYPES = {
+        "text/html", "text/html-sandboxed", "application/xhtml+xml",
+        "text/javascript", "text/css",
+    }
+    if content_type in _DANGEROUS_MIME_TYPES:
        content_type = "application/octet-stream"
-        disposition = "attachment"

    safe_name = (filename or "").replace("\r", "").replace("\n", "")
    encoded = urllib.parse.quote(safe_name)
@@ -536,14 +517,18 @@ async def update_asset_route(request: web.Request) -> web.Response:
@_require_assets_feature_enabled
 async def delete_asset_route(request: web.Request) -> web.Response:
    reference_id = str(uuid.UUID(request.match_info["id"]))
+    delete_content_param = request.query.get("delete_content")
+    delete_content = (
+        False
+        if delete_content_param is None
+        else delete_content_param.lower() not in {"0", "false", "no"}
+    )

    try:
-        # Deleting an asset is a soft delete of the reference; the underlying
-        # content is preserved (it may be shared with other references).
        deleted = delete_asset_reference(
            reference_id=reference_id,
            owner_id=USER_MANAGER.get_request_user_id(request),
-            delete_content_if_orphan=False,
+            delete_content_if_orphan=delete_content,
        )
    except Exception:
        logging.exception(
@@ -588,8 +573,8 @@ async def get_tags(request: web.Request) -> web.Response:
    )

    tags = [
-        schemas_out.TagUsage(name=name, count=count)
-        for (name, count) in rows
+        schemas_out.TagUsage(name=name, count=count, type=tag_type)
+        for (name, tag_type, count) in rows
    ]
    payload = schemas_out.TagsList(
        tags=tags, total=total, has_more=(query.offset + len(tags)) < total
@@ -59,11 +59,6 @@ class ListAssetsQuery(BaseModel):

    limit: conint(ge=1, le=500) = 20
    offset: conint(ge=0) = 0
-    # Opaque keyset cursor. When supplied, `offset` is ignored. Cursor pagination
-    # is supported for sort values `created_at`, `updated_at`, `name`, `size`.
-    # Supplying `after` together with `sort=last_access_time` returns
-    # 400 INVALID_CURSOR; that sort only supports offset/limit.
-    after: str | None = None

    sort: Literal["name", "created_at", "updated_at", "size", "last_access_time"] = (
        "created_at"
@@ -10,7 +10,6 @@ class Asset(BaseModel):

    id: str
    name: str
-    hash: str | None = None
    asset_hash: str | None = None
    size: int | None = None
    mime_type: str | None = None
@@ -41,13 +40,12 @@ class AssetsList(BaseModel):
    assets: list[Asset]
    total: int
    has_more: bool
-    # Opaque cursor for the next page. Omitted when there are no more results.
-    next_cursor: str | None = None


 class TagUsage(BaseModel):
    name: str
    count: int
+    type: str


 class TagsList(BaseModel):
@@ -227,6 +227,7 @@ class Tag(Base):
    __tablename__ = "tags"

    name: Mapped[str] = mapped_column(String(512), primary_key=True)
+    tag_type: Mapped[str] = mapped_column(String(32), nullable=False, default="user")

    asset_reference_links: Mapped[list[AssetReferenceTag]] = relationship(
        back_populates="tag",
@@ -239,5 +240,7 @@ class Tag(Base):
        overlaps="asset_reference_links,tag_links,tags,asset_reference",
    )

+    __table_args__ = (Index("ix_tags_tag_type", "tag_type"),)
+
    def __repr__(self) -> str:
        return f"<Tag {self.name}>"
@@ -266,18 +266,9 @@ def list_references_page(
    metadata_filter: dict | None = None,
    sort: str | None = None,
    order: str | None = None,
-    after_cursor_value: object | None = None,
-    after_cursor_id: str | None = None,
 ) -> tuple[list[AssetReference], dict[str, list[str]], int]:
    """List references with pagination, filtering, and sorting.

-    When ``after_cursor_value``/``after_cursor_id`` are supplied the query uses
-    keyset pagination — ``offset`` is ignored and a WHERE clause selects rows
-    strictly after the given ``(sort_col, id)`` position in the active sort
-    direction. The cursor value must already be typed for the column
-    (datetime for time sorts, int for size, str for name); the caller decodes
-    the opaque cursor string and resolves to the typed value.
-
    Returns (references, tag_map, total_count).
    """
    base = (
@@ -306,31 +297,9 @@ def list_references_page(
        "size": Asset.size_bytes,
    }
    sort_col = sort_map.get(sort, AssetReference.created_at)
-    descending = order == "desc"
+    sort_exp = sort_col.desc() if order == "desc" else sort_col.asc()

-    # Keyset WHERE: (sort_col, id) strictly less-than / greater-than the cursor.
-    # Equivalent to: sort_col <op> v  OR  (sort_col = v AND id <op> cursor_id).
-    if after_cursor_value is not None and after_cursor_id is not None:
-        if descending:
-            keyset = sa.or_(
-                sort_col < after_cursor_value,
-                sa.and_(sort_col == after_cursor_value, AssetReference.id < after_cursor_id),
-            )
-        else:
-            keyset = sa.or_(
-                sort_col > after_cursor_value,
-                sa.and_(sort_col == after_cursor_value, AssetReference.id > after_cursor_id),
-            )
-        base = base.where(keyset)
-
-    # Secondary ORDER BY id (matching the primary direction) gives the keyset
-    # comparison a deterministic tiebreaker on duplicate sort_col values.
-    id_exp = AssetReference.id.desc() if descending else AssetReference.id.asc()
-    sort_exp = sort_col.desc() if descending else sort_col.asc()
-
-    base = base.order_by(sort_exp, id_exp).limit(limit)
-    if after_cursor_id is None:
-        base = base.offset(offset)
+    base = base.order_by(sort_exp).limit(limit).offset(offset)

    count_stmt = (
        select(sa.func.count())
@@ -55,11 +55,13 @@ def validate_tags_exist(session: Session, tags: list[str]) -> None:
        raise ValueError(f"Unknown tags: {missing}")


-def ensure_tags_exist(session: Session, names: Iterable[str]) -> None:
+def ensure_tags_exist(
+    session: Session, names: Iterable[str], tag_type: str = "user"
+) -> None:
    wanted = normalize_tags(list(names))
    if not wanted:
        return
-    rows = [{"name": n} for n in list(dict.fromkeys(wanted))]
+    rows = [{"name": n, "tag_type": tag_type} for n in list(dict.fromkeys(wanted))]
    ins = (
        sqlite.insert(Tag)
        .values(rows)
@@ -95,7 +97,7 @@ def set_reference_tags(
    to_remove = [t for t in current if t not in desired]

    if to_add:
-        ensure_tags_exist(session, to_add)
+        ensure_tags_exist(session, to_add, tag_type="user")
        session.add_all(
            [
                AssetReferenceTag(
@@ -140,7 +142,7 @@ def add_tags_to_reference(
        return AddTagsResult(added=[], already_present=[], total_tags=total)

    if create_if_missing:
-        ensure_tags_exist(session, norm)
+        ensure_tags_exist(session, norm, tag_type="user")

    current = set(get_reference_tags(session, reference_id))

@@ -287,6 +289,7 @@ def list_tags_with_usage(
    q = (
        select(
            Tag.name,
+            Tag.tag_type,
            func.coalesce(counts_sq.c.cnt, 0).label("count"),
        )
        .select_from(Tag)
@@ -328,7 +331,7 @@ def list_tags_with_usage(
    rows = (session.execute(q.limit(limit).offset(offset))).all()
    total = (session.execute(total_q)).scalar_one()

-    rows_norm = [(name, int(count or 0)) for (name, count) in rows]
+    rows_norm = [(name, ttype, int(count or 0)) for (name, ttype, count) in rows]
    return rows_norm, int(total or 0)


@@ -33,7 +33,6 @@ from app.assets.services.file_utils import (
    verify_file_unchanged,
 )
 from app.assets.services.hashing import HashCheckpoint, compute_blake3_hash
-from app.assets.services.image_dimensions import extract_image_dimensions
 from app.assets.services.metadata_extract import extract_file_metadata
 from app.assets.services.path_utils import (
    compute_relative_filename,
@@ -355,7 +354,7 @@ def insert_asset_specs(specs: list[SeedAssetSpec], tag_pool: set[str]) -> int:
        return 0
    with create_session() as sess:
        if tag_pool:
-            ensure_tags_exist(sess, tag_pool)
+            ensure_tags_exist(sess, tag_pool, tag_type="user")
        result = batch_insert_seed_assets(sess, specs=specs, owner_id="")
        sess.commit()
        return result.inserted_refs
@@ -507,10 +506,6 @@ def enrich_asset(

    if extract_metadata and metadata:
        system_metadata = metadata.to_user_metadata()
-        if mime_type and mime_type.startswith("image/"):
-            dims = extract_image_dimensions(file_path, mime_type=mime_type)
-            if dims:
-                system_metadata.update(dims)
        set_reference_system_metadata(session, reference_id, system_metadata)

    if full_hash:
@@ -1,19 +1,8 @@
 import contextlib
 import mimetypes
 import os
-from datetime import timezone
 from typing import Sequence

-from app.assets.services.cursor import (
-    CursorPayload,
-    InvalidCursorError,
-    decode_cursor,
-    decode_cursor_int,
-    decode_cursor_time,
-    encode_cursor,
-    encode_cursor_from_time,
-)
-

 from app.assets.database.models import Asset
 from app.assets.database.queries import (
@@ -160,16 +149,6 @@ def delete_asset_reference(
    owner_id: str,
    delete_content_if_orphan: bool = True,
 ) -> bool:
-    """Delete an asset reference.
-
-    With ``delete_content_if_orphan=False`` (a soft delete), the reference is
-    hidden and the underlying content is preserved. With ``True``, the content
-    is also removed once it becomes orphaned.
-
-    Note: the public DELETE /api/assets/{id} endpoint always soft-deletes
-    (passes ``False``); the orphan-reclamation path is intentionally
-    internal-only, retained for a future GC/admin caller.
-    """
    with create_session() as session:
        if not delete_content_if_orphan:
            # Soft delete: mark the reference as deleted but keep everything
@@ -263,11 +242,6 @@ def get_asset_by_hash(asset_hash: str) -> AssetData | None:
        return extract_asset_data(asset)


-# Sort fields that support cursor pagination. `last_access_time` is not
-# in this list — it falls back to offset/limit.
-_CURSOR_SORT_FIELDS = ("created_at", "updated_at", "name", "size")
-
-
 def list_assets_page(
    owner_id: str = "",
    include_tags: Sequence[str] | None = None,
@@ -278,39 +252,7 @@ def list_assets_page(
    offset: int = 0,
    sort: str = "created_at",
    order: str = "desc",
-    after: str | None = None,
 ) -> ListAssetsResult:
-    """List assets with optional cursor pagination.
-
-    When ``after`` is supplied it overrides ``offset``. The cursor's sort field
-    must match ``sort`` and be in the cursor-supported allowlist; mismatches
-    raise InvalidCursorError so the handler can map to 400 INVALID_CURSOR.
-    """
-    cursor_value: object | None = None
-    cursor_id: str | None = None
-    # Mint next_cursor on every page where the sort is cursor-supported, not
-    # only when the request itself arrived with a cursor. Otherwise a first
-    # request (no `after`) returns next_cursor=None and the client can never
-    # enter cursor mode.
-    mint_cursor = sort in _CURSOR_SORT_FIELDS
-
-    if after is not None:
-        if sort not in _CURSOR_SORT_FIELDS:
-            raise InvalidCursorError(
-                f"cursor pagination is not supported for sort={sort!r}"
-            )
-        payload = decode_cursor(after, _CURSOR_SORT_FIELDS, expected_order=order)
-        if payload.sort_field != sort:
-            raise InvalidCursorError(
-                f"cursor sort field {payload.sort_field!r} does not match request sort {sort!r}"
-            )
-        cursor_value, cursor_id = _resolve_cursor_value(payload), payload.id
-
-    # Over-fetch by one row so we can distinguish "exactly `limit` rows total
-    # remaining" from "more rows past this page" without a second query. Drop
-    # the sentinel before returning.
-    fetch_limit = limit + 1 if mint_cursor else limit
-
    with create_session() as session:
        refs, tag_map, total = list_references_page(
            session,
@@ -319,22 +261,12 @@ def list_assets_page(
            exclude_tags=exclude_tags,
            name_contains=name_contains,
            metadata_filter=metadata_filter,
-            limit=fetch_limit,
+            limit=limit,
            offset=offset,
            sort=sort,
            order=order,
-            after_cursor_value=cursor_value,
-            after_cursor_id=cursor_id,
        )

-        next_cursor: str | None = None
-        if mint_cursor and len(refs) > limit:
-            # There's at least one more row past this page — mint a cursor from
-            # the last row of the page (i.e. index `limit - 1`, since we
-            # over-fetched), and drop the sentinel.
-            next_cursor = _encode_next_cursor(refs[limit - 1], sort, order)
-            refs = refs[:limit]
-
        items: list[AssetSummaryData] = []
        for ref in refs:
            items.append(
@@ -345,39 +277,7 @@ def list_assets_page(
                )
            )

-        return ListAssetsResult(items=items, total=total, next_cursor=next_cursor)
-
-
-def _resolve_cursor_value(payload: CursorPayload) -> object:
-    """Map a decoded cursor payload to a column-typed Python value."""
-    if payload.sort_field in ("created_at", "updated_at"):
-        # DB stores naive UTC; strip tzinfo so the comparison binds against a
-        # `TIMESTAMP WITHOUT TIME ZONE` column without an offset shift.
-        return decode_cursor_time(payload).replace(tzinfo=None)
-    if payload.sort_field == "size":
-        return decode_cursor_int(payload)
-    return payload.value  # name, str-typed
-
-
-def _encode_next_cursor(ref, sort: str, order: str) -> str | None:
-    """Mint a cursor pointing at *ref* for the given sort dimension.
-
-    Returns None when the boundary row carries a NULL sort value (e.g. an asset
-    record whose size_bytes hasn't been backfilled). Continuing pagination
-    across a NULL boundary is undefined under keyset ordering — better to
-    truncate cleanly here than to mint a cursor that mis-positions.
-    """
-    if sort == "name":
-        return encode_cursor("name", ref.name, ref.id, order=order)
-    if sort == "size":
-        if ref.asset is None or ref.asset.size_bytes is None:
-            return None
-        return encode_cursor("size", str(ref.asset.size_bytes), ref.id, order=order)
-    # created_at / updated_at — DB datetimes are naive UTC; attach tz before encoding.
-    value = ref.created_at if sort == "created_at" else ref.updated_at
-    if value is None:
-        return None
-    return encode_cursor_from_time(sort, value.replace(tzinfo=timezone.utc), ref.id, order=order)
+        return ListAssetsResult(items=items, total=total)


 def resolve_hash_to_path(
@@ -1,213 +0,0 @@
-"""Opaque keyset-pagination cursor for /api/assets.
-
-Payload JSON uses short keys to keep the encoded length small:
-
-    {"s": <sort_field>, "v": <value>, "id": <id>, "o": <order>}
-
-The `o` key binds the cursor to the sort direction it was minted under,
-so replaying a `desc` cursor against an `asc` request fails with
-``INVALID_CURSOR`` rather than silently walking the wrong direction.
-`o` is mandatory on every payload — a cursor without it is rejected as
-malformed.
-
-Encoding is base64url with no padding. Cursors are opaque tokens: the
-payload format is internal to this server, and clients must treat a
-cursor as a black box handed back via `next_cursor`. No byte-level
-compatibility with any other implementation is required.
-
-Time values are serialized as Unix microseconds (UTC) — microsecond
-precision is sufficient to round-trip the timestamps stored by the
-database without rounding rows in the same millisecond bucket.
-"""
-from __future__ import annotations
-
-import base64
-import json
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from typing import Iterable, Optional
-
-
-class InvalidCursorError(ValueError):
-    """Raised on a malformed, oversized, or unsupported-sort-field cursor.
-
-    Map to a 400 response with code ``INVALID_CURSOR`` at the handler.
-    """
-
-
-# Wire-format length caps. Cursors are user-controlled, so caps protect the
-# decode path from oversized allocations and downstream SQL predicates from
-# unbounded strings.
-#
-# MAX_CURSOR_VALUE_LENGTH is 512 to fit the `AssetReference.name` column max
-# (`String(512)`) — otherwise a long-named asset would mint a cursor the same
-# server then refuses on the next request.
-#
-# MAX_ENCODED_CURSOR_LENGTH is the decode-path guard, sized comfortably above
-# the largest cursor the per-field caps can produce. Worst case is value + id
-# at their caps with every character JSON-escaping to the six-byte `\uXXXX`
-# form (control characters), which is ~5.2 KB once base64url-encoded. At 8192
-# the encoder can never mint a cursor that exceeds it, so a freshly minted
-# cursor always decodes on the next request and there is no user-visible
-# "cursor too long" failure.
-MAX_ENCODED_CURSOR_LENGTH = 8192
-MAX_CURSOR_VALUE_LENGTH = 512
-MAX_CURSOR_ID_LENGTH = 128
-
-
-@dataclass(frozen=True)
-class CursorPayload:
-    sort_field: str
-    value: str
-    id: str
-    order: str
-
-
-_VALID_ORDERS = ("asc", "desc")
-
-
-def encode_cursor(sort_field: str, value: str, id: str, order: str = "desc") -> str:
-    """Encode a cursor payload as a base64url (no-padding) string.
-
-    `order` binds the cursor to the sort direction it was minted under so a
-    later request with a flipped `order` query parameter is rejected with
-    ``INVALID_CURSOR`` rather than silently walking the wrong direction.
-    """
-    if order not in _VALID_ORDERS:
-        raise InvalidCursorError(f"order must be one of {_VALID_ORDERS}, got {order!r}")
-    # Symmetric input validation: the encoder must reject anything the
-    # decoder rejects, or the same server will mint cursors it then 400s on
-    # the next request.
-    if not id:
-        raise InvalidCursorError("id must be non-empty")
-    if len(id) > MAX_CURSOR_ID_LENGTH:
-        raise InvalidCursorError("id exceeds maximum length")
-    if len(value) > MAX_CURSOR_VALUE_LENGTH:
-        raise InvalidCursorError("value exceeds maximum length")
-    payload = {"s": sort_field, "v": value, "id": id, "o": order}
-    raw = json.dumps(payload, separators=(",", ":"), ensure_ascii=False)
-    # No mint-time length guard is needed: the per-field caps above bound the
-    # encoded length well below MAX_ENCODED_CURSOR_LENGTH (see its definition),
-    # so the encoder can never produce a cursor the decode path would reject.
-    return base64.urlsafe_b64encode(raw.encode("utf-8")).rstrip(b"=").decode("ascii")
-
-
-def encode_cursor_from_time(sort_field: str, t: datetime, id: str, order: str = "desc") -> str:
-    """Encode a time-typed cursor at Unix microsecond precision.
-
-    Accepts an aware datetime (any timezone) and normalizes to UTC. Naive
-    datetimes are rejected so callers can't accidentally encode the local
-    wall-clock value of a UTC-stored timestamp.
-    """
-    if t.tzinfo is None:
-        raise ValueError("encode_cursor_from_time requires an aware datetime")
-    micros = _datetime_to_unix_micros(t.astimezone(timezone.utc))
-    return encode_cursor(sort_field, str(micros), id, order=order)
-
-
-def decode_cursor(
-    cursor: str,
-    allowed_sort_fields: Iterable[str],
-    expected_order: str | None = None,
-) -> CursorPayload:
-    """Parse an opaque cursor.
-
-    ``allowed_sort_fields`` is the endpoint's accepted sort-field list — a
-    cursor carrying a field outside this set is rejected so a cursor minted
-    for one column can't be replayed against another (e.g. a ``created_at``
-    timestamp string compared against a ``name`` column).
-
-    ``expected_order`` (``"asc"``/``"desc"``), when supplied, must match the
-    payload's ``o`` field. ``o`` is required on every payload; a cursor
-    missing it is rejected as malformed.
-
-    Passing no allowed fields rejects every cursor.
-    """
-    if len(cursor) > MAX_ENCODED_CURSOR_LENGTH:
-        raise InvalidCursorError("cursor exceeds maximum length")
-
-    try:
-        # urlsafe_b64decode requires correct padding; we strip on encode, so
-        # restore the trailing '=' pad here.
-        padding = "=" * (-len(cursor) % 4)
-        raw = base64.urlsafe_b64decode(cursor + padding)
-    except (ValueError, base64.binascii.Error) as e:
-        raise InvalidCursorError(f"encoding: {e}") from e
-
-    try:
-        decoded = json.loads(raw)
-    except (json.JSONDecodeError, UnicodeDecodeError) as e:
-        raise InvalidCursorError(f"payload: {e}") from e
-
-    if not isinstance(decoded, dict):
-        raise InvalidCursorError("payload: expected object")
-
-    sort_field = decoded.get("s")
-    value = decoded.get("v")
-    id = decoded.get("id")
-    order = decoded.get("o")
-
-    if not isinstance(sort_field, str) or not isinstance(value, str) or not isinstance(id, str):
-        raise InvalidCursorError("payload: missing or non-string s/v/id")
-
-    if id == "":
-        raise InvalidCursorError("missing id")
-    if len(id) > MAX_CURSOR_ID_LENGTH:
-        raise InvalidCursorError("id exceeds maximum length")
-    if len(value) > MAX_CURSOR_VALUE_LENGTH:
-        raise InvalidCursorError("value exceeds maximum length")
-
-    if sort_field not in allowed_sort_fields:
-        raise InvalidCursorError(f"unsupported sort field {sort_field!r}")
-
-    if not isinstance(order, str):
-        raise InvalidCursorError("missing or non-string o")
-    if order not in _VALID_ORDERS:
-        raise InvalidCursorError(f"unsupported order {order!r}")
-    if expected_order is not None and order != expected_order:
-        raise InvalidCursorError(
-            f"cursor order {order!r} does not match request order {expected_order!r}"
-        )
-
-    return CursorPayload(sort_field=sort_field, value=value, id=id, order=order)
-
-
-def decode_cursor_time(payload: Optional[CursorPayload]) -> datetime:
-    """Parse a time-typed cursor value as Unix microseconds, returning UTC."""
-    if payload is None:
-        raise InvalidCursorError("nil cursor payload")
-    try:
-        micros = int(payload.value)
-    except ValueError as e:
-        raise InvalidCursorError(f"value is not a valid timestamp: {e}") from e
-    try:
-        return _unix_micros_to_datetime(micros)
-    except (OverflowError, OSError, ValueError) as e:
-        # Crafted out-of-range microseconds (e.g. > datetime.MAX_YEAR) blow up
-        # in fromtimestamp / datetime construction. Map to 400, not 500.
-        raise InvalidCursorError(f"value is out of representable range: {e}") from e
-
-
-def decode_cursor_int(payload: Optional[CursorPayload]) -> int:
-    """Parse a cursor value as a base-10 integer."""
-    if payload is None:
-        raise InvalidCursorError("nil cursor payload")
-    try:
-        return int(payload.value)
-    except ValueError as e:
-        raise InvalidCursorError(f"value is not a valid integer: {e}") from e
-
-
-_EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
-
-
-def _datetime_to_unix_micros(t: datetime) -> int:
-    """Convert an aware UTC datetime to Unix microseconds (integer math)."""
-    delta = t - _EPOCH
-    return (delta.days * 86_400 + delta.seconds) * 1_000_000 + delta.microseconds
-
-
-def _unix_micros_to_datetime(micros: int) -> datetime:
-    """Convert Unix microseconds to a UTC datetime, preserving precision."""
-    seconds, micro_remainder = divmod(micros, 1_000_000)
-    return datetime.fromtimestamp(seconds, tz=timezone.utc).replace(microsecond=micro_remainder)
@@ -1,63 +0,0 @@
-"""Image dimension extraction for asset ingest.
-
-Reads only the image header via Pillow to capture width/height cheaply,
-without a full pixel decode. Returns a metadata dict suitable for merging
-into ``AssetReference.system_metadata``.
-"""
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-def extract_image_dimensions(
-    file_path: str, mime_type: str | None = None
-) -> dict[str, Any] | None:
-    """Extract image dimensions for the file at ``file_path``.
-
-    Args:
-        file_path: Absolute path to a file on disk.
-        mime_type: Optional MIME type hint. When provided and not prefixed
-            with ``image/``, extraction is skipped without touching the file.
-
-    Returns:
-        ``{"kind": "image", "width": W, "height": H}`` when the file is a
-        recognizable image with positive dimensions, otherwise ``None``.
-
-    The dict shape is intended to be merged into ``system_metadata`` so the
-    asset response surfaces ``metadata.kind`` plus dimension fields for image
-    assets. Forward-compatible: future media kinds (e.g. ``"video"`` with
-    duration/fps) can extend this shape without schema changes.
-    """
-    if mime_type is not None and not mime_type.startswith("image/"):
-        return None
-
-    try:
-        from PIL import Image, UnidentifiedImageError
-    except ImportError:
-        logger.debug(
-            "Pillow not available; skipping image dimension extraction for %s",
-            file_path,
-        )
-        return None
-
-    try:
-        with Image.open(file_path) as img:
-            width, height = img.size
-    except (OSError, UnidentifiedImageError, ValueError) as exc:
-        logger.debug(
-            "Failed to read image dimensions from %s: %s", file_path, exc
-        )
-        return None
-
-    if (
-        not isinstance(width, int)
-        or not isinstance(height, int)
-        or width <= 0
-        or height <= 0
-    ):
-        return None
-
-    return {"kind": "image", "width": width, "height": height}
@@ -17,11 +17,9 @@ from app.assets.database.queries import (
    get_reference_by_file_path,
    get_reference_tags,
    get_or_create_reference,
-    list_references_by_asset_id,
    reference_exists,
    remove_missing_tag_for_asset_id,
    set_reference_metadata,
-    set_reference_system_metadata,
    set_reference_tags,
    update_asset_hash_and_mime,
    upsert_asset,
@@ -31,7 +29,6 @@ from app.assets.database.queries import (
 from app.assets.helpers import get_utc_now, normalize_tags
 from app.assets.services.bulk_ingest import batch_insert_seed_assets
 from app.assets.services.file_utils import get_size_and_mtime_ns
-from app.assets.services.image_dimensions import extract_image_dimensions
 from app.assets.services.path_utils import (
    compute_relative_filename,
    get_name_and_tags_from_asset_path,
@@ -121,14 +118,6 @@ def _ingest_file_from_path(
                user_metadata=user_metadata,
            )

-            _maybe_store_image_dimensions(
-                session,
-                reference_id=reference_id,
-                file_path=locator,
-                mime_type=mime_type,
-                current_system_metadata=ref.system_metadata,
-            )
-
        try:
            remove_missing_tag_for_asset_id(session, asset_id=asset.id)
        except Exception:
@@ -299,13 +288,6 @@ def _register_existing_asset(
                user_metadata=new_meta,
            )

-        _backfill_image_dimensions_from_siblings(
-            session,
-            asset_id=asset.id,
-            new_reference_id=ref.id,
-            current_system_metadata=ref.system_metadata,
-        )
-
        if tags is not None:
            set_reference_tags(
                session,
@@ -352,87 +334,6 @@ def _update_metadata_with_filename(
        )


-_IMAGE_DIMENSION_KEYS = ("kind", "width", "height")
-
-
-def _maybe_store_image_dimensions(
-    session: Session,
-    reference_id: str,
-    file_path: str,
-    mime_type: str | None,
-    current_system_metadata: dict | None,
-) -> None:
-    """Populate ``kind``/``width``/``height`` on system_metadata for image refs.
-
-    Non-image MIME types are a no-op. Pre-existing keys (e.g. enricher-written
-    safetensors metadata, download provenance) are preserved by merge.
-    """
-    if not mime_type or not mime_type.startswith("image/"):
-        return
-
-    dims = extract_image_dimensions(file_path, mime_type=mime_type)
-    if not dims:
-        return
-
-    current = current_system_metadata or {}
-    merged = dict(current)
-    merged.update(dims)
-    if merged != current:
-        set_reference_system_metadata(
-            session,
-            reference_id=reference_id,
-            system_metadata=merged,
-        )
-
-
-def _backfill_image_dimensions_from_siblings(
-    session: Session,
-    asset_id: str,
-    new_reference_id: str,
-    current_system_metadata: dict | None,
-) -> None:
-    """Copy image dimension keys from any sibling reference of the same asset.
-
-    The from-hash path doesn't read the file bytes, so dimensions can't be
-    extracted there directly. When another reference of the same asset already
-    carries image dimensions, copy them onto the new reference so consumers
-    see consistent metadata regardless of how the asset was registered.
-
-    Best-effort: missing siblings, non-image siblings, or absent dimension
-    keys leave the target reference unchanged.
-    """
-    current = current_system_metadata or {}
-    if current.get("kind") == "image" and "width" in current and "height" in current:
-        return
-
-    for sibling in list_references_by_asset_id(session, asset_id):
-        if sibling.id == new_reference_id:
-            continue
-        meta = sibling.system_metadata or {}
-        if meta.get("kind") != "image":
-            continue
-        width = meta.get("width")
-        height = meta.get("height")
-        if (
-            type(width) is not int
-            or type(height) is not int
-            or width <= 0
-            or height <= 0
-        ):
-            continue
-        merged = dict(current)
-        merged["kind"] = "image"
-        merged["width"] = width
-        merged["height"] = height
-        if merged != current:
-            set_reference_system_metadata(
-                session,
-                reference_id=new_reference_id,
-                system_metadata=merged,
-            )
-        return
-
-
 def _sanitize_filename(name: str | None, fallback: str) -> str:
    n = os.path.basename((name or "").strip() or fallback)
    return n if n else fallback
@@ -4,6 +4,7 @@ Tier 1: Filesystem metadata (zero parsing)
 Tier 2: Safetensors header metadata (fast JSON read only)
 """

+from __future__ import annotations

 import json
 import logging
@@ -56,6 +56,7 @@ class IngestResult:

 class TagUsage(NamedTuple):
    name: str
+    tag_type: str
    count: int


@@ -70,7 +71,6 @@ class AssetSummaryData:
 class ListAssetsResult:
    items: list[AssetSummaryData]
    total: int
-    next_cursor: str | None = None


@dataclass(frozen=True)
@@ -75,7 +75,7 @@ def list_tags(
            owner_id=owner_id,
        )

-    return [TagUsage(name, count) for name, count in rows], total
+    return [TagUsage(name, tag_type, count) for name, tag_type, count in rows], total


 def list_tag_histogram(
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import folder_paths
 import glob
@@ -1,3 +1,4 @@
+from __future__ import annotations
 import argparse
 import logging
 import os
@@ -37,63 +38,40 @@ def is_valid_version(version: str) -> bool:
    pattern = r"^(\d+)\.(\d+)\.(\d+)$"
    return bool(re.match(pattern, version))

+def get_installed_frontend_version():
+    """Get the currently installed frontend package version."""
+    frontend_version_str = version("comfyui-frontend-package")
+    return frontend_version_str
+
+
 def get_required_frontend_version():
    return get_required_packages_versions().get("comfyui-frontend-package", None)


-COMFY_PACKAGE_VERSIONS = []
-def get_comfy_package_versions():
-    """List installed/required versions for every comfy* package in requirements.txt."""
-    if COMFY_PACKAGE_VERSIONS:
-        return COMFY_PACKAGE_VERSIONS.copy()
-    out = COMFY_PACKAGE_VERSIONS
-    for name, required in (get_required_packages_versions() or {}).items():
-        if not name.startswith("comfy"):
-            continue
-        try:
-            installed = version(name)
-        except Exception:
-            installed = None
-        out.append({"name": name, "installed": installed, "required": required})
-    return out.copy()
+def check_frontend_version():
+    """Check if the frontend version is up to date."""

-
-def check_comfy_packages_versions():
-    """Warn for every comfy* package whose installed version is below requirements.txt."""
-    from packaging.version import InvalidVersion, parse as parse_pep440
-    outdated_packages = []
-
-    for pkg in get_comfy_package_versions():
-        installed_str = pkg["installed"]
-        required_str = pkg["required"]
-        if not installed_str or not required_str:
-            continue
-        try:
-            outdated = parse_pep440(installed_str) < parse_pep440(required_str)
-        except InvalidVersion as e:
-            logging.error(f"Failed to check {pkg['name']} version: {e}")
-            continue
-        if outdated:
-            outdated_packages.append((pkg["name"], installed_str, required_str))
-        else:
-            logging.info("{} version: {}".format(pkg["name"], installed_str))
-
-    if outdated_packages:
-        package_warnings = "\n".join(
-            f"Installed {name} version {installed} is lower than the recommended version {required}."
-            for name, installed, required in outdated_packages
-        )
-        app.logger.log_startup_warning(
-            f"""
+    try:
+        frontend_version_str = get_installed_frontend_version()
+        frontend_version = parse_version(frontend_version_str)
+        required_frontend_str = get_required_frontend_version()
+        required_frontend = parse_version(required_frontend_str)
+        if frontend_version < required_frontend:
+            app.logger.log_startup_warning(
+                f"""
 ________________________________________________________________________
 WARNING WARNING WARNING WARNING WARNING

-{package_warnings}
+Installed frontend version {".".join(map(str, frontend_version))} is lower than the recommended version {".".join(map(str, required_frontend))}.

-{get_missing_requirements_message()}
+{frontend_install_warning_message()}
 ________________________________________________________________________
 """.strip()
-        )
+            )
+        else:
+            logging.info("ComfyUI frontend version: {}".format(frontend_version_str))
+    except Exception as e:
+        logging.error(f"Failed to check frontend version: {e}")


 REQUEST_TIMEOUT = 10  # seconds
@@ -223,11 +201,6 @@ class FrontendManager:
    def get_required_templates_version(cls) -> str:
        return get_required_packages_versions().get("comfyui-workflow-templates", None)

-    @classmethod
-    def get_comfy_package_versions(cls):
-        """List installed/required versions for every comfy* package in requirements.txt."""
-        return get_comfy_package_versions()
-
    @classmethod
    def default_frontend_path(cls) -> str:
        try:
@@ -368,7 +341,7 @@ comfyui-workflow-templates is not installed.
            main error source might be request timeout or invalid URL.
        """
        if version_string == DEFAULT_VERSION_STRING:
-            check_comfy_packages_versions()
+            check_frontend_version()
            return cls.default_frontend_path()

        repo_owner, repo_name, version = cls.parse_version_string(version_string)
@@ -430,7 +403,7 @@ comfyui-workflow-templates is not installed.
        except Exception as e:
            logging.error("Failed to initialize frontend: %s", e)
            logging.info("Falling back to the default frontend.")
-            check_comfy_packages_versions()
+            check_frontend_version()
            return cls.default_frontend_path()
    @classmethod
    def template_asset_handler(cls):
@@ -5,40 +5,6 @@ import logging
 import sys
 import threading

-ANSI_NAMED_COLORS = {
-    'black':   '\033[30m',
-    'red':     '\033[31m',
-    'green':   '\033[32m',
-    'yellow':  '\033[33m',
-    'blue':    '\033[34m',
-    'magenta': '\033[35m',
-    'cyan':    '\033[36m',
-    'white':   '\033[37m',
-}
-
-ANSI_LEVEL_COLORS = {
-    'DEBUG':    ANSI_NAMED_COLORS['cyan'],
-    'INFO':     ANSI_NAMED_COLORS['green'],
-    'WARNING':  ANSI_NAMED_COLORS['yellow'],
-    'ERROR':    ANSI_NAMED_COLORS['red'],
-    'CRITICAL': ANSI_NAMED_COLORS['magenta'],
-}
-
-ANSI_RESET = '\033[0m'
-ANSI_BOLD  = '\033[1m'
-
-
-class ColoredFormatter(logging.Formatter):
-    def format(self, record):
-        color = ANSI_LEVEL_COLORS.get(record.levelname, '')
-        bold  = ANSI_BOLD if record.levelno >= logging.WARNING else ''
-        level_tag = f"{bold}{color}[{record.levelname}]{ANSI_RESET} "
-        message = super().format(record)
-        line_color = ANSI_NAMED_COLORS.get(getattr(record, 'color', ''), '')
-        if line_color:
-            return f"{level_tag}{line_color}{message}{ANSI_RESET}"
-        return level_tag + message
-
 logs = None
 stdout_interceptor = None
 stderr_interceptor = None
@@ -102,10 +68,8 @@ def setup_logger(log_level: str = 'INFO', capacity: int = 300, use_stdout: bool
    logger = logging.getLogger()
    logger.setLevel(log_level)

-    formatter = ColoredFormatter("%(message)s")
-
    stream_handler = logging.StreamHandler()
-    stream_handler.setFormatter(formatter)
+    stream_handler.setFormatter(logging.Formatter("%(message)s"))

    if use_stdout:
        # Only errors and critical to stderr
@@ -113,7 +77,7 @@ def setup_logger(log_level: str = 'INFO', capacity: int = 300, use_stdout: bool

        # Lesser to stdout
        stdout_handler = logging.StreamHandler(sys.stdout)
-        stdout_handler.setFormatter(formatter)
+        stdout_handler.setFormatter(logging.Formatter("%(message)s"))
        stdout_handler.addFilter(lambda record: record.levelno < logging.ERROR)
        logger.addHandler(stdout_handler)

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import base64
 import json
@@ -50,45 +52,21 @@ class ModelFileManager:
        @routes.get("/experiment/models/preview/{folder}/{path_index}/{filename:.*}")
        async def get_model_preview(request):
            folder_name = request.match_info.get("folder", None)
+            path_index = int(request.match_info.get("path_index", None))
            filename = request.match_info.get("filename", None)

            if folder_name not in folder_paths.folder_names_and_paths:
                return web.Response(status=404)

-            # The "{filename:.*}" capture also matches the empty string, which
-            # would resolve to the folder itself; reject it explicitly.
-            if not filename:
-                return web.Response(status=400)
-
-            try:
-                path_index = int(request.match_info.get("path_index", None))
-            except (TypeError, ValueError):
-                return web.Response(status=400)
-
            folders = folder_paths.folder_names_and_paths[folder_name]
-            if path_index < 0 or path_index >= len(folders[0]):
-                return web.Response(status=404)
            folder = folders[0][path_index]
-            full_filename = os.path.normpath(os.path.join(folder, filename))
-
-            # Prevent path traversal: the requested file must stay within the
-            # configured model folder. `filename` is an unrestricted ".*" capture,
-            # so values like "../../../../etc/passwd" would otherwise escape it.
-            if not folder_paths.is_within_directory(folder, full_filename):
-                return web.Response(status=403)
+            full_filename = os.path.join(folder, filename)

            previews = self.get_model_previews(full_filename)
            default_preview = previews[0] if len(previews) > 0 else None
            if default_preview is None or (isinstance(default_preview, str) and not os.path.isfile(default_preview)):
                return web.Response(status=404)

-            # The preview is selected by a glob inside get_model_previews, so a
-            # companion file (e.g. "model.preview.png") could itself be a symlink
-            # resolving outside the model folder. Re-validate the file actually
-            # opened: is_within_directory realpaths it, catching symlink escape.
-            if isinstance(default_preview, str) and not folder_paths.is_within_directory(folder, default_preview):
-                return web.Response(status=403)
-
            try:
                with Image.open(default_preview) as img:
                    img_bytes = BytesIO()
@@ -1,3 +1,4 @@
+from __future__ import annotations
 import json
 import os
 import re
@@ -6,7 +7,6 @@ import glob
 import shutil
 import logging
 import tempfile
-import mimetypes
 from aiohttp import web
 from urllib import parse
 from comfy.cli_args import args
@@ -337,20 +337,7 @@ class UserManager():
            if not isinstance(path, str):
                return path

-            # User data files are arbitrary user-supplied content and are never
-            # meant to render inline. Disable MIME sniffing and force a download
-            # so uploaded markup/scripts can't execute in the app origin (stored
-            # XSS). Content-Disposition: attachment is the load-bearing guard;
-            # the content-type override and nosniff are defence in depth.
-            content_type = mimetypes.guess_type(path)[0] or 'application/octet-stream'
-            if folder_paths.is_dangerous_content_type(content_type):
-                content_type = 'application/octet-stream'
-
-            return web.FileResponse(path, headers={
-                "Content-Type": content_type,
-                "X-Content-Type-Options": "nosniff",
-                "Content-Disposition": "attachment",
-            })
+            return web.FileResponse(path)

        @routes.post("/userdata/{file}")
        async def post_userdata(request):
@@ -1553,7 +1553,7 @@
          "VHS_MetadataImage": true,
          "VHS_KeepIntermediate": true
        },
-        "category": "Image generation and editing/Conditioned",
+        "category": "Image generation and editing/Canny to image",
        "description": "Generates an image from a Canny edge map using Z-Image-Turbo, with text conditioning."
      }
    ]
@@ -3600,7 +3600,7 @@
        "extra": {
          "workflowRendererVersion": "LG"
        },
-        "category": "Video generation and editing/Conditioned",
+        "category": "Video generation and editing/Canny to video",
        "description": "Generates video from Canny edge maps using LTX-2, with optional synchronized audio."
      }
    ]
@@ -1401,7 +1401,7 @@
        "extra": {
          "workflowRendererVersion": "LG"
        },
-        "category": "Image generation and editing/Conditioned",
+        "category": "Image generation and editing/ControlNet",
        "description": "Generates images from a text prompt and ControlNet conditioning (e.g. depth, canny) using Z-Image-Turbo."
      }
    ]
@@ -1579,7 +1579,7 @@
          "VHS_MetadataImage": true,
          "VHS_KeepIntermediate": true
        },
-        "category": "Image generation and editing/Conditioned",
+        "category": "Image generation and editing/Depth to image",
        "description": "Generates an image from a depth map using Z-Image-Turbo with text conditioning."
      },
      {
@@ -4233,7 +4233,7 @@
        "extra": {
          "workflowRendererVersion": "LG"
        },
-        "category": "Video generation and editing/Conditioned",
+        "category": "Video generation and editing/Depth to video",
        "description": "Generates depth-controlled video with LTX-2: motion and structure follow a depth-reference video alongside text prompting, optional first-frame image conditioning, with optional synchronized audio."
      },
      {
@@ -3350,7 +3350,7 @@
          }
        ],
        "extra": {},
-        "category": "Video generation and editing/Conditioned",
+        "category": "Video generation and editing/First-Last-Frame to Video",
        "description": "Generates a video interpolating between first and last keyframes using LTX-2.3."
      }
    ]
@@ -3350,7 +3350,7 @@
          }
        ],
        "extra": {},
-        "category": "Video generation and editing/FLF2V",
+        "category": "Video generation and editing/First-Last-Frame to Video",
        "description": "Generates a video that interpolates between the first and last keyframes using LTX-2.3, including optional audio."
      }
    ]
@@ -310,9 +310,9 @@
        "extra": {
          "workflowRendererVersion": "LG"
        },
-        "category": "Image Tools",
+        "category": "Text generation/Image Captioning",
        "description": "Generates descriptive captions for images using Google's Gemini multimodal LLM."
      }
    ]
  }
-}
+}
@@ -1,569 +0,0 @@
-{
-  "revision": 0,
-  "last_node_id": 89,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 89,
-      "type": "85e595bd-af9e-40ee-85c5-b98bb15da47a",
-      "pos": [
-        320,
-        520
-      ],
-      "size": [
-        400,
-        360
-      ],
-      "flags": {},
-      "order": 3,
-      "mode": 0,
-      "inputs": [
-        {
-          "localized_name": "image",
-          "name": "image",
-          "type": "IMAGE",
-          "link": null
-        },
-        {
-          "name": "resolution",
-          "type": "INT",
-          "widget": {
-            "name": "resolution"
-          },
-          "link": null
-        },
-        {
-          "name": "resize_method",
-          "type": "COMBO",
-          "widget": {
-            "name": "resize_method"
-          },
-          "link": null
-        },
-        {
-          "label": "output_type",
-          "name": "output",
-          "type": "COMFY_DYNAMICCOMBO_V3",
-          "widget": {
-            "name": "output"
-          },
-          "link": null
-        },
-        {
-          "label": "output_normalization",
-          "name": "output.normalization",
-          "type": "COMBO",
-          "widget": {
-            "name": "output.normalization"
-          },
-          "link": null
-        },
-        {
-          "label": "apply_sky_clip",
-          "name": "output.apply_sky_clip",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "output.apply_sky_clip"
-          },
-          "link": null
-        },
-        {
-          "name": "model_name",
-          "type": "COMBO",
-          "widget": {
-            "name": "model_name"
-          },
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "localized_name": "IMAGE",
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": []
-        }
-      ],
-      "properties": {
-        "proxyWidgets": [
-          [
-            "87",
-            "resolution"
-          ],
-          [
-            "87",
-            "resize_method"
-          ],
-          [
-            "86",
-            "output"
-          ],
-          [
-            "86",
-            "output.normalization"
-          ],
-          [
-            "86",
-            "output.apply_sky_clip"
-          ],
-          [
-            "88",
-            "model_name"
-          ]
-        ],
-        "cnr_id": "comfy-core",
-        "ver": "0.24.0"
-      },
-      "widgets_values": [],
-      "title": "Image Depth Estimation (Depth Anything 3)"
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "85e595bd-af9e-40ee-85c5-b98bb15da47a",
-        "version": 1,
-        "state": {
-          "lastGroupId": 4,
-          "lastNodeId": 89,
-          "lastLinkId": 109,
-          "lastRerouteId": 0
-        },
-        "revision": 2,
-        "config": {},
-        "name": "Image Depth Estimation (Depth Anything 3)",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            400,
-            90,
-            166.998046875,
-            188
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            1250,
-            146,
-            128,
-            68
-          ]
-        },
-        "inputs": [
-          {
-            "id": "43cf3118-495a-487d-8eb3-a17c7e92f64f",
-            "name": "image",
-            "type": "IMAGE",
-            "linkIds": [
-              19
-            ],
-            "localized_name": "image",
-            "pos": [
-              542.998046875,
-              114
-            ]
-          },
-          {
-            "id": "1089a0a1-6db1-45a8-84b0-0bfdc2ed920a",
-            "name": "resolution",
-            "type": "INT",
-            "linkIds": [
-              22
-            ],
-            "pos": [
-              542.998046875,
-              134
-            ]
-          },
-          {
-            "id": "25fb64ac-26d5-466d-995b-6d51b9afa2c4",
-            "name": "resize_method",
-            "type": "COMBO",
-            "linkIds": [
-              23
-            ],
-            "pos": [
-              542.998046875,
-              154
-            ]
-          },
-          {
-            "id": "8acafb7c-6c8b-46b3-9d74-c563498a3af1",
-            "name": "output",
-            "type": "COMFY_DYNAMICCOMBO_V3",
-            "linkIds": [
-              24
-            ],
-            "label": "output_type",
-            "pos": [
-              542.998046875,
-              174
-            ]
-          },
-          {
-            "id": "1da5009b-4648-43e8-a257-16426630cf22",
-            "name": "output.normalization",
-            "type": "COMBO",
-            "linkIds": [
-              25
-            ],
-            "label": "output_normalization",
-            "pos": [
-              542.998046875,
-              194
-            ]
-          },
-          {
-            "id": "fd7edb33-5fb1-4538-a411-26e5039a9321",
-            "name": "output.apply_sky_clip",
-            "type": "BOOLEAN",
-            "linkIds": [
-              26
-            ],
-            "label": "apply_sky_clip",
-            "pos": [
-              542.998046875,
-              214
-            ]
-          },
-          {
-            "id": "b5be4c8a-b833-4f1e-8c94-3ed1dd722190",
-            "name": "model_name",
-            "type": "COMBO",
-            "linkIds": [
-              106
-            ],
-            "pos": [
-              542.998046875,
-              234
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "478ab537-63bc-4d74-a9f0-c975f550880f",
-            "name": "IMAGE",
-            "type": "IMAGE",
-            "linkIds": [
-              7
-            ],
-            "localized_name": "IMAGE",
-            "pos": [
-              1274,
-              170
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 86,
-            "type": "DA3Render",
-            "pos": [
-              800,
-              310
-            ],
-            "size": [
-              380,
-              130
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "da3_geometry",
-                "name": "da3_geometry",
-                "type": "DA3_GEOMETRY",
-                "link": 12
-              },
-              {
-                "localized_name": "output",
-                "name": "output",
-                "type": "COMFY_DYNAMICCOMBO_V3",
-                "widget": {
-                  "name": "output"
-                },
-                "link": 24
-              },
-              {
-                "localized_name": "output.normalization",
-                "name": "output.normalization",
-                "type": "COMBO",
-                "widget": {
-                  "name": "output.normalization"
-                },
-                "link": 25
-              },
-              {
-                "localized_name": "output.apply_sky_clip",
-                "name": "output.apply_sky_clip",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "output.apply_sky_clip"
-                },
-                "link": 26
-              },
-              {
-                "name": "geometry",
-                "type": "DA3_GEOMETRY",
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "IMAGE",
-                "name": "IMAGE",
-                "type": "IMAGE",
-                "slot_index": 0,
-                "links": [
-                  7
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "DA3Render",
-              "cnr_id": "comfy-core",
-              "ver": "0.19.0"
-            },
-            "widgets_values": [
-              "depth",
-              "v2_style",
-              false
-            ]
-          },
-          {
-            "id": 87,
-            "type": "DA3Inference",
-            "pos": [
-              800,
-              50
-            ],
-            "size": [
-              390,
-              130
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "da3_model",
-                "name": "da3_model",
-                "type": "DA3_MODEL",
-                "link": 107
-              },
-              {
-                "localized_name": "image",
-                "name": "image",
-                "type": "IMAGE",
-                "link": 19
-              },
-              {
-                "localized_name": "resolution",
-                "name": "resolution",
-                "type": "INT",
-                "widget": {
-                  "name": "resolution"
-                },
-                "link": 22
-              },
-              {
-                "localized_name": "resize_method",
-                "name": "resize_method",
-                "type": "COMBO",
-                "widget": {
-                  "name": "resize_method"
-                },
-                "link": 23
-              },
-              {
-                "localized_name": "mode",
-                "name": "mode",
-                "type": "COMFY_DYNAMICCOMBO_V3",
-                "widget": {
-                  "name": "mode"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "da3_geometry",
-                "name": "da3_geometry",
-                "type": "DA3_GEOMETRY",
-                "slot_index": 0,
-                "links": [
-                  12
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "DA3Inference",
-              "cnr_id": "comfy-core",
-              "ver": "0.19.0"
-            },
-            "widgets_values": [
-              504,
-              "upper_bound_resize",
-              "mono"
-            ]
-          },
-          {
-            "id": 88,
-            "type": "LoadDA3Model",
-            "pos": [
-              810,
-              -160
-            ],
-            "size": [
-              400,
-              140
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "model_name",
-                "name": "model_name",
-                "type": "COMBO",
-                "widget": {
-                  "name": "model_name"
-                },
-                "link": 106
-              },
-              {
-                "localized_name": "weight_dtype",
-                "name": "weight_dtype",
-                "type": "COMBO",
-                "widget": {
-                  "name": "weight_dtype"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "DA3_MODEL",
-                "name": "DA3_MODEL",
-                "type": "DA3_MODEL",
-                "links": [
-                  107
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "LoadDA3Model",
-              "cnr_id": "comfy-core",
-              "ver": "0.24.0",
-              "models": [
-                {
-                  "name": "depth_anything_3_mono_large.safetensors",
-                  "url": "https://huggingface.co/Comfy-Org/Depth-Anything-3/resolve/main/geometry_estimation/depth_anything_3_mono_large.safetensors",
-                  "directory": "geometry_estimation"
-                }
-              ]
-            },
-            "widgets_values": [
-              "depth_anything_3_mono_large.safetensors",
-              "default"
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 12,
-            "origin_id": 87,
-            "origin_slot": 0,
-            "target_id": 86,
-            "target_slot": 0,
-            "type": "DA3_GEOMETRY"
-          },
-          {
-            "id": 19,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 87,
-            "target_slot": 1,
-            "type": "IMAGE"
-          },
-          {
-            "id": 7,
-            "origin_id": 86,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 22,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 87,
-            "target_slot": 2,
-            "type": "INT"
-          },
-          {
-            "id": 23,
-            "origin_id": -10,
-            "origin_slot": 2,
-            "target_id": 87,
-            "target_slot": 3,
-            "type": "COMBO"
-          },
-          {
-            "id": 24,
-            "origin_id": -10,
-            "origin_slot": 3,
-            "target_id": 86,
-            "target_slot": 1,
-            "type": "COMFY_DYNAMICCOMBO_V3"
-          },
-          {
-            "id": 25,
-            "origin_id": -10,
-            "origin_slot": 4,
-            "target_id": 86,
-            "target_slot": 2,
-            "type": "COMBO"
-          },
-          {
-            "id": 26,
-            "origin_id": -10,
-            "origin_slot": 5,
-            "target_id": 86,
-            "target_slot": 3,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 106,
-            "origin_id": -10,
-            "origin_slot": 6,
-            "target_id": 88,
-            "target_slot": 0,
-            "type": "COMBO"
-          },
-          {
-            "id": 107,
-            "origin_id": 88,
-            "origin_slot": 0,
-            "target_id": 87,
-            "target_slot": 0,
-            "type": "DA3_MODEL"
-          }
-        ],
-        "extra": {},
-        "category": "Conditioning & Preprocessors/Depth",
-        "description": "This subgraph takes an input image and produces a depth map using the Depth Anything 3 model, which recovers spatially consistent geometry from any number of views. It is ideal for single or multi-view images, videos, and 3D scenes where accurate depth estimation is needed for tasks like SLAM, novel view synthesis, or spatial perception. The model uses a plain transformer backbone and supports both monocular and multi-view inputs without."
-      }
-    ]
-  },
-  "extra": {
-    "BlueprintDescription": "This subgraph takes an input image and produces a depth map using the Depth Anything 3 model, which recovers spatially consistent geometry from any number of views. It is ideal for single or multi-view images, videos, and 3D scenes where accurate depth estimation is needed for tasks like SLAM, novel view synthesis, or spatial perception. The model uses a plain transformer backbone and supports both monocular and multi-view inputs without."
-  }
-}
@@ -1,779 +0,0 @@
-{
-  "revision": 0,
-  "last_node_id": 33,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 33,
-      "type": "6062babb-b649-4a71-be9e-20ebce567744",
-      "pos": [
-        -450,
-        4240
-      ],
-      "size": [
-        420,
-        400
-      ],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [
-        {
-          "localized_name": "image",
-          "name": "image",
-          "type": "IMAGE",
-          "link": null
-        },
-        {
-          "name": "face_landmarker",
-          "type": "FACE_LANDMARKER",
-          "link": null
-        },
-        {
-          "name": "detector_variant",
-          "type": "COMBO",
-          "widget": {
-            "name": "detector_variant"
-          },
-          "link": null
-        },
-        {
-          "name": "num_faces",
-          "type": "INT",
-          "widget": {
-            "name": "num_faces"
-          },
-          "link": null
-        },
-        {
-          "label": "custom_face_oval",
-          "name": "regions.face_oval",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "regions.face_oval"
-          },
-          "link": null
-        },
-        {
-          "label": "custom_lips",
-          "name": "regions.lips",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "regions.lips"
-          },
-          "link": null
-        },
-        {
-          "label": "custom_left_eye",
-          "name": "regions.left_eye",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "regions.left_eye"
-          },
-          "link": null
-        },
-        {
-          "label": "custom_right_eye",
-          "name": "regions.right_eye",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "regions.right_eye"
-          },
-          "link": null
-        },
-        {
-          "label": "custom_irises",
-          "name": "regions.irises",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "regions.irises"
-          },
-          "link": null
-        },
-        {
-          "name": "model_name",
-          "type": "COMBO",
-          "widget": {
-            "name": "model_name"
-          },
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "localized_name": "face_landmarks",
-          "name": "face_landmarks",
-          "type": "FACE_LANDMARKS",
-          "links": []
-        },
-        {
-          "localized_name": "bboxes",
-          "name": "bboxes",
-          "type": "BOUNDING_BOX",
-          "links": []
-        },
-        {
-          "label": "mask",
-          "name": "MASK_1",
-          "type": "MASK",
-          "links": []
-        }
-      ],
-      "title": "Image Face Detection (Mediapipe)",
-      "properties": {
-        "proxyWidgets": [
-          [
-            "11",
-            "detector_variant"
-          ],
-          [
-            "11",
-            "num_faces"
-          ],
-          [
-            "20",
-            "regions.face_oval"
-          ],
-          [
-            "20",
-            "regions.lips"
-          ],
-          [
-            "20",
-            "regions.left_eye"
-          ],
-          [
-            "20",
-            "regions.right_eye"
-          ],
-          [
-            "20",
-            "regions.irises"
-          ],
-          [
-            "2",
-            "model_name"
-          ]
-        ],
-        "cnr_id": "comfy-core",
-        "ver": "0.22.0",
-        "enableTabs": false,
-        "tabWidth": 65,
-        "tabXOffset": 10,
-        "hasSecondTab": false,
-        "secondTabText": "Send Back",
-        "secondTabOffset": 80,
-        "secondTabWidth": 65
-      },
-      "widgets_values": []
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "6062babb-b649-4a71-be9e-20ebce567744",
-        "version": 1,
-        "state": {
-          "lastGroupId": 2,
-          "lastNodeId": 158,
-          "lastLinkId": 140,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "Image Face Detection (Mediapipe)",
-        "description": "Detects facial landmarks from an image using MediaPipe, outputting landmark data, face bounding boxes, and an optional face-region mask.",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            -710,
-            4300,
-            148.880859375,
-            248
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            140,
-            4480,
-            137.677734375,
-            108
-          ]
-        },
-        "inputs": [
-          {
-            "id": "705dc1ae-6dc9-4155-92df-52f816ad451e",
-            "name": "image",
-            "type": "IMAGE",
-            "linkIds": [
-              60
-            ],
-            "localized_name": "image",
-            "pos": [
-              -585.119140625,
-              4324
-            ]
-          },
-          {
-            "id": "d6277190-732c-4604-b7cd-d3a9588bf761",
-            "name": "face_landmarker",
-            "type": "FACE_LANDMARKER",
-            "linkIds": [
-              74
-            ],
-            "pos": [
-              -585.119140625,
-              4344
-            ]
-          },
-          {
-            "id": "ac473a08-6a86-42a7-b460-e70c6c5e1e2b",
-            "name": "detector_variant",
-            "type": "COMBO",
-            "linkIds": [
-              75
-            ],
-            "pos": [
-              -585.119140625,
-              4364
-            ]
-          },
-          {
-            "id": "1bec2252-ca2d-496e-8a33-33a61d21f897",
-            "name": "num_faces",
-            "type": "INT",
-            "linkIds": [
-              76
-            ],
-            "pos": [
-              -585.119140625,
-              4384
-            ]
-          },
-          {
-            "id": "17994fa2-0ea0-4c9b-a70a-19789c459c80",
-            "name": "regions.face_oval",
-            "type": "BOOLEAN",
-            "linkIds": [
-              77
-            ],
-            "label": "custom_face_oval",
-            "pos": [
-              -585.119140625,
-              4404
-            ]
-          },
-          {
-            "id": "1c6c5893-2aee-4c37-b702-15ef2e20d863",
-            "name": "regions.lips",
-            "type": "BOOLEAN",
-            "linkIds": [
-              78
-            ],
-            "label": "custom_lips",
-            "pos": [
-              -585.119140625,
-              4424
-            ]
-          },
-          {
-            "id": "f353fcea-4b6f-42a1-8fdd-32b3aa1e1f09",
-            "name": "regions.left_eye",
-            "type": "BOOLEAN",
-            "linkIds": [
-              79
-            ],
-            "label": "custom_left_eye",
-            "pos": [
-              -585.119140625,
-              4444
-            ]
-          },
-          {
-            "id": "1387e121-c1fb-4522-8f0d-43459e11dd86",
-            "name": "regions.right_eye",
-            "type": "BOOLEAN",
-            "linkIds": [
-              80
-            ],
-            "label": "custom_right_eye",
-            "pos": [
-              -585.119140625,
-              4464
-            ]
-          },
-          {
-            "id": "14acb0a0-d1f4-48f3-ba31-811b26236ef9",
-            "name": "regions.irises",
-            "type": "BOOLEAN",
-            "linkIds": [
-              81
-            ],
-            "label": "custom_irises",
-            "pos": [
-              -585.119140625,
-              4484
-            ]
-          },
-          {
-            "id": "25a82859-87de-42c8-8431-09948665546e",
-            "name": "model_name",
-            "type": "COMBO",
-            "linkIds": [
-              86
-            ],
-            "pos": [
-              -585.119140625,
-              4504
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "d2ba3f92-e8b1-49c3-9590-cfad56c54cf4",
-            "name": "face_landmarks",
-            "type": "FACE_LANDMARKS",
-            "linkIds": [
-              44
-            ],
-            "localized_name": "face_landmarks",
-            "pos": [
-              164,
-              4504
-            ]
-          },
-          {
-            "id": "4f356bb0-d4c4-4f93-b4cf-0845a65c4e6d",
-            "name": "bboxes",
-            "type": "BOUNDING_BOX",
-            "linkIds": [
-              25
-            ],
-            "localized_name": "bboxes",
-            "pos": [
-              164,
-              4524
-            ]
-          },
-          {
-            "id": "f6309e1d-6397-4363-b38f-778a122abc51",
-            "name": "MASK_1",
-            "type": "MASK",
-            "linkIds": [
-              83
-            ],
-            "label": "mask",
-            "pos": [
-              164,
-              4544
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 11,
-            "type": "MediaPipeFaceLandmarker",
-            "pos": [
-              -280,
-              4280
-            ],
-            "size": [
-              350,
-              220
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "face_detection_model",
-                "name": "face_detection_model",
-                "type": "FACE_DETECTION_MODEL",
-                "link": 66
-              },
-              {
-                "localized_name": "image",
-                "name": "image",
-                "type": "IMAGE",
-                "link": 60
-              },
-              {
-                "localized_name": "detector_variant",
-                "name": "detector_variant",
-                "type": "COMBO",
-                "widget": {
-                  "name": "detector_variant"
-                },
-                "link": 75
-              },
-              {
-                "localized_name": "num_faces",
-                "name": "num_faces",
-                "type": "INT",
-                "widget": {
-                  "name": "num_faces"
-                },
-                "link": 76
-              },
-              {
-                "localized_name": "min_confidence",
-                "name": "min_confidence",
-                "type": "FLOAT",
-                "widget": {
-                  "name": "min_confidence"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "missing_frame_fallback",
-                "name": "missing_frame_fallback",
-                "type": "COMBO",
-                "widget": {
-                  "name": "missing_frame_fallback"
-                },
-                "link": null
-              },
-              {
-                "name": "face_landmarker",
-                "type": "FACE_LANDMARKER",
-                "link": 74
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "face_landmarks",
-                "name": "face_landmarks",
-                "type": "FACE_LANDMARKS",
-                "links": [
-                  44,
-                  46
-                ]
-              },
-              {
-                "localized_name": "bboxes",
-                "name": "bboxes",
-                "type": "BOUNDING_BOX",
-                "links": [
-                  25
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "MediaPipeFaceLandmarker",
-              "cnr_id": "comfy-core",
-              "ver": "0.22.0",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65
-            },
-            "widgets_values": [
-              "full",
-              0,
-              0.5,
-              "empty"
-            ]
-          },
-          {
-            "id": 2,
-            "type": "LoadMediaPipeFaceLandmarker",
-            "pos": [
-              -290,
-              4060
-            ],
-            "size": [
-              350,
-              140
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "model_name",
-                "name": "model_name",
-                "type": "COMBO",
-                "widget": {
-                  "name": "model_name"
-                },
-                "link": 86
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "FACE_DETECTION_MODEL",
-                "name": "FACE_DETECTION_MODEL",
-                "type": "FACE_DETECTION_MODEL",
-                "links": [
-                  66
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "LoadMediaPipeFaceLandmarker",
-              "cnr_id": "comfy-core",
-              "ver": "0.22.0",
-              "models": [
-                {
-                  "name": "mediapipe_face_fp32.safetensors",
-                  "url": "https://huggingface.co/Comfy-Org/mediapipe/resolve/main/detection/mediapipe_face_fp32.safetensors",
-                  "directory": "detection"
-                }
-              ],
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65
-            },
-            "widgets_values": [
-              "mediapipe_face_fp32.safetensors"
-            ]
-          },
-          {
-            "id": 20,
-            "type": "MediaPipeFaceMask",
-            "pos": [
-              -290,
-              4560
-            ],
-            "size": [
-              360,
-              180
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "face_landmarks",
-                "name": "face_landmarks",
-                "type": "FACE_LANDMARKS",
-                "link": 46
-              },
-              {
-                "localized_name": "regions",
-                "name": "regions",
-                "type": "COMFY_DYNAMICCOMBO_V3",
-                "widget": {
-                  "name": "regions"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "regions.face_oval",
-                "name": "regions.face_oval",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "regions.face_oval"
-                },
-                "link": 77
-              },
-              {
-                "localized_name": "regions.lips",
-                "name": "regions.lips",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "regions.lips"
-                },
-                "link": 78
-              },
-              {
-                "localized_name": "regions.left_eye",
-                "name": "regions.left_eye",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "regions.left_eye"
-                },
-                "link": 79
-              },
-              {
-                "localized_name": "regions.right_eye",
-                "name": "regions.right_eye",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "regions.right_eye"
-                },
-                "link": 80
-              },
-              {
-                "localized_name": "regions.irises",
-                "name": "regions.irises",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "regions.irises"
-                },
-                "link": 81
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "MASK",
-                "name": "MASK",
-                "type": "MASK",
-                "links": [
-                  83
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "MediaPipeFaceMask",
-              "cnr_id": "comfy-core",
-              "ver": "0.22.0",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65
-            },
-            "widgets_values": [
-              "custom",
-              true,
-              false,
-              false,
-              false,
-              false
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 66,
-            "origin_id": 2,
-            "origin_slot": 0,
-            "target_id": 11,
-            "target_slot": 0,
-            "type": "FACE_DETECTION_MODEL"
-          },
-          {
-            "id": 46,
-            "origin_id": 11,
-            "origin_slot": 0,
-            "target_id": 20,
-            "target_slot": 0,
-            "type": "FACE_LANDMARKS"
-          },
-          {
-            "id": 60,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 11,
-            "target_slot": 1,
-            "type": "IMAGE"
-          },
-          {
-            "id": 44,
-            "origin_id": 11,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "FACE_LANDMARKS"
-          },
-          {
-            "id": 25,
-            "origin_id": 11,
-            "origin_slot": 1,
-            "target_id": -20,
-            "target_slot": 1,
-            "type": "BOUNDING_BOX"
-          },
-          {
-            "id": 74,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 11,
-            "target_slot": 6,
-            "type": "FACE_LANDMARKER"
-          },
-          {
-            "id": 75,
-            "origin_id": -10,
-            "origin_slot": 2,
-            "target_id": 11,
-            "target_slot": 2,
-            "type": "COMBO"
-          },
-          {
-            "id": 76,
-            "origin_id": -10,
-            "origin_slot": 3,
-            "target_id": 11,
-            "target_slot": 3,
-            "type": "INT"
-          },
-          {
-            "id": 77,
-            "origin_id": -10,
-            "origin_slot": 4,
-            "target_id": 20,
-            "target_slot": 2,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 78,
-            "origin_id": -10,
-            "origin_slot": 5,
-            "target_id": 20,
-            "target_slot": 3,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 79,
-            "origin_id": -10,
-            "origin_slot": 6,
-            "target_id": 20,
-            "target_slot": 4,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 80,
-            "origin_id": -10,
-            "origin_slot": 7,
-            "target_id": 20,
-            "target_slot": 5,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 81,
-            "origin_id": -10,
-            "origin_slot": 8,
-            "target_id": 20,
-            "target_slot": 6,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 83,
-            "origin_id": 20,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 2,
-            "type": "MASK"
-          },
-          {
-            "id": 86,
-            "origin_id": -10,
-            "origin_slot": 9,
-            "target_id": 2,
-            "target_slot": 0,
-            "type": "COMBO"
-          }
-        ],
-        "extra": {},
-        "category": "Conditioning & Preprocessors/Face Detection"
-      }
-    ]
-  },
-  "extra": {}
-}
@@ -703,7 +703,7 @@
          }
        ],
        "extra": {},
-        "category": "Conditioning & Preprocessors/Segmentation & Mask",
+        "category": "Image Tools/Image Segmentation",
        "description": "Segments images into masks using Meta SAM3 from text prompts, points, or boxes."
      }
    ]
@@ -1302,7 +1302,7 @@
        "extra": {
          "workflowRendererVersion": "LG"
        },
-        "category": "Image generation and editing/Upscale",
+        "category": "Image generation and editing/Enhance",
        "description": "Upscales images to higher resolution using Z-Image-Turbo."
      }
    ]
@@ -1312,4 +1312,4 @@
    "workflowRendererVersion": "LG"
  },
  "version": 0.4
-}
+}
@@ -1,18 +1,19 @@
 {
+  "id": "6af0a6c1-0161-4528-8685-65776e838d44",
  "revision": 0,
-  "last_node_id": 76,
-  "last_link_id": 0,
+  "last_node_id": 75,
+  "last_link_id": 245,
  "nodes": [
    {
-      "id": 76,
-      "type": "96338968-1242-4f02-b6a1-d496af4bcffe",
+      "id": 75,
+      "type": "488652fd-6edf-4d06-8f9f-4d84d3a34eaf",
      "pos": [
-        670,
-        1280
+        600,
+        830
      ],
      "size": [
        400,
-        201.3125
+        110
      ],
      "flags": {},
      "order": 0,
@@ -58,44 +59,47 @@
          "links": []
        }
      ],
-      "title": "Image Depth Estimation (Lotus Depth)",
      "properties": {
        "proxyWidgets": [
          [
-            "28",
+            "-1",
            "sigma"
          ],
          [
-            "10",
+            "-1",
            "unet_name"
          ],
          [
-            "14",
+            "-1",
            "vae_name"
          ]
        ],
        "cnr_id": "comfy-core",
        "ver": "0.14.1"
      },
-      "widgets_values": []
+      "widgets_values": [
+        999.0000000000002,
+        "lotus-depth-d-v1-1.safetensors",
+        "vae-ft-mse-840000-ema-pruned.safetensors"
+      ]
    }
  ],
  "links": [],
-  "version": 0.4,
+  "groups": [],
  "definitions": {
    "subgraphs": [
      {
-        "id": "96338968-1242-4f02-b6a1-d496af4bcffe",
+        "id": "488652fd-6edf-4d06-8f9f-4d84d3a34eaf",
        "version": 1,
        "state": {
          "lastGroupId": 1,
-          "lastNodeId": 76,
+          "lastNodeId": 75,
          "lastLinkId": 245,
          "lastRerouteId": 0
        },
        "revision": 0,
        "config": {},
-        "name": "Image Depth Estimation (Lotus Depth)",
+        "name": "Image to Depth Map (Lotus)",
        "inputNode": {
          "id": -10,
          "bounding": [
@@ -187,12 +191,12 @@
            "id": 10,
            "type": "UNETLoader",
            "pos": [
-              110,
-              -250
+              108.05555555555557,
+              -253.05555555555557
            ],
            "size": [
-              260,
-              90
+              254.93706597222226,
+              82
            ],
            "flags": {},
            "order": 4,
@@ -230,9 +234,9 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "UNETLoader",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "UNETLoader",
              "models": [
                {
                  "name": "lotus-depth-d-v1-1.safetensors",
@@ -251,12 +255,12 @@
            "id": 18,
            "type": "DisableNoise",
            "pos": [
-              610,
-              -270
+              607.0641494069639,
+              -268.33337840371513
            ],
            "size": [
-              180,
-              40
+              175,
+              33.333333333333336
            ],
            "flags": {},
            "order": 0,
@@ -274,25 +278,26 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "DisableNoise",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "DisableNoise",
              "widget_ue_connectable": {}
-            }
+            },
+            "widgets_values": []
          },
          {
-            "id": 74,
+            "id": 23,
            "type": "VAEEncode",
            "pos": [
              620,
              160
            ],
            "size": [
-              180,
+              175,
              50
            ],
            "flags": {},
-            "order": 11,
+            "order": 10,
            "mode": 0,
            "inputs": [
              {
@@ -320,11 +325,12 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "VAEEncode",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "VAEEncode",
              "widget_ue_connectable": {}
-            }
+            },
+            "widgets_values": []
          },
          {
            "id": 21,
@@ -335,7 +341,7 @@
            ],
            "size": [
              210,
-              60
+              58
            ],
            "flags": {},
            "order": 1,
@@ -363,9 +369,9 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "KSamplerSelect",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "KSamplerSelect",
              "widget_ue_connectable": {}
            },
            "widgets_values": [
@@ -380,7 +386,7 @@
              -170
            ],
            "size": [
-              180,
+              175,
              50
            ],
            "flags": {},
@@ -412,11 +418,12 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "BasicGuider",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "BasicGuider",
              "widget_ue_connectable": {}
-            }
+            },
+            "widgets_values": []
          },
          {
            "id": 16,
@@ -426,8 +433,8 @@
              -130
            ],
            "size": [
-              300,
-              280
+              295.99609375,
+              271.65798611111114
            ],
            "flags": {},
            "order": 6,
@@ -483,11 +490,12 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "SamplerCustomAdvanced",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "SamplerCustomAdvanced",
              "widget_ue_connectable": {}
-            }
+            },
+            "widgets_values": []
          },
          {
            "id": 28,
@@ -498,10 +506,10 @@
            ],
            "size": [
              210,
-              60
+              58
            ],
            "flags": {},
-            "order": 10,
+            "order": 11,
            "mode": 0,
            "inputs": [
              {
@@ -532,9 +540,9 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "SetFirstSigma",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "SetFirstSigma",
              "widget_ue_connectable": {}
            },
            "widgets_values": [
@@ -549,7 +557,7 @@
              -120
            ],
            "size": [
-              180,
+              175,
              50
            ],
            "flags": {},
@@ -581,11 +589,12 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "VAEDecode",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "VAEDecode",
              "widget_ue_connectable": {}
-            }
+            },
+            "widgets_values": []
          },
          {
            "id": 22,
@@ -595,8 +604,8 @@
              -220
            ],
            "size": [
-              180,
-              40
+              175,
+              33.333333333333336
            ],
            "flags": {},
            "order": 9,
@@ -621,11 +630,12 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "ImageInvert",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "ImageInvert",
              "widget_ue_connectable": {}
-            }
+            },
+            "widgets_values": []
          },
          {
            "id": 14,
@@ -635,8 +645,8 @@
              -90
            ],
            "size": [
-              260,
-              60
+              254.93706597222226,
+              58
            ],
            "flags": {},
            "order": 5,
@@ -665,9 +675,9 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "VAELoader",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "VAELoader",
              "models": [
                {
                  "name": "vae-ft-mse-840000-ema-pruned.safetensors",
@@ -682,15 +692,15 @@
            ]
          },
          {
-            "id": 75,
+            "id": 68,
            "type": "LotusConditioning",
            "pos": [
              400,
              -150
            ],
            "size": [
-              180,
-              40
+              175,
+              33.333333333333336
            ],
            "flags": {},
            "order": 2,
@@ -708,11 +718,12 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "LotusConditioning",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "LotusConditioning",
              "widget_ue_connectable": {}
-            }
+            },
+            "widgets_values": []
          },
          {
            "id": 20,
@@ -723,7 +734,7 @@
            ],
            "size": [
              210,
-              110
+              106
            ],
            "flags": {},
            "order": 8,
@@ -775,9 +786,9 @@
              }
            ],
            "properties": {
-              "Node name for S&R": "BasicScheduler",
              "cnr_id": "comfy-core",
              "ver": "0.3.34",
+              "Node name for S&R": "BasicScheduler",
              "widget_ue_connectable": {}
            },
            "widgets_values": [
@@ -839,7 +850,7 @@
          },
          {
            "id": 201,
-            "origin_id": 74,
+            "origin_id": 23,
            "origin_slot": 0,
            "target_id": 16,
            "target_slot": 4,
@@ -855,7 +866,7 @@
          },
          {
            "id": 238,
-            "origin_id": 75,
+            "origin_id": 68,
            "origin_slot": 0,
            "target_id": 19,
            "target_slot": 1,
@@ -881,7 +892,7 @@
            "id": 38,
            "origin_id": 14,
            "origin_slot": 0,
-            "target_id": 74,
+            "target_id": 23,
            "target_slot": 1,
            "type": "VAE"
          },
@@ -897,7 +908,7 @@
            "id": 37,
            "origin_id": -10,
            "origin_slot": 0,
-            "target_id": 74,
+            "target_id": 23,
            "target_slot": 0,
            "type": "IMAGE"
          },
@@ -937,11 +948,12 @@
        "extra": {
          "workflowRendererVersion": "LG"
        },
-        "category": "Conditioning & Preprocessors/Depth",
+        "category": "Image generation and editing/Depth to image",
        "description": "Estimates a monocular depth map from an input image using the Lotus depth estimation model."
      }
    ]
  },
+  "config": {},
  "extra": {
    "ds": {
      "scale": 1.3589709866044692,
@@ -949,6 +961,8 @@
        -138.53613935617864,
        -786.0629126022195
      ]
-    }
-  }
+    },
+    "workflowRendererVersion": "LG"
+  },
+  "version": 0.4
 }
@@ -1,888 +0,0 @@
-{
-  "revision": 0,
-  "last_node_id": 675,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 675,
-      "type": "01b6a731-fb78-4070-9a38-c87146da9604",
-      "pos": [
-        -2480,
-        3400
-      ],
-      "size": [
-        360,
-        433.3125
-      ],
-      "flags": {},
-      "order": 2,
-      "mode": 0,
-      "inputs": [
-        {
-          "localized_name": "input",
-          "name": "input",
-          "type": "IMAGE,MASK",
-          "link": null
-        },
-        {
-          "label": "resize_target_longer_size",
-          "name": "resize_type.longer_size",
-          "type": "INT",
-          "widget": {
-            "name": "resize_type.longer_size"
-          },
-          "link": null
-        },
-        {
-          "name": "scale_method",
-          "type": "COMBO",
-          "widget": {
-            "name": "scale_method"
-          },
-          "link": null
-        },
-        {
-          "name": "draw_body",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "draw_body"
-          },
-          "link": null
-        },
-        {
-          "name": "draw_hands",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "draw_hands"
-          },
-          "link": null
-        },
-        {
-          "name": "draw_face",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "draw_face"
-          },
-          "link": null
-        },
-        {
-          "name": "draw_feet",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "draw_feet"
-          },
-          "link": null
-        },
-        {
-          "name": "stick_width",
-          "type": "INT",
-          "widget": {
-            "name": "stick_width"
-          },
-          "link": null
-        },
-        {
-          "name": "face_point_size",
-          "type": "INT",
-          "widget": {
-            "name": "face_point_size"
-          },
-          "link": null
-        },
-        {
-          "name": "score_threshold",
-          "type": "FLOAT",
-          "widget": {
-            "name": "score_threshold"
-          },
-          "link": null
-        },
-        {
-          "name": "ckpt_name",
-          "type": "COMBO",
-          "widget": {
-            "name": "ckpt_name"
-          },
-          "link": null
-        },
-        {
-          "name": "bboxes",
-          "shape": 7,
-          "type": "BOUNDING_BOX",
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "localized_name": "IMAGE",
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": []
-        },
-        {
-          "name": "keypoints",
-          "type": "POSE_KEYPOINT",
-          "links": null
-        }
-      ],
-      "properties": {
-        "proxyWidgets": [
-          [
-            "674",
-            "resize_type.longer_size"
-          ],
-          [
-            "674",
-            "scale_method"
-          ],
-          [
-            "672",
-            "draw_body"
-          ],
-          [
-            "672",
-            "draw_hands"
-          ],
-          [
-            "672",
-            "draw_face"
-          ],
-          [
-            "672",
-            "draw_feet"
-          ],
-          [
-            "672",
-            "stick_width"
-          ],
-          [
-            "672",
-            "face_point_size"
-          ],
-          [
-            "672",
-            "score_threshold"
-          ],
-          [
-            "673",
-            "ckpt_name"
-          ]
-        ],
-        "cnr_id": "comfy-core",
-        "ver": "0.15.1",
-        "ue_properties": {
-          "widget_ue_connectable": {},
-          "version": "7.7",
-          "input_ue_unconnectable": {}
-        }
-      },
-      "widgets_values": [],
-      "title": "Image to Pose Map (SDPose-OOD)"
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "01b6a731-fb78-4070-9a38-c87146da9604",
-        "version": 1,
-        "state": {
-          "lastGroupId": 0,
-          "lastNodeId": 676,
-          "lastLinkId": 1715,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "Image to Pose Map (SDPose-OOD)",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            -3290,
-            3590,
-            190.8984375,
-            288
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            -1756.2451602089645,
-            3366,
-            128,
-            88
-          ]
-        },
-        "inputs": [
-          {
-            "id": "e24699c3-1356-4634-9eb4-19bb58e5c0b0",
-            "name": "input",
-            "type": "IMAGE,MASK",
-            "linkIds": [
-              1700
-            ],
-            "localized_name": "input",
-            "pos": [
-              -3123.1015625,
-              3614
-            ]
-          },
-          {
-            "id": "088eefc1-cd8a-4573-993f-9e4da008a12d",
-            "name": "resize_type.longer_size",
-            "type": "INT",
-            "linkIds": [
-              1704
-            ],
-            "label": "resize_target_longer_size",
-            "pos": [
-              -3123.1015625,
-              3634
-            ]
-          },
-          {
-            "id": "b6449bd3-73d4-41c8-b81f-cf8d33f76a2e",
-            "name": "scale_method",
-            "type": "COMBO",
-            "linkIds": [
-              1705
-            ],
-            "pos": [
-              -3123.1015625,
-              3654
-            ]
-          },
-          {
-            "id": "4cff52ad-ed07-4c97-8803-fcbd89554fd0",
-            "name": "draw_body",
-            "type": "BOOLEAN",
-            "linkIds": [
-              1706
-            ],
-            "pos": [
-              -3123.1015625,
-              3674
-            ]
-          },
-          {
-            "id": "7af63dce-f7df-4d7e-8215-d7c7f60bf81c",
-            "name": "draw_hands",
-            "type": "BOOLEAN",
-            "linkIds": [
-              1707
-            ],
-            "pos": [
-              -3123.1015625,
-              3694
-            ]
-          },
-          {
-            "id": "af3a9bce-61f9-4aca-b530-9f65e028b35e",
-            "name": "draw_face",
-            "type": "BOOLEAN",
-            "linkIds": [
-              1708
-            ],
-            "pos": [
-              -3123.1015625,
-              3714
-            ]
-          },
-          {
-            "id": "4620f6a3-2c85-4b79-ad8f-35d0326b568f",
-            "name": "draw_feet",
-            "type": "BOOLEAN",
-            "linkIds": [
-              1709
-            ],
-            "pos": [
-              -3123.1015625,
-              3734
-            ]
-          },
-          {
-            "id": "fee5d0c9-8d4b-4934-81d8-ba2206dc56cb",
-            "name": "stick_width",
-            "type": "INT",
-            "linkIds": [
-              1710
-            ],
-            "pos": [
-              -3123.1015625,
-              3754
-            ]
-          },
-          {
-            "id": "aafdd060-ba81-4324-a9cc-b656e1ebc133",
-            "name": "face_point_size",
-            "type": "INT",
-            "linkIds": [
-              1711
-            ],
-            "pos": [
-              -3123.1015625,
-              3774
-            ]
-          },
-          {
-            "id": "514c5503-f9e6-4d23-b1ae-1d3291acb2a3",
-            "name": "score_threshold",
-            "type": "FLOAT",
-            "linkIds": [
-              1712
-            ],
-            "pos": [
-              -3123.1015625,
-              3794
-            ]
-          },
-          {
-            "id": "ae46de61-2cc6-483e-8ee9-87e4144a2ffa",
-            "name": "ckpt_name",
-            "type": "COMBO",
-            "linkIds": [
-              1713
-            ],
-            "pos": [
-              -3123.1015625,
-              3814
-            ]
-          },
-          {
-            "id": "41bec0c6-dffa-4c78-9289-ee678715ae54",
-            "name": "bboxes",
-            "type": "BOUNDING_BOX",
-            "linkIds": [
-              1714
-            ],
-            "pos": [
-              -3123.1015625,
-              3834
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "f05ed8cc-9403-4f14-8085-4364b06f8a48",
-            "name": "IMAGE",
-            "type": "IMAGE",
-            "linkIds": [
-              1701
-            ],
-            "localized_name": "IMAGE",
-            "pos": [
-              -1732.2451602089645,
-              3390
-            ]
-          },
-          {
-            "id": "29a6584e-4685-4986-8ffd-e6d8539953fd",
-            "name": "keypoints",
-            "type": "POSE_KEYPOINT",
-            "linkIds": [
-              1715
-            ],
-            "pos": [
-              -1732.2451602089645,
-              3410
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 671,
-            "type": "SDPoseKeypointExtractor",
-            "pos": [
-              -2470,
-              3250
-            ],
-            "size": [
-              270,
-              180
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "model",
-                "name": "model",
-                "type": "MODEL",
-                "link": 1696
-              },
-              {
-                "localized_name": "vae",
-                "name": "vae",
-                "type": "VAE",
-                "link": 1697
-              },
-              {
-                "localized_name": "image",
-                "name": "image",
-                "type": "IMAGE",
-                "link": 1698
-              },
-              {
-                "localized_name": "bboxes",
-                "name": "bboxes",
-                "shape": 7,
-                "type": "BOUNDING_BOX",
-                "link": 1714
-              },
-              {
-                "localized_name": "batch_size",
-                "name": "batch_size",
-                "type": "INT",
-                "widget": {
-                  "name": "batch_size"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "keypoints",
-                "name": "keypoints",
-                "type": "POSE_KEYPOINT",
-                "links": [
-                  1699,
-                  1715
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "SDPoseKeypointExtractor",
-              "cnr_id": "comfy-core",
-              "ver": "0.15.0",
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "version": "7.7",
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              16
-            ]
-          },
-          {
-            "id": 674,
-            "type": "ResizeImageMaskNode",
-            "pos": [
-              -2960,
-              3490
-            ],
-            "size": [
-              270,
-              110
-            ],
-            "flags": {},
-            "order": 3,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "input",
-                "name": "input",
-                "type": "IMAGE,MASK",
-                "link": 1700
-              },
-              {
-                "localized_name": "resize_type",
-                "name": "resize_type",
-                "type": "COMFY_DYNAMICCOMBO_V3",
-                "widget": {
-                  "name": "resize_type"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "resize_type.longer_size",
-                "name": "resize_type.longer_size",
-                "type": "INT",
-                "widget": {
-                  "name": "resize_type.longer_size"
-                },
-                "link": 1704
-              },
-              {
-                "localized_name": "scale_method",
-                "name": "scale_method",
-                "type": "COMBO",
-                "widget": {
-                  "name": "scale_method"
-                },
-                "link": 1705
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "resized",
-                "name": "resized",
-                "type": "*",
-                "links": [
-                  1698
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "ResizeImageMaskNode",
-              "cnr_id": "comfy-core",
-              "ver": "0.15.0",
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "version": "7.7",
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              "scale longer dimension",
-              1024,
-              "area"
-            ]
-          },
-          {
-            "id": 672,
-            "type": "SDPoseDrawKeypoints",
-            "pos": [
-              -2120,
-              3260
-            ],
-            "size": [
-              270,
-              280
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "keypoints",
-                "name": "keypoints",
-                "type": "POSE_KEYPOINT",
-                "link": 1699
-              },
-              {
-                "localized_name": "draw_body",
-                "name": "draw_body",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "draw_body"
-                },
-                "link": 1706
-              },
-              {
-                "localized_name": "draw_hands",
-                "name": "draw_hands",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "draw_hands"
-                },
-                "link": 1707
-              },
-              {
-                "localized_name": "draw_face",
-                "name": "draw_face",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "draw_face"
-                },
-                "link": 1708
-              },
-              {
-                "localized_name": "draw_feet",
-                "name": "draw_feet",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "draw_feet"
-                },
-                "link": 1709
-              },
-              {
-                "localized_name": "stick_width",
-                "name": "stick_width",
-                "type": "INT",
-                "widget": {
-                  "name": "stick_width"
-                },
-                "link": 1710
-              },
-              {
-                "localized_name": "face_point_size",
-                "name": "face_point_size",
-                "type": "INT",
-                "widget": {
-                  "name": "face_point_size"
-                },
-                "link": 1711
-              },
-              {
-                "localized_name": "score_threshold",
-                "name": "score_threshold",
-                "type": "FLOAT",
-                "widget": {
-                  "name": "score_threshold"
-                },
-                "link": 1712
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "IMAGE",
-                "name": "IMAGE",
-                "type": "IMAGE",
-                "links": [
-                  1701
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "SDPoseDrawKeypoints",
-              "cnr_id": "comfy-core",
-              "ver": "0.15.0",
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "version": "7.7",
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              true,
-              true,
-              true,
-              true,
-              4,
-              2,
-              0.5
-            ]
-          },
-          {
-            "id": 673,
-            "type": "CheckpointLoaderSimple",
-            "pos": [
-              -2960,
-              3250
-            ],
-            "size": [
-              390,
-              190
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "ckpt_name",
-                "name": "ckpt_name",
-                "type": "COMBO",
-                "widget": {
-                  "name": "ckpt_name"
-                },
-                "link": 1713
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "MODEL",
-                "name": "MODEL",
-                "type": "MODEL",
-                "links": [
-                  1696
-                ]
-              },
-              {
-                "localized_name": "CLIP",
-                "name": "CLIP",
-                "type": "CLIP",
-                "links": []
-              },
-              {
-                "localized_name": "VAE",
-                "name": "VAE",
-                "type": "VAE",
-                "links": [
-                  1697
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "CheckpointLoaderSimple",
-              "cnr_id": "comfy-core",
-              "ver": "0.15.0",
-              "models": [
-                {
-                  "name": "sdpose_wholebody_fp16.safetensors",
-                  "url": "https://huggingface.co/Comfy-Org/SDPose/resolve/main/checkpoints/sdpose_wholebody_fp16.safetensors",
-                  "directory": "checkpoints"
-                }
-              ],
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "version": "7.7",
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              "sdpose_wholebody_fp16.safetensors"
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 1696,
-            "origin_id": 673,
-            "origin_slot": 0,
-            "target_id": 671,
-            "target_slot": 0,
-            "type": "MODEL"
-          },
-          {
-            "id": 1697,
-            "origin_id": 673,
-            "origin_slot": 2,
-            "target_id": 671,
-            "target_slot": 1,
-            "type": "VAE"
-          },
-          {
-            "id": 1698,
-            "origin_id": 674,
-            "origin_slot": 0,
-            "target_id": 671,
-            "target_slot": 2,
-            "type": "IMAGE"
-          },
-          {
-            "id": 1699,
-            "origin_id": 671,
-            "origin_slot": 0,
-            "target_id": 672,
-            "target_slot": 0,
-            "type": "POSE_KEYPOINT"
-          },
-          {
-            "id": 1700,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 674,
-            "target_slot": 0,
-            "type": "IMAGE,MASK"
-          },
-          {
-            "id": 1701,
-            "origin_id": 672,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 1704,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 674,
-            "target_slot": 2,
-            "type": "INT"
-          },
-          {
-            "id": 1705,
-            "origin_id": -10,
-            "origin_slot": 2,
-            "target_id": 674,
-            "target_slot": 3,
-            "type": "COMBO"
-          },
-          {
-            "id": 1706,
-            "origin_id": -10,
-            "origin_slot": 3,
-            "target_id": 672,
-            "target_slot": 1,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 1707,
-            "origin_id": -10,
-            "origin_slot": 4,
-            "target_id": 672,
-            "target_slot": 2,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 1708,
-            "origin_id": -10,
-            "origin_slot": 5,
-            "target_id": 672,
-            "target_slot": 3,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 1709,
-            "origin_id": -10,
-            "origin_slot": 6,
-            "target_id": 672,
-            "target_slot": 4,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 1710,
-            "origin_id": -10,
-            "origin_slot": 7,
-            "target_id": 672,
-            "target_slot": 5,
-            "type": "INT"
-          },
-          {
-            "id": 1711,
-            "origin_id": -10,
-            "origin_slot": 8,
-            "target_id": 672,
-            "target_slot": 6,
-            "type": "INT"
-          },
-          {
-            "id": 1712,
-            "origin_id": -10,
-            "origin_slot": 9,
-            "target_id": 672,
-            "target_slot": 7,
-            "type": "FLOAT"
-          },
-          {
-            "id": 1713,
-            "origin_id": -10,
-            "origin_slot": 10,
-            "target_id": 673,
-            "target_slot": 0,
-            "type": "COMBO"
-          },
-          {
-            "id": 1714,
-            "origin_id": -10,
-            "origin_slot": 11,
-            "target_id": 671,
-            "target_slot": 3,
-            "type": "BOUNDING_BOX"
-          },
-          {
-            "id": 1715,
-            "origin_id": 671,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 1,
-            "type": "POSE_KEYPOINT"
-          }
-        ],
-        "extra": {
-          "workflowRendererVersion": "LG"
-        },
-        "category": "Conditioning & Preprocessors/Pose",
-        "description": "Extracts human pose keypoints and stick-figure visuals from an image using SDPose-OOD, with optional bounding-box input per subject."
-      }
-    ]
-  },
-  "extra": {
-    "ue_links": []
-  }
-}
@@ -1298,7 +1298,7 @@
          "VHS_MetadataImage": true,
          "VHS_KeepIntermediate": true
        },
-        "category": "Image generation and editing/Conditioned",
+        "category": "Image generation and editing/Pose to image",
        "description": "Generates an image from pose keypoints using Z-Image-Turbo with text conditioning."
      }
    ]
@@ -3870,7 +3870,7 @@
        "extra": {
          "workflowRendererVersion": "LG"
        },
-        "category": "Video generation and editing/Conditioned",
+        "category": "Video generation and editing/Pose to video",
        "description": "Generates video from pose reference frames using LTX-2, with optional synchronized audio."
      }
    ]
@@ -270,7 +270,7 @@
        "extra": {
          "workflowRendererVersion": "LG"
        },
-        "category": "Text Tools",
+        "category": "Text generation/Prompt enhance",
        "description": "Expands short text prompts into detailed descriptions using a text generation model for better generation quality."
      }
    ]
@@ -389,7 +389,7 @@
          }
        ],
        "extra": {},
-        "category": "Image Tools/Background Removal"
+        "category": "Image generation and editing/Background Removal"
      }
    ]
  },
@@ -1,485 +0,0 @@
-{
-  "revision": 0,
-  "last_node_id": 10,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 10,
-      "type": "3fb7557a-470d-4983-9d8c-6d5caa9788f0",
-      "pos": [
-        -250,
-        8590
-      ],
-      "size": [
-        280,
-        360
-      ],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [
-        {
-          "localized_name": "text_per_line",
-          "name": "text_per_line",
-          "type": "STRING",
-          "widget": {
-            "name": "text_per_line"
-          },
-          "link": null
-        },
-        {
-          "localized_name": "index",
-          "name": "index",
-          "type": "INT",
-          "widget": {
-            "name": "index"
-          },
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "localized_name": "selected_line",
-          "name": "selected_line",
-          "type": "STRING",
-          "links": []
-        }
-      ],
-      "properties": {
-        "proxyWidgets": [
-          [
-            "2",
-            "string"
-          ],
-          [
-            "3",
-            "value"
-          ]
-        ],
-        "cnr_id": "comfy-core",
-        "ver": "0.19.0",
-        "ue_properties": {
-          "widget_ue_connectable": {},
-          "input_ue_unconnectable": {}
-        }
-      },
-      "widgets_values": [],
-      "title": "Select Per-Line Text by Index"
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "3fb7557a-470d-4983-9d8c-6d5caa9788f0",
-        "version": 1,
-        "state": {
-          "lastGroupId": 0,
-          "lastNodeId": 10,
-          "lastLinkId": 14,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "Select Per-Line Text by Index",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            -990,
-            8595,
-            128,
-            88
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            710,
-            8585,
-            128,
-            68
-          ]
-        },
-        "inputs": [
-          {
-            "id": "75417d82-a934-4ac9-b667-d8dcd5a3bfb3",
-            "name": "text_per_line",
-            "type": "STRING",
-            "linkIds": [
-              13
-            ],
-            "localized_name": "text_per_line",
-            "pos": [
-              -886,
-              8619
-            ]
-          },
-          {
-            "id": "46e69a73-1804-4ca6-9175-31445bf0be96",
-            "name": "index",
-            "type": "INT",
-            "linkIds": [
-              14
-            ],
-            "localized_name": "index",
-            "pos": [
-              -886,
-              8639
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "e34e8ad1-84d2-4bd2-a460-eb7de6067c10",
-            "name": "selected_line",
-            "type": "STRING",
-            "linkIds": [
-              10
-            ],
-            "localized_name": "selected_line",
-            "pos": [
-              734,
-              8609
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 1,
-            "type": "PreviewAny",
-            "pos": [
-              -500,
-              8400
-            ],
-            "size": [
-              230,
-              180
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "source",
-                "name": "source",
-                "type": "*",
-                "link": 1
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "STRING",
-                "name": "STRING",
-                "type": "STRING",
-                "links": [
-                  6
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "PreviewAny",
-              "cnr_id": "comfy-core",
-              "ver": "0.19.0",
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              null,
-              null,
-              null
-            ]
-          },
-          {
-            "id": 2,
-            "type": "RegexExtract",
-            "pos": [
-              -240,
-              8740
-            ],
-            "size": [
-              470,
-              460
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "showAdvanced": false,
-            "inputs": [
-              {
-                "localized_name": "string",
-                "name": "string",
-                "type": "STRING",
-                "widget": {
-                  "name": "string"
-                },
-                "link": 13
-              },
-              {
-                "localized_name": "regex_pattern",
-                "name": "regex_pattern",
-                "type": "STRING",
-                "widget": {
-                  "name": "regex_pattern"
-                },
-                "link": 9
-              },
-              {
-                "localized_name": "mode",
-                "name": "mode",
-                "type": "COMBO",
-                "widget": {
-                  "name": "mode"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "case_insensitive",
-                "name": "case_insensitive",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "case_insensitive"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "multiline",
-                "name": "multiline",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "multiline"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "dotall",
-                "name": "dotall",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "dotall"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "group_index",
-                "name": "group_index",
-                "type": "INT",
-                "widget": {
-                  "name": "group_index"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "STRING",
-                "name": "STRING",
-                "type": "STRING",
-                "links": [
-                  10
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "RegexExtract",
-              "cnr_id": "comfy-core",
-              "ver": "0.19.0",
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              "",
-              "",
-              "First Group",
-              false,
-              false,
-              false,
-              1
-            ]
-          },
-          {
-            "id": 3,
-            "type": "PrimitiveInt",
-            "pos": [
-              -810,
-              8400
-            ],
-            "size": [
-              270,
-              110
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "value",
-                "name": "value",
-                "type": "INT",
-                "widget": {
-                  "name": "value"
-                },
-                "link": 14
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "INT",
-                "name": "INT",
-                "type": "INT",
-                "links": [
-                  1
-                ]
-              }
-            ],
-            "title": "Int (line index)",
-            "properties": {
-              "Node name for S&R": "Int (line index)",
-              "cnr_id": "comfy-core",
-              "ver": "0.19.0",
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              0,
-              "fixed"
-            ]
-          },
-          {
-            "id": 8,
-            "type": "StringReplace",
-            "pos": [
-              -240,
-              8400
-            ],
-            "size": [
-              400,
-              280
-            ],
-            "flags": {},
-            "order": 3,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "string",
-                "name": "string",
-                "type": "STRING",
-                "widget": {
-                  "name": "string"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "find",
-                "name": "find",
-                "type": "STRING",
-                "widget": {
-                  "name": "find"
-                },
-                "link": null
-              },
-              {
-                "localized_name": "replace",
-                "name": "replace",
-                "type": "STRING",
-                "widget": {
-                  "name": "replace"
-                },
-                "link": 6
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "STRING",
-                "name": "STRING",
-                "type": "STRING",
-                "links": [
-                  9
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "StringReplace",
-              "cnr_id": "comfy-core",
-              "ver": "0.19.0",
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              "^(?:[^\\n]*\\n){index}([^\\n]*)(?:\\n|$)",
-              "index",
-              ""
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 1,
-            "origin_id": 3,
-            "origin_slot": 0,
-            "target_id": 1,
-            "target_slot": 0,
-            "type": "INT"
-          },
-          {
-            "id": 9,
-            "origin_id": 8,
-            "origin_slot": 0,
-            "target_id": 2,
-            "target_slot": 1,
-            "type": "STRING"
-          },
-          {
-            "id": 6,
-            "origin_id": 1,
-            "origin_slot": 0,
-            "target_id": 8,
-            "target_slot": 2,
-            "type": "STRING"
-          },
-          {
-            "id": 10,
-            "origin_id": 2,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "STRING"
-          },
-          {
-            "id": 13,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 2,
-            "target_slot": 0,
-            "type": "STRING"
-          },
-          {
-            "id": 14,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 3,
-            "target_slot": 0,
-            "type": "INT"
-          }
-        ],
-        "extra": {},
-        "category": "Text Tools",
-        "description": "Selects one line from multiline text by zero-based index for batch or list-driven prompt workflows."
-      }
-    ]
-  },
-  "extra": {
-    "ue_links": [],
-    "links_added_by_ue": []
-  }
-}
@@ -1,714 +0,0 @@
-{
-  "revision": 0,
-  "last_node_id": 251,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 251,
-      "type": "609e1fd1-b731-4b78-89ac-d19b1156b025",
-      "pos": [
-        -1490,
-        130
-      ],
-      "size": [
-        230,
-        164
-      ],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "inputs": [
-        {
-          "localized_name": "source_image",
-          "name": "source_image",
-          "type": "IMAGE",
-          "link": null
-        },
-        {
-          "localized_name": "columns",
-          "name": "columns",
-          "type": "INT",
-          "widget": {
-            "name": "columns"
-          },
-          "link": null
-        },
-        {
-          "localized_name": "rows",
-          "name": "rows",
-          "type": "INT",
-          "widget": {
-            "name": "rows"
-          },
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "localized_name": "tiles",
-          "name": "tiles",
-          "type": "IMAGE",
-          "links": []
-        }
-      ],
-      "properties": {
-        "proxyWidgets": [
-          [
-            "228",
-            "value"
-          ],
-          [
-            "252",
-            "value"
-          ]
-        ],
-        "cnr_id": "comfy-core",
-        "ver": "0.20.1",
-        "enableTabs": false,
-        "tabWidth": 65,
-        "tabXOffset": 10,
-        "hasSecondTab": false,
-        "secondTabText": "Send Back",
-        "secondTabOffset": 80,
-        "secondTabWidth": 65
-      },
-      "widgets_values": [],
-      "title": "Split Image Grid to Tiles"
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "609e1fd1-b731-4b78-89ac-d19b1156b025",
-        "version": 1,
-        "state": {
-          "lastGroupId": 9,
-          "lastNodeId": 252,
-          "lastLinkId": 429,
-          "lastRerouteId": 0
-        },
-        "revision": 0,
-        "config": {},
-        "name": "Split Image Grid to Tiles",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            -1690,
-            260,
-            128,
-            108
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            -510,
-            590,
-            128,
-            68
-          ]
-        },
-        "inputs": [
-          {
-            "id": "866ac798-cfbc-450a-b755-e704f86404d9",
-            "name": "source_image",
-            "type": "IMAGE",
-            "linkIds": [
-              386,
-              389
-            ],
-            "localized_name": "source_image",
-            "pos": [
-              -1586,
-              284
-            ]
-          },
-          {
-            "id": "bc37b1f8-8ab2-4f19-bd00-75d4fbc4feb3",
-            "name": "columns",
-            "type": "INT",
-            "linkIds": [
-              427
-            ],
-            "localized_name": "columns",
-            "pos": [
-              -1586,
-              304
-            ]
-          },
-          {
-            "id": "d45915da-e848-43dd-9ccc-e3161e9c99d9",
-            "name": "rows",
-            "type": "INT",
-            "linkIds": [
-              428
-            ],
-            "localized_name": "rows",
-            "pos": [
-              -1586,
-              324
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "18bc780f-064b-4038-87c6-67dba71deb08",
-            "name": "tiles",
-            "type": "IMAGE",
-            "linkIds": [
-              394
-            ],
-            "localized_name": "tiles",
-            "shape": 6,
-            "pos": [
-              -486,
-              614
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 225,
-            "type": "SplitImageToTileList",
-            "pos": [
-              -1010,
-              620
-            ],
-            "size": [
-              290,
-              170
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "image",
-                "name": "image",
-                "type": "IMAGE",
-                "link": 386
-              },
-              {
-                "localized_name": "tile_width",
-                "name": "tile_width",
-                "type": "INT",
-                "widget": {
-                  "name": "tile_width"
-                },
-                "link": 403
-              },
-              {
-                "localized_name": "tile_height",
-                "name": "tile_height",
-                "type": "INT",
-                "widget": {
-                  "name": "tile_height"
-                },
-                "link": 404
-              },
-              {
-                "localized_name": "overlap",
-                "name": "overlap",
-                "type": "INT",
-                "widget": {
-                  "name": "overlap"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "IMAGE",
-                "name": "IMAGE",
-                "shape": 6,
-                "type": "IMAGE",
-                "links": [
-                  394
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "SplitImageToTileList",
-              "cnr_id": "comfy-core",
-              "ver": "0.20.1",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65
-            },
-            "widgets_values": [
-              1024,
-              1024,
-              0
-            ]
-          },
-          {
-            "id": 231,
-            "type": "ComfyMathExpression",
-            "pos": [
-              -1080,
-              330
-            ],
-            "size": [
-              370,
-              190
-            ],
-            "flags": {},
-            "order": 4,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "a",
-                "localized_name": "values.a",
-                "name": "values.a",
-                "type": "FLOAT,INT,BOOLEAN",
-                "link": 390
-              },
-              {
-                "label": "b",
-                "localized_name": "values.b",
-                "name": "values.b",
-                "shape": 7,
-                "type": "FLOAT,INT,BOOLEAN",
-                "link": 429
-              },
-              {
-                "label": "c",
-                "localized_name": "values.c",
-                "name": "values.c",
-                "shape": 7,
-                "type": "FLOAT,INT,BOOLEAN",
-                "link": null
-              },
-              {
-                "localized_name": "expression",
-                "name": "expression",
-                "type": "STRING",
-                "widget": {
-                  "name": "expression"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "FLOAT",
-                "name": "FLOAT",
-                "type": "FLOAT",
-                "links": null
-              },
-              {
-                "localized_name": "INT",
-                "name": "INT",
-                "type": "INT",
-                "links": [
-                  404
-                ]
-              },
-              {
-                "localized_name": "BOOL",
-                "name": "BOOL",
-                "type": "BOOLEAN",
-                "links": null
-              }
-            ],
-            "title": "Math Expression （Height）",
-            "properties": {
-              "Node name for S&R": "ComfyMathExpression",
-              "cnr_id": "comfy-core",
-              "ver": "0.18.1",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "version": "7.7",
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              "max(1, (int(a) + int(b) - 1) // int(b))"
-            ]
-          },
-          {
-            "id": 229,
-            "type": "ComfyMathExpression",
-            "pos": [
-              -1090,
-              -30
-            ],
-            "size": [
-              370,
-              190
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-              {
-                "label": "a",
-                "localized_name": "values.a",
-                "name": "values.a",
-                "type": "FLOAT,INT,BOOLEAN",
-                "link": 387
-              },
-              {
-                "label": "b",
-                "localized_name": "values.b",
-                "name": "values.b",
-                "shape": 7,
-                "type": "FLOAT,INT,BOOLEAN",
-                "link": 388
-              },
-              {
-                "label": "c",
-                "localized_name": "values.c",
-                "name": "values.c",
-                "shape": 7,
-                "type": "FLOAT,INT,BOOLEAN",
-                "link": null
-              },
-              {
-                "localized_name": "expression",
-                "name": "expression",
-                "type": "STRING",
-                "widget": {
-                  "name": "expression"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "FLOAT",
-                "name": "FLOAT",
-                "type": "FLOAT",
-                "links": null
-              },
-              {
-                "localized_name": "INT",
-                "name": "INT",
-                "type": "INT",
-                "links": [
-                  403
-                ]
-              },
-              {
-                "localized_name": "BOOL",
-                "name": "BOOL",
-                "type": "BOOLEAN",
-                "links": null
-              }
-            ],
-            "title": "Math Expression （Width）",
-            "properties": {
-              "Node name for S&R": "ComfyMathExpression",
-              "cnr_id": "comfy-core",
-              "ver": "0.18.1",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "version": "7.7",
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              "max(1, (int(a) + int(b) - 1) // int(b))"
-            ]
-          },
-          {
-            "id": 228,
-            "type": "PrimitiveInt",
-            "pos": [
-              -1380,
-              90
-            ],
-            "size": [
-              230,
-              110
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "value",
-                "name": "value",
-                "type": "INT",
-                "widget": {
-                  "name": "value"
-                },
-                "link": 427
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "INT",
-                "name": "INT",
-                "type": "INT",
-                "links": [
-                  388
-                ]
-              }
-            ],
-            "title": "Int (grid columns)",
-            "properties": {
-              "Node name for S&R": "Int (grid columns)",
-              "cnr_id": "comfy-core",
-              "ver": "0.18.1",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "version": "7.7",
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              2,
-              "fixed"
-            ]
-          },
-          {
-            "id": 230,
-            "type": "GetImageSize",
-            "pos": [
-              -1380,
-              290
-            ],
-            "size": [
-              230,
-              100
-            ],
-            "flags": {},
-            "order": 3,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "image",
-                "name": "image",
-                "type": "IMAGE",
-                "link": 389
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "width",
-                "name": "width",
-                "type": "INT",
-                "links": [
-                  387
-                ]
-              },
-              {
-                "localized_name": "height",
-                "name": "height",
-                "type": "INT",
-                "links": [
-                  390
-                ]
-              },
-              {
-                "localized_name": "batch_size",
-                "name": "batch_size",
-                "type": "INT",
-                "links": null
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "GetImageSize",
-              "cnr_id": "comfy-core",
-              "ver": "0.18.1",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "version": "7.7",
-                "input_ue_unconnectable": {}
-              }
-            }
-          },
-          {
-            "id": 252,
-            "type": "PrimitiveInt",
-            "pos": [
-              -1380,
-              470
-            ],
-            "size": [
-              230,
-              110
-            ],
-            "flags": {},
-            "order": 5,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "value",
-                "name": "value",
-                "type": "INT",
-                "widget": {
-                  "name": "value"
-                },
-                "link": 428
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "INT",
-                "name": "INT",
-                "type": "INT",
-                "links": [
-                  429
-                ]
-              }
-            ],
-            "title": "Int (grid rows)",
-            "properties": {
-              "Node name for S&R": "Int (grid rows)",
-              "cnr_id": "comfy-core",
-              "ver": "0.18.1",
-              "enableTabs": false,
-              "tabWidth": 65,
-              "tabXOffset": 10,
-              "hasSecondTab": false,
-              "secondTabText": "Send Back",
-              "secondTabOffset": 80,
-              "secondTabWidth": 65,
-              "ue_properties": {
-                "widget_ue_connectable": {},
-                "version": "7.7",
-                "input_ue_unconnectable": {}
-              }
-            },
-            "widgets_values": [
-              3,
-              "fixed"
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 403,
-            "origin_id": 229,
-            "origin_slot": 1,
-            "target_id": 225,
-            "target_slot": 1,
-            "type": "INT"
-          },
-          {
-            "id": 404,
-            "origin_id": 231,
-            "origin_slot": 1,
-            "target_id": 225,
-            "target_slot": 2,
-            "type": "INT"
-          },
-          {
-            "id": 390,
-            "origin_id": 230,
-            "origin_slot": 1,
-            "target_id": 231,
-            "target_slot": 0,
-            "type": "INT"
-          },
-          {
-            "id": 387,
-            "origin_id": 230,
-            "origin_slot": 0,
-            "target_id": 229,
-            "target_slot": 0,
-            "type": "INT"
-          },
-          {
-            "id": 388,
-            "origin_id": 228,
-            "origin_slot": 0,
-            "target_id": 229,
-            "target_slot": 1,
-            "type": "INT"
-          },
-          {
-            "id": 386,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 225,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 389,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 230,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 394,
-            "origin_id": 225,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 427,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 228,
-            "target_slot": 0,
-            "type": "INT"
-          },
-          {
-            "id": 428,
-            "origin_id": -10,
-            "origin_slot": 2,
-            "target_id": 252,
-            "target_slot": 0,
-            "type": "INT"
-          },
-          {
-            "id": 429,
-            "origin_id": 252,
-            "origin_slot": 0,
-            "target_id": 231,
-            "target_slot": 1,
-            "type": "INT"
-          }
-        ],
-        "extra": {},
-        "category": "Image Tools/Crop",
-        "description": "Splits an image into a configurable columns×rows grid of equal tiles for tiled generation or processing."
-      }
-    ]
-  },
-  "extra": {}
-}
@@ -307,9 +307,9 @@
        "extra": {
          "workflowRendererVersion": "LG"
        },
-        "category": "Video Tools",
+        "category": "Text generation/Video Captioning",
        "description": "Generates descriptive captions for video input using Google's Gemini multimodal LLM."
      }
    ]
  }
-}
+}
@@ -1,825 +0,0 @@
-{
-  "revision": 0,
-  "last_node_id": 97,
-  "last_link_id": 0,
-  "nodes": [
-    {
-      "id": 97,
-      "type": "253ec5ca-8333-4ddf-a036-9fc0923651b9",
-      "pos": [
-        410,
-        500
-      ],
-      "size": [
-        400,
-        400
-      ],
-      "flags": {},
-      "order": 3,
-      "mode": 0,
-      "inputs": [
-        {
-          "name": "video",
-          "type": "VIDEO",
-          "link": null
-        },
-        {
-          "name": "start_time",
-          "type": "FLOAT",
-          "widget": {
-            "name": "start_time"
-          },
-          "link": null
-        },
-        {
-          "name": "duration",
-          "type": "FLOAT",
-          "widget": {
-            "name": "duration"
-          },
-          "link": null
-        },
-        {
-          "name": "resolution",
-          "type": "INT",
-          "widget": {
-            "name": "resolution"
-          },
-          "link": null
-        },
-        {
-          "name": "resize_method",
-          "type": "COMBO",
-          "widget": {
-            "name": "resize_method"
-          },
-          "link": null
-        },
-        {
-          "label": "output_type",
-          "name": "output",
-          "type": "COMFY_DYNAMICCOMBO_V3",
-          "widget": {
-            "name": "output"
-          },
-          "link": null
-        },
-        {
-          "label": "normalization",
-          "name": "output.normalization",
-          "type": "COMBO",
-          "widget": {
-            "name": "output.normalization"
-          },
-          "link": null
-        },
-        {
-          "name": "output.apply_sky_clip",
-          "type": "BOOLEAN",
-          "widget": {
-            "name": "output.apply_sky_clip"
-          },
-          "link": null
-        },
-        {
-          "name": "model_name",
-          "type": "COMBO",
-          "widget": {
-            "name": "model_name"
-          },
-          "link": null
-        }
-      ],
-      "outputs": [
-        {
-          "localized_name": "IMAGE",
-          "name": "IMAGE",
-          "type": "IMAGE",
-          "links": []
-        },
-        {
-          "name": "audio",
-          "type": "AUDIO",
-          "links": []
-        },
-        {
-          "name": "fps",
-          "type": "FLOAT",
-          "links": []
-        }
-      ],
-      "properties": {
-        "proxyWidgets": [
-          [
-            "96",
-            "start_time"
-          ],
-          [
-            "96",
-            "duration"
-          ],
-          [
-            "93",
-            "resolution"
-          ],
-          [
-            "93",
-            "resize_method"
-          ],
-          [
-            "92",
-            "output"
-          ],
-          [
-            "92",
-            "output.normalization"
-          ],
-          [
-            "92",
-            "output.apply_sky_clip"
-          ],
-          [
-            "94",
-            "model_name"
-          ]
-        ],
-        "cnr_id": "comfy-core",
-        "ver": "0.24.0"
-      },
-      "widgets_values": [],
-      "title": "Video Depth Estimation (Depth Anything 3)"
-    }
-  ],
-  "links": [],
-  "version": 0.4,
-  "definitions": {
-    "subgraphs": [
-      {
-        "id": "253ec5ca-8333-4ddf-a036-9fc0923651b9",
-        "version": 1,
-        "state": {
-          "lastGroupId": 4,
-          "lastNodeId": 97,
-          "lastLinkId": 129,
-          "lastRerouteId": 0
-        },
-        "revision": 2,
-        "config": {},
-        "name": "Video Depth Estimation (Depth Anything 3)",
-        "inputNode": {
-          "id": -10,
-          "bounding": [
-            -230,
-            130,
-            167.912109375,
-            228
-          ]
-        },
-        "outputNode": {
-          "id": -20,
-          "bounding": [
-            1520,
-            140,
-            128,
-            108
-          ]
-        },
-        "inputs": [
-          {
-            "id": "698c28c6-cf92-4039-8b39-f3062868ea7c",
-            "name": "video",
-            "type": "VIDEO",
-            "linkIds": [
-              119
-            ],
-            "pos": [
-              -86.087890625,
-              154
-            ]
-          },
-          {
-            "id": "97a1f63e-1585-4a40-9dec-e2700120d84a",
-            "name": "start_time",
-            "type": "FLOAT",
-            "linkIds": [
-              121
-            ],
-            "pos": [
-              -86.087890625,
-              174
-            ]
-          },
-          {
-            "id": "4dbbd3b3-c5ee-4a56-a0d3-3268d3b2fd64",
-            "name": "duration",
-            "type": "FLOAT",
-            "linkIds": [
-              122
-            ],
-            "pos": [
-              -86.087890625,
-              194
-            ]
-          },
-          {
-            "id": "16f55101-f99d-4c0c-bebf-c3b31c54f13e",
-            "name": "resolution",
-            "type": "INT",
-            "linkIds": [
-              124
-            ],
-            "pos": [
-              -86.087890625,
-              214
-            ]
-          },
-          {
-            "id": "d9cd7693-4bb3-4ed7-9a75-276b997abcd9",
-            "name": "resize_method",
-            "type": "COMBO",
-            "linkIds": [
-              125
-            ],
-            "pos": [
-              -86.087890625,
-              234
-            ]
-          },
-          {
-            "id": "a6e90532-323b-462e-ba9c-1672384d5b31",
-            "name": "output",
-            "type": "COMFY_DYNAMICCOMBO_V3",
-            "linkIds": [
-              126
-            ],
-            "label": "output_type",
-            "pos": [
-              -86.087890625,
-              254
-            ]
-          },
-          {
-            "id": "69e6aeef-437d-4fde-b2fc-d5ab9369238d",
-            "name": "output.normalization",
-            "type": "COMBO",
-            "linkIds": [
-              127
-            ],
-            "label": "normalization",
-            "pos": [
-              -86.087890625,
-              274
-            ]
-          },
-          {
-            "id": "73206f72-f89a-4698-885e-5d9277df2998",
-            "name": "output.apply_sky_clip",
-            "type": "BOOLEAN",
-            "linkIds": [
-              128
-            ],
-            "pos": [
-              -86.087890625,
-              294
-            ]
-          },
-          {
-            "id": "dddbc7fc-9431-448a-9ed3-9aa62404288b",
-            "name": "model_name",
-            "type": "COMBO",
-            "linkIds": [
-              129
-            ],
-            "pos": [
-              -86.087890625,
-              314
-            ]
-          }
-        ],
-        "outputs": [
-          {
-            "id": "478ab537-63bc-4d74-a9f0-c975f550880f",
-            "name": "IMAGE",
-            "type": "IMAGE",
-            "linkIds": [
-              7
-            ],
-            "localized_name": "IMAGE",
-            "pos": [
-              1544,
-              164
-            ]
-          },
-          {
-            "id": "cdaf037e-79bc-4a94-b06c-0fd32e76f615",
-            "name": "audio",
-            "type": "AUDIO",
-            "linkIds": [
-              112
-            ],
-            "pos": [
-              1544,
-              184
-            ]
-          },
-          {
-            "id": "4c0e5484-d193-49c7-b107-92619628880a",
-            "name": "fps",
-            "type": "FLOAT",
-            "linkIds": [
-              113
-            ],
-            "pos": [
-              1544,
-              204
-            ]
-          }
-        ],
-        "widgets": [],
-        "nodes": [
-          {
-            "id": 92,
-            "type": "DA3Render",
-            "pos": [
-              740,
-              230
-            ],
-            "size": [
-              380,
-              130
-            ],
-            "flags": {},
-            "order": 0,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "da3_geometry",
-                "name": "da3_geometry",
-                "type": "DA3_GEOMETRY",
-                "link": 12
-              },
-              {
-                "localized_name": "output",
-                "name": "output",
-                "type": "COMFY_DYNAMICCOMBO_V3",
-                "widget": {
-                  "name": "output"
-                },
-                "link": 126
-              },
-              {
-                "localized_name": "output.normalization",
-                "name": "output.normalization",
-                "type": "COMBO",
-                "widget": {
-                  "name": "output.normalization"
-                },
-                "link": 127
-              },
-              {
-                "localized_name": "output.apply_sky_clip",
-                "name": "output.apply_sky_clip",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "output.apply_sky_clip"
-                },
-                "link": 128
-              },
-              {
-                "name": "geometry",
-                "type": "DA3_GEOMETRY",
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "IMAGE",
-                "name": "IMAGE",
-                "type": "IMAGE",
-                "slot_index": 0,
-                "links": [
-                  7
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "DA3Render",
-              "cnr_id": "comfy-core",
-              "ver": "0.19.0"
-            },
-            "widgets_values": [
-              "depth",
-              "v2_style",
-              false
-            ]
-          },
-          {
-            "id": 93,
-            "type": "DA3Inference",
-            "pos": [
-              740,
-              -30
-            ],
-            "size": [
-              390,
-              130
-            ],
-            "flags": {},
-            "order": 1,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "da3_model",
-                "name": "da3_model",
-                "type": "DA3_MODEL",
-                "link": 107
-              },
-              {
-                "localized_name": "image",
-                "name": "image",
-                "type": "IMAGE",
-                "link": 111
-              },
-              {
-                "localized_name": "resolution",
-                "name": "resolution",
-                "type": "INT",
-                "widget": {
-                  "name": "resolution"
-                },
-                "link": 124
-              },
-              {
-                "localized_name": "resize_method",
-                "name": "resize_method",
-                "type": "COMBO",
-                "widget": {
-                  "name": "resize_method"
-                },
-                "link": 125
-              },
-              {
-                "localized_name": "mode",
-                "name": "mode",
-                "type": "COMFY_DYNAMICCOMBO_V3",
-                "widget": {
-                  "name": "mode"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "da3_geometry",
-                "name": "da3_geometry",
-                "type": "DA3_GEOMETRY",
-                "slot_index": 0,
-                "links": [
-                  12
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "DA3Inference",
-              "cnr_id": "comfy-core",
-              "ver": "0.19.0"
-            },
-            "widgets_values": [
-              504,
-              "lower_bound_resize",
-              "mono"
-            ]
-          },
-          {
-            "id": 94,
-            "type": "LoadDA3Model",
-            "pos": [
-              50,
-              410
-            ],
-            "size": [
-              400,
-              140
-            ],
-            "flags": {},
-            "order": 2,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "model_name",
-                "name": "model_name",
-                "type": "COMBO",
-                "widget": {
-                  "name": "model_name"
-                },
-                "link": 129
-              },
-              {
-                "localized_name": "weight_dtype",
-                "name": "weight_dtype",
-                "type": "COMBO",
-                "widget": {
-                  "name": "weight_dtype"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "DA3_MODEL",
-                "name": "DA3_MODEL",
-                "type": "DA3_MODEL",
-                "links": [
-                  107
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "LoadDA3Model",
-              "cnr_id": "comfy-core",
-              "ver": "0.24.0",
-              "models": [
-                {
-                  "name": "depth_anything_3_mono_large.safetensors",
-                  "url": "https://huggingface.co/Comfy-Org/Depth-Anything-3/resolve/main/geometry_estimation/depth_anything_3_mono_large.safetensors",
-                  "directory": "geometry_estimation"
-                }
-              ]
-            },
-            "widgets_values": [
-              "depth_anything_3_mono_large.safetensors",
-              "default"
-            ]
-          },
-          {
-            "id": 95,
-            "type": "GetVideoComponents",
-            "pos": [
-              70,
-              -140
-            ],
-            "size": [
-              260,
-              120
-            ],
-            "flags": {},
-            "order": 3,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "video",
-                "name": "video",
-                "type": "VIDEO",
-                "link": 120
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "images",
-                "name": "images",
-                "type": "IMAGE",
-                "links": [
-                  111
-                ]
-              },
-              {
-                "localized_name": "audio",
-                "name": "audio",
-                "type": "AUDIO",
-                "links": [
-                  112
-                ]
-              },
-              {
-                "localized_name": "fps",
-                "name": "fps",
-                "type": "FLOAT",
-                "links": [
-                  113
-                ]
-              },
-              {
-                "localized_name": "bit_depth",
-                "name": "bit_depth",
-                "type": "INT",
-                "links": null
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "GetVideoComponents",
-              "cnr_id": "comfy-core",
-              "ver": "0.24.0"
-            }
-          },
-          {
-            "id": 96,
-            "type": "Video Slice",
-            "pos": [
-              70,
-              -360
-            ],
-            "size": [
-              270,
-              170
-            ],
-            "flags": {},
-            "order": 4,
-            "mode": 0,
-            "inputs": [
-              {
-                "localized_name": "video",
-                "name": "video",
-                "type": "VIDEO",
-                "link": 119
-              },
-              {
-                "localized_name": "start_time",
-                "name": "start_time",
-                "type": "FLOAT",
-                "widget": {
-                  "name": "start_time"
-                },
-                "link": 121
-              },
-              {
-                "localized_name": "duration",
-                "name": "duration",
-                "type": "FLOAT",
-                "widget": {
-                  "name": "duration"
-                },
-                "link": 122
-              },
-              {
-                "localized_name": "strict_duration",
-                "name": "strict_duration",
-                "type": "BOOLEAN",
-                "widget": {
-                  "name": "strict_duration"
-                },
-                "link": null
-              }
-            ],
-            "outputs": [
-              {
-                "localized_name": "VIDEO",
-                "name": "VIDEO",
-                "type": "VIDEO",
-                "links": [
-                  120
-                ]
-              }
-            ],
-            "properties": {
-              "Node name for S&R": "Video Slice",
-              "cnr_id": "comfy-core",
-              "ver": "0.24.0"
-            },
-            "widgets_values": [
-              0,
-              5,
-              false
-            ]
-          }
-        ],
-        "groups": [],
-        "links": [
-          {
-            "id": 12,
-            "origin_id": 93,
-            "origin_slot": 0,
-            "target_id": 92,
-            "target_slot": 0,
-            "type": "DA3_GEOMETRY"
-          },
-          {
-            "id": 7,
-            "origin_id": 92,
-            "origin_slot": 0,
-            "target_id": -20,
-            "target_slot": 0,
-            "type": "IMAGE"
-          },
-          {
-            "id": 107,
-            "origin_id": 94,
-            "origin_slot": 0,
-            "target_id": 93,
-            "target_slot": 0,
-            "type": "DA3_MODEL"
-          },
-          {
-            "id": 111,
-            "origin_id": 95,
-            "origin_slot": 0,
-            "target_id": 93,
-            "target_slot": 1,
-            "type": "IMAGE"
-          },
-          {
-            "id": 112,
-            "origin_id": 95,
-            "origin_slot": 1,
-            "target_id": -20,
-            "target_slot": 1,
-            "type": "AUDIO"
-          },
-          {
-            "id": 113,
-            "origin_id": 95,
-            "origin_slot": 2,
-            "target_id": -20,
-            "target_slot": 2,
-            "type": "FLOAT"
-          },
-          {
-            "id": 119,
-            "origin_id": -10,
-            "origin_slot": 0,
-            "target_id": 96,
-            "target_slot": 0,
-            "type": "VIDEO"
-          },
-          {
-            "id": 120,
-            "origin_id": 96,
-            "origin_slot": 0,
-            "target_id": 95,
-            "target_slot": 0,
-            "type": "VIDEO"
-          },
-          {
-            "id": 121,
-            "origin_id": -10,
-            "origin_slot": 1,
-            "target_id": 96,
-            "target_slot": 1,
-            "type": "FLOAT"
-          },
-          {
-            "id": 122,
-            "origin_id": -10,
-            "origin_slot": 2,
-            "target_id": 96,
-            "target_slot": 2,
-            "type": "FLOAT"
-          },
-          {
-            "id": 124,
-            "origin_id": -10,
-            "origin_slot": 3,
-            "target_id": 93,
-            "target_slot": 2,
-            "type": "INT"
-          },
-          {
-            "id": 125,
-            "origin_id": -10,
-            "origin_slot": 4,
-            "target_id": 93,
-            "target_slot": 3,
-            "type": "COMBO"
-          },
-          {
-            "id": 126,
-            "origin_id": -10,
-            "origin_slot": 5,
-            "target_id": 92,
-            "target_slot": 1,
-            "type": "COMFY_DYNAMICCOMBO_V3"
-          },
-          {
-            "id": 127,
-            "origin_id": -10,
-            "origin_slot": 6,
-            "target_id": 92,
-            "target_slot": 2,
-            "type": "COMBO"
-          },
-          {
-            "id": 128,
-            "origin_id": -10,
-            "origin_slot": 7,
-            "target_id": 92,
-            "target_slot": 3,
-            "type": "BOOLEAN"
-          },
-          {
-            "id": 129,
-            "origin_id": -10,
-            "origin_slot": 8,
-            "target_id": 94,
-            "target_slot": 0,
-            "type": "COMBO"
-          }
-        ],
-        "extra": {},
-        "category": "Conditioning & Preprocessors/Depth",
-        "description": "This subgraph processes a video input through Depth Anything 3 to produce temporally consistent depth maps for each frame, outputting a depth video. It is ideal for video content requiring spatial geometry estimation, such as 3D reconstruction, SLAM, or novel view synthesis from moving cameras. The model uses a plain transformer backbone trained with a depth-ray representation, supporting any number of views without requiring known camera poses."
-      }
-    ]
-  },
-  "extra": {
-    "BlueprintDescription": "This subgraph processes a video input through Depth Anything 3 to produce temporally consistent depth maps for each frame, outputting a depth video. It is ideal for video content requiring spatial geometry estimation, such as 3D reconstruction, SLAM, or novel view synthesis from moving cameras. The model uses a plain transformer backbone trained with a depth-ray representation, supporting any number of views without requiring known camera poses."
-  }
-}
@@ -818,7 +818,7 @@
          }
        ],
        "extra": {},
-        "category": "Conditioning & Preprocessors/Segmentation & Mask",
+        "category": "Video Tools",
        "description": "Segments video into temporally consistent masks using Meta SAM3 from text or interactive prompts."
      }
    ]
@@ -412,7 +412,7 @@
        "extra": {
          "workflowRendererVersion": "LG"
        },
-        "category": "Video generation and editing/Upscale",
+        "category": "Video generation and editing/Enhance video",
        "description": "Upscales video to 4× resolution using a GAN-based upscaling model."
      }
    ]
@@ -105,7 +105,7 @@ class WindowAttention(nn.Module):

        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.long().view(-1)].view(
            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
-        relative_position_bias = comfy.ops.cast_to_input(relative_position_bias.permute(2, 0, 1).contiguous(), attn)  # nH, Wh*Ww, Wh*Ww
+        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
        attn = attn + relative_position_bias.unsqueeze(0)

        if mask is not None:
@@ -44,18 +44,16 @@ class BackgroundRemovalModel():
        comfy.model_management.load_model_gpu(self.patcher)
        H, W = image.shape[1], image.shape[2]
        pixel_values = comfy.clip_model.clip_preprocess(image.to(self.load_device), size=self.image_size, mean=self.image_mean, std=self.image_std, crop=False)
-
-        if pixel_values.shape[0] > 1:
-            out = torch.cat([
-                self.model(pixel_values=pixel_values[i:i+1])
-                for i in range(pixel_values.shape[0])
-            ], dim=0)
-        else:
-            out = self.model(pixel_values=pixel_values)
+        out = self.model(pixel_values=pixel_values)
        out = torch.nn.functional.interpolate(out, size=(H, W), mode="bicubic", antialias=False)

        mask = out.sigmoid().to(device=comfy.model_management.intermediate_device(), dtype=comfy.model_management.intermediate_dtype())
-        return mask.squeeze(1)  # (B, 1, H, W) -> (B, H, W)
+        if mask.ndim == 3:
+            mask = mask.unsqueeze(0)
+        if mask.shape[1] != 1:
+            mask = mask.movedim(-1, 1)
+
+        return mask


 def load_background_removal_model(sd):
@@ -49,7 +49,7 @@ parser.add_argument("--temp-directory", type=str, default=None, help="Set the Co
 parser.add_argument("--input-directory", type=str, default=None, help="Set the ComfyUI input directory. Overrides --base-directory.")
 parser.add_argument("--auto-launch", action="store_true", help="Automatically launch ComfyUI in the default browser.")
 parser.add_argument("--disable-auto-launch", action="store_true", help="Disable auto launching the browser.")
-parser.add_argument("--cuda-device", type=str, default=None, metavar="DEVICE_ID", help="Set the ids of cuda devices this instance will use, as a comma-separated list (e.g. '0' or '0,1'). All other devices will not be visible.")
+parser.add_argument("--cuda-device", type=int, default=None, metavar="DEVICE_ID", help="Set the id of the cuda device this instance will use. All other devices will not be visible.")
 parser.add_argument("--default-device", type=int, default=None, metavar="DEFAULT_DEVICE_ID", help="Set the id of the default device, all other devices will stay visible.")
 cm_group = parser.add_mutually_exclusive_group()
 cm_group.add_argument("--cuda-malloc", action="store_true", help="Enable cudaMallocAsync (enabled by default for torch 2.0 and up).")
@@ -110,12 +110,13 @@ 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-ram", nargs='*', type=float, default=[], metavar="GB", help="Use RAM pressure caching with the specified headroom thresholds. This is the default caching mode. The first value sets the active-cache threshold; the optional second value sets the inactive-cache/pin threshold. Defaults when no values are provided: active 10%% of system RAM (min 2GB, max 10GB), inactive 100%% of system RAM (max 96GB).")
 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("--high-ram", action="store_true", help="Can improve performance slightly on high RAM or on systems where pagefile use is preferred over model loading.")
+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).")

 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.")
@@ -134,24 +135,23 @@ upcast.add_argument("--dont-upcast-attention", action="store_true", help="Disabl
 parser.add_argument("--enable-manager", action="store_true", help="Enable the ComfyUI-Manager feature.")
 manager_group = parser.add_mutually_exclusive_group()
 manager_group.add_argument("--disable-manager-ui", action="store_true", help="Disables only the ComfyUI-Manager UI and endpoints. Scheduled installations and similar background tasks will still operate.")
-manager_group.add_argument("--enable-manager-legacy-ui", action="store_true", help="Enables the legacy UI of ComfyUI-Manager. Implies --enable-manager.")
+manager_group.add_argument("--enable-manager-legacy-ui", action="store_true", help="Enables the legacy UI of ComfyUI-Manager")


 vram_group = parser.add_mutually_exclusive_group()
 vram_group.add_argument("--gpu-only", action="store_true", help="Store and run everything (text encoders/CLIP models, etc... on the GPU).")
 vram_group.add_argument("--highvram", action="store_true", help="By default models will be unloaded to CPU memory after being used. This option keeps them in GPU memory.")
-vram_group.add_argument("--lowvram", action="store_true", help="Doesn't do anything if dynamic vram is enabled. If dynamic vram isn't being used this option makes the text encoders run on the CPU.")
+vram_group.add_argument("--normalvram", action="store_true", help="Used to force normal vram use if lowvram gets automatically enabled.")
+vram_group.add_argument("--lowvram", action="store_true", help="Split the unet in parts to use less vram.")
 vram_group.add_argument("--novram", action="store_true", help="When lowvram isn't enough.")
 vram_group.add_argument("--cpu", action="store_true", help="To use the CPU for everything (slow).")

 parser.add_argument("--reserve-vram", type=float, default=None, help="Set the amount of vram in GB you want to reserve for use by your OS/other software. By default some amount is reserved depending on your OS.")
-parser.add_argument("--vram-headroom", type=float, default=0, help="Set the amount of vram in GB for DynamicVRAM to maintain as extra headroom above default. ComfyUI will try and keep this much VRAM completely free and unused, even counting VRAM from other apps.")

 parser.add_argument("--async-offload", nargs='?', const=2, type=int, default=None, metavar="NUM_STREAMS", help="Use async weight offloading. An optional argument controls the amount of offload streams. Default is 2. Enabled by default on Nvidia.")
 parser.add_argument("--disable-async-offload", action="store_true", help="Disable async weight offloading.")
 parser.add_argument("--disable-dynamic-vram", action="store_true", help="Disable dynamic VRAM and use estimate based model loading.")
 parser.add_argument("--enable-dynamic-vram", action="store_true", help="Enable dynamic VRAM on systems where it's not enabled by default.")
-parser.add_argument("--fast-disk", action="store_true", help="Prefer disk-backed dynamic loading and offload over unpinned RAM. Can be faster for users with fast NVME disks.")

 parser.add_argument("--force-non-blocking", action="store_true", help="Force ComfyUI to use non-blocking operations for all applicable tensors. This may improve performance on some non-Nvidia systems but can cause issues with some workflows.")

@@ -168,8 +168,6 @@ class PerformanceFeature(enum.Enum):

 parser.add_argument("--fast", nargs="*", type=PerformanceFeature, help="Enable some untested and potentially quality deteriorating optimizations. This is used to test new features so using it might crash your comfyui. --fast with no arguments enables everything. You can pass a list specific optimizations if you only want to enable specific ones. Current valid optimizations: {}".format(" ".join(map(lambda c: c.value, PerformanceFeature))))

-parser.add_argument("--debug-hang", action="store_true", help="Enable stack trace dumps on Ctrl-C for debugging hangs.")
-
 parser.add_argument("--disable-pinned-memory", action="store_true", help="Disable pinned memory use.")

 parser.add_argument("--mmap-torch-files", action="store_true", help="Use mmap when loading ckpt/pt files.")
@@ -225,7 +223,6 @@ parser.add_argument(
 )

 parser.add_argument("--user-directory", type=is_valid_directory, default=None, help="Set the ComfyUI user directory with an absolute path. Overrides --base-directory.")
-parser.add_argument("--models-directory", type=is_valid_directory, default=None, help="Set the ComfyUI models directory. Overrides the models folder in --base-directory.")

 parser.add_argument("--enable-compress-response-body", action="store_true", help="Enable compressing response body.")

@@ -241,7 +238,6 @@ database_default_path = os.path.abspath(
 )
 parser.add_argument("--database-url", type=str, default=f"sqlite:///{database_default_path}", help="Specify the database URL, e.g. for an in-memory database you can use 'sqlite:///:memory:'.")
 parser.add_argument("--enable-assets", action="store_true", help="Enable the assets system (API routes, database synchronization, and background scanning).")
-parser.add_argument("--enable-asset-hashing", action="store_true", help="Compute blake3 content hashes when scanning assets. Hashing enables future asset-portability features (deduplication, cross-machine model resolution) but adds startup cost and per-output cost on large models directories. Off by default; enable to opt in.")
 parser.add_argument("--feature-flag", type=str, action='append', default=[], metavar="KEY[=VALUE]", help="Set a server feature flag. Use KEY=VALUE to set an explicit value, or bare KEY to set it to true. Can be specified multiple times. Boolean values (true/false) and numbers are auto-converted. Examples: --feature-flag show_signin_button=true  or  --feature-flag show_signin_button")
 parser.add_argument("--list-feature-flags", action="store_true", help="Print the registry of known CLI-settable feature flags as JSON and exit.")

@@ -250,12 +246,6 @@ if comfy.options.args_parsing:
 else:
    args = parser.parse_args([])

-if args.cache_ram is not None and len(args.cache_ram) > 2:
-    parser.error("--cache-ram accepts at most two values: active GB and inactive GB")
-
-if args.high_ram:
-    args.cache_classic = True
-
 if args.windows_standalone_build:
    args.auto_launch = True

@@ -265,10 +255,6 @@ if args.disable_auto_launch:
 if args.force_fp16:
    args.fp16_unet = True

-# '--enable-manager-legacy-ui' is meaningless unless the manager is enabled, so imply '--enable-manager'.
-if args.enable_manager_legacy_ui:
-    args.enable_manager = True
-

 # '--fast' is not provided, use an empty set
 if args.fast is None:
@@ -9,7 +9,6 @@ import comfy.model_management
 import comfy.utils
 import comfy.clip_model
 import comfy.image_encoders.dino2
-import comfy.image_encoders.dino3

 class Output:
    def __getitem__(self, key):
@@ -24,16 +23,12 @@ IMAGE_ENCODERS = {
    "siglip_vision_model": comfy.clip_model.CLIPVisionModelProjection,
    "siglip2_vision_model": comfy.clip_model.CLIPVisionModelProjection,
    "dinov2": comfy.image_encoders.dino2.Dinov2Model,
-    "dinov3": comfy.image_encoders.dino3.DINOv3ViTModel,
 }

 class ClipVisionModel():
    def __init__(self, json_config):
-        if isinstance(json_config, dict):
-            config = json_config
-        else:
-            with open(json_config) as f:
-                config = json.load(f)
+        with open(json_config) as f:
+            config = json.load(f)

        self.image_size = config.get("image_size", 224)
        self.image_mean = config.get("image_mean", [0.48145466, 0.4578275, 0.40821073])
@@ -139,8 +134,6 @@ def load_clipvision_from_sd(sd, prefix="", convert_keys=False):
        json_config = os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), "image_encoders"), "dino2_giant.json")
    elif 'encoder.layer.23.layer_scale2.lambda1' in sd:
        json_config = os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), "image_encoders"), "dino2_large.json")
-    elif 'layer.0.mlp.gate_proj.weight' in sd and 'layer.31.norm1.weight' in sd: # Dinov3 ViT-H/16+ (SwiGLU gated MLP, 32 layers)
-        json_config = comfy.image_encoders.dino3.DINOV3_VITH_CONFIG
    else:
        return None

@@ -1,5 +1,6 @@
 """Comfy-specific type hinting"""

+from __future__ import annotations
 from typing import Literal, TypedDict, Optional
 from typing_extensions import NotRequired
 from abc import ABC, abstractmethod
@@ -8,8 +8,6 @@ from abc import ABC, abstractmethod
 import logging
 import comfy.model_management
 import comfy.patcher_extension
-import comfy.utils
-import comfy.conds
 if TYPE_CHECKING:
    from comfy.model_base import BaseModel
    from comfy.model_patcher import ModelPatcher
@@ -53,18 +51,12 @@ class ContextHandlerABC(ABC):


 class IndexListContextWindow(ContextWindowABC):
-    def __init__(self, index_list: list[int], dim: int=0, total_frames: int=0, modality_windows: dict=None, context_overlap: int=0):
+    def __init__(self, index_list: list[int], dim: int=0, total_frames: int=0):
        self.index_list = index_list
        self.context_length = len(index_list)
-        self.context_overlap = context_overlap
        self.dim = dim
        self.total_frames = total_frames
        self.center_ratio = (min(index_list) + max(index_list)) / (2 * total_frames)
-        self.modality_windows = modality_windows  # dict of {mod_idx: IndexListContextWindow}
-        self.guide_frames_indices: list[int] = []
-        self.guide_overlap_info: list[tuple[int, int]] = []
-        self.guide_kf_local_positions: list[int] = []
-        self.guide_downscale_factors: list[int] = []

    def get_tensor(self, full: torch.Tensor, device=None, dim=None, retain_index_list=[]) -> torch.Tensor:
        if dim is None:
@@ -93,11 +85,6 @@ class IndexListContextWindow(ContextWindowABC):
        region_idx = int(self.center_ratio * num_regions)
        return min(max(region_idx, 0), num_regions - 1)

-    def get_window_for_modality(self, modality_idx: int) -> 'IndexListContextWindow':
-        if modality_idx == 0:
-            return self
-        return self.modality_windows[modality_idx]
-

 class IndexListCallbacks:
    EVALUATE_CONTEXT_WINDOWS = "evaluate_context_windows"
@@ -161,172 +148,6 @@ def slice_cond(cond_value, window: IndexListContextWindow, x_in: torch.Tensor, d
    return cond_value._copy_with(sliced)


-def compute_guide_overlap(guide_entries: list[dict], keyframe_idxs: torch.Tensor, temporal_downscale_ratio: int, window_index_list: list[int]):
-    """Compute which concatenated guide frames overlap with a context window.
-
-    Each guide's latent-space start is derived from its first token's pixel-t-start
-    in keyframe_idxs (shape (B, [t,h,w], num_tokens, [start, end])), divided by the
-    model's temporal_downscale_ratio.
-
-    Args:
-        guide_entries: list of guide_attention_entry dicts
-        keyframe_idxs: per-token pixel coords cond tensor for the modality
-        temporal_downscale_ratio: model's pixel-to-latent temporal compression ratio
-        window_index_list: the window's frame indices into the video portion
-
-    Returns:
-        suffix_indices: indices into the guide_frames tensor for frame selection
-        overlap_info: list of (entry_idx, overlap_count) for guide_attention_entries adjustment
-        kf_local_positions: window-local frame positions for keyframe_idxs regeneration
-        total_overlap: total number of overlapping guide frames
-    """
-    window_set = set(window_index_list)
-    window_list = list(window_index_list)
-    suffix_indices = []
-    overlap_info = []
-    kf_local_positions = []
-    suffix_base = 0
-    token_offset = 0
-
-    for entry_idx, entry in enumerate(guide_entries):
-        first_t_pixel = int(keyframe_idxs[0, 0, token_offset, 0].item())
-        latent_start = (first_t_pixel + temporal_downscale_ratio - 1) // temporal_downscale_ratio
-        guide_len = entry["latent_shape"][0]
-        entry_overlap = 0
-
-        for local_offset in range(guide_len):
-            video_pos = latent_start + local_offset
-            if video_pos in window_set:
-                suffix_indices.append(suffix_base + local_offset)
-                kf_local_positions.append(window_list.index(video_pos))
-                entry_overlap += 1
-
-        if entry_overlap > 0:
-            overlap_info.append((entry_idx, entry_overlap))
-        suffix_base += guide_len
-        token_offset += entry["pre_filter_count"]
-
-    return suffix_indices, overlap_info, kf_local_positions, len(suffix_indices)
-
-
-@dataclass
-class WindowingState:
-    """Per-modality context windowing state for each step,
-    built using IndexListContextHandler._build_window_state().
-    For non-multimodal models the lists are length 1
-    """
-    latents: list[torch.Tensor]                  # per-modality working latents (guide frames stripped)
-    guide_latents: list[torch.Tensor | None]     # per-modality guide frames stripped from latents
-    guide_entries: list[list[dict] | None]       # per-modality guide_attention_entry metadata
-    keyframe_idxs: list[torch.Tensor | None]     # per-modality keyframe_idxs tensor for guide latent_start derivation
-    latent_shapes: list | None                   # original packed shapes for unpack/pack (None if not multimodal)
-    dim: int = 0                                 # primary modality temporal dim for context windowing
-    is_multimodal: bool = False
-    temporal_downscale_ratio: int = 1            # model's pixel-to-latent temporal compression ratio
-
-    def prepare_window(self, window: IndexListContextWindow, model) -> IndexListContextWindow:
-        """Reformat window for multimodal contexts by deriving per-modality index lists.
-        Non-multimodal contexts return the input window unchanged.
-        """
-        if not self.is_multimodal:
-            return window
-
-        x = self.latents[0]
-        primary_total = self.latent_shapes[0][self.dim]
-        primary_overlap = window.context_overlap
-        map_shapes = self.latent_shapes
-        if x.size(self.dim) != primary_total:
-            map_shapes = list(self.latent_shapes)
-            video_shape = list(self.latent_shapes[0])
-            video_shape[self.dim] = x.size(self.dim)
-            map_shapes[0] = torch.Size(video_shape)
-        try:
-            per_modality_indices = model.map_context_window_to_modalities(
-                window.index_list, map_shapes, self.dim)
-        except AttributeError:
-            raise NotImplementedError(
-                f"{type(model).__name__} must implement map_context_window_to_modalities for multimodal context windows.")
-        modality_windows = {}
-        for mod_idx in range(1, len(self.latents)):
-            modality_total_frames = self.latents[mod_idx].shape[self.dim]
-            ratio = modality_total_frames / primary_total if primary_total > 0 else 1
-            modality_overlap = max(round(primary_overlap * ratio), 0)
-            modality_windows[mod_idx] = IndexListContextWindow(
-                per_modality_indices[mod_idx], dim=self.dim,
-                total_frames=modality_total_frames,
-                context_overlap=modality_overlap)
-        return IndexListContextWindow(
-            window.index_list, dim=self.dim, total_frames=x.shape[self.dim],
-            modality_windows=modality_windows, context_overlap=primary_overlap)
-
-    def slice_for_window(self, window: IndexListContextWindow, retain_index_list: list[int], device=None) -> tuple[list[torch.Tensor], list[int]]:
-        """Slice latents for a context window, injecting guide frames where applicable.
-        For multimodal contexts, uses the modality-specific windows derived in prepare_window().
-        """
-        sliced = []
-        guide_frame_counts = []
-        for idx in range(len(self.latents)):
-            modality_window = window.get_window_for_modality(idx)
-            retain = retain_index_list if idx == 0 else []
-            s = modality_window.get_tensor(self.latents[idx], device, retain_index_list=retain)
-            if self.guide_entries[idx] is not None:
-                s, ng = self._inject_guide_frames(s, modality_window, modality_idx=idx)
-            else:
-                ng = 0
-            sliced.append(s)
-            guide_frame_counts.append(ng)
-        return sliced, guide_frame_counts
-
-    def strip_guide_frames(self, out_per_modality: list[list[torch.Tensor]], guide_frame_counts: list[int], window: IndexListContextWindow):
-        """Strip injected guide frames from per-cond, per-modality outputs in place."""
-        for idx in range(len(self.latents)):
-            if guide_frame_counts[idx] > 0:
-                window_len = len(window.get_window_for_modality(idx).index_list)
-                for ci in range(len(out_per_modality)):
-                    out_per_modality[ci][idx] = out_per_modality[ci][idx].narrow(self.dim, 0, window_len)
-
-    def _inject_guide_frames(self, latent_slice: torch.Tensor, window: IndexListContextWindow, modality_idx: int = 0) -> tuple[torch.Tensor, int]:
-        guide_entries = self.guide_entries[modality_idx]
-        guide_frames = self.guide_latents[modality_idx]
-        keyframe_idxs = self.keyframe_idxs[modality_idx]
-        suffix_idx, overlap_info, kf_local_pos, guide_frame_count = compute_guide_overlap(
-            guide_entries, keyframe_idxs, self.temporal_downscale_ratio, window.index_list)
-        # Shift keyframe positions to account for causal_window_fix anchor occupying sub-pos 0.
-        anchor_idx = getattr(window, 'causal_anchor_index', None)
-        if anchor_idx is not None and anchor_idx >= 0:
-            kf_local_pos = [p + 1 for p in kf_local_pos]
-        window.guide_frames_indices = suffix_idx
-        window.guide_overlap_info = overlap_info
-        window.guide_kf_local_positions = kf_local_pos
-
-        # Derive per-overlap-entry latent_downscale_factor from guide entry latent_shape vs guide frame spatial dims.
-        # guide_frames has full (post-dilation) spatial dims; entry["latent_shape"] has pre-dilation dims.
-        guide_downscale_factors = []
-        if guide_frame_count > 0:
-            full_H = guide_frames.shape[3]
-            for entry_idx, _ in overlap_info:
-                entry_H = guide_entries[entry_idx]["latent_shape"][1]
-                guide_downscale_factors.append(full_H // entry_H)
-        window.guide_downscale_factors = guide_downscale_factors
-
-        if guide_frame_count > 0:
-            idx = tuple([slice(None)] * self.dim + [suffix_idx])
-            return torch.cat([latent_slice, guide_frames[idx]], dim=self.dim), guide_frame_count
-        return latent_slice, 0
-
-    def patch_latent_shapes(self, sub_conds, new_shapes):
-        if not self.is_multimodal:
-            return
-
-        for cond_list in sub_conds:
-            if cond_list is None:
-                continue
-            for cond_dict in cond_list:
-                model_conds = cond_dict.get('model_conds', {})
-                if 'latent_shapes' in model_conds:
-                    model_conds['latent_shapes'] = comfy.conds.CONDConstant(new_shapes)
-
-
@dataclass
 class ContextSchedule:
    name: str
@@ -341,7 +162,7 @@ ContextResults = collections.namedtuple("ContextResults", ['window_idx', 'sub_co
 class IndexListContextHandler(ContextHandlerABC):
    def __init__(self, context_schedule: ContextSchedule, fuse_method: ContextFuseMethod, context_length: int=1, context_overlap: int=0, context_stride: int=1,
                 closed_loop: bool=False, dim:int=0, freenoise: bool=False, cond_retain_index_list: list[int]=[], split_conds_to_windows: bool=False,
-                 latent_retain_index_list: list[int]=[], causal_window_fix: bool=True):
+                 causal_window_fix: bool=True):
        self.context_schedule = context_schedule
        self.fuse_method = fuse_method
        self.context_length = context_length
@@ -353,118 +174,17 @@ class IndexListContextHandler(ContextHandlerABC):
        self.freenoise = freenoise
        self.cond_retain_index_list = [int(x.strip()) for x in cond_retain_index_list.split(",")] if cond_retain_index_list else []
        self.split_conds_to_windows = split_conds_to_windows
-        self.latent_retain_index_list = [int(x.strip()) for x in latent_retain_index_list.split(",")] if latent_retain_index_list else []
        self.causal_window_fix = causal_window_fix

        self.callbacks = {}

-    @staticmethod
-    def _get_latent_shapes(conds):
-        for cond_list in conds:
-            if cond_list is None:
-                continue
-            for cond_dict in cond_list:
-                model_conds = cond_dict.get('model_conds', {})
-                if 'latent_shapes' in model_conds:
-                    return model_conds['latent_shapes'].cond
-        return None
-
-    @staticmethod
-    def _get_guide_entries(conds):
-        for cond_list in conds:
-            if cond_list is None:
-                continue
-            for cond_dict in cond_list:
-                model_conds = cond_dict.get('model_conds', {})
-                entries = model_conds.get('guide_attention_entries')
-                if entries is not None and hasattr(entries, 'cond') and entries.cond:
-                    return entries.cond
-        return None
-
-    @staticmethod
-    def _get_keyframe_idxs(conds):
-        for cond_list in conds:
-            if cond_list is None:
-                continue
-            for cond_dict in cond_list:
-                model_conds = cond_dict.get('model_conds', {})
-                kf = model_conds.get('keyframe_idxs')
-                if kf is not None and hasattr(kf, 'cond') and kf.cond is not None:
-                    return kf.cond
-        return None
-
-    def _apply_freenoise(self, noise: torch.Tensor, conds: list[list[dict]], seed: int) -> torch.Tensor:
-        """Apply FreeNoise shuffling, scaling context length/overlap per-modality by frame ratio.
-        If guide frames are present on the primary modality, only the video portion is shuffled.
-        """
-        guide_entries = self._get_guide_entries(conds)
-        guide_count = sum(e["latent_shape"][0] for e in guide_entries) if guide_entries else 0
-
-        latent_shapes = self._get_latent_shapes(conds)
-        if latent_shapes is not None and len(latent_shapes) > 1:
-            modalities = comfy.utils.unpack_latents(noise, latent_shapes)
-            primary_total = latent_shapes[0][self.dim]
-            primary_video_count = modalities[0].size(self.dim) - guide_count
-            apply_freenoise(modalities[0].narrow(self.dim, 0, primary_video_count), self.dim, self.context_length, self.context_overlap, seed)
-            for i in range(1, len(modalities)):
-                mod_total = latent_shapes[i][self.dim]
-                ratio = mod_total / primary_total if primary_total > 0 else 1
-                mod_ctx_len = max(round(self.context_length * ratio), 1)
-                mod_ctx_overlap = max(round(self.context_overlap * ratio), 0)
-                modalities[i] = apply_freenoise(modalities[i], self.dim, mod_ctx_len, mod_ctx_overlap, seed)
-            noise, _ = comfy.utils.pack_latents(modalities)
-            return noise
-        video_count = noise.size(self.dim) - guide_count
-        apply_freenoise(noise.narrow(self.dim, 0, video_count), self.dim, self.context_length, self.context_overlap, seed)
-        return noise
-
-    def _build_window_state(self, x_in: torch.Tensor, conds: list[list[dict]], model: BaseModel) -> WindowingState:
-        """Build windowing state for the current step, including unpacking latents and extracting guide frame info from conds."""
-        latent_shapes = self._get_latent_shapes(conds)
-        is_multimodal = latent_shapes is not None and len(latent_shapes) > 1
-        unpacked_latents = comfy.utils.unpack_latents(x_in, latent_shapes) if is_multimodal else [x_in]
-
-        unpacked_latents_list = list(unpacked_latents)
-        guide_latents_list = [None] * len(unpacked_latents)
-        guide_entries_list = [None] * len(unpacked_latents)
-        keyframe_idxs_list = [None] * len(unpacked_latents)
-
-        extracted_guide_entries = self._get_guide_entries(conds)
-        extracted_keyframe_idxs = self._get_keyframe_idxs(conds)
-
-        # Strip guide frames (only from first modality for now)
-        if extracted_guide_entries is not None:
-            guide_count = sum(e["latent_shape"][0] for e in extracted_guide_entries)
-            if guide_count > 0:
-                x = unpacked_latents[0]
-                latent_count = x.size(self.dim) - guide_count
-                unpacked_latents_list[0] = x.narrow(self.dim, 0, latent_count)
-                guide_latents_list[0] = x.narrow(self.dim, latent_count, guide_count)
-                guide_entries_list[0] = extracted_guide_entries
-                keyframe_idxs_list[0] = extracted_keyframe_idxs
-
-
-        return WindowingState(
-            latents=unpacked_latents_list,
-            guide_latents=guide_latents_list,
-            guide_entries=guide_entries_list,
-            keyframe_idxs=keyframe_idxs_list,
-            latent_shapes=latent_shapes,
-            dim=self.dim,
-            is_multimodal=is_multimodal,
-            temporal_downscale_ratio=model.latent_format.temporal_downscale_ratio)
-
    def should_use_context(self, model: BaseModel, conds: list[list[dict]], x_in: torch.Tensor, timestep: torch.Tensor, model_options: dict[str]) -> bool:
-        window_state = self._build_window_state(x_in, conds, model) # build window_state to check frame counts, will be built again in execute
-        total_frame_count = window_state.latents[0].size(self.dim)
-        if total_frame_count > self.context_length:
-            logging.info(f"\nUsing context windows: Context length {self.context_length} with overlap {self.context_overlap} for {total_frame_count} frames.")
+        # for now, assume first dim is batch - should have stored on BaseModel in actual implementation
+        if x_in.size(self.dim) > self.context_length:
+            logging.info(f"Using context windows {self.context_length} with overlap {self.context_overlap} for {x_in.size(self.dim)} frames.")
            if self.cond_retain_index_list:
                logging.info(f"Retaining original cond for indexes: {self.cond_retain_index_list}")
-            if self.latent_retain_index_list:
-                logging.info(f"Retaining original latent for indexes: {self.latent_retain_index_list}")
            return True
-        logging.info(f"\nNot using context windows since context length ({self.context_length}) exceeds input frames ({total_frame_count}).")
        return False

    def prepare_control_objects(self, control: ControlBase, device=None) -> ControlBase:
@@ -555,9 +275,7 @@ class IndexListContextHandler(ContextHandlerABC):
        return resized_cond

    def set_step(self, timestep: torch.Tensor, model_options: dict[str]):
-        sample_sigmas = model_options["transformer_options"]["sample_sigmas"]
-        current_timestep = timestep[0].to(sample_sigmas.dtype)
-        mask = torch.isclose(sample_sigmas, current_timestep, rtol=0.0001)
+        mask = torch.isclose(model_options["transformer_options"]["sample_sigmas"], timestep[0], rtol=0.0001)
        matches = torch.nonzero(mask)
        if torch.numel(matches) == 0:
            return  # substep from multi-step sampler: keep self._step from the last full step
@@ -566,98 +284,54 @@ class IndexListContextHandler(ContextHandlerABC):
    def get_context_windows(self, model: BaseModel, x_in: torch.Tensor, model_options: dict[str]) -> list[IndexListContextWindow]:
        full_length = x_in.size(self.dim) # TODO: choose dim based on model
        context_windows = self.context_schedule.func(full_length, self, model_options)
-        context_windows = [IndexListContextWindow(window, dim=self.dim, total_frames=full_length, context_overlap=self.context_overlap) for window in context_windows]
+        context_windows = [IndexListContextWindow(window, dim=self.dim, total_frames=full_length) for window in context_windows]
        return context_windows

    def execute(self, calc_cond_batch: Callable, model: BaseModel, conds: list[list[dict]], x_in: torch.Tensor, timestep: torch.Tensor, model_options: dict[str]):
        self._model = model
        self.set_step(timestep, model_options)
-
-        window_state = self._build_window_state(x_in, conds, model)
-        num_modalities = len(window_state.latents)
-
-        context_windows = self.get_context_windows(model, window_state.latents[0], model_options)
+        context_windows = self.get_context_windows(model, x_in, model_options)
        enumerated_context_windows = list(enumerate(context_windows))
-        total_windows = len(enumerated_context_windows)

-        # Initialize per-modality accumulators (length 1 for single-modality)
-        accum = [[torch.zeros_like(m) for _ in conds] for m in window_state.latents]
+        conds_final = [torch.zeros_like(x_in) for _ in conds]
        if self.fuse_method.name == ContextFuseMethods.RELATIVE:
-            counts = [[torch.ones(get_shape_for_dim(m, self.dim), device=m.device) for _ in conds] for m in window_state.latents]
+            counts_final = [torch.ones(get_shape_for_dim(x_in, self.dim), device=x_in.device) for _ in conds]
        else:
-            counts = [[torch.zeros(get_shape_for_dim(m, self.dim), device=m.device) for _ in conds] for m in window_state.latents]
-        biases = [[([0.0] * m.shape[self.dim]) for _ in conds] for m in window_state.latents]
+            counts_final = [torch.zeros(get_shape_for_dim(x_in, self.dim), device=x_in.device) for _ in conds]
+        biases_final = [([0.0] * x_in.shape[self.dim]) for _ in conds]

        for callback in comfy.patcher_extension.get_all_callbacks(IndexListCallbacks.EXECUTE_START, self.callbacks):
            callback(self, model, x_in, conds, timestep, model_options)

-        # accumulate results from each context window
        for enum_window in enumerated_context_windows:
-            results = self.evaluate_context_windows(
-                calc_cond_batch, model, x_in, conds, timestep, [enum_window],
-                model_options, window_state=window_state, total_windows=total_windows)
+            results = self.evaluate_context_windows(calc_cond_batch, model, x_in, conds, timestep, [enum_window], model_options)
            for result in results:
-                # result.sub_conds_out is per-cond, per-modality: list[list[Tensor]]
-                for mod_idx in range(num_modalities):
-                    mod_out = [result.sub_conds_out[ci][mod_idx] for ci in range(len(conds))]
-                    modality_window = result.window.get_window_for_modality(mod_idx)
-                    self.combine_context_window_results(
-                        window_state.latents[mod_idx], mod_out, result.sub_conds, modality_window,
-                        result.window_idx, total_windows, timestep,
-                        accum[mod_idx], counts[mod_idx], biases[mod_idx])
-
-        # fuse accumulated results into final conds
+                self.combine_context_window_results(x_in, result.sub_conds_out, result.sub_conds, result.window, result.window_idx, len(enumerated_context_windows), timestep,
+                                            conds_final, counts_final, biases_final)
        try:
-            result_out = []
-            for ci in range(len(conds)):
-                finalized = []
-                for mod_idx in range(num_modalities):
-                    if self.fuse_method.name != ContextFuseMethods.RELATIVE:
-                        accum[mod_idx][ci] /= counts[mod_idx][ci]
-                    f = accum[mod_idx][ci]
-
-                    # if guide frames were injected, append them to the end of the fused latents for the next step
-                    if window_state.guide_latents[mod_idx] is not None:
-                        f = torch.cat([f, window_state.guide_latents[mod_idx]], dim=self.dim)
-                    finalized.append(f)
-
-                # pack modalities together if needed
-                if window_state.is_multimodal and len(finalized) > 1:
-                    packed, _ = comfy.utils.pack_latents(finalized)
-                else:
-                    packed = finalized[0]
-
-                result_out.append(packed)
-            return result_out
+            # finalize conds
+            if self.fuse_method.name == ContextFuseMethods.RELATIVE:
+                # relative is already normalized, so return as is
+                del counts_final
+                return conds_final
+            else:
+                # normalize conds via division by context usage counts
+                for i in range(len(conds_final)):
+                    conds_final[i] /= counts_final[i]
+                del counts_final
+                return conds_final
        finally:
            for callback in comfy.patcher_extension.get_all_callbacks(IndexListCallbacks.EXECUTE_CLEANUP, self.callbacks):
                callback(self, model, x_in, conds, timestep, model_options)

-    def evaluate_context_windows(self, calc_cond_batch: Callable, model: BaseModel, x_in: torch.Tensor, conds,
-                                timestep: torch.Tensor, enumerated_context_windows: list[tuple[int, IndexListContextWindow]],
-                                model_options, window_state: WindowingState, total_windows: int = None,
-                                device=None, first_device=None):
-        """Evaluate context windows and return per-cond, per-modality outputs in ContextResults.sub_conds_out
-
-        For each window:
-        1. Builds windows (for each modality if multimodal)
-        2. Slices window for each modality
-        3. Injects concatenated latent guide frames where present
-        4. Packs together if needed and calls model
-        5. Unpacks and strips any guides from outputs
-        """
-        x = window_state.latents[0]
-
+    def evaluate_context_windows(self, calc_cond_batch: Callable, model: BaseModel, x_in: torch.Tensor, conds, timestep: torch.Tensor, enumerated_context_windows: list[tuple[int, IndexListContextWindow]],
+                                model_options, device=None, first_device=None):
        results: list[ContextResults] = []
        for window_idx, window in enumerated_context_windows:
            # allow processing to end between context window executions for faster Cancel
            comfy.model_management.throw_exception_if_processing_interrupted()

-            # prepare the window accounting for multimodal windows
-            window = window_state.prepare_window(window, model)
-
-            # causal_window_fix: prepend a pre-window frame that will be stripped post-forward.
-            # Set anchor before slice_for_window so the latent slice and downstream cond slices both pick it up.
+            # causal_window_fix: prepend a pre-window frame that will be stripped post-forward
            anchor_applied = False
            if self.causal_window_fix:
                anchor_idx = window.index_list[0] - 1
@@ -665,46 +339,27 @@ class IndexListContextHandler(ContextHandlerABC):
                    window.causal_anchor_index = anchor_idx
                    anchor_applied = True

-            # slice the window for each modality, injecting guide frames where applicable
-            sliced, guide_frame_counts_per_modality = window_state.slice_for_window(window, self.latent_retain_index_list, device)
-
            for callback in comfy.patcher_extension.get_all_callbacks(IndexListCallbacks.EVALUATE_CONTEXT_WINDOWS, self.callbacks):
                callback(self, model, x_in, conds, timestep, model_options, window_idx, window, model_options, device, first_device)

-            logging.info(f"Context window {window_idx + 1}/{total_windows or len(enumerated_context_windows)}: frames {window.index_list[0]}-{window.index_list[-1]} of {x.shape[self.dim]}"
-                         + (f" (+{guide_frame_counts_per_modality[0]} guide frames)" if guide_frame_counts_per_modality[0] > 0 else "")
-                         )
-
-            # if multimodal, pack modalities together
-            if window_state.is_multimodal and len(sliced) > 1:
-                sub_x, sub_shapes = comfy.utils.pack_latents(sliced)
-            else:
-                sub_x, sub_shapes = sliced[0], [sliced[0].shape]
-
-            # get resized conds for window
+            # update exposed params
            model_options["transformer_options"]["context_window"] = window
-            sub_timestep = window.get_tensor(timestep, dim=0)
-            sub_conds = [self.get_resized_cond(cond, x, window) for cond in conds]
+            # get subsections of x, timestep, conds
+            sub_x = window.get_tensor(x_in, device)
+            sub_timestep = window.get_tensor(timestep, device, dim=0)
+            sub_conds = [self.get_resized_cond(cond, x_in, window, device) for cond in conds]

-            # if multimodal, patch latent_shapes in conds for correct unpacking in model
-            window_state.patch_latent_shapes(sub_conds, sub_shapes)
-
-            # call model on window
            sub_conds_out = calc_cond_batch(model, sub_conds, sub_x, sub_timestep, model_options)
+            if device is not None:
+                for i in range(len(sub_conds_out)):
+                    sub_conds_out[i] = sub_conds_out[i].to(x_in.device)

-            # unpack outputs
-            out_per_modality = [comfy.utils.unpack_latents(sub_conds_out[i], sub_shapes) for i in range(len(sub_conds_out))]
-
-            # strip causal_window_fix anchor from primary modality before guide strip so window_len math stays correct
+            # strip causal_window_fix anchor if applied
            if anchor_applied:
-                for ci in range(len(out_per_modality)):
-                    t = out_per_modality[ci][0]
-                    out_per_modality[ci][0] = t.narrow(self.dim, 1, t.shape[self.dim] - 1)
+                for i in range(len(sub_conds_out)):
+                    sub_conds_out[i] = sub_conds_out[i].narrow(self.dim, 1, sub_conds_out[i].shape[self.dim] - 1)

-            # strip injected guide frames
-            window_state.strip_guide_frames(out_per_modality, guide_frame_counts_per_modality, window)
-
-            results.append(ContextResults(window_idx, out_per_modality, sub_conds, window))
+            results.append(ContextResults(window_idx, sub_conds_out, sub_conds, window))
        return results


@@ -728,7 +383,7 @@ class IndexListContextHandler(ContextHandlerABC):
                    biases_final[i][idx] = bias_total + bias
        else:
            # add conds and counts based on weights of fuse method
-            weights = get_context_weights(window.context_length, x_in.shape[self.dim], window.index_list, self, sigma=timestep, context_overlap=window.context_overlap)
+            weights = get_context_weights(window.context_length, x_in.shape[self.dim], window.index_list, self, sigma=timestep)
            weights_tensor = match_weights_to_dim(weights, x_in, self.dim, device=x_in.device)
            for i in range(len(sub_conds_out)):
                window.add_window(conds_final[i], sub_conds_out[i] * weights_tensor)
@@ -738,22 +393,16 @@ class IndexListContextHandler(ContextHandlerABC):
            callback(self, x_in, sub_conds_out, sub_conds, window, window_idx, total_windows, timestep, conds_final, counts_final, biases_final)


-def _prepare_sampling_wrapper(executor, model, noise_shape: torch.Tensor, conds, *args, **kwargs):
-    # Scale noise_shape to a single context window so VRAM estimation budgets per-window.
+def _prepare_sampling_wrapper(executor, model, noise_shape: torch.Tensor, *args, **kwargs):
+    # limit noise_shape length to context_length for more accurate vram use estimation
    model_options = kwargs.get("model_options", None)
    if model_options is None:
        raise Exception("model_options not found in prepare_sampling_wrapper; this should never happen, something went wrong.")
    handler: IndexListContextHandler = model_options.get("context_handler", None)
    if handler is not None:
        noise_shape = list(noise_shape)
-        is_packed = len(noise_shape) == 3 and noise_shape[1] == 1
-        if is_packed:
-            # TODO: latent_shapes cond isn't attached yet at this point, so we can't compute a
-            # per-window flat latent here. Skipping the clamp over-estimates but prevents immediate OOM.
-            pass
-        elif handler.dim < len(noise_shape) and noise_shape[handler.dim] > handler.context_length:
-            noise_shape[handler.dim] = min(noise_shape[handler.dim], handler.context_length)
-    return executor(model, noise_shape, conds, *args, **kwargs)
+        noise_shape[handler.dim] = min(noise_shape[handler.dim], handler.context_length)
+    return executor(model, noise_shape, *args, **kwargs)


 def create_prepare_sampling_wrapper(model: ModelPatcher):
@@ -773,12 +422,11 @@ def _sampler_sample_wrapper(executor, guider, sigmas, extra_args, callback, nois
        raise Exception("context_handler not found in sampler_sample_wrapper; this should never happen, something went wrong.")
    if not handler.freenoise:
        return executor(guider, sigmas, extra_args, callback, noise, *args, **kwargs)
-
-    conds = [guider.conds.get('positive', guider.conds.get('negative', []))]
-    noise = handler._apply_freenoise(noise, conds, extra_args["seed"])
+    noise = apply_freenoise(noise, handler.dim, handler.context_length, handler.context_overlap, extra_args["seed"])

    return executor(guider, sigmas, extra_args, callback, noise, *args, **kwargs)

+
 def create_sampler_sample_wrapper(model: ModelPatcher):
    model.add_wrapper_with_key(
        comfy.patcher_extension.WrappersMP.SAMPLER_SAMPLE,
@@ -786,6 +434,7 @@ def create_sampler_sample_wrapper(model: ModelPatcher):
        _sampler_sample_wrapper
    )

+
 def match_weights_to_dim(weights: list[float], x_in: torch.Tensor, dim: int, device=None) -> torch.Tensor:
    total_dims = len(x_in.shape)
    weights_tensor = torch.Tensor(weights).to(device=device)
@@ -931,9 +580,8 @@ def get_matching_context_schedule(context_schedule: str) -> ContextSchedule:
    return ContextSchedule(context_schedule, func)


-def get_context_weights(length: int, full_length: int, idxs: list[int], handler: IndexListContextHandler, sigma: torch.Tensor=None, context_overlap: int=None):
-    context_overlap = handler.context_overlap if context_overlap is None else context_overlap
-    return handler.fuse_method.func(length, sigma=sigma, handler=handler, full_length=full_length, idxs=idxs, context_overlap=context_overlap)
+def get_context_weights(length: int, full_length: int, idxs: list[int], handler: IndexListContextHandler, sigma: torch.Tensor=None):
+    return handler.fuse_method.func(length, sigma=sigma, handler=handler, full_length=full_length, idxs=idxs)


 def create_weights_flat(length: int, **kwargs) -> list[float]:
@@ -951,18 +599,18 @@ def create_weights_pyramid(length: int, **kwargs) -> list[float]:
        weight_sequence = list(range(1, max_weight, 1)) + [max_weight] + list(range(max_weight - 1, 0, -1))
    return weight_sequence

-def create_weights_overlap_linear(length: int, full_length: int, idxs: list[int], context_overlap: int, **kwargs):
+def create_weights_overlap_linear(length: int, full_length: int, idxs: list[int], handler: IndexListContextHandler, **kwargs):
    # based on code in Kijai's WanVideoWrapper: https://github.com/kijai/ComfyUI-WanVideoWrapper/blob/dbb2523b37e4ccdf45127e5ae33e31362f755c8e/nodes.py#L1302
    # only expected overlap is given different weights
    weights_torch = torch.ones((length))
    # blend left-side on all except first window
    if min(idxs) > 0:
-        ramp_up = torch.linspace(1e-37, 1, context_overlap)
-        weights_torch[:context_overlap] = ramp_up
+        ramp_up = torch.linspace(1e-37, 1, handler.context_overlap)
+        weights_torch[:handler.context_overlap] = ramp_up
    # blend right-side on all except last window
    if max(idxs) < full_length-1:
-        ramp_down = torch.linspace(1, 1e-37, context_overlap)
-        weights_torch[-context_overlap:] = ramp_down
+        ramp_down = torch.linspace(1, 1e-37, handler.context_overlap)
+        weights_torch[-handler.context_overlap:] = ramp_down
    return weights_torch

 class ContextFuseMethods:
@@ -15,14 +15,13 @@
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
-from __future__ import annotations
+

 import torch
 from enum import Enum
 import math
 import os
 import logging
-import copy
 import comfy.utils
 import comfy.model_management
 import comfy.model_detection
@@ -39,7 +38,7 @@ import comfy.ldm.hydit.controlnet
 import comfy.ldm.flux.controlnet
 import comfy.ldm.qwen_image.controlnet
 import comfy.cldm.dit_embedder
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 if TYPE_CHECKING:
    from comfy.hooks import HookGroup

@@ -65,18 +64,6 @@ class StrengthType(Enum):
    CONSTANT = 1
    LINEAR_UP = 2

-class ControlIsolation:
-    '''Temporarily set a ControlBase object's previous_controlnet to None to prevent cascading calls.'''
-    def __init__(self, control: ControlBase):
-        self.control = control
-        self.orig_previous_controlnet = control.previous_controlnet
-
-    def __enter__(self):
-        self.control.previous_controlnet = None
-
-    def __exit__(self, *args):
-        self.control.previous_controlnet = self.orig_previous_controlnet
-
 class ControlBase:
    def __init__(self):
        self.cond_hint_original = None
@@ -90,7 +77,7 @@ class ControlBase:
        self.compression_ratio = 8
        self.upscale_algorithm = 'nearest-exact'
        self.extra_args = {}
-        self.previous_controlnet: Union[ControlBase, None] = None
+        self.previous_controlnet = None
        self.extra_conds = []
        self.strength_type = StrengthType.CONSTANT
        self.concat_mask = False
@@ -98,7 +85,6 @@ class ControlBase:
        self.extra_concat = None
        self.extra_hooks: HookGroup = None
        self.preprocess_image = lambda a: a
-        self.multigpu_clones: dict[torch.device, ControlBase] = {}

    def set_cond_hint(self, cond_hint, strength=1.0, timestep_percent_range=(0.0, 1.0), vae=None, extra_concat=[]):
        self.cond_hint_original = cond_hint
@@ -125,38 +111,17 @@ class ControlBase:
    def cleanup(self):
        if self.previous_controlnet is not None:
            self.previous_controlnet.cleanup()
-        for device_cnet in self.multigpu_clones.values():
-            with ControlIsolation(device_cnet):
-                device_cnet.cleanup()
+
        self.cond_hint = None
        self.extra_concat = None
        self.timestep_range = None

    def get_models(self):
        out = []
-        for device_cnet in self.multigpu_clones.values():
-            out += device_cnet.get_models_only_self()
        if self.previous_controlnet is not None:
            out += self.previous_controlnet.get_models()
        return out

-    def get_models_only_self(self):
-        'Calls get_models, but temporarily sets previous_controlnet to None.'
-        with ControlIsolation(self):
-            return self.get_models()
-
-    def get_instance_for_device(self, device):
-        'Returns instance of this Control object intended for selected device.'
-        return self.multigpu_clones.get(device, self)
-
-    def deepclone_multigpu(self, load_device, autoregister=False):
-        '''
-        Create deep clone of Control object where model(s) is set to other devices.
-
-        When autoregister is set to True, the deep clone is also added to multigpu_clones dict.
-        '''
-        raise NotImplementedError("Classes inheriting from ControlBase should define their own deepclone_multigpu funtion.")
-
    def get_extra_hooks(self):
        out = []
        if self.extra_hooks is not None:
@@ -165,7 +130,7 @@ class ControlBase:
            out += self.previous_controlnet.get_extra_hooks()
        return out

-    def copy_to(self, c: ControlBase):
+    def copy_to(self, c):
        c.cond_hint_original = self.cond_hint_original
        c.strength = self.strength
        c.timestep_percent_range = self.timestep_percent_range
@@ -319,14 +284,6 @@ class ControlNet(ControlBase):
        self.copy_to(c)
        return c

-    def deepclone_multigpu(self, load_device, autoregister=False):
-        c = self.copy()
-        c.control_model = copy.deepcopy(c.control_model)
-        c.control_model_wrapped = comfy.model_patcher.ModelPatcher(c.control_model, load_device=load_device, offload_device=comfy.model_management.unet_offload_device())
-        if autoregister:
-            self.multigpu_clones[load_device] = c
-        return c
-
    def get_models(self):
        out = super().get_models()
        out.append(self.control_model_wrapped)
@@ -357,10 +314,6 @@ class QwenFunControlNet(ControlNet):
        super().pre_run(model, percent_to_timestep_function)
        self.set_extra_arg("base_model", model.diffusion_model)

-    def cleanup(self):
-        self.extra_args.pop("base_model", None)
-        super().cleanup()
-
    def copy(self):
        c = QwenFunControlNet(None, global_average_pooling=self.global_average_pooling, load_device=self.load_device, manual_cast_dtype=self.manual_cast_dtype)
        c.control_model = self.control_model
@@ -953,14 +906,6 @@ class T2IAdapter(ControlBase):
        self.copy_to(c)
        return c

-    def deepclone_multigpu(self, load_device, autoregister=False):
-        c = self.copy()
-        c.t2i_model = copy.deepcopy(c.t2i_model)
-        c.device = load_device
-        if autoregister:
-            self.multigpu_clones[load_device] = c
-        return c
-
 def load_t2i_adapter(t2i_data, model_options={}): #TODO: model_options
    compression_ratio = 8
    upscale_algorithm = 'nearest-exact'
@@ -1,20 +1,5 @@
-import logging
-
 import torch

-_CK_STOCHASTIC_ROUNDING_AVAILABLE = False
-try:
-    import comfy_kitchen as ck
-    _ck_stochastic_rounding_fp8 = ck.stochastic_rounding_fp8
-    _CK_STOCHASTIC_ROUNDING_AVAILABLE = True
-except (AttributeError, ImportError):
-    logging.warning("comfy_kitchen does not support stochastic FP8 rounding, please update comfy_kitchen.")
-
-if not _CK_STOCHASTIC_ROUNDING_AVAILABLE:
-    def _ck_stochastic_rounding_fp8(value, rng, dtype):
-        raise NotImplementedError("comfy_kitchen does not support stochastic FP8 rounding")
-
-
 def calc_mantissa(abs_x, exponent, normal_mask, MANTISSA_BITS, EXPONENT_BIAS, generator=None):
    mantissa_scaled = torch.where(
        normal_mask,
@@ -72,10 +57,6 @@ def stochastic_rounding(value, dtype, seed=0):
    if dtype == torch.float8_e4m3fn or dtype == torch.float8_e5m2:
        generator = torch.Generator(device=value.device)
        generator.manual_seed(seed)
-        if _CK_STOCHASTIC_ROUNDING_AVAILABLE:
-            rng = torch.randint(0, 256, value.size(), dtype=torch.uint8, layout=value.layout, device=value.device, generator=generator)
-            return _ck_stochastic_rounding_fp8(value, rng, dtype)
-
        output = torch.empty_like(value, dtype=dtype)
        num_slices = max(1, (value.numel() / (4096 * 4096)))
        slice_size = max(1, round(value.shape[0] / num_slices))
@@ -1,13 +1,7 @@
 import torch
-import torch.nn.functional as F
-
 from comfy.text_encoders.bert import BertAttention
 import comfy.model_management
 from comfy.ldm.modules.attention import optimized_attention_for_device
-from comfy.ldm.depth_anything_3.reference_view_selector import (
-    select_reference_view, reorder_by_reference, restore_original_order,
-    THRESH_FOR_REF_SELECTION,
-)


 class Dino2AttentionOutput(torch.nn.Module):
@@ -20,41 +14,13 @@ class Dino2AttentionOutput(torch.nn.Module):


 class Dino2AttentionBlock(torch.nn.Module):
-    def __init__(self, embed_dim, heads, layer_norm_eps, dtype, device, operations,
-                 qk_norm=False):
+    def __init__(self, embed_dim, heads, layer_norm_eps, dtype, device, operations):
        super().__init__()
-        self.heads = heads
-        self.head_dim = embed_dim // heads
        self.attention = BertAttention(embed_dim, heads, dtype, device, operations)
        self.output = Dino2AttentionOutput(embed_dim, embed_dim, layer_norm_eps, dtype, device, operations)
-        if qk_norm:
-            self.q_norm = operations.LayerNorm(self.head_dim, dtype=dtype, device=device)
-            self.k_norm = operations.LayerNorm(self.head_dim, dtype=dtype, device=device)
-        else:
-            self.q_norm = None
-            self.k_norm = None

-    def forward(self, x, mask, optimized_attention, pos=None, rope=None):
-        # Fast path used by the existing CLIP-vision DINOv2 (no DA3 extensions).
-        if self.q_norm is None and rope is None:
-            return self.output(self.attention(x, mask, optimized_attention))
-
-        # DA3 path: do QKV manually so we can apply per-head QK-norm and 2D RoPE.
-        attn = self.attention
-        B, N, C = x.shape
-        h = self.heads
-        d = self.head_dim
-        q = attn.query(x).view(B, N, h, d).transpose(1, 2)
-        k = attn.key(x).view(B, N, h, d).transpose(1, 2)
-        v = attn.value(x).view(B, N, h, d).transpose(1, 2)
-        if self.q_norm is not None:
-            q = self.q_norm(q)
-            k = self.k_norm(k)
-        if rope is not None and pos is not None:
-            q = rope(q, pos)
-            k = rope(k, pos)
-        out = optimized_attention(q, k, v, h, mask=mask, skip_reshape=True)
-        return self.output(out)
+    def forward(self, x, mask, optimized_attention):
+        return self.output(self.attention(x, mask, optimized_attention))


 class LayerScale(torch.nn.Module):
@@ -98,11 +64,9 @@ class SwiGLUFFN(torch.nn.Module):


 class Dino2Block(torch.nn.Module):
-    def __init__(self, dim, num_heads, layer_norm_eps, dtype, device, operations, use_swiglu_ffn,
-                 qk_norm=False):
+    def __init__(self, dim, num_heads, layer_norm_eps, dtype, device, operations, use_swiglu_ffn):
        super().__init__()
-        self.attention = Dino2AttentionBlock(dim, num_heads, layer_norm_eps, dtype, device, operations,
-                                             qk_norm=qk_norm)
+        self.attention = Dino2AttentionBlock(dim, num_heads, layer_norm_eps, dtype, device, operations)
        self.layer_scale1 = LayerScale(dim, dtype, device, operations)
        self.layer_scale2 = LayerScale(dim, dtype, device, operations)
        if use_swiglu_ffn:
@@ -112,90 +76,19 @@ class Dino2Block(torch.nn.Module):
        self.norm1 = operations.LayerNorm(dim, eps=layer_norm_eps, dtype=dtype, device=device)
        self.norm2 = operations.LayerNorm(dim, eps=layer_norm_eps, dtype=dtype, device=device)

-    def forward(self, x, optimized_attention, pos=None, rope=None, attn_mask=None):
-        x = x + self.layer_scale1(self.attention(self.norm1(x), attn_mask, optimized_attention,
-                                                 pos=pos, rope=rope))
+    def forward(self, x, optimized_attention):
+        x = x + self.layer_scale1(self.attention(self.norm1(x), None, optimized_attention))
        x = x + self.layer_scale2(self.mlp(self.norm2(x)))
        return x


-# -----------------------------------------------------------------------------
-# 2D Rotary position embedding (DA3 extension)
-# -----------------------------------------------------------------------------
-
-
-class _PositionGetter:
-    """Cache (h, w) -> flat (y, x) position grid used to feed ``rope``."""
-
-    def __init__(self):
-        self._cache: dict = {}
-
-    def __call__(self, batch_size: int, height: int, width: int, device) -> torch.Tensor:
-        key = (height, width, device)
-        if key not in self._cache:
-            y = torch.arange(height, device=device)
-            x = torch.arange(width, device=device)
-            self._cache[key] = torch.cartesian_prod(y, x)
-        cached = self._cache[key]
-        return cached.view(1, height * width, 2).expand(batch_size, -1, -1).clone()
-
-
-class RotaryPositionEmbedding2D(torch.nn.Module):
-    """2D RoPE used by DA3-Small/Base. No learnable parameters."""
-
-    def __init__(self, frequency: float = 100.0):
-        super().__init__()
-        self.base_frequency = frequency
-        self._freq_cache: dict = {}
-
-    def _components(self, dim: int, seq_len: int, device, dtype):
-        key = (dim, seq_len, device, dtype)
-        if key not in self._freq_cache:
-            exp = torch.arange(0, dim, 2, device=device).float() / dim
-            inv_freq = 1.0 / (self.base_frequency ** exp)
-            pos = torch.arange(seq_len, device=device, dtype=inv_freq.dtype)
-            ang = torch.einsum("i,j->ij", pos, inv_freq)
-            ang = ang.to(dtype)
-            ang = torch.cat((ang, ang), dim=-1)
-            self._freq_cache[key] = (ang.cos().to(dtype), ang.sin().to(dtype))
-        return self._freq_cache[key]
-
-    @staticmethod
-    def _rotate(x: torch.Tensor) -> torch.Tensor:
-        d = x.shape[-1]
-        x1, x2 = x[..., : d // 2], x[..., d // 2:]
-        return torch.cat((-x2, x1), dim=-1)
-
-    def _apply_1d(self, tokens, positions, cos_c, sin_c):
-        cos = F.embedding(positions, cos_c)[:, None, :, :]
-        sin = F.embedding(positions, sin_c)[:, None, :, :]
-        return (tokens * cos) + (self._rotate(tokens) * sin)
-
-    def forward(self, tokens: torch.Tensor, positions: torch.Tensor) -> torch.Tensor:
-        feature_dim = tokens.size(-1) // 2
-        max_pos = int(positions.max()) + 1
-        cos_c, sin_c = self._components(feature_dim, max_pos, tokens.device, tokens.dtype)
-        v, h = tokens.chunk(2, dim=-1)
-        v = self._apply_1d(v, positions[..., 0], cos_c, sin_c)
-        h = self._apply_1d(h, positions[..., 1], cos_c, sin_c)
-        return torch.cat((v, h), dim=-1)
-
-
 class Dino2Encoder(torch.nn.Module):
-    def __init__(self, dim, num_heads, layer_norm_eps, num_layers, dtype, device, operations, use_swiglu_ffn,
-                 qknorm_start: int = -1):
+    def __init__(self, dim, num_heads, layer_norm_eps, num_layers, dtype, device, operations, use_swiglu_ffn):
        super().__init__()
-        self.layer = torch.nn.ModuleList([
-            Dino2Block(
-                dim, num_heads, layer_norm_eps, dtype, device, operations,
-                use_swiglu_ffn=use_swiglu_ffn,
-                qk_norm=(qknorm_start != -1 and i >= qknorm_start),
-            )
-            for i in range(num_layers)
-        ])
+        self.layer = torch.nn.ModuleList([Dino2Block(dim, num_heads, layer_norm_eps, dtype, device, operations, use_swiglu_ffn = use_swiglu_ffn)
+                                          for _ in range(num_layers)])

    def forward(self, x, intermediate_output=None):
-        # Backward-compat path used by ``ClipVisionModel`` (no DA3 extensions).
        optimized_attention = optimized_attention_for_device(x.device, False, small_input=True)

        if intermediate_output is not None:
@@ -213,7 +106,6 @@ class Dino2Encoder(torch.nn.Module):
 class Dino2PatchEmbeddings(torch.nn.Module):
    def __init__(self, dim, num_channels=3, patch_size=14, image_size=518, dtype=None, device=None, operations=None):
        super().__init__()
-        self.patch_size = patch_size
        self.projection = operations.Conv2d(
            in_channels=num_channels,
            out_channels=dim,
@@ -229,62 +121,21 @@ class Dino2PatchEmbeddings(torch.nn.Module):


 class Dino2Embeddings(torch.nn.Module):
-    def __init__(self, dim, dtype, device, operations,
-                 patch_size: int = 14, image_size: int = 518,
-                 use_mask_token: bool = True,
-                 num_camera_tokens: int = 0):
+    def __init__(self, dim, dtype, device, operations):
        super().__init__()
-        self.patch_size = patch_size
-        self.image_size = image_size
+        patch_size = 14
+        image_size = 518

        self.patch_embeddings = Dino2PatchEmbeddings(dim, patch_size=patch_size, image_size=image_size, dtype=dtype, device=device, operations=operations)
        self.position_embeddings = torch.nn.Parameter(torch.empty(1, (image_size // patch_size) ** 2 + 1, dim, dtype=dtype, device=device))
-        self.cls_token = torch.nn.Parameter(torch.empty(1, 1, dim, dtype=dtype, device=device)) # mask_token is a pre-training param, kept only so strict loading accepts the key.
-        if use_mask_token:
-            self.mask_token = torch.nn.Parameter(torch.empty(1, dim, dtype=dtype, device=device))
-        else:
-            self.mask_token = None
-        if num_camera_tokens > 0:
-            # DA3 stores (ref_token, src_token) pairs that get injected at the
-            # alt-attn boundary; see ``Dinov2Model._inject_camera_token``.
-            self.camera_token = torch.nn.Parameter(torch.empty(1, num_camera_tokens, dim, dtype=dtype, device=device))
-        else:
-            self.camera_token = None
-
-    def interpolate_pos_encoding(self, x, h_pixels, w_pixels):
-        pos_embed = comfy.model_management.cast_to_device(self.position_embeddings, x.device, torch.float32)
-
-        class_pos = pos_embed[:, 0:1]
-        patch_pos = pos_embed[:, 1:]
-        N = patch_pos.shape[1]
-        M = int(N ** 0.5)
-        assert N == M * M, f"DINOv2 position grid must be square, got N={N} patches (sqrt={M})"
-        h0 = h_pixels // self.patch_size
-        w0 = w_pixels // self.patch_size
-        # +0.1 matches upstream DINOv2's FP-rounding workaround so the interpolate output size lands on (h0, w0).
-        # scale_factor is (height_scale, width_scale) -- height MUST come first;
-        # swapping these only happens to work for square inputs and breaks
-        # non-square paths like DA3-Small / DA3-Base multi-view.
-        scale_factor = ((h0 + 0.1) / M, (w0 + 0.1) / M)
-
-        patch_pos = patch_pos.reshape(1, M, M, -1).permute(0, 3, 1, 2)
-        patch_pos = torch.nn.functional.interpolate(patch_pos, scale_factor=scale_factor, mode="bicubic", antialias=False)
-        assert (h0, w0) == patch_pos.shape[-2:], (
-            f"Interpolated pos-embed grid {tuple(patch_pos.shape[-2:])} does not match "
-            f"target patch grid ({h0}, {w0}) for input {h_pixels}x{w_pixels} (patch_size={self.patch_size}); "
-            f"check scale_factor axis order and +0.1 rounding workaround"
-        )
-        patch_pos = patch_pos.permute(0, 2, 3, 1).flatten(1, 2)
-        return torch.cat((class_pos, patch_pos), dim=1).to(x.dtype)
+        self.cls_token = torch.nn.Parameter(torch.empty(1, 1, dim, dtype=dtype, device=device))
+        self.mask_token = torch.nn.Parameter(torch.empty(1, dim, dtype=dtype, device=device))

    def forward(self, pixel_values):
        x = self.patch_embeddings(pixel_values)
+        # TODO: mask_token?
        x = torch.cat((self.cls_token.to(device=x.device, dtype=x.dtype).expand(x.shape[0], -1, -1), x), dim=1)
-        if x.shape[1] - 1 == self.position_embeddings.shape[1] - 1:
-            x = x + comfy.model_management.cast_to_device(self.position_embeddings, x.device, x.dtype)
-        else:
-            h, w = pixel_values.shape[-2:]
-            x = x + self.interpolate_pos_encoding(x, h, w)
+        x = x + comfy.model_management.cast_to_device(self.position_embeddings, x.device, x.dtype)
        return x


@@ -296,201 +147,14 @@ class Dinov2Model(torch.nn.Module):
        heads = config_dict["num_attention_heads"]
        layer_norm_eps = config_dict["layer_norm_eps"]
        use_swiglu_ffn = config_dict["use_swiglu_ffn"]
-        patch_size = config_dict.get("patch_size", 14)
-        image_size = config_dict.get("image_size", 518)
-        use_mask_token = config_dict.get("use_mask_token", True)

-        # DA3 extensions (all default to disabled).
-        self.alt_start = config_dict.get("alt_start", -1)
-        self.qknorm_start = config_dict.get("qknorm_start", -1)
-        self.rope_start = config_dict.get("rope_start", -1)
-        self.cat_token = config_dict.get("cat_token", False)
-        rope_freq = config_dict.get("rope_freq", 100.0)
-
-        self.embed_dim = dim
-        self.patch_size = patch_size
-        self.num_register_tokens = 0
-        self.patch_start_idx = 1
-
-        if self.rope_start != -1 and rope_freq > 0:
-            self.rope = RotaryPositionEmbedding2D(frequency=rope_freq)
-            self._position_getter = _PositionGetter()
-        else:
-            self.rope = None
-            self._position_getter = None
-
-        # camera_token shape: (1, 2, dim) -> (ref_token, src_token).
-        num_cam_tokens = 2 if self.alt_start != -1 else 0
-
-        self.embeddings = Dino2Embeddings(
-            dim, dtype, device, operations,
-            patch_size=patch_size, image_size=image_size,
-            use_mask_token=use_mask_token, num_camera_tokens=num_cam_tokens,
-        )
-        self.encoder = Dino2Encoder(
-            dim, heads, layer_norm_eps, num_layers, dtype, device, operations,
-            use_swiglu_ffn=use_swiglu_ffn,
-            qknorm_start=self.qknorm_start,
-        )
+        self.embeddings = Dino2Embeddings(dim, dtype, device, operations)
+        self.encoder = Dino2Encoder(dim, heads, layer_norm_eps, num_layers, dtype, device, operations, use_swiglu_ffn = use_swiglu_ffn)
        self.layernorm = operations.LayerNorm(dim, eps=layer_norm_eps, dtype=dtype, device=device)

    def forward(self, pixel_values, attention_mask=None, intermediate_output=None):
-        if self.alt_start != -1:
-            raise RuntimeError(
-                "Dinov2Model.forward() is the backward-compatible CLIP-vision path and does not "
-                "apply DA3 extensions (RoPE, alternating attention, camera-token injection). "
-                "Use get_intermediate_layers_da3() for Depth Anything 3 models."
-            )
        x = self.embeddings(pixel_values)
        x, i = self.encoder(x, intermediate_output=intermediate_output)
        x = self.layernorm(x)
        pooled_output = x[:, 0, :]
        return x, i, pooled_output, None
-
-    def get_intermediate_layers(self, pixel_values, indices, apply_norm=True):
-        """Single-view multi-layer feature extraction."""
-        x = self.embeddings(pixel_values)
-        optimized_attention = optimized_attention_for_device(x.device, False, small_input=True)
-        n_layers = len(self.encoder.layer)
-        resolved = [(i if i >= 0 else n_layers + i) for i in indices]
-        target = set(resolved)
-        max_idx = max(resolved)
-        n_skip = 1  # skip cls token
-        cache = {}
-        for i, layer in enumerate(self.encoder.layer):
-            x = layer(x, optimized_attention)
-            if i in target:
-                normed = self.layernorm(x) if apply_norm else x
-                cache[i] = (normed[:, n_skip:], normed[:, 0])
-            if i >= max_idx:
-                break
-        return [cache[i] for i in resolved]
-
-    # ------------------------------------------------------------------
-    # Depth Anything 3 forward
-    # ------------------------------------------------------------------
-    def _prepare_rope_positions(self, B, S, H, W, device):
-        if self.rope is None:
-            return None, None
-        ph, pw = H // self.patch_size, W // self.patch_size
-        pos = self._position_getter(B * S, ph, pw, device=device)
-        # Shift so the cls/cam token at position 0 is reserved for "no diff".
-        pos = pos + 1
-        cls_pos = torch.zeros(B * S, self.patch_start_idx, 2, device=device, dtype=pos.dtype)
-        # Per-view local: real grid positions for patches, 0 for cls token.
-        pos_local = torch.cat([cls_pos, pos], dim=1)
-        # Global (across views): same grid positions; cls token still at 0,
-        # but patches share the same positions in every view.
-        pos_global = torch.cat([cls_pos, torch.zeros_like(pos) + 1], dim=1)
-        return pos_local, pos_global
-
-    def _inject_camera_token(self, x: torch.Tensor, B: int, S: int, cam_token: "torch.Tensor | None") -> torch.Tensor:
-        # x: (B, S, N, C). Replace token at index 0 with the camera token.
-        if cam_token is not None:
-            inj = cam_token
-        else:
-            ct = comfy.model_management.cast_to_device(self.embeddings.camera_token, x.device, x.dtype)
-            ref_token = ct[:, :1].expand(B, -1, -1)
-            src_token = ct[:, 1:].expand(B, max(S - 1, 0), -1)
-            inj = torch.cat([ref_token, src_token], dim=1)
-        x = x.clone()
-        x[:, :, 0] = inj
-        return x
-
-    def get_intermediate_layers_da3(self, pixel_values, out_layers, cam_token=None, ref_view_strategy="saddle_balanced", export_feat_layers=None):
-        """Multi-view multi-layer feature extraction used by Depth Anything 3."""
-        if pixel_values.ndim == 4:
-            pixel_values = pixel_values.unsqueeze(1)
-        assert pixel_values.ndim == 5 and pixel_values.shape[2] == 3, \
-            f"expected (B,3,H,W) or (B,S,3,H,W); got {tuple(pixel_values.shape)}"
-        B, S, _, H, W = pixel_values.shape
-
-        # Patch + cls + (interpolated) pos embed for each view.
-        x = pixel_values.reshape(B * S, 3, H, W)
-        x = self.embeddings(x)                          # (B*S, 1+N, C)
-        x = x.reshape(B, S, x.shape[-2], x.shape[-1])    # (B, S, 1+N, C)
-
-        pos_local, pos_global = self._prepare_rope_positions(B, S, H, W, x.device)
-        # optimized_attention is only used by blocks without QK-norm/RoPE
-        # (vanilla DINOv2 path); enabling-aware blocks fall through to SDPA.
-        optimized_attention = optimized_attention_for_device(x.device, False, small_input=True)
-
-        out_set = set(out_layers)
-        export_set = set(export_feat_layers) if export_feat_layers else set()
-        outputs: list[torch.Tensor] = []
-        aux_outputs: list[torch.Tensor] = []
-        local_x = x
-        b_idx = None
-
-
-        for i, blk in enumerate(self.encoder.layer):
-            apply_rope = self.rope is not None and i >= self.rope_start
-            block_rope = self.rope if apply_rope else None
-            l_pos = pos_local if apply_rope else None
-            g_pos = pos_global if apply_rope else None
-
-            # Reference-view selection threshold: matches the upstream constant
-            # THRESH_FOR_REF_SELECTION = 3. Skipped when a user-supplied
-            # cam_token is provided (camera info already pins the geometry).
-            if (self.alt_start != -1 and i == self.alt_start - 1 and S >= THRESH_FOR_REF_SELECTION and cam_token is None):
-                b_idx = select_reference_view(x, strategy=ref_view_strategy)
-                x = reorder_by_reference(x, b_idx)
-                local_x = reorder_by_reference(local_x, b_idx)
-
-            if self.alt_start != -1 and i == self.alt_start:
-                x = self._inject_camera_token(x, B, S, cam_token)
-
-            if self.alt_start != -1 and i >= self.alt_start and (i % 2 == 1):
-                # Global attention across views: flatten S into the seq dim.
-                t = x.reshape(B, S * x.shape[-2], x.shape[-1])
-                p = g_pos.reshape(B, S * g_pos.shape[-2], g_pos.shape[-1]) if g_pos is not None else None
-                t = blk(t, optimized_attention=optimized_attention, pos=p, rope=block_rope)
-                x = t.reshape(B, S, x.shape[-2], x.shape[-1])
-            else:
-                # Per-view local attention.
-                t = x.reshape(B * S, x.shape[-2], x.shape[-1])
-                p = l_pos.reshape(B * S, l_pos.shape[-2], l_pos.shape[-1]) if l_pos is not None else None
-                t = blk(t, optimized_attention=optimized_attention, pos=p, rope=block_rope)
-                x = t.reshape(B, S, x.shape[-2], x.shape[-1])
-                local_x = x
-
-            if i in out_set:
-                if self.cat_token:
-                    out_x = torch.cat([local_x, x], dim=-1)
-                else:
-                    out_x = x
-                # Restore original view order on the way out so heads see views
-                # in the user's expected order.
-                if b_idx is not None and self.alt_start != -1:
-                    out_x = restore_original_order(out_x, b_idx)
-                outputs.append(out_x)
-
-            if i in export_set:
-                aux = x
-                if b_idx is not None and self.alt_start != -1:
-                    aux = restore_original_order(aux, b_idx)
-                aux_outputs.append(aux)
-
-        # Apply final norm. When cat_token is set, only the right half
-        # ("global" features) is normalised; the left half is left as-is to
-        # match the upstream DA3 head signature.
-        normed: list[torch.Tensor] = []
-        cls_tokens: list[torch.Tensor] = []
-        for out_x in outputs:
-            cls_tokens.append(out_x[:, :, 0])
-            if out_x.shape[-1] == self.embed_dim:
-                normed.append(self.layernorm(out_x))
-            elif out_x.shape[-1] == self.embed_dim * 2:
-                left = out_x[..., :self.embed_dim]
-                right = self.layernorm(out_x[..., self.embed_dim:])
-                normed.append(torch.cat([left, right], dim=-1))
-            else:
-                raise ValueError(f"Unexpected token width: {out_x.shape[-1]}")
-
-        # Drop cls/cam token from the patch sequence.
-        normed = [o[..., 1 + self.num_register_tokens:, :] for o in normed]
-
-        # Final layernorm + drop cls token from auxiliary features too.
-        aux_normed = [self.layernorm(o)[..., 1 + self.num_register_tokens:, :]
-                      for o in aux_outputs]
-        return list(zip(normed, cls_tokens)), aux_normed
@@ -1,259 +0,0 @@
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-import comfy.ops
-from comfy.ldm.modules.attention import optimized_attention_for_device
-from comfy.image_encoders.dino2 import LayerScale as DINOv3ViTLayerScale
-
-
-# DINOv3 ViT-H/16+ (SwiGLU)
-DINOV3_VITH_CONFIG = {
-    "model_type": "dinov3",
-    "num_hidden_layers": 32,
-    "hidden_size": 1280,
-    "num_attention_heads": 20,
-    "num_register_tokens": 4,
-    "intermediate_size": 5120,
-    "layer_norm_eps": 1e-5,
-    "num_channels": 3,
-    "patch_size": 16,
-    "rope_theta": 100.0,
-    "use_gated_mlp": True,
-    "gated_mlp_act": "silu",
-    "image_size": 1024,
-    "image_mean": [0.485, 0.456, 0.406],
-    "image_std": [0.229, 0.224, 0.225],
-}
-
-
-class DINOv3ViTMLP(nn.Module):
-    def __init__(self, hidden_size, intermediate_size, mlp_bias, device, dtype, operations):
-        super().__init__()
-        self.hidden_size = hidden_size
-        self.intermediate_size = intermediate_size
-        self.up_proj = operations.Linear(self.hidden_size, self.intermediate_size, bias=mlp_bias, device=device, dtype=dtype)
-        self.down_proj = operations.Linear(self.intermediate_size, self.hidden_size, bias=mlp_bias, device=device, dtype=dtype)
-        self.act_fn = torch.nn.GELU()
-
-    def forward(self, x):
-        return self.down_proj(self.act_fn(self.up_proj(x)))
-
-
-def rotate_half(x):
-    x1 = x[..., : x.shape[-1] // 2]
-    x2 = x[..., x.shape[-1] // 2 :]
-    return torch.cat((-x2, x1), dim=-1)
-
-
-def apply_rotary_pos_emb(q, k, cos, sin, **kwargs):
-    num_tokens = q.shape[-2]
-    num_patches = sin.shape[-2]
-    num_prefix_tokens = num_tokens - num_patches
-
-    q_prefix_tokens, q_patches = q.split((num_prefix_tokens, num_patches), dim=-2)
-    k_prefix_tokens, k_patches = k.split((num_prefix_tokens, num_patches), dim=-2)
-
-    q_patches = (q_patches * cos) + (rotate_half(q_patches) * sin)
-    k_patches = (k_patches * cos) + (rotate_half(k_patches) * sin)
-
-    q = torch.cat((q_prefix_tokens, q_patches), dim=-2)
-    k = torch.cat((k_prefix_tokens, k_patches), dim=-2)
-
-    return q, k
-
-
-class DINOv3ViTAttention(nn.Module):
-    def __init__(self, hidden_size, num_attention_heads, device, dtype, operations):
-        super().__init__()
-        self.embed_dim = hidden_size
-        self.num_heads = num_attention_heads
-        self.head_dim = self.embed_dim // self.num_heads
-
-        self.k_proj = operations.Linear(self.embed_dim, self.embed_dim, bias=False, device=device, dtype=dtype)  # key_bias = False
-        self.v_proj = operations.Linear(self.embed_dim, self.embed_dim, bias=True, device=device, dtype=dtype)
-        self.q_proj = operations.Linear(self.embed_dim, self.embed_dim, bias=True, device=device, dtype=dtype)
-        self.o_proj = operations.Linear(self.embed_dim, self.embed_dim, bias=True, device=device, dtype=dtype)
-
-    def forward(self, hidden_states, attention_mask=None, position_embeddings=None, **kwargs):
-        batch_size, patches, _ = hidden_states.size()
-
-        query_states = self.q_proj(hidden_states)
-        key_states = self.k_proj(hidden_states)
-        value_states = self.v_proj(hidden_states)
-
-        query_states = query_states.view(batch_size, patches, self.num_heads, self.head_dim).transpose(1, 2)
-        key_states = key_states.view(batch_size, patches, self.num_heads, self.head_dim).transpose(1, 2)
-        value_states = value_states.view(batch_size, patches, self.num_heads, self.head_dim).transpose(1, 2)
-
-        if position_embeddings is not None:
-            cos, sin = position_embeddings
-            query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)
-
-        attn = optimized_attention_for_device(query_states.device, mask=False)
-        attn_output = attn(
-            query_states, key_states, value_states, self.num_heads, attention_mask,
-            skip_reshape=True, skip_output_reshape=True, low_precision_attention=False,
-        )
-
-        attn_output = attn_output.transpose(1, 2)
-        attn_output = attn_output.reshape(batch_size, patches, -1).contiguous()
-        attn_output = self.o_proj(attn_output)
-        return attn_output
-
-
-class DINOv3ViTGatedMLP(nn.Module):
-    def __init__(self, hidden_size, intermediate_size, mlp_bias, device, dtype, operations, act="silu"):
-        super().__init__()
-        self.hidden_size = hidden_size
-        self.intermediate_size = intermediate_size
-        self.gate_proj = operations.Linear(self.hidden_size, self.intermediate_size, bias=mlp_bias, device=device, dtype=dtype)
-        self.up_proj = operations.Linear(self.hidden_size, self.intermediate_size, bias=mlp_bias, device=device, dtype=dtype)
-        self.down_proj = operations.Linear(self.intermediate_size, self.hidden_size, bias=mlp_bias, device=device, dtype=dtype)
-        self.act_fn = torch.nn.SiLU() if act == "silu" else torch.nn.GELU()
-
-    def forward(self, x):
-        return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x))
-
-
-def get_patches_center_coordinates(num_patches_h, num_patches_w, dtype, device):
-    coords_h = torch.arange(0.5, num_patches_h, dtype=dtype, device=device)
-    coords_w = torch.arange(0.5, num_patches_w, dtype=dtype, device=device)
-    coords_h = coords_h / num_patches_h
-    coords_w = coords_w / num_patches_w
-    coords = torch.stack(torch.meshgrid(coords_h, coords_w, indexing="ij"), dim=-1)
-    coords = coords.flatten(0, 1)
-    coords = 2.0 * coords - 1.0
-    return coords
-
-
-class DINOv3ViTRopePositionEmbedding(nn.Module):
-    inv_freq: torch.Tensor
-
-    def __init__(self, rope_theta, hidden_size, num_attention_heads, patch_size, device, dtype):
-        super().__init__()
-        self.base = rope_theta
-        self.head_dim = hidden_size // num_attention_heads
-        self.patch_size = patch_size
-
-        inv_freq = 1 / self.base ** torch.arange(0, 1, 4 / self.head_dim, dtype=torch.float32, device=device)
-        self.register_buffer("inv_freq", inv_freq, persistent=False)
-
-    def forward(self, pixel_values):
-        _, _, height, width = pixel_values.shape
-        num_patches_h = height // self.patch_size
-        num_patches_w = width // self.patch_size
-
-        patch_coords = get_patches_center_coordinates(num_patches_h, num_patches_w, dtype=torch.float32, device=pixel_values.device)
-        self.inv_freq = self.inv_freq.to(pixel_values.device)
-        angles = 2 * math.pi * patch_coords[:, :, None] * self.inv_freq[None, None, :]
-        angles = angles.flatten(1, 2)
-        angles = angles.tile(2)
-        cos = torch.cos(angles).to(dtype=pixel_values.dtype)
-        sin = torch.sin(angles).to(dtype=pixel_values.dtype)
-        return cos, sin
-
-
-class DINOv3ViTEmbeddings(nn.Module):
-    def __init__(self, hidden_size, num_register_tokens, num_channels, patch_size, dtype, device, operations):
-        super().__init__()
-        self.cls_token = nn.Parameter(torch.empty(1, 1, hidden_size, device=device, dtype=dtype))
-        self.mask_token = nn.Parameter(torch.empty(1, 1, hidden_size, device=device, dtype=dtype))
-        self.register_tokens = nn.Parameter(torch.empty(1, num_register_tokens, hidden_size, device=device, dtype=dtype))
-        self.patch_embeddings = operations.Conv2d(
-            num_channels, hidden_size, kernel_size=patch_size, stride=patch_size, device=device, dtype=dtype
-        )
-
-    def forward(self, pixel_values, bool_masked_pos=None):
-        batch_size = pixel_values.shape[0]
-
-        patch_embeddings = self.patch_embeddings(pixel_values)
-        patch_embeddings = patch_embeddings.flatten(2).transpose(1, 2)
-
-        if bool_masked_pos is not None:
-            mask_token = comfy.ops.cast_to_input(self.mask_token, patch_embeddings)
-            patch_embeddings = torch.where(bool_masked_pos.unsqueeze(-1), mask_token, patch_embeddings)
-
-        cls_token = comfy.ops.cast_to_input(self.cls_token.expand(batch_size, -1, -1), patch_embeddings)
-        register_tokens = comfy.ops.cast_to_input(self.register_tokens.expand(batch_size, -1, -1), patch_embeddings)
-        embeddings = torch.cat([cls_token, register_tokens, patch_embeddings], dim=1)
-        return embeddings
-
-
-class DINOv3ViTLayer(nn.Module):
-    def __init__(self, hidden_size, layer_norm_eps, use_gated_mlp, mlp_bias, intermediate_size,
-                 num_attention_heads, device, dtype, operations, gated_mlp_act="silu"):
-        super().__init__()
-        self.norm1 = operations.LayerNorm(hidden_size, eps=layer_norm_eps, device=device, dtype=dtype)
-        self.attention = DINOv3ViTAttention(hidden_size, num_attention_heads, device=device, dtype=dtype, operations=operations)
-        self.layer_scale1 = DINOv3ViTLayerScale(hidden_size, device=device, dtype=dtype, operations=None)
-
-        self.norm2 = operations.LayerNorm(hidden_size, eps=layer_norm_eps, device=device, dtype=dtype)
-        if use_gated_mlp:
-            self.mlp = DINOv3ViTGatedMLP(hidden_size, intermediate_size, mlp_bias, device=device, dtype=dtype, operations=operations, act=gated_mlp_act)
-        else:
-            self.mlp = DINOv3ViTMLP(hidden_size, intermediate_size=intermediate_size, mlp_bias=mlp_bias, device=device, dtype=dtype, operations=operations)
-        self.layer_scale2 = DINOv3ViTLayerScale(hidden_size, device=device, dtype=dtype, operations=None)
-
-    def forward(self, hidden_states, attention_mask=None, position_embeddings=None):
-        residual = hidden_states
-        hidden_states = self.norm1(hidden_states)
-        hidden_states = self.attention(hidden_states, attention_mask=attention_mask, position_embeddings=position_embeddings)
-        hidden_states = self.layer_scale1(hidden_states)
-        hidden_states = hidden_states + residual
-
-        residual = hidden_states
-        hidden_states = self.norm2(hidden_states)
-        hidden_states = self.mlp(hidden_states)
-        hidden_states = self.layer_scale2(hidden_states)
-        hidden_states = hidden_states + residual
-        return hidden_states
-
-
-class DINOv3ViTModel(nn.Module):
-    def __init__(self, config, dtype, device, operations):
-        super().__init__()
-        num_hidden_layers = config["num_hidden_layers"]
-        hidden_size = config["hidden_size"]
-        num_attention_heads = config["num_attention_heads"]
-        num_register_tokens = config["num_register_tokens"]
-        intermediate_size = config["intermediate_size"]
-        layer_norm_eps = config["layer_norm_eps"]
-        num_channels = config["num_channels"]
-        patch_size = config["patch_size"]
-        rope_theta = config["rope_theta"]
-        use_gated_mlp = config.get("use_gated_mlp", False)
-        gated_mlp_act = config.get("gated_mlp_act", "silu")
-
-        self.embeddings = DINOv3ViTEmbeddings(
-            hidden_size, num_register_tokens, num_channels=num_channels, patch_size=patch_size,
-            dtype=dtype, device=device, operations=operations
-        )
-        self.rope_embeddings = DINOv3ViTRopePositionEmbedding(
-            rope_theta, hidden_size, num_attention_heads, patch_size=patch_size, dtype=dtype, device=device
-        )
-        self.layer = nn.ModuleList([
-            DINOv3ViTLayer(hidden_size, layer_norm_eps, use_gated_mlp=use_gated_mlp, mlp_bias=True,
-                           intermediate_size=intermediate_size, num_attention_heads=num_attention_heads,
-                           dtype=dtype, device=device, operations=operations, gated_mlp_act=gated_mlp_act)
-            for _ in range(num_hidden_layers)])
-        self.norm = operations.LayerNorm(hidden_size, eps=layer_norm_eps, dtype=dtype, device=device)
-
-    def get_input_embeddings(self):
-        return self.embeddings.patch_embeddings
-
-    def forward(self, pixel_values, bool_masked_pos=None, **kwargs):
-        hidden_states = self.embeddings(pixel_values, bool_masked_pos=bool_masked_pos)
-        position_embeddings = self.rope_embeddings(pixel_values)
-
-        for layer_module in self.layer:
-            hidden_states = layer_module(hidden_states, position_embeddings=position_embeddings)
-
-        if kwargs.get("skip_norm_elementwise", False):
-            sequence_output = F.layer_norm(hidden_states, hidden_states.shape[-1:])
-        else:
-            norm = self.norm.to(hidden_states.device)
-            sequence_output = norm(hidden_states)
-        pooled_output = sequence_output[:, 0, :]
-        return sequence_output, None, pooled_output, None
@@ -150,12 +150,6 @@ class SD3(LatentFormat):
 class StableAudio1(LatentFormat):
    latent_channels = 64
    latent_dimensions = 1
-    temporal_downscale_ratio = 2048
-
-class StableAudio3(LatentFormat):
-    latent_channels = 256
-    latent_dimensions = 1
-    temporal_downscale_ratio = 4096

 class Flux(SD3):
    latent_channels = 16
@@ -239,16 +233,6 @@ class Flux2(LatentFormat):
    def process_out(self, latent):
        return latent

-class TripoSplat(LatentFormat):
-    # Sequence latent (B, 8192, 16) the camera token rides alongside as a second nested latent
-    latent_channels = 16
-
-    def process_in(self, latent):
-        return latent
-
-    def process_out(self, latent):
-        return latent
-
 class Mochi(LatentFormat):
    latent_channels = 12
    latent_dimensions = 3
@@ -782,7 +766,6 @@ class ACEAudio(LatentFormat):
 class ACEAudio15(LatentFormat):
    latent_channels = 64
    latent_dimensions = 1
-    temporal_downscale_ratio = 1764

 class ChromaRadiance(LatentFormat):
    latent_channels = 3
@@ -809,15 +792,13 @@ class ZImagePixelSpace(ChromaRadiance):
    """
    pass

+
 class HiDreamO1Pixel(ChromaRadiance):
    """Pixel-space latent format for HiDream-O1.
    No VAE — model patches/unpatches raw RGB internally with patch_size=32.
    """
    pass

-class PixelDiTPixel(ChromaRadiance):
-    pass
-
 class CogVideoX(LatentFormat):
    """Latent format for CogVideoX-2b (THUDM/CogVideoX-2b).

@@ -217,7 +217,10 @@ class AceStepAttention(nn.Module):
                cos, sin = position_embeddings
                query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)

-        gqa_kwargs = {"enable_gqa": True} if self.num_heads != self.num_kv_heads else {}
+        n_rep = self.num_heads // self.num_kv_heads
+        if n_rep > 1:
+            key_states = key_states.repeat_interleave(n_rep, dim=1)
+            value_states = value_states.repeat_interleave(n_rep, dim=1)

        attn_bias = None
        if self.sliding_window is not None and not self.is_cross_attention:
@@ -241,7 +244,7 @@ class AceStepAttention(nn.Module):
            else:
                attn_bias = window_bias

-        attn_output = optimized_attention(query_states, key_states, value_states, self.num_heads, attn_bias, skip_reshape=True, low_precision_attention=False, **gqa_kwargs)
+        attn_output = optimized_attention(query_states, key_states, value_states, self.num_heads, attn_bias, skip_reshape=True, low_precision_attention=False)
        attn_output = self.o_proj(attn_output)

        return attn_output
@@ -10,17 +10,6 @@ from torch import nn
 from torch.nn import functional as F
 import math
 import comfy.ops
-from .embedders import ExpoFourierFeatures
-
-
-def _left_pad_to_match(emb, target_len):
-    emb_len = emb.shape[-2]
-    if emb_len < target_len:
-        return F.pad(emb, (0, 0, target_len - emb_len, 0), value=0.)
-    elif emb_len > target_len:
-        return emb[:, -target_len:, :]
-    return emb
-

 class FourierFeatures(nn.Module):
    def __init__(self, in_features, out_features, std=1., dtype=None, device=None):
@@ -33,7 +22,6 @@ class FourierFeatures(nn.Module):
        f = 2 * math.pi * input @ comfy.ops.cast_to_input(self.weight.T, input)
        return torch.cat([f.cos(), f.sin()], dim=-1)

-
 # norms
 class LayerNorm(nn.Module):
    def __init__(self, dim, bias=False, fix_scale=False, dtype=None, device=None):
@@ -55,16 +43,6 @@ class LayerNorm(nn.Module):
            beta = comfy.ops.cast_to_input(beta, x)
        return F.layer_norm(x, x.shape[-1:], weight=comfy.ops.cast_to_input(self.gamma, x), bias=beta)

-
-class RMSNorm(nn.Module):
-    def __init__(self, dim, dtype=None, device=None):
-        super().__init__()
-        self.gamma = nn.Parameter(torch.empty(dim, dtype=dtype, device=device))
-
-    def forward(self, x):
-        return F.rms_norm(x, x.shape[-1:], weight=comfy.ops.cast_to_input(self.gamma, x))
-
-
 class GLU(nn.Module):
    def __init__(
        self,
@@ -258,6 +236,13 @@ class FeedForward(nn.Module):

        linear_out = operations.Linear(inner_dim, dim_out, bias = not no_bias, dtype=dtype, device=device) if not use_conv else operations.Conv1d(inner_dim, dim_out, conv_kernel_size, padding = (conv_kernel_size // 2), bias = not no_bias, dtype=dtype, device=device)

+        # # init last linear layer to 0
+        # if zero_init_output:
+        #     nn.init.zeros_(linear_out.weight)
+        #     if not no_bias:
+        #         nn.init.zeros_(linear_out.bias)
+
+
        self.ff = nn.Sequential(
            linear_in,
            rearrange('b d n -> b n d') if use_conv else nn.Identity(),
@@ -276,10 +261,8 @@ class Attention(nn.Module):
        dim_context = None,
        causal = False,
        zero_init_output=True,
-        qk_norm = "none",
-        differential = False,
+        qk_norm = False,
        natten_kernel_size = None,
-        feat_scale = False,
        dtype=None,
        device=None,
        operations=None,
@@ -288,7 +271,6 @@ class Attention(nn.Module):
        self.dim = dim
        self.dim_heads = dim_heads
        self.causal = causal
-        self.differential = differential

        dim_kv = dim_context if dim_context is not None else dim

@@ -296,37 +278,18 @@ class Attention(nn.Module):
        self.kv_heads = dim_kv // dim_heads

        if dim_context is not None:
-            if differential:
-                self.to_q = operations.Linear(dim, dim * 2, bias=False, dtype=dtype, device=device)
-                self.to_kv = operations.Linear(dim_kv, dim_kv * 3, bias=False, dtype=dtype, device=device)
-            else:
-                self.to_q = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device)
-                self.to_kv = operations.Linear(dim_kv, dim_kv * 2, bias=False, dtype=dtype, device=device)
+            self.to_q = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device)
+            self.to_kv = operations.Linear(dim_kv, dim_kv * 2, bias=False, dtype=dtype, device=device)
        else:
-            if differential:
-                self.to_qkv = operations.Linear(dim, dim * 5, bias=False, dtype=dtype, device=device)
-            else:
-                self.to_qkv = operations.Linear(dim, dim * 3, bias=False, dtype=dtype, device=device)
+            self.to_qkv = operations.Linear(dim, dim * 3, bias=False, dtype=dtype, device=device)

        self.to_out = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device)

-        # Accept bool for backward compat
-        if isinstance(qk_norm, bool):
-            qk_norm = "l2" if qk_norm else "none"
+        # if zero_init_output:
+        #     nn.init.zeros_(self.to_out.weight)
+
        self.qk_norm = qk_norm

-        if self.qk_norm == "ln":
-            self.q_norm = operations.LayerNorm(dim_heads, elementwise_affine=True, eps=1.0e-6, dtype=dtype, device=device)
-            self.k_norm = operations.LayerNorm(dim_heads, elementwise_affine=True, eps=1.0e-6, dtype=dtype, device=device)
-        elif self.qk_norm == "rms":
-            self.q_norm = RMSNorm(dim_heads, dtype=dtype, device=device)
-            self.k_norm = RMSNorm(dim_heads, dtype=dtype, device=device)
-
-        self.feat_scale = feat_scale
-
-        if self.feat_scale:
-            self.lambda_dc = nn.Parameter(torch.empty(dim, dtype=dtype, device=device))
-            self.lambda_hf = nn.Parameter(torch.empty(dim, dtype=dtype, device=device))

    def forward(
        self,
@@ -343,51 +306,22 @@ class Attention(nn.Module):
        kv_input = context if has_context else x

        if hasattr(self, 'to_q'):
-            if self.differential:
-                # cross-attention differential: to_q → (q, q_diff), to_kv → (k, k_diff, v)
-                q, q_diff = self.to_q(x).chunk(2, dim=-1)
-                q      = rearrange(q,      'b n (h d) -> b h n d', h=h)
-                q_diff = rearrange(q_diff, 'b n (h d) -> b h n d', h=h)
-                q = torch.stack([q, q_diff], dim=1)  # (B, 2, H, N, D)
-                k, k_diff, v = self.to_kv(kv_input).chunk(3, dim=-1)
-                k      = rearrange(k,      'b n (h d) -> b h n d', h=kv_h)
-                k_diff = rearrange(k_diff, 'b n (h d) -> b h n d', h=kv_h)
-                v      = rearrange(v,      'b n (h d) -> b h n d', h=kv_h)
-                k = torch.stack([k, k_diff], dim=1)  # (B, 2, H, M, D)
-            else:
-                # Use separate linear projections for q and k/v
-                q = self.to_q(x)
-                q = rearrange(q, 'b n (h d) -> b h n d', h = h)
+            # Use separate linear projections for q and k/v
+            q = self.to_q(x)
+            q = rearrange(q, 'b n (h d) -> b h n d', h = h)

-                k, v = self.to_kv(kv_input).chunk(2, dim=-1)
+            k, v = self.to_kv(kv_input).chunk(2, dim=-1)

-                k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = kv_h), (k, v))
+            k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = kv_h), (k, v))
        else:
-            if self.differential:
-                # self-attention differential: to_qkv → (q, k, v, q_diff, k_diff)
-                q, k, v, q_diff, k_diff = self.to_qkv(x).chunk(5, dim=-1)
-                q, k, v, q_diff, k_diff = map(
-                    lambda t: rearrange(t, 'b n (h d) -> b h n d', h=h),
-                    (q, k, v, q_diff, k_diff)
-                )
-                q = torch.stack([q, q_diff], dim=1)  # (B, 2, H, N, D)
-                k = torch.stack([k, k_diff], dim=1)
-            else:
-                # Use fused linear projection
-                q, k, v = self.to_qkv(x).chunk(3, dim=-1)
-                q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = h), (q, k, v))
+            # Use fused linear projection
+            q, k, v = self.to_qkv(x).chunk(3, dim=-1)
+            q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = h), (q, k, v))

        # Normalize q and k for cosine sim attention
-        if self.qk_norm == "l2":
+        if self.qk_norm:
            q = F.normalize(q, dim=-1)
            k = F.normalize(k, dim=-1)
-        elif self.qk_norm == "rms":
-            q_type, k_type = q.dtype, k.dtype
-            q = self.q_norm(q).to(q_type)
-            k = self.k_norm(k).to(k_type)
-        elif self.qk_norm != 'none':
-            q = self.q_norm(q)
-            k = self.k_norm(k)

        if rotary_pos_emb is not None and not has_context:
            freqs, _ = rotary_pos_emb
@@ -425,26 +359,14 @@ class Attention(nn.Module):
        if n == 1 and causal:
            causal = False

-        gqa_kwargs = {"enable_gqa": True} if h != kv_h else {}
-
-        if self.differential:
-            q, q_diff = q.unbind(dim=1)
-            k, k_diff = k.unbind(dim=1)
-            out      = optimized_attention(q,      k,      v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options, **gqa_kwargs)
-            out_diff = optimized_attention(q_diff, k_diff, v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options, **gqa_kwargs)
-            out = out - out_diff
-        else:
-            out = optimized_attention(q, k, v, h, skip_reshape=True, low_precision_attention=False, transformer_options=transformer_options, **gqa_kwargs)
+        if h != kv_h:
+            # Repeat interleave kv_heads to match q_heads
+            heads_per_kv_head = h // kv_h
+            k, v = map(lambda t: t.repeat_interleave(heads_per_kv_head, dim = 1), (k, v))

+        out = optimized_attention(q, k, v, h, skip_reshape=True, transformer_options=transformer_options)
        out = self.to_out(out)

-        if self.feat_scale:
-            out_dc = out.mean(dim=-2, keepdim=True)
-            out_hf = out - out_dc
-
-            # Selectively modulate DC and high frequency components
-            out = out + comfy.ops.cast_to_input(self.lambda_dc, out) * out_dc + comfy.ops.cast_to_input(self.lambda_hf, out) * out_hf
-
        if mask is not None:
            mask = rearrange(mask, 'b n -> b n 1')
            out = out.masked_fill(~mask, 0.)
@@ -495,14 +417,11 @@ class TransformerBlock(nn.Module):
            cross_attend = False,
            dim_context = None,
            global_cond_dim = None,
-            global_cond_shared_embed = False,
-            local_add_cond_dim = None,
            causal = False,
            zero_init_branch_outputs = True,
            conformer = False,
            layer_ix = -1,
            remove_norms = False,
-            norm_type = "layer_norm",
            attn_kwargs = {},
            ff_kwargs = {},
            norm_kwargs = {},
@@ -517,20 +436,8 @@ class TransformerBlock(nn.Module):
        self.cross_attend = cross_attend
        self.dim_context = dim_context
        self.causal = causal
-        self.global_cond_shared_embed = global_cond_shared_embed

-        norm_layer_map = {
-            "layer_norm": LayerNorm,
-            "rms_norm": RMSNorm,
-        }
-        norm_cls = norm_layer_map.get(norm_type, LayerNorm)
-
-        def make_norm():
-            if remove_norms:
-                return nn.Identity()
-            return norm_cls(dim, dtype=dtype, device=device, **norm_kwargs)
-
-        self.pre_norm = make_norm()
+        self.pre_norm = LayerNorm(dim, dtype=dtype, device=device, **norm_kwargs) if not remove_norms else nn.Identity()

        self.self_attn = Attention(
            dim,
@@ -544,7 +451,7 @@ class TransformerBlock(nn.Module):
        )

        if cross_attend:
-            self.cross_attend_norm = make_norm()
+            self.cross_attend_norm = LayerNorm(dim, dtype=dtype, device=device, **norm_kwargs) if not remove_norms else nn.Identity()
            self.cross_attn = Attention(
                dim,
                dim_heads = dim_heads,
@@ -557,56 +464,37 @@ class TransformerBlock(nn.Module):
                **attn_kwargs
            )

-        self.ff_norm = make_norm()
-        self.ff = FeedForward(dim, zero_init_output=zero_init_branch_outputs, dtype=dtype, device=device, operations=operations, **ff_kwargs)
+        self.ff_norm = LayerNorm(dim, dtype=dtype, device=device, **norm_kwargs) if not remove_norms else nn.Identity()
+        self.ff = FeedForward(dim, zero_init_output=zero_init_branch_outputs, dtype=dtype, device=device, operations=operations,**ff_kwargs)

        self.layer_ix = layer_ix

        self.conformer = ConformerModule(dim, norm_kwargs=norm_kwargs) if conformer else None

-        # Global conditioning
-        self.has_global_cond = (global_cond_dim is not None) or global_cond_shared_embed
+        self.global_cond_dim = global_cond_dim

-        if global_cond_shared_embed:
-            # SA3 style: learnable per-block additive bias; global_cond is pre-projected to (B, dim*6)
-            self.to_scale_shift_gate = nn.Parameter(torch.empty(dim * 6, device=device, dtype=dtype))
-        elif global_cond_dim is not None:
-            # SA1 style: per-block MLP projects global_cond → (B, dim*6)
+        if global_cond_dim is not None:
            self.to_scale_shift_gate = nn.Sequential(
                nn.SiLU(),
-                operations.Linear(global_cond_dim, dim * 6, bias=False, device=device, dtype=dtype)
+                nn.Linear(global_cond_dim, dim * 6, bias=False)
            )

-        # Local additive conditioning (e.g. inpaint mask + masked latent)
-        self.local_add_cond_dim = local_add_cond_dim
-        if local_add_cond_dim is not None:
-            self.to_local_embed = nn.Sequential(
-                operations.Linear(local_add_cond_dim, dim, bias=True, dtype=dtype, device=device),
-                nn.SiLU(),
-                operations.Linear(dim, dim, bias=True, dtype=dtype, device=device),
-            )
-        else:
-            self.to_local_embed = None
+            nn.init.zeros_(self.to_scale_shift_gate[1].weight)
+            #nn.init.zeros_(self.to_scale_shift_gate_self[1].bias)

    def forward(
        self,
        x,
        context = None,
        global_cond=None,
-        local_add_cond=None,
        mask = None,
        context_mask = None,
        rotary_pos_emb = None,
        transformer_options={}
    ):
-        if self.has_global_cond and global_cond is not None:
-            if self.global_cond_shared_embed:
-                # global_cond already has shape (B, dim*6)
-                ssg = (comfy.ops.cast_to_input(self.to_scale_shift_gate, global_cond) + global_cond).unsqueeze(1)
-            else:
-                ssg = self.to_scale_shift_gate(global_cond).unsqueeze(1)
+        if self.global_cond_dim is not None and self.global_cond_dim > 0 and global_cond is not None:

-            scale_self, shift_self, gate_self, scale_ff, shift_ff, gate_ff = ssg.chunk(6, dim = -1)
+            scale_self, shift_self, gate_self, scale_ff, shift_ff, gate_ff = self.to_scale_shift_gate(global_cond).unsqueeze(1).chunk(6, dim = -1)

            # self-attention with adaLN
            residual = x
@@ -622,9 +510,6 @@ class TransformerBlock(nn.Module):
            if self.conformer is not None:
                x = x + self.conformer(x)

-            if local_add_cond is not None and self.to_local_embed is not None:
-                x = x + _left_pad_to_match(self.to_local_embed(local_add_cond), x.shape[-2])
-
            # feedforward with adaLN
            residual = x
            x = self.ff_norm(x)
@@ -642,9 +527,6 @@ class TransformerBlock(nn.Module):
            if self.conformer is not None:
                x = x + self.conformer(x)

-            if local_add_cond is not None and self.to_local_embed is not None:
-                x = x + _left_pad_to_match(self.to_local_embed(local_add_cond), x.shape[-2])
-
            x = x + self.ff(self.ff_norm(x))

        return x
@@ -661,8 +543,6 @@ class ContinuousTransformer(nn.Module):
        cross_attend=False,
        cond_token_dim=None,
        global_cond_dim=None,
-        global_cond_shared_embed=False,
-        local_add_cond_dim=None,
        causal=False,
        rotary_pos_emb=True,
        zero_init_branch_outputs=True,
@@ -670,7 +550,6 @@ class ContinuousTransformer(nn.Module):
        use_sinusoidal_emb=False,
        use_abs_pos_emb=False,
        abs_pos_emb_max_length=10000,
-        num_memory_tokens=0,
        dtype=None,
        device=None,
        operations=None,
@@ -683,8 +562,6 @@ class ContinuousTransformer(nn.Module):
        self.depth = depth
        self.causal = causal
        self.layers = nn.ModuleList([])
-        self.num_memory_tokens = num_memory_tokens
-        self.global_cond_shared_embed = global_cond_shared_embed

        self.project_in = operations.Linear(dim_in, dim, bias=False, dtype=dtype, device=device) if dim_in is not None else nn.Identity()
        self.project_out = operations.Linear(dim, dim_out, bias=False, dtype=dtype, device=device) if dim_out is not None else nn.Identity()
@@ -700,22 +577,7 @@ class ContinuousTransformer(nn.Module):

        self.use_abs_pos_emb = use_abs_pos_emb
        if use_abs_pos_emb:
-            self.pos_emb = AbsolutePositionalEmbedding(dim, abs_pos_emb_max_length + num_memory_tokens)
-
-        if num_memory_tokens > 0:
-            self.memory_tokens = nn.Parameter(torch.empty(num_memory_tokens, dim, device=device, dtype=dtype))
-
-        # Shared global-cond embedder (SA3 style): projects (B, global_cond_dim) → (B, dim*6)
-        self.global_cond_embedder = None
-        if global_cond_shared_embed and global_cond_dim is not None:
-            self.global_cond_embedder = nn.Sequential(
-                operations.Linear(global_cond_dim, dim, bias=True, dtype=dtype, device=device),
-                nn.SiLU(),
-                operations.Linear(dim, dim * 6, bias=True, dtype=dtype, device=device),
-            )
-
-        # When using shared embed, TransformerBlocks use per-block Parameter (not per-block MLP)
-        block_global_cond_dim = None if global_cond_shared_embed else global_cond_dim
+            self.pos_emb = AbsolutePositionalEmbedding(dim, abs_pos_emb_max_length)

        for i in range(depth):
            self.layers.append(
@@ -724,9 +586,7 @@ class ContinuousTransformer(nn.Module):
                    dim_heads = dim_heads,
                    cross_attend = cross_attend,
                    dim_context = cond_token_dim,
-                    global_cond_dim = block_global_cond_dim,
-                    global_cond_shared_embed = global_cond_shared_embed,
-                    local_add_cond_dim = local_add_cond_dim,
+                    global_cond_dim = global_cond_dim,
                    causal = causal,
                    zero_init_branch_outputs = zero_init_branch_outputs,
                    conformer=conformer,
@@ -745,7 +605,6 @@ class ContinuousTransformer(nn.Module):
        prepend_embeds = None,
        prepend_mask = None,
        global_cond = None,
-        local_add_cond = None,
        return_info = False,
        **kwargs
    ):
@@ -773,9 +632,7 @@ class ContinuousTransformer(nn.Module):

                mask = torch.cat((prepend_mask, mask), dim = -1)

-        if self.num_memory_tokens > 0:
-            memory_tokens = comfy.ops.cast_to_input(self.memory_tokens, x).expand(batch, -1, -1)
-            x = torch.cat((memory_tokens, x), dim=1)
+        # Attention layers

        if self.rotary_pos_emb is not None:
            rotary_pos_emb = self.rotary_pos_emb.forward_from_seq_len(x.shape[1], dtype=torch.float, device=x.device)
@@ -785,10 +642,6 @@ class ContinuousTransformer(nn.Module):
        if self.use_sinusoidal_emb or self.use_abs_pos_emb:
            x = x + self.pos_emb(x)

-        # Project global_cond once (SA3 shared-embed path)
-        if global_cond is not None and self.global_cond_embedder is not None:
-            global_cond = self.global_cond_embedder(global_cond)
-
        blocks_replace = patches_replace.get("dit", {})
        # Iterate over the transformer layers
        for i, layer in enumerate(self.layers):
@@ -801,17 +654,12 @@ class ContinuousTransformer(nn.Module):
                out = blocks_replace[("double_block", i)]({"img": x, "txt": context, "vec": global_cond, "pe": rotary_pos_emb, "transformer_options": transformer_options}, {"original_block": block_wrap})
                x = out["img"]
            else:
-                x = layer(x, rotary_pos_emb=rotary_pos_emb, global_cond=global_cond,
-                          local_add_cond=local_add_cond, context=context,
-                          transformer_options=transformer_options)
+                x = layer(x, rotary_pos_emb = rotary_pos_emb, global_cond=global_cond, context=context, transformer_options=transformer_options)
+            # x = checkpoint(layer, x, rotary_pos_emb = rotary_pos_emb, global_cond=global_cond, **kwargs)

            if return_info:
                info["hidden_states"].append(x)

-        # Strip memory tokens before projecting out
-        if self.num_memory_tokens > 0:
-            x = x[:, self.num_memory_tokens:, :]
-
        x = self.project_out(x)

        if return_info:
@@ -834,7 +682,6 @@ class AudioDiffusionTransformer(nn.Module):
        num_heads=24,
        transformer_type: tp.Literal["continuous_transformer"] = "continuous_transformer",
        global_cond_type: tp.Literal["prepend", "adaLN"] = "prepend",
-        timestep_features_type: str = "learned",
        audio_model="",
        dtype=None,
        device=None,
@@ -849,10 +696,7 @@ class AudioDiffusionTransformer(nn.Module):
        # Timestep embeddings
        timestep_features_dim = 256

-        if timestep_features_type == "expo":
-            self.timestep_features = ExpoFourierFeatures(timestep_features_dim, 0.5, 10000.0)
-        else:
-            self.timestep_features = FourierFeatures(1, timestep_features_dim, dtype=dtype, device=device)
+        self.timestep_features = FourierFeatures(1, timestep_features_dim, dtype=dtype, device=device)

        self.to_timestep_embed = nn.Sequential(
            operations.Linear(timestep_features_dim, embed_dim, bias=True, dtype=dtype, device=device),
@@ -937,7 +781,6 @@ class AudioDiffusionTransformer(nn.Module):
        cross_attn_cond=None,
        cross_attn_cond_mask=None,
        input_concat_cond=None,
-        local_add_cond=None,
        global_embed=None,
        prepend_cond=None,
        prepend_cond_mask=None,
@@ -959,13 +802,9 @@ class AudioDiffusionTransformer(nn.Module):
            prepend_cond = self.to_prepend_embed(prepend_cond)

            prepend_inputs = prepend_cond
-            prepend_length = prepend_cond.shape[1]
            if prepend_cond_mask is not None:
                prepend_mask = prepend_cond_mask

-        if local_add_cond is not None and local_add_cond.dim() == 3:
-            local_add_cond = local_add_cond.permute(0, 2, 1)
-
        if input_concat_cond is not None:

            # Interpolate input_concat_cond to the same length as x
@@ -1011,7 +850,7 @@ class AudioDiffusionTransformer(nn.Module):
        if self.transformer_type == "x-transformers":
            output = self.transformer(x, prepend_embeds=prepend_inputs, context=cross_attn_cond, context_mask=cross_attn_cond_mask, mask=mask, prepend_mask=prepend_mask, **extra_args, **kwargs)
        elif self.transformer_type == "continuous_transformer":
-            output = self.transformer(x, prepend_embeds=prepend_inputs, context=cross_attn_cond, context_mask=cross_attn_cond_mask, mask=mask, prepend_mask=prepend_mask, return_info=return_info, local_add_cond=local_add_cond, **extra_args, **kwargs)
+            output = self.transformer(x, prepend_embeds=prepend_inputs, context=cross_attn_cond, context_mask=cross_attn_cond_mask, mask=mask, prepend_mask=prepend_mask, return_info=return_info, **extra_args, **kwargs)

            if return_info:
                output, info = output
@@ -1037,7 +876,6 @@ class AudioDiffusionTransformer(nn.Module):
        context=None,
        context_mask=None,
        input_concat_cond=None,
-        local_add_cond=None,
        global_embed=None,
        negative_global_embed=None,
        prepend_cond=None,
@@ -1052,7 +890,6 @@ class AudioDiffusionTransformer(nn.Module):
                cross_attn_cond=context,
                cross_attn_cond_mask=context_mask,
                input_concat_cond=input_concat_cond,
-                local_add_cond=local_add_cond,
                global_embed=global_embed,
                prepend_cond=prepend_cond,
                prepend_cond_mask=prepend_cond_mask,
@@ -31,39 +31,15 @@ def TimePositionalEmbedding(dim: int, out_features: int) -> nn.Module:
    )


-class ExpoFourierFeatures(nn.Module):
-    """Exponentially-spaced Fourier features (no learnable parameters)."""
-    def __init__(self, dim, min_freq=0.5, max_freq=10000.0):
-        super().__init__()
-        self.dim = dim
-        self.min_freq = min_freq
-        self.max_freq = max_freq
-
-    def forward(self, t):
-        in_dtype = t.dtype
-        t = t.float()
-        if t.dim() == 1:
-            t = t.unsqueeze(-1)
-        half_dim = self.dim // 2
-        ramp = torch.linspace(0, 1, half_dim, device=t.device, dtype=torch.float32)
-        freqs = torch.exp(ramp * (math.log(self.max_freq) - math.log(self.min_freq)) + math.log(self.min_freq))
-        args = t * freqs * 2 * math.pi
-        return torch.cat([args.cos(), args.sin()], dim=-1).to(in_dtype)
-
-
 class NumberEmbedder(nn.Module):
    def __init__(
        self,
        features: int,
        dim: int = 256,
-        fourier_features_type="learned",
    ):
        super().__init__()
        self.features = features
-        if fourier_features_type == "expo":
-            self.embedding = nn.Sequential(ExpoFourierFeatures(dim=dim), comfy.ops.manual_cast.Linear(in_features=dim, out_features=features))
-        else:
-            self.embedding = TimePositionalEmbedding(dim=dim, out_features=features)
+        self.embedding = TimePositionalEmbedding(dim=dim, out_features=features)

    def forward(self, x: Union[List[float], Tensor]) -> Tensor:
        if not torch.is_tensor(x):
@@ -101,15 +77,14 @@ class NumberConditioner(Conditioner):
    def __init__(self,
                output_dim: int,
                min_val: float=0,
-                max_val: float=1,
-                fourier_features_type: str = "learned",
+                max_val: float=1
                ):
        super().__init__(output_dim, output_dim)

        self.min_val = min_val
        self.max_val = max_val

-        self.embedder = NumberEmbedder(features=output_dim, fourier_features_type=fourier_features_type)
+        self.embedder = NumberEmbedder(features=output_dim)

    def forward(self, floats, device=None):
            # Cast the inputs to floats
@@ -1,533 +0,0 @@
-import torch
-import torch.nn as nn
-
-import comfy.ops
-import comfy.model_management
-from comfy.ldm.modules.attention import optimized_attention
-from comfy.ldm.audio.autoencoder import WNConv1d
-
-ops = comfy.ops.disable_weight_init
-
-class Transpose(nn.Module):
-    def forward(self, x, **kwargs):
-        return x.transpose(-2, -1)
-
-
-def _zero_pad_modulo_sequence(x, size, dim=-2):
-    input_len = x.shape[dim]
-    pad_len = (size - input_len % size) % size
-    if pad_len > 0:
-        pad_shape = list(x.shape)
-        pad_shape[dim] = pad_len
-        x = torch.cat([x, torch.zeros(pad_shape, device=x.device, dtype=x.dtype)], dim=dim)
-    return x
-
-
-def _sliding_window_mask(seq_len, window, device, dtype):
-    """Additive attention mask enforcing a ±window local window (matches flash_attn window_size)."""
-    i = torch.arange(seq_len, device=device).unsqueeze(1)
-    j = torch.arange(seq_len, device=device).unsqueeze(0)
-    out_of_window = (j - i).abs() > window
-    return torch.where(
-        out_of_window,
-        torch.full((1,), torch.finfo(dtype).min / 4, device=device, dtype=dtype),
-        torch.zeros(1, device=device, dtype=dtype),
-    )
-
-
-class DynamicTanh(nn.Module):
-    def __init__(self, dim, init_alpha=4.0, dtype=None, device=None, **kwargs):
-        super().__init__()
-        self.alpha = nn.Parameter(torch.empty(1, dtype=dtype, device=device))
-        self.gamma = nn.Parameter(torch.empty(dim, dtype=dtype, device=device))
-        self.beta = nn.Parameter(torch.empty(dim, dtype=dtype, device=device))
-
-    def forward(self, x):
-        alpha = comfy.ops.cast_to_input(self.alpha, x)
-        gamma = comfy.ops.cast_to_input(self.gamma, x)
-        beta = comfy.ops.cast_to_input(self.beta, x)
-        return gamma * torch.tanh(alpha * x) + beta
-
-
-class RotaryEmbedding(nn.Module):
-    def __init__(self, dim, base=10000, base_rescale_factor=1., dtype=None, device=None):
-        super().__init__()
-        base = base * base_rescale_factor ** (dim / (dim - 2))
-        self.register_buffer("inv_freq", torch.empty(dim // 2, dtype=dtype, device=device))
-
-    def forward_from_seq_len(self, seq_len, device, dtype=None):
-        t = torch.arange(seq_len, device=device, dtype=torch.float32)
-        return self.forward(t)
-
-    def forward(self, t):
-        freqs = torch.outer(t.float(), comfy.model_management.cast_to(self.inv_freq, dtype=torch.float32, device=t.device))
-        freqs = torch.cat((freqs, freqs), dim=-1)
-        return freqs, 1.
-
-
-def _rotate_half(x):
-    d = x.shape[-1] // 2
-    return torch.cat((-x[..., d:], x[..., :d]), dim=-1)
-
-
-def _apply_rotary_pos_emb(t, freqs):
-    out_dtype = t.dtype
-    rot_dim = freqs.shape[-1]
-    seq_len = t.shape[-2]
-    freqs = freqs[-seq_len:]
-    t_rot, t_pass = t[..., :rot_dim], t[..., rot_dim:]
-    t_rot = t_rot * freqs.cos() + _rotate_half(t_rot) * freqs.sin()
-    return torch.cat((t_rot.to(out_dtype), t_pass.to(out_dtype)), dim=-1)
-
-
-class Attention(nn.Module):
-    def __init__(self, dim, dim_heads=64, qk_norm="none", qk_norm_eps=1e-6,
-                 differential=False, zero_init_output=True,
-                 dtype=None, device=None, operations=None, **kwargs):
-        super().__init__()
-        self.num_heads = dim // dim_heads
-        self.differential = differential
-        self.qk_norm = qk_norm
-
-        self.to_qkv = operations.Linear(
-            dim, dim * (5 if differential else 3), bias=False, dtype=dtype, device=device)
-        self.to_out = operations.Linear(dim, dim, bias=False, dtype=dtype, device=device)
-
-        if qk_norm == "dyt":
-            self.q_norm = DynamicTanh(dim_heads, dtype=dtype, device=device)
-            self.k_norm = DynamicTanh(dim_heads, dtype=dtype, device=device)
-        elif qk_norm == "rms":
-            self.q_norm = operations.RMSNorm(dim_heads, eps=qk_norm_eps, dtype=dtype, device=device)
-            self.k_norm = operations.RMSNorm(dim_heads, eps=qk_norm_eps, dtype=dtype, device=device)
-
-    def forward(self, x, rotary_pos_emb=None, mask=None, **kwargs):
-        B, N, _ = x.shape
-        h = self.num_heads
-
-        qkv = self.to_qkv(x)
-        if self.differential:
-            q, k, v, q_diff, k_diff = qkv.chunk(5, dim=-1)
-            del qkv
-            q = q.view(B, N, h, -1).transpose(1, 2)
-            k = k.view(B, N, h, -1).transpose(1, 2)
-            v = v.view(B, N, h, -1).transpose(1, 2)
-            q_diff = q_diff.view(B, N, h, -1).transpose(1, 2)
-            k_diff = k_diff.view(B, N, h, -1).transpose(1, 2)
-        else:
-            q, k, v = qkv.chunk(3, dim=-1)
-            del qkv
-            q = q.view(B, N, h, -1).transpose(1, 2)
-            k = k.view(B, N, h, -1).transpose(1, 2)
-            v = v.view(B, N, h, -1).transpose(1, 2)
-
-        if self.qk_norm != "none":
-            q_dtype, k_dtype = q.dtype, k.dtype
-            q = self.q_norm(q).to(q_dtype)
-            k = self.k_norm(k).to(k_dtype)
-            if self.differential:
-                q_diff = self.q_norm(q_diff).to(q_dtype)
-                k_diff = self.k_norm(k_diff).to(k_dtype)
-
-        if rotary_pos_emb is not None:
-            freqs, _ = rotary_pos_emb
-            q_dtype, k_dtype = q.dtype, k.dtype
-            q = _apply_rotary_pos_emb(q.float(), freqs).to(q_dtype)
-            k = _apply_rotary_pos_emb(k.float(), freqs).to(k_dtype)
-            if self.differential:
-                q_diff = _apply_rotary_pos_emb(q_diff.float(), freqs).to(q_dtype)
-                k_diff = _apply_rotary_pos_emb(k_diff.float(), freqs).to(k_dtype)
-
-        if self.differential:
-            out = (optimized_attention(q, k, v, h, mask=mask, skip_reshape=True, low_precision_attention=False)
-                   - optimized_attention(q_diff, k_diff, v, h, mask=mask, skip_reshape=True, low_precision_attention=False))
-            del q, k, v, q_diff, k_diff
-        else:
-            out = optimized_attention(q, k, v, h, mask=mask, skip_reshape=True, low_precision_attention=False)
-            del q, k, v
-
-        return self.to_out(out)
-
-
-class _Sin(nn.Module):
-    def forward(self, x):
-        return torch.sin(3.14159265359 * x)
-
-
-class _GLU(nn.Module):
-    def __init__(self, dim_in, dim_out, activation, dtype=None, device=None, operations=None):
-        super().__init__()
-        self.act = activation
-        self.proj = operations.Linear(dim_in, dim_out * 2, dtype=dtype, device=device)
-
-    def forward(self, x):
-        x = self.proj(x)
-        x, gate = x.chunk(2, dim=-1)
-        return x * self.act(gate)
-
-
-class FeedForward(nn.Module):
-    def __init__(self, dim, mult=4, no_bias=False, zero_init_output=True,
-                 sinusoidal=False, dtype=None, device=None, operations=None, **kwargs):
-        super().__init__()
-        inner_dim = int(dim * mult)
-        act = _Sin() if sinusoidal else nn.SiLU()
-        self.ff = nn.Sequential(
-            _GLU(dim, inner_dim, act, dtype=dtype, device=device, operations=operations),
-            nn.Identity(),
-            operations.Linear(inner_dim, dim, bias=not no_bias, dtype=dtype, device=device),
-            nn.Identity(),
-        )
-
-    def forward(self, x, **kwargs):
-        return self.ff(x)
-
-
-class TransformerBlock(nn.Module):
-    def __init__(self, dim, dim_heads=64, causal=False, zero_init_branch_outputs=True,
-                 norm_type="dyt", add_rope=False, attn_kwargs=None, ff_kwargs=None,
-                 norm_kwargs=None, dtype=None, device=None, operations=None, **kwargs):
-        super().__init__()
-        if attn_kwargs is None:
-            attn_kwargs = {}
-        if ff_kwargs is None:
-            ff_kwargs = {}
-        if norm_kwargs is None:
-            norm_kwargs = {}
-        dim_heads = min(dim_heads, dim)
-
-        Norm = DynamicTanh if norm_type == "dyt" else operations.RMSNorm
-        norm_kw = {**norm_kwargs, "dtype": dtype, "device": device}
-
-        self.pre_norm = Norm(dim, **norm_kw)
-        self.self_attn = Attention(dim, dim_heads=dim_heads,
-                                   zero_init_output=zero_init_branch_outputs,
-                                   dtype=dtype, device=device, operations=operations,
-                                   **attn_kwargs)
-        self.ff_norm = Norm(dim, **norm_kw)
-        self.ff = FeedForward(dim, zero_init_output=zero_init_branch_outputs,
-                              dtype=dtype, device=device, operations=operations, **ff_kwargs)
-        self.rope = RotaryEmbedding(dim_heads // 2, dtype=dtype, device=device) if add_rope else None
-
-    def forward(self, x, mask=None, **kwargs):
-        rope = self.rope.forward_from_seq_len(x.shape[-2], device=x.device) \
-               if self.rope is not None else None
-        x = x + self.self_attn(self.pre_norm(x), rotary_pos_emb=rope, mask=mask)
-        x = x + self.ff(self.ff_norm(x))
-        return x
-
-
-class TransformerResamplingBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, stride, type="encoder",
-                 transformer_depth=3, dim_heads=128, differential=True,
-                 sliding_window=None, chunk_size=128, chunk_midpoint_shift=False,
-                 dyt=True, ff_mult=3, mapping_bias=True, variable_stride=False,
-                 sinusoidal_blocks=0, conv_mapping=False, dtype=None, device=None, operations=None, **kwargs):
-        super().__init__()
-        if type not in ("encoder", "decoder"):
-            raise ValueError(f"type must be 'encoder' or 'decoder', got {type!r}")
-
-        self.type = type
-        self.stride = stride
-        self.chunk_size = chunk_size
-        self.chunk_midpoint_shift = chunk_midpoint_shift
-        self.variable_stride = variable_stride
-        self.transformer_depth = transformer_depth
-
-        transformer_dim = out_channels if type == "encoder" else in_channels
-
-        self.mapping = (WNConv1d(in_channels, out_channels, 3 if conv_mapping else 1, padding="same", bias=mapping_bias)
-                        if in_channels != out_channels else nn.Identity())
-
-        self.sliding_window_latents = sliding_window
-        self.sliding_window_seq = self._get_sliding_window_size(sliding_window, stride)
-        self.input_seg_size, self.output_seg_size, self.sub_chunk_size = self._get_seg_sizes(stride)
-
-        token_seq = 1 if variable_stride else self.output_seg_size
-        self.new_tokens = nn.Parameter(torch.empty(1, token_seq, transformer_dim, dtype=dtype, device=device))
-
-        norm_type = "dyt" if dyt else "rms_norm"
-        attn_kwargs = {"qk_norm": "dyt" if dyt else "rms", "qk_norm_eps": 1e-3,
-                       "differential": differential}
-        norm_kwargs = {"eps": 1e-3}
-        transformers = []
-        for i in range(transformer_depth):
-            sinusoidal = (transformer_depth - i) < sinusoidal_blocks
-            transformers.append(TransformerBlock(
-                transformer_dim,
-                dim_heads=dim_heads,
-                causal=False,
-                zero_init_branch_outputs=True,
-                norm_type=norm_type,
-                add_rope=True,
-                attn_kwargs=attn_kwargs,
-                ff_kwargs={"mult": ff_mult, "no_bias": False, "sinusoidal": sinusoidal},
-                norm_kwargs=norm_kwargs,
-                dtype=dtype, device=device, operations=operations,
-            ))
-        self.transformers = nn.ModuleList(transformers)
-
-    def _get_sliding_window_size(self, window, stride, prepend_cond_length=0):
-        if window is None:
-            return None
-        return [w * (stride + 1 + prepend_cond_length) for w in window]
-
-    def _get_seg_sizes(self, stride, prepend_cond_length=0):
-        sub_chunk_size = stride + 1 + prepend_cond_length
-        input_seg_size = stride if self.type == "encoder" else 1
-        output_seg_size = 1 if self.type == "encoder" else stride
-        return input_seg_size, output_seg_size, sub_chunk_size
-
-    def forward(self, x, stride=None, **kwargs):
-        B = x.shape[0]
-
-        if stride is None:
-            input_seg = self.input_seg_size
-            output_seg = self.output_seg_size
-            sub_chunk = self.sub_chunk_size
-            sliding_window = self.sliding_window_seq
-        else:
-            input_seg, output_seg, sub_chunk = self._get_seg_sizes(stride)
-            sliding_window = self._get_sliding_window_size(self.sliding_window_latents, stride)
-
-        if self.type == "encoder":
-            if self.transformer_depth > 0:
-                pad_mod = self.chunk_size if sliding_window is None else input_seg
-                x = _zero_pad_modulo_sequence(x, pad_mod, dim=-1)
-            x = self.mapping(x)
-
-        if self.transformer_depth > 0:
-            x = x.permute(0, 2, 1)
-
-            if self.type != "encoder":
-                pad_mod = 1 if sliding_window is not None else (
-                    self.chunk_size // (stride if stride is not None else self.stride))
-                x = _zero_pad_modulo_sequence(x, pad_mod)
-
-            C = x.shape[2]
-            x = x.reshape(-1, input_seg, C)
-
-            new_tokens = self.new_tokens.expand(x.shape[0], output_seg, -1)
-            x = torch.cat([x, comfy.ops.cast_to_input(new_tokens, x)], dim=-2)
-            del new_tokens
-
-            x = x.reshape(B, -1, C)
-
-            if sliding_window is None:
-                eff_chunk = self.chunk_size + self.chunk_size // (stride if stride is not None else self.stride)
-
-            if sliding_window is None and self.chunk_midpoint_shift:
-                split = self.transformer_depth // 2
-                shift = eff_chunk // 2
-
-                x = x.reshape(-1, eff_chunk, C)
-                for layer in self.transformers[:split]:
-                    x = layer(x)
-                x = x.reshape(B, -1, C)
-
-                shifted = torch.cat([x[:, :shift, :], x, x[:, -shift:, :]], dim=1)
-                del x
-                x = shifted.reshape(-1, eff_chunk, C)
-                del shifted
-                for layer in self.transformers[split:]:
-                    x = layer(x)
-                x = x.reshape(B, -1, C)
-                x = x[:, shift:-shift, :]
-            elif sliding_window is None:
-                x = x.reshape(-1, eff_chunk, C)
-                for layer in self.transformers:
-                    x = layer(x)
-                x = x.reshape(B, -1, C)
-            else:
-                attn_mask = _sliding_window_mask(x.shape[1], sliding_window[0], x.device, x.dtype)
-                for layer in self.transformers:
-                    x = layer(x, mask=attn_mask)
-
-            x = x.reshape(-1, sub_chunk, C)
-            x = x[:, -output_seg:, :]
-            x = x.reshape(B, -1, C).transpose(1, 2)
-
-        if self.type == "decoder":
-            x = self.mapping(x)
-
-        return x
-
-
-class SAMEEncoder(nn.Module):
-    def __init__(self, in_channels=2, channels=128, latent_dim=32,
-                 c_mults=(1, 2, 4, 8), strides=(2, 4, 8, 8),
-                 transformer_depths=(3, 3, 3, 3),
-                 dtype=None, device=None, operations=None, **kwargs):
-        super().__init__()
-        channel_dims = [in_channels] + [channels * c for c in c_mults]
-        layers = []
-        for i in range(len(c_mults)):
-            layers.append(TransformerResamplingBlock(
-                in_channels=channel_dims[i], out_channels=channel_dims[i + 1],
-                stride=strides[i], type="encoder",
-                transformer_depth=transformer_depths[i],
-                dtype=dtype, device=device, operations=operations, **kwargs))
-        layers += [
-            Transpose(),
-            operations.Linear(channel_dims[-1], latent_dim, dtype=dtype, device=device),
-            Transpose(),
-        ]
-        self.layers = nn.ModuleList(layers)
-
-    def forward(self, x, **kwargs):
-        for layer in self.layers:
-            x = layer(x)
-        return x
-
-
-class SAMEDecoder(nn.Module):
-    def __init__(self, out_channels=2, channels=128, latent_dim=32,
-                 c_mults=(1, 2, 4, 8), strides=(2, 4, 8, 8),
-                 transformer_depths=(3, 3, 3, 3), sinusoidal_blocks=None,
-                 dtype=None, device=None, operations=None, **kwargs):
-        super().__init__()
-        if sinusoidal_blocks is None:
-            sinusoidal_blocks = [0] * len(c_mults)
-        channel_dims = [out_channels] + [channels * c for c in c_mults]
-        layers = [
-            Transpose(),
-            operations.Linear(latent_dim, channel_dims[-1], dtype=dtype, device=device),
-            Transpose(),
-        ]
-        for i in range(len(c_mults) - 1, -1, -1):
-            layers.append(TransformerResamplingBlock(
-                in_channels=channel_dims[i + 1], out_channels=channel_dims[i],
-                stride=strides[i], type="decoder",
-                transformer_depth=transformer_depths[i],
-                sinusoidal_blocks=sinusoidal_blocks[i],
-                dtype=dtype, device=device, operations=operations, **kwargs))
-        self.layers = nn.ModuleList(layers)
-
-    def forward(self, x, **kwargs):
-        for layer in self.layers:
-            x = layer(x)
-        return x
-
-
-class SoftNormBottleneck(nn.Module):
-    def __init__(self, dim=32, noise_augment_dim=0, noise_regularize=False,
-                 auto_scale=False, freeze=False, dtype=None, device=None, **kwargs):
-        super().__init__()
-        self.noise_augment_dim = noise_augment_dim
-        self.noise_regularize = noise_regularize
-        self.scaling_factor = nn.Parameter(torch.empty(1, dim, 1, dtype=dtype, device=device))
-        self.bias = nn.Parameter(torch.empty(1, dim, 1, dtype=dtype, device=device))
-        self.noise_scaling_factor = nn.Parameter(torch.empty(1, noise_augment_dim, 1, dtype=dtype, device=device))
-        if auto_scale:
-            self.register_parameter("running_std", nn.Parameter(
-                torch.empty(1, dtype=dtype, device=device), requires_grad=False))
-        if freeze:
-            for p in self.parameters():
-                p.requires_grad = False
-
-    def encode(self, x, return_info=False, **kwargs):
-        x = x * comfy.ops.cast_to_input(self.scaling_factor, x) \
-              + comfy.ops.cast_to_input(self.bias, x)
-        if hasattr(self, "running_std"):
-            x = x / comfy.ops.cast_to_input(self.running_std, x)
-        if return_info:
-            return x, {}
-        return x
-
-    def decode(self, x, **kwargs):
-        if hasattr(self, "running_std"):
-            x = x * comfy.ops.cast_to_input(self.running_std, x)
-        if self.noise_regularize:
-            scaling = self.running_std if hasattr(self, "running_std") \
-                      else x.std(dim=-1, keepdim=True)
-            noise = torch.randn_like(x) * comfy.ops.cast_to_input(scaling, x) * 1e-3
-            x = x + noise
-        if self.noise_augment_dim > 0:
-            noise = comfy.ops.cast_to_input(self.noise_scaling_factor, x) * torch.randn(
-                x.shape[0], self.noise_augment_dim, x.shape[-1], device=x.device, dtype=x.dtype)
-            x = torch.cat([x, noise], dim=1)
-        return x
-
-
-class PatchedPretransform(nn.Module):
-    def __init__(self, channels, patch_size, **kwargs):
-        super().__init__()
-        self.channels = channels
-        self.patch_size = patch_size
-        self.enable_grad = False
-
-    def _pad(self, x):
-        pad_len = (self.patch_size - x.shape[-1] % self.patch_size) % self.patch_size
-        if pad_len > 0:
-            x = torch.cat([x, torch.zeros_like(x[:, :, :pad_len])], dim=-1)
-        return x
-
-    def encode(self, x):
-        x = self._pad(x)
-        B, C, T = x.shape
-        h = self.patch_size
-        L = T // h
-        # b c (l h) -> b (c h) l
-        return x.reshape(B, C, L, h).permute(0, 1, 3, 2).reshape(B, C * h, L)
-
-    def decode(self, x):
-        B, Ch, L = x.shape
-        h = self.patch_size
-        C = Ch // h
-        # b (c h) l -> b c (l h)
-        return x.reshape(B, C, h, L).permute(0, 1, 3, 2).reshape(B, C, L * h)
-
-
-class SA3AudioVAE(nn.Module):
-    """SA3 VAE. State dict keys match checkpoint after stripping 'pretransform.model.'"""
-
-    def __init__(self, channels=256, transformer_depths=12, sinusoidal_blocks=8,
-                 sliding_window=None, decoder_conv_mapping=False,
-                 chunk_size=128, chunk_midpoint_shift=False,
-                 dtype=None, device=None, operations=None):
-        super().__init__()
-        if operations is None:
-            operations = ops
-
-        self.pretransform = PatchedPretransform(channels=2, patch_size=256)
-
-        common_kwargs = dict(
-            differential=True, dyt=True, dim_heads=64,
-            sliding_window=sliding_window, variable_stride=True,
-            chunk_size=chunk_size, chunk_midpoint_shift=chunk_midpoint_shift,
-            dtype=dtype, device=device, operations=operations,
-        )
-        self.encoder = SAMEEncoder(
-            in_channels=512, channels=channels, c_mults=[6], strides=[16],
-            latent_dim=256, transformer_depths=[transformer_depths],
-            conv_mapping=False, **common_kwargs,
-        )
-        self.decoder = SAMEDecoder(
-            out_channels=512, channels=channels, c_mults=[6], strides=[16],
-            latent_dim=256, transformer_depths=[transformer_depths], sinusoidal_blocks=[sinusoidal_blocks],
-            conv_mapping=decoder_conv_mapping, **common_kwargs,
-        )
-        self.bottleneck = SoftNormBottleneck(
-            dim=256, noise_augment_dim=0, noise_regularize=True,
-            auto_scale=True, freeze=True,
-            dtype=dtype, device=device,
-        )
-
-    @torch.no_grad()
-    def _pretransform_encode(self, x):
-        return self.pretransform.encode(x)
-
-    @torch.no_grad()
-    def _pretransform_decode(self, x):
-        return self.pretransform.decode(x)
-
-    def encode(self, x):
-        x = self._pretransform_encode(x)
-        x = self.encoder(x)
-        x = self.bottleneck.encode(x)
-        return x
-
-    def decode(self, x):
-        x = self.bottleneck.decode(x)
-        x = self.decoder(x)
-        x = self._pretransform_decode(x)
-        return x
@@ -1,318 +0,0 @@
-# Boogu-Image-0.1 transformer
-# Architecture is an OmniGen2 derivative (see comfy/ldm/omnigen/omnigen2.py) with an
-# added dual-stream ("double_stream") stage before the single-stream layers, conditioned
-# by a Qwen3-VL multimodal LLM. Reuses the OmniGen2/Lumina building blocks and the Flux
-# RoPE core, the only new component is the double-stream block + the hybrid forward order.
-
-from typing import Optional, Tuple
-
-import torch
-import torch.nn as nn
-from einops import rearrange
-
-import comfy.ldm.common_dit
-import comfy.ldm.omnigen.omnigen2
-from comfy.ldm.modules.attention import optimized_attention_masked
-from comfy.ldm.omnigen.omnigen2 import (
-    OmniGen2RotaryPosEmbed,
-    Lumina2CombinedTimestepCaptionEmbedding,
-    LuminaRMSNormZero,
-    LuminaLayerNormContinuous,
-    LuminaFeedForward,
-    Attention,
-    OmniGen2TransformerBlock,
-    apply_rotary_emb,
-)
-
-class BooguDoubleStreamProcessor(nn.Module):
-    # Joint attention over [instruct ; img] with separate per-stream q/k/v and output projections.
-    def __init__(self, dim, head_dim, heads, kv_heads, dtype=None, device=None, operations=None):
-        super().__init__()
-        query_dim = head_dim * heads
-        kv_dim = head_dim * kv_heads
-
-        self.img_to_q = operations.Linear(query_dim, query_dim, bias=False, dtype=dtype, device=device)
-        self.img_to_k = operations.Linear(query_dim, kv_dim, bias=False, dtype=dtype, device=device)
-        self.img_to_v = operations.Linear(query_dim, kv_dim, bias=False, dtype=dtype, device=device)
-
-        self.instruct_to_q = operations.Linear(query_dim, query_dim, bias=False, dtype=dtype, device=device)
-        self.instruct_to_k = operations.Linear(query_dim, kv_dim, bias=False, dtype=dtype, device=device)
-        self.instruct_to_v = operations.Linear(query_dim, kv_dim, bias=False, dtype=dtype, device=device)
-
-        self.instruct_out = operations.Linear(query_dim, query_dim, bias=False, dtype=dtype, device=device)
-        self.img_out = operations.Linear(query_dim, query_dim, bias=False, dtype=dtype, device=device)
-
-    def forward(self, attn, img_hidden_states, instruct_hidden_states, rotary_emb, attention_mask=None, transformer_options={}):
-        batch_size = img_hidden_states.shape[0]
-        L_instruct = instruct_hidden_states.shape[1]
-
-        img_q = self.img_to_q(img_hidden_states)
-        img_k = self.img_to_k(img_hidden_states)
-        img_v = self.img_to_v(img_hidden_states)
-
-        instruct_q = self.instruct_to_q(instruct_hidden_states)
-        instruct_k = self.instruct_to_k(instruct_hidden_states)
-        instruct_v = self.instruct_to_v(instruct_hidden_states)
-
-        # Concatenate instruction first, then image (matches reference processor order).
-        query = torch.cat([instruct_q, img_q], dim=1)
-        key = torch.cat([instruct_k, img_k], dim=1)
-        value = torch.cat([instruct_v, img_v], dim=1)
-
-        query = query.view(batch_size, -1, attn.heads, attn.dim_head)
-        key = key.view(batch_size, -1, attn.kv_heads, attn.dim_head)
-        value = value.view(batch_size, -1, attn.kv_heads, attn.dim_head)
-
-        query = attn.norm_q(query)
-        key = attn.norm_k(key)
-
-        if rotary_emb is not None:
-            query = apply_rotary_emb(query, rotary_emb)
-            key = apply_rotary_emb(key, rotary_emb)
-
-        query = query.transpose(1, 2)
-        key = key.transpose(1, 2)
-        value = value.transpose(1, 2)
-
-        gqa_kwargs = {"enable_gqa": True} if attn.kv_heads < attn.heads else {}
-        hidden_states = optimized_attention_masked(query, key, value, attn.heads, attention_mask, skip_reshape=True, transformer_options=transformer_options, **gqa_kwargs)
-
-        # Split back to instruction/image, apply per-stream output projections, recombine.
-        instruct_hidden_states = self.instruct_out(hidden_states[:, :L_instruct])
-        img_hidden_states = self.img_out(hidden_states[:, L_instruct:])
-        hidden_states = torch.cat([instruct_hidden_states, img_hidden_states], dim=1)
-
-        hidden_states = attn.to_out[0](hidden_states)
-        return hidden_states
-
-
-class BooguJointAttention(nn.Module):
-    # Holds the shared q/k RMSNorm + final output projection
-    def __init__(self, dim, head_dim, heads, kv_heads, eps=1e-5, dtype=None, device=None, operations=None):
-        super().__init__()
-        self.heads = heads
-        self.kv_heads = kv_heads
-        self.dim_head = head_dim
-        self.scale = head_dim ** -0.5
-
-        self.norm_q = operations.RMSNorm(head_dim, eps=eps, dtype=dtype, device=device)
-        self.norm_k = operations.RMSNorm(head_dim, eps=eps, dtype=dtype, device=device)
-        self.to_out = nn.Sequential(
-            operations.Linear(heads * head_dim, dim, bias=False, dtype=dtype, device=device),
-            nn.Dropout(0.0),
-        )
-        self.processor = BooguDoubleStreamProcessor(dim, head_dim, heads, kv_heads, dtype=dtype, device=device, operations=operations)
-
-    def forward(self, img_hidden_states, instruct_hidden_states, rotary_emb, attention_mask=None, transformer_options={}):
-        return self.processor(self, img_hidden_states, instruct_hidden_states, rotary_emb, attention_mask, transformer_options=transformer_options)
-
-
-class BooguDoubleStreamBlock(nn.Module):
-    # Dual-stream block: joint attention over [instruct ; img] + image self-attention, each stream with its own modulation/MLP.
-    def __init__(self, dim, num_attention_heads, num_kv_heads, multiple_of, ffn_dim_multiplier, norm_eps, dtype=None, device=None, operations=None):
-        super().__init__()
-        head_dim = dim // num_attention_heads
-
-        self.img_instruct_attn = BooguJointAttention(dim, head_dim, num_attention_heads, num_kv_heads, eps=1e-5, dtype=dtype, device=device, operations=operations)
-        self.img_self_attn = Attention(
-            query_dim=dim, dim_head=head_dim, heads=num_attention_heads, kv_heads=num_kv_heads,
-            eps=1e-5, bias=False, dtype=dtype, device=device, operations=operations,
-        )
-
-        self.img_feed_forward = LuminaFeedForward(dim=dim, inner_dim=4 * dim, multiple_of=multiple_of, dtype=dtype, device=device, operations=operations)
-        self.instruct_feed_forward = LuminaFeedForward(dim=dim, inner_dim=4 * dim, multiple_of=multiple_of, dtype=dtype, device=device, operations=operations)
-
-        self.img_norm1 = LuminaRMSNormZero(embedding_dim=dim, norm_eps=norm_eps, dtype=dtype, device=device, operations=operations)
-        self.img_norm2 = LuminaRMSNormZero(embedding_dim=dim, norm_eps=norm_eps, dtype=dtype, device=device, operations=operations)
-        self.img_norm3 = LuminaRMSNormZero(embedding_dim=dim, norm_eps=norm_eps, dtype=dtype, device=device, operations=operations)
-        self.instruct_norm1 = LuminaRMSNormZero(embedding_dim=dim, norm_eps=norm_eps, dtype=dtype, device=device, operations=operations)
-        self.instruct_norm2 = LuminaRMSNormZero(embedding_dim=dim, norm_eps=norm_eps, dtype=dtype, device=device, operations=operations)
-
-        self.img_attn_norm = operations.RMSNorm(dim, eps=norm_eps, dtype=dtype, device=device)
-        self.img_self_attn_norm = operations.RMSNorm(dim, eps=norm_eps, dtype=dtype, device=device)
-        self.img_ffn_norm1 = operations.RMSNorm(dim, eps=norm_eps, dtype=dtype, device=device)
-        self.img_ffn_norm2 = operations.RMSNorm(dim, eps=norm_eps, dtype=dtype, device=device)
-
-        self.instruct_attn_norm = operations.RMSNorm(dim, eps=norm_eps, dtype=dtype, device=device)
-        self.instruct_ffn_norm1 = operations.RMSNorm(dim, eps=norm_eps, dtype=dtype, device=device)
-        self.instruct_ffn_norm2 = operations.RMSNorm(dim, eps=norm_eps, dtype=dtype, device=device)
-
-    def forward(self, img_hidden_states, instruct_hidden_states, joint_rotary_emb, img_rotary_emb, temb, joint_attention_mask=None, img_attention_mask=None, transformer_options={}):
-        L_instruct = instruct_hidden_states.shape[1]
-
-        img_norm1_out, img_gate_msa, img_scale_mlp, img_gate_mlp = self.img_norm1(img_hidden_states, temb)
-        img_norm2_out, img_shift_mlp, _, _ = self.img_norm2(img_hidden_states, temb)
-        img_norm3_out, img_gate_self, _, _ = self.img_norm3(img_hidden_states, temb)
-
-        instruct_norm1_out, instruct_gate_msa, instruct_scale_mlp, instruct_gate_mlp = self.instruct_norm1(instruct_hidden_states, temb)
-        instruct_norm2_out, instruct_shift_mlp, _, _ = self.instruct_norm2(instruct_hidden_states, temb)
-
-        joint_attn_out = self.img_instruct_attn(img_norm1_out, instruct_norm1_out, joint_rotary_emb, joint_attention_mask, transformer_options=transformer_options)
-        instruct_attn_out = joint_attn_out[:, :L_instruct]
-        img_attn_out = joint_attn_out[:, L_instruct:]
-
-        img_self_attn_out = self.img_self_attn(img_norm3_out, img_norm3_out, img_attention_mask, img_rotary_emb, transformer_options=transformer_options)
-
-        img_hidden_states = img_hidden_states + img_gate_msa.unsqueeze(1).tanh() * self.img_attn_norm(img_attn_out)
-        img_hidden_states = img_hidden_states + img_gate_self.unsqueeze(1).tanh() * self.img_self_attn_norm(img_self_attn_out)
-        img_mlp_input = (1 + img_scale_mlp.unsqueeze(1)) * img_norm2_out + img_shift_mlp.unsqueeze(1)
-        img_mlp_out = self.img_feed_forward(self.img_ffn_norm1(img_mlp_input))
-        img_hidden_states = img_hidden_states + img_gate_mlp.unsqueeze(1).tanh() * self.img_ffn_norm2(img_mlp_out)
-
-        instruct_hidden_states = instruct_hidden_states + instruct_gate_msa.unsqueeze(1).tanh() * self.instruct_attn_norm(instruct_attn_out)
-        instruct_mlp_input = (1 + instruct_scale_mlp.unsqueeze(1)) * instruct_norm2_out + instruct_shift_mlp.unsqueeze(1)
-        instruct_mlp_out = self.instruct_feed_forward(self.instruct_ffn_norm1(instruct_mlp_input))
-        instruct_hidden_states = instruct_hidden_states + instruct_gate_mlp.unsqueeze(1).tanh() * self.instruct_ffn_norm2(instruct_mlp_out)
-
-        return img_hidden_states, instruct_hidden_states
-
-
-class BooguTransformer2DModel(nn.Module):
-    def __init__(
-        self,
-        patch_size: int = 2,
-        in_channels: int = 16,
-        out_channels: Optional[int] = None,
-        hidden_size: int = 3360,
-        num_layers: int = 32,
-        num_double_stream_layers: int = 8,
-        num_refiner_layers: int = 2,
-        num_attention_heads: int = 28,
-        num_kv_heads: int = 7,
-        multiple_of: int = 256,
-        ffn_dim_multiplier: Optional[float] = None,
-        norm_eps: float = 1e-5,
-        axes_dim_rope: Tuple[int, int, int] = (40, 40, 40),
-        axes_lens: Tuple[int, int, int] = (2048, 1664, 1664),
-        instruction_feat_dim: int = 4096,
-        timestep_scale: float = 1000.0,
-        image_model=None,
-        device=None, dtype=None, operations=None,
-    ):
-        super().__init__()
-
-        self.patch_size = patch_size
-        self.out_channels = out_channels or in_channels
-        self.hidden_size = hidden_size
-        self.dtype = dtype
-
-        self.rope_embedder = OmniGen2RotaryPosEmbed(
-            theta=10000,
-            axes_dim=axes_dim_rope,
-            axes_lens=axes_lens,
-            patch_size=patch_size,
-        )
-
-        self.x_embedder = operations.Linear(patch_size * patch_size * in_channels, hidden_size, dtype=dtype, device=device)
-        self.ref_image_patch_embedder = operations.Linear(patch_size * patch_size * in_channels, hidden_size, dtype=dtype, device=device)
-
-        self.time_caption_embed = Lumina2CombinedTimestepCaptionEmbedding(
-            hidden_size=hidden_size,
-            text_feat_dim=instruction_feat_dim,
-            norm_eps=norm_eps,
-            timestep_scale=timestep_scale, dtype=dtype, device=device, operations=operations
-        )
-
-        self.noise_refiner = nn.ModuleList([
-            OmniGen2TransformerBlock(hidden_size, num_attention_heads, num_kv_heads, multiple_of, ffn_dim_multiplier, norm_eps, modulation=True, dtype=dtype, device=device, operations=operations)
-            for _ in range(num_refiner_layers)
-        ])
-
-        self.ref_image_refiner = nn.ModuleList([
-            OmniGen2TransformerBlock(hidden_size, num_attention_heads, num_kv_heads, multiple_of, ffn_dim_multiplier, norm_eps, modulation=True, dtype=dtype, device=device, operations=operations)
-            for _ in range(num_refiner_layers)
-        ])
-
-        self.context_refiner = nn.ModuleList([
-            OmniGen2TransformerBlock(hidden_size, num_attention_heads, num_kv_heads, multiple_of, ffn_dim_multiplier, norm_eps, modulation=False, dtype=dtype, device=device, operations=operations)
-            for _ in range(num_refiner_layers)
-        ])
-
-        self.double_stream_layers = nn.ModuleList([
-            BooguDoubleStreamBlock(hidden_size, num_attention_heads, num_kv_heads, multiple_of, ffn_dim_multiplier, norm_eps, dtype=dtype, device=device, operations=operations)
-            for _ in range(num_double_stream_layers)
-        ])
-
-        self.single_stream_layers = nn.ModuleList([
-            OmniGen2TransformerBlock(hidden_size, num_attention_heads, num_kv_heads, multiple_of, ffn_dim_multiplier, norm_eps, modulation=True, dtype=dtype, device=device, operations=operations)
-            for _ in range(num_layers)
-        ])
-
-        self.norm_out = LuminaLayerNormContinuous(
-            embedding_dim=hidden_size,
-            conditioning_embedding_dim=min(hidden_size, 1024),
-            elementwise_affine=False,
-            eps=1e-6,
-            out_dim=patch_size * patch_size * self.out_channels, dtype=dtype, device=device, operations=operations
-        )
-
-        self.image_index_embedding = nn.Parameter(torch.empty(5, hidden_size, device=device, dtype=dtype))
-
-    # Patchify/refine helpers are identical to OmniGen2; reuse via bound methods.
-    flat_and_pad_to_seq = comfy.ldm.omnigen.omnigen2.OmniGen2Transformer2DModel.flat_and_pad_to_seq
-    img_patch_embed_and_refine = comfy.ldm.omnigen.omnigen2.OmniGen2Transformer2DModel.img_patch_embed_and_refine
-
-    def forward(self, x, timesteps, context, num_tokens, ref_latents=None, attention_mask=None, transformer_options={}, **kwargs):
-        B, C, H, W = x.shape
-        hidden_states = comfy.ldm.common_dit.pad_to_patch_size(x, (self.patch_size, self.patch_size))
-        _, _, H_padded, W_padded = hidden_states.shape
-        timestep = 1.0 - timesteps
-        text_hidden_states = context
-        text_attention_mask = attention_mask
-        ref_image_hidden_states = ref_latents
-        device = hidden_states.device
-
-        temb, text_hidden_states = self.time_caption_embed(timestep, text_hidden_states, hidden_states[0].dtype)
-
-        (
-            hidden_states, ref_image_hidden_states,
-            img_mask, ref_img_mask,
-            l_effective_ref_img_len, l_effective_img_len,
-            ref_img_sizes, img_sizes,
-        ) = self.flat_and_pad_to_seq(hidden_states, ref_image_hidden_states)
-
-        (
-            context_rotary_emb, ref_img_rotary_emb, noise_rotary_emb,
-            rotary_emb, encoder_seq_lengths, seq_lengths,
-        ) = self.rope_embedder(
-            hidden_states.shape[0], text_hidden_states.shape[1], [num_tokens] * text_hidden_states.shape[0],
-            l_effective_ref_img_len, l_effective_img_len,
-            ref_img_sizes, img_sizes, device,
-        )
-
-        for layer in self.context_refiner:
-            text_hidden_states = layer(text_hidden_states, text_attention_mask, context_rotary_emb, transformer_options=transformer_options)
-
-        img_len = hidden_states.shape[1]
-        combined_img_hidden_states = self.img_patch_embed_and_refine(
-            hidden_states, ref_image_hidden_states,
-            img_mask, ref_img_mask,
-            noise_rotary_emb, ref_img_rotary_emb,
-            l_effective_ref_img_len, l_effective_img_len,
-            temb,
-            transformer_options=transformer_options,
-        )
-
-        # Double-stream stage: the image self-attention only sees the [ref ; noise] tokens,
-        # which sit after the instruction tokens in the joint rope.
-        L_instruct = text_hidden_states.shape[1]
-        combined_img_rotary_emb = rotary_emb[:, L_instruct:]
-        for layer in self.double_stream_layers:
-            combined_img_hidden_states, text_hidden_states = layer(
-                combined_img_hidden_states, text_hidden_states,
-                rotary_emb, combined_img_rotary_emb, temb,
-                joint_attention_mask=None, img_attention_mask=None,
-                transformer_options=transformer_options,
-            )
-
-        hidden_states = torch.cat([text_hidden_states, combined_img_hidden_states], dim=1)
-
-        for layer in self.single_stream_layers:
-            hidden_states = layer(hidden_states, None, rotary_emb, temb, transformer_options=transformer_options)
-
-        hidden_states = self.norm_out(hidden_states, temb)
-
-        p = self.patch_size
-        output = rearrange(hidden_states[:, -img_len:], 'b (h w) (p1 p2 c) -> b c (h p1) (w p2)', h=H_padded // p, w=W_padded // p, p1=p, p2=p)[:, :, :H, :W]
-
-        return -output
@@ -38,8 +38,6 @@ class ChromaRadianceParams(ChromaParams):
    # None means use the same dtype as the model.
    nerf_embedder_dtype: Optional[torch.dtype]
    use_x0: bool
-    # Use sequential txt_ids instead of zeros
-    use_sequential_txt_ids: bool

 class ChromaRadiance(Chroma):
    """
@@ -164,9 +162,6 @@ class ChromaRadiance(Chroma):
        if params.use_x0:
            self.register_buffer("__x0__", torch.tensor([]))

-        if params.use_sequential_txt_ids:
-            self.register_buffer("__sequential__", torch.tensor([]))
-
    @property
    def _nerf_final_layer(self) -> nn.Module:
        if self.params.nerf_final_head_type == "linear":
@@ -318,9 +313,6 @@ class ChromaRadiance(Chroma):
        img_ids[:, :, 2] = img_ids[:, :, 2] + torch.linspace(0, w_len - 1, steps=w_len, device=x.device, dtype=x.dtype).unsqueeze(0)
        img_ids = repeat(img_ids, "h w c -> b (h w) c", b=bs)
        txt_ids = torch.zeros((bs, context.shape[1], 3), device=x.device, dtype=x.dtype)
-        # Radiance after 2026-05-22 uses sequential txt_ids instead of zeros
-        if params.use_sequential_txt_ids:
-            txt_ids[:, :, 0] = torch.arange(context.shape[1], device=x.device, dtype=x.dtype).unsqueeze(0).expand(bs, -1)

        img_out = self.forward_orig(
            img,
@@ -1,25 +0,0 @@
-"""Colormap utilities for depth and geometry visualisation."""
-
-from __future__ import annotations
-
-import torch
-
-
-def turbo(x: torch.Tensor) -> torch.Tensor:
-    """Anton Mikhailov polynomial approximation of the Turbo colormap.
-
-    Args:
-        x: Float tensor with values in [0, 1].
-
-    Returns:
-        RGB tensor of the same shape as ``x`` with a trailing size-3 dimension.
-    """
-    x = x.clamp(0.0, 1.0)
-    x2 = x * x
-    x3 = x2 * x
-    x4 = x2 * x2
-    x5 = x4 * x
-    r = 0.13572138 + 4.61539260*x - 42.66032258*x2 + 132.13108234*x3 - 152.94239396*x4 + 59.28637943*x5
-    g = 0.09140261 + 2.19418839*x + 4.84296658*x2 - 14.18503333*x3 +   4.27729857*x4 +  2.82956604*x5
-    b = 0.10667330 + 12.64194608*x - 60.58204836*x2 + 110.36276771*x3 - 89.90310912*x4 + 27.34824973*x5
-    return torch.stack([r, g, b], dim=-1).clamp(0.0, 1.0)
@@ -14,7 +14,15 @@ from torchvision import transforms
 import comfy.patcher_extension
 from comfy.ldm.modules.attention import optimized_attention
 import comfy.ldm.common_dit
-import comfy.quant_ops
+
+def apply_rotary_pos_emb(
+    t: torch.Tensor,
+    freqs: torch.Tensor,
+) -> torch.Tensor:
+    t_ = t.reshape(*t.shape[:-1], 2, -1).movedim(-2, -1).unsqueeze(-2).float()
+    t_out = freqs[..., 0] * t_[..., 0] + freqs[..., 1] * t_[..., 1]
+    t_out = t_out.movedim(-1, -2).reshape(*t.shape).type_as(t)
+    return t_out


 # ---------------------- Feed Forward Network -----------------------
@@ -165,7 +173,8 @@ class Attention(nn.Module):
            k = self.k_norm(k)
            v = self.v_norm(v)
            if self.is_selfattn and rope_emb is not None:  # only apply to self-attention!
-                q, k = comfy.quant_ops.ck.apply_rope_split_half(q, k, rope_emb)
+                q = apply_rotary_pos_emb(q, rope_emb)
+                k = apply_rotary_pos_emb(k, rope_emb)
            return q, k, v

        q, k, v = apply_norm_and_rotary_pos_emb(q, k, v, rope_emb)
@@ -515,7 +524,7 @@ class Block(nn.Module):
            h=H,
            w=W,
        )
-        x_B_T_H_W_D = torch.addcmul(x_B_T_H_W_D, gate_self_attn_B_T_1_1_D.to(residual_dtype), result_B_T_H_W_D.to(residual_dtype))
+        x_B_T_H_W_D = x_B_T_H_W_D + gate_self_attn_B_T_1_1_D.to(residual_dtype) * result_B_T_H_W_D.to(residual_dtype)

        def _x_fn(
            _x_B_T_H_W_D: torch.Tensor,
@@ -548,7 +557,7 @@ class Block(nn.Module):
            shift_cross_attn_B_T_1_1_D,
            transformer_options=transformer_options,
        )
-        x_B_T_H_W_D = torch.addcmul(x_B_T_H_W_D, gate_cross_attn_B_T_1_1_D.to(residual_dtype), result_B_T_H_W_D.to(residual_dtype))
+        x_B_T_H_W_D = result_B_T_H_W_D.to(residual_dtype) * gate_cross_attn_B_T_1_1_D.to(residual_dtype) + x_B_T_H_W_D

        normalized_x_B_T_H_W_D = _fn(
            x_B_T_H_W_D,
@@ -557,7 +566,7 @@ class Block(nn.Module):
            shift_mlp_B_T_1_1_D,
        )
        result_B_T_H_W_D = self.mlp(normalized_x_B_T_H_W_D.to(compute_dtype))
-        x_B_T_H_W_D = torch.addcmul(x_B_T_H_W_D, gate_mlp_B_T_1_1_D.to(residual_dtype), result_B_T_H_W_D.to(residual_dtype))
+        x_B_T_H_W_D = x_B_T_H_W_D + gate_mlp_B_T_1_1_D.to(residual_dtype) * result_B_T_H_W_D.to(residual_dtype)
        return x_B_T_H_W_D


@@ -1,177 +0,0 @@
-"""Camera-token encoder and decoder for Depth Anything 3."""
-
-from __future__ import annotations
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from comfy.ldm.modules.attention import optimized_attention_for_device
-from .transform import affine_inverse, extri_intri_to_pose_encoding
-
-
-# -----------------------------------------------------------------------
-# Building blocks (mirror depth_anything_3.model.utils.{attention,block})
-# -----------------------------------------------------------------------
-
-
-class _Mlp(nn.Module):
-    """Standard 2-layer MLP with GELU. Matches upstream ``utils.attention.Mlp``."""
-
-    def __init__(self, in_features, hidden_features=None, out_features=None, *, device=None, dtype=None, operations=None):
-        super().__init__()
-        out_features = out_features or in_features
-        hidden_features = hidden_features or in_features
-        self.fc1 = operations.Linear(in_features, hidden_features, bias=True, device=device, dtype=dtype)
-        self.fc2 = operations.Linear(hidden_features, out_features, bias=True, device=device, dtype=dtype)
-
-    def forward(self, x):
-        return self.fc2(F.gelu(self.fc1(x)))
-
-
-class _LayerScale(nn.Module):
-    """Per-channel learnable scaling. Matches upstream LayerScale."""
-
-    def __init__(self, dim, *, device=None, dtype=None):
-        super().__init__()
-        self.gamma = nn.Parameter(torch.empty(dim, device=device, dtype=dtype))
-
-    def forward(self, x):
-        return x * self.gamma.to(dtype=x.dtype, device=x.device)
-
-
-class _Attention(nn.Module):
-    """ Self-attention with fused QKV projection. Mirrors upstream utils.attention.Attention;
-    Layout matches the HF safetensors (attn.qkv.{weight,bias} and attn.proj.{weight,bias})."""
-
-    def __init__(self, dim, num_heads, *, device=None, dtype=None, operations=None):
-        super().__init__()
-        assert dim % num_heads == 0
-        self.num_heads = num_heads
-        self.head_dim = dim // num_heads
-        self.qkv = operations.Linear(dim, dim * 3, bias=True, device=device, dtype=dtype)
-        self.proj = operations.Linear(dim, dim, bias=True, device=device, dtype=dtype)
-
-    def forward(self, x):
-        B, N, C = x.shape
-        qkv = self.qkv(x).reshape(B, N, 3, C)
-        q, k, v = qkv.unbind(2)                      # each (B, N, C)
-        attn_fn = optimized_attention_for_device(x.device, small_input=True)
-        out = attn_fn(q, k, v, heads=self.num_heads)
-        return self.proj(out)
-
-
-class _Block(nn.Module):
-    """Pre-norm transformer block with LayerScale. Used by :class:CameraEnc. Layout follows upstream utils.block.Block."""
-
-    def __init__(self, dim, num_heads, mlp_ratio=4, init_values=0.01, *, device=None, dtype=None, operations=None):
-        super().__init__()
-        self.norm1 = operations.LayerNorm(dim, device=device, dtype=dtype)
-        self.attn = _Attention(dim, num_heads, device=device, dtype=dtype, operations=operations)
-        self.ls1 = _LayerScale(dim, device=device, dtype=dtype) if init_values else nn.Identity()
-        self.norm2 = operations.LayerNorm(dim, device=device, dtype=dtype)
-        self.mlp = _Mlp(in_features=dim, hidden_features=int(dim * mlp_ratio), device=device, dtype=dtype, operations=operations)
-        self.ls2 = _LayerScale(dim, device=device, dtype=dtype) if init_values else nn.Identity()
-
-    def forward(self, x):
-        x = x + self.ls1(self.attn(self.norm1(x)))
-        x = x + self.ls2(self.mlp(self.norm2(x)))
-        return x
-
-
-class CameraEnc(nn.Module):
-    """Encode per-view (extrinsics, intrinsics) into a camera token.
-
-    Maps a 9-D pose-encoding vector through a small MLP up to the backbone's
-    ``embed_dim``, then runs ``trunk_depth`` transformer blocks. The output
-    has shape ``(B, S, embed_dim)`` and is injected at block ``alt_start``
-    of the DINOv2 backbone in place of the cls token.
-
-    Parameters mirror the upstream ``cam_enc.py`` so HF weights load directly.
-    """
-
-    def __init__(
-        self,
-        dim_out: int = 1024,
-        dim_in: int = 9,
-        trunk_depth: int = 4,
-        target_dim: int = 9,
-        num_heads: int = 16,
-        mlp_ratio: int = 4,
-        init_values: float = 0.01,
-        *,
-        device=None, dtype=None, operations=None,
-        **_kwargs,
-    ):
-        super().__init__()
-        self.target_dim = target_dim
-        self.trunk_depth = trunk_depth
-        self.trunk = nn.Sequential(*[
-            _Block(dim_out, num_heads=num_heads, mlp_ratio=mlp_ratio,
-                   init_values=init_values,
-                   device=device, dtype=dtype, operations=operations)
-            for _ in range(trunk_depth)
-        ])
-        self.token_norm = operations.LayerNorm(dim_out, device=device, dtype=dtype)
-        self.trunk_norm = operations.LayerNorm(dim_out, device=device, dtype=dtype)
-        self.pose_branch = _Mlp(
-            in_features=dim_in,
-            hidden_features=dim_out // 2,
-            out_features=dim_out,
-            device=device, dtype=dtype, operations=operations,
-        )
-
-    def forward(self, extrinsics: torch.Tensor, intrinsics: torch.Tensor,
-                image_size_hw) -> torch.Tensor:
-        """Encode camera parameters into ``(B, S, dim_out)`` tokens."""
-        c2ws = affine_inverse(extrinsics)
-        pose_encoding = extri_intri_to_pose_encoding(c2ws, intrinsics, image_size_hw)
-        tokens = self.pose_branch(pose_encoding.to(self.pose_branch.fc1.weight.dtype))
-        tokens = self.token_norm(tokens)
-        tokens = self.trunk(tokens)
-        tokens = self.trunk_norm(tokens)
-        return tokens
-
-
-class CameraDec(nn.Module):
-    """Decode the final cam token into a 9-D pose encoding.
-
-    Output layout: ``[T(3), quat_xyzw(4), fov_h, fov_w]``. The translation is
-    always predicted by the network; the quaternion and FoV can either be
-    predicted or supplied via ``camera_encoding`` (used at training time
-    when GT cameras are available -- not exercised at inference here).
-
-    Parameters mirror the upstream ``cam_dec.py`` so HF weights load directly.
-    """
-
-    def __init__(self, dim_in: int = 1536,
-                 *, device=None, dtype=None, operations=None, **_kwargs):
-        super().__init__()
-        d = dim_in
-        self.backbone = nn.Sequential(
-            operations.Linear(d, d, device=device, dtype=dtype),
-            nn.ReLU(),
-            operations.Linear(d, d, device=device, dtype=dtype),
-            nn.ReLU(),
-        )
-        self.fc_t = operations.Linear(d, 3, device=device, dtype=dtype)
-        self.fc_qvec = operations.Linear(d, 4, device=device, dtype=dtype)
-        self.fc_fov = nn.Sequential(
-            operations.Linear(d, 2, device=device, dtype=dtype),
-            nn.ReLU(),
-        )
-
-    def forward(self, feat: torch.Tensor,
-                camera_encoding: "torch.Tensor | None" = None) -> torch.Tensor:
-        """Decode ``(B, N, dim_in)`` cam tokens into ``(B, N, 9)`` pose enc."""
-        B, N = feat.shape[:2]
-        feat = feat.reshape(B * N, -1)
-        feat = self.backbone(feat)
-        out_t = self.fc_t(feat.float()).reshape(B, N, 3)
-        if camera_encoding is None:
-            out_qvec = self.fc_qvec(feat.float()).reshape(B, N, 4)
-            out_fov = self.fc_fov(feat.float()).reshape(B, N, 2)
-        else:
-            out_qvec = camera_encoding[..., 3:7]
-            out_fov = camera_encoding[..., -2:]
-        return torch.cat([out_t, out_qvec, out_fov], dim=-1)
@@ -1,489 +0,0 @@
-"""DPT / DualDPT heads for Depth Anything 3."""
-
-from __future__ import annotations
-
-from typing import List, Optional, Sequence, Tuple
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class Permute(nn.Module):
-    def __init__(self, dims: Tuple[int, ...]):
-        super().__init__()
-        self.dims = dims
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        return x.permute(*self.dims)
-
-
-def _custom_interpolate(
-    x: torch.Tensor,
-    size: Optional[Tuple[int, int]] = None,
-    scale_factor: Optional[float] = None,
-    mode: str = "bilinear",
-    align_corners: bool = True,
-) -> torch.Tensor:
-    if size is None:
-        assert scale_factor is not None
-        size = (int(x.shape[-2] * scale_factor), int(x.shape[-1] * scale_factor))
-    INT_MAX = 1610612736
-    total = size[0] * size[1] * x.shape[0] * x.shape[1]
-    if total > INT_MAX:
-        chunks = torch.chunk(x, chunks=(total // INT_MAX) + 1, dim=0)
-        outs = [F.interpolate(c, size=size, mode=mode, align_corners=align_corners) for c in chunks]
-        return torch.cat(outs, dim=0).contiguous()
-    return F.interpolate(x, size=size, mode=mode, align_corners=align_corners)
-
-
-def _create_uv_grid(width: int, height: int, aspect_ratio: float, dtype, device) -> torch.Tensor:
-    """Normalised UV grid spanning (-x_span, -y_span)..(x_span, y_span)."""
-    diag_factor = (aspect_ratio ** 2 + 1.0) ** 0.5
-    span_x = aspect_ratio / diag_factor
-    span_y = 1.0 / diag_factor
-    left_x = -span_x * (width - 1) / width
-    right_x = span_x * (width - 1) / width
-    top_y = -span_y * (height - 1) / height
-    bottom_y = span_y * (height - 1) / height
-    x_coords = torch.linspace(left_x, right_x, steps=width, dtype=dtype, device=device)
-    y_coords = torch.linspace(top_y, bottom_y, steps=height, dtype=dtype, device=device)
-    uu, vv = torch.meshgrid(x_coords, y_coords, indexing="xy")
-    return torch.stack((uu, vv), dim=-1)  # (H, W, 2)
-
-
-def _make_sincos_pos_embed(embed_dim: int, pos: torch.Tensor, omega_0: float = 100.0) -> torch.Tensor:
-    omega = torch.arange(embed_dim // 2, dtype=torch.float32, device=pos.device)
-    omega = 1.0 / omega_0 ** (omega / (embed_dim / 2.0))
-    pos = pos.reshape(-1)
-    out = torch.einsum("m,d->md", pos, omega)
-    return torch.cat([out.sin(), out.cos()], dim=1).float()
-
-
-def _position_grid_to_embed(pos_grid: torch.Tensor, embed_dim: int, omega_0: float = 100.0) -> torch.Tensor:
-    H, W, _ = pos_grid.shape
-    pos_flat = pos_grid.reshape(-1, 2)
-    emb_x = _make_sincos_pos_embed(embed_dim // 2, pos_flat[:, 0], omega_0=omega_0)
-    emb_y = _make_sincos_pos_embed(embed_dim // 2, pos_flat[:, 1], omega_0=omega_0)
-    emb = torch.cat([emb_x, emb_y], dim=-1)
-    return emb.view(H, W, embed_dim)
-
-
-def _add_pos_embed(x: torch.Tensor, W: int, H: int, ratio: float = 0.1) -> torch.Tensor:
-    """Stateless UV positional embedding added to a feature map (B, C, h, w)."""
-    pw, ph = x.shape[-1], x.shape[-2]
-    pe = _create_uv_grid(pw, ph, aspect_ratio=W / H, dtype=x.dtype, device=x.device)
-    pe = _position_grid_to_embed(pe, x.shape[1]) * ratio
-    pe = pe.permute(2, 0, 1)[None].expand(x.shape[0], -1, -1, -1).to(dtype=x.dtype)
-    return x + pe
-
-
-def _apply_activation(x: torch.Tensor, activation: str) -> torch.Tensor:
-    act = (activation or "linear").lower()
-    if act == "exp":
-        return torch.exp(x)
-    if act == "expp1":
-        return torch.exp(x) + 1
-    if act == "expm1":
-        return torch.expm1(x)
-    if act == "relu":
-        return torch.relu(x)
-    if act == "sigmoid":
-        return torch.sigmoid(x)
-    if act == "softplus":
-        return F.softplus(x)
-    if act == "tanh":
-        return torch.tanh(x)
-    return x
-
-
-# -----------------------------------------------------------------------------
-# Fusion building blocks
-# -----------------------------------------------------------------------------
-
-
-class ResidualConvUnit(nn.Module):
-    def __init__(self, features: int, device=None, dtype=None, operations=None):
-        super().__init__()
-        self.conv1 = operations.Conv2d(features, features, 3, 1, 1, bias=True, device=device, dtype=dtype)
-        self.conv2 = operations.Conv2d(features, features, 3, 1, 1, bias=True, device=device, dtype=dtype)
-        self.activation = nn.ReLU(inplace=False)
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        out = self.activation(x)
-        out = self.conv1(out)
-        out = self.activation(out)
-        out = self.conv2(out)
-        return out + x
-
-
-class FeatureFusionBlock(nn.Module):
-    def __init__(self, features: int, has_residual: bool = True, align_corners: bool = True, device=None, dtype=None, operations=None):
-        super().__init__()
-        self.align_corners = align_corners
-        self.has_residual = has_residual
-        if has_residual:
-            self.resConfUnit1 = ResidualConvUnit(features, device=device, dtype=dtype, operations=operations)
-        else:
-            self.resConfUnit1 = None
-        self.resConfUnit2 = ResidualConvUnit(features, device=device, dtype=dtype, operations=operations)
-        self.out_conv = operations.Conv2d(features, features, 1, 1, 0, bias=True, device=device, dtype=dtype)
-
-    def forward(self, *xs: torch.Tensor, size: Optional[Tuple[int, int]] = None) -> torch.Tensor:
-        y = xs[0]
-        if self.has_residual and len(xs) > 1 and self.resConfUnit1 is not None:
-            y = y + self.resConfUnit1(xs[1])
-        y = self.resConfUnit2(y)
-        if size is None:
-            up_kwargs = {"scale_factor": 2.0}
-        else:
-            up_kwargs = {"size": size}
-        y = _custom_interpolate(y, **up_kwargs, mode="bilinear", align_corners=self.align_corners)
-        y = self.out_conv(y)
-        return y
-
-
-class _Scratch(nn.Module):
-    """Container that mirrors upstream ``scratch`` attribute layout."""
-
-
-def _make_scratch(in_shape: List[int], out_shape: int, device=None, dtype=None, operations=None) -> _Scratch:
-    scratch = _Scratch()
-    scratch.layer1_rn = operations.Conv2d(in_shape[0], out_shape, 3, 1, 1, bias=False, device=device, dtype=dtype)
-    scratch.layer2_rn = operations.Conv2d(in_shape[1], out_shape, 3, 1, 1, bias=False, device=device, dtype=dtype)
-    scratch.layer3_rn = operations.Conv2d(in_shape[2], out_shape, 3, 1, 1, bias=False, device=device, dtype=dtype)
-    scratch.layer4_rn = operations.Conv2d(in_shape[3], out_shape, 3, 1, 1, bias=False, device=device, dtype=dtype)
-    return scratch
-
-
-def _make_fusion_block(features: int, has_residual: bool = True, device=None, dtype=None, operations=None) -> FeatureFusionBlock:
-    return FeatureFusionBlock(features, has_residual=has_residual, align_corners=True, device=device, dtype=dtype, operations=operations)
-
-
-# -----------------------------------------------------------------------------
-# DPT (single head + optional sky head) -- used by DA3Mono/Metric
-# -----------------------------------------------------------------------------
-
-
-class DPT(nn.Module):
-    """Single-head DPT used by DA3Mono-Large and DA3Metric-Large."""
-
-    def __init__(
-        self,
-        dim_in: int,
-        patch_size: int = 14,
-        output_dim: int = 1,
-        activation: str = "exp",
-        conf_activation: str = "expp1",
-        features: int = 256,
-        out_channels: Sequence[int] = (256, 512, 1024, 1024),
-        pos_embed: bool = False,
-        down_ratio: int = 1,
-        head_name: str = "depth",
-        use_sky_head: bool = True,
-        sky_name: str = "sky",
-        sky_activation: str = "relu",
-        norm_type: str = "idt",
-        device=None, dtype=None, operations=None,
-    ):
-        super().__init__()
-        self.patch_size = patch_size
-        self.activation = activation
-        self.conf_activation = conf_activation
-        self.pos_embed = pos_embed
-        self.down_ratio = down_ratio
-        self.head_main = head_name
-        self.sky_name = sky_name
-        self.out_dim = output_dim
-        self.has_conf = output_dim > 1
-        self.use_sky_head = use_sky_head
-        self.sky_activation = sky_activation
-        self.intermediate_layer_idx: Tuple[int, int, int, int] = (0, 1, 2, 3)
-
-        if norm_type == "layer":
-            self.norm = operations.LayerNorm(dim_in, device=device, dtype=dtype)
-        else:
-            self.norm = nn.Identity()
-
-        out_channels = list(out_channels)
-        self.projects = nn.ModuleList([
-            operations.Conv2d(dim_in, oc, kernel_size=1, stride=1, padding=0, device=device, dtype=dtype)
-            for oc in out_channels
-        ])
-        self.resize_layers = nn.ModuleList([
-            operations.ConvTranspose2d(out_channels[0], out_channels[0], kernel_size=4, stride=4, padding=0, device=device, dtype=dtype),
-            operations.ConvTranspose2d(out_channels[1], out_channels[1], kernel_size=2, stride=2, padding=0, device=device, dtype=dtype),
-            nn.Identity(),
-            operations.Conv2d(out_channels[3], out_channels[3], kernel_size=3, stride=2, padding=1, device=device, dtype=dtype),
-        ])
-
-        self.scratch = _make_scratch(out_channels, features, device=device, dtype=dtype, operations=operations)
-        self.scratch.refinenet1 = _make_fusion_block(features, device=device, dtype=dtype, operations=operations)
-        self.scratch.refinenet2 = _make_fusion_block(features, device=device, dtype=dtype, operations=operations)
-        self.scratch.refinenet3 = _make_fusion_block(features, device=device, dtype=dtype, operations=operations)
-        self.scratch.refinenet4 = _make_fusion_block(features, has_residual=False, device=device, dtype=dtype, operations=operations)
-
-        head_features_1 = features
-        head_features_2 = 32
-        self.scratch.output_conv1 = operations.Conv2d(
-            head_features_1, head_features_1 // 2, kernel_size=3, stride=1, padding=1,
-            device=device, dtype=dtype,
-        )
-        self.scratch.output_conv2 = nn.Sequential(
-            operations.Conv2d(head_features_1 // 2, head_features_2, kernel_size=3, stride=1, padding=1, device=device, dtype=dtype),
-            nn.ReLU(inplace=False),
-            operations.Conv2d(head_features_2, output_dim, kernel_size=1, stride=1, padding=0, device=device, dtype=dtype),
-        )
-
-        if self.use_sky_head:
-            self.scratch.sky_output_conv2 = nn.Sequential(
-                operations.Conv2d(head_features_1 // 2, head_features_2, kernel_size=3, stride=1, padding=1, device=device, dtype=dtype),
-                nn.ReLU(inplace=False),
-                operations.Conv2d(head_features_2, 1, kernel_size=1, stride=1, padding=0, device=device, dtype=dtype),
-            )
-
-    def forward(self, feats: List[torch.Tensor], H: int, W: int, patch_start_idx: int = 0, **_kwargs) -> dict:
-        # feats[i][0] is the patch-token tensor with shape (B, S, N_patch, C)
-        B, S, N, C = feats[0][0].shape
-        feats_flat = [feat[0].reshape(B * S, N, C) for feat in feats]
-
-        ph, pw = H // self.patch_size, W // self.patch_size
-        resized = []
-        for stage_idx, take_idx in enumerate(self.intermediate_layer_idx):
-            x = feats_flat[take_idx][:, patch_start_idx:]
-            x = self.norm(x)
-            x = x.permute(0, 2, 1).contiguous().reshape(B * S, C, ph, pw)
-            x = self.projects[stage_idx](x)
-            if self.pos_embed:
-                x = _add_pos_embed(x, W, H)
-            x = self.resize_layers[stage_idx](x)
-            resized.append(x)
-
-        l1_rn = self.scratch.layer1_rn(resized[0])
-        l2_rn = self.scratch.layer2_rn(resized[1])
-        l3_rn = self.scratch.layer3_rn(resized[2])
-        l4_rn = self.scratch.layer4_rn(resized[3])
-
-        out = self.scratch.refinenet4(l4_rn, size=l3_rn.shape[2:])
-        out = self.scratch.refinenet3(out, l3_rn, size=l2_rn.shape[2:])
-        out = self.scratch.refinenet2(out, l2_rn, size=l1_rn.shape[2:])
-        out = self.scratch.refinenet1(out, l1_rn)
-
-        h_out = int(ph * self.patch_size / self.down_ratio)
-        w_out = int(pw * self.patch_size / self.down_ratio)
-
-        fused = self.scratch.output_conv1(out)
-        fused = _custom_interpolate(fused, (h_out, w_out), mode="bilinear", align_corners=True)
-        if self.pos_embed:
-            fused = _add_pos_embed(fused, W, H)
-        feat = fused
-
-        main_logits = self.scratch.output_conv2(feat)
-        outs = {}
-        if self.has_conf:
-            fmap = main_logits.permute(0, 2, 3, 1)
-            pred = _apply_activation(fmap[..., :-1], self.activation)
-            conf = _apply_activation(fmap[..., -1], self.conf_activation)
-            outs[self.head_main] = pred.squeeze(-1).view(B, S, *pred.shape[1:-1])
-            outs[f"{self.head_main}_conf"] = conf.view(B, S, *conf.shape[1:])
-        else:
-            pred = _apply_activation(main_logits, self.activation)
-            outs[self.head_main] = pred.squeeze(1).view(B, S, *pred.shape[2:])
-
-        if self.use_sky_head:
-            sky_logits = self.scratch.sky_output_conv2(feat)
-            if self.sky_activation.lower() == "sigmoid":
-                sky = torch.sigmoid(sky_logits)
-            elif self.sky_activation.lower() == "relu":
-                sky = F.relu(sky_logits)
-            else:
-                sky = sky_logits
-            outs[self.sky_name] = sky.squeeze(1).view(B, S, *sky.shape[2:])
-
-        return outs
-
-
-# -----------------------------------------------------------------------------
-# DualDPT (depth + auxiliary "ray" head) -- used by DA3-Small / DA3-Base
-# -----------------------------------------------------------------------------
-
-
-class DualDPT(nn.Module):
-    """Two-head DPT used by DA3-Small / DA3-Base."""
-
-    def __init__(
-        self,
-        dim_in: int,
-        patch_size: int = 14,
-        output_dim: int = 2,
-        activation: str = "exp",
-        conf_activation: str = "expp1",
-        features: int = 256,
-        out_channels: Sequence[int] = (256, 512, 1024, 1024),
-        pos_embed: bool = True,
-        down_ratio: int = 1,
-        aux_pyramid_levels: int = 4,
-        aux_out1_conv_num: int = 5,
-        head_names: Tuple[str, str] = ("depth", "ray"),
-        device=None, dtype=None, operations=None,
-    ):
-        super().__init__()
-        self.patch_size = patch_size
-        self.activation = activation
-        self.conf_activation = conf_activation
-        self.pos_embed = pos_embed
-        self.down_ratio = down_ratio
-        self.aux_levels = aux_pyramid_levels
-        self.aux_out1_conv_num = aux_out1_conv_num
-        self.head_main, self.head_aux = head_names
-        self.intermediate_layer_idx: Tuple[int, int, int, int] = (0, 1, 2, 3)
-        # Toggle the auxiliary ray branch at runtime. Default off (mono path).
-        # DepthAnything3Net flips this on when running multi-view + ray-pose.
-        self.enable_aux: bool = False
-
-        self.norm = operations.LayerNorm(dim_in, device=device, dtype=dtype)
-        out_channels = list(out_channels)
-        self.projects = nn.ModuleList([
-            operations.Conv2d(dim_in, oc, kernel_size=1, stride=1, padding=0, device=device, dtype=dtype)
-            for oc in out_channels
-        ])
-        self.resize_layers = nn.ModuleList([
-            operations.ConvTranspose2d(out_channels[0], out_channels[0], kernel_size=4, stride=4, padding=0, device=device, dtype=dtype),
-            operations.ConvTranspose2d(out_channels[1], out_channels[1], kernel_size=2, stride=2, padding=0, device=device, dtype=dtype),
-            nn.Identity(),
-            operations.Conv2d(out_channels[3], out_channels[3], kernel_size=3, stride=2, padding=1, device=device, dtype=dtype),
-        ])
-
-        self.scratch = _make_scratch(out_channels, features, device=device, dtype=dtype, operations=operations)
-        # Main fusion chain
-        self.scratch.refinenet1 = _make_fusion_block(features, device=device, dtype=dtype, operations=operations)
-        self.scratch.refinenet2 = _make_fusion_block(features, device=device, dtype=dtype, operations=operations)
-        self.scratch.refinenet3 = _make_fusion_block(features, device=device, dtype=dtype, operations=operations)
-        self.scratch.refinenet4 = _make_fusion_block(features, has_residual=False, device=device, dtype=dtype, operations=operations)
-        # Auxiliary fusion chain (separate copies)
-        self.scratch.refinenet1_aux = _make_fusion_block(features, device=device, dtype=dtype, operations=operations)
-        self.scratch.refinenet2_aux = _make_fusion_block(features, device=device, dtype=dtype, operations=operations)
-        self.scratch.refinenet3_aux = _make_fusion_block(features, device=device, dtype=dtype, operations=operations)
-        self.scratch.refinenet4_aux = _make_fusion_block(features, has_residual=False, device=device, dtype=dtype, operations=operations)
-
-        head_features_1 = features
-        head_features_2 = 32
-
-        # Main head neck + final projection
-        self.scratch.output_conv1 = operations.Conv2d(
-            head_features_1, head_features_1 // 2, kernel_size=3, stride=1, padding=1,
-            device=device, dtype=dtype,
-        )
-        self.scratch.output_conv2 = nn.Sequential(
-            operations.Conv2d(head_features_1 // 2, head_features_2, kernel_size=3, stride=1, padding=1, device=device, dtype=dtype),
-            nn.ReLU(inplace=False),
-            operations.Conv2d(head_features_2, output_dim, kernel_size=1, stride=1, padding=0, device=device, dtype=dtype),
-        )
-
-        # Aux pre-head per level (multi-level pyramid)
-        self.scratch.output_conv1_aux = nn.ModuleList([
-            self._make_aux_out1_block(head_features_1, device=device, dtype=dtype, operations=operations)
-            for _ in range(self.aux_levels)
-        ])
-
-        # Aux final projection per level (includes LayerNorm permute path).
-        ln_seq = [Permute((0, 2, 3, 1)),
-                  operations.LayerNorm(head_features_2, device=device, dtype=dtype),
-                  Permute((0, 3, 1, 2))]
-        self.scratch.output_conv2_aux = nn.ModuleList([
-            nn.Sequential(
-                operations.Conv2d(head_features_1 // 2, head_features_2, kernel_size=3, stride=1, padding=1, device=device, dtype=dtype),
-                *ln_seq,
-                nn.ReLU(inplace=False),
-                operations.Conv2d(head_features_2, 7, kernel_size=1, stride=1, padding=0, device=device, dtype=dtype),
-            )
-            for _ in range(self.aux_levels)
-        ])
-
-    @staticmethod
-    def _make_aux_out1_block(in_ch: int, *, device=None, dtype=None, operations=None) -> nn.Sequential:
-        # aux_out1_conv_num=5 in all Apache-2.0 variants.
-        return nn.Sequential(
-            operations.Conv2d(in_ch, in_ch // 2, 3, 1, 1, device=device, dtype=dtype),
-            operations.Conv2d(in_ch // 2, in_ch, 3, 1, 1, device=device, dtype=dtype),
-            operations.Conv2d(in_ch, in_ch // 2, 3, 1, 1, device=device, dtype=dtype),
-            operations.Conv2d(in_ch // 2, in_ch, 3, 1, 1, device=device, dtype=dtype),
-            operations.Conv2d(in_ch, in_ch // 2, 3, 1, 1, device=device, dtype=dtype),
-        )
-
-    def forward(self, feats: List[torch.Tensor], H: int, W: int, patch_start_idx: int = 0, **_kwargs) -> dict:
-        B, S, N, C = feats[0][0].shape
-        feats_flat = [feat[0].reshape(B * S, N, C) for feat in feats]
-
-        ph, pw = H // self.patch_size, W // self.patch_size
-        resized = []
-        for stage_idx, take_idx in enumerate(self.intermediate_layer_idx):
-            x = feats_flat[take_idx][:, patch_start_idx:]
-            x = self.norm(x)
-            x = x.permute(0, 2, 1).contiguous().reshape(B * S, C, ph, pw)
-            x = self.projects[stage_idx](x)
-            if self.pos_embed:
-                x = _add_pos_embed(x, W, H)
-            x = self.resize_layers[stage_idx](x)
-            resized.append(x)
-
-        l1_rn = self.scratch.layer1_rn(resized[0])
-        l2_rn = self.scratch.layer2_rn(resized[1])
-        l3_rn = self.scratch.layer3_rn(resized[2])
-        l4_rn = self.scratch.layer4_rn(resized[3])
-
-        # Main pyramid (output_conv1 is applied inside the upstream `_fuse`,
-        # before interpolation -- replicate that order here).
-        m = self.scratch.refinenet4(l4_rn, size=l3_rn.shape[2:])
-        if self.enable_aux:
-            a4 = self.scratch.refinenet4_aux(l4_rn, size=l3_rn.shape[2:])
-            aux_pyr = [a4]
-        m = self.scratch.refinenet3(m, l3_rn, size=l2_rn.shape[2:])
-        if self.enable_aux:
-            aux_pyr.append(self.scratch.refinenet3_aux(aux_pyr[-1], l3_rn, size=l2_rn.shape[2:]))
-        m = self.scratch.refinenet2(m, l2_rn, size=l1_rn.shape[2:])
-        if self.enable_aux:
-            aux_pyr.append(self.scratch.refinenet2_aux(aux_pyr[-1], l2_rn, size=l1_rn.shape[2:]))
-        m = self.scratch.refinenet1(m, l1_rn)
-        if self.enable_aux:
-            aux_pyr.append(self.scratch.refinenet1_aux(aux_pyr[-1], l1_rn))
-        m = self.scratch.output_conv1(m)
-
-        h_out = int(ph * self.patch_size / self.down_ratio)
-        w_out = int(pw * self.patch_size / self.down_ratio)
-
-        m = _custom_interpolate(m, (h_out, w_out), mode="bilinear", align_corners=True)
-        if self.pos_embed:
-            m = _add_pos_embed(m, W, H)
-        main_logits = self.scratch.output_conv2(m)
-        fmap = main_logits.permute(0, 2, 3, 1)
-        depth_pred = _apply_activation(fmap[..., :-1], self.activation)
-        depth_conf = _apply_activation(fmap[..., -1], self.conf_activation)
-
-        outs = {
-            self.head_main: depth_pred.squeeze(-1).view(B, S, *depth_pred.shape[1:-1]),
-            f"{self.head_main}_conf": depth_conf.view(B, S, *depth_conf.shape[1:]),
-        }
-
-        if self.enable_aux:
-            # Auxiliary "ray" head (multi-level inside) -- only the last level
-            # is returned. Mirrors upstream ``DualDPT._fuse`` + ``_forward_impl``:
-            # each aux pyramid level goes through ``output_conv1_aux[i]``
-            # (5-layer conv stack that ends at ``features // 2`` channels),
-            # then the last level optionally gets a pos-embed and finally
-            # ``output_conv2_aux[-1]``.
-            aux_processed = [
-                self.scratch.output_conv1_aux[i](a) for i, a in enumerate(aux_pyr)
-            ]
-            last_aux = aux_processed[-1]
-            if self.pos_embed:
-                last_aux = _add_pos_embed(last_aux, W, H)
-            last_aux_logits = self.scratch.output_conv2_aux[-1](last_aux)
-            fmap_last = last_aux_logits.permute(0, 2, 3, 1)
-            # Channels: [ray(6), ray_conf(1)]; ray uses 'linear' activation.
-            aux_pred = fmap_last[..., :-1]
-            aux_conf = _apply_activation(fmap_last[..., -1], self.conf_activation)
-            outs[self.head_aux] = aux_pred.view(B, S, *aux_pred.shape[1:])
-            outs[f"{self.head_aux}_conf"] = aux_conf.view(B, S, *aux_conf.shape[1:])
-
-        return outs
@@ -1,236 +0,0 @@
-from __future__ import annotations
-
-from typing import Dict, Optional, Sequence
-
-import torch
-import torch.nn as nn
-
-from comfy.image_encoders.dino2 import Dinov2Model
-
-from .camera import CameraDec, CameraEnc
-from .dpt import DPT, DualDPT
-from .ray_pose import get_extrinsic_from_camray
-from .transform import affine_inverse, pose_encoding_to_extri_intri
-
-
-_HEAD_REGISTRY = {
-    "dpt": DPT,
-    "dualdpt": DualDPT,
-}
-
-
-# Backbone presets (mirror the upstream DINOv2 ViT variants).
-_BACKBONE_PRESETS = {
-    "vits": dict(hidden_size=384,  num_hidden_layers=12, num_attention_heads=6,  use_swiglu_ffn=False),
-    "vitb": dict(hidden_size=768,  num_hidden_layers=12, num_attention_heads=12, use_swiglu_ffn=False),
-    "vitl": dict(hidden_size=1024, num_hidden_layers=24, num_attention_heads=16, use_swiglu_ffn=False),
-    "vitg": dict(hidden_size=1536, num_hidden_layers=40, num_attention_heads=24, use_swiglu_ffn=True),
-}
-
-
-def _build_backbone_config(
-    backbone_name: str,
-    *,
-    alt_start: int,
-    qknorm_start: int,
-    rope_start: int,
-    cat_token: bool,
-) -> dict:
-    if backbone_name not in _BACKBONE_PRESETS:
-        raise ValueError(f"Unknown DINOv2 backbone variant: {backbone_name!r}")
-    cfg = dict(_BACKBONE_PRESETS[backbone_name])
-    cfg.update(dict(
-        layer_norm_eps=1e-6,
-        patch_size=14,
-        image_size=518,
-        # No mask_token in DA3 weights; omit param to avoid load warnings.
-        use_mask_token=False,
-        alt_start=alt_start,
-        qknorm_start=qknorm_start,
-        rope_start=rope_start,
-        cat_token=cat_token,
-        rope_freq=100.0,
-    ))
-    return cfg
-
-
-class DepthAnything3Net(nn.Module):
-
-    PATCH_SIZE = 14
-
-    def __init__(
-        self,
-        # --- Backbone ---
-        backbone_name: str = "vitl",
-        out_layers: Sequence[int] = (4, 11, 17, 23),
-        alt_start: int = -1,
-        qknorm_start: int = -1,
-        rope_start: int = -1,
-        cat_token: bool = False,
-        # --- Head ---
-        head_type: str = "dpt",  # dpt or dualdpt
-        head_dim_in: int = 1024,
-        head_output_dim: int = 1,  # 1 = depth only, 2 = depth+conf
-        head_features: int = 256,
-        head_out_channels: Sequence[int] = (256, 512, 1024, 1024),
-        head_use_sky_head: bool = True, # ignored by DualDPT
-        head_pos_embed: Optional[bool] = None,  # default: True for DualDPT, False for DPT
-        # --- Camera (multi-view) ---
-        has_cam_enc: bool = False,
-        has_cam_dec: bool = False,
-        cam_dim_out: Optional[int] = None,  # CameraEnc dim_out (defaults to embed_dim)
-        cam_dec_dim_in: Optional[int] = None,  # CameraDec dim_in  (defaults to 2*embed_dim with cat_token)
-        # ComfyUI plumbing
-        device=None, dtype=None, operations=None,
-        **_ignored,
-    ):
-        super().__init__()
-        head_cls = _HEAD_REGISTRY[head_type.lower()]
-        self.head_type = head_type.lower()
-        self.has_sky = (self.head_type == "dpt") and head_use_sky_head
-        self.has_conf = head_output_dim > 1
-        self.out_layers = list(out_layers)
-
-        backbone_cfg = _build_backbone_config(
-            backbone_name,
-            alt_start=alt_start,
-            qknorm_start=qknorm_start,
-            rope_start=rope_start,
-            cat_token=cat_token,
-        )
-        self.backbone = Dinov2Model(backbone_cfg, dtype, device, operations)
-
-        head_kwargs = dict(
-            dim_in=head_dim_in,
-            patch_size=self.PATCH_SIZE,
-            output_dim=head_output_dim,
-            features=head_features,
-            out_channels=tuple(head_out_channels),
-            device=device, dtype=dtype, operations=operations,
-        )
-        if self.head_type == "dpt":
-            head_kwargs.update(
-                use_sky_head=head_use_sky_head,
-                pos_embed=(False if head_pos_embed is None else head_pos_embed),
-            )
-        else:  # dualdpt
-            head_kwargs.update(
-                pos_embed=(True if head_pos_embed is None else head_pos_embed),
-            )
-        self.head = head_cls(**head_kwargs)
-
-        # Built only if checkpoint has weights; cam_enc output dim == embed_dim.
-        embed_dim = backbone_cfg["hidden_size"]
-        if has_cam_enc:
-            self.cam_enc = CameraEnc(
-                dim_out=cam_dim_out if cam_dim_out is not None else embed_dim,
-                num_heads=max(1, embed_dim // 64),
-                device=device, dtype=dtype, operations=operations,
-            )
-        else:
-            self.cam_enc = None
-        if has_cam_dec:
-            default_dim = embed_dim * (2 if cat_token else 1)
-            self.cam_dec = CameraDec(
-                dim_in=cam_dec_dim_in if cam_dec_dim_in is not None else default_dim,
-                device=device, dtype=dtype, operations=operations,
-            )
-        else:
-            self.cam_dec = None
-
-        self.dtype = dtype
-
-    def forward(
-        self,
-        image: torch.Tensor,
-        extrinsics: Optional[torch.Tensor] = None,
-        intrinsics: Optional[torch.Tensor] = None,
-        *,
-        use_ray_pose: bool = False,
-        ref_view_strategy: str = "saddle_balanced",
-        export_feat_layers: Optional[Sequence[int]] = None,
-        **_unused,
-    ) -> Dict[str, torch.Tensor]:
-        """Run depth and optionally pose prediction."""
-        if image.ndim == 4:
-            image = image.unsqueeze(1)  # (B, 1, 3, H, W)
-        assert image.ndim == 5 and image.shape[2] == 3, \
-            f"image must be (B,3,H,W) or (B,S,3,H,W); got {tuple(image.shape)}"
-
-        B, S, _, H, W = image.shape
-        assert H % self.PATCH_SIZE == 0 and W % self.PATCH_SIZE == 0, \
-            f"image H,W must be multiples of {self.PATCH_SIZE}; got {(H, W)}"
-
-        # Camera-token preparation (multi-view path).
-        cam_token = None
-        if extrinsics is not None and intrinsics is not None and self.cam_enc is not None:
-            cam_token = self.cam_enc(extrinsics, intrinsics, (H, W))
-
-        # Toggle aux ray output on/off depending on what the caller asked for.
-        if isinstance(self.head, DualDPT):
-            self.head.enable_aux = bool(use_ray_pose)
-
-        feats, aux_feats = self.backbone.get_intermediate_layers_da3(
-            image, self.out_layers, cam_token=cam_token,
-            ref_view_strategy=ref_view_strategy,
-            export_feat_layers=export_feat_layers,
-        )
-        head_out = self.head(feats, H=H, W=W, patch_start_idx=0)
-
-        # Pose prediction.
-        out: Dict[str, torch.Tensor] = {}
-        if use_ray_pose and "ray" in head_out and "ray_conf" in head_out:
-            ray = head_out["ray"]
-            ray_conf = head_out["ray_conf"]
-            extr_c2w, focal, pp = get_extrinsic_from_camray(
-                ray, ray_conf, ray.shape[-3], ray.shape[-2],
-            )
-            # Match the upstream output: w2c, drop the homogeneous row.
-            extr_w2c = affine_inverse(extr_c2w)[:, :, :3, :]
-            # Build pixel-space intrinsics from the normalised focal/pp output.
-            intr = torch.eye(3, device=ray.device, dtype=ray.dtype)
-            intr = intr[None, None].expand(extr_c2w.shape[0], extr_c2w.shape[1], 3, 3).clone()
-            intr[:, :, 0, 0] = focal[:, :, 0] / 2 * W
-            intr[:, :, 1, 1] = focal[:, :, 1] / 2 * H
-            intr[:, :, 0, 2] = pp[:, :, 0] * W * 0.5
-            intr[:, :, 1, 2] = pp[:, :, 1] * H * 0.5
-            out["extrinsics"] = extr_w2c
-            out["intrinsics"] = intr
-        elif self.cam_dec is not None and S > 1:
-            # Decode the cam-token of the final out_layer into a pose encoding.
-            cam_feat = feats[-1][1]  # (B, S, dim_in_to_cam_dec)
-            pose_enc = self.cam_dec(cam_feat)
-            c2w_3x4, intr = pose_encoding_to_extri_intri(pose_enc, (H, W))
-            # Match the upstream output convention: w2c (world->camera), 3x4.
-            c2w_4x4 = torch.cat([
-                c2w_3x4,
-                torch.tensor([0, 0, 0, 1], device=c2w_3x4.device, dtype=c2w_3x4.dtype)
-                    .view(1, 1, 1, 4).expand(B, S, 1, 4),
-            ], dim=-2)
-            out["extrinsics"] = affine_inverse(c2w_4x4)[:, :, :3, :]
-            out["intrinsics"] = intr
-
-        # Flatten the views axis for per-pixel outputs (depth/conf/sky) so the
-        # per-image consumer keeps its (B*S, H, W) interface.
-        for k, v in head_out.items():
-            if k in ("ray", "ray_conf"):
-                # Keep multi-view shape for downstream pose work.
-                out[k] = v
-            elif v.ndim >= 3 and v.shape[0] == B and v.shape[1] == S:
-                out[k] = v.reshape(B * S, *v.shape[2:])
-            else:
-                out[k] = v
-
-        if export_feat_layers:
-            out["aux_features"] = self._reshape_aux_features(aux_feats, H, W)
-        return out
-
-    def _reshape_aux_features(self, aux_feats, H: int, W: int):
-        """Reshape (B, S, N, C) aux features into (B, S, h_p, w_p, C)."""
-        ph, pw = H // self.PATCH_SIZE, W // self.PATCH_SIZE
-        out = []
-        for f in aux_feats:
-            B, S, N, C = f.shape
-            assert N == ph * pw, f"aux feature seq mismatch: {N} != {ph}*{pw}"
-            out.append(f.reshape(B, S, ph, pw, C))
-        return out
@@ -1,128 +0,0 @@
-"""Input/output preprocessing helpers for Depth Anything 3."""
-
-from __future__ import annotations
-
-from typing import Tuple
-
-import torch
-
-import comfy.utils
-
-PATCH_SIZE = 14
-
-# ImageNet normalization constants used during DA3 training.
-_IMAGENET_MEAN = torch.tensor([0.485, 0.456, 0.406])
-_IMAGENET_STD = torch.tensor([0.229, 0.224, 0.225])
-
-
-def _round_to_patch(x: int, patch: int = PATCH_SIZE) -> int:
-    down = (x // patch) * patch
-    up = down + patch
-    return up if abs(up - x) <= abs(x - down) else down
-
-
-def compute_target_size(orig_h: int, orig_w: int, process_res: int, method: str = "upper_bound_resize") -> Tuple[int, int]:
-    """Compute (target_h, target_w) for a single image.
-    upper_bound_resize: scale longest side to process_res, then round each dim to nearest multiple of 14 (default upstream method).
-    lower_bound_resize: scale shortest side to process_res, then round."""
-
-    if method == "upper_bound_resize":
-        longest = max(orig_h, orig_w)
-        scale = process_res / float(longest)
-    elif method == "lower_bound_resize":
-        shortest = min(orig_h, orig_w)
-        scale = process_res / float(shortest)
-    else:
-        raise ValueError(f"Unsupported process_res_method: {method}")
-
-    new_w = max(1, _round_to_patch(int(round(orig_w * scale))))
-    new_h = max(1, _round_to_patch(int(round(orig_h * scale))))
-    return new_h, new_w
-
-
-def preprocess_image(image: torch.Tensor, process_res: int = 504, method: str = "upper_bound_resize") -> torch.Tensor:
-    assert image.ndim == 4 and image.shape[-1] == 3, f"expected (B,H,W,3) IMAGE; got {tuple(image.shape)}"
-    B, H, W, _ = image.shape
-    target_h, target_w = compute_target_size(H, W, process_res, method)
-
-    # (B, H, W, 3) -> (B, 3, H, W)
-    x = image.movedim(-1, 1).contiguous()
-    if (target_h, target_w) != (H, W):
-        # Upstream uses cv2 INTER_CUBIC (upscale) / INTER_AREA (downscale).
-        # Lanczos in ``common_upscale`` is anti-aliased and produces the
-        # closest pixel-wise match in a sweep across {bilinear, bicubic,
-        # area, lanczos, bislerp}. Used in both directions for simplicity.
-        x = comfy.utils.common_upscale(x.float(), target_w, target_h, "lanczos", "disabled",)
-    x = x.clamp(0.0, 1.0)
-
-    mean = _IMAGENET_MEAN.to(device=x.device, dtype=x.dtype).view(1, 3, 1, 1)
-    std = _IMAGENET_STD.to(device=x.device, dtype=x.dtype).view(1, 3, 1, 1)
-    x = (x - mean) / std
-    return x
-
-
-# -----------------------------------------------------------------------------
-# Output post-processing (sky-aware clipping for Mono/Metric variants)
-# -----------------------------------------------------------------------------
-
-
-def compute_non_sky_mask(sky_prediction: torch.Tensor, threshold: float = 0.3) -> torch.Tensor:
-    """Boolean mask: True for non-sky pixels (sky probability < threshold)."""
-    return sky_prediction < threshold
-
-
-def apply_sky_aware_clip(depth: torch.Tensor, sky: torch.Tensor, threshold: float = 0.3, quantile: float = 0.99) -> torch.Tensor:
-    """Clips sky regions to the 99th percentile of non-sky depth. Returns a new depth tensor."""
-    non_sky = compute_non_sky_mask(sky, threshold=threshold)
-    if non_sky.sum() <= 10 or (~non_sky).sum() <= 10:
-        return depth.clone()
-
-    non_sky_depth = depth[non_sky]
-    if non_sky_depth.numel() > 100_000:
-        idx = torch.randint(0, non_sky_depth.numel(), (100_000,), device=non_sky_depth.device)
-        sampled = non_sky_depth[idx]
-    else:
-        sampled = non_sky_depth
-
-    max_depth = torch.quantile(sampled, quantile)
-    out = depth.clone()
-    out[~non_sky] = max_depth
-    return out
-
-
-def normalize_depth_v2_style(depth: torch.Tensor, sky: torch.Tensor | None = None, low_quantile: float = 0.01, high_quantile: float = 0.99) -> torch.Tensor:
-    """V2-style normalization computes percentile bounds over non-sky pixels (when available), then maps depth into [0, 1] with near = white (1.0)."""
-    if sky is not None:
-        mask = compute_non_sky_mask(sky)
-        if mask.any():
-            valid = depth[mask]
-        else:
-            valid = depth.flatten()
-    else:
-        valid = depth.flatten()
-
-    if valid.numel() > 100_000:
-        idx = torch.randint(0, valid.numel(), (100_000,), device=valid.device)
-        sample = valid[idx]
-    else:
-        sample = valid
-
-    lo = torch.quantile(sample, low_quantile)
-    hi = torch.quantile(sample, high_quantile)
-    rng = (hi - lo).clamp(min=1e-6)
-    norm = ((depth - lo) / rng).clamp(0.0, 1.0)
-    # Nearer pixels are brighter (1.0)
-    norm = 1.0 - norm
-    if sky is not None:
-        # Sky pixels become black (far / unknown)
-        sky_mask = ~compute_non_sky_mask(sky)
-        norm = torch.where(sky_mask, torch.zeros_like(norm), norm)
-    return norm
-
-
-def normalize_depth_min_max(depth: torch.Tensor) -> torch.Tensor:
-    """Simple per-frame min/max normalization with near=1.0 convention."""
-    lo = depth.amin(dim=(-2, -1), keepdim=True)
-    hi = depth.amax(dim=(-2, -1), keepdim=True)
-    rng = (hi - lo).clamp(min=1e-6)
-    return 1.0 - ((depth - lo) / rng).clamp(0.0, 1.0)
@@ -1,272 +0,0 @@
-"""Ray-to-pose conversion for the multi-view path of Depth Anything 3."""
-
-from __future__ import annotations
-
-from typing import Optional, Tuple
-
-import torch
-
-
-# qr/svd use fp32: CUDA often has no fp16/bf16 kernels for these ops.
-
-
-def _ql_decomposition(A: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
-    """Decompose A = Q @ L with Q orthogonal and L lower-triangular.
-    Implemented in terms of QR by reversing the columns/rows; the standard
-    trick from the upstream reference. Inputs A are (3, 3)."""
-    P = torch.tensor([[0, 0, 1], [0, 1, 0], [1, 0, 0]], device=A.device, dtype=A.dtype)
-    A_tilde = A @ P
-    # CUDA QR is not implemented for fp16/bf16; upcast just for this call.
-    Q_tilde, R_tilde = torch.linalg.qr(A_tilde.float())
-    Q_tilde = Q_tilde.to(A.dtype)
-    R_tilde = R_tilde.to(A.dtype)
-    Q = Q_tilde @ P
-    L = P @ R_tilde @ P
-    d = torch.diag(L)
-    sign = torch.sign(d)
-    Q = Q * sign[None, :]  # scale columns of Q
-    L = L * sign[:, None]  # scale rows of L
-    return Q, L
-
-
-def _homogenize_points(points: torch.Tensor) -> torch.Tensor:
-    return torch.cat([points, torch.ones_like(points[..., :1])], dim=-1)
-
-
-# -----------------------------------------------------------------------------
-# Weighted-LSQ + RANSAC homography (batched)
-# -----------------------------------------------------------------------------
-
-
-def _find_homography_weighted_lsq(src_pts: torch.Tensor, dst_pts: torch.Tensor, confident_weight: torch.Tensor,) -> torch.Tensor:
-    """Solve a single H with weighted least-squares (DLT)."""
-    N = src_pts.shape[0]
-    if N < 4:
-        raise ValueError("At least 4 points are required to compute a homography.")
-    w = confident_weight.sqrt().unsqueeze(1)  # (N, 1)
-    x = src_pts[:, 0:1]
-    y = src_pts[:, 1:2]
-    u = dst_pts[:, 0:1]
-    v = dst_pts[:, 1:2]
-    zeros = torch.zeros_like(x)
-    A1 = torch.cat([-x * w, -y * w, -w, zeros, zeros, zeros, x * u * w, y * u * w, u * w], dim=1)
-    A2 = torch.cat([zeros, zeros, zeros, -x * w, -y * w, -w, x * v * w, y * v * w, v * w], dim=1)
-    A = torch.cat([A1, A2], dim=0)        # (2N, 9)
-    # CUDA SVD is not implemented for fp16/bf16; upcast just for this call.
-    _, _, Vh = torch.linalg.svd(A.float())
-    Vh = Vh.to(A.dtype)
-    H = Vh[-1].reshape(3, 3)
-    return H / H[-1, -1]
-
-
-def _find_homography_weighted_lsq_batched(src_pts_batch: torch.Tensor, dst_pts_batch: torch.Tensor, confident_weight_batch: torch.Tensor) -> torch.Tensor:
-    """Batched DLT solver. Inputs (B, K, 2) / (B, K); output (B, 3, 3)."""
-    B, K, _ = src_pts_batch.shape
-    w = confident_weight_batch.sqrt().unsqueeze(2)
-    x = src_pts_batch[:, :, 0:1]
-    y = src_pts_batch[:, :, 1:2]
-    u = dst_pts_batch[:, :, 0:1]
-    v = dst_pts_batch[:, :, 1:2]
-    zeros = torch.zeros_like(x)
-    A1 = torch.cat([-x * w, -y * w, -w, zeros, zeros, zeros, x * u * w, y * u * w, u * w], dim=2)
-    A2 = torch.cat([zeros, zeros, zeros, -x * w, -y * w, -w, x * v * w, y * v * w, v * w], dim=2)
-    A = torch.cat([A1, A2], dim=1)        # (B, 2K, 9)
-    # CUDA SVD is not implemented for fp16/bf16; upcast just for this call.
-    _, _, Vh = torch.linalg.svd(A.float())
-    Vh = Vh.to(A.dtype)
-    H = Vh[:, -1].reshape(B, 3, 3)
-    return H / H[:, 2:3, 2:3]
-
-
-def _ransac_find_homography_weighted_batched(
-    src_pts: torch.Tensor,                # (B, N, 2)
-    dst_pts: torch.Tensor,                # (B, N, 2)
-    confident_weight: torch.Tensor,       # (B, N)
-    n_sample: int,
-    n_iter: int = 100,
-    reproj_threshold: float = 3.0,
-    num_sample_for_ransac: int = 8,
-    max_inlier_num: int = 10000,
-    rand_sample_iters_idx: Optional[torch.Tensor] = None,
-) -> torch.Tensor:
-    """Batched weighted-RANSAC homography estimator. Returns (B, 3, 3) homography matrices."""
-    B, N, _ = src_pts.shape
-    assert N >= 4
-    device = src_pts.device
-
-    sorted_idx = torch.argsort(confident_weight, descending=True, dim=1)
-    candidate_idx = sorted_idx[:, :n_sample]                  # (B, n_sample)
-
-    if rand_sample_iters_idx is None:
-        rand_sample_iters_idx = torch.stack(
-            [torch.randperm(n_sample, device=device)[:num_sample_for_ransac]
-             for _ in range(n_iter)],
-            dim=0,
-        )
-
-    rand_idx = candidate_idx[:, rand_sample_iters_idx]        # (B, n_iter, k)
-    b_idx = (
-        torch.arange(B, device=device)
-        .view(B, 1, 1)
-        .expand(B, n_iter, num_sample_for_ransac)
-    )
-    src_b = src_pts[b_idx, rand_idx]
-    dst_b = dst_pts[b_idx, rand_idx]
-    w_b = confident_weight[b_idx, rand_idx]
-
-    cB, cN = src_b.shape[:2]
-    H_batch = _find_homography_weighted_lsq_batched(
-        src_b.flatten(0, 1), dst_b.flatten(0, 1), w_b.flatten(0, 1),
-    ).unflatten(0, (cB, cN))                                  # (B, n_iter, 3, 3)
-
-    src_homo = torch.cat([src_pts, torch.ones(B, N, 1, device=device, dtype=src_pts.dtype)], dim=2)
-    proj = torch.bmm(
-        src_homo.unsqueeze(1).expand(B, n_iter, N, 3).reshape(-1, N, 3),
-        H_batch.reshape(-1, 3, 3).transpose(1, 2),
-    )                                                          # (B*n_iter, N, 3)
-    proj_xy = (proj[:, :, :2] / proj[:, :, 2:3]).reshape(B, n_iter, N, 2)
-    err = ((proj_xy - dst_pts.unsqueeze(1)) ** 2).sum(-1).sqrt()  # (B, n_iter, N)
-    inlier_mask = err < reproj_threshold
-    score = (inlier_mask * confident_weight.unsqueeze(1)).sum(dim=2)
-    best_idx = torch.argmax(score, dim=1)
-    best_inlier_mask = inlier_mask[torch.arange(B, device=device), best_idx]
-
-    # Refit with the inlier set (per-batch, since the inlier counts vary).
-    H_inlier_list = []
-    for b in range(B):
-        mask = best_inlier_mask[b]
-        in_src = src_pts[b][mask]
-        in_dst = dst_pts[b][mask]
-        in_w = confident_weight[b][mask]
-        if in_src.shape[0] < 4:
-            # Fall back to identity when RANSAC fails to find enough inliers.
-            H_inlier_list.append(torch.eye(3, device=device, dtype=src_pts.dtype))
-            continue
-        sorted_w = torch.argsort(in_w, descending=True)
-        if len(sorted_w) > max_inlier_num:
-            keep = max(int(len(sorted_w) * 0.95), max_inlier_num)
-            sorted_w = sorted_w[:keep][torch.randperm(keep, device=device)[:max_inlier_num]]
-        H_inlier_list.append(
-            _find_homography_weighted_lsq(in_src[sorted_w], in_dst[sorted_w], in_w[sorted_w])
-        )
-    return torch.stack(H_inlier_list, dim=0)
-
-
-# -----------------------------------------------------------------------------
-# Camera-ray utilities
-# -----------------------------------------------------------------------------
-
-
-def _unproject_identity(num_y: int, num_x: int, B: int, S: int, device, dtype) -> torch.Tensor:
-    """Camera-space unit rays for an identity intrinsic on a 2x2 image plane."""
-    dx = 1.0 / num_x
-    dy = 1.0 / num_y
-    # Centered camera-space coords directly (skip the K^-1 step since it's
-    # just a translation by -1 on x and y when K is identity-with-center=1).
-    y = torch.linspace(-(1 - dy), (1 - dy), num_y, device=device, dtype=dtype)
-    x = torch.linspace(-(1 - dx), (1 - dx), num_x, device=device, dtype=dtype)
-    yy, xx = torch.meshgrid(y, x, indexing="ij")
-    grid = torch.stack((xx, yy), dim=-1)            # (h, w, 2)
-    grid = grid.unsqueeze(0).unsqueeze(0).expand(B, S, num_y, num_x, 2)
-    return torch.cat([grid, torch.ones_like(grid[..., :1])], dim=-1)
-
-
-def _camray_to_caminfo(
-    camray: torch.Tensor,  # (B, S, h, w, 6)
-    confidence: Optional[torch.Tensor] = None,  # (B, S, h, w)
-    reproj_threshold: float = 0.2,
-) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
-    """Convert per-pixel camera rays to per-view (R, T, focal, principal)."""
-    if confidence is None:
-        confidence = torch.ones_like(camray[..., 0])
-    B, S, h, w, _ = camray.shape
-    device = camray.device
-    dtype = camray.dtype
-
-    rays_target = camray[..., :3]                           # (B, S, h, w, 3)
-    rays_origin = _unproject_identity(h, w, B, S, device, dtype)
-
-    # Flatten (B*S, h*w, *) for the RANSAC routine.
-    rays_target = rays_target.flatten(0, 1).flatten(1, 2)
-    rays_origin = rays_origin.flatten(0, 1).flatten(1, 2)
-    weights = confidence.flatten(0, 1).flatten(1, 2).clone()
-
-    # Project to 2D in homogeneous form (the upstream calls this "perspective division").
-    z_thresh = 1e-4
-    mask = (rays_target[:, :, 2].abs() > z_thresh) & (rays_origin[:, :, 2].abs() > z_thresh)
-    weights = torch.where(mask, weights, torch.zeros_like(weights))
-    src = rays_origin.clone()
-    dst = rays_target.clone()
-    src[..., 0] = torch.where(mask, src[..., 0] / src[..., 2], src[..., 0])
-    src[..., 1] = torch.where(mask, src[..., 1] / src[..., 2], src[..., 1])
-    dst[..., 0] = torch.where(mask, dst[..., 0] / dst[..., 2], dst[..., 0])
-    dst[..., 1] = torch.where(mask, dst[..., 1] / dst[..., 2], dst[..., 1])
-    src = src[..., :2]
-    dst = dst[..., :2]
-
-    N = src.shape[1]
-    n_iter = 100
-    sample_ratio = 0.3
-    num_sample_for_ransac = 8
-    n_sample = max(num_sample_for_ransac, int(N * sample_ratio))
-    rand_idx = torch.stack(
-        [torch.randperm(n_sample, device=device)[:num_sample_for_ransac] for _ in range(n_iter)],
-        dim=0,
-    )
-
-    # Chunk along the view axis to keep peak memory predictable.
-    chunk = 2
-    A_list = []
-    for i in range(0, src.shape[0], chunk):
-        A = _ransac_find_homography_weighted_batched(
-            src[i:i + chunk], dst[i:i + chunk], weights[i:i + chunk],
-            n_sample=n_sample, n_iter=n_iter,
-            num_sample_for_ransac=num_sample_for_ransac,
-            reproj_threshold=reproj_threshold,
-            rand_sample_iters_idx=rand_idx,
-            max_inlier_num=8000,
-        )
-        # Flip sign on dets that come out < 0 (so that the QL produces a
-        # right-handed rotation). ``det`` lacks fp16/bf16 CUDA kernels, so
-        # do the comparison in fp32.
-        flip = torch.linalg.det(A.float()) < 0
-        A = torch.where(flip[:, None, None], -A, A)
-        A_list.append(A)
-    A = torch.cat(A_list, dim=0)                            # (B*S, 3, 3)
-
-    R_list, f_list, pp_list = [], [], []
-    for i in range(A.shape[0]):
-        R, L = _ql_decomposition(A[i])
-        L = L / L[2][2]
-        f_list.append(torch.stack((L[0][0], L[1][1])))
-        pp_list.append(torch.stack((L[2][0], L[2][1])))
-        R_list.append(R)
-    R = torch.stack(R_list).reshape(B, S, 3, 3)
-    focal = torch.stack(f_list).reshape(B, S, 2)
-    pp = torch.stack(pp_list).reshape(B, S, 2)
-
-    # Translation: confidence-weighted average of camray direction(s).
-    cf = confidence.flatten(0, 1).flatten(1, 2)
-    T = (camray.flatten(0, 1).flatten(1, 2)[..., 3:] * cf.unsqueeze(-1)).sum(dim=1)
-    T = T / cf.sum(dim=-1, keepdim=True)
-    T = T.reshape(B, S, 3)
-
-    # Match upstream output convention: focal -> 1/focal, pp + 1.
-    return R, T, 1.0 / focal, pp + 1.0
-
-
-def get_extrinsic_from_camray(
-    camray: torch.Tensor,  # (B, S, h, w, 6)
-    conf: torch.Tensor,  # (B, S, h, w, 1) or (B, S, h, w)
-    patch_size_y: int,
-    patch_size_x: int,
-) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-    """Wrap a 4x4 extrinsic + per-view focal + principal-point output."""
-    if conf.ndim == 5 and conf.shape[-1] == 1:
-        conf = conf.squeeze(-1)
-    R, T, focal, pp = _camray_to_caminfo(camray, confidence=conf)
-    extr = torch.cat([R, T.unsqueeze(-1)], dim=-1)           # (B, S, 3, 4)
-    homo_row = torch.tensor([0, 0, 0, 1], dtype=R.dtype, device=R.device)
-    homo_row = homo_row.view(1, 1, 1, 4).expand(R.shape[0], R.shape[1], 1, 4)
-    extr = torch.cat([extr, homo_row], dim=-2)               # (B, S, 4, 4)
-    return extr, focal, pp
@@ -1,87 +0,0 @@
-"""Reference-view selection for the multi-view path of Depth Anything 3."""
-
-from __future__ import annotations
-
-from typing import Literal
-
-import torch
-
-
-RefViewStrategy = Literal["first", "middle", "saddle_balanced", "saddle_sim_range"]
-
-
-# Per the upstream constants module: ``THRESH_FOR_REF_SELECTION = 3``.
-# Reference selection only runs when there are at least this many views.
-THRESH_FOR_REF_SELECTION: int = 3
-
-
-def select_reference_view(x: torch.Tensor, strategy: RefViewStrategy = "saddle_balanced") -> torch.Tensor:
-    """Pick a reference view index per batch element."""
-    B, S, _, _ = x.shape
-    if S <= 1:
-        return torch.zeros(B, dtype=torch.long, device=x.device)
-    if strategy == "first":
-        return torch.zeros(B, dtype=torch.long, device=x.device)
-    if strategy == "middle":
-        return torch.full((B,), S // 2, dtype=torch.long, device=x.device)
-
-    # Feature-based strategies: normalised cls/cam token per view.
-    img_class_feat = x[:, :, 0] / x[:, :, 0].norm(dim=-1, keepdim=True)  # (B,S,C)
-
-    if strategy == "saddle_balanced":
-        sim = torch.matmul(img_class_feat, img_class_feat.transpose(1, 2))  # (B,S,S)
-        sim_no_diag = sim - torch.eye(S, device=sim.device).unsqueeze(0)
-        sim_score = sim_no_diag.sum(dim=-1) / (S - 1)               # (B,S)
-        feat_norm = x[:, :, 0].norm(dim=-1)                          # (B,S)
-        feat_var = img_class_feat.var(dim=-1)                        # (B,S)
-
-        def _normalize(metric):
-            mn = metric.min(dim=1, keepdim=True).values
-            mx = metric.max(dim=1, keepdim=True).values
-            return (metric - mn) / (mx - mn + 1e-8)
-
-        sim_n, norm_n, var_n = _normalize(sim_score), _normalize(feat_norm), _normalize(feat_var)
-        balance = (sim_n - 0.5).abs() + (norm_n - 0.5).abs() + (var_n - 0.5).abs()
-        return balance.argmin(dim=1)
-
-    if strategy == "saddle_sim_range":
-        sim = torch.matmul(img_class_feat, img_class_feat.transpose(1, 2))
-        sim_no_diag = sim - torch.eye(S, device=sim.device).unsqueeze(0)
-        sim_max = sim_no_diag.max(dim=-1).values
-        sim_min = sim_no_diag.min(dim=-1).values
-        return (sim_max - sim_min).argmax(dim=1)
-
-    raise ValueError(
-        f"Unknown reference view selection strategy: {strategy!r}. "
-        f"Must be one of: 'first', 'middle', 'saddle_balanced', 'saddle_sim_range'"
-    )
-
-
-def reorder_by_reference(x: torch.Tensor, b_idx: torch.Tensor) -> torch.Tensor:
-    """Reorder x so the reference view is at position 0 in axis S."""
-    B, S = x.shape[0], x.shape[1]
-    if S <= 1:
-        return x
-    positions = torch.arange(S, device=x.device).unsqueeze(0).expand(B, -1)
-    b_idx_exp = b_idx.unsqueeze(1)
-    reorder = torch.where(
-        (positions > 0) & (positions <= b_idx_exp),
-        positions - 1,
-        positions,
-    )
-    reorder[:, 0] = b_idx
-    batch = torch.arange(B, device=x.device).unsqueeze(1)
-    return x[batch, reorder]
-
-
-def restore_original_order(x: torch.Tensor, b_idx: torch.Tensor) -> torch.Tensor:
-    """Inverse of reorder_by_reference."""
-    B, S = x.shape[0], x.shape[1]
-    if S <= 1:
-        return x
-    target_positions = torch.arange(S, device=x.device).unsqueeze(0).expand(B, -1)
-    b_idx_exp = b_idx.unsqueeze(1)
-    restore = torch.where(target_positions < b_idx_exp, target_positions + 1, target_positions)
-    restore = torch.scatter(restore, dim=1, index=b_idx_exp, src=torch.zeros_like(b_idx_exp))
-    batch = torch.arange(B, device=x.device).unsqueeze(1)
-    return x[batch, restore]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Matt MillerandGitHub	6b39e9a44a	Merge branch 'master' into cursor/mark-deprecated-cloud-endpoints-e81e Python Linting / Run Ruff (push) Has been cancelled Details Python Linting / Run Pylint (push) Has been cancelled Details	2026-05-12 09:11:38 -07:00
Matt MillerandGitHub	3beca6e30e	Merge branch 'master' into cursor/mark-deprecated-cloud-endpoints-e81e Python Linting / Run Ruff (push) Waiting to run Details Python Linting / Run Pylint (push) Waiting to run Details Build package / Build Test (3.10) (push) Has been cancelled Details Build package / Build Test (3.11) (push) Has been cancelled Details Build package / Build Test (3.12) (push) Has been cancelled Details Build package / Build Test (3.13) (push) Has been cancelled Details Build package / Build Test (3.14) (push) Has been cancelled Details	2026-05-11 11:45:42 -07:00
Matt MillerandGitHub	5a400d837e	Merge branch 'master' into cursor/mark-deprecated-cloud-endpoints-e81e Python Linting / Run Ruff (push) Has been cancelled Details Python Linting / Run Pylint (push) Has been cancelled Details	2026-05-08 19:48:32 -07:00
Matt Miller	81af8e4de2	fix(spec): consolidate duplicate path entries on deprecated cloud-runtime endpoints Previous commit added new path entries with `deprecated: true` for `/api/job/{job_id}/status`, `/api/history_v2`, `/api/history_v2/{prompt_id}`, `/api/logs`, and `/api/viewvideo`, but the canonical entries already existed elsewhere in the file. Result: 5 duplicate path keys (Spectral parser errors), and the deprecation flag did not land on the operations that FE clients consume by operationId. This commit moves `deprecated: true` plus the standardized "Deprecated." description onto the canonical operations (`getCloudJobStatus`, `getHistoryV2`, `getHistoryV2ByPromptId`, `getCloudLogs`, `viewVideo`) and removes the duplicate entries. Operation IDs and response schemas are unchanged. Spectral lint passes with zero new warnings.	2026-05-08 18:30:11 -07:00
Cursor Agent Matt Miller Matt Miller	fd17b95e1c	Mark deprecated cloud-runtime endpoints in openapi.yaml Python Linting / Run Ruff (push) Waiting to run Details Python Linting / Run Pylint (push) Waiting to run Details Add five cloud-runtime FE-facing endpoints to the OSS spec with deprecated: true and standardized description prefixes: - GET /api/history_v2 — superseded by GET /api/jobs - GET /api/history_v2/{prompt_id} — superseded by GET /api/jobs/{prompt_id} - GET /api/logs — returns static placeholder; no real log data - GET /api/viewvideo — alias of GET /api/view for legacy video playback - GET /api/job/{job_id}/status — superseded by GET /api/jobs/{job_id} Each endpoint is tagged x-runtime: [cloud] and follows the same deprecation convention established for /api/history endpoints. Co-authored-by: Matt Miller <MillerMedia@users.noreply.github.com>	2026-05-08 15:19:04 -07:00