Drop an unused import in the second-copy test

Manager installs the pack in custom_nodes/ausboss-nodes and a git clone
lands in custom_nodes/ComfyUI-AusBoss. With both folders present, both
copies registered GET /ausboss/pack_modules and ComfyUI stopped at
startup: "Added route will never be executed, method HEAD is already
registered".

The first copy to load claims a marker in sys.modules. A later copy
loads no node modules, registers no routes, serves no js folder, and
prints which folder it skipped.

.claude/skills/ausboss-node-brand/SKILL.md

@@ -1,123 +0,0 @@
----
-name: ausboss-node-brand
-description: Brand identity and design language for ComfyUI-AusBoss nodes — naming, visual language, settings conventions, frontend interaction etiquette, and the proof checklist. Load when building, porting, or restyling an AusBoss node or any pack-wide frontend feature.
----
-
-# AusBoss node brand and design language
-
-This skill layers the pack's *design language* on top of the hard rules in
-[AGENTS.md](../../../AGENTS.md) and the admission checklist in
-[docs/adding_a_node.md](../../../docs/adding_a_node.md). Read those for what is
-allowed; read this for what makes a node feel like an AusBoss node.
-
-## Identity
-
-- Mapping key `AUSBOSS_NODES_<Purpose>` — permanent API, never renamed, and
-  always written as a string literal in both mapping dicts so registry
-  scanners (which parse, not import) can discover it.
-- Display name `<Name> 🆎`; category `🆎 AusBoss/<Group>`. The category, the
-  `AUSBOSS_NODES_` id prefix, and the "ausboss" `SEARCH_ALIASES` entry keep
-  the pack searchable by name.
-- Every node ships `DESCRIPTION`, input `tooltip`s, `OUTPUT_TOOLTIPS`, and
-  `SEARCH_ALIASES` with intent words the display name lacks ("trim", "cut",
-  "outpaint", "watermark").
-- Namespace everything frontend-visible with `ausboss`: routes, extension
-  names, events, CSS classes, DOM markers, caches.
-
-**This identity is for the public pack only.** Experiments live in the private
-ComfyUI-AusBoss-Lab repo and wear a parallel grammar so the two never collide
-and a lab node is obvious on the canvas:
-
-| | public pack | lab |
-|---|---|---|
-| mapping key | `AUSBOSS_NODES_<Purpose>` | `AUSBOSS_LAB_<Purpose>` |
-| display name | `<Name> 🆎` | `<Name> 🧪` |
-| category | `🆎 AusBoss/<Group>` | `🧪 AusBoss Lab/<Group>` |
-
-Do not apply this skill's polish budget to a lab node. Lab nodes deliberately
-skip example workflows, thumbnails, frontend work and changelog entries —
-those are release-gate items, and adding them early is how a workshop turns
-into a second product. They also fall outside `js/appearance/`, which keys on
-the `AUSBOSS_NODES_` prefix, so they stay uncolored on purpose.
-
-## Visual language
-
-- Editor handle grammar (keep it consistent everywhere): **cyan squares** =
-  crop, **orange diamonds** = padding, **green knob** = rotate. Section
-  legends reuse the same markers so the colors teach themselves.
-- Node colors come from the scheme table in
-  [js/shared/appearance.mjs](../../../js/shared/appearance.mjs) — the single
-  source of truth. Adding a scheme means adding one table row; the tests in
-  `tests/appearance.test.mjs` validate it automatically. Title is always
-  darker than body in the muted rows; the flagship "AusBoss" row (the
-  pack-wide default) pairs the teal title with a near-black body. Values are
-  tuned against the dark canvas.
-- Coloring is automatic: `js/appearance/index.js` targets every class whose
-  `comfyClass` starts with `AUSBOSS_NODES_` (plus the `SimpleWatermarkRemover`
-  alias). New nodes need zero per-node color work.
-- Node faces stay compact. Big interactions get a fullscreen editor or an
-  inline mode — never a node with a huge fixed minimum size.
-
-## Settings conventions
-
-- Ids are `AusBoss.<Area>.<Name>`; register declaratively via the
-  `settings: [...]` array on `app.registerExtension`.
-- `category: ["🆎 AusBoss", "<Area>", "<Leaf>"]` with a **distinct leaf per
-  setting** — settings sharing a leaf collapse into one panel row.
-- Tooltips explain the *consequence* of the setting, in prose.
-- `onChange(value)` must use the passed value (on some frontends it fires
-  before the store write) and must guard against no-op changes. Seed the
-  current value in `setup()` — `onChange` does not fire for the stored value
-  on load on all versions.
-- Every non-obvious behavior gets an off switch; surprising behaviors default
-  to off.
-
-## Frontend patterns
-
-- Entries in `js/<feature>/index.js` auto-load; shared logic lives in
-  import-only `js/shared/*.mjs`. Pure decision logic and geometry go in the
-  `.mjs` modules with `node:test` coverage in `tests/*.test.mjs` — DOM wiring
-  stays thin in the entry file.
-- **Widgets are the single source of truth.** Rich UI drives hidden standard
-  widgets (`serialize: false` on DOM widgets); no custom serialization, so
-  save/load, undo, and API format work through LiteGraph's default path.
-- Chain lifecycle hooks with `chainCallback` from `js/shared/index.mjs`;
-  never assign prototype callbacks directly.
-- Build API URLs through the `api` module helpers — never write root-relative
-  strings like `/view?...`, which break behind proxies and hosted frontends.
-
-## Interaction etiquette
-
-- A click on empty panel space must fall through (no `preventDefault`) so the
-  node stays draggable from its body.
-- Wheel and middle-click belong to the graph (zoom/pan) unless the widget is
-  actively using them for its own view — capture them only in an explicit
-  edit mode.
-- Set LiteGraph node properties with `node.color = undefined`, never
-  `delete node.color` — deleting breaks reactivity under the Nodes 2.0
-  renderer.
-- Distinguish "workflow is loading" from "user changed the source" before
-  resetting state; restored values must never be wiped by a load-path
-  callback.
-- Drawn glyphs stay small; hit zones stay generous (larger than the glyph).
-  Corners are hit-tested before edges.
-
-## Backend patterns
-
-- Shared compute in `nodes/_<topic>_helpers.py`; node files are thin V1
-  wrappers. IMAGE is BHWC float, MASK is BHW, returns are always tuples.
-- Import-time console output stays ASCII (Windows cp1252 consoles); the 🆎
-  emoji is safe only in categories and display names.
-- Treat every route parameter and widget value as attacker-controlled: path
-  containment checks live in shared helpers, never re-rolled per call site.
-
-## Prove it
-
-```bash
-python scripts/validate_nodes.py
-node --test tests/*.test.mjs
-```
-
-Then the full checklist in [docs/adding_a_node.md](../../../docs/adding_a_node.md):
-restart ComfyUI, watch the banner, check `/object_info`, queue an API graph,
-load the example workflow, and hard-refresh the browser after JS changes.

.comfyignore

@@ -0,0 +1,40 @@
+# Files comfy-cli leaves OUT of the Registry archive (gitignore syntax; the
+# packer zips git-tracked files minus these, so untracked local files need
+# no entry). Runtime code, node help, example workflows, README, LICENSE and
+# pyproject stay in. Everything below is development-only or README media:
+# it adds nothing for a user.
+#
+# scripts/release_preflight.py lists the archive the same way and fails when
+# a path outside its runtime allowlist ships, when a runtime file is dropped
+# (js/docs/ is node help and must ship), or when the archive outgrows its
+# size budget.
+
+# tests and offline tooling
+tests/
+scripts/
+
+# CI and repository automation
+.github/
+
+# developer docs and tool settings (docs/ at the root only)
+AGENTS.md
+CLAUDE.md
+CONTRIBUTING.md
+SECURITY.md
+.claude/
+/docs/
+
+# README media: GitHub shows it on the repository page, nothing in the
+# pack loads it
+/assets/
+
+# the changelog: the Registry shows each version's notes, made from it when
+# the version is published (scripts/changelog_notes.py), and the full list
+# stays in the repository; nothing in the pack reads it
+CHANGELOG.md
+
+# repository files
+.gitignore
+.comfyignore
+.gitattributes
+.editorconfig

.editorconfig

@@ -0,0 +1,19 @@
+# Matches what the repository holds: UTF-8, LF, a final newline, spaces.
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+trim_trailing_whitespace = true
+
+[*.py]
+indent_size = 4
+
+[*.{js,mjs,json,yml,yaml,md}]
+indent_size = 2
+
+# Two trailing spaces are a Markdown line break.
+[*.md]
+trim_trailing_whitespace = false

.gitattributes

@@ -0,0 +1,2 @@
+# Text files are stored and checked out with LF line endings on every OS.
+* text=auto eol=lf

.github/FUNDING.yml

@@ -0,0 +1 @@
+ko_fi: ausboss

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,64 @@
+name: Bug report
+description: A node errors, gives a wrong result, or looks broken.
+labels: [bug]
+body:
+  - type: markdown
+    attributes:
+      value: >-
+        Security problems go through the
+        [security policy](https://github.com/ausboss/ComfyUI-AusBoss/security/policy),
+        not a public issue.
+  - type: input
+    id: comfyui-version
+    attributes:
+      label: ComfyUI and frontend versions
+      description: Both are under Settings → About.
+      placeholder: ComfyUI v0.x.y, frontend v1.x.y
+    validations:
+      required: true
+  - type: input
+    id: pack-version
+    attributes:
+      label: AusBoss version
+      description: The console banner prints it when ComfyUI starts, as "AusBoss vX.Y.Z".
+      placeholder: AusBoss v2.1.0
+    validations:
+      required: true
+  - type: dropdown
+    id: install-method
+    attributes:
+      label: Installed with
+      options:
+        - ComfyUI-Manager or the Comfy Registry
+        - git clone
+  - type: input
+    id: nodes
+    attributes:
+      label: Node(s)
+      placeholder: Save Image 🆎
+    validations:
+      required: true
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to reproduce
+      placeholder: |
+        1. Load the attached workflow
+        2. Set ...
+        3. Queue it
+  - type: textarea
+    id: expected
+    attributes:
+      label: What you expected
+  - type: textarea
+    id: actual
+    attributes:
+      label: What happened instead
+      description: Include any error from the ComfyUI console or the browser console.
+    validations:
+      required: true
+  - type: textarea
+    id: attachments
+    attributes:
+      label: Workflow or screenshot
+      description: Drag the smallest workflow .json that shows the problem, or a screenshot, into this box.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Security problem
+    url: https://github.com/ausboss/ComfyUI-AusBoss/security/policy
+    about: Report it privately instead of in a public issue.

.github/ISSUE_TEMPLATE/idea.yml

@@ -0,0 +1,28 @@
+name: Workflow idea
+description: A workflow problem the pack could solve.
+labels: [enhancement]
+body:
+  - type: markdown
+    attributes:
+      value: >-
+        The pack admits nodes deliberately: each one solves a problem that
+        comes up again and again, in a compact node
+        ([how a node gets added](https://github.com/ausboss/ComfyUI-AusBoss/blob/main/docs/adding_a_node.md)).
+        Start with the problem; the node can come later.
+  - type: textarea
+    id: problem
+    attributes:
+      label: The problem
+      description: What do you keep doing by hand, or with a pile of nodes?
+    validations:
+      required: true
+  - type: textarea
+    id: today
+    attributes:
+      label: How you handle it today
+      description: The nodes or steps you use now. A workflow .json or a screenshot helps.
+  - type: textarea
+    id: idea
+    attributes:
+      label: What would help
+      description: Optional. A new node, or a change to an existing one.

.github/pull_request_template.md

@@ -0,0 +1,7 @@
+<!-- What does this change, and why? -->
+
+
+- [ ] Offline checks run (the commands in CONTRIBUTING.md)
+- [ ] No version bump: a `pyproject.toml` version change on `main` publishes a release
+- [ ] No node inputs or outputs renamed or reordered: saved workflows depend on them
+- [ ] Screenshots attached for UI changes

.github/workflows/comfyui_compat.yml

@@ -0,0 +1,160 @@
+name: ComfyUI updates
+
+# Every night the pack is run against the newest ComfyUI: its newest release
+# and its development head. Nothing here needs a GPU or a model file.
+#
+# What runs, on a clean machine with ComfyUI installed for the CPU:
+#   1. tests/test_comfy_core_contract.py: everything the pack takes from
+#      ComfyUI is still there (modules, functions, ComfyUI's own nodes the
+#      pack calls and the inputs it passes them).
+#   2. All Python tests, with this ComfyUI on the path.
+#   3. ComfyUI is started with the pack in it. scripts/compat_boot.py asks it
+#      which nodes it offers: every public node of the pack, and every node
+#      and required input the example workflows use.
+#   4. scripts/dev/face_smoke.mjs puts every node on a graph in headless
+#      Chrome, in the classic node view and in Nodes 2.0: its face comes up
+#      and nothing throws.
+#
+# A failure on the release opens an issue (or adds to the open one) and fails
+# the run. The development head breaks and mends itself often, so that job
+# never fails the run, and it only opens an issue after two nights in a row.
+#
+# It also runs on a pull request that changes one of these checks.
+on:
+  schedule:
+    - cron: "17 9 * * *"
+  workflow_dispatch:
+  pull_request:
+    branches: [main]
+    paths:
+      - ".github/workflows/comfyui_compat.yml"
+      - "tests/test_comfy_core_contract.py"
+      - "scripts/compat_boot.py"
+      - "scripts/dev/face_smoke.mjs"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: comfyui-updates-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  compat:
+    name: ComfyUI ${{ matrix.comfyui }}
+    if: ${{ github.repository == 'ausboss/ComfyUI-AusBoss' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 45
+    continue-on-error: ${{ matrix.comfyui == 'master' }}
+    permissions:
+      contents: read
+      issues: write
+      actions: read
+    strategy:
+      fail-fast: false
+      matrix:
+        comfyui: [release, master]
+    env:
+      PIP_DISABLE_PIP_VERSION_CHECK: "1"
+    steps:
+      - name: Check out the pack
+        uses: actions/checkout@v7
+        with:
+          path: ComfyUI-AusBoss
+          persist-credentials: false
+      - name: Which ComfyUI
+        id: which
+        env:
+          GH_TOKEN: ${{ github.token }}
+          WANTED: ${{ matrix.comfyui }}
+        run: |
+          if [ "$WANTED" = "release" ]; then
+            ref=$(gh api repos/Comfy-Org/ComfyUI/releases/latest --jq .tag_name)
+          else
+            ref=master
+          fi
+          test -n "$ref"
+          echo "ref=$ref" >> "$GITHUB_OUTPUT"
+          echo "ComfyUI at $ref"
+      - name: Check out ComfyUI
+        uses: actions/checkout@v7
+        with:
+          repository: Comfy-Org/ComfyUI
+          ref: ${{ steps.which.outputs.ref }}
+          path: ComfyUI
+          persist-credentials: false
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: ComfyUI/requirements.txt
+      - uses: actions/setup-node@v7
+        with:
+          node-version: "24"
+      - name: Install ComfyUI for the CPU
+        run: |
+          python -m pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu
+          python -m pip install -r ComfyUI/requirements.txt
+          git -C ComfyUI log -1 --format='ComfyUI %h %cd %s' --date=short
+          python -m pip list 2>/dev/null | grep -i -E "^(comfyui|torch) " || true
+          # Which CPU ran it: float results can differ by a last bit between CPUs.
+          lscpu | grep -E "^Model name" || true
+      - name: Everything the pack takes from ComfyUI is there
+        working-directory: ComfyUI-AusBoss
+        run: AUSBOSS_COMFY_ROOT="$GITHUB_WORKSPACE/ComfyUI" python tests/test_comfy_core_contract.py
+      - name: Python tests on this ComfyUI
+        working-directory: ComfyUI-AusBoss
+        run: AUSBOSS_COMFY_ROOT="$GITHUB_WORKSPACE/ComfyUI" python scripts/run_python_tests.py
+      - name: Start ComfyUI with the pack in it
+        run: |
+          ln -s "$GITHUB_WORKSPACE/ComfyUI-AusBoss" ComfyUI/custom_nodes/ComfyUI-AusBoss
+          cd ComfyUI
+          nohup python main.py --cpu --port 8188 --disable-auto-launch > "$GITHUB_WORKSPACE/comfyui.log" 2>&1 &
+          for i in $(seq 1 90); do
+            if curl -s -m 2 http://127.0.0.1:8188/system_stats > /dev/null; then echo "up after $((i * 2)) s"; exit 0; fi
+            sleep 2
+          done
+          echo "ComfyUI did not come up"; tail -60 "$GITHUB_WORKSPACE/comfyui.log"; exit 1
+      - name: Every node is offered and every example still fits
+        run: python ComfyUI-AusBoss/scripts/compat_boot.py --url http://127.0.0.1:8188 --log comfyui.log
+      - name: Every node's face comes up, classic and Nodes 2.0
+        run: |
+          google-chrome --headless=new --remote-debugging-port=9333 --no-sandbox --disable-gpu --disable-dev-shm-usage \
+            --user-data-dir="$RUNNER_TEMP/chrome" about:blank > "$GITHUB_WORKSPACE/chrome.log" 2>&1 &
+          for i in $(seq 1 30); do curl -s -m 2 http://127.0.0.1:9333/json/version > /dev/null && break; sleep 1; done
+          status=0
+          node ComfyUI-AusBoss/scripts/dev/face_smoke.mjs 9333 || status=1
+          node ComfyUI-AusBoss/scripts/dev/face_smoke.mjs 9333 --vue || status=1
+          exit "$status"
+      - name: ComfyUI's log
+        if: ${{ always() }}
+        run: tail -80 comfyui.log || true
+      # Only a nightly run tells anyone: a pull request shows its own result.
+      - name: Open or add to an issue
+        if: ${{ failure() && github.event_name == 'schedule' }}
+        env:
+          GH_TOKEN: ${{ github.token }}
+          WANTED: ${{ matrix.comfyui }}
+          REF: ${{ steps.which.outputs.ref }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        run: |
+          cd ComfyUI-AusBoss
+          if [ "$WANTED" = "master" ]; then
+            # The development head: only when last night's run failed on it too.
+            before=$(gh run list --workflow comfyui_compat.yml --event schedule --limit 2 --json databaseId --jq '.[1].databaseId // empty')
+            last=""
+            if [ -n "$before" ]; then
+              last=$(gh api "repos/$GITHUB_REPOSITORY/actions/runs/$before/jobs" --jq '.jobs[] | select(.name == "ComfyUI master") | .steps[] | select(.conclusion == "failure") | .name' | head -1)
+            fi
+            if [ -z "$last" ]; then echo "First night it fails on the development head: no issue yet."; exit 0; fi
+          fi
+          title="ComfyUI $WANTED: the pack's nightly check fails"
+          commit=$(git -C ../ComfyUI log -1 --format='%h (%cd) %s' --date=short)
+          body=$(printf 'The nightly check of the pack against ComfyUI `%s` failed.\n\n- ComfyUI: %s\n- Run: %s\n\nThe failed step in that run names what broke: a module or function ComfyUI no longer has, a node or input an example uses, or a node whose face did not come up.' "$REF" "$commit" "$RUN_URL")
+          gh label create comfyui-update --description "A ComfyUI update broke something" --color 14424D 2>/dev/null || true
+          open=$(gh issue list --state open --label comfyui-update --search "in:title \"$title\"" --json number --jq '.[0].number // empty')
+          if [ -n "$open" ]; then
+            gh issue comment "$open" --body "$body"
+          else
+            gh issue create --title "$title" --label comfyui-update --body "$body"
+          fi

.github/workflows/publish_action.yml

@@ -0,0 +1,119 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+    paths:
+      - "pyproject.toml"
+
+# Publishes the pack to registry.comfy.org when a push to main changes the
+# version in pyproject.toml, or on a manual run from main. Editing another
+# pyproject field (description, keywords) without a new version publishes
+# nothing, and the offline checks must pass before anything is uploaded.
+# A successful upload also creates the version's tag and GitHub Release.
+# Requires the repository secret REGISTRY_ACCESS_TOKEN, an API key created
+# for the "ausboss" publisher at registry.comfy.org.
+permissions:
+  contents: read
+
+concurrency:
+  group: registry-publish
+  cancel-in-progress: false
+
+jobs:
+  check:
+    name: Check version and validate
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    if: ${{ github.repository == 'ausboss/ComfyUI-AusBoss' && github.ref == 'refs/heads/main' }}
+    outputs:
+      publish: ${{ steps.version.outputs.publish }}
+      version: ${{ steps.version.outputs.version }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - name: Did the version change?
+        id: version
+        env:
+          BEFORE: ${{ github.event.before }}
+          EVENT: ${{ github.event_name }}
+        run: |
+          read_version='import sys, tomllib; print(tomllib.loads(sys.stdin.read())["project"]["version"])'
+          current=$(python -c "$read_version" < pyproject.toml)
+          echo "version=$current" >> "$GITHUB_OUTPUT"
+          previous=""
+          if [ -n "$BEFORE" ] && git cat-file -e "$BEFORE^{commit}" 2>/dev/null; then
+            previous=$(git show "$BEFORE:pyproject.toml" | python -c "$read_version")
+          fi
+          if [ "$EVENT" = "workflow_dispatch" ] || [ "$current" != "$previous" ]; then
+            echo "publish=true" >> "$GITHUB_OUTPUT"
+            echo "Publishing $current (was ${previous:-unknown})."
+          else
+            echo "publish=false" >> "$GITHUB_OUTPUT"
+            echo "pyproject.toml changed but the version stayed $current; nothing to publish."
+          fi
+      - uses: actions/setup-node@v7
+        if: steps.version.outputs.publish == 'true'
+        with:
+          node-version: "24"
+      - name: Offline checks
+        if: steps.version.outputs.publish == 'true'
+        run: |
+          python scripts/validate_nodes.py
+          python scripts/release_preflight.py
+          node --test --test-isolation=none tests/*.test.mjs
+
+  publish-node:
+    name: Publish Custom Node to registry
+    needs: check
+    if: ${{ needs.check.outputs.publish == 'true' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v7
+      # The Registry shows a version's notes under "More". comfy-cli takes
+      # them from COMFY_NODE_CHANGELOG, so this version's CHANGELOG entries
+      # are put there, one short line each, before the publish step runs.
+      - name: Notes for this version
+        run: python3 scripts/changelog_notes.py --github-env
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@main
+        with:
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}
+
+  github-release:
+    name: Create GitHub Release
+    needs: [check, publish-node]
+    if: ${{ needs.check.outputs.publish == 'true' }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - name: Publish release notes and tag
+        env:
+          GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
+          VERSION: ${{ needs.check.outputs.version }}
+        run: |
+          tag="v$VERSION"
+          if gh release view "$tag" >/dev/null 2>&1; then
+            echo "Release $tag already exists; leaving it unchanged."
+            exit 0
+          fi
+          python scripts/changelog_notes.py --version "$VERSION" --full > "$RUNNER_TEMP/release-notes.md"
+          gh release create "$tag" --target "$GITHUB_SHA" --title "$VERSION" \
+            --notes-file "$RUNNER_TEMP/release-notes.md" --latest

.github/workflows/publish_model_downloader.yml

@@ -0,0 +1,82 @@
+name: Publish Model Downloader addon
+
+on:
+  workflow_dispatch:
+    inputs:
+      addon_commit:
+        description: Full commit SHA from ComfyUI-AusBoss-Model-Downloader main
+        required: true
+        type: string
+      changelog:
+        description: Release note for this version, shown in the Registry's Updates section
+        required: true
+        type: string
+
+# The existing AusBoss publisher credential stays in this repository. This
+# manual job publishes only the separately maintained Model Downloader addon.
+# It does not release or change the main AusBoss node pack.
+permissions:
+  contents: read
+
+concurrency:
+  group: registry-publish-model-downloader
+  cancel-in-progress: false
+
+jobs:
+  publish:
+    if: github.repository == 'ausboss/ComfyUI-AusBoss' && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - name: Require an exact addon commit
+        env:
+          ADDON_COMMIT: ${{ inputs.addon_commit }}
+        run: '[[ "$ADDON_COMMIT" =~ ^[0-9a-f]{40}$ ]]'
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+        with:
+          repository: ausboss/ComfyUI-AusBoss-Model-Downloader
+          ref: ${{ inputs.addon_commit }}
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Require a commit merged into addon main
+        run: git merge-base --is-ancestor HEAD origin/main
+      - uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7
+        with:
+          python-version: '3.12'
+      - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7
+        with:
+          node-version: '24'
+          package-manager-cache: false
+      - name: Install validation and publishing tools
+        run: python -m pip install -r requirements-dev.txt comfy-cli==1.25.0
+      - name: Offline checks
+        run: |
+          python -m unittest discover -s tests -v
+          ruff check --select F,E9 __init__.py downloader tests scripts
+          node --test tests/*.test.mjs
+          node --check js/model_downloader/index.js
+          node --check js/shared/download_controls.mjs
+      - name: Build and inspect Registry package
+        run: |
+          comfy --skip-prompt --no-enable-telemetry node pack
+          python scripts/check_registry_package.py
+      - name: Refuse an existing immutable version
+        run: python scripts/registry_status.py --require-unpublished
+      - name: Publish addon
+        id: publish
+        env:
+          REGISTRY_ACCESS_TOKEN: ${{ secrets.REGISTRY_ACCESS_TOKEN }}
+          COMFY_NODE_CHANGELOG: ${{ inputs.changelog }}
+        run: |
+          if [ -z "$REGISTRY_ACCESS_TOKEN" ]; then
+            echo '::error::REGISTRY_ACCESS_TOKEN is not configured.'
+            exit 1
+          fi
+          if [ -z "${COMFY_NODE_CHANGELOG// /}" ]; then
+            echo '::error::The changelog input is empty; the Registry shows it as the release note.'
+            exit 1
+          fi
+          comfy --skip-prompt --no-enable-telemetry node publish --token "$REGISTRY_ACCESS_TOKEN"
+      - name: Report Registry review status
+        if: always() && steps.publish.outcome != 'skipped'
+        run: python scripts/registry_status.py --report

.github/workflows/registry_status.yml

@@ -0,0 +1,41 @@
+name: Check Registry approval
+
+on:
+  workflow_run:
+    workflows: ["Publish to Comfy registry"]
+    types: [completed]
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version to check; blank uses pyproject.toml"
+        required: false
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  registry-status:
+    if: github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-latest
+    timeout-minutes: 3
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ github.event.workflow_run.head_sha || github.sha }}
+          persist-credentials: false
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      # Review happens after upload. Pending/Flagged are a successful status
+      # report, not approval; a ban, missing version or broken lookup still fails.
+      - name: Report exact published version's approval state
+        id: registry
+        env:
+          AUSBOSS_TARGET_VERSION: ${{ inputs.version }}
+        run: |
+          if [ -n "$AUSBOSS_TARGET_VERSION" ]; then
+            python scripts/registry_status.py --report --version "$AUSBOSS_TARGET_VERSION"
+          else
+            python scripts/registry_status.py --report
+          fi

.github/workflows/validate_action.yml

@@ -0,0 +1,64 @@
+name: Validate release candidate
+
+on:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  offline-checks:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - uses: actions/setup-node@v7
+        with:
+          node-version: "24"
+      - run: python scripts/validate_nodes.py
+      - run: python scripts/release_preflight.py
+      # The test files that need only the standard library. The rest import
+      # torch, NumPy or PyAV and run in ComfyUI's own Python environment.
+      - name: Standard-library Python tests
+        run: >-
+          python scripts/run_python_tests.py
+          tests/test_changelog_notes.py
+          tests/test_execution_helpers.py
+          tests/test_layout_boxes_helpers.py
+          tests/test_lora_helpers.py
+          tests/test_math_helpers.py
+          tests/test_media_paths.py
+          tests/test_memory_helpers.py
+          tests/test_node_api.py
+          tests/test_registry_contract.py
+          tests/test_registry_status.py
+          tests/test_resolution.py
+          tests/test_status_helpers.py
+          tests/test_utility_nodes.py
+          tests/test_validate_inputs.py
+          tests/test_workflow_contract.py
+          tests/test_comfy_core_contract.py
+      # `node --check file.js` passes a broken file that uses import or
+      # export when no package.json marks it as a module, so each file goes
+      # in on stdin with the module type stated.
+      - name: JavaScript syntax
+        run: |
+          status=0
+          while IFS= read -r -d '' file; do
+            node --input-type=module --check < "$file" || { echo "::error file=$file::syntax error"; status=1; }
+          done < <(git ls-files -z -- 'js/*.js' '*.mjs')
+          exit "$status"
+      - run: node --test --test-isolation=none tests/*.test.mjs
+      - name: Ruff (pyflakes and syntax errors)
+        run: |
+          python -m pip install ruff==0.16.3
+          ruff check --select F,E9 .

.gitignore

@@ -11,7 +11,7 @@ venv/
 .DS_Store
 Thumbs.db
 
-# Local scratch — untracked experiments and node ports in progress
+# Local scratch files
 _scratch/
 *.log
 
@@ -21,7 +21,14 @@ uv.lock
 # User aspect-ratio presets - personal copy of ausboss_presets_example.json
 ausboss_presets.json
 
-# Local working notes
-ausboss_test_checklist.md
-ausboss_idea_backlog.md
-.claude/skills/comfyui-node-api/SKILL.md
+# Local notes at the repository root
+/ausboss_*.md
+
+# Local tool settings
+/.agents/
+
+# Local tool output: the archive `comfy node pack` writes, and per-machine
+# worktrees and settings
+node.zip
+.claude/worktrees/
+.claude/settings.local.json

AGENTS.md

@@ -1,134 +1,12 @@
-# ComfyUI-AusBoss — Agent Working Rules
+# ComfyUI-AusBoss: start here
 
-Instructions for any coding agent working in this repo. `CLAUDE.md` imports
-this file, so keep everything here and leave that one as a pointer.
+A pack of ComfyUI custom nodes by ausboss. Two kinds of agents read this.
 
-A suite of polished ComfyUI custom nodes by ausboss. Public nodes must solve a
-repeated workflow need, keep a compact graph footprint, and pass backend plus
-browser acceptance before release.
-
-## This repo is the showroom, not the workshop
-
-Experiments live in the private **ComfyUI-AusBoss-Lab** repo, not here. Default
-a new node to the lab and promote it later; adding it here is the deliberate
-act of publishing it, and after a release its mapping key can never change.
-
-A node belongs in the lab, not this repo, when any of these is true:
-
-- it depends on a third-party pack or model most people will not have
-- it encodes constants owned by someone else — a model card, an upstream
-  default — that go stale when they change them, leaving this pack shipping
-  wrong advice under ausboss's name
-- it solved a need once rather than a repeated workflow need
-- its inputs are still moving
-
-The lab mirrors this repo's layout, so a promotion is a port, not a rewrite.
-Its namespaces are held apart (`AUSBOSS_LAB_` ids, `🧪 AusBoss Lab/`
-categories, `🧪` display suffix) so both packs install at once. The port steps
-and the release gate are in the lab's `docs/promoting.md`.
-
-`scripts/validate_nodes.py` enforces the boundary from this side: a mapping key
-that is registered but absent from `PUBLIC_NODE_IDS` fails the build, so an
-experiment cannot ride along into a release unnoticed.
-
-## Hard rules
-
-- Never modify `LICENSE`.
-- Never bump `version` in `pyproject.toml` unless explicitly asked.
-- Never add agent attribution to commits or PRs — no `Co-Authored-By`
-  trailers, no "generated with" footers. Commits are authored by ausboss alone.
-- Do not read or analyze `__pycache__`, `.git`, or editor config directories.
-- Ask before whole-repo sweeps or large refactors; propose a short plan first.
-- Keep diffs minimal: touch only the lines the task needs.
-- Be concise; skip pleasantries.
-
-## Third-party independence
-
-- Never copy third-party code, assets, fonts, icons, CSS, or documentation.
-- Review ecosystem overlap before accepting a public node. Generic overlap is
-  fine, but implementation, naming, interaction design, and documentation must
-  be this repository's own work.
-
-## Architecture
-
-```text
-__init__.py       # NODE_MODULES list → importlib merge of all mappings.
-                  # Fail-soft: a broken module logs and is skipped, the rest load.
-nodes/
-  node_<name>.py  # exactly one node (or one tight family) per file;
-                  # exports NODE_CLASS_MAPPINGS + NODE_DISPLAY_NAME_MAPPINGS
-  _<topic>_helpers.py  # shared backend logic, underscore prefix = not a node
-js/
-  <name>/index.js # frontend entry per node or pack-wide feature, e.g.
-                  # appearance/ (.js files auto-load)
-  shared/*.mjs    # import-only shared modules (.mjs files do NOT auto-load)
-docs/             # developer docs
-scripts/          # offline checks, stdlib only. validate_nodes.py is the
-                  # entry point; registry_contract.py holds the rules that
-                  # keep nodes visible to registry scanners.
-example_workflows/  # example workflows (regular workflow JSON, not API JSON)
-```
-
-## Conventions
-
-- Public mapping keys use `AUSBOSS_NODES_<Purpose>`. The mapping key is the
-  workflow-compatibility contract and must never be renamed after release.
-- Write those keys as **string literals** inside `NODE_CLASS_MAPPINGS` and
-  `NODE_DISPLAY_NAME_MAPPINGS` — never a `NODE_ID` variable. Registry scanners
-  (ComfyUI-Manager) AST-parse the source without importing it, so a variable
-  key makes every node invisible and "install missing custom nodes" stops
-  offering the pack. `scripts/validate_nodes.py` enforces this.
-- Assign each mapping **once**, at module level, to a non-empty dict literal,
-  and never mention the name again — no `update()`, no `del`, no
-  `alias = NODE_CLASS_MAPPINGS`. A scanner reads that one literal and stops,
-  so anything done to the mapping afterwards is invisible to it. Both
-  mappings must carry exactly the same keys.
-- Display name: `<Name> 🆎` — the emoji is the pack signature. Typing
-  "ausboss" still surfaces every node through the `🆎 AusBoss/<Group>`
-  category, the `AUSBOSS_NODES_` id prefix, and the "ausboss" entry every
-  node keeps in `SEARCH_ALIASES`.
-- Category: `🆎 AusBoss/<Group>`. The emoji is safe here — categories reach
-  the frontend as JSON and are never printed to the console at import time.
-- Every node gets `DESCRIPTION`, input `tooltip`s, and `OUTPUT_TOOLTIPS`.
-- IMAGE tensors are BHWC float batches; MASK is BHW. Return tuples always,
-  even for one output: `(value,)`.
-- Console output at import time must stay ASCII — ComfyUI on Windows often
-  runs a cp1252 console, and a UnicodeEncodeError there kills the whole pack.
-- No new pip dependencies without an explicit decision; if truly optional,
-  use `[project.optional-dependencies]` and fail soft at runtime.
-- Frontend JS never assigns prototype callbacks directly — use
-  `chainCallback` from `js/shared/index.mjs`.
-- Frontend settings use `AusBoss.<Area>.<Name>` ids with
-  `category: ["🆎 AusBoss", "<Area>", "<Leaf>"]` and a distinct leaf per
-  setting. Node color schemes live in `js/shared/appearance.mjs`.
-
-## Adding a node
-
-Follow `docs/adding_a_node.md`. Short version: create `nodes/node_<name>.py`
-from the template, add `"node_<name>"` to `NODE_MODULES` in `__init__.py`,
-optionally add `js/<name>/index.js`, then validate. Brand and design-language
-guidance (visual grammar, settings conventions, interaction etiquette) lives
-in `.claude/skills/ausboss-node-brand/SKILL.md`.
-
-## Validation
-
-```bash
-python scripts/validate_nodes.py
-```
-
-Then restart ComfyUI fully, watch the AusBoss banner for failed modules,
-confirm the node appears in `GET http://127.0.0.1:8188/object_info`, queue a
-tiny API graph, and load its example workflow. After JS changes, hard-refresh
-the browser tab (Ctrl+Shift+R).
-
-## Phase 2: porting an existing node
-
-1. Drop the old file in `_scratch/` (gitignored) and read it fully first.
-2. Rebuild the core compute in a clean `nodes/node_<name>.py` from the
-   template — port logic deliberately, don't paste wholesale.
-3. Shared logic goes to `nodes/_<topic>_helpers.py`, not duplicated.
-4. Frontend goes to `js/<name>/index.js`; reusable bits to `js/shared/`.
-5. Keep the old class-name string as the mapping key only if existing saved
-   workflows must keep loading; otherwise use the `AUSBOSS_NODES_<Purpose>`
-   convention.
-6. Run the validation steps above before calling it done.
+- **Using the nodes in a workflow?** Read
+  [js/docs/agents/README.md](js/docs/agents/README.md): which node does which
+  job, where each node's help page is, and the example workflows. That folder
+  ships with the pack, so it is also in a ComfyUI install.
+- **Changing the pack itself?** Read [CONTRIBUTING.md](CONTRIBUTING.md) in full
+  before the first edit. It holds the layout, the rules every node follows and
+  the checks to run. A new node follows
+  [docs/adding_a_node.md](docs/adding_a_node.md).

CLAUDE.md

@@ -1,9 +1,2 @@
-# CLAUDE.md
-
-Working rules for this repo live in [AGENTS.md](AGENTS.md) — the tool-neutral
-file every coding agent reads. Keep edits there, not here.
-
-The line below is a Claude Code import: it pulls AGENTS.md into context
-automatically, so nothing has to be duplicated between the two files.
-
 @AGENTS.md
+@CONTRIBUTING.md

CONTRIBUTING.md

@@ -0,0 +1,393 @@
+# Contributing
+
+Bug reports, workflow ideas and pull requests are welcome.
+
+## Reporting a problem
+
+The most useful report names:
+
+- the ComfyUI and frontend versions (Settings → About),
+- the pack version from the console banner (`AusBoss vX.Y.Z | N nodes loaded`),
+- the node, what you expected, and what happened instead,
+- the smallest workflow that shows it, plus a screenshot for anything visual.
+
+Security problems go through [SECURITY.md](SECURITY.md) instead of a public
+issue.
+
+## Pull requests
+
+- Read the contributor guide below first, and a new public node
+  follows [docs/adding_a_node.md](docs/adding_a_node.md). A new node is a
+  conversation before it is a pull request.
+- Mapping keys, input names and order, and output order are a permanent API:
+  saved workflows depend on them. Append optional inputs and outputs instead
+  of renaming or reordering. `tests/test_node_api.py` checks this against a
+  snapshot; its docstring shows how to refresh the snapshot after a
+  compatible change.
+- Leave `version` in `pyproject.toml` alone. A version change that reaches
+  `main` publishes to the Comfy Registry.
+- Run the offline checks. None of them needs a GPU; the Python tests need
+  ComfyUI's Python environment.
+
+  ```bash
+  python scripts/validate_nodes.py
+  python scripts/release_preflight.py
+  python scripts/run_python_tests.py
+  node --test tests/*.test.mjs
+  ```
+
+- Frontend changes are checked on a real canvas as well as in tests.
+  [docs/live_testing.md](docs/live_testing.md) describes the headless browser
+  harness and what to screenshot.
+- A fix PR says what was wrong, adds a test that fails before the fix and
+  passes after it, and shows before/after results.
+
+## Contributor guide
+
+How the repo is laid out, the conventions every node follows, and the checks
+to run. A suite of polished ComfyUI custom nodes by ausboss. Public nodes must
+solve a repeated workflow need, keep a compact graph footprint, and pass
+backend plus browser acceptance before release.
+
+### READ FIRST: write for the people who use the nodes
+
+Everything a user reads starts with the plainest version. That covers node
+descriptions, tooltips, the `?` help pages (`js/docs/*.md`), the README,
+example workflow notes, report and error text, and the CHANGELOG. Get more
+technical later in the text, or in its own section.
+
+- Open with what it does and when to use it, in everyday words and short
+  sentences. Someone new to ComfyUI should get it on the first read.
+- A tooltip is one or two short sentences: what this is, and what to pick.
+- Measurements, test results, edge cases and how it works go further down,
+  under a heading such as "Technical details".
+- Keep jargon out of the opening (resample, warp, frame, affine,
+  estimator, canvas space). If a term is needed, say what it means the
+  first time.
+- Put a number up top only when it helps someone decide what to do.
+
+If a sentence needs a second read, rewrite it.
+
+### Which nodes ship
+
+A node ships only when its mapping key is listed in `PUBLIC_NODE_IDS` in
+`scripts/validate_nodes.py`; the validator fails on any registered key that
+is not listed there.
+
+### Hard rules
+
+- Never modify `LICENSE`.
+- Never bump `version` in `pyproject.toml` — a version bump that lands on
+  main **publishes to the Comfy Registry automatically** (see Releasing).
+- Keep diffs minimal: touch only the lines the task needs.
+
+### Third-party independence
+
+- Never copy third-party code, assets, fonts, icons, CSS, or documentation.
+- Review ecosystem overlap before accepting a public node. Generic overlap is
+  fine, but implementation, naming, interaction design, and documentation must
+  be this repository's own work.
+
+### Architecture
+
+```text
+__init__.py       # NODE_MODULES list → importlib merge of all mappings.
+                  # Fail-soft: a broken module logs and is skipped, the rest load.
+nodes/
+  node_<name>.py  # exactly one node (or one tight family) per file;
+                  # exports NODE_CLASS_MAPPINGS + NODE_DISPLAY_NAME_MAPPINGS
+  _<topic>_helpers.py  # shared backend logic, underscore prefix = not a node
+js/
+  <name>/index.js # frontend entry per node or pack-wide feature, e.g.
+                  # appearance/ (.js files auto-load)
+  shared/*.mjs    # import-only shared modules (.mjs files do NOT auto-load)
+docs/             # developer docs
+scripts/          # offline checks in stdlib Python. validate_nodes.py is
+                  # the entry point; registry_contract.py holds the rules
+                  # that keep nodes visible to registry scanners;
+                  # registry_status.py reads the Registry API; dev/ is the
+                  # Node.js canvas harness (docs/live_testing.md).
+example_workflows/  # example workflows (regular workflow JSON, not API JSON)
+```
+
+### Conventions
+
+- Public mapping keys use `AUSBOSS_NODES_<Purpose>`. The mapping key is the
+  workflow-compatibility contract and must never be renamed after release.
+- Inputs and outputs only grow after a release: append an input as
+  optional, append an output, and never rename, reorder, remove or newly
+  require one. Saved workflows keep widget values by position and links by
+  slot, and an API prompt must carry every required input.
+  `tests/test_node_api.py` holds the pack to `tests/fixtures/node_api.json`;
+  refresh that snapshot with the test's `--update` after a compatible change
+  or a new node.
+- Appending an input to a node with a card or panel takes one more step.
+  Workflows saved by earlier releases end that node's values with an empty
+  value for each card and panel, and values come back by position, so the
+  new input opens holding that empty value. Give a widget input a
+  `resetUnknown` fallback in its card (`js/widget_cards/index.js`), or a
+  `RESET_UNKNOWN` beside `NODE_CLASS` in the node's own `js/<name>/index.js`
+  if it has no card (as LoRA Loader does). The fallback equals the node's
+  default, which is what an API prompt without the input runs with. Then
+  list the input in `tests/saved_widget_values.test.mjs`. Cards and
+  panels themselves are never saved: set `widget.serialize = false` right
+  after `addDOMWidget` (`options.serialize` only keeps a widget out of the
+  prompt).
+- Write those keys as **string literals** inside `NODE_CLASS_MAPPINGS` and
+  `NODE_DISPLAY_NAME_MAPPINGS` — never a `NODE_ID` variable. Registry scanners
+  (ComfyUI-Manager) AST-parse the source without importing it, so a variable
+  key makes every node invisible and "install missing custom nodes" stops
+  offering the pack. `scripts/validate_nodes.py` enforces this.
+- Assign each mapping **once**, at module level, to a non-empty dict literal,
+  and never mention the name again — no `update()`, no `del`, no
+  `alias = NODE_CLASS_MAPPINGS`. A scanner reads that one literal and stops,
+  so anything done to the mapping afterwards is invisible to it. Both
+  mappings must carry exactly the same keys.
+- Display name: `<Name> 🆎` — the emoji is the pack signature. Typing
+  "ausboss" still surfaces every node through the `🆎 AusBoss/<Group>`
+  category, the `AUSBOSS_NODES_` id prefix, and the "ausboss" entry every
+  node keeps in `SEARCH_ALIASES`.
+- Category: `🆎 AusBoss/<Group>`. The emoji is safe here — categories reach
+  the frontend as JSON and are never printed to the console at import time.
+- Every node gets `DESCRIPTION`, input `tooltip`s, and `OUTPUT_TOOLTIPS`.
+- IMAGE tensors are BHWC float batches; MASK is BHW. Return tuples always,
+  even for one output: `(value,)`.
+- Console output at import time must stay ASCII — ComfyUI on Windows often
+  runs a cp1252 console, and a UnicodeEncodeError there kills the whole pack.
+- Widget values and route parameters are attacker-controlled: ComfyUI's
+  `/prompt` and the pack's routes need no login. Media reads and writes stay
+  inside ComfyUI's input, output and temp folders - no opt-in switches, no
+  "any folder" settings, no folder pickers. A file is picked from a list and
+  named below one of those folders the way ComfyUI names it
+  (`clip.mp4 [output]`); no input opens a whole path as given.
+  A route answers with data it made (JSON, a small picture), never a file by
+  its path (`web.FileResponse`), and its error text goes through
+  `safe_route_error` (`nodes/_route_errors.py`). Besides those the pack only reads
+  its registered model folders (the one write there is LoRA Loader's Civitai
+  button: a `.civitai.info` file and a `.preview.jpg` picture, saved beside a
+  LoRA, never replacing a picture) and keeps its own
+  settings files in ComfyUI's user folder (`user/ausboss/`). Nothing is handed to a
+  subprocess. The Registry bans versions for exactly this.
+- The pack's server code makes no network requests: no HTTP or socket client
+  in shipped Python (`release_preflight.py` fails on one). The one outbound
+  call is LoRA Loader's click-only Civitai lookup, made by the browser to a
+  fixed civitai.com address with a plain SHA256, plus the LoRA's picture
+  from `image.civitai.com` on the same click (`js/lora_loader/index.js`,
+  `js/shared/civitai_lookup.mjs`). `release_preflight.py` allows a raw
+  `fetch(` only there and in `js/cache_guard`, which only talks to the pack's
+  own server. Graph links are made with
+  `linkSlots` from `js/shared/graph_links.mjs`, never the index-based
+  `node.connect(...)`, which registry scans read as a network socket.
+  SECURITY.md states the model for users.
+- No new pip dependencies without an explicit decision; if truly optional,
+  use `[project.optional-dependencies]` and fail soft at runtime.
+- Frontend files import each other only with plain string literals
+  (`from "../shared/x.mjs"`, `import("../shared/x.mjs")`). The server adds a
+  version tag to those paths (`nodes/_frontend_cache.py`) so an update never
+  meets old copies from the browser's cache. A path built in code
+  (`new URL(...)`, `"../shared/" + name`) escapes the tag and loads a second,
+  stale copy; `tests/test_frontend_cache.py` fails on one.
+- Frontend JS never assigns prototype callbacks directly — use
+  `chainCallback` from `js/shared/index.mjs`, or `chainHandler` where the
+  return value matters (a truthy `onMouseDown` result is what stops a node
+  drag). Messages to the user go through `showToast`, never `alert()`.
+- The mouse wheel over a node zooms the graph, on every part of its face.
+  `js/canvas_passthrough/` hands the wheel on from the pack's panels, and
+  keeps it only for a box that can still scroll or a field being typed in,
+  so a panel adds no wheel listener of its own
+  (`tests/canvas_passthrough.test.mjs` lists the few that exist). After a
+  change to a node face, `scripts/dev/wheel_sweep.mjs` turns the wheel at
+  every point of every node and must find no dead spot, in both renderers.
+- For compact panel actions and preview switches, use `compactAction` and
+  `panelSwitch` from `js/shared/panel_controls.mjs`. That module owns their
+  appearance, section caption styles, and common file and save labels. A
+  node styles its layout locally; leave the shared control's face to the
+  component. Its selectors only match explicitly named AusBoss controls.
+- Every INT and FLOAT a public node exposes reaches the user as a scrub
+  control, Adobe-style: drag the value to scrub, click to type, chevron
+  arrows step, Shift is always the fine step. Use `makeScrubInput` from
+  `js/shared/scrub_input.mjs` — never a bare `<input type=number>`, and
+  never a classic canvas number widget on a finished node face. Units
+  (`px`, `MP`, `×`) ride inside the box in a fixed-width slot that every
+  single-field row reserves, so the numbers down a card share one centre
+  line. Known, deliberate exceptions: the Seed card's seed (typed) and Load
+  Video's trim timecodes (typed).
+- **Node faces are widget cards.** A node whose face would be classic
+  LiteGraph widgets (full-width rows with an arrow at each end) gets an
+  entry in `js/widget_cards/index.js` instead: `mountWidgetCard` from
+  `js/shared/widget_card.mjs` hides the standard widgets and mirrors them
+  in one compact DOM card — numbers → scrub, ≤ 4 short choices → segmented
+  pill (else a select), booleans → an off | on pill as wide as the other
+  controls (never a small switch inside a card), strings → text field,
+  multiline → `kind: "textarea"` (`grow: true` takes the node's spare
+  height), hex colors → swatch. Rows can depend on other values (`when`)
+  and fold behind a disclosure (`group`). The widgets underneath stay the
+  single source of truth (save/load, undo, API, links).
+- **One linkable widget per row.** The frontend (≥ 1.10.4, "Widget Input
+  Socket" RFC #9) gives every widget an input socket drawn at the widget's
+  own row, only while a link is dragged, hovered or connected; "convert to
+  input" no longer exists. The card lends each hidden widget its row's
+  position, so two widgets on one row would stack two sockets on one pixel
+  and nobody could aim. A `pair` row is therefore only allowed with
+  `top: true`, which lifts its sockets into the node's slot column under
+  the real inputs (Image Resize width/height); everything else is one
+  widget per row. A value that is meant to be wired rather than typed is a
+  backend `forceInput: True` socket (Math Expression `a`/`b`/`c`), and a
+  multi-type string such as `"FLOAT,INT"` accepts either kind of link.
+- Preview-carrying nodes (Select Frame, Mask Refine, Mask by Name, LaMa
+  Inpaint, Save Image) share
+  `js/input_preview/`: a thin bar (node tools left, a small `preview`
+  switch right) above the picture, the picture gone and the node shorter
+  when the switch is off, backed by an optional `preview` BOOLEAN input
+  that also skips the temp file. A new node with a result picture reuses
+  it rather than growing its own.
+- A DOM panel that shows a stage/preview claims the node's free height via
+  `fillNodeHeight` from `js/shared/panel_layout.mjs` — never a hand-rolled
+  `computeSize`, which pins the panel and leaves dead space when the node is
+  dragged taller. `tests/panel_guards.test.mjs` enforces this pack-wide: a
+  new panel entry must be added to its `mustGrow` set (or `fixedByDesign`
+  for genuinely constant-height rows), so the choice is always explicit.
+  A `fixedByDesign` card also calls `pinVuePanelHeight`: its own
+  `computeSize` only pins it in the classic renderer, and Nodes 2.0 would
+  stretch it with the node and squeeze a picture under it. Run Timer does
+  not: its readout fills the node on purpose.
+- **A picture or clip in a stage sits out of flow.** Nodes 2.0 sizes a node
+  by its content, so an in-flow portrait clip drawn at full width held Load
+  Video at 965 px where classic goes to 584 px. Position the media
+  `absolute` in its stage, and the stage takes its size from the node
+  alone. A picture is centred at its own size (`js/input_preview/`); a
+  player fills the stage so its controls stay along the bottom edge
+  (`js/shared/video_ui.mjs`). Text that is fitted to its box follows the
+  same rule: the Callout's text is `absolute` in its card
+  (`js/callout/index.js`), or the text sizes the card it is fitted to.
+  `tests/panel_guards.test.mjs` holds all three.
+- **A panel's declared minimum width is its node's real floor.** Pass
+  `exactMinWidth: true` to `fillNodeHeight`; a constant-height card that
+  keeps its own `computeSize` calls `holdNodeMinWidth` instead. Left alone,
+  the frontend adds 104 px to a growing panel's number and ignores a pinned
+  card's number altogether (the node falls to its 210 px default), so a
+  declared 320 meant 424 for one and 210 for the other. Prove each face on
+  a real canvas at that width in both renderers; a panel that clips there
+  gets a larger minimum, not a broken face. Nodes 2.0 never goes under
+  225 px whatever a panel declares.
+- **A growing panel's declared minimum height holds in Nodes 2.0 too.**
+  Nodes 2.0 lays a node out by its content, not by the floor a widget
+  declares, so a panel whose content has no height of its own was dragged
+  flat there. `fillNodeHeight` also writes the floor to the panel's
+  element as a CSS `min-height`, less `WIDGET_FRAME`, while the panel sits
+  inside a Nodes 2.0 node. So declare `minHeight` as what the element needs
+  plus `WIDGET_FRAME`, and never assign a growing panel's
+  `computeLayoutSize` by hand. Prove the floor with a real corner drag up
+  in both renderers.
+- Frontend settings use `AusBoss.<Area>.<Name>` ids with
+  `category: ["🆎 AusBoss", "<Area>", "<Leaf>"]` and a distinct leaf per
+  setting. Node color schemes live in `js/shared/appearance.mjs`.
+
+### Adding a node
+
+Follow `docs/adding_a_node.md`. Short version: create `nodes/node_<name>.py`
+modelled on a small existing node such as `nodes/node_image_size.py`, add
+`"node_<name>"` to `NODE_MODULES` in `__init__.py` and the key to
+`PUBLIC_NODE_IDS` in `scripts/validate_nodes.py`, give it a help page at
+`js/docs/<KEY>.md`, optionally add `js/<name>/index.js`, then validate.
+
+### Validation
+
+Run the offline checks before a pull request:
+
+```bash
+python scripts/validate_nodes.py
+python scripts/release_preflight.py
+python scripts/run_python_tests.py   # with ComfyUI's Python
+node --test tests/*.test.mjs
+```
+
+Then restart ComfyUI fully (a changed `INPUT_TYPES` is only served after a
+restart), watch the AusBoss banner for failed modules, confirm the node
+appears in `GET http://127.0.0.1:8188/object_info`, queue a tiny API graph,
+and load its example workflow. After JS changes, hard-refresh the browser
+tab (Ctrl+Shift+R) — the frontend caches `.mjs` modules aggressively.
+
+Frontend work is proven on a real canvas, not by reading code: the
+headless-Chrome harness in `scripts/dev/` (recipe, gotchas and the
+screenshot convention in `docs/live_testing.md`) creates nodes, drives real
+mouse drags, and screenshots the result. A link-drop test that only checks
+which input got the link is not enough — look at the picture and ask whether
+a person could have aimed there.
+
+A ComfyUI update can break a node without a line of the pack changing. So
+the pack is run against the newest ComfyUI every night
+(`.github/workflows/comfyui_compat.yml`): its newest release and its
+development head, on the CPU, with no model files. Three checks, which also
+run by hand against any ComfyUI:
+
+```bash
+AUSBOSS_COMFY_ROOT=<ComfyUI> python tests/test_comfy_core_contract.py
+python scripts/compat_boot.py --url http://127.0.0.1:8188
+node scripts/dev/face_smoke.mjs <chrome port>            # and again with --vue
+```
+
+- `test_comfy_core_contract.py` reads the pack's own source for everything
+  it takes from ComfyUI and looks each thing up in the real one. It finds
+  imports by itself. A call to one of ComfyUI's own nodes by name
+  (`SAM3_Detect`), or an internal read with a fallback, goes in the tables at
+  the top of that file; the test fails on a node call that is not listed.
+- `compat_boot.py` asks a running ComfyUI which nodes it offers: every public
+  node of the pack, and every node and required input the examples use.
+- `face_smoke.mjs` puts every node on a graph and fails when a face does not
+  come up or something throws.
+
+A failure on the release opens an issue labelled `comfyui-update`. What these
+cannot see is anything that needs a model: run the real thing on a GPU
+before a release that follows a ComfyUI update.
+
+### Releasing
+
+A new `version` in `pyproject.toml` that lands on main publishes to the Comfy
+Registry through the publish workflow (`.github/workflows/publish_action.yml`).
+After a successful upload, the same workflow tags that commit and creates a
+GitHub Release with the full changelog section. The README badge links to the
+latest GitHub Release. If only that step fails, rerun the failed jobs to retry
+it without uploading the Registry version again. Existing releases are left
+unchanged on a rerun. Contributors never change `version`.
+
+For an authorized release, update both `pyproject.toml` and
+`AUSBOSS_JS_VERSION`, date the changelog section, then run
+`python scripts/release_badge.py`. Preflight rejects a badge that does not
+match the pack version. Its SVG lives in the repository so the release
+number stays visible when an external badge service is unavailable.
+
+The Registry shows notes with each version. They are that version's section
+of `CHANGELOG.md`, one line per entry: its bold opening, and for a new node
+the sentence that says what it does (`scripts/changelog_notes.py`). So open
+every entry with a bold line that makes sense on its own.
+
+### Example workflows
+
+Examples are what most people run first, so each one must work for a
+stranger with only the files its Workflow Note lists.
+
+- Every model loader selects the official file name, the basename of its
+  download URL, carries that file in `properties.models`
+  (`name`, `url`, `directory`), and the Note's model row names the same
+  file. People who keep models in subfolders pick their copy.
+- Media loaders (Load Image, Load Image + Pad, Load Video, Image Crop +
+  Rotate + Pad and the video nodes) are saved blank. A file name is one the
+  stranger doesn't have, and ComfyUI flags that node red when the workflow
+  loads. The Workflow Note tells people to load their own picture; the
+  sample files stay in `example_workflows/inputs/` for anyone who wants to
+  try one.
+- Save nodes use a filename prefix without a folder. Seeds are fixed.
+- Numbered groups hold every node, nothing overlaps (title bars included),
+  the saved zoom is at least 0.6 so widget text draws, the workflow `id` is
+  a real uuid4, and the `.jpg` beside the `.json` shows a real output.
+- The frontend saves widget values twice, by position and by name
+  (`widgets_values_named`), and can restore by name; both copies must agree.
+- `scripts/workflow_contract.py` checks links, groups, overlaps, the note,
+  the id, the zoom, the named copies, the download info and the save
+  prefixes. Whether the note tells the truth about the graph is review.
+- Text-to-image examples have no source to describe. Edit and inpaint
+  examples keep an explicit change instruction: a description of the old
+  scene is not an edit. MiniMax H3 and Klein caption their sources with
+  Qwen3-VL 8B because their own text encoders returned only punctuation
+  when asked to describe an image.

README.md

@@ -1,189 +1,494 @@
 <div align="center">
   <h1>ComfyUI-AusBoss</h1>
-  <p><strong>Polished nodes for the workflows I use most.</strong></p>
+  <p>ComfyUI nodes for image and video work.</p>
   <p>
     <img src="https://img.shields.io/badge/license-MIT-blue?style=flat-square" alt="MIT License">
-    <img src="https://img.shields.io/badge/release-1.0.0-00b4aa?style=flat-square" alt="Release 1.0.0">
+    <!-- Generated by scripts/release_badge.py. Release preflight checks
+         the badge against pyproject.toml so it cannot silently go stale. -->
+    <a href="https://github.com/ausboss/ComfyUI-AusBoss/releases/latest"><img src="assets/readme/release.svg" alt="Latest release"></a>
+    <a href="https://www.youtube.com/@ausbossdev"><img src="https://img.shields.io/badge/YouTube-%40ausbossdev-00b4aa?style=flat-square&logo=youtube&logoColor=white" alt="YouTube @ausbossdev"></a>
+    <a href="https://discord.gg/RwVxY9Fuaj"><img src="https://img.shields.io/badge/Discord-AusBoss-00b4aa?style=flat-square&logo=discord&logoColor=white" alt="Discord: AusBoss"></a>
+    <a href="https://huggingface.co/ausboss"><img src="https://img.shields.io/badge/Hugging%20Face-ausboss-00b4aa?style=flat-square&logo=huggingface&logoColor=white" alt="Hugging Face: ausboss"></a>
+    <a href="https://x.com/Zanzibased"><img src="https://img.shields.io/badge/X-%40Zanzibased-00b4aa?style=flat-square&logo=x&logoColor=white" alt="X @Zanzibased"></a>
   </p>
 </div>
 
-ComfyUI-AusBoss is a curated collection of polished nodes designed to streamline the ComfyUI workflows I use most. Each node replaces repetitive setup with focused controls, compact graph footprints, and only the outputs needed downstream. Larger visual tasks open into dedicated full-screen editors, while experiments and one-off utilities stay out of the public pack.
+I made these nodes for my own ComfyUI workflows, mostly because I wanted features I couldn't find in other packs. I use them myself, and I keep adding new ones.
 
-## Nodes
+Most of them are for image and video work. ComfyUI's core nodes already cover the basics, like seeds, sizes and prompts, so use these where they add something. A few of the things they do:
 
-### Image Crop + Rotate + Pad 🆎
+- **[Mask by Touch](#mask-by-touch):** click a thing on the picture and get its mask. Hover shows what a click would take, and **Fine edges** follows hair and fur.
+- **[Mask by Name](#mask-by-name):** type "the red jacket" and get its mask and a cut-out.
+- **[Image Crop + Rotate + Pad](#image-crop--rotate--pad):** turn, crop and pad a picture by dragging handles on the node, for outpainting.
+- **[Stitch Inpaint](#stitch-inpaint):** after an inpaint or outpaint, everything you didn't ask to change is your original pixels again.
+- **[Video Crop + Rotate + Pad → Clip](#video-crop--rotate--pad--clip):** trim a clip on a timeline, and pad or crop it to a new shape.
+- **[Tiled Upscale](#tiled-upscale):** upscale a picture in tiles to the megapixels you set.
+- **[Image Folder](#image-folder):** tick pictures in a folder and run the workflow on each one.
+- **[Layout Boxes](#layout-boxes):** draw boxes where things and words go in the picture, for MOSS-Image.
+- **[Image Compare A/B](#image-compare-ab):** a before-and-after slider, and a brush to mix the two.
+- **[LoRA Loader](#lora-loader):** a whole LoRA stack in one node, each row with its own switch and strength.
+- **[Workflow Switches](#workflow-switches):** turn parts of a workflow off and on from one small card.
 
-A Load Image-style node with a compact transformed preview and a full-screen editor for precise crop, rotation, padding, fill, mask feathering, and output-size alignment. The preview is itself a live stage — drag the crop handles, padding diamonds, and rotate knob directly on the node, and open the editor when you want zoom, pan, and the numeric sidebar.
-
-### Video Crop + Rotate + Pad 🆎
-
-Targets an exact video frame from an uploaded input file or local path. The full-screen editor adds a long timeline, playback, exact frame steps, and the same transform controls as the image node.
-
-### Select Frame 🆎
-
-Returns one unchanged frame from an `IMAGE` batch using a clear one-based frame number. Out-of-range requests report the valid range instead of silently selecting the wrong image.
-
-### Frame Chooser 🆎
-
-Pauses the graph and shows the incoming batch as a clickable filmstrip: pick the frames to keep, or Keep all / Cancel — with digits, `A`/`N`, `Enter` and `Escape` on the keyboard. A countdown can auto-answer with the policy you choose, a reload mid-pause restores the panel, and filling `pick_list` skips the pause entirely so a chosen take reruns headlessly (your interactive picks are written back there for you). Outputs the kept sub-batch, its count, and the one-based indices.
-
-### LoRA Loader 🆎
-
-A stacked multi-LoRA node. Each row has an on/off pill, a searchable picker (type to filter, arrow keys + Enter to pick; browse view groups by folder and hovering shows the preview image), and strengths you can **drag left/right to scrub** (Shift for fine steps) or click to type. A header pill toggles the whole stack. The per-row info card shows the LoRA's preview image, base model, trigger words from its file metadata, a one-click Civitai lookup, or your own saved words — click words to toggle them into the deduplicated `trigger_words` output — plus an optional suggested strength range that tints out-of-range values. The bar's ▤ button saves and applies named templates of the whole stack, and a LoRA trained for a different base model than the connected checkpoint logs a console warning. CLIP input is optional.
-
-### Align Image 🆎
-
-Snaps width and height to a clean multiple of a number you pick — 16, 32, whatever the model wants. Qwen image models, VAEs, and many samplers behave best on cleanly divisible sizes. `resize` rescales to the nearest multiple, `crop` center-crops down, `pad` replicate-pads up, and the new size comes out as INTs for wiring into latent nodes — plus `offset_x`/`offset_y` for cropping back after sampling.
-
-### Image Size 🆎
-
-Reads an image's dimensions as INTs — width, height, longest edge, shortest edge — so resizes and latents key off the actual image instead of retyped numbers that drift.
-
-### LM Studio Chat 🆎
-
-Sends a prompt (and optionally an image) to a local LM Studio server — or any OpenAI-compatible endpoint — and returns the reply as text. Empty model name means "whatever the server has loaded", reasoning-model `<think>` blocks come out on a separate output so the text stays clean for conditioning, and the seed doubles as the re-roll knob. Chain the `history` output into another chat node's `history` input for multi-turn conversations, or fill `json_schema` to force a structured JSON reply. Errors are actionable: a refused connection says how to start the server.
-
-### Color Match 🆎
-
-Harmonizes an image against a reference by transferring per-channel LAB mean and standard deviation — the fix for an inpainted or upscaled region that comes back slightly brighter or cooler than the plate it sits in. Optional mask restricts the correction to just that region, and `strength` blends it back toward the original. For video, `reference_mode: first_frame` locks every frame to the batch's own first frame — the one-node flicker fix.
-
-### Pad Image 🆎
-
-Pads an image with a solid color, replicated edges, replicated edge pixels, or a **pillarbox blur** (a blurred, dimmed copy of the frame behind the sharp original — the standard look for reframing video to a new aspect). Also returns a mask covering exactly the new padding, ready to wire straight into an outpaint. The stage on the node is the control: drag any edge of the final rect to set that side's padding over a live preview of the input (run once to fill it in).
-
-### Load Image + Pad 🆎
-
-A Load Image that opens straight into an outpaint canvas: drag any edge of the final rect drawn on the node to grow that side's padding — the whole edge is the handle, per-side pixel counts ride the bands, and the badge always shows the true output size. The mask covers exactly the padding with an optional **feather** ramped inward across the seam, the canvas rounds up to a clean multiple, and a **megapixel target** rescales the source *before* padding so the mask seam stays crisp at sampler-friendly sizes. Outputs the canvas, the mask, and the final width/height as INTs.
-
-### Drop Shadow 🆎
-
-Drops a soft shadow behind a masked subject with signed offset, grow, blur, color, and opacity — what sells a padded or reframed composition as deliberate. A multiply blend mode keeps the backdrop's texture, and the `shadow_mask` output hands the effective shadow alpha to downstream compositing.
-
-### Frame Interpolate 🆎
-
-Retimes a clip by **frames per second rather than a whole-number multiple**, so 24 to 30 works as naturally as doubling. Choose a fast `blend` crossfade or optical flow for real motion. Hard cuts are detected and held rather than interpolated across, avoiding the smeared morph other interpolators produce at a scene change. Memory is bounded by planning the work first and streaming results back to the CPU.
-
-### LaMa Inpaint 🆎
-
-Inpaints white mask regions with a TorchScript LaMa checkpoint, preserves pixels where the mask is zero, and processes large video batches one frame at a time to keep VRAM bounded. Place `big-lama.pt` in `ComfyUI/models/lama/`; the node never performs automatic downloads.
-
-### Crop For Inpaint / Stitch Inpaint 🆎
-
-Inpaint only where it matters: Crop For Inpaint grows the mask's bounding box by a context factor and emits the crop, the raw sampling mask, and a stitcher; Stitch Inpaint pastes the result back with a separately feathered blend so every pixel outside the blend region stays **bit-identical** to the original. The stitcher broadcasts across a video batch, so one crop serves a whole clip. An optional `fix_edge_halo` toggle removes the rim that appears when a feathered seam gets blended twice. `target_megapixels` rescales the crop to a sampler-friendly area with a selectable `rescale_algorithm`, and the `extend_*` inputs grow the frame itself for outpainting — the new bands become part of the stitched output.
-
-### Load Video 🆎
-
-Loads a video as frames plus audio with `frame_count`, `fps`, `width`, `height`, and `duration` outputs, plus a lazy core `VIDEO` handle so the clip chains straight into ComfyUI's own video nodes. Its single responsive player includes a two-handle trim timeline: drag **IN** and **OUT** (shown as `h:mm:ss.s` timecodes you can type into), preview exactly that window, and optionally loop it. Only the selected window is decoded, with a memory guard that reports oversized trims instead of exhausting RAM; audio is extracted lazily only when consumed. Optional custom width/height with aspect-preserving single-side mode; `every_nth` thins long clips (the fps output divides to match) and `max_frames` caps the decode outright.
-
-### Refine Mask 🆎
-
-Grows or shrinks a mask, fills enclosed holes, melts jagged edges with a `smooth` control that does not feather, feathers, and rescales the extremes with black/white points — returning both the refined mask and its inverse. Optional `guided filter` and `matting` tiers refine the edge against a guide image when you install the matching extra.
-
-### Save Video 🆎
-
-Encodes frames — or a connected core `VIDEO` — to an H.264/H.265 mp4 or VP9 webm (all CRF-controlled) tagged bt709 (so platforms don't shift your colors), with optional muxed audio and the workflow embedded, so a saved mp4 dragged back onto the canvas restores its workflow. The responsive in-node player previews the encoded result with loop and reload controls. Wire `fps` from Load Video to preserve source timing; a connected video brings its own rate and overrides the widget. Encoding runs off the executor thread with per-frame progress, so a long export never freezes the UI.
-
-### Compare 🆎
-
-A/B any two images: slide mode sweeps B over A under your pointer with a seam line, hold mode shows B while pressed. Passes image A through, so it sits mid-graph without rewiring.
-
-The two transform nodes return exactly:
-
-1. `image` — transformed ComfyUI `IMAGE`
-2. `mask` — generated-area `MASK`, including source transparency, rotation corners, and padding
-
-The operation order is always **rotate → crop → pad**. New sources start with zero rotation, full crop, zero padding, and a canvas multiple of `1`.
+The **?** in a classic node's title bar opens a short card with its inputs and outputs. In Nodes 2.0, right-click the node and choose **About this node**. Every node also has a longer help page in ComfyUI's node help panel. I post the workflows I make with them on [Civitai](https://civitai.com/user/AusBoss) and [X @Zanzibased](https://x.com/Zanzibased), and videos of them on [YouTube @ausbossdev](https://www.youtube.com/@ausbossdev). Can't open Civitai? All my workflows are on [my Discord](https://discord.gg/RwVxY9Fuaj) too. If a node saves you time, a star on the repo helps other people find it.
 
 ## Install
 
+In **ComfyUI-Manager**, open the Custom Nodes Manager, search for **AusBoss** and install it. From the command line, `comfy node install ausboss-nodes` does the same. To get the newest changes first, clone the repository instead:
+
 ```bash
 cd ComfyUI/custom_nodes
 git clone https://github.com/ausboss/ComfyUI-AusBoss.git
 ```
 
-Restart ComfyUI, then search for `AusBoss`. There are no additional Python dependencies; the pack uses Pillow, NumPy, Torch, and PyAV already distributed with ComfyUI. LaMa Inpaint additionally needs a TorchScript `big-lama.pt` checkpoint in `ComfyUI/models/lama/`.
+Restart ComfyUI and search the node library for **AusBoss**.
 
-## Model Links
+Install it one way, not both. Manager puts the pack in `custom_nodes/ausboss-nodes` and a clone in `custom_nodes/ComfyUI-AusBoss`. They are the same pack, so if both folders are there, delete one. The console says which copy it skipped.
 
-**lama**
+After an update, through Manager or `git pull`, restart ComfyUI and hard-refresh the browser with **Ctrl+Shift+R**. Otherwise the browser keeps the old JavaScript, and the pack warns you about it. Manager can install a version or two behind while the Comfy Registry reviews a new release. To get the newest one, pick it in Manager's version list, or update by hand: delete the pack's folder in `ComfyUI/custom_nodes` and clone the repository as shown above.
 
-- [big-lama.pt](https://github.com/Sanster/models/releases/download/add_big_lama/big-lama.pt)
+The pack uses the Pillow, NumPy, Torch and PyAV that come with ComfyUI. Each example lists the models it needs on its Workflow Note. LaMa Inpaint also needs [`big-lama.pt`](https://github.com/Sanster/models/releases/download/add_big_lama/big-lama.pt) in `ComfyUI/models/lama/`. The pack never downloads weights by itself.
 
-## Model Storage Location
+### Upgrading from 1.x
 
-```text
-📂 ComfyUI/
-└── 📂 models/
-    └── 📂 lama/
-        └── big-lama.pt
+2.0 removed **LM Studio Chat** (use **Text** for a fixed prompt) and Align Image's `offset_x` and `offset_y` outputs. Math Expression's `a`, `b` and `c` are sockets now instead of typed boxes, so put constants in the expression itself. 1.2 removed **Drop Shadow**, **Pad Image** (use **Load Image + Pad**) and **Frame Chooser**. Save Image writes only inside ComfyUI's output folder. The [changelog](CHANGELOG.md) has the details.
+
+| Section | What's in it |
+|---|---|
+| [Image nodes](#image-nodes) | Rotate, crop and pad; resize, align and measure; upscale in tiles; run a whole folder; match colors; realign edits; compare; save |
+| [Video nodes](#video-nodes) | Load and trim, pick a frame, transform a clip, change the frame rate, save |
+| [Mask and inpaint nodes](#mask-and-inpaint-nodes) | Mask a thing by clicking it or typing its name, refine masks, remove objects with LaMa, crop around a mask and stitch the result back |
+| [Models and conditioning](#models-and-conditioning) | LoRA stack, Krea 2 prompts and references |
+| [Workflow utilities](#workflow-utilities) | Canvas size, seed, batches, math, text, memory, notes, callouts, switches, timer, step preview |
+| [Example workflows](#example-workflows) | Ready-made workflows, each with a setup card |
+| [For workflow creators](#for-workflow-creators) | Setup cards, before and after, repeatable seeds, measured run times |
+| [Pack-wide tools](#pack-wide-tools) | Help cards, node colors, snap into line, recreate and replace, run status, completion sound |
+
+## Image nodes
+
+### Image Crop + Rotate + Pad
+
+Rotate, crop and pad a picture by dragging handles on the node. Cyan squares crop, orange diamonds pad, and the green handle rotates. It rotates first, then crops, then pads. The full-screen editor adds exact sizes, zoom and pan.
+
+Open **Crop, pad & resize** under the preview and tap a ratio to pad the picture to it, or to crop it with **Fit** set to crop. A lit ratio is the shape the canvas has right now: drag a handle to another shape and it goes dark, and the row says Custom. The padlock at the end of the row keeps the shape while you drag, and the button at the start turns the shape between portrait and landscape. **Reset crop** brings back the whole picture, and **Divisible by** makes the width and height divide evenly by a number such as 8, 16 or 32, for models that need it. Feather and output resizing are on the node and in the editor.
+
+It returns the `image`, a `mask` of everything the model paints (padding, see-through parts of the source and the corners a rotation opens up), a `stitcher`, the untouched `original`, the output `width` and `height`, and a `prompt_image`. Wire the stitcher into **Stitch Inpaint** after the sampler to put your original back. See-through parts of a PNG, such as a cutout's missing background, are filled like the padding and painted; `prompt_image` and `original` show them as white. Give `prompt_image` to whatever writes your prompt, so it describes a real backdrop instead of the gray fill. **Load Image + Pad** has more fill choices and a separate reference output.
+
+![The full-screen image editor with a rotated lake photo, cyan crop handles, orange padding handles, aspect ratios, and dimension controls.](assets/readme/image-editor.webp)
+
+![A night photo of a woman leaning out of a car window is turned and padded, and Krea 2 fills the new space with more of the street.](assets/readme/rotate-outpaint.gif)
+
+Krea 2 Rotate + Outpaint turns a photo, pads it and paints the new area in one pass. [Try the Krea 2 Rotate + Outpaint example →](example_workflows/Krea%202%20Rotate%20%2B%20Outpaint%20%28AusBoss%29.json)
+
+### Load Image + Pad
+
+Makes a canvas for outpainting: drag the edges out to add room around a picture. The Source list shows the picture under the pointer. The new area can be a solid color, the average color of the nearest edge, the edge pixels smeared outward, a blurred copy of the picture, or a mirror of it. The card also has a seam feather, a canvas multiple and a megapixel budget, and **Exact padding** opens one control per side. A budget of 0 keeps the picture's size, and anything higher resizes the picture before padding. A picture wired into `source_image` is padded instead of the chosen file.
+
+It returns the padded `image`, a `mask` of the padding, `width`, `height`, a `stitcher`, and a smaller unpadded `reference` for the model. Wire the stitcher into **Stitch Inpaint** after the sampler, and everything outside the seam stays your original picture.
+
+The Klein 9B Outpaint example pads its picture with Load Image + Pad. [Open the Klein 9B Outpaint workflow →](example_workflows/Klein%209B%20Outpaint%20%28AusBoss%29.json)
+
+### Image Folder
+
+Pick a folder, tick the pictures you want in a thumbnail gallery, and run the workflow on each one. **All in one run** does every picked picture with one press of Run. **One per run** loads one picture each run and steps to the next by itself, so a picture that fails only skips itself. After the last picture it stops with a message, or starts over at the first and keeps going. It gives each picture's mask, its file name for saving the result under the same name, its number and how many there are.
+
+**Browse** lists the folders inside ComfyUI's input or output folder. A folder from anywhere else on your computer is brought in: drop it on the node, or choose it in your file explorer, and its pictures are copied into the input folder. A really big folder asks first. The node reads nothing outside those two folders.
+
+### Image Resize
+
+Resizes to a width and height, a longest or shortest edge, a megapixel count, or a scale factor. It can fit inside the size, stretch to it, fill it and crop the rest, or pad with a color you pick. New nodes start in megapixels mode, and saved workflows keep their mode. The card shows only the controls for the chosen mode, and width and height each take their own link.
+
+An optional mask is resized the same way. It returns `image`, `mask`, `width` and `height`. Padding shows up white in the mask, and with no mask wired in, the rest of the mask is black. `divisible_by` rounds the size to a multiple, and `interpolation` picks the resize filter.
+
+### Tiled Upscale
+
+Sets the size of the finished picture in megapixels and cuts your picture into tiles a model can redraw one at a time. A picture that fits in one tile stays whole, and a small picture is not redrawn far past the detail it has. Send the tiles through your sampler, then into Tiled Upscale Stitch with the stitcher.
+
+Megapixels is the one control to set. Under More are the tile size, the overlap, the grid multiple and the redraw limit, and an upscale model can be plugged in. It returns `tiles`, `stitcher`, `before` (your picture enlarged the plain way to the finished size), `width`, `height` and a `report` that says what was done.
+
+### Tiled Upscale Stitch
+
+Puts the redrawn tiles from Tiled Upscale back together, blends the joins and brings the picture to the size you asked for. Keep colors matches each tile to the same tile of your picture first, so the tiles agree with each other and grain in an old photo does not push the colors.
+
+The Qwen Image 2.1 Upscale + Restore example redraws a small or worn photo sharp at the megapixels you set, in tiles above about 2. [Try the Qwen Image 2.1 Upscale + Restore example →](example_workflows/Qwen%20Image%202.1%20Upscale%20%2B%20Restore%20%28AusBoss%29.json)
+
+### Align Image
+
+Rounds a picture's size to a multiple you choose, by resizing, cropping or padding. Use it when the next model needs sizes that divide evenly and you don't want to type a target size. Crop and pad have anchors for where to cut or add, and padding can repeat the edge pixels or use a solid color. It returns the picture with its width and height.
+
+### Image Size
+
+Reads a picture's `width`, `height`, `longest_edge`, `shortest_edge` and batch `count` as whole numbers. Wire them into a resize, a latent, a frame count or Math Expression, so the rest of the graph follows the source's size. After a run the node shows each number beside its output.
+
+### Color Match
+
+Matches a picture's colors to a reference, with LAB, RGB, MKL or histogram transfer. Strength sets how much, and an optional mask (with invert) limits where. With `reference_mode` set to first frame, every frame of a batch matches the batch's first frame. That can cut down color drift in a clip, but it does not steady motion.
+
+### Realign to Source (EXPERIMENTAL 🧪)
+
+Lines an edited picture back up with the original. Qwen Image 2.1 often draws an edit, especially a style change, a little bigger or shifted: up to about 12% taller, by a different amount every seed. Wire in the edit and the picture it was made from. The node measures how far the edit moved and moves it back, at the original's size. It fixes the zoom and shift of the whole picture, not shapes the edit redrew in a new place, so the result lines up closely rather than pixel for pixel.
+
+For the best result, pad the picture with Load Image + Pad's `mirror` fill before the edit and wire its `stitcher` in. The edit gets room to move, and you get back just your picture's area with real picture at the edges. Without that margin, an edit made at the picture's own size loses a thin strip the model pushed out of view. `empty_mask` marks that strip so you can crop or inpaint it, and **Empty fill** picks what it shows in the meantime.
+
+**Fit** is `zoom + shift` (how Qwen edits drift) or `affine`, which also fixes a slight tilt. When the drift is a whole number of pixels, the node cuts the picture out as it is, with no resizing. `report` gives the measured zoom and shift, and the margin a side needed when an edit ran out of picture. A picture it can't measure passes through at the source's size, and the report says why. [Try the Qwen Image 2.1 Edit + Realign example →](example_workflows/Qwen%20Image%202.1%20Edit%20%2B%20Realign%20%28AusBoss%29.json)
+
+![A Qwen Image 2.1 watercolor edit of a woman in front of a wall of old TVs, flipped against the original: without Realign the waistband and a shelf edge sit lower (61 px off), with Realign to Source they line up (0.6 px off).](assets/readme/realign.gif)
+
+The same watercolor edit without and with Realign to Source: 61 px off before, 0.6 px after.
+
+![Chart titled CRT wall, watercolor: Qwen draws it 5.6% taller, showing the original, the edit as Qwen drew it (61 px off) and the realigned edit (0.6 px off), with close-ups of the waistband.](assets/readme/realign-chart.webp)
+
+Qwen drew this watercolor 5.6% taller, and Realign to Source lined it back up with the original.
+
+### Image Compare A/B
+
+Compares two pictures with a slider, or flips between them whole. Nothing covers the picture, and its size shows underneath. The panel grows with the node, and images A and B pass through, so you can put it anywhere on an image wire. **Erase** mixes the two by hand: rub parts of one picture away with a brush so the other shows through, then save the mix as a PNG under a name you type, with a layered PSD for Photoshop or GIMP if you want it.
+
+### Save Image
+
+Saves PNG, lossless WebP or lossless JPEG XL, with the workflow embedded if you want it. Pick a folder inside ComfyUI's output folder or browse its subfolders, edit the file name, and the path preview shows where the file will go. Chips add a counter, the date, the time, the size or a batch number to the name. Name tokens work as in ComfyUI's own Save Image: `%date:yyyy-MM-dd%`, `%width%`, `%KSampler.seed%`.
+
+Link `filename` to keep a name from upstream, or `caption_text` to write a matching `.txt` next to each picture. The counter picks a name that isn't taken yet. Turn it off to reuse the same path on purpose. JPEG XL needs the optional `pillow-jxl-plugin` extra. The [help page](js/docs/AUSBOSS_NODES_SaveImage.md) has the full naming and compatibility notes.
+
+Turn on **steps** to watch the picture form in the node while it is being made, with a **STOP** button for a run that is going wrong. It is off by default.
+
+## Video nodes
+
+![A square clip of a woman under a blue sky grows into a tall 9:16 frame as LTX 2.3 fills in more sky above her and the wall below.](assets/readme/video-outpaint.gif)
+
+Here LTX 2.3 Video Outpaint takes a square clip to 9:16 and stitches the original frames back in.
+
+The example keeps the clip's audio when there is any. The outpaint LoRA needs a pure black fill, since gray or white bands come back flat. With a black canvas it works at any aspect ratio and on any side. [Open the LTX 2.3 Video Outpaint workflow →](example_workflows/LTX%202.3%20Video%20Outpaint%20%28AusBoss%29.json)
+
+### Load Video
+
+Upload a video, or pick one from the Source list, which plays the clip under the pointer. Trim it with IN and OUT handles or typed timecodes. The player plays the part you kept and can loop it. Width and height resize while decoding, and setting only one keeps the shape. `every_nth` skips frames and lowers the reported fps so the timing stays right, and `max_frames` caps how many frames load.
+
+It returns the frames, audio, frame count, fps, width, height, duration and a core `VIDEO`. Only the part you kept is decoded, and it checks memory before a large load. When you save the frames, wire its fps into the save node.
+
+### Load Audio
+
+Upload a sound file, or pick one from the Source list, and the node shows it as a wave. Drag the IN and OUT handles to keep only the part you want, or type the times. Press play to hear just that part. Set **Max length** to the longest sound the next step can take, such as a video's length: anything past it turns red and is cut off, so you see what comes out before you run. Click the red length next to OUT to move OUT to the cut.
+
+It returns the `audio` you kept and its length in `seconds`. Only that part is decoded. [Help page](js/docs/AUSBOSS_NODES_LoadAudio.md).
+
+### Video Crop + Rotate + Pad → Frame
+
+Picks one frame from a video, then gives you the same rotate, crop and pad controls as the image node, plus an optional megapixel resize. Scrub to the frame with the playhead on the node; the editor adds frame-by-frame stepping and playback. It returns the transformed `image`, a `mask` of the added area, a `stitcher`, the chosen `original` frame, and the output `width` and `height`. For a whole clip, use the Clip version below.
+
+### Video Crop + Rotate + Pad → Clip
+
+Applies one rotate, crop and pad to every frame of a trimmed clip. It has the source picker, a timeline with a playhead and frame-accurate IN and OUT handles, frame skipping, a frame limit, the transform handles and output resizing. While you drag a trim handle, the node shows the exact first or last frame the run keeps. The bright part of the selection is what gets output.
+
+Fill, feather and the resize budget are in **Crop, pad & resize** below the timeline, and a new clip keeps them. That matters for video outpainting, because the black, hard-edged canvas the model needs survives a source swap. A fresh Clip node starts with that canvas, and the editor's **Reset transform** goes back to it. **Frames for** trims the end to the frame count the next video model takes: LTX (8n+1) or Wan (4n+1). Tap a ratio to pad the clip to it; a new clip is padded to the lit ratio too. The padlock keeps the shape while you drag a handle.
+
+It returns the frames, mask, audio, frame count, fps, size, duration, a `stitcher`, and the chosen `original` frames before the transform. **Inpaint & Stitch** in the editor sets the protected source area and previews the blend. After a video outpaint, wire the stitcher straight into **Stitch Inpaint**, with no Crop For Inpaint in between. It works in chunks to keep memory down.
+
+**Fixed frames** sets an exact output length: 120 frames at 24 fps is five seconds. Drag either handle, or drag the highlighted band to move the whole window. Type the count, or link a frame count into `fixed_frames`. 0 turns the fixed length off. The frame limit still caps the length.
+
+![The full-screen video editor with a portrait clip padded to landscape, an Inpaint and Stitch panel, and a timeline with IN and OUT handles.](assets/readme/video-editor.webp)
+
+The Clip node's editor, from the video outpaint example.
+
+### Select Frame
+
+Picks one frame from a batch, unchanged: `1` is the first, `-1` the last and `-2` the one before it. 0, or a number past the end, stops with an error that gives the valid range. The preview switch shows the frame, or hides it and skips writing the preview file.
+
+### Frame Interpolate
+
+Changes a clip's frame rate by making in-between frames. You set the source and target fps, so 24 to 30 works as well as doubling. The blend method crossfades frames, and optical flow uses RAFT weights you put in place yourself. At a hard cut it holds the frame instead of blending two unrelated shots. It works in chunks to keep memory down.
+
+It returns the new frames and their fps. It doesn't touch audio, so carry the source audio to Save Video separately. The [help page](js/docs/AUSBOSS_NODES_FrameInterpolate.md) covers the weights and timing.
+
+### Save Video
+
+Saves a frame batch or a core `VIDEO` as MP4 (H.264 or H.265), WebM (VP9 or AV1), ProRes MOV, lossless FFV1 MKV, GIF or WebP. Which encoders you get depends on your FFmpeg and PyAV build, and H.264 and H.265 come in CPU and NVENC versions. The videos carry color tags, and optionally audio and the workflow.
+
+**Ping-pong** plays forward and then back without repeating the turnaround frames. A wired `VIDEO` brings its own frame rate; otherwise wire fps from Load Video or Frame Interpolate. The player on the node shows the saved file, and **Preview steps** shows the clip's first frame while it is being made, with a **STOP** button. Drop a saved video back on the canvas to load the workflow inside it, for the formats that can hold one. The [help page](js/docs/AUSBOSS_NODES_SaveVideo.md) has the format and audio details.
+
+## Mask and inpaint nodes
+
+![A woman in a pink fur coat under neon signs; a wipe turns the coat into a black leather jacket and leaves the rest of the picture as it was.](assets/readme/inpaint-masked.gif)
+
+Krea 2 Inpaint Masked turns the painted fur coat into a leather jacket, using Mask Refine, Crop For Inpaint and Stitch Inpaint. [Open the Krea 2 Inpaint Masked workflow →](example_workflows/Krea%202%20Inpaint%20Masked%20%28AusBoss%29.json)
+
+### Mask by Name
+
+Type what to find in a picture, like "the dog" or "the red jacket", and get its mask. Nothing to paint. The node shows what it found, tinted on the picture, with how sure it is, and **FIND** runs only this node so you can check the mask before the rest of the workflow runs. When it finds nothing it stops the run with a plain message, so nothing after it runs on an empty mask; a setting passes an empty mask on instead.
+
+It also returns the thing cut out on a see-through background, and how many things matched. Under **More**: how sure SAM 3 must be, fill the holes in the mask, and free SAM 3 from VRAM after the search. If you build a workflow that loads a big model after this node, turn **Free VRAM** on. The search is ComfyUI's own SAM 3: wire `model` and `clip` from a Load Checkpoint that loads the SAM 3 file. Needs ComfyUI 0.20 or newer, which has SAM 3 built in.
+
+The Mask by Name example finds a thing by its name and saves its cut-out and its mask, with a Workflow Switches card to skip either one. [Open the Mask by Name workflow →](example_workflows/Mask%20by%20Name%20%28AusBoss%29.json)
+
+### Mask by Touch
+
+Click a thing on the picture and get its mask. No name to type and no MaskEditor: the picture is on the node. Move the pointer over it and the thing a click would take lights up, with its name beside the pointer: the jacket, not the whole person. Click to pick it, and click more things to add them. What is lit in teal is what the mask will be.
+
+![Mask by Touch on a photo of a woman in a pink fur coat under neon signs: pointing lights up her face, hair and coat, clicks pick the coat and the hair, the eye shows the cut-out, and Subject with Fine edges cuts out the whole person with every strand of hair.](assets/readme/mask-by-touch.gif)
+
+When a click could mean more than one thing, the node shows the pick with two arrows, like **‹ jacket · 1 of 3 ›**: an arrow swaps it for the next thing at that spot. A stroke across two things, like both shoes, takes both. Ctrl-click a thing to take it away again.
+
+To fix the mask by hand, switch **Pick | Paint | Erase** (or press W, B or E, as in Photoshop). The brush has a size and a soft edge, set with **[** and **]** or by holding Alt and the right mouse button and dragging, and it shows under the pointer as it will paint. Hold **Ctrl** for the opposite: erase while you paint, paint while you erase.
+
+Every area has a chip under the picture: a thing you picked, or an area you painted. Paint that touches an area joins its chip, and erasing makes none. A chip's cross takes that area away, a click selects it so what you paint joins it, and **all 3** on a named pick takes every thing of that name. The field at the end of the row takes a name you type, for things that did not light up.
+
+**Subject** picks the picture's main subject in one click, and **Background** everything else. **Fine edges** is for hair and fur: switched on, the outline of the subject is followed strand by strand, on light and dark backgrounds, and the cut-out loses the colour of the old background. All three use ComfyUI's own background-removal model (`birefnet.safetensors`, ComfyUI 0.21 or newer); the help page says where to get it.
+
+**Grow** and **Soften** show on the picture while you drag them. Under **More**: Smooth, Fill small holes, Invert, what to do when nothing is picked, and Free VRAM. The eye beside Undo and Clear hides everything else to show the result, as a cut-out or as the mask.
+
+It also returns the picked area cut out on a see-through background, and the names of what was picked as text. The search is ComfyUI's own SAM 3: wire `model` and `clip` from a Load Checkpoint that loads the SAM 3 file. Needs ComfyUI 0.20 or newer, which has SAM 3 built in. The [help page](js/docs/AUSBOSS_NODES_MaskByTouch.md) has the keys and the details.
+
+The Mask by Touch example loads a picture, lets you click what you want, and saves its cut-out and its mask, with Fine edges on. [Open the Mask by Touch workflow →](example_workflows/Mask%20by%20Touch%20%28AusBoss%29.json)
+
+The Qwen Image 2.1 Inpaint example uses the same click to change one thing: click it, say what it should become, and only that part is repainted. [Open the Qwen Image 2.1 Inpaint workflow →](example_workflows/Qwen%20Image%202.1%20Inpaint%20%28AusBoss%29.json) · [Watch it on YouTube →](https://youtu.be/iMgaiXoB0v4)
+
+### Mask Refine
+
+Grows or shrinks a mask, blurs it, fills holes, smooths jagged edges, and sets black and white points. The card shows Expand and Blur, and **More** opens the rest. **AUTO** picks expand and blur values from the mask's size. The optional preview shows the result.
+
+It returns the refined mask and its inverse. The `guided filter` and `matting` edge modes use a guide picture and each need an optional extra (see [Optional extras](#optional-extras)). The default, `off`, needs nothing extra.
+
+### LaMa Inpaint
+
+Removes what is under the white part of a mask and fills the hole from the surroundings, using a local LaMa model. Pixels under black stay as they are. One mask can cover a whole batch, and video frames go through one at a time to keep VRAM use down. The preview can show frames as they finish, or be switched off.
+
+Put `big-lama.pt` in `ComfyUI/models/lama/`. It works one frame at a time, so a hard texture in a video may need more cleanup across frames. The old `SimpleWatermarkRemover` node id still loads, so older workflows keep working. [Try the Simple Video Watermark Remover example →](example_workflows/Simple%20Video%20Watermark%20Remover%20%28AusBoss%29.json)
+
+### Crop For Inpaint
+
+Crops the masked area plus some of what's around it, and can resize the crop to a target size or megapixel budget. It returns the cropped `image`, the `mask` the model paints in, and a `stitcher`. The card shows the usual mask and blend settings, and target size and canvas extension fold behind a disclosure.
+
+The mask and the blend are separate. Growing or blurring the mask changes what the model can repaint, and the blend margin changes how the result joins the original. Raise **Context** or **Extra context** when the model needs to see more around the area. **Stay in picture**, on by default, stops the crop at the picture's edges. The `extend_*` controls grow the canvas for outpainting.
+
+### Stitch Inpaint
+
+Puts a generated crop or outpaint back into the original, using the stitcher from Crop For Inpaint, Load Image + Pad or any Crop + Rotate + Pad node. Everything outside the blend area keeps the stitcher's original pixels exactly. A video stitcher carries every original frame.
+
+For a turned picture, or an outpaint with Tone match off, set **Seam** to **blend in** in the card's gear menu. It fades the model's picture into yours with no tone shift. **Tone match** evens out color steps at the seam. **Fix edge halo** cleans up a rim that got blended twice. It needs the optional matting extra, and without it the node warns and stitches normally. The [help page](js/docs/AUSBOSS_NODES_StitchInpaint.md) explains the stitcher and batches.
+
+## Models and conditioning
+
+### LoRA Loader
+
+A whole LoRA stack in one node. Each row has an on switch, a searchable picker for the file and a strength you scrub. The strength bars share one scale, so the rows are easy to compare, and switching off the strongest row rescales the rest. Model and CLIP strengths can be split, and the CLIP input is optional.
+
+The toolbar has the stack toggle, saved templates, reconnect and settings. The toggle turns the whole stack off, and back on to the rows you had on. **Absorb chain LoRAs** in the settings menu moves a chain of other LoRA loaders into this stack, in the order they applied, repeats included. It bypasses the old loaders only when every MODEL, CLIP and other connection can be kept. A shared branch or linked stack settings leave the chain alone.
+
+![LoRA Loader absorbs a connected LoRA chain, shows strength changes while scrubbing, and restores the previous toggle selection.](assets/readme/lora-chain-demo.gif)
+
+Each LoRA gets an info card from the file's metadata, a `.civitai.info` file next to it, and words you save yourself. The card's **Fetch Civitai info** button looks the file up on Civitai (your browser asks civitai.com, only when you click) and saves the answer as that `.civitai.info` file. Files Civitai doesn't know, such as unpublished or hidden models, come back as not found. The trigger words you pick come out of the `triggers` output. The same click saves the LoRA's picture from Civitai next to the file, so hovering the LoRA shows it (PG-13 or milder unless you allow more in the gear menu; a picture you already have is never replaced).
+
+In the **+ LoRA** list, tick several files to add them at once. Rows can be gathered into groups, like layer groups in an image editor: each group folds away, and has its own switch that turns all its LoRAs off while each one keeps its own setting. A Workflow Switch can turn a whole group on and off.
+
+When a file has moved, the node finds it by name if only one file matches. A missing LoRA that is switched on stops the run by default. Turn off **Stop on missing LoRA** to warn and skip it instead. A LoRA that changes nothing in the model gets a warning with its file name.
+
+### Krea 2 Encode
+
+Krea 2's positive and negative prompts in one card. Connect a VAE and reference pictures, and it adds them as references too, resized for the model first. **VLM reference** sets whether the text encoder also looks at them. Leave the references empty for plain text to image. For an outpaint, connect the pad node's mask too: the model then sees the new area in your picture's own colour instead of gray, so it paints it rather than keeping a gray frame.
+
+The prompt box takes several lines and a linked text. The [help page](js/docs/AUSBOSS_NODES_Krea2Encode.md) covers preparing references. With an outpaint LoRA, copy the wiring from the matching example.
+
+### Krea 2 Outpaint Model Patch
+
+Tells Krea 2 where a reference picture sits on the canvas. It's made for Krea 2 outpaint LoRAs, and the two that exist want different placements. Put it after the LoRAs and before the sampler, and connect a stitcher and the reference conditioning from Krea 2 Encode.
+
+The card has **Reference** placement and **KV cache**. The placement has to match the LoRA:
+
+- **Whole canvas + AnyPaint:** the padded picture is the reference, VLM reference is on, the pad mask goes into Krea 2 Encode's `mask`, and a masked starting latent keeps the known pixels. Several sides can extend in one pass. The Krea 2 Outpaint example works this way.
+- **Source rectangle + Registered Outpaint:** use the unpadded reference with VLM reference off. The source has to span the whole canvas in one direction, so extend left and right, or top and bottom, in each pass, including any padding added for rounding.
+
+![A 16:9 photo of a woman at a waterfront railing is padded to 4:5, and Krea 2 fills in more sky above and the railing below.](assets/readme/krea2-outpaint.gif)
+
+Here Krea 2 Outpaint takes a 16:9 photo to 4:5 in one pass. [Open the Krea 2 Outpaint workflow →](example_workflows/Krea%202%20Outpaint%20%28AusBoss%29.json)
+
+The patch relies on ComfyUI's internal attention code. Its [help page](js/docs/AUSBOSS_NODES_Krea2OutpaintModelPatch.md) explains both setups and what happens without reference conditioning.
+
+## Workflow utilities
+
+Core ComfyUI has its own nodes for most of these jobs, and they work fine. These versions add the extras described under each one.
+
+### Latent Size
+
+Sets a canvas size. Pick landscape or portrait, a ratio and a megapixel budget, or drag the canvas handles. Orientation stays separate from the ratio, even on square. Typed sizes stay exact, and how drags snap is adjustable. It was called Resolution Master before 2.4.0.
+
+It returns `width`, `height` and an empty image latent. The gear picks the latent layout (4, 16 or 128 channels) and the batch size. The latent's size rounds down to whole latent cells, so pick sizes that suit the layout when you wire the latent to a sampler. For video, use `width` and `height` with the model's own video latent node.
+
+![Latent Size with a 1344 by 768 landscape canvas, its ratio chips, and the size and megapixel controls.](assets/readme/controls-showcase.webp)
+
+### Layout Boxes
+
+Draw boxes on a canvas and say what goes in each one: a thing, or words to write in the picture. Wire `elements` to MOSS-Image Layout Prompt and the picture puts each thing where its box is. It does what ComfyUI's own Create Bounding Boxes does, with the same inputs and the same outputs from the same boxes, and its canvas also works in the classic node look.
+
+Drag to draw a box, drag it to move it and its handles to size it; under the canvas each box gets **object** or **text**, its words and up to five colors. A picture on `background` shows under the boxes and sets the canvas size, `width` and `height` can come from Latent Size, and boxes on the `bboxes` wire fill the canvas when the workflow runs. **Grid** snaps the boxes as you drag them, starts off over a picture and takes its size from the gear, **Layouts** starts from a ready arrangement, the arrow keys move the chosen box one pixel at a time (ten with Shift), and Delete and Ctrl + D remove and copy it.
+
+The `mask` output is white inside every box: load a picture, draw a box over the words on a sign, and an inpaint chain can write new words there while the rest of the picture stays as it was. For words at a slant, drag the round handle over a box to turn it: the mask turns with it, and a turned text box tells the model its slant.
+
+![Layout Boxes over a photo of a woman in front of a neon ramen sign: a text box is drawn over the sign, AUSBOSS and red neon letters are typed in, and MOSS-Image's result wipes in with the sign reading AUSBOSS.](assets/readme/layout-boxes.gif)
+
+### Seed
+
+One seed for several samplers. **Random**, **Fixed** and **Step** set what happens after each run. Switching to Random, or from Fixed to Step, changes the seed right away, so the next run is a new one. **New seed** rolls a value and keeps it. **Use last run** brings back the seed the last run actually used. The history menu keeps the last eight seeds and saves them with the workflow.
+
+### Select Every Nth
+
+Keeps every nth picture of a batch, after an offset that counts from 0. With nth 2, offset 0 keeps frames 1, 3 and 5, and offset 1 keeps 2, 4 and 6. The order stays the same. Wire the batch's fps in, and the `fps` output is divided by nth, so the thinned clip still lasts as long.
+
+### Split Batch
+
+Splits a batch after a frame number, counting from 1. Output `a` ends with that frame, and `b` gets the rest. Each side needs at least one frame, so a split point that breaks that stops with an error that gives the valid range.
+
+### Merge Batches
+
+Puts batch `b` after `a`. When the sizes match, nothing is resized. When they differ, it resizes to a's size or b's size, or stops with an error, whichever you pick. Both need the same number of channels.
+
+### Text
+
+A text box that grows with the node and sends its text, unchanged, down a `STRING` wire. Use it for a prompt, caption, path or other text that several nodes share. Spaces and line breaks are kept. Ctrl + Up and Ctrl + Down change the weight of the selected words, as in ComfyUI's own prompt boxes.
+
+### H3 Prompt Writer
+
+Type what happens, one line for each moment, and leave a blank line to cut to a new place. Connect up to four pictures and give each one a job: a person, a place, an outfit, a thing or a style. Copy the moves from a video, keep a clip going, or add a voice or a song. A timeline on the node shows when each moment plays before you run it. It needs no extra model and you never see H3's prompt format. Connect a small text model and it fills in a one-line idea.
+
+**Change something** edits the named part of a video while keeping its person and sound. For a person swap, an optional `@1 looks like ...` line describes the connected replacement. Jobs that keep the source clip's length show **From the clip**; the `keeps_clip_sound` output helps a workflow choose the source audio.
+
+### Integer
+
+One whole number (`INT`) on a scrub control, for sharing a size, count or other whole number across nodes. Like every number box in the pack, it takes a typed sum: `1024*1.5`.
+
+### Float
+
+One decimal number (`FLOAT`) on a scrub control, for sharing a strength, scale, frame rate or duration across nodes.
+
+### Math Expression
+
+Works out a number from linked `a`, `b` and `c` inputs, each an integer or a decimal. An input left unwired counts as 0. It handles arithmetic plus `min`, `max`, `abs`, `round`, `floor`, `ceil` and `sqrt`, for example `a * 2` or `ceil(a / 32) * 32`. It returns a float and a rounded integer, and halves round away from zero. The expression is parsed, never run as Python code.
+
+### Show Text
+
+Shows what arrives on a wire, in a panel you can select from and resize: text, a number, or any other value. Text is passed on unchanged, and a number comes out as text. The last text shown saves with the workflow. Very long text may be cut short on screen, but the output keeps all of it. It runs as an output node, so nothing has to be connected after it.
+
+### Free Memory
+
+Passes any value through and, on the way, unloads ComfyUI's cached models, runs Python's garbage collection and clears the CUDA cache where there is one. Put it between two heavy stages when the second one needs the room. It runs only when its input changes, like any cached node, and later stages may take longer while models load again.
+
+### Workflow Note
+
+A setup card for a shared workflow: a title, instructions in Markdown, each model's download link and folder, the node packs it needs, and your links. It checks the models and packs against the install it's opened in. **Edit** changes the card, and **Banner** turns it into a small section title. The note never runs, and its text is never shown as raw HTML.
+
+### Callout
+
+A note for the canvas whose text grows to fill it, so it reads without zooming in. Double-click to type; a blank line starts a new point and `**two stars**` stress a word. Type an arrow emoji such as ⬆️ and it turns into a teal arrow in the middle of the line. Click a node while you edit, then press an arrow, and the arrow is linked to that node: click it later and the canvas brings the node into view. It never runs and has no wires.
+
+### Compact note and link tiles
+
+**Callout Tile** shows a compact title or colored YouTube/Discord link button. **Workflow Note Tile** opens a full help note from a compact button. They reuse the note editors and save as distinct node types, so an older install reports a missing node instead of drawing an incompatible plain note. Install or update ComfyUI-AusBoss, restart ComfyUI and reload when either tile is missing. Existing ordinary notes and callouts keep their original types.
+
+### Run Timer
+
+A stopwatch for the whole run, with no wires. It starts when the queue starts running, holds the total when the run ends, and saves the last time with the workflow. Recent times are in its right-click menu. You can resize it. It only shows time and doesn't change how the graph runs.
+
+### Step Preview
+
+Shows the picture while it is being made, one step at a time, so you can stop a run that is going wrong after the first few steps. It has no wires: put it anywhere and it shows whichever sampler is working. **STOP** stops this run; **STOP ALL** also empties the queue. When the picture is saved, the finished picture replaces the last step. It turns on ComfyUI's step pictures for its own runs, unless you chose a preview method yourself. The [help page](js/docs/AUSBOSS_NODES_StepPreview.md) covers sharper step pictures.
+
+### Workflow Switches
+
+Turns parts of a workflow off and on from one small card. Select the nodes of one part, such as a box and its Save Image, press **+ Switch**, and they get one **off | on** switch with a name you choose. To pick between settings instead, set a node and press **+ Choice** for each way: the card becomes one pill. Every group can have a switch of its own too. Off bypasses the nodes, so a step in the middle of a chain can be skipped and the picture still reaches the steps after it; a setting mutes them instead. A switch can change settings instead: save what chosen nodes hold for on and for off, and one click sets Steps to 8 and turns a LoRA row on. **Done** shrinks the card to the labels and their switches. A row whose nodes are only partly on reads **mixed**. The node never runs and has no wires. An AI agent can set one up for you: point it at the [agent guide](js/docs/agents/workflow_switches.md).
+
+## Example workflows
+
+These are the workflows where the nodes do something core ComfyUI doesn't do by itself: outpainting and inpainting that put your original picture back, lining an edit back up with its source, upscaling a picture in tiles, masking a thing by its name or with a click, and removing a watermark from a clip. Open a JSON file from [`example_workflows/`](example_workflows), or find them under this pack in ComfyUI's template browser. Each one has a thumbnail, numbered groups and a Workflow Note with the setup steps and model downloads.
+
+![The Krea 2 Rotate + Outpaint workflow: a setup note on the left, then groups for your input, the two boxes and the model loaders, and the result with a before-and-after slider and Save Image.](assets/readme/workflow-layout.webp)
+
+The examples use this layout: named groups for your input, the models and the result, with the plumbing inside two boxes you can double-click to open.
+
+The workflows open with their image and video loaders empty, so you load your own picture or clip. To try one with a sample first, copy the pier photo or the short pier clip from [`example_workflows/inputs/`](example_workflows/inputs) into `ComfyUI/input/`. If you keep models in subfolders, pick your copy in each loader before you run. A green model check on the note only means the file exists; it doesn't mean the loader has that file selected. The models' licenses and any download terms are their authors'.
+
+| Workflow | What it does | What you need |
+|---|---|---|
+| [Krea 2 Outpaint](example_workflows/Krea%202%20Outpaint%20%28AusBoss%29.json) | Pick a ratio or drag the orange handles out, and Krea 2 paints the new area | Krea 2 Turbo and the AnyPaint LoRA; its text encoder also writes the caption |
+| [Krea 2 Inpaint Masked](example_workflows/Krea%202%20Inpaint%20Masked%20%28AusBoss%29.json) | Paint over part of a picture, say what goes there, and Krea 2 repaints only that | Krea 2 Turbo and the AnyPaint LoRA |
+| [Krea 2 Rotate + Outpaint](example_workflows/Krea%202%20Rotate%20%2B%20Outpaint%20%28AusBoss%29.json) | Turn, crop and pad a picture, and Krea 2 paints the new area | Krea 2 Turbo and the AnyPaint LoRA |
+| [Klein 9B Outpaint](example_workflows/Klein%209B%20Outpaint%20%28AusBoss%29.json) | Extend a picture with the PixaOutpaint LoRA, then stitch the original back | Distilled Klein 9B, its Qwen encoder and the Flux 2 VAE, the PixaOutpaint LoRA, and Qwen3-VL 8B INT8 for the caption |
+| [LTX 2.3 Video Outpaint](example_workflows/LTX%202.3%20Video%20Outpaint%20%28AusBoss%29.json) | Widen a vertical clip, keeping its audio and original pixels | LTX 2.3, the distilled LoRA and the outpaint IC-LoRA |
+| [Qwen Image 2.1 Edit + Realign](example_workflows/Qwen%20Image%202.1%20Edit%20%2B%20Realign%20%28AusBoss%29.json) | Type a short edit, and Realign to Source lines Qwen's result back up with your picture | Qwen Image 2.1 INT8, Qwen3-VL 8B INT8 and the 2.1 VAE |
+| [Qwen Image 2.1 Upscale + Restore](example_workflows/Qwen%20Image%202.1%20Upscale%20%2B%20Restore%20%28AusBoss%29.json) | Load a small or worn photo, set the megapixels, and Qwen redraws it sharp, in tiles above about 2 | Qwen Image 2.1 INT8, Qwen3-VL 8B INT8, the 2.1 VAE, the Restore LoRA and, for Fast, the Viggle Turbo LoRA |
+| [Qwen Image 2.1 Inpaint](example_workflows/Qwen%20Image%202.1%20Inpaint%20%28AusBoss%29.json) | Click a thing in your picture, say what to change, and Qwen repaints only that part | Qwen Image 2.1 INT8, Qwen3-VL 8B INT8, the 2.1 VAE, ComfyUI's own SAM 3.1 and, for Fast, the Viggle Turbo LoRA |
+| [Mask by Name](example_workflows/Mask%20by%20Name%20%28AusBoss%29.json) | Type what to find in a picture, and get its mask and a cut-out with a see-through background | ComfyUI's own SAM 3.1 (ComfyUI 0.20 or newer) |
+| [Mask by Touch](example_workflows/Mask%20by%20Touch%20%28AusBoss%29.json) | Click a thing in a picture, or its whole subject, and get its mask and a cut-out with hair-fine edges | ComfyUI's own SAM 3.1 and its background-removal model (ComfyUI 0.21 or newer) |
+| [Simple Video Watermark Remover](example_workflows/Simple%20Video%20Watermark%20Remover%20%28AusBoss%29.json) | Find an overlay in a clip and remove it, with a one-frame comparison branch | ComfyUI's own SAM 3.1 (ComfyUI 0.20 or newer), plus `big-lama.pt` |
+
+Every example uses only core nodes and this pack. Speed and memory use depend on the models, the sizes, the frame count and whatever else is using the GPU.
+
+## For workflow creators
+
+If you share workflows, a few of these nodes help the people who download them:
+
+- **Workflow Note** puts a setup card on the canvas with each model's download link, folder and size, the node packs it needs and your links, and checks them against the reader's install.
+- **Callout** is a note with big readable text and teal arrows you type with an emoji.
+- **Image Compare A/B** shows the result against its source with a slider.
+- **Seed** keeps runs repeatable, and **Use last run** brings back the seed the last run used.
+- **Run Timer** shows how long the whole run took, so a speed note is measured.
+- **Save Image** embeds the workflow in PNG, lossless WebP or JPEG XL files, with names you control.
+- **Workflow Switches** gives each optional part of your workflow one off | on switch, so people skip what they don't need without breaking the chain.
+- **Free Memory** between two heavy stages, and **Free VRAM** on Mask by Name and Mask by Touch, give the next model its room on a smaller graphics card.
+
+People who download your workflow get the nodes through ComfyUI-Manager's missing-node install, like any other pack.
+
+## Pack-wide tools
+
+- **Help cards:** the **?** in a classic node's title bar opens its description, inputs and outputs. Nodes 2.0 and titleless nodes such as Run Timer have **About this node** in their right-click menu.
+- **Recreate node 🆎** (right-click an AusBoss node) rebuilds a node saved by an older version from the current definition. It keeps the values, links, position and colors.
+- **Replace with AusBoss nodes 🆎** (canvas right-click or the command palette) finds third-party nodes this pack can stand in for, such as VideoHelperSuite's Load Video and Video Combine or KJNodes' Color Match. It previews each swap and replaces the ones you leave ticked.
+- **Snap into line:** a node, group or selection you drag lines up with the nodes and groups around it, edge to edge or middle to middle, and a teal line shows what it lines up with. Pulling a corner to resize lines up the same way. Hold Shift while you drag to skip it, or turn it off in Settings → 🆎 AusBoss → Canvas.
+- **Line up:** select two or more nodes or groups and the selection toolbar gets a Line up button: line up edges or middles, match widths or heights, or space them evenly. With two or more nodes selected, pulling the edge or corner of one resizes them all: a column gets one width, a row one height, a grid both (turn it off in Settings → 🆎 AusBoss → Canvas → Resize together).
+- **Node colors:** Settings → 🆎 AusBoss → Appearance sets the scheme for every AusBoss node (AusBoss, Graphite, Slate, Teal, Moss, Plum, Rust, Navy, Custom or Theme default). A node's right-click **AusBoss color** menu recolors just that node, and nodes you colored by hand keep their colors.
+- **Run status:** under Settings → 🆎 AusBoss → Chrome, the queue status can show in the browser tab's title and icon, running nodes get live progress badges, and each node's run time can be shown.
+- **Completion sound:** Settings → 🆎 AusBoss → Notifications plays a short chime when the queue finishes.
+
+## Editor controls and settings
+
+- Drag a number box to scrub it, or click it to type. Hold Shift for fine steps.
+- Hold Shift while you turn the green rotation handle to snap to 15° steps.
+- In the full-screen editor, the mouse wheel zooms, and the middle mouse button or Alt-drag pans. On the node itself, the wheel and middle mouse button still move the graph.
+- **Alt+E** opens the selected node's transform editor. Change the key in Settings → Keybindings.
+- The video editors have frame stepping, playback and exact timeline seeking, on the node face as well as in the editor. The Clip node's IN and OUT handles sit on the source's own frames, so the frame shown for IN is the first one decoded and the frame shown for OUT is the last.
+- Your own aspect presets go in `ausboss_presets.json` beside the pack. Copy [`ausboss_presets_example.json`](ausboss_presets_example.json) to start. Your file survives updates.
+
+LoRA Loader and Latent Size have their own gear menus for per-node preferences.
+
+The video transform nodes read a video you pick from a list of ComfyUI's input folder (Uploads) or output folder (Outputs), never one named by a whole path, and Save Image writes only inside the output folder. No widget can point the pack anywhere else on the disk. See [the video transform help](js/docs/AUSBOSS_NODES_VideoCropRotatePad.md).
+
+## Optional extras
+
+Three features need an extra Python package. Install it with the Python that runs ComfyUI. For the Windows portable build, that is `python_embeded\python.exe -m pip install ...` from the portable folder.
+
+```bash
+python -m pip install opencv-contrib-python   # Mask Refine: guided filter
+python -m pip install "pymatting>=1.1"        # Mask Refine: matting; Stitch Inpaint: edge halo
+python -m pip install pillow-jxl-plugin       # Save Image: lossless JPEG XL
 ```
 
-After updating frontend files, hard-refresh the browser with `Ctrl+Shift+R`.
+The default mask settings, ordinary stitching, PNG and lossless WebP don't need them. Optical flow needs RAFT weights on disk, and the node's help page explains the setup. Which video codecs you have depends on your ComfyUI environment.
 
-## Quick start
+## Compatibility and development
 
-1. Add either transform node.
-2. Pick or upload a source. For very large videos, switch the video node to `local path` mode.
-   Queued workflows always read local paths, but the editor's live preview of paths outside
-   ComfyUI's own folders is opt-in: start ComfyUI with `AUSBOSS_TRANSFORM_LOCAL_PREVIEW=1`
-   to enable it. This keeps the preview routes from exposing arbitrary files to anything
-   that can reach your ComfyUI server (for example on `--listen`).
-3. Click **Open editor**.
-4. Drag cyan crop handles, orange padding handles, or the green rotation handle.
-5. Close the editor and connect `image` and `mask` downstream.
+The pack needs ComfyUI **0.27.1** or newer. An example for a newer model needs a ComfyUI core that supports that model, and updating only this pack can't add it. Every night it is checked against the newest ComfyUI release and ComfyUI's development version. It works on the classic canvas and in Nodes 2.0, and running a workflow doesn't need an editor open.
 
-Use the matching examples in [`example_workflows`](example_workflows) as small starting graphs.
-
-## Editor controls
-
-- Eight crop handles with generous hit targets
-- Four visually distinct padding handles
-- Rotation handle with alignment grid and `Shift` snapping to 15 degrees
-- Free or ratio-locked crop
-- Mouse-wheel zoom; middle-mouse or `Alt`-drag pan
-- Reset view, reset padding, and reset all
-- Video first/last, ±1, ±25, ±50, ±100, playback, and timeline scrubbing
-
-## Settings
-
-Under **Settings → 🆎 AusBoss** you can pick an **AusBoss node color** scheme
-(Graphite, Slate, Teal, Moss, Plum, Rust, Navy, or **Custom** with your own
-picked tint). It recolors every AusBoss
-node in the open workflow immediately and applies to nodes you add later.
-Nodes you have colored by hand keep their own colors, and **Theme default**
-returns everything to the stock look. Right-click any AusBoss node for a
-per-node **AusBoss color** override, and press **Alt+E** (rebindable in
-Settings → Keybindings) to open the selected transform node's editor.
-
-Custom crop aspect-ratio presets live in an optional `ausboss_presets.json`
-next to the pack — copy `ausboss_presets_example.json` to start; your file is
-gitignored and survives updates.
-
-Under **Chrome**: the browser tab's icon and title can show rendering state
-and queue depth (on by default), **live status badges** report progress on the
-node itself while it works — `frame 43/120` through a video inpaint — (on by
-default), and optional **node runtime badges** stamp each node with its seconds
-after a run (off by default).
-
-## Compatibility
-
-- Classic V1 node definitions for broad ComfyUI compatibility
-- Classic canvas and Nodes 2.0 frontend support
-- API-mode execution does not require the editor to be open
-- Transform editors validated on ComfyUI `0.27.1`; the pack scaffold was also validated on `0.28.0`
-
-The declared minimum is ComfyUI `0.27.1` (`supported_comfyui_version` in `pyproject.toml`, which ComfyUI-Manager enforces at install time). If a frontend update changes custom-widget behavior, please include your ComfyUI and frontend versions in the issue.
-
-## Development
+Backend changes need a full ComfyUI restart, and frontend changes need a hard refresh. Run the backend tests with ComfyUI's Python:
 
 ```bash
 python scripts/validate_nodes.py
 python scripts/release_preflight.py
-python -m unittest discover -s tests -p "test_*.py" -v
+python scripts/run_python_tests.py
 node --test tests/*.test.mjs
 ```
 
-See [`AGENTS.md`](AGENTS.md) for compatibility rules and [`docs/adding_a_node.md`](docs/adding_a_node.md) for the node checklist.
+The backend tests run in separate processes, because their offline ComfyUI stubs must not leak between files. [CONTRIBUTING.md](CONTRIBUTING.md) covers bug reports and pull requests. [`docs/live_testing.md`](docs/live_testing.md) covers canvas, mouse-drag, save and reload, and workflow checks, and [`docs/adding_a_node.md`](docs/adding_a_node.md) lists what a new public node needs.
+
+## Feedback
+
+Bug reports and workflow ideas are welcome in [issues](https://github.com/ausboss/ComfyUI-AusBoss/issues). Security problems go through [SECURITY.md](SECURITY.md). Every release is in the [changelog](CHANGELOG.md). If a node saves you time, a star on GitHub helps other people find it. There is also a [Ko-fi page](https://ko-fi.com/ausboss) if you want to leave a tip.
 
 ## License
 

SECURITY.md

@@ -0,0 +1,70 @@
+# Security
+
+ComfyUI answers `/prompt` and custom-node routes without a login, so anyone
+who can reach a ComfyUI server can queue a workflow or call a node's route.
+This pack treats every widget value and route parameter as untrusted and
+follows a few fixed rules.
+
+## What the pack does and does not do
+
+- **Files stay inside ComfyUI's folders.** Save Image writes only to
+  ComfyUI's output folder or a subfolder of it, and Save Video checks its
+  prefix and final file the same way. Image Compare's Erase save and Align
+  never take a file to read from the browser: they work on the two previews
+  that node made in its last run, and Align writes its lined-up copy of B
+  beside them in ComfyUI's temp folder. The name typed for the new files is a plain name
+  with no folder in it, and they go straight into the output folder. Load Video, Load Image + Pad
+  and Image Crop + Rotate + Pad pick from the input folder, and take a file ComfyUI made by
+  the name it gives it (`photo.png [output]`), as core Load Image does; the video transform
+  nodes read a video picked from a list of the
+  input or the output folder, by the name ComfyUI gives it there
+  (`clip.mp4 [output]`), and their uploader streams into the input folder.
+  No input opens a whole path as given. Absolute paths, `..`, `~`, Windows drive and
+  alternate-stream syntax, UNC paths and symlinks that lead outside those
+  folders are refused.
+- **Routes answer with data, not files.** The pack's routes send JSON and
+  small pictures made for the request (a video frame, a gallery tile, a
+  LoRA's preview). The only files sent as they are on the disk are the
+  pack's own scripts. An error message never names a place on the server's
+  disk.
+- **The server makes no network requests.** The pack's Python code never
+  contacts a host. The one exception is a button you click: LoRA Loader's
+  **Fetch Civitai info** has your browser ask civitai.com about that one
+  LoRA, by its SHA256 hash, and the answer is saved beside the LoRA as
+  `<model>.civitai.info` (inside ComfyUI's LoRA folders). The pack checks
+  that the answer describes the same file before saving it. Nothing is sent
+  until you click, and the button can be turned off in the node's settings.
+  The same click also has your browser download the LoRA's first picture
+  from Civitai's picture server (a small copy, without cookies, rated PG-13
+  or milder unless you allow more). The pack checks it is a picture and
+  saves it beside the LoRA as `<model>.preview.jpg`, never replacing a
+  picture that is there. The gear menu's **Civitai picture** option turns
+  this off.
+- **No code execution.** Math Expression parses its text into an
+  allowlisted syntax tree of arithmetic and a few math functions; it never
+  runs Python source. The pack starts no subprocesses and installs nothing
+  at runtime.
+- **No automatic downloads.** You place model weights (LaMa, RAFT optical
+  flow) yourself; the pack never fetches them.
+- **LaMa opens only known files.** A LaMa model file can run code when it
+  opens, so LaMa Inpaint checks a file's SHA-256 first and opens only known
+  copies of `big-lama.pt`.
+- **No raw HTML from workflows.** Workflow Note renders its Markdown into
+  text nodes, and its links open only `http(s)` addresses.
+
+`scripts/release_preflight.py` fails a release whose shipped code contains an
+HTTP or socket client.
+
+These rules protect a ComfyUI server from the requests it receives. They do
+not defend against someone who can already change files on the ComfyUI
+machine, and exposing ComfyUI beyond a trusted network is still a risk of
+its own.
+
+## Reporting a vulnerability
+
+Report privately through this repository's **Security** tab →
+**Report a vulnerability**. If that option is not offered, open an issue
+asking for a private contact and leave the details out of it.
+
+Fixes land on `main` and ship in the next release; the
+[CHANGELOG](CHANGELOG.md) records security-relevant changes.

__init__.py

@@ -7,35 +7,70 @@ name to NODE_MODULES below — nothing else to wire up.
 
 A module that fails to import is skipped with a console warning instead
 of taking the whole pack down, so one broken node never hides the rest.
+
+Only one copy of the pack loads. People install it from ComfyUI-Manager
+(custom_nodes/ausboss-nodes) and from GitHub (custom_nodes/ComfyUI-AusBoss),
+and two copies used to register the same server routes, which stopped
+ComfyUI at startup. A second copy now loads nothing and says which folder
+to delete.
 """
 
 import importlib
 import os
-import re
+import sys
+import tomllib
 import traceback
+import types
 
-# One entry per file in nodes/. Keep alphabetical-ish; order only affects
-# nothing functional.
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_FIRST_COPY = sys.modules.setdefault(
+    "_ausboss_nodes_first_copy", types.SimpleNamespace(folder=_HERE)
+)
+_IS_SECOND_COPY = _FIRST_COPY.folder != _HERE
+
+# One entry per file in nodes/, kept alphabetical. The order has no
+# functional effect.
 NODE_MODULES = [
     "node_align_image",
+    "node_batch_utils",
+    "node_callout",
     "node_color_match",
     "node_compare",
-    "node_drop_shadow",
-    "node_frame_chooser",
     "node_frame_interpolate",
+    "node_free_memory",
+    "node_h3_prompt_writer",
     "node_image_crop_rotate_pad",
+    "node_image_folder",
+    "node_image_resize",
     "node_image_size",
     "node_inpaint_crop_stitch",
+    "node_krea2_encode",
+    "node_krea2_model_patch",
     "node_lama_inpaint",
-    "node_lmstudio_chat",
+    "node_layout_boxes",
+    "node_literals",
     "node_load_image_pad",
+    "node_load_audio",
     "node_load_video",
     "node_lora_loader",
-    "node_pad_image",
+    "node_mask_by_name",
+    "node_mask_by_touch",
+    "node_math",
+    "node_realign_to_source",
     "node_refine_mask",
+    "node_resolution",
+    "node_run_timer",
+    "node_save_image",
     "node_save_video",
+    "node_seed",
     "node_select_frame",
+    "node_show_text",
+    "node_step_preview",
+    "node_tiled_upscale",
     "node_video_crop_rotate_pad",
+    "node_video_crop_rotate_pad_clip",
+    "node_workflow_note",
+    "node_workflow_switches",
 ]
 
 NODE_CLASS_MAPPINGS = {}
@@ -43,6 +78,8 @@ NODE_DISPLAY_NAME_MAPPINGS = {}
 _failed_modules = []
 
 for _module_name in NODE_MODULES:
+    if _IS_SECOND_COPY:
+        break
     try:
         _module = importlib.import_module(f".nodes.{_module_name}", __name__)
         NODE_CLASS_MAPPINGS.update(getattr(_module, "NODE_CLASS_MAPPINGS", {}))
@@ -55,18 +92,18 @@ for _module_name in NODE_MODULES:
 
 # Folder ComfyUI serves to the browser; every .js file in it is loaded as a
 # frontend extension. Shared modules use .mjs so they are import-only.
-WEB_DIRECTORY = "./js"
+WEB_DIRECTORY = None if _IS_SECOND_COPY else "./js"
 
 __all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]
 
 
-def _read_version():
+def _read_version(folder=None):
     """Version straight from pyproject.toml so it is never duplicated."""
     try:
-        pyproject = os.path.join(os.path.dirname(__file__), "pyproject.toml")
-        with open(pyproject, "r", encoding="utf-8") as f:
-            match = re.search(r'^version\s*=\s*"([^"]+)"', f.read(), re.MULTILINE)
-        return match.group(1) if match else "unknown"
+        pyproject = os.path.join(folder or os.path.dirname(__file__), "pyproject.toml")
+        with open(pyproject, "rb") as f:
+            version = tomllib.load(f).get("project", {}).get("version")
+        return version if isinstance(version, str) and version.strip() else "unknown"
     except Exception:
         return "unknown"
 
@@ -81,6 +118,17 @@ def _print_banner():
     bar = f"{teal}{'-' * 70}{reset}"
 
     print(bar)
+    if _IS_SECOND_COPY:
+        def where(folder):
+            text = f"{os.path.basename(folder)} (v{_read_version(folder)})"
+            return text.encode("ascii", "replace").decode("ascii")
+
+        print(f"  {red}AusBoss is installed twice, so this copy is not loaded.{reset}")
+        print(f"  In use:  custom_nodes/{where(_FIRST_COPY.folder)}")
+        print(f"  Skipped: custom_nodes/{where(_HERE)}")
+        print("  Delete one of the two folders and restart ComfyUI.")
+        print(bar)
+        return
     print(
         f"  {teal}AusBoss{reset} v{_read_version()}  |  "
         f"{len(NODE_CLASS_MAPPINGS)} nodes loaded"
@@ -91,4 +139,12 @@ def _print_banner():
     print(bar)
 
 
+try:
+    if not _IS_SECOND_COPY:
+        from .nodes._frontend_cache import register_frontend_cache_guard
+
+        register_frontend_cache_guard()
+except Exception:
+    traceback.print_exc()
+
 _print_banner()

assets/readme/release.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="105" height="20" role="img" aria-label="release: v2.23.0">
+  <title>release: v2.23.0</title>
+  <path fill="#555" d="M0 0h48v20H0z"/>
+  <path fill="#00b4aa" d="M48 0h57v20H48z"/>
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
+    <text x="24" y="14">release</text>
+    <text x="76.5" y="14">v2.23.0</text>
+  </g>
+</svg>

docs/adding_a_node.md

@@ -20,22 +20,26 @@ Every visible field and output must earn its place. Published IDs, input order,
 
 1. Put independently testable processing in an underscore-prefixed helper under `nodes/`.
 2. Add one V1 wrapper in `nodes/node_<purpose>.py` with `INPUT_TYPES`, `RETURN_TYPES`, `FUNCTION`, `CATEGORY`, and both mapping dictionaries — keys as string literals, never a `NODE_ID` variable, or registry scanners cannot see the node.
-3. Add the module to `NODE_MODULES` in `__init__.py`.
-4. Add frontend JavaScript only when the normal schema cannot provide the required interaction.
+3. Add the module to `NODE_MODULES` in `__init__.py` and the key to `PUBLIC_NODE_IDS` in `scripts/validate_nodes.py`; the validator fails on a registered key it does not know. A key kept only so old workflows load goes in `LEGACY_NODE_IDS` instead.
+4. Give the node its face. Any INT, FLOAT, BOOLEAN, COMBO or STRING widget on a public node is shown through a widget card entry in `js/widget_cards/index.js` (see CONTRIBUTING.md, Conventions: numbers scrub, booleans are off | on pills, one linkable widget per row, `top: true` or `forceInput` for values people wire). Write more frontend JavaScript only when the card grammar cannot provide the interaction (a stage, a player, an editor).
 5. Namespace every route, extension, event, DOM marker, CSS class, cache, and browser state with `ausboss`.
 6. Chain lifecycle hooks through `chainCallback`; never replace core or third-party prototypes directly.
 7. Keep normal workflow and API execution independent from the custom frontend.
-8. Ship user-facing toggles as ComfyUI settings under the `AusBoss.*` namespace (see `.claude/skills/ausboss-node-brand/SKILL.md`). Node coloring is automatic for `AUSBOSS_NODES_*` classes via `js/appearance/` — no per-node work.
+8. Ship user-facing toggles as ComfyUI settings under the `AusBoss.*` namespace. Node coloring is automatic for `AUSBOSS_NODES_*` classes via `js/appearance/` — no per-node work.
+9. A `VALIDATE_INPUTS` names only the inputs it reads, never `**kwargs`. ComfyUI skips its own range and list checks for every input a validator names (naming `input_types` also switches off its link checks), and repeats a failed check once per named input. Checks that need several values can run in the node itself. `tests/test_validate_inputs.py` pins what each validator names.
 
 ## Document and prove
 
-- Add rich help at `js/docs/<exact-mapping-key>.md`.
-- Add a minimal workflow and matching JPEG under `example_workflows/`.
+- Add rich help at `js/docs/<exact-mapping-key>.md` (the validator checks it exists) and a section in `README.md`. Name card controls the way the node face shows them, with the widget name alongside: **Tone match** (`color_match`).
+- Show the node in an example under `example_workflows/`, a new one or an existing one it fits: a Workflow Note, numbered groups holding every node, no overlaps, and a matching `.jpg` of a real output. CONTRIBUTING.md, Example workflows, lists the rest.
+- A DOM panel goes into `tests/panel_guards.test.mjs` as `mustGrow` or `fixedByDesign`.
+- At the next release, name the node in the pyproject `description`: Registry and Manager search read it.
 - Extend `scripts/validate_nodes.py` when the new contract needs a permanent assertion.
+- Add the node to the API snapshot: `AUSBOSS_COMFY_ROOT=<ComfyUI> python tests/test_node_api.py --update` with ComfyUI's Python. From then on its inputs and outputs may only be appended.
 - Add pure Python and dependency-free JavaScript tests.
 - Compile with ComfyUI's embedded Python.
 - Verify `/object_info/<mapping-key>`, ownership, served assets, routes, API execution, and queued dimensions/masks.
-- Test the actual canvas in Classic and Nodes 2.0, including save/reload, duplication, graph zoom, source replacement, and teardown.
-- Scan the diff for paths, hosts, secrets, obsolete branding, placeholders, agent attribution, and non-ASCII import output.
+- Test the actual canvas in Classic and Nodes 2.0, including save/reload, duplication, graph zoom, source replacement, and teardown. Drag a real link onto every card row and socket and look at where it lands (`docs/live_testing.md`).
+- Scan the diff for paths, hosts, secrets, placeholders and non-ASCII import output.
 
 Do not release a node that only works in the editor, only works for one source, or returns debugging outputs users do not need.

docs/live_testing.md

@@ -0,0 +1,95 @@
+# Live frontend testing
+
+Frontend work in this pack is proven on a real canvas: a node is created in a
+real ComfyUI tab, real mouse drags are dispatched, and the result is a
+screenshot a person looks at. Reading the code, or a test that only checks
+which input received a link, has let broken designs through before (three
+sockets stacked on one pixel passed every automated check). This is the
+recipe.
+
+## The pieces
+
+- **ComfyUI** on `http://127.0.0.1:8188` (set `COMFY_URL` to point the
+  scripts elsewhere), with this repository installed or linked into
+  `custom_nodes`. A changed `INPUT_TYPES` is served only after a full
+  restart. Stop the test instance, then start it from the ComfyUI checkout
+  using that installation's Python environment:
+
+  ```bash
+  python main.py --listen 127.0.0.1
+  ```
+
+  From this repository, run `python scripts/run_python_tests.py` with the
+  same environment to isolate ComfyUI stubs and keep CPU thread counts
+  bounded. Set `AUSBOSS_COMFY_ROOT` to the ComfyUI checkout to enable the
+  optional core video integration checks.
+
+- **Headless Chrome or Chromium** on an unused CDP port; these examples use
+  **9334**. Use a separate test profile and the installed browser executable:
+
+  ```bash
+  chromium \
+    --headless=new --remote-debugging-port=9334 --user-data-dir=/tmp/chrome-ausboss \
+    --window-size=1800,1100 --no-first-run --no-default-browser-check about:blank &
+  ```
+
+- **`scripts/dev/`** — small Node scripts that talk CDP directly, with no
+  package dependencies. Use a Node version with built-in `fetch` and `WebSocket`:
+
+  | script | does |
+  |---|---|
+  | `cdp.mjs <port> <workflow.json\|-> <out.png\|-> [eval.js] [waitMs]` | opens/reuses the Comfy tab, optionally loads a workflow, evaluates a JS file, screenshots (a returned `__clip` rect clips the shot), prints the eval result as JSON |
+  | `cdp_drag.mjs <port> <setup.js> <mid.png\|-> <after.png\|-> [check.js]` | `setup.js` returns `{from, to, __clip}` in client pixels; presses at `from`, moves to `to`, screenshots mid-drag, releases, evaluates `check.js`, screenshots again |
+  | `audit_workflows.mjs <port> <output-dir> [workflow.json ...]` | loads every example (or selected files), exports API and loaded graphs, captures screenshots, and fails on overlaps, missing nodes, browser exceptions, or exposed AusBoss number widgets |
+  | `wheel_sweep.mjs <port> [--vue] [--only=Type,Type] [--workflow=file.json] [--shots=dir]` | turns the mouse wheel at every point of every node of the pack (or of the nodes in one workflow) and fails on any spot where the graph does not zoom, naming the element that took the wheel; `--real` sends real wheel turns, slower and on a coarser grid |
+  | `face_smoke.mjs <port> [--vue] [--only=Type,Type]` | puts one of each node of the pack on an empty graph and fails when a face does not come up: no node, a panel that is not on the page or has no size, an error thrown, a file of the pack that did not load. Needs no model, so it also runs in the nightly ComfyUI check |
+  | `cdp_nav_debug.mjs <port>` | navigates the tab in place and logs every CDP event, for when a tab stops answering |
+  | `cdp_hang.mjs <port>` | pre-arms the debugger on a fresh tab, loads ComfyUI, and pauses to print the stack if the page stops answering |
+
+  `CDP_RELOAD=1` closes the Comfy tab and opens a fresh one with the cache
+  cleared — required after editing any `.mjs`, which the frontend caches
+  hard.
+
+## Screenshot convention
+
+An eval creates the node at `pos [0, 0]`, sets `app.canvas.ds.scale = 1` and
+`ds.offset = [160, 230]`, and returns
+`__clip: { x: r.left + 152, y: r.top + 192, width: node.size[0] + 16, height: node.size[1] + 46 }`
+(`r` is the canvas element's bounding rect). A drag gives two shots: `_mid`,
+taken during the drag, and `_after`, the result.
+
+## Gotchas learned the hard way
+
+- **Clearing the graph reuses node ids**, and the frontend's widget store
+  hands a new node the previous node's widget values (a toggled `preview`
+  came back `false`). Bump `app.graph.last_node_id += 50` after
+  `app.graph.clear()`, or set the value you want explicitly.
+- **A real mouse drag marks the workflow modified.** The next in-place
+  navigation raises ComfyUI's `beforeunload` dialog and the whole tab stops
+  answering every CDP call, even `1+1`; it looks exactly like a renderer
+  hang. The scripts auto-accept dialogs, and `CDP_RELOAD=1` makes `cdp.mjs`
+  reload into a fresh tab rather than navigate the old one.
+- **Reset a half-finished link drag** (`app.canvas.linkConnector.reset()`)
+  before clearing the graph in an eval.
+- The mid-drag screenshot shows the socket lit and the tooltip, not the
+  greyed field: the field greys once the link exists, in the `_after` shot.
+- Widget input sockets are drawn only while a link is dragged, hovered, or
+  connected, so a "no socket visible" screenshot at rest is normal; the
+  mid-drag shot is the one that shows where a link can land.
+- `cdp.mjs` and `cdp_drag.mjs` requests time out after 25 s; the workflow
+  audit allows 45 s.
+  Inspect the browser's dialogs and logs when a request stops responding.
+- Keep test renders and logs out of the repository; only deliberately
+  shipped sample media belongs in `example_workflows/inputs/`.
+
+## What to verify for a node face
+
+1. The face at rest (values, alignment, no clipped panel).
+2. Every group disclosure open.
+3. A real link dropped on every row and socket, `_mid` and `_after`.
+4. `app.graphToPrompt()` sends the link for a linked input and the typed
+   value otherwise.
+5. Save, reload (fresh tab), and confirm links, values and hidden state.
+6. The preview switch on and off where the node has one.
+7. The wheel zooms the graph over every part of the face:
+   `wheel_sweep.mjs`, once plain and once with `--vue`.

example_workflows/image_crop_rotate_pad.json

@@ -1,40 +0,0 @@
-{
-  "last_node_id": 2,
-  "last_link_id": 1,
-  "nodes": [
-    {
-      "id": 1,
-      "type": "AUSBOSS_NODES_ImageCropRotatePad",
-      "pos": [120, 180],
-      "size": [360, 390],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {"name": "image", "type": "IMAGE", "links": [1], "slot_index": 0},
-        {"name": "mask", "type": "MASK", "links": [], "slot_index": 1}
-      ],
-      "properties": {"Node name for S&R": "AUSBOSS_NODES_ImageCropRotatePad"},
-      "widgets_values": ["", 0, "free", 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "#808080"]
-    },
-    {
-      "id": 2,
-      "type": "PreviewImage",
-      "pos": [560, 180],
-      "size": [360, 400],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "inputs": [{"name": "images", "type": "IMAGE", "link": 1}],
-      "outputs": [],
-      "properties": {"Node name for S&R": "PreviewImage"}
-    }
-  ],
-  "links": [[1, 1, 0, 2, 0, "IMAGE"]],
-  "groups": [],
-  "config": {},
-  "extra": {},
-  "version": 0.4
-}
-

example_workflows/video_crop_rotate_pad.json

@@ -1,40 +0,0 @@
-{
-  "last_node_id": 2,
-  "last_link_id": 1,
-  "nodes": [
-    {
-      "id": 1,
-      "type": "AUSBOSS_NODES_VideoCropRotatePad",
-      "pos": [120, 150],
-      "size": [360, 455],
-      "flags": {},
-      "order": 0,
-      "mode": 0,
-      "inputs": [],
-      "outputs": [
-        {"name": "image", "type": "IMAGE", "links": [1], "slot_index": 0},
-        {"name": "mask", "type": "MASK", "links": [], "slot_index": 1}
-      ],
-      "properties": {"Node name for S&R": "AUSBOSS_NODES_VideoCropRotatePad"},
-      "widgets_values": ["", "input folder", "", "frame index", 0, 0, 0, "free", 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, "#808080"]
-    },
-    {
-      "id": 2,
-      "type": "PreviewImage",
-      "pos": [560, 150],
-      "size": [360, 400],
-      "flags": {},
-      "order": 1,
-      "mode": 0,
-      "inputs": [{"name": "images", "type": "IMAGE", "link": 1}],
-      "outputs": [],
-      "properties": {"Node name for S&R": "PreviewImage"}
-    }
-  ],
-  "links": [[1, 1, 0, 2, 0, "IMAGE"]],
-  "groups": [],
-  "config": {},
-  "extra": {},
-  "version": 0.4
-}
-

js/align_image/index.js

@@ -1,60 +0,0 @@
-import { app } from "/scripts/app.js";
-import { chainCallback } from "../shared/index.mjs";
-import { setWidgetVisible } from "../shared/widget_visibility.mjs";
-
-const NODE_CLASS = "AUSBOSS_NODES_AlignImage";
-
-// Each anchor/fill widget only means something in its own mode, so the node
-// face stays as compact as before the options existed:
-//   crop_position          -> mode == "crop"
-//   pad_position, pad_fill -> mode == "pad"
-//   pad_color              -> mode == "pad" AND pad_fill == "color"
-function syncOptionWidgets(node) {
-  const widget = (name) => node.widgets?.find((item) => item.name === name);
-  const mode = widget("mode");
-  const padFill = widget("pad_fill");
-  if (!mode) return;
-  const wants = {
-    crop_position: mode.value === "crop",
-    pad_position: mode.value === "pad",
-    pad_fill: mode.value === "pad",
-    pad_color: mode.value === "pad" && padFill?.value === "color",
-  };
-  let changed = false;
-  for (const [name, visible] of Object.entries(wants)) {
-    const target = widget(name);
-    if (target && setWidgetVisible(target, visible)) changed = true;
-  }
-  if (!changed) return;
-  const width = node.size?.[0] ?? 0;
-  node.setSize([Math.max(width, node.computeSize()[0]), node.computeSize()[1]]);
-  node.graph?.setDirtyCanvas?.(true, true);
-}
-
-function watchWidget(node, name) {
-  const widget = node.widgets?.find((item) => item.name === name);
-  if (!widget) return;
-  const previous = widget.callback;
-  widget.callback = function (...args) {
-    const result = previous?.apply(this, args);
-    syncOptionWidgets(node);
-    return result;
-  };
-}
-
-app.registerExtension({
-  name: "AusBoss.AlignImage",
-  beforeRegisterNodeDef(nodeType, nodeData) {
-    if (nodeData?.name !== NODE_CLASS) return;
-    chainCallback(nodeType.prototype, "onNodeCreated", function () {
-      watchWidget(this, "mode");
-      watchWidget(this, "pad_fill");
-      syncOptionWidgets(this);
-    });
-    chainCallback(nodeType.prototype, "onConfigure", function () {
-      // Restored widget values land after creation; re-sync to the loaded
-      // mode without disturbing the size the workflow saved.
-      queueMicrotask(() => syncOptionWidgets(this));
-    });
-  },
-});

js/appearance/index.js

@@ -1,5 +1,4 @@
-import { api } from "/scripts/api.js";
-import { app } from "/scripts/app.js";
+import { app } from "../../../scripts/app.js";
 import {
   CUSTOM_SCHEME,
   DEFAULT_SCHEME,
@@ -10,8 +9,9 @@ import {
   schemeColors,
   shouldRecolor,
   titleInk,
+  wearsLegacyScheme,
 } from "../shared/appearance.mjs";
-import { AUSBOSS_JS_VERSION, chainCallback } from "../shared/index.mjs";
+import { chainCallback, chainHandler, isAusbossNode } from "../shared/index.mjs";
 import {
   BADGE_RADIUS,
   badgeCenter,
@@ -23,6 +23,7 @@ import { openInfoCard } from "../shared/settings_menu.mjs";
 
 const SETTING_ID = "AusBoss.Appearance.NodeColor";
 const CUSTOM_SETTING_ID = "AusBoss.Appearance.CustomColor";
+const COLOR_OVERRIDE = "ausbossColor";
 
 // Stored bare (no "#") to match the color setting's storage contract.
 const DEFAULT_CUSTOM_COLOR = "00b4aa";
@@ -40,42 +41,11 @@ let activeCustomColor = DEFAULT_CUSTOM_COLOR;
 let activeCustomTitle = normalizeHexColor(DEFAULT_CUSTOM_COLOR);
 
 function setActiveCustomColor(value) {
+  if (!normalizeHexColor(value)) return;
   activeCustomColor = value;
   activeCustomTitle = normalizeHexColor(value);
 }
 
-// Surface the stale-cache warning where the user actually looks. On current
-// frontends app.extensionManager is the workspace store, whose `toast` is the
-// toast store: add({ severity, summary, detail, life }) queues a PrimeVue
-// toast. Older frontends without it fall back to the console, and nothing in
-// here may ever throw — this is advice, not a feature.
-function warnStaleJs(serverVersion) {
-  const detail =
-    `Installed pack is v${serverVersion} but this tab is running ` +
-    `v${AUSBOSS_JS_VERSION} JavaScript from the browser cache. Hard-refresh ` +
-    "the tab (Ctrl+Shift+R) to load the updated frontend.";
-  try {
-    const toast = app.extensionManager?.toast;
-    if (typeof toast?.add === "function") {
-      toast.add({
-        severity: "warn",
-        summary: "AusBoss frontend is stale",
-        detail,
-        life: 15000,
-      });
-      return;
-    }
-  } catch (_error) {
-    // Toast store missing or incompatible: the console still works.
-  }
-  console.warn(`[AusBoss] ${detail}`);
-}
-
-function isAusbossNode(node) {
-  const comfyClass = node?.comfyClass || "";
-  return comfyClass.startsWith("AUSBOSS_NODES_") || comfyClass === "SimpleWatermarkRemover";
-}
-
 function applyScheme(node, colors) {
   // Assigning undefined (never `delete`) keeps the property reactive under
   // the Vue-based Nodes 2.0 renderer while still restoring theme defaults.
@@ -88,6 +58,7 @@ function applyScheme(node, colors) {
 function repaintAll(next, previous) {
   for (const node of collectGraphNodes(app.graph)) {
     if (!isAusbossNode(node)) continue;
+    if (Object.hasOwn(node.properties ?? {}, COLOR_OVERRIDE)) continue;
     if (!shouldRecolor(node, previous)) continue;
     applyScheme(node, next);
   }
@@ -178,23 +149,15 @@ app.registerExtension({
     const storedCustom = app.ui?.settings?.getSettingValue?.(CUSTOM_SETTING_ID);
     if (normalizeHexColor(storedCustom)) setActiveCustomColor(storedCustom);
     installTitleInk();
-    // Stale-cache probe: an updated pack served to a browser still running
-    // old cached JavaScript fails in confusing ways, so say so once. Any
-    // network or route failure stays silent — this is advice, not a feature.
-    try {
-      const response = await api.fetchApi("/ausboss/pack_version");
-      const payload = await response.json();
-      const server = payload?.version;
-      if (response.ok && server && server !== "unknown" && server !== AUSBOSS_JS_VERSION) {
-        warnStaleJs(server);
-      }
-    } catch (_error) {
-      // Old backend without the route, offline, or a non-JSON reply: silent.
-    }
   },
   getNodeMenuItems(node) {
     if (!isAusbossNode(node)) return [];
+    // Vue nodes skip the canvas badge callbacks; title-less nodes have no bar.
+    const about = isTitleless(node) || globalThis.LiteGraph?.vueNodesMode === true
+      ? [{ content: "About this node", callback: () => openHelpCard(node, null) }]
+      : [];
     return [
+      ...about,
       {
         content: "AusBoss color",
         has_submenu: true,
@@ -202,12 +165,14 @@ app.registerExtension({
           options: SCHEME_NAMES.map((name) => ({
             content: name,
             callback: () => {
-              // A menu pick writes the colors directly; shouldRecolor then
-              // treats them as the user's choice during setting sweeps.
+              // Keep an explicit choice, including no colors, through saves
+              // and setting changes. Custom stores the pair picked today.
               const colors = schemeColors(name, activeCustomColor);
               // Custom with an unusable stored color resolves to null, which
               // would wrongly read as "Theme default" — do nothing instead.
               if (name === CUSTOM_SCHEME && !colors) return;
+              node.properties ??= {};
+              node.properties[COLOR_OVERRIDE] = colors ? { ...colors } : null;
               applyScheme(node, colors);
               app.graph?.setDirtyCanvas?.(true, true);
             },
@@ -219,20 +184,48 @@ app.registerExtension({
   nodeCreated(node) {
     if (!isAusbossNode(node)) return;
     installHelpBadge(node);
-    // Colors restored from a saved workflow (and manual picks) land before
-    // this hook runs — an already-colored node is left alone.
-    if (node.color || node.bgcolor) return;
-    const colors = schemeColors(activeScheme, activeCustomColor);
-    if (colors) applyScheme(node, colors);
+    restoreAppearance(node);
+    // Construction precedes saved fields; reload, paste and undo restore
+    // their colors and properties before this callback runs.
+    chainCallback(node, "onConfigure", function (saved) {
+      restoreAppearance(this, saved);
+    });
   },
 });
 
-// Every AusBoss node gets a quiet "?" in the title bar; clicking it opens a
-// card built from the node's own DESCRIPTION and tooltips, so the docs on
-// screen are exactly the docs in the source.
+function restoreAppearance(node, saved) {
+  if (Object.hasOwn(node.properties ?? {}, COLOR_OVERRIDE)) {
+    // A later pick in ComfyUI's own color menu is saved in the native fields.
+    if (saved?.color || saved?.bgcolor) return;
+    applyScheme(node, node.properties[COLOR_OVERRIDE]);
+    return;
+  }
+  if ((node.color || node.bgcolor) && !wearsLegacyScheme(node)) return;
+  applyScheme(node, schemeColors(activeScheme, activeCustomColor));
+}
+
+function isTitleless(node) {
+  return (node.title_mode ?? node.constructor?.title_mode) === (globalThis.LiteGraph?.NO_TITLE ?? 1);
+}
+
+function openHelpCard(node, event) {
+  const nodeData = node.constructor?.nodeData;
+  const clientX = event?.clientX ?? window.innerWidth / 2;
+  const clientY = event?.clientY ?? 80;
+  openInfoCard({
+    anchor: { left: clientX - 150, top: clientY, bottom: clientY + 6 },
+    title: node.title || nodeData?.display_name || "About this node",
+    sections: helpSections(nodeData),
+  });
+}
+
+// Classic nodes get a quiet "?" in the title bar. Vue nodes open the same
+// card from their context menu. Its text comes from DESCRIPTION and tooltips.
 function installHelpBadge(node) {
+  // A title-less node (Run Timer) has no bar to hang the badge on; its
+  // card opens from the node's context menu instead.
   chainCallback(node, "onDrawForeground", function (ctx) {
-    if (!showBadge(this.size?.[0] ?? 0, this.flags?.collapsed)) return;
+    if (isTitleless(this) || !showBadge(this.size?.[0] ?? 0, this.flags?.collapsed)) return;
     const [x, y] = badgeCenter(this.size[0]);
     ctx.save();
     ctx.beginPath();
@@ -247,17 +240,10 @@ function installHelpBadge(node) {
     ctx.fillText("?", x, y + 0.5);
     ctx.restore();
   });
-  chainCallback(node, "onMouseDown", function (event, pos) {
-    if (!showBadge(this.size?.[0] ?? 0, this.flags?.collapsed)) return false;
+  chainHandler(node, "onMouseDown", function (event, pos) {
+    if (isTitleless(this) || !showBadge(this.size?.[0] ?? 0, this.flags?.collapsed)) return false;
     if (!pos || !hitsBadge(pos, this.size[0])) return false;
-    const nodeData = this.constructor?.nodeData;
-    const clientX = event?.clientX ?? window.innerWidth / 2;
-    const clientY = event?.clientY ?? 80;
-    openInfoCard({
-      anchor: { left: clientX - 150, top: clientY, bottom: clientY + 6 },
-      title: this.title || nodeData?.display_name || "About this node",
-      sections: helpSections(nodeData),
-    });
+    openHelpCard(this, event);
     return true; // consume the click so it does not start a drag
   });
 }

js/cache_guard/index.js

@@ -0,0 +1,80 @@
+// Notices when this tab is still running old AusBoss files after an update,
+// refreshes them, and asks for a reload. A reload alone is not always enough:
+// browsers may keep reusing the old shared modules (.mjs) for hours.
+//
+// Imports nothing from ../shared on purpose. Old cached copies of those files
+// are the problem this entry has to survive.
+import { api } from "../../../scripts/api.js";
+import { app } from "../../../scripts/app.js";
+
+const PACK_URL = new URL("../", import.meta.url).href;
+const PARALLEL = 6;
+
+async function runningVersion() {
+  try {
+    return (await import("../shared/index.mjs")).AUSBOSS_JS_VERSION;
+  } catch (_error) {
+    return null;
+  }
+}
+
+// Fetching with cache "reload" replaces the browser's stored copy with a
+// fresh one, so the next page load uses the new files.
+async function refreshModules(paths) {
+  const queue = [...paths];
+  const worker = async () => {
+    while (queue.length) {
+      const path = queue.pop();
+      try {
+        await fetch(PACK_URL + path, { cache: "reload" });
+      } catch (_error) {
+        // One file failing to refresh must not stop the rest.
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: PARALLEL }, worker));
+}
+
+function askForReload(installed) {
+  const detail =
+    `AusBoss v${installed} is installed, but this page is still running an older copy. ` +
+    "Press F5 to reload the page.";
+  const toast = app.extensionManager?.toast;
+  if (typeof toast?.add === "function") {
+    // No `life`: the message stays until it is closed. The page keeps running
+    // the old files until it is reloaded, however long that takes.
+    toast.add({ severity: "warn", summary: "AusBoss was updated", detail });
+  } else {
+    console.warn(`[AusBoss] ${detail}`);
+  }
+}
+
+// The installed version this page already asked a reload for. A server that
+// drops and comes back several times must not stack the same message.
+let asked = null;
+
+async function check() {
+  // Advice, not a feature: any network or route failure stays silent.
+  try {
+    const installed = (await (await api.fetchApi("/ausboss/pack_version")).json())?.version;
+    const running = await runningVersion();
+    if (!installed || installed === "unknown" || !running || installed === running || installed === asked) return;
+    asked = installed;
+    const listing = await (await api.fetchApi("/ausboss/pack_modules")).json();
+    await refreshModules(Array.isArray(listing?.modules) ? listing.modules : []);
+    askForReload(installed);
+  } catch (_error) {
+    // Old backend without the routes, offline, or a non-JSON reply.
+  }
+}
+
+app.registerExtension({
+  name: "ausboss.cache_guard",
+  async setup() {
+    await check();
+    // An update from the Manager restarts the server and reloads the workflow,
+    // not the page, so an open tab keeps the scripts it started with. Look
+    // again every time the server comes back.
+    api.addEventListener("reconnected", check);
+  },
+});

js/callout/index.js

@@ -0,0 +1,724 @@
+// Callout 🆎: a note whose text grows to fill it. An arrow typed into the text
+// (an arrow emoji such as ⬆️, a plain arrow, a pointing hand, or -> and <-)
+// shows as a teal arrow sitting in the line.
+//
+// The text lives in the node's one STRING widget (hidden, so save/load, undo
+// and copy ride the default path); the panel only shows it. Decisions live in
+// js/shared/callout.mjs under node:test.
+
+import { app } from "../../../scripts/app.js";
+import { setTileFace, TILE_FACE_CSS } from "../shared/tile_face.mjs";
+import { CALLOUT_TYPES, serializeNoteIdentity } from "../shared/note_identity.mjs";
+import { BRAND, chainCallback, keepDomWidgetWidthAuto } from "../shared/index.mjs";
+import {
+  ARROW_ANGLE,
+  ARROW_CHOICES,
+  DOUBLE_ARROWS,
+  arrowText,
+  fitFontSize,
+  parseBlocks,
+  pastedLink,
+  repointLinks,
+  targetId,
+  toggleSmall,
+  tileLinkFields,
+  tileLinkText,
+  urlLabel,
+  wrapLink,
+} from "../shared/callout.mjs";
+import { onPaste } from "../shared/paste_ids.mjs";
+import { keepKeyInField } from "../shared/canvas_passthrough.mjs";
+import { WIDGET_FRAME, fillNodeHeight } from "../shared/panel_layout.mjs";
+import { hideInputsInDef, hideWidget } from "../shared/widget_visibility.mjs";
+import { commitWidgetValue } from "../shared/widget_card_math.mjs";
+import { compactAction } from "../shared/panel_controls.mjs";
+import { frameBounds } from "../shared/workflow_switches.mjs";
+
+const CSS_ID = "ausboss-callout-css";
+const WIDGET_NAME = "ausboss_callout_panel";
+const DEFAULT_SIZE = [380, 160];
+const PANEL_MIN_WIDTH = 200;
+const PANEL_MIN_HEIGHT = 64;
+const SVG_NS = "http://www.w3.org/2000/svg";
+const ARROW_COLOR = "#1fd3c6";
+const LINK_TILES = {
+  youtube: { label: "Watch Me on YouTube", url: "https://www.youtube.com/@ausbossdev" },
+  discord: { label: "Join for Help or More Workflows", url: "https://discord.gg/RwVxY9Fuaj" },
+};
+const FRAME_FILL = 0.8; // the share of the view a node brought into view takes, as in Workflow Switches
+const FONT = '"IBM Plex Sans", "Inter", "Segoe UI", system-ui, -apple-system, sans-serif';
+
+// The text sits out of flow, centred in the card by its auto margins. Nodes
+// 2.0 sizes a node by its content, so text in normal flow set the note's
+// height: a note could not be made shorter than its own text, and the text
+// was then fitted to a card it had sized itself. Out of flow, the card takes
+// its size from the node alone, in both renderers.
+//
+// The editor's bar is laid out for a note of ordinary width. On a narrow one
+// it drops its "Arrow" label and its hint, and when the note is tall enough
+// it goes onto two rows, so the buttons keep their size instead of being
+// squeezed to slivers (the two @container rules).
+function ensureCss() {
+  if (document.getElementById(CSS_ID)) return;
+  const style = document.createElement("style");
+  style.id = CSS_ID;
+  style.textContent = `
+${TILE_FACE_CSS}
+.ausboss-callout{box-sizing:border-box;width:100%;height:100%;padding:2px 4px 6px;overflow:hidden;pointer-events:none;}
+.ausboss-callout-card{position:relative;box-sizing:border-box;width:100%;height:100%;overflow:hidden;border-radius:8px;background:linear-gradient(135deg,rgba(0,180,170,.07),rgba(0,0,0,.2));}
+.ausboss-callout-inner{position:absolute;top:0;bottom:0;left:0;box-sizing:border-box;width:100%;height:fit-content;margin:auto 0;padding:.6em 1em .6em .85em;color:#d6e6e4;font-family:${FONT};font-weight:500;line-height:1.4;letter-spacing:.003em;overflow-wrap:anywhere;}
+.ausboss-callout-point{margin:0 0 .6em;padding-left:.7em;border-left:2px solid rgba(0,180,170,.7);}
+.ausboss-callout-point:last-child{margin-bottom:0;}
+.ausboss-callout-point b{color:#6fe0d6;font-weight:650;}
+.ausboss-callout-small{margin-top:.3em;color:#9fb5b2;font-size:max(11px,.62em);font-weight:400;line-height:1.4;}
+.ausboss-callout-small b{color:#8fd6cf;font-weight:600;}
+.ausboss-callout-card[data-tile=youtube]{background:#ae2639}
+.ausboss-callout-card[data-tile=discord]{background:#5146aa}
+.ausboss-callout-card[data-tile=title]{background:#090909;border-left:4px solid #21c7b9}
+.ausboss-callout-card[data-tile] .ausboss-callout-inner{padding-block:.15em;}
+.ausboss-callout-card[data-tile] .ausboss-callout-point{border:0;padding:0;margin:0;font-weight:650;color:#fff}
+.ausboss-callout-card[data-tile] .ausboss-callout-url{color:white;text-decoration:none;display:flex;align-items:center;gap:12px}
+.ausboss-callout-card[data-tile] .ausboss-callout-url svg{width:36px;height:28px;flex:none}
+.ausboss-callout-card[data-tile] .ausboss-callout-out{margin-left:auto}
+.ausboss-callout-card[data-tile] .ausboss-callout-tools{right:27px;}
+.ausboss-callout-empty{color:#6f8987;font-size:14px;font-weight:400;}
+.ausboss-callout-arrow{display:inline-block;width:1.2em;height:1.2em;margin:0 .1em;vertical-align:-.26em;filter:drop-shadow(0 0 .3em rgba(0,180,170,.55));}
+.ausboss-callout-arrow svg{display:block;width:100%;height:100%;overflow:visible;}
+.ausboss-callout-arrow.is-link{pointer-events:auto;cursor:pointer;border-radius:6px;filter:drop-shadow(0 0 .4em rgba(0,180,170,.8));}
+.ausboss-callout-arrow.is-link:hover{background:rgba(0,180,170,.2);}
+.ausboss-callout-arrow.is-gone{opacity:.4;}
+.ausboss-callout-url,.ausboss-callout-jump{pointer-events:auto;cursor:pointer;border-radius:.2em;color:#6fe0d6;text-decoration:underline;text-decoration-thickness:.06em;text-underline-offset:.17em;}
+.ausboss-callout-url:hover,.ausboss-callout-jump:hover{background:rgba(0,180,170,.2);color:#a5f1ea;}
+.ausboss-callout-url b,.ausboss-callout-jump b{color:inherit;}
+.ausboss-callout-out{display:inline-block;margin-left:.2em;font-size:.7em;font-weight:600;vertical-align:.14em;text-decoration:none;opacity:.85;}
+.ausboss-callout-jump.is-gone{opacity:.45;cursor:default;text-decoration-style:dotted;}
+.ausboss-callout-tools{position:absolute;top:5px;right:5px;display:flex;gap:4px;opacity:0;transition:opacity .15s;pointer-events:auto;}
+.ausboss-callout-card:is(:hover,:focus-within) .ausboss-callout-tools,.ausboss-callout.is-selected .ausboss-callout-tools{opacity:.95;}
+.ausboss-callout-tool{height:22px;padding:0 8px;border:1px solid rgba(0,180,170,.45);border-radius:5px;background:rgba(8,14,16,.86);color:#9fd8d3;font:600 11px ${FONT};letter-spacing:.02em;cursor:pointer;}
+.ausboss-callout-tool:hover{color:#fff;border-color:${BRAND};}
+.ausboss-callout-editor{position:absolute;inset:0;box-sizing:border-box;display:flex;flex-direction:column;gap:6px;padding:6px;border:1px solid ${BRAND};border-radius:8px;background:rgba(5,10,11,.95);pointer-events:auto;container-type:size;}
+.ausboss-callout-edit{flex:1;min-height:0;box-sizing:border-box;width:100%;padding:6px 8px;resize:none;border:none;background:transparent;color:#e6f4f3;font:15px/1.45 ${FONT};outline:none;}
+.ausboss-callout-arrowbar{flex:none;display:flex;align-items:center;gap:4px;}
+.ausboss-callout-arrowbar span{margin-right:4px;color:#6f8987;font:11px ${FONT};}
+.ausboss-callout-link{margin-left:auto;display:flex;align-items:center;gap:6px;max-width:55%;color:#6f8987;font:11px ${FONT};white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}
+.ausboss-callout-link.has-node{color:#9fe8e1;}
+.ausboss-callout-link button{height:20px;padding:0 6px;border:1px solid rgba(0,180,170,.35);border-radius:5px;background:rgba(8,14,16,.9);color:#9fd8d3;font:600 11px ${FONT};cursor:pointer;}
+.ausboss-callout-pick{width:26px;height:24px;padding:3px;border:1px solid rgba(0,180,170,.35);border-radius:5px;background:rgba(8,14,16,.9);cursor:pointer;}
+.ausboss-callout-pick:hover{border-color:${BRAND};background:rgba(0,180,170,.14);}
+.ausboss-callout-pick svg{display:block;width:100%;height:100%;}
+.ausboss-callout-size{flex:none;height:24px;margin-left:4px;padding:0 7px;border:1px solid rgba(0,180,170,.35);border-radius:5px;background:rgba(8,14,16,.9);color:#9fd8d3;font:600 11px ${FONT};cursor:pointer;}
+.ausboss-callout-size:hover{border-color:${BRAND};background:rgba(0,180,170,.14);}
+.ausboss-tile-editor{box-sizing:border-box;width:min(520px,94vw);max-height:86vh;overflow:auto;margin:auto;padding:24px;border:1px solid #365957;border-top:3px solid ${BRAND};border-radius:10px;background:#111b1c;color:#e6f4f3;box-shadow:0 18px 64px #0008;font:14px/1.5 ${FONT};}
+.ausboss-tile-editor::backdrop{background:#06090ab8;}
+.ausboss-tile-editor h2{margin:0 0 18px;font-size:21px;}
+.ausboss-tile-editor label{display:flex;flex-direction:column;gap:7px;margin-bottom:16px;font-weight:600;}
+.ausboss-tile-editor input,.ausboss-tile-editor textarea{box-sizing:border-box;width:100%;padding:10px 12px;border:1px solid #365957;border-radius:5px;background:#080e10;color:#e6f4f3;font:16px/1.5 ${FONT};user-select:text;}
+.ausboss-tile-editor textarea{min-height:120px;resize:vertical;}
+.ausboss-tile-editor :is(input,textarea):focus{outline:2px solid ${BRAND};outline-offset:1px;}
+.ausboss-tile-editor footer{display:flex;justify-content:flex-end;align-items:center;gap:8px;}
+.ausboss-tile-editor footer span{margin-right:auto;color:#99b0ad;font-size:12px;}
+.ausboss-tile-editor .ausboss-compact-action{height:32px;padding:0 15px;font-size:13px;}
+.ausboss-tile-editor .ausboss-tile-error{color:#ffc36d;margin:0 0 12px;}
+@container (max-width:395px){.ausboss-callout-arrowbar>span:first-child,.ausboss-callout-link:not(.has-node){display:none;}}
+@container (max-width:395px) and (min-height:112px){.ausboss-callout-arrowbar{flex-wrap:wrap;}.ausboss-callout-pick{flex:none;}}
+`;
+  document.head.appendChild(style);
+}
+
+function el(tag, className, text) {
+  const node = document.createElement(tag);
+  if (className) node.className = className;
+  if (text != null) node.textContent = text;
+  return node;
+}
+
+function svg(tag, attrs) {
+  const node = document.createElementNS(SVG_NS, tag);
+  for (const [key, value] of Object.entries(attrs)) node.setAttribute(key, value);
+  return node;
+}
+
+// One teal arrow, drawn right-pointing and turned to face `kind`.
+function arrowIcon(kind) {
+  const root = svg("svg", { viewBox: "0 0 24 24", "aria-hidden": "true" });
+  const group = svg("g", { transform: `rotate(${ARROW_ANGLE[kind] ?? 0} 12 12)`, fill: ARROW_COLOR, stroke: ARROW_COLOR });
+  const double = DOUBLE_ARROWS.has(kind);
+  group.append(
+    svg("path", { d: `M${double ? 5 : 3} 12H${double ? 19 : 15.5}`, fill: "none", "stroke-width": "2.8", "stroke-linecap": "round" }),
+    svg("path", { d: "M13.5 5.8L22 12L13.5 18.2Z", "stroke-width": "1.6", "stroke-linejoin": "round" }),
+  );
+  if (double) {
+    group.append(svg("path", { d: "M10.5 5.8L2 12L10.5 18.2Z", "stroke-width": "1.6", "stroke-linejoin": "round" }));
+  }
+  root.append(group);
+  return root;
+}
+
+// The node a link names, looked up in the graph the note sits in.
+function linkedNode(state, id) {
+  const graph = state.node.graph ?? app.graph;
+  return graph?.getNodeById?.(id) ?? graph?.getNodeById?.(Number(id)) ?? null;
+}
+
+function nodeName(node) {
+  return node?.getTitle?.() ?? node?.title ?? node?.type ?? "node";
+}
+
+// The group a link names (#g3), looked up in the graph the note sits in.
+function linkedGroup(state, id) {
+  const graph = state.node.graph ?? app.graph;
+  return (graph?.groups ?? graph?._groups ?? []).find((group) => String(group?.id) === String(id)) ?? null;
+}
+
+const isGroup = (item) => Boolean(item) && (item instanceof (globalThis.LGraphGroup ?? globalThis.LiteGraph?.LGraphGroup ?? class {}) || (item.constructor?.name === "LGraphGroup"));
+
+// What a piece of the text points at inside the workflow: a node or a group,
+// with the words that say so. null for a piece that points at nothing here.
+function placeOf(state, piece) {
+  if (piece.group !== undefined) {
+    const group = linkedGroup(state, piece.group);
+    return { item: group, title: group ? `Bring the group "${group.title ?? ""}" into view` : "The group this points at is not in the workflow" };
+  }
+  if (piece.link !== undefined) {
+    const node = linkedNode(state, piece.link);
+    return { item: node, title: node ? `Bring "${nodeName(node)}" into view` : "The node this points at is not in the workflow" };
+  }
+  return null;
+}
+
+function arrowSpan(state, kind, piece = {}) {
+  const span = el("span", "ausboss-callout-arrow");
+  span.append(arrowIcon(kind));
+  // Inside linked words (a run) the arrow is part of that link.
+  const place = piece.run === undefined ? placeOf(state, piece) : null;
+  if (!place) return span;
+  span.classList.add("is-link", place.item ? "is-live" : "is-gone");
+  span.title = place.title;
+  span.addEventListener("click", (event) => {
+    event.stopPropagation();
+    bringIntoView(place.item);
+  });
+  return span;
+}
+
+// The words of one link, as one element: an address opens in a new tab, a
+// node or a group comes into view.
+function linkRun(state, first) {
+  if (first.url !== undefined) {
+    const link = el("a", "ausboss-callout-url");
+    const tile = state.card.dataset.tile;
+    if (tile === "youtube" || tile === "discord") {
+      const icon = svg("svg", { viewBox:"0 0 28 20", "aria-hidden":"true" });
+      if (tile === "youtube") {
+        icon.append(svg("rect",{x:0,y:1,width:28,height:18,rx:5,fill:"white"}),
+          svg("path",{d:"M11 5.5 19 10 11 14.5Z",fill:"#ae2639"}));
+      } else {
+        icon.append(svg("path",{d:"M4 3 10 1l1 2a15 15 0 0 1 6 0l1-2 6 2c2 4 3 8 3 12l-6 4-2-3a17 17 0 0 1-10 0l-2 3-6-4c0-4 1-8 3-12Z",fill:"white"}));
+        for (const cx of [9,19]) icon.append(svg("ellipse",{cx,cy:10,rx:2,ry:2.6,fill:"#5146aa"}));
+      }
+      link.append(icon);
+    }
+    link.href = first.url;
+    link.target = "_blank";
+    link.rel = "noopener noreferrer";
+    link.title = `Opens ${urlLabel(first.url)} in a new tab`;
+    // A press on a link must not become a node drag, and a double-click is one visit.
+    link.addEventListener("pointerdown", (event) => event.stopPropagation());
+    let last = 0;
+    link.addEventListener("click", (event) => {
+      event.stopPropagation();
+      if (event.timeStamp - last < 600) event.preventDefault();
+      last = event.timeStamp;
+    });
+    return link;
+  }
+  const place = placeOf(state, first);
+  const jump = el("span", "ausboss-callout-jump");
+  jump.setAttribute("role", "link");
+  jump.title = place.title;
+  if (!place.item) jump.classList.add("is-gone");
+  jump.addEventListener("pointerdown", (event) => event.stopPropagation());
+  jump.addEventListener("click", (event) => {
+    event.stopPropagation();
+    bringIntoView(place.item);
+  });
+  return jump;
+}
+
+// Bring a node or a group into view the way Workflow Switches does: a small
+// one is shown at natural size, a big one fitted to most of the view.
+function bringIntoView(target) {
+  const canvas = app.canvas;
+  if (!target || !canvas) return;
+  const title = isGroup(target) ? 0 : (globalThis.LiteGraph?.NODE_TITLE_HEIGHT ?? 30);
+  const found = [target.pos[0], target.pos[1] - title, target.size[0], target.size[1] + title];
+  const view = canvas.canvas?.getBoundingClientRect?.();
+  const rect = frameBounds(found, [view?.width, view?.height], FRAME_FILL);
+  if (typeof canvas.animateToBounds === "function") {
+    canvas.animateToBounds(rect, { zoom: FRAME_FILL });
+  } else if (typeof canvas.ds?.fitToBounds === "function") {
+    canvas.ds.fitToBounds(rect, { zoom: FRAME_FILL });
+    canvas.setDirty?.(true, true);
+  }
+}
+
+function renderText(state) {
+  const style = state.node.properties?.ausbossCalloutTile;
+  if (["youtube","discord","title"].includes(style)) state.card.dataset.tile = style;
+  else delete state.card.dataset.tile;
+  setTileFace(state.node, state.root, Boolean(state.card.dataset.tile), () => startEdit(state));
+  const blocks = parseBlocks(state.valueWidget.value);
+  state.inner.replaceChildren();
+  state.empty = blocks.length === 0;
+  if (state.empty) {
+    state.inner.append(el("div", "ausboss-callout-empty", "Double-click to write a note"));
+  }
+  for (const lines of blocks) {
+    const point = el("div", "ausboss-callout-point");
+    lines.forEach((line, index) => {
+      // Small print is a block of its own under the line above it. Normal
+      // lines are told apart by a break, as before; a block needs none.
+      const into = line.small ? el("div", "ausboss-callout-small") : point;
+      if (index && !line.small && !lines[index - 1].small) point.append(document.createElement("br"));
+      let run = null;
+      let wrap = null;
+      for (const piece of line) {
+        // The pieces of one link sit in one element.
+        if (piece.run !== run) {
+          if (wrap?.classList.contains("ausboss-callout-url")) wrap.append(el("span", "ausboss-callout-out", "↗"));
+          run = piece.run;
+          wrap = run === undefined ? null : linkRun(state, piece);
+          if (wrap) into.append(wrap);
+        }
+        const target = wrap ?? into;
+        if (piece.arrow) target.append(arrowSpan(state, piece.arrow, piece));
+        else target.append(piece.bold ? el("b", "", piece.text) : document.createTextNode(piece.text));
+      }
+      if (wrap?.classList.contains("ausboss-callout-url")) wrap.append(el("span", "ausboss-callout-out", "↗"));
+      if (line.small) point.append(into);
+    });
+    state.inner.append(point);
+  }
+  fit(state);
+}
+
+// The frontend's wrapper around a panel takes every click, so a press on the
+// note's body would neither select nor drag it. The wrapper hands those
+// presses to the canvas and opens the editor on a double-click; the Edit
+// button and the editor take the pointer for themselves.
+let forwarded = null;
+
+function letClicksThrough(state) {
+  const wrapper = state.root.closest(".dom-widget");
+  if (!wrapper || wrapper.__ausbossCallout) return;
+  wrapper.__ausbossCallout = true;
+  // The presses are forwarded to the canvas, which can swallow the browser's
+  // own double-click, so a second press close to the first is read here.
+  let lastPress = null;
+  wrapper.addEventListener("pointerdown", (event) => {
+    const canvas = app.canvas;
+    if (event.target !== wrapper || event.button !== 0 || !canvas) return;
+    const again = lastPress
+      && event.timeStamp - lastPress.time < 500
+      && Math.hypot(event.clientX - lastPress.x, event.clientY - lastPress.y) < 8;
+    lastPress = { time: event.timeStamp, x: event.clientX, y: event.clientY };
+    if (again) {
+      lastPress = null;
+      event.preventDefault();
+      event.stopPropagation();
+      startEdit(state);
+      return;
+    }
+    forwarded = event.pointerId;
+    event.preventDefault();
+    event.stopPropagation();
+    canvas.processMouseDown(event);
+  }, true);
+  wrapper.addEventListener("contextmenu", (event) => {
+    if (event.target !== wrapper) return;
+    event.preventDefault();
+    app.canvas?.processContextMenu?.(state.node, event);
+  }, true);
+  window.addEventListener("pointermove", (event) => {
+    if (forwarded === event.pointerId) app.canvas?.processMouseMove(event);
+  }, true);
+  window.addEventListener("pointerup", (event) => {
+    if (forwarded !== event.pointerId) return;
+    forwarded = null;
+    app.canvas?.processMouseUp(event);
+  }, true);
+}
+
+// The text grows to the largest size that still sits inside the node.
+function fit(state) {
+  const { card, inner } = state;
+  letClicksThrough(state);
+  if (state.empty) {
+    inner.style.fontSize = "";
+    return;
+  }
+  const height = card.clientHeight;
+  const width = card.clientWidth;
+  if (!height || !width) return;
+  const fits = (px) => {
+    inner.style.fontSize = `${px}px`;
+    return inner.offsetHeight <= height && inner.scrollWidth <= width + 1;
+  };
+  const size = fitFontSize(fits);
+  const social = card.dataset.tile === "youtube" || card.dataset.tile === "discord";
+  inner.style.fontSize = `${social ? Math.min(size, 16) : size}px`;
+}
+
+function markChanged() {
+  app.graph?.setDirtyCanvas?.(true, true);
+  try {
+    app.extensionManager?.workflow?.activeWorkflow?.changeTracker?.checkState?.();
+  } catch {
+    // The change tracker is optional; the canvas still saves what it holds.
+  }
+}
+
+function startTileEdit(state) {
+  if (state.editor) return;
+  const original = String(state.valueWidget.value ?? "");
+  const social = ["youtube", "discord"].includes(state.card.dataset.tile);
+  const link = social ? tileLinkFields(original) : null;
+  const dialog = el("dialog", "ausboss-tile-editor");
+  const heading = social ? "Edit link tile" : "Edit title";
+  dialog.setAttribute("aria-label", heading);
+  dialog.append(el("h2", "", heading));
+  const label = el("label", "", link ? "Button text" : "Text");
+  const text = el(link ? "input" : "textarea");
+  text.value = link?.label ?? original;
+  label.append(text);
+  dialog.append(label);
+  let address;
+  if (link) {
+    const field = el("label", "", "Link address");
+    address = el("input");
+    address.type = "url";
+    address.value = link.url;
+    field.append(address);
+    dialog.append(field);
+  }
+  const error = el("p", "ausboss-tile-error");
+  error.setAttribute("role", "alert");
+  const foot = el("footer");
+  const cancel = compactAction("Cancel");
+  const save = compactAction("Save");
+  foot.append(el("span", "", "Ctrl + Enter to save"), cancel, save);
+  dialog.append(error, foot);
+  const commit = () => {
+    let value = text.value;
+    try {
+      if (address) value = tileLinkText(text.value, address.value);
+    } catch (problem) {
+      error.textContent = problem.message;
+      return;
+    }
+    if (value !== original) {
+      state.node.graph?.beforeChange?.();
+      commitWidgetValue(state.node, state.valueWidget, value, app.canvas);
+      renderText(state);
+      state.node.graph?.afterChange?.();
+      markChanged();
+    }
+    dialog.close();
+  };
+  save.addEventListener("click", commit);
+  cancel.addEventListener("click", () => dialog.close());
+  dialog.addEventListener("keydown", event => {
+    event.stopPropagation();
+    if (event.key === "Enter" && (event.ctrlKey || event.metaKey)) {
+      event.preventDefault();
+      commit();
+    }
+  });
+  dialog.addEventListener("keyup", event => event.stopPropagation());
+  dialog.addEventListener("close", () => {
+    state.editor = null;
+    dialog.remove();
+    state.root.querySelector(".ausboss-callout-tool")?.focus();
+  }, { once: true });
+  state.editor = dialog;
+  document.body.append(dialog);
+  dialog.showModal();
+  text.focus();
+  text.select();
+}
+
+function startEdit(state) {
+  if (state.editor) return;
+  if (state.card.dataset.tile) return startTileEdit(state);
+  const wrap = el("div", "ausboss-callout-editor");
+  const area = el("textarea", "ausboss-callout-edit");
+  area.value = state.valueWidget.value ?? "";
+  area.placeholder = "One idea per paragraph. **Bold** a word to stress it. The buttons below add an arrow, make a line small or make words a link.";
+  area.spellcheck = true;
+  const bar = el("div", "ausboss-callout-arrowbar");
+  bar.append(el("span", "", "Arrow"));
+  // The node the next arrow will be linked to: click a node on the canvas
+  // while editing, then press an arrow.
+  let linkTarget = null;
+  const linkBox = el("div", "ausboss-callout-link");
+  const showLink = () => {
+    linkBox.replaceChildren();
+    linkBox.classList.toggle("has-node", Boolean(linkTarget));
+    if (!linkTarget) {
+      linkBox.append(el("span", "", "Click a node or a group to link to it"));
+      return;
+    }
+    const clear = el("button", "", "\u00D7");
+    clear.type = "button";
+    clear.title = "Do not link the next arrow or link";
+    clear.addEventListener("mousedown", (event) => event.preventDefault());
+    clear.addEventListener("click", () => {
+      linkTarget = null;
+      showLink();
+      area.focus();
+    });
+    linkBox.append(el("span", "", `Links to ${isGroup(linkTarget) ? `the group ${linkTarget.title ?? ""}` : nodeName(linkTarget)}`), clear);
+  };
+  // What stands after # for the picked node or group: "12", "g3", or nothing.
+  const pickedId = () => (linkTarget ? targetId(linkTarget, isGroup(linkTarget)) : undefined);
+  for (const [kind, emoji] of ARROW_CHOICES) {
+    const pick = el("button", "ausboss-callout-pick");
+    pick.type = "button";
+    pick.title = `Add an arrow pointing ${kind}. Click a node first to link it.`;
+    pick.append(arrowIcon(kind));
+    // The text box keeps focus, so clicking an arrow does not end the edit.
+    pick.addEventListener("mousedown", (event) => event.preventDefault());
+    pick.addEventListener("click", () => {
+      area.setRangeText(arrowText(emoji, pickedId()), area.selectionStart, area.selectionEnd, "end");
+      linkTarget = null;
+      showLink();
+      area.focus();
+    });
+    bar.append(pick);
+  }
+  // Small print for the line the caret is on, or every line of a selection.
+  const small = el("button", "ausboss-callout-size", "Small");
+  small.type = "button";
+  small.title = "Make this line small print, for the details under the line above. Press again to make it normal.";
+  small.addEventListener("mousedown", (event) => event.preventDefault());
+  small.addEventListener("click", () => {
+    const next = toggleSmall(area.value, area.selectionStart, area.selectionEnd);
+    area.setRangeText(next.insert, next.from, next.to, "preserve");
+    area.setSelectionRange(next.selectionStart, next.selectionEnd);
+    area.focus();
+  });
+  bar.append(small);
+  // The selected words become a link: to the picked node or group, or to an
+  // address, which comes back selected so it can be pasted over.
+  const link = el("button", "ausboss-callout-size", "Link");
+  link.type = "button";
+  link.title = "Make the selected words a link. Click a node or a group first to link to it; otherwise paste the address of a page.";
+  link.addEventListener("mousedown", (event) => event.preventDefault());
+  link.addEventListener("click", () => {
+    const id = pickedId();
+    const next = wrapLink(area.value, area.selectionStart, area.selectionEnd, id ? `#${id}` : "");
+    area.setRangeText(next.insert, next.from, next.to, "preserve");
+    area.setSelectionRange(next.selectionStart, next.selectionEnd);
+    linkTarget = null;
+    showLink();
+    area.focus();
+  });
+  bar.append(link);
+  bar.append(linkBox);
+  showLink();
+  wrap.append(area, bar);
+
+  let done = false;
+  const finish = (keep) => {
+    if (done) return;
+    done = true;
+    const value = area.value;
+    state.editor = null;
+    watch.abort();
+    wrap.remove();
+    if (keep && value !== state.valueWidget.value) {
+      commitWidgetValue(state.node, state.valueWidget, value, app.canvas);
+    }
+    renderText(state);
+    markChanged();
+  };
+  area.addEventListener("keydown", (event) => {
+    keepKeyInField(event);
+    if (event.key === "Escape") finish(false);
+  });
+  area.addEventListener("keyup", (event) => event.stopPropagation());
+  // An address pasted over selected words makes them a link to it.
+  area.addEventListener("paste", (event) => {
+    const selected = area.value.slice(area.selectionStart, area.selectionEnd);
+    const made = pastedLink(selected, event.clipboardData?.getData("text/plain"));
+    if (!made) return;
+    event.preventDefault();
+    area.setRangeText(made, area.selectionStart, area.selectionEnd, "end");
+  });
+  // A press on the editor's own bar keeps the keyboard in the text box.
+  wrap.addEventListener("mousedown", (event) => {
+    if (event.target !== area) event.preventDefault();
+  });
+  wrap.addEventListener("pointerdown", (event) => event.stopPropagation());
+  wrap.addEventListener("wheel", (event) => event.stopPropagation(), { passive: true });
+  // Clicking another node on the canvas takes the keyboard from the text box.
+  // That is how the link is picked, so the edit stays open then; a click on
+  // empty canvas, or on the note itself, ends it.
+  const watch = new AbortController();
+  let pointerDown = false;
+  window.addEventListener("pointerdown", () => { pointerDown = true; }, { capture: true, signal: watch.signal });
+  const settle = () => {
+    if (done) return;
+    const others = [...(app.canvas?.selectedItems ?? [])].filter((item) => item !== state.node && item?.pos && item?.size);
+    const stays = others.length === 1 && !app.canvas.selectedItems.has?.(state.node);
+    if (stays) {
+      linkTarget = others[0];
+      showLink();
+      area.focus();
+    } else {
+      finish(true);
+    }
+  };
+  window.addEventListener("pointerup", () => {
+    pointerDown = false;
+    if (waiting) {
+      waiting = false;
+      setTimeout(settle, 40);
+    }
+  }, { capture: true, signal: watch.signal });
+  let waiting = false;
+  area.addEventListener("blur", () => {
+    if (done) return;
+    if (pointerDown) waiting = true;
+    else finish(true);
+  });
+  state.editor = wrap;
+  state.card.append(wrap);
+  area.focus();
+}
+
+function buildPanel(node) {
+  if (node.__ausbossCallout) return node.__ausbossCallout;
+  const valueWidget = node.widgets?.find((item) => item.name === "text");
+  if (!valueWidget) return null;
+  ensureCss();
+  hideWidget(valueWidget);
+
+  const root = el("div", "ausboss-callout");
+  const card = el("div", "ausboss-callout-card");
+  const inner = el("div", "ausboss-callout-inner");
+  const tools = el("div", "ausboss-callout-tools");
+  const edit = el("button", "ausboss-callout-tool", "Edit");
+  edit.type = "button";
+  edit.title = "Edit the text. Double-clicking the note does the same.";
+  tools.append(edit);
+  card.append(inner, tools);
+  root.append(card);
+  tools.addEventListener("pointerdown", (event) => event.stopPropagation());
+
+  const panelHeight = () => (card.dataset.tile ? 36 : PANEL_MIN_HEIGHT) + WIDGET_FRAME;
+  const domWidget = node.addDOMWidget(WIDGET_NAME, "ausboss_callout", root, {
+    serialize: false,
+    hideOnZoom: false,
+    getMinHeight: panelHeight,
+  });
+  keepDomWidgetWidthAuto(domWidget);
+  domWidget.serialize = false;
+  fillNodeHeight(domWidget, {
+    minWidth: PANEL_MIN_WIDTH,
+    minHeight: panelHeight,
+    minNodeSize: [PANEL_MIN_WIDTH, PANEL_MIN_HEIGHT + 40],
+    exactMinWidth: true,
+  });
+
+  const state = { node, valueWidget, domWidget, root, card, inner, empty: true, editor: null, frame: 0 };
+  node.__ausbossCallout = state;
+  edit.addEventListener("click", () => startEdit(state));
+  card.addEventListener("dblclick", (event) => {
+    if (card.dataset.tile && !event.target.closest("a,button,textarea,.ausboss-callout-editor")) startEdit(state);
+  });
+  state.observer = new ResizeObserver(() => {
+    cancelAnimationFrame(state.frame);
+    state.frame = requestAnimationFrame(() => fit(state));
+  });
+  state.observer.observe(card);
+  node.setSize?.([
+    Math.max(node.size?.[0] ?? 0, DEFAULT_SIZE[0]),
+    Math.max(node.size?.[1] ?? 0, DEFAULT_SIZE[1]),
+  ]);
+  renderText(state);
+  return state;
+}
+
+app.registerExtension({
+  name: "AusBoss.Callout",
+  setup() {
+    // A note copied with what its links name follows the copies.
+    onPaste(({ nodes, groups, created }) => {
+      for (const node of created) {
+        if (!CALLOUT_TYPES.has(node?.comfyClass) && !CALLOUT_TYPES.has(node?.type)) continue;
+        const state = buildPanel(node);
+        if (!state) continue;
+        const text = repointLinks(state.valueWidget.value, nodes, groups);
+        if (text === null) continue;
+        state.valueWidget.value = text;
+        renderText(state);
+      }
+    });
+  },
+  beforeRegisterNodeDef(nodeType, nodeData) {
+    if (!CALLOUT_TYPES.has(nodeData?.name)) return;
+    hideInputsInDef(nodeData, ["text"]);
+    chainCallback(nodeType.prototype, "onNodeCreated", function () {
+      if (nodeData.name === "AUSBOSS_NODES_CalloutTile") {
+        this.properties ??= {};
+        this.properties.ausbossCalloutTile ??= "title";
+      }
+      buildPanel(this);
+      // Keep new tiles compact without changing ordinary or saved callouts.
+      if (nodeData.name === "AUSBOSS_NODES_CalloutTile") this.setSize?.([380, 80]);
+    });
+    chainCallback(nodeType.prototype, "onSerialize", function (saved) {
+      serializeNoteIdentity(saved, ["youtube", "discord", "title"].includes(this.properties?.ausbossCalloutTile));
+    });
+    chainCallback(nodeType.prototype, "onConfigure", function (saved) {
+      // Saved values land after onNodeCreated; show them.
+      queueMicrotask(() => {
+        const state = buildPanel(this);
+        if (!state) return;
+        renderText(state);
+        if (state.card.dataset.tile && Number.isFinite(saved?.size?.[1])) {
+          this.setSize?.([this.size[0], saved.size[1]]);
+        }
+      });
+    });
+    chainCallback(nodeType.prototype, "onDblClick", function () {
+      const state = this.__ausbossCallout;
+      if (state) startEdit(state);
+    });
+    chainCallback(nodeType.prototype, "getExtraMenuOptions", function (_canvas, options) {
+      const state = this.__ausbossCallout;
+      if (!state || !Array.isArray(options)) return;
+      for (const [style, label] of [["plain","Plain callout"],["title","Title tile"],["youtube","Set YouTube link tile"],["discord","Set Discord link tile"]]) {
+        options.unshift({ content: label, callback: () => {
+          this.properties ??= {};
+          this.properties.ausbossCalloutTile = style;
+          const preset = LINK_TILES[style];
+          if (preset) commitWidgetValue(this, state.valueWidget, `[${preset.label}](${preset.url})`, app.canvas);
+          renderText(state);
+          if (style !== "plain") this.setSize?.([this.size[0], style === "title" ? 86 : 78]);
+          markChanged();
+        }});
+      }
+      options.unshift({ content: "Edit callout text", callback: () => startEdit(state) }, null);
+    });
+    chainCallback(nodeType.prototype, "onRemoved", function () {
+      const state = this.__ausbossCallout;
+      if (!state) return;
+      state.observer?.disconnect();
+      state.editor?.close?.();
+      cancelAnimationFrame(state.frame);
+      this.__ausbossCallout = null;
+    });
+  },
+});

js/canvas_passthrough/index.js

@@ -0,0 +1,142 @@
+// Graph zoom and pan over the pack's panels, and files dropped on them.
+//
+// The mouse wheel and the Ctrl + Shift drag-zoom shortcut reach the graph only
+// from the empty canvas; a panel that takes the mouse swallowed them, so
+// zooming stopped over Compare, the crop previews, the video viewers and every
+// control on a card. One listener here hands those gestures back, the same way
+// ComfyUI does for its own text boxes. A panel that wants the wheel for itself
+// (a scrolling list, a focused text field, an editor) still keeps it.
+//
+// A file dragged in from the desktop, or a picture's card from the Assets
+// panel, has the same problem in the classic renderer: dropped on a node's
+// title it loads into the node, dropped on the node's panel (the picture, the
+// controls) it missed the node. The drop listeners here hand it to the node
+// under the pointer.
+import { app } from "../../../scripts/app.js";
+import {
+  dragCarriesFiles, graphDragStarts, panelHost, panelKeepsWheel, panelNeedsDropHelp, panelRoot,
+} from "../shared/canvas_passthrough.mjs";
+import { showToast } from "../shared/index.mjs";
+
+let forwardedPointer = null;
+// The node a dragged file is over while the pointer is on its panel.
+let dropNode = null;
+
+function canvas() {
+  return app.canvas ?? null;
+}
+
+function onWheel(event) {
+  const target = event.target;
+  const root = panelRoot(target);
+  const lgCanvas = canvas();
+  if (!root || !lgCanvas || event.defaultPrevented) return;
+  if (panelKeepsWheel(target, event, { root, host: panelHost(target), styleOf: (el) => getComputedStyle(el), activeElement: document.activeElement })) return;
+  event.preventDefault();
+  lgCanvas.processMouseWheel(event);
+}
+
+function onPointerDown(event) {
+  const lgCanvas = canvas();
+  if (!lgCanvas || !panelRoot(event.target)) return;
+  if (!graphDragStarts(event, { dragZoomEnabled: lgCanvas.dragZoomEnabled })) return;
+  forwardedPointer = event.pointerId;
+  event.preventDefault();
+  event.stopPropagation();
+  lgCanvas.processMouseDown(event);
+}
+
+function onPointerMove(event) {
+  if (forwardedPointer !== event.pointerId) return;
+  canvas()?.processMouseMove(event);
+}
+
+function onPointerEnd(event) {
+  if (forwardedPointer !== event.pointerId) return;
+  forwardedPointer = null;
+  canvas()?.processMouseUp(event);
+}
+
+// The node a panel belongs to, found the way the canvas finds the node under
+// a drag: by where the pointer is.
+function nodeUnder(event) {
+  const lgCanvas = canvas();
+  const graph = lgCanvas?.graph;
+  if (!graph || typeof lgCanvas.adjustMouseEvent !== "function") return null;
+  lgCanvas.adjustMouseEvent(event);
+  if (!Number.isFinite(event.canvasX) || !Number.isFinite(event.canvasY)) return null;
+  return graph.getNodeOnPos?.(event.canvasX, event.canvasY) ?? null;
+}
+
+// The node that takes this dragged file, or null when the drag is not ours
+// to help with: no files, not over one of the pack's classic panels, or a
+// node that does not take files.
+function takerOf(event) {
+  if (!dragCarriesFiles(event) || !panelNeedsDropHelp(event.target)) return null;
+  const node = nodeUnder(event);
+  if (typeof node?.onDragDrop !== "function" || !node.onDragOver?.(event)) return null;
+  return node;
+}
+
+// ComfyUI outlines the node a file is dragged over; keep that outline while
+// the pointer is on the node's panel.
+function markDropNode(node) {
+  if (dropNode === node) return;
+  dropNode = node;
+  if ("dragOverNode" in app) app.dragOverNode = node;
+  canvas()?.graph?.setDirtyCanvas?.(false, true);
+}
+
+function onDragOver(event) {
+  const node = takerOf(event);
+  if (!node) {
+    if (dropNode && panelRoot(event.target)) markDropNode(null);
+    return;
+  }
+  // Without this the browser refuses the drop.
+  event.preventDefault();
+  if (event.dataTransfer) event.dataTransfer.dropEffect = "copy";
+  markDropNode(node);
+}
+
+async function onDrop(event) {
+  const node = takerOf(event);
+  if (!node) return;
+  // The node gets the file. ComfyUI's own handler would add a Load Image
+  // node for it, or open it as a workflow.
+  event.preventDefault();
+  event.stopPropagation();
+  markDropNode(null);
+  const file = event.dataTransfer?.files?.[0] ?? null;
+  try {
+    if (await node.onDragDrop(event)) return;
+    // Not a file this node takes (a workflow dropped on a loader): let
+    // ComfyUI open it, as it does for a drop on the node's title.
+    if (file && file.type !== "image/bmp") await app.handleFile?.(file);
+  } catch (error) {
+    showToast({ severity: "error", detail: `That file could not be loaded: ${error?.message ?? error}`, life: 8000 });
+  }
+}
+
+function onDragEnd() {
+  if (dropNode) markDropNode(null);
+}
+
+app.registerExtension({
+  name: "AusBoss.CanvasPassthrough",
+  setup() {
+    // The wheel listener sits in the bubble phase so a panel's own handler
+    // (stopPropagation / preventDefault) always gets the first say.
+    window.addEventListener("wheel", onWheel, { passive: false });
+    window.addEventListener("pointerdown", onPointerDown, true);
+    window.addEventListener("pointermove", onPointerMove, true);
+    window.addEventListener("pointerup", onPointerEnd, true);
+    window.addEventListener("pointercancel", onPointerEnd, true);
+    // Capture phase: ComfyUI's own drop listener sits on the document and
+    // must not also act on a file the node took.
+    window.addEventListener("dragover", onDragOver, true);
+    window.addEventListener("drop", onDrop, true);
+    window.addEventListener("dragend", onDragEnd, true);
+    window.addEventListener("dragleave", (event) => { if (!event.relatedTarget) onDragEnd(); }, true);
+  },
+});

js/chrome/index.js

@@ -1,7 +1,8 @@
-import { app } from "/scripts/app.js";
-import { api } from "/scripts/api.js";
+import { app } from "../../../scripts/app.js";
+import { api } from "../../../scripts/api.js";
 import { AUSBOSS_JS_VERSION, BRAND, BRAND_BODY, chainCallback } from "../shared/index.mjs";
 import { nodeByExecutionId } from "../shared/graph_ids.mjs";
+import { isOwnRun, ownRuns } from "../shared/prompt_scope.mjs";
 import {
   advanceExecution,
   applyStatus,
@@ -187,6 +188,7 @@ const runtime = {
   enabled: false,
   abort: null,
   state: createRunState(),
+  kept: null,
 };
 
 function graphNodes() {
@@ -217,34 +219,62 @@ function stampUpdates(updates) {
   if (updates.length) app.graph?.setDirtyCanvas?.(true, false);
 }
 
+// The badges a run cleared when it started, kept until it is clear that the
+// run is one of the workflow's: a node's own run (Mask by Touch looking at
+// its picture) is only known as one once the queue has answered.
+function keepBadges(promptId) {
+  const badges = [];
+  for (const node of graphNodes()) {
+    if (node[RUNTIME_KEY] !== undefined) badges.push([node, node[RUNTIME_KEY]]);
+  }
+  runtime.kept = { promptId: promptId ? String(promptId) : null, badges };
+}
+
 function enableRuntime() {
   if (runtime.abort) return;
   runtime.abort = new AbortController();
   const signal = runtime.abort.signal;
-  const closeRun = () => stampUpdates(advanceExecution(runtime.state, null, performance.now()));
+  // A run a node starts for itself leaves the last run's badges alone.
+  const workflowRun = (handler) => (event) => {
+    const detail = event?.detail;
+    if (!isOwnRun(detail && typeof detail === "object" ? detail.prompt_id : null)) handler(event);
+  };
+  const closeRun = workflowRun(() => stampUpdates(advanceExecution(runtime.state, null, performance.now())));
   api.addEventListener(
     "execution_start",
-    () => {
+    workflowRun((event) => {
+      keepBadges(event?.detail?.prompt_id);
       runtime.state = createRunState();
       clearBadges();
-    },
+    }),
     { signal },
   );
   api.addEventListener(
     "executing",
-    (event) =>
-      stampUpdates(advanceExecution(runtime.state, executingNodeId(event?.detail), performance.now())),
+    workflowRun((event) =>
+      stampUpdates(advanceExecution(runtime.state, executingNodeId(event?.detail), performance.now()))),
     { signal },
   );
   api.addEventListener("execution_success", closeRun, { signal });
   api.addEventListener("execution_error", closeRun, { signal });
   api.addEventListener("execution_interrupted", closeRun, { signal });
+  const stop = ownRuns.subscribe((promptId) => {
+    const kept = runtime.kept;
+    if (!kept || kept.promptId !== promptId) return;
+    runtime.kept = null;
+    runtime.state = createRunState();
+    clearBadges();
+    for (const [node, seconds] of kept.badges) node[RUNTIME_KEY] = seconds;
+    app.graph?.setDirtyCanvas?.(true, false);
+  });
+  signal.addEventListener("abort", stop);
 }
 
 function disableRuntime() {
   runtime.abort?.abort();
   runtime.abort = null;
   runtime.state = createRunState();
+  runtime.kept = null;
   try {
     clearBadges();
     app.graph?.setDirtyCanvas?.(true, false);
@@ -334,9 +364,10 @@ function drawNodeBadge(node, ctx) {
     const padX = 5;
     const height = 15;
     const width = Math.ceil(ctx.measureText(badge.text).width) + padX * 2;
-    // Top-right, floating just above the title bar so it never covers
-    // the node title or its widgets.
-    const x = node.size[0] - width;
+    // Top-left, floating just above the title bar so it never covers the
+    // node title or its widgets. The right side belongs to the frontend's
+    // own node-source badge, which sits at the same height.
+    const x = 0;
     const y = -titleHeight - height - 4;
     roundedRectPath(ctx, x, y, width, height, 4);
     ctx.fillStyle = "rgba(8, 20, 19, 0.85)";

js/compare/index.js

@@ -1,24 +1,48 @@
-import { api } from "/scripts/api.js";
-import { app } from "/scripts/app.js";
-import { BRAND, chainCallback, keepDomWidgetWidthAuto } from "../shared/index.mjs";
+import { api } from "../../../scripts/api.js";
+import { app } from "../../../scripts/app.js";
+import { isForeignRun, outputKey } from "../shared/prompt_scope.mjs";
+import { BRAND, chainCallback, keepDomWidgetWidthAuto, notifyAusbossChange } from "../shared/index.mjs";
+import { lookupLink } from "../shared/graph_links.mjs";
+import { WIDGET_FRAME, fillNodeHeight, growToNodeFloor } from "../shared/panel_layout.mjs";
 import { mediaViewQuery, responsivePreviewHeight } from "../shared/video_preview.mjs";
-import { VIDEO_MIN_WIDTH, ensureVideoCss, makeToolButton } from "../shared/video_ui.mjs";
+import { makeSlideSwitch } from "../shared/slide_switch.mjs";
+import { makePictureStepper } from "../shared/picture_stepper.mjs";
+import { keepIndex, stepIndex } from "../shared/picture_steps.mjs";
+import { VIDEO_MIN_WIDTH, ensureVideoCss } from "../shared/video_ui.mjs";
 import {
-  clipFraction,
+  slideFraction,
+  compareBadges,
   compareClip,
-  findCompareImages,
+  compareResultSide,
+  compareSizeLabel,
+  compareSwitchValue,
+  findComparePairs,
   normalizeCompareMode,
+  sizeAfterErase,
 } from "../shared/compare.mjs";
+import { CHECKER, backdropPadding, savedLinks } from "../shared/compare_erase.mjs";
+import { ERASE_CSS, makeEraser } from "../shared/compare_erase_stage.mjs";
 
 const NODE_NAME = "AUSBOSS_NODES_Compare";
 const PANEL_WIDGET = "ausboss_compare_panel";
 const PANEL_CHROME = 12;
-const CSS_ID = "ausboss-compare-ui-v1";
-
-const MODE_HINTS = {
-  slide: "Move across the panel to reveal B",
-  hold: "Press and hold to see B",
-};
+// The stage floor plus the caption row that now sits under it.
+const CAPTION_HEIGHT = 24;
+const PANEL_MIN_HEIGHT = 144 + CAPTION_HEIGHT;
+// Height the node opens at. It used to fall out of computeSize; with the panel
+// now free to grow, the default has to be stated somewhere, and a 16:9-ish
+// stage is the shape most A/B pairs want.
+const DEFAULT_NODE_SIZE = [
+  420,
+  responsivePreviewHeight(420, 132, 520) + PANEL_CHROME + CAPTION_HEIGHT + 60,
+];
+const CSS_ID = "ausboss-compare-ui-v6";
+const ROOT_GAP = 6;
+const FOOTER_GAP = 8;
+const BADGE_WIDTH = 22;
+const REST_SETTING = "AusBoss.Compare.RestOnResult";
+const SIZE_BEFORE_ERASE = "ausboss_compare_size_before_erase";
+let restOnResult = true;
 
 function ensureCompareCss() {
   ensureVideoCss(); // tool button styles are shared with the video panels
@@ -26,16 +50,26 @@ function ensureCompareCss() {
   const style = document.createElement("style");
   style.id = CSS_ID;
   style.textContent = `
-.ausboss-compare-root{box-sizing:border-box;width:100%;height:100%;display:flex;flex-direction:column;gap:6px;padding:2px 6px 6px;color:#d8eeee;font:11px/1.35 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;overflow:hidden;}
+.ausboss-compare-root{box-sizing:border-box;width:100%;height:100%;display:flex;flex-direction:column;gap:${ROOT_GAP}px;padding:2px 6px 6px;color:#d8eeee;font:11px/1.35 -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;overflow:hidden;}
 .ausboss-compare-stage{position:relative;flex:1 1 auto;min-height:112px;overflow:hidden;border:1px solid rgba(0,180,170,.34);border-radius:6px;background:#000;box-shadow:inset 0 0 0 1px rgba(255,255,255,.025);touch-action:none;}
 .ausboss-compare-stage img{position:absolute;inset:0;width:100%;height:100%;object-fit:contain;user-select:none;-webkit-user-drag:none;}
 .ausboss-compare-stage.is-empty img{visibility:hidden;}
+.ausboss-compare-stage img.has-alpha{box-sizing:border-box;background-image:repeating-conic-gradient(${CHECKER.light} 0 25%,${CHECKER.dark} 0 50%);background-size:${CHECKER.side * 2}px ${CHECKER.side * 2}px;background-origin:content-box;background-clip:content-box;}
 .ausboss-compare-seam{position:absolute;top:0;bottom:0;z-index:2;width:1px;margin-left:-0.5px;background:${BRAND};box-shadow:0 0 4px rgba(0,180,170,.55);opacity:0;pointer-events:none;}
 .ausboss-compare-status{position:absolute;left:7px;top:7px;z-index:3;max-width:calc(100% - 112px);padding:3px 6px;border-radius:4px;background:rgba(0,0,0,.7);color:#b8d3d1;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;pointer-events:none;backdrop-filter:blur(4px);}
+/* Once the previews are up the status has nothing to say, and an empty chip
+   over the corner of the picture is just something in the way. */
+.ausboss-compare-status:empty{display:none;}
 .ausboss-compare-stage.is-empty .ausboss-compare-status{left:50%;top:50%;max-width:82%;transform:translate(-50%,-50%);color:#78908e;text-align:center;white-space:normal;}
-.ausboss-compare-tools{position:absolute;right:6px;top:6px;z-index:4;display:flex;gap:4px;opacity:.9;}
-.ausboss-compare-tools:hover{opacity:1;}
-`;
+.ausboss-compare-footer{display:flex;align-items:center;gap:${FOOTER_GAP}px;flex:none;height:24px;}
+.ausboss-compare-identity{position:absolute;left:0;right:0;top:7px;height:22px;z-index:3;pointer-events:none;}
+.ausboss-compare-identity span{position:absolute;top:0;width:${BADGE_WIDTH}px;height:22px;border-radius:4px;background:rgba(0,0,0,.7);color:#d8eeee;font-weight:600;text-align:center;line-height:22px;}
+.ausboss-compare-identity span[hidden]{display:none;}
+.ausboss-compare-stage.is-empty .ausboss-compare-identity{display:none;}
+.ausboss-compare-caption{flex:1;min-width:0;height:${CAPTION_HEIGHT}px;overflow:hidden;color:#8ba3a1;font-size:10px;line-height:${CAPTION_HEIGHT}px;text-align:center;white-space:nowrap;text-overflow:ellipsis;}
+.ausboss-compare-caption a{color:${BRAND};font-weight:700;text-decoration:none;cursor:pointer;}
+.ausboss-compare-caption a:hover{text-decoration:underline;}
+${ERASE_CSS}`;
   document.head.appendChild(style);
 }
 
@@ -47,42 +81,208 @@ function getMode(node) {
   return node.properties.ausboss_compare_mode;
 }
 
+// One floor for every mode: Erase fits its rows into the node as it is, so
+// picking it never moves the node's edge over its neighbours.
+const PANEL_FLOOR = PANEL_MIN_HEIGHT + WIDGET_FRAME;
+
+// A and B ride on either side of the split line (compareBadges), so each
+// label sits on the picture it names wherever the line is.
 function applyClip(state) {
-  const { clipPath, seamLeft, seamVisible } = compareClip(state.fraction);
-  state.imageB.style.clipPath = clipPath;
+  const { clipPath, seamLeft, seamVisible, showA, showB } = compareClip(state.fraction);
+  state.imageA.style.clipPath = clipPath;
+  // "" hands a picture back to the stylesheet, which hides both while the
+  // stage is empty.
+  state.imageA.style.visibility = showA ? "" : "hidden";
+  state.imageB.style.visibility = showB ? "" : "hidden";
   state.seam.style.left = seamLeft;
   state.seam.style.opacity = seamVisible ? "1" : "0";
+  const places = compareBadges(state.fraction, state.stage.clientWidth || 0, BADGE_WIDTH);
+  for (const [badge, left] of [[state.identityLeft, places.a], [state.identityRight, places.b]]) {
+    badge.hidden = left == null;
+    if (left != null) badge.style.left = `${left}px`;
+  }
+  state.identity.title = seamVisible ? "A on the left of the line · B on the right" : `Showing ${state.fraction === 0 ? "B" : "A"}`;
+  state.identity.setAttribute("aria-label", state.identity.title);
+}
+
+// A picture with see-through parts lies on a checkerboard. It is the
+// picture's own background, held to the picture by padding the size of the
+// bars beside it, so in Slide the cut that shows A hides B behind A's clear
+// parts too.
+function placeBackdrops(state) {
+  const { clientWidth, clientHeight } = state.stage;
+  for (const [image, ref] of [[state.imageA, state.refs?.a], [state.imageB, state.refs?.b]]) {
+    const clear = Boolean(ref?.alpha) && image.naturalWidth > 0;
+    image.classList.toggle("has-alpha", clear);
+    image.style.padding = clear ? backdropPadding(clientWidth, clientHeight, image.naturalWidth, image.naturalHeight) : "";
+  }
 }
 
 function setEmpty(state, text) {
   state.stage.classList.add("is-empty");
   state.status.textContent = text;
+  state.caption.textContent = "";
 }
 
 function setReady(state) {
   state.stage.classList.remove("is-empty");
-  const mode = getMode(state.node);
-  const size = state.refs?.a?.width
-    ? `${state.refs.a.width}×${state.refs.a.height} · `
-    : "";
-  state.status.textContent = `${size}${MODE_HINTS[mode]}`;
+  // Keep loading/error status separate from the image identity label.
+  state.status.textContent = "";
+  state.caption.textContent = compareSizeLabel(state.refs);
+}
+
+// After a save the caption names the files as links: ComfyUI often runs on
+// another computer, and this is how the mix gets from there to an editor.
+// The next pair of pictures puts the size back.
+function showSaved(state, files) {
+  const links = savedLinks(files);
+  if (!links.length) return;
+  state.caption.textContent = "Saved ";
+  links.forEach(({ label, file }, index) => {
+    const link = document.createElement("a");
+    link.textContent = label;
+    link.href = api.apiURL(`/view?${mediaViewQuery(file, "output")}`);
+    link.download = file.filename;
+    link.title = `Download ${file.filename}`;
+    link.addEventListener("pointerdown", (event) => event.stopPropagation());
+    state.caption.append(index ? " · " : "", link);
+  });
 }
 
 function updateModeButtons(state) {
-  const mode = getMode(state.node);
-  state.slideButton.classList.toggle("active", mode === "slide");
-  state.holdButton.classList.toggle("active", mode === "hold");
-  if (!state.stage.classList.contains("is-empty")) setReady(state);
+  state.modeSwitch.set(compareSwitchValue(getMode(state.node), state.showingB));
+}
+
+// Hand the stage to the brush, or take it back, when the mode says so. The
+// node keeps its size: Erase's rows wrap and take their room from the
+// picture. Pack 2.12.1 grew a small node for Erase and kept the size from
+// before with the workflow; a node saved like that still gets it back.
+function syncErase(state) {
+  const node = state.node;
+  const on = getMode(node) === "erase";
+  if (state.eraser.active === on) return;
+  state.eraser.setActive(on);
+  if (on || !node.size) return;
+  const back = sizeAfterErase([...node.size], node.properties[SIZE_BEFORE_ERASE]);
+  delete node.properties[SIZE_BEFORE_ERASE];
+  if (back) node.setSize?.(back);
+}
+
+// In toggle mode the reveal is all or nothing.
+function applyToggle(state) {
+  state.fraction = state.showingB ? 0 : 1;
+  applyClip(state);
+  updateModeButtons(state);
+  state.node.setDirtyCanvas?.(true, true);
+}
+
+// One graph's links, in the shape compareResultSide reads them.
+function linkView(graph) {
+  const origin = (linkId) => {
+    const link = lookupLink(graph, linkId);
+    return link ? { id: String(link.origin_id), slot: link.origin_slot } : null;
+  };
+  return {
+    origin,
+    feeds: (id) => (graph?.getNodeById?.(id)?.inputs ?? []).map((input) => origin(input?.link)?.id),
+    inside(id) {
+      const subgraph = graph?.getNodeById?.(id)?.subgraph;
+      if (!subgraph) return null;
+      const view = linkView(subgraph);
+      return { ...view, output: (slot) => view.origin(subgraph.outputs?.[slot]?.linkIds?.[0]) };
+    },
+  };
+}
+
+// Which input holds the result, read from the graph the panel sits in.
+function resultSide(node) {
+  const view = linkView(node.graph);
+  const source = (name) => view.origin(node.inputs?.find((input) => input?.name === name)?.link);
+  return compareResultSide(source("image_a"), source("image_b"), view);
+}
+
+// Slide mode rests on the result while the pointer is away.
+function showResult(state) {
+  state.fraction = resultSide(state.node) === "B" ? 0 : 1;
+  applyClip(state);
+}
+
+// A click on the mode switch. The mode saves with the workflow; a flip
+// between A and B within the lock does too, through the side it stores.
+function pickMode(state, value) {
+  const node = state.node;
+  const before = compareSwitchValue(getMode(node), state.showingB);
+  if (value === "slide") {
+    node.properties.ausboss_compare_mode = normalizeCompareMode("slide");
+    state.showingB = false;
+    state.fraction = 1;
+    syncErase(state);
+    if (restOnResult) showResult(state);
+    else applyClip(state);
+  } else if (value === "erase") {
+    node.properties.ausboss_compare_mode = "erase";
+    syncErase(state);
+  } else {
+    // Keep the legacy mode key; the optional side property restores new locks.
+    node.properties.ausboss_compare_mode = "toggle";
+    node.properties.ausboss_compare_side = value === "b" ? "B" : "A";
+    state.showingB = value === "b";
+    syncErase(state);
+    applyToggle(state);
+  }
+  updateModeButtons(state);
+  node.setDirtyCanvas?.(true, true);
+  if (value !== before) notifyAusbossChange();
 }
 
 function loadPreviews(state, refs) {
   state.refs = refs;
   state.loaded = 0;
+  state.eraser.setPictures(null);
   setEmpty(state, "Loading previews…");
+  // A new pair opens on the result, unless a lock or the pointer holds the view.
+  if (restOnResult && getMode(state.node) === "slide" && !state.stage.matches(":hover")) showResult(state);
   state.imageA.src = api.apiURL(`/view?${mediaViewQuery(refs.a, "temp")}`);
   state.imageB.src = api.apiURL(`/view?${mediaViewQuery(refs.b, "temp")}`);
 }
 
+// The arrows need room beside the mode switch. While they show, the node's
+// floor is what the footer's fixed parts take, measured; the caption gives
+// way first.
+function compareMinWidth(state) {
+  if (!state || state.stepper.root.hidden) return VIDEO_MIN_WIDTH;
+  const parts = state.stepper.root.offsetWidth + state.modeSwitch.root.offsetWidth;
+  if (!parts || !state.footer.clientWidth) return VIDEO_MIN_WIDTH;
+  const inset = state.node.size[0] - state.footer.clientWidth;
+  return Math.max(VIDEO_MIN_WIDTH, Math.ceil(inset + parts + 2 * FOOTER_GAP));
+}
+
+// A run's pairs. The panel shows one, and the arrows step through the rest:
+// a list of pictures runs the node once per picture.
+function showPairs(state, pairs) {
+  const hidden = state.stepper.root.hidden;
+  state.pairs = pairs;
+  state.index = keepIndex(state.index, pairs.length);
+  state.stepper.set(state.index, pairs.length);
+  if (state.stepper.root.hidden !== hidden) growToNodeFloor(state.widget);
+  if (pairs.length) loadPreviews(state, pairs[state.index]);
+}
+
+// Align swaps B for B lined up with A, or back: the pair on screen changes,
+// and so does the one the arrows come back to.
+function showAligned(state, refs) {
+  if (!refs) return;
+  if (state.pairs[state.index]) state.pairs[state.index] = refs;
+  loadPreviews(state, refs);
+}
+
+function stepPair(state, step) {
+  if (state.pairs.length < 2) return;
+  state.index = stepIndex(state.index, state.pairs.length, step);
+  state.stepper.set(state.index, state.pairs.length);
+  loadPreviews(state, state.pairs[state.index]);
+}
+
 function buildPanel(node) {
   if (node.__ausbossCompare) return node.__ausbossCompare;
   ensureCompareCss();
@@ -98,122 +298,194 @@ function buildPanel(node) {
   const status = document.createElement("div");
   status.className = "ausboss-compare-status";
   status.textContent = "Run to load the A/B previews";
-  const tools = document.createElement("div");
-  tools.className = "ausboss-compare-tools";
-  const slideButton = makeToolButton("SLIDE", "Slide: the seam follows the pointer across the image");
-  const holdButton = makeToolButton("HOLD", "Hold: press and hold anywhere to see B, release for A");
-  tools.append(slideButton, holdButton);
-  stage.append(imageA, imageB, seam, status, tools);
-  root.append(stage);
+  const identity = document.createElement("div");
+  identity.className = "ausboss-compare-identity";
+  const identityLeft = document.createElement("span");
+  const identityRight = document.createElement("span");
+  identityLeft.textContent = "A";
+  identityRight.textContent = "B";
+  identity.append(identityLeft, identityRight);
+  const abort = new AbortController();
+  const signal = abort.signal;
+  // One switch for what the panel does: slide across the pair, hold one of
+  // the two, or mix them with the brush. Its marker slides to the choice.
+  const modeSwitch = makeSlideSwitch({
+    label: "What the panel does",
+    // Each choice as wide as its name, so the row still fits a narrow node.
+    fit: true,
+    options: [
+      { value: "slide", label: "Slide", title: "Slide: the line follows the pointer across the picture, A on its left and B on its right" },
+      { value: "a", label: "A", title: "Show picture A and hold it" },
+      { value: "b", label: "B", title: "Show picture B and hold it" },
+      { value: "erase", label: "Erase", title: "Erase: rub one picture away with a brush so the other shows through, then save the mix" },
+    ],
+    value: "slide",
+    signal,
+    onChange: (value) => node.__ausbossCompare && pickMode(node.__ausbossCompare, value),
+  });
+  stage.append(imageB, imageA, seam, status, identity);
+  const caption = document.createElement("div");
+  caption.className = "ausboss-compare-caption";
+  const eraser = makeEraser({
+    node, root, stage, imageA, imageB, signal,
+    onSaved: (files) => showSaved(node.__ausbossCompare, files),
+    onAligned: (refs) => node.__ausbossCompare && showAligned(node.__ausbossCompare, refs),
+  });
+  const stepper = makePictureStepper({
+    noun: "pair",
+    signal,
+    onStep: (step) => node.__ausbossCompare && stepPair(node.__ausbossCompare, step),
+  });
+  const footer = document.createElement("div");
+  footer.className = "ausboss-compare-footer";
+  footer.append(stepper.root, caption, modeSwitch.root);
+  root.append(eraser.bar, stage, footer, eraser.saveRow);
 
   const widget = node.addDOMWidget(PANEL_WIDGET, "ausboss_compare", root, {
     serialize: false,
     hideOnZoom: false,
-    getMinHeight: () => 132,
+    getMinHeight: () => PANEL_FLOOR,
   });
   keepDomWidgetWidthAuto(widget);
-  widget.computeSize = (width) => {
-    const resolvedWidth = Math.max(VIDEO_MIN_WIDTH, Number(width || node.size?.[0] || 360));
-    return [resolvedWidth, responsivePreviewHeight(resolvedWidth, 132, 520) + PANEL_CHROME];
-  };
-  widget.computeLayoutSize = () => ({ minWidth: VIDEO_MIN_WIDTH, minHeight: 144 });
-  widget.options ??= {};
-  widget.options.minNodeSize = [VIDEO_MIN_WIDTH, 220];
+  // Not saved with the workflow either: options.serialize only keeps it out
+  // of the prompt, and saved values come back by position.
+  widget.serialize = false;
+  // + WIDGET_FRAME: the frontend insets the element, so a bare floor hands
+  // the panel fewer CSS pixels than the stage + caption minimums and shaves
+  // the caption's glyphs at the node's minimum height.
+  fillNodeHeight(widget, {
+    minWidth: () => compareMinWidth(node.__ausbossCompare),
+    minHeight: PANEL_FLOOR,
+    minNodeSize: [VIDEO_MIN_WIDTH, 220],
+    exactMinWidth: true,
+  });
 
-  const abort = new AbortController();
   const state = node.__ausbossCompare = {
-    node, root, stage, imageA, imageB, seam, status, slideButton, holdButton,
-    widget, abort, refs: null, fraction: 0, loaded: 0, holding: false,
+    node, root, stage, imageA, imageB, seam, status, caption, identity, identityLeft, identityRight,
+    footer, modeSwitch, eraser, stepper,
+    widget, abort, refs: null, pairs: [], index: 0, fraction: 1, loaded: 0, showingB: false,
   };
   applyClip(state);
   updateModeButtons(state);
 
-  const signal = abort.signal;
-  const setMode = (mode) => (event) => {
-    event.preventDefault();
-    event.stopPropagation();
-    node.properties.ausboss_compare_mode = normalizeCompareMode(mode);
-    if (mode !== "hold") state.holding = false;
-    state.fraction = 0;
+  // The labels are placed in pixels, so they follow the stage's width.
+  const resized = new ResizeObserver(() => {
     applyClip(state);
-    updateModeButtons(state);
-    node.setDirtyCanvas?.(true, true);
-  };
-  slideButton.addEventListener("click", setMode("slide"), { signal });
-  holdButton.addEventListener("click", setMode("hold"), { signal });
-
-  // The panel owns pointer movement only inside itself; pointerdown is never
-  // prevented, so dragging the node from its title keeps working. Events
-  // born in the tools bar never reach the stage behaviors — in hold mode a
-  // stage pointerdown captures the pointer, which would retarget the
-  // release and eat the button's click (the "stuck on HOLD" bug).
+    placeBackdrops(state);
+  });
+  resized.observe(stage);
+  signal.addEventListener("abort", () => resized.disconnect());
+  // Movement belongs to the preview only; graph dragging and panning remain
+  // untouched. A/B locks ignore pointer movement and exits.
   stage.addEventListener("pointermove", (event) => {
-    if (tools.contains(event.target)) return;
-    if (!state.refs || getMode(node) !== "slide" || state.holding) return;
+    if (!state.refs || getMode(node) !== "slide") return;
     const rect = stage.getBoundingClientRect();
-    state.fraction = clipFraction(event.clientX, rect.left, rect.width);
+    state.fraction = slideFraction(event.clientX, rect.left, rect.width);
     applyClip(state);
   }, { signal });
 
-  stage.addEventListener("pointerdown", (event) => {
-    if (tools.contains(event.target)) return;
-    if (!state.refs || getMode(node) !== "hold") return;
-    state.holding = true;
-    state.fraction = 1;
+  // Back to the result on every exit, including top/bottom. With the
+  // setting off, settle to the nearest full image instead.
+  stage.addEventListener("pointerleave", (event) => {
+    if (!state.refs || getMode(node) !== "slide") return;
+    if (restOnResult) return showResult(state);
+    const rect = stage.getBoundingClientRect();
+    state.fraction = slideFraction(event.clientX, rect.left, rect.width, true);
     applyClip(state);
-    try {
-      stage.setPointerCapture(event.pointerId);
-    } catch {
-      // Pointer capture is best-effort; release still arrives via the
-      // window when the browser refuses it.
-    }
   }, { signal });
 
-  const endHold = () => {
-    if (!state.holding) return;
-    state.holding = false;
-    state.fraction = 0;
-    applyClip(state);
-  };
-  stage.addEventListener("pointerup", endHold, { signal });
-  stage.addEventListener("pointercancel", endHold, { signal });
-
   const onImageLoad = () => {
+    placeBackdrops(state);
     state.loaded += 1;
     if (state.loaded >= 2) {
       setReady(state);
+      eraser.setPictures(state.refs);
       node.setDirtyCanvas?.(true, true);
     }
   };
   imageA.addEventListener("load", onImageLoad, { signal });
   imageB.addEventListener("load", onImageLoad, { signal });
-  const onImageError = () => setEmpty(state, "A compare preview could not load");
+  const onImageError = () => {
+    eraser.setPictures(null);
+    setEmpty(state, "A compare preview could not load");
+  };
   imageA.addEventListener("error", onImageError, { signal });
   imageB.addEventListener("error", onImageError, { signal });
 
   return state;
 }
 
+// Going back to a workflow tab puts its results back in ComfyUI's store,
+// but the panel only ever filled from onExecuted. Show the stored pair.
+function showStoredResult(node) {
+  const state = node.__ausbossCompare;
+  if (!state || state.refs) return;
+  showPairs(state, findComparePairs(app.nodeOutputs?.[outputKey(node, app.rootGraph ?? app.graph)]));
+}
+
 app.registerExtension({
   name: "ausboss.compare.panel",
+  settings: [
+    {
+      id: REST_SETTING,
+      name: "Rest on the result",
+      type: "boolean",
+      defaultValue: true,
+      category: ["🆎 AusBoss", "Image Compare", "Rest on the result"],
+      tooltip:
+        "While the pointer is away, Image Compare A/B shows the result: "
+        + "after every run, and again each time the pointer leaves the "
+        + "picture. Off: it stays on the picture nearest to where the "
+        + "pointer left, and a new run does not change it.",
+      onChange(value) {
+        restOnResult = value !== false;
+      },
+    },
+  ],
+  setup() {
+    // onChange only fires on later edits, so seed from the stored value here.
+    restOnResult = app.ui?.settings?.getSettingValue?.(REST_SETTING) !== false;
+  },
+  onNodeOutputsUpdated() {
+    setTimeout(() => {
+      for (const node of app.graph?._nodes ?? []) if (node?.comfyClass === NODE_NAME) showStoredResult(node);
+    }, 0);
+  },
   beforeRegisterNodeDef(nodeType, nodeData) {
     if (nodeData?.name !== NODE_NAME) return;
     chainCallback(nodeType.prototype, "onNodeCreated", function () {
       buildPanel(this);
+      // Only for a genuinely new node: onConfigure restores a saved size after
+      // this runs, so a workflow's own dimensions still win.
+      this.setSize?.([
+        Math.max(DEFAULT_NODE_SIZE[0], this.size?.[0] ?? 0),
+        Math.max(DEFAULT_NODE_SIZE[1], this.size?.[1] ?? 0),
+      ]);
     });
     chainCallback(nodeType.prototype, "onConfigure", function () {
+      const state = this.__ausbossCompare;
       queueMicrotask(() => {
-        const state = buildPanel(this);
-        updateModeButtons(state);
+        if (!state || this.__ausbossCompare !== state || state.abort.signal.aborted) return;
+        state.showingB = this.properties?.ausboss_compare_side === "B";
+        syncErase(state);
+        // The saved paint, if the pictures are already up.
+        if (state.refs && state.loaded >= 2) state.eraser.setPictures(state.refs);
+        if (getMode(this) === "toggle") applyToggle(state);
+        else updateModeButtons(state);
       });
     });
     chainCallback(nodeType.prototype, "onExecuted", function (message) {
+      if (isForeignRun()) return;
       const state = buildPanel(this);
-      const refs = findCompareImages(message);
-      if (refs) loadPreviews(state, refs);
-      else setEmpty(state, "Execution finished without compare previews");
+      const pairs = findComparePairs(message);
+      showPairs(state, pairs);
+      if (!pairs.length) setEmpty(state, "Execution finished without compare previews");
       app.canvas?.setDirty?.(true, true);
     });
+    // A link on the filename input decides whether the name is typed here.
+    chainCallback(nodeType.prototype, "onConnectionsChange", function () {
+      this.__ausbossCompare?.eraser?.refresh();
+    });
     chainCallback(nodeType.prototype, "onRemoved", function () {
       this.__ausbossCompare?.abort?.abort();
       this.__ausbossCompare = null;

js/docs/AUSBOSS_NODES_AlignImage.md

@@ -8,20 +8,36 @@ cleanly; this node makes any input legal without hand-typing resolutions.
 ## Controls
 
 - **image**: BHWC batch to align; every frame is treated the same.
-- **multiple**: Both output sides come out divisible by this. `16` or `32`
-  suits most diffusion models; latent nodes generally want at least `8`.
-- **mode**: How the multiple is reached. Each mode implies its own rounding
-  direction, so there is no separate rounding widget:
+- **Multiple** (`multiple`, starts at `16`): Both output sides come out
+  divisible by this. `16` or `32` suits most diffusion models; latent nodes
+  generally want at least `8`.
+- **Mode** (`mode`): How the multiple is reached. Each mode implies its own
+  rounding direction, so there is no separate rounding widget:
   - **resize** — rescale to the *nearest* multiple. A slight stretch, but
     every pixel's content survives. The default.
-  - **crop** — center-crop *down* to the next multiple. No distortion; a few
-    edge pixels are trimmed.
-  - **pad** — replicate-pad the edges *up* to the next multiple, split
-    evenly. No distortion; a few edge pixels are invented by repetition.
+  - **crop** — crop *down* to the next multiple. No distortion; a few edge
+    pixels are trimmed where **Anchor** says.
+  - **pad** — pad the edges *up* to the next multiple. No distortion; the
+    new pixels land where **Anchor** says and are filled per **Pad fill**.
+- **Anchor** (`crop_position`): Crop mode only — which part of the frame
+  survives. `center` trims both edges evenly; `top`, `bottom`, `left`, or
+  `right` pin that edge and trim the opposite one. Ignored by resize and pad.
+- **Anchor** (`pad_position`): Pad mode only — where the image sits on the
+  grown canvas; the new pixels land on the opposite side. `center` splits
+  them evenly. Same vocabulary as `crop_position`.
+- **Pad fill** (`pad_fill`): Pad mode only — what fills the new area.
+  `replicate` stretches the edge pixels out; `color` uses **Pad color** as a
+  solid.
+- **Pad color** (`pad_color`, starts black): The solid fill, shown only
+  while **Pad fill** is `color`. Hex, `R,G,B` numbers, or a CSS color name;
+  a color the node cannot read becomes mid-gray.
+
+The two **Anchor** rows, **Pad fill** and **Pad color** only show in the
+mode that uses them.
 
 A side already smaller than one multiple can never be cropped legal, so it
-snaps up to exactly one multiple in every mode (replicate-padded when the
-mode would otherwise shrink it).
+snaps up to exactly one multiple in every mode (in crop mode the deficit is
+replicate-padded evenly, whatever the **Anchor**).
 
 ## Outputs
 
@@ -30,6 +46,7 @@ mode would otherwise shrink it).
   Latent, a resize, or conditioning nodes so the numbers can never drift
   from the actual image.
 
+
 ## Notes
 
 At most `multiple - 1` pixels are added or removed per side, so the change

js/docs/AUSBOSS_NODES_Callout.md

@@ -0,0 +1,94 @@
+# Callout
+
+A note for the canvas. Type a line or two and the text grows to fill the
+note, so people can read it without zooming in. Type an arrow emoji such as ⬆️
+to point at the part you are talking about.
+
+Use it to explain a step in a workflow you share. It never runs and has no
+wires.
+
+## Tile presets
+
+Right-click the Callout and choose **Title tile** to give your existing text a black heading with a teal accent. **Set YouTube link tile** and **Set Discord link tile** fill in the AusBoss link and label. Click the label to open the link, or drag the tile to move it. Choose **Plain callout** to return to the standard style with the current text.
+
+- Press **Edit** on a tile to open a larger editor. A link tile has separate **Button text** and **Link address** fields. Existing mixed text stays in a text box.
+- Double-click a title to edit it. **Save** or `Ctrl+Enter` keeps the change; **Cancel** or `Esc` leaves the original text.
+- Drag the visible bottom-right grip to resize. You can also focus the grip and use arrow keys; hold **Shift** for smaller changes. Resizing keeps the tile in place and supports Undo.
+
+## Writing
+
+- On a plain callout, double-click the note, or press **Edit**, to type. Click outside the box to
+  keep the text. **Esc** drops what you typed.
+- A blank line starts a new point. Each point gets a thin teal line beside it.
+- Put two stars around a word to stress it: `**Resize is on.**`
+- For the details, make a line **small print**: put the caret on it and press
+  **Small** under the text box. It is drawn small under the line above, so
+  the first line stays big enough to read from far out. Press **Small** again
+  to make it normal.
+- A line that starts with `##` is read the same as one that doesn't, so notes
+  written for the core Markdown Note paste in as they are.
+- Drag the corner to change the size. The text grows or shrinks to fit.
+
+## Arrows
+
+Type an arrow and it turns into a teal arrow, in the middle of your line.
+
+- Use an arrow emoji: ⬆️ ⬇️ ⬅️ ➡️ ↗️ ↘️ ↙️ ↖️. The pointing hands 👆 👇 👈 👉
+  and the plain arrows ← ↑ → ↓ work too, and so do `->` and `<-`.
+- Or press an arrow in the row under the text box while you edit.
+- Put the note next to the part it explains and point the arrow at it.
+
+### Link an arrow to a node
+
+While you edit, click a node on the canvas, then press an arrow. The arrow is
+linked to that node. Click a linked arrow later and the canvas brings the node
+into view, the same way the frame button in Workflow Switches does. Hover the
+arrow to see which node it goes to.
+
+In the text a linked arrow is written like `➡️#12`, where 12 is the node's
+number. You can leave the `#12` out to get a plain arrow. If the node is
+deleted the arrow stays, faded, and does nothing.
+
+## Links
+
+A note can link to a page on the web, or to a part of the workflow.
+
+- **To a page:** select the words, press **Link** under the text box, and
+  paste the address. Or select the words and paste the address straight over
+  them. Click the words later and the page opens in a new tab. A small ↗
+  after the words shows that they leave ComfyUI, and hovering shows where
+  they go.
+- **To a node or a group:** while you edit, click the node or the group on
+  the canvas, select the words and press **Link**. Click the words later and
+  the canvas brings it into view. An arrow can point at a group too: click
+  the group, then press an arrow.
+- A note that is nothing but one link is a big button for it: its words fill
+  the note.
+
+In the text a link is written `[the words](https://example.com)`, or
+`[the words](#12)` for node 12 and `[the words](#g3)` for group 3.
+
+## Technical details
+
+- The text is stored in the node's one hidden `text` input, so saving,
+  undo and copy work like any other node. Nothing else is saved with it.
+- A note copied together with the nodes and groups its links name links to
+  the copies. A link to anything left behind keeps its number.
+- In the text, small print is a line that starts with six `#` and a space:
+  `###### Off, your words go in as typed.` Small print is 62% of the note's
+  text size and never under 11 px.
+- Notes written before small print look the same. An older version of the
+  pack drops those six `#` like any other heading mark, so a note with small
+  print still reads right there, with every line at one size.
+- The text size is the largest whole pixel size, from 12 to 30, that fits the
+  note. A very long text at the smallest size is cut off at the bottom: make
+  the note taller.
+- Only `http` and `https` addresses become links. Anything else in the round
+  brackets leaves the text as typed. A link opens in a new tab and is never
+  opened by the note itself: only your click does.
+- A link from someone else's workflow goes where its author pointed it. Hover
+  it to read the address before you click.
+- An older version of the pack shows a link as typed, brackets and address
+  included, so the address can still be read and copied there.
+- The font is IBM Plex Sans when the computer has it, otherwise the system
+  font. The node loads no fonts and makes no network requests.

js/docs/AUSBOSS_NODES_CalloutTile.md

@@ -0,0 +1,7 @@
+# Callout Tile
+
+A compact title or colored link button for a workflow. Choose **Title tile**, **Set YouTube link tile**, or **Set Discord link tile** from its menu. Press **Edit** to change its text or link; you can also double-click a title. Drag its visible corner to resize.
+
+It uses the same text, arrows and links as [Callout](AUSBOSS_NODES_Callout.md). **Plain callout** returns to the ordinary note face. Nothing runs and it has no outputs.
+
+Tiles save with their own node type. If ComfyUI reports this node missing, install or update **ComfyUI-AusBoss**, restart ComfyUI, and reload the workflow. An older pack cannot draw the tile correctly. Keep the missing node so its text and settings are preserved.

js/docs/AUSBOSS_NODES_ColorMatch.md

@@ -1,30 +1,55 @@
 # Color Match
 
-Copies the color statistics of a reference image onto the input. Both images
-are converted to LAB, the per-channel mean and spread of the input are mapped
-onto the reference's, and the result is converted back — the classic fix for
-an inpainted or stitched region that came back with a slight color cast.
+Makes one picture's colors match another's. Use it when an inpainted or
+stitched area comes back a little too warm, cool, dark or bright next to the
+original. Four methods go from a gentle fix to an exact match, and a
+first-frame mode matches every frame of a video to its first, which can
+reduce color drift between frames.
 
 ## Controls
 
 - **image**: The image to correct.
-- **reference**: The image whose look to copy. For a stitched inpaint, feed
-  the original image here. A single reference broadcasts across a batch;
-  a matched batch pairs frame to frame.
-- **strength**: `0` returns the input untouched, `1` applies the full match;
-  values between blend linearly.
+- **Strength** (`strength`, starts at `1`): `0` returns the input untouched,
+  `1` applies the full match; values between blend linearly.
+- **reference** (optional): The image whose look to copy. For a stitched
+  inpaint, feed the original image here. A single reference broadcasts
+  across a batch; a matched batch pairs frame to frame. Required unless
+  **Reference** (`reference_mode`) is **first frame**.
+- **Method** (`method`): How the colors move.
+  - **lab** — per-channel mean/std shift in LAB. Perceptual and the safe
+    default: corrects overall casts and contrast without shifting
+    individual hues around.
+  - **rgb** — the same mean/std shift in raw channels.
+  - **mkl** — maps the full color covariance; best when hues are rotated,
+    not just shifted.
+  - **hist** (`histogram`) — matches each channel's distribution exactly.
+    The strongest and least subtle.
 - **mask** (optional): Restricts the match to the white area — both the
   statistics measured on the image and where the correction lands. Black
   pixels pass through **bit-identical**. Reference statistics always come
-  from the whole reference frame.
+  from the whole reference frame. Without a mask the whole image is
+  matched. A mask of another size than the image stops the run.
+- **Invert mask** (`invert_mask`): Treats the mask's black area as the region
+  to correct instead of the white area.
+- **Reference** (`reference_mode`): Where the target statistics come from.
+  **reference** uses the connected reference image. **first frame**
+  (`first_frame`) uses the batch's own first frame as the target for every frame, no reference
+  needed; the `reference` input is ignored. That can reduce color drift
+  between frames; it does not stabilize motion.
 
 ## Outputs
 
-- **image**: The color-matched image.
+- **image**: The color-matched image; pixels outside the mask are untouched.
 
 ## Notes
 
-- The transfer is per-channel mean/std in LAB, so it corrects overall casts
-  and contrast without shifting individual hues around.
-- Pair it with **Stitch Inpaint 🆎**: stitch first, then match the
-  blended region back to the original using the inpaint mask.
+- The node takes a mask but outputs none on purpose: the mask only scopes
+  the fix and passes through your graph unchanged — wire your original
+  mask onward.
+- Pair it with **Stitch Inpaint 🆎**: stitch first, then wire Stitch
+  Inpaint's `blend_mask` into **mask** and the original picture into
+  **reference**. That matches exactly the pasted area back to the original.
+- For video whose color drifts between frames, **Reference** set to
+  **first frame** matches every frame to the clip's opening color. It cannot
+  stabilize motion, and frames whose content changes, such as a pan onto a
+  darker scene, are pulled toward the first frame's colors as well.

js/docs/AUSBOSS_NODES_Compare.md

@@ -1,31 +1,193 @@
-# A/B Compare
+# Image Compare A/B
 
 Shows two images on one panel so differences pop out instead of hiding in a
-side-by-side. The first frame of each batch is previewed; `image_a` passes
-through the output unchanged, so the node can sit in the middle of a graph
-without breaking anything downstream.
+side-by-side. The first frame of each batch is previewed; `image_a` and
+`image_b` pass through their outputs unchanged, so the node can sit in the
+middle of a graph without breaking anything downstream.
 
 ## Inputs
 
 - **image_a**: The baseline batch. Its first frame is preview A, and the
-  whole batch is what the output carries.
-- **image_b**: The comparison batch. Its first frame is preview B.
+  whole batch is what the `image_a` output carries.
+- **image_b**: The comparison batch. Its first frame is preview B, and the
+  whole batch is what the `image_b` output carries.
+- **filename** (optional): a name for the files that **Erase** saves, such
+  as the source picture's file name. Leave it unwired to type the name on
+  the node.
 
 ## Panel
 
-Run the workflow once to load the previews, then compare:
+Run the workflow once to load the previews. The switch under the picture
+picks what the panel does, and its marker slides to your choice:
 
-- **Slide** (default): move the pointer across the panel. B is revealed up
-  to the pointer with a thin seam marking the split.
-- **Hold**: press and hold anywhere on the panel to see B in full; release
-  to snap back to A.
+- **Slide** (default): the panel shows the result. Move the pointer across
+  it to compare: A appears on the left of the line and B on the right. Move
+  the pointer away and the result is back. Every new run shows its result
+  too.
+- **A** / **B**: show that picture and hold it, whatever the pointer does.
+- **Erase**: mix the two pictures by hand. One picture is on top; paint on
+  it and it rubs away, so the other one shows through. Then save the mix.
+  See **Erase** below.
 
-The button in the panel's corner switches between the two modes, and the
-choice is stored with the node.
+A picture with see-through parts shows them over a checkerboard, as an
+editor does.
 
-## Output
+The labels ride with the split line: **A** just left of it and **B** just right of
+it, on the picture each one names. With one picture showing, its label sits alone
+at the top centre. The chosen mode and locked side are
+stored with the node, including support for modes from older workflows. The resolution
+sits under the picture, beside the switch; differing sizes are
+labeled individually.
+
+## Several pictures
+
+Give the node a list of pictures, such as a folder of images, and it shows
+arrows under the picture (‹ 2 / 5 ›). Click them to step through the pairs:
+A and B change together. **Erase** saves the pair you are looking at.
+
+A batch still shows its first frame only.
+
+## Erase
+
+Use it when you want part of one picture and part of the other: the edit
+is good but it changed the hands, so you paint the old hands back. Or you
+only want the new sky.
+
+It also brings back a clear background. When the picture underneath has
+see-through parts, such as a cut-out the model filled in behind, rub the
+top one away there and they come back clear. The saved PNG and PSD keep
+them.
+
+Pick **Erase** on the switch. A row of tools opens above the picture:
+
+- **Erase | Restore**: what the brush does. Erase rubs the top picture
+  away. Restore paints it back. Holding **Ctrl**, or using the right
+  mouse button, does the other one for as long as you hold it.
+- **Size** is the brush's width, in pixels of the picture.
+- The dot beside **Size** previews one brush dab. It grows with Size and its edge fades as you increase Soft.
+- **Soft** is the brush's edge: 0 is a hard edge, 100 fades all the way
+  from the middle.
+- Drag left and right on **Size** or **Soft**, on the word, the number or
+  the unit, to change the value. Click the number to type one.
+- **On top: A | B** is the picture you start from. Pick the other and it
+  goes on top instead. Your paint stays where it is.
+- **ALIGN** lines B up with A. Edit models often draw the picture a few
+  pixels to the side or a little zoomed in, so the edges of your paint
+  show a step. Click it and B is moved back over A; Save and Copy use the
+  lined-up B. Click it again to go back to B as it came. It fixes a shift
+  and a zoom, not a picture that bent or changed shape. Where B was moved
+  off its edge, A fills the gap.
+- **UNDO** takes back the last stroke, or a Clear. **CLEAR** takes all the
+  paint off.
+
+The brush shows around the pointer in teal: a ring at its full size, and
+its shape inside, solid in the middle and fading where the edge is soft.
+It turns coral while it paints back.
+
+Set the brush without leaving the picture, with the same keys as in
+Photoshop:
+
+- **E** erases and **B** paints back, as with Photoshop's eraser and
+  brush.
+- **[** and **]** make it smaller and larger.
+- **Shift + [** and **Shift + ]** make the edge softer and harder.
+- Hold **Alt** and the **right mouse button**, then drag: left and right
+  for the size, up and down for the edge (up is softer). The brush stays
+  where you pressed and changes as you drag, with its size and softness
+  written under it; the dashed ring is where its solid middle ends. One
+  drag can do both: go across for the size, then turn up or down for the
+  edge. On a Mac, hold Control and Option and drag.
+
+These keys only work while the pointer is on the picture. ComfyUI's own
+shortcuts are left alone.
+
+A second row opens under the switch, for saving:
+
+- **Name**: what the files are called. `compare` is used when it is empty.
+  Letters, digits, spaces, dots, dashes and underscores are kept; a folder
+  cannot be part of the name. With the **filename** input wired, the name
+  comes from there and the field only shows it.
+- **PSD off | on**: on makes Save write two more files (see below).
+- **Copy** puts the mix on the clipboard at full size, to paste into an
+  editor or a chat. Nothing is saved. Browsers only allow this when
+  ComfyUI is opened as `localhost` or over `https`; from another computer
+  on a plain address, use Save.
+- **Save**, at the right end, writes the mix to ComfyUI's output folder as
+  a PNG, such as `compare_00001.png`. Nothing is run again, and every save
+  takes the next number, so nothing is written over.
+
+With **PSD** on, Save also writes:
+
+- `compare_00001.psd`: both pictures as layers, with your paint as a
+  layer mask on the top one. Open it in Photoshop, GIMP or another
+  editor that reads PSD files, and keep working on the mask there.
+- `compare_00001_mask.png`: the mask alone. White is where the picture
+  underneath shows.
+
+After a save, the line under the picture says **Saved** with a link for
+each file. Click one to download it, which helps when ComfyUI runs on
+another computer.
+
+Your paint is kept with the workflow. A new run keeps it while the picture
+keeps its size, so you can change a seed and look again; press **CLEAR**
+to start over. Pictures of another size start clean.
+
+## Which picture is the result
+
+B, the "after" picture. If your graph makes A out of B's picture (B is the
+picture you loaded and A is the edited one), the result is A. To keep one
+picture up whatever happens, use the **A** or **B** button.
+
+## Outputs
 
 - **image_a**: The `image_a` batch, untouched.
+- **image_b**: The `image_b` batch, untouched: the picture you compared
+  against, often the edited one. Wire it on when the picture you want to
+  keep is B.
 
-Previews are written to ComfyUI's temp folder and vanish with it; nothing is
-saved to the output folder and no network requests are made.
+Previews are written to ComfyUI's temp folder and vanish with it. Nothing
+is saved to the output folder until you press **SAVE** in Erase, and no
+network requests are made.
+
+## Technical details
+
+- While sliding, the outer 6% on either side snaps to a full image.
+- The result is found from the links: when the node that feeds `image_b` is
+  somewhere upstream of the node that feeds `image_a`, A was made from B and
+  A is the result. When both pictures come out of one subgraph, the same
+  check is made inside it. In every other case it is B: two unrelated
+  pictures, both pictures out of one plain node, or a link the node cannot
+  follow (a Set and Get pair, for example).
+- Settings → AusBoss → Image Compare → **Rest on the result** switches this
+  off. The panel then stays on the picture nearest to where the pointer
+  left, and a new run does not change it.
+- **Erase works on the first picture of each batch**, at its full size.
+  The mix is always A's size: a B of another size is resized to fit A.
+- **See-through parts** are kept in a preview only when a picture has some,
+  so solid pictures save exactly as before. The mix lays the top picture
+  over the other as an editor does. In the PSD each layer keeps its own
+  see-through parts, and the flat picture carries the mix's, its colours
+  stored over white the way Photoshop stores them. **Align** measures the
+  two pictures laid over gray and moves B's see-through parts with it.
+- **What is kept is the strokes**, not a painted picture. The panel draws
+  them for you, and Save draws them again on the server at full size, so
+  the saved edge is as sharp as the picture however small the node is.
+  Copy draws them at full size in the browser.
+- **Erase never changes the node's size.** On a narrow node its rows wrap
+  onto a second line and the picture gets shorter instead.
+- **The brush** is a solid middle with a blurred edge. At Soft 100 the
+  middle is half the brush wide and the blur is an eighth of the size.
+- **Save mixes the two pictures of the node's last run**, which ComfyUI
+  keeps in its temp folder. After a restart of ComfyUI they are gone: run
+  the workflow once more, then save. The browser sends the strokes, a key
+  for that run and the name: it never names a file to read, and the name
+  is checked again on the server.
+- **A wired name is tidied**: its folder and extension are dropped, and
+  anything a file name cannot hold becomes an underscore
+  (`sets/a/photo 12.jpg` saves `photo 12_00001.png`).
+- **The saved files carry no workflow.** A mix is made by hand, so there
+  is nothing a workflow could make again.
+- **The PSD** is 8-bit RGB and not compressed: about 12 bytes for each
+  pixel, so 50 MB for a 2048 x 2048 picture. It carries no colour profile,
+  like the PNG.
+- **Limits**: 400 strokes in one mix. The node says so when it is full.

js/docs/AUSBOSS_NODES_CropForInpaint.md

@@ -1,34 +1,93 @@
 # Crop For Inpaint
 
-Cuts the masked region — plus enough surrounding context — out of an image
-so an inpainting model works at the region's native resolution instead of
-shrinking the whole frame. Pairs with **Stitch Inpaint 🆎**, which
-pastes the result back exactly where it came from.
+Cuts out the part of a picture you masked, with some of what is around it, so
+the model repaints just that part at full detail instead of the whole picture
+shrunk down. Use it with **Stitch Inpaint 🆎**, which pastes the result back
+exactly where it came from. The **Extend** rows (`extend_*`) add new space on a
+side of the picture, which is how the pair outpaints.
 
 ## Controls
 
 - **image**: BHWC image or video frames to crop around the mask.
 - **mask**: White marks the area to inpaint. A multi-frame mask is unioned
   into one crop window so a whole video shares one stitcher; an empty mask
-  selects the full image (and stitches back unchanged).
-- **context_factor**: Grows the mask bounding box symmetrically by this
-  factor. The grown window is shifted back inside the frame first; only
-  when it truly cannot fit is the image extended with edge-replicated
-  padding.
-- **blend_pixels**: Feather width used *only when pasting back*: the paste
-  mask is widened by this many pixels and blurred. The sampling mask sent
-  to the inpainter stays hard-edged, so feathering never weakens what the
-  model sees. `0` pastes with the raw mask.
-- **output_multiple**: Crop and target dimensions are rounded up to a
-  multiple of this so samplers accept them.
-- **target_width / target_height**: Rescale the crop to a fixed size for
+  selects the full image (and stitches back unchanged). A picture with no
+  mask painted on it stops the run with "No mask painted" and how to paint
+  one (core Load Image sends a small blank stand-in in that case). A mask
+  of another size than the picture also stops the run, and the message
+  gives both sizes.
+- **Context** (`context_factor`): Grows the mask bounding box
+  symmetrically by this factor. The grown window is shifted back inside the
+  frame first. When it's bigger than the picture, **Stay in picture**
+  decides what happens.
+- **Stay in picture** (`keep_inside`, on by default): Keeps the crop inside
+  the picture. When the context would reach past an edge (a big mask, or a
+  small picture), the crop stops at that edge, so the model sees only real
+  picture and, after a **Target** rescale, paints the new part larger and
+  sharper. Off is the old behavior: the crop runs past the edge and the
+  extra space is filled with stretched copies of the edge pixels. One catch
+  with it on: the model sees more of what's around your mask and carries it
+  on, so paint over leftovers at the mask's edge that you don't want kept.
+- **Blend** (`blend_pixels`): Feather width used *only when pasting back*:
+  the paste mask is widened by this many pixels and blurred. The sampling
+  mask sent to the inpainter stays hard-edged, so feathering never weakens
+  what the model sees. `0` pastes with the raw mask.
+- **Multiple** (`output_multiple`): The crop's size is rounded up to a
+  multiple of this. Keep it at `32` (the default) for Qwen Image 2.1, Flux
+  and most newer models. Their VAE trims a picture that is not a multiple
+  of 16 or 32, and the trimmed result, stretched back over the crop, looks
+  slightly bigger than the original. Stitch Inpaint says so in the console
+  when that happens.
+- **Target width / Target height** (`target_width` / `target_height`, in
+  the **Target size, extend** fold): Rescale the crop to a fixed size for
   the sampler. `0` keeps the native crop size; setting only one dimension
-  derives the other from the crop's aspect ratio.
+  derives the other from the crop's aspect ratio. Explicit values here
+  override `target_megapixels`. When the crop is rescaled, the crop area
+  takes in a few more pixels of context on one side so it has the exact
+  shape of the target size, and the picture is scaled the same amount
+  both ways, never stretched.
+
+### Shaping the mask
+
+- **Grow** (`mask_grow`): Dilate the sampling mask by this many pixels
+  (negative shrinks) so the inpainter repaints past the drawn edge. This
+  reshapes what gets painted, unlike `blend_pixels`, which only feathers the
+  paste-back.
+- **Blur** (`mask_blur`): Gaussian sigma softening the sampling mask's
+  edge, for models that honor soft masks. `0` keeps the hard edge.
+- **Invert mask** (`invert_mask`): Inpaint the black area instead of the
+  white area — everything outside the drawn region. Applied before growing
+  or blurring.
+
+### Sizing the crop
+
+On the card, the **Target size, extend** fold holds these rows,
+**Target width / Target height** and the **Extend** rows.
+
+- **Extra context** (`context_pixels`): Flat extra context in pixels added
+  around the mask box after `context_factor`'s growth.
+- **Target** (`target_megapixels`): Rescale the crop for the sampler so its
+  area is about this many megapixels — `1.0` suits SDXL-class models, `0`
+  keeps the native crop size. Explicit `target_width`/`target_height` wins.
+- **Rescale** (`rescale_algorithm`): Resize filter for both directions of
+  the sampler round trip. `bilinear` is the safe default, `bicubic` keeps
+  upscales a touch crisper, `area` suits heavy downscales, `nearest` never
+  invents pixels.
+
+### Outpainting
+
+- **Extend left / Extend right / Extend up / Extend down** (`extend_left` /
+  `extend_right` / `extend_up` / `extend_down`): Grow the picture itself by
+  this many pixels on that side. The new bands are filled with stretched
+  copies of the edge pixels, are always painted (even with **Invert mask**
+  on), and become part of the stitched output — draw nothing and the
+  extended bands alone are inpainted.
 
 ## Outputs
 
 - **image**: The cropped region, sized for the sampler.
-- **mask**: The matching hard-edged sampling mask.
+- **mask**: The matching hard-edged sampling mask (soft only where
+  `mask_blur` says so).
 - **stitcher**: Everything Stitch Inpaint needs to put the result back.
 
 ## Wiring
@@ -42,3 +101,17 @@ Load Image ── Crop For Inpaint ── image ──> LaMa Inpaint ── imag
 Any inpainting sampler fits between the two nodes the same way — connect
 the crop's `image` and `mask` to it, then its output to Stitch Inpaint's
 `inpainted` input.
+
+A picture with see-through parts keeps them through the pair. ComfyUI's
+Load Image splits them off into its `mask`; wire its `IMAGE` and `MASK`
+into **Join Image with Alpha** to put them back on before the crop. The
+sampler gets the colours, and Stitch Inpaint gives the result its clear
+parts back.
+
+## Technical details
+
+- Starting values: Context `1.2`, Blend `16` px, Multiple `32`; Grow, Blur,
+  Extra context, the Target rows and the Extend rows start at `0`.
+- With no Target size set, the crop is still rounded up to **Multiple**, so
+  with **Stay in picture** on it can still reach a few pixels (at most
+  Multiple - 1) past an edge.

js/docs/AUSBOSS_NODES_DropShadow.md

@@ -1,21 +0,0 @@
-# Drop Shadow
-
-Casts a colored shadow from a subject mask and composites it beneath the
-original image. The subject itself is protected from the shadow, while pixels
-outside the shadow remain unchanged.
-
-## Controls
-
-- **image**: The image containing the subject.
-- **mask**: White identifies the subject that casts the shadow. One mask can
-  broadcast across an image batch.
-- **offset_x / offset_y**: Signed pixel offset for the cast direction.
-- **grow**: Expands the shadow before softening it.
-- **blur**: Gaussian edge softness in pixels; `0` keeps a hard edge.
-- **shadow_color**: Hex, RGB, grayscale, or CSS color name.
-- **opacity**: Shadow strength from `0` to `1`; `0` is an exact pass-through.
-
-## Output
-
-- **image**: The input image with the colored shadow composited beneath the
-  masked subject.

js/docs/AUSBOSS_NODES_Float.md

@@ -0,0 +1,55 @@
+# Float
+
+A number with decimals. Set one strength, scale, or CFG here, wire it to
+every node that needs it, and change it in one place.
+
+## Controls
+
+- **Value** (`value`): The number to send out. It starts at `0`. The box
+  shows the decimals its steps use (`0.00`) and holds up to three, so a
+  typed `0.125` stays `0.125`.
+- The gear, right: **Look**. **normal** is the usual box with its label.
+  **big** shows the number large in the middle of the node, with an arrow
+  on each side, for a setting people change on every run, such as the
+  length of a clip. A drag and typing work the same. Each node keeps its own look, and it is
+  saved with the workflow.
+
+## Limits
+
+Wire the output to a setting that has limits and the box takes them over.
+Wired to a sampler's **denoise**, it goes from 0 to 1 and no further: type
+1.5 and you get 1. The card shows **0–1** beside the value.
+
+- It works through a Reroute and into a box (subgraph) too.
+- Wired to two settings, it keeps to what both allow.
+- Unwire it and it takes any number again.
+- A new box takes the value of the first setting you wire it to, so wiring
+  it up changes nothing until you move it. A box you have already set, or
+  one that came with a workflow, keeps its own value.
+
+## Output
+
+- **float**: The value, unchanged.
+
+For arithmetic on the way — scaling, clamping with `min`/`max` — feed this
+into **Math Expression 🆎** instead of retyping derived numbers.
+
+## Technical details
+
+- The limits are those of the input the wire lands on, the way ComfyUI's own
+  Primitive node takes them. When the inputs agree on a step, the fine step
+  (Shift) is that step.
+- A value that is outside the limits when the wire is made is brought to the
+  nearest one.
+- The box holds three decimals, or as many as the step it took over needs.
+  It shows the decimals its arrow step reaches (at least one) and goes past
+  them only for a value that uses more: `1.00` wired to denoise, `8.0` wired
+  to CFG, `0.855` for a typed 0.855.
+- The limits are kept by the node's face. A value sent straight through the
+  API is passed on as it is.
+- Wired only to inputs that share no value (one stops at 1, the other starts
+  at 2), the box keeps no limits.
+- The look is stored in the node's properties as `ausboss_text_look: "big"`, the
+  same as Text 🆎. It is not an input, so the saved value and what the node
+  sends are the same in both looks, and an older version of the pack shows
+  the usual box.

js/docs/AUSBOSS_NODES_FrameChooser.md

@@ -1,93 +0,0 @@
-# Frame Chooser
-
-Pauses the running graph and turns the node into a clickable filmstrip of every
-incoming frame. Pick the frames to keep, press **Keep selected**, and the graph
-resumes with just those frames — always in their original order.
-
-## Controls
-
-- **frames**: A BHWC image batch, commonly the frame output of a video loader.
-- **behavior**: `always pause` stops every run until you answer. `keep last
-  selection` re-applies this node's previous answer immediately and only pauses
-  when no previous answer fits the current batch.
-- **preview_max_size**: Longest edge of the filmstrip thumbnails. Smaller
-  values encode and load faster; the full-resolution frames are untouched.
-- **timeout_seconds**: How long a pause waits before **on_timeout** answers
-  for you. `0` waits forever. While armed, the panel header counts down the
-  seconds left.
-- **on_timeout**: What an expired countdown does — `keep all`, `keep first`,
-  `keep last`, or `cancel` (interrupts the run like the stop button). Ignored
-  while **timeout_seconds** is `0`.
-- **pick_list**: One-based frame numbers, e.g. `1,4,9` (commas or spaces).
-  When filled, the node applies them immediately — no pause, no filmstrip —
-  and the run can cache like any ordinary node. **Clear it to make the node
-  pause again.** A number outside the batch fails the run instead of
-  guessing.
-
-  Under **keep last selection**, answering a pause fills this widget in for
-  you with the kept indices, so the next queue reproduces the same choice
-  headlessly. Under **always pause** nothing is written here: a filled
-  `pick_list` pre-answers the node, so writing one back would answer every
-  later queue on its own and quietly retire the setting you chose. Keeping
-  all frames writes an empty list, not an enumeration of the batch — the
-  answer stays "keep everything" however long the next clip is.
-
-## While paused
-
-- Click thumbnails to toggle them; the header counts the selection, and
-  **ALL** / **NONE** flip the whole filmstrip at once.
-- **Keep selected** resumes with the chosen frames. **Keep all** resumes with
-  every frame — an empty selection deliberately means keep-all, so a quick
-  "just continue" can never produce an empty batch.
-- **Cancel** interrupts the run exactly like ComfyUI's stop button.
-  Interrupting the queue also releases the pause.
-- The controls grey out while an answer is on its way, so a doubled Enter or
-  click cannot send it twice; a reply that lands after the pause is already
-  over is ignored rather than reported as a failure.
-- Reloading the page does not lose the pause: when the graph finishes
-  loading, the panel re-fetches every still-waiting chooser from the server
-  and re-renders its filmstrip (countdown included).
-- A pause that starts out of sight — another browser tab, another workflow,
-  or the node scrolled off the canvas — raises a toast naming the node and
-  briefly highlights the waiting workflow tab. One notice per pause; a
-  filmstrip you can already see stays quiet.
-- The first moments after the filmstrip appears ignore clicks, so a click
-  meant for the canvas cannot answer a pause that popped up under the cursor.
-
-## Keyboard
-
-Active while the panel has focus — it takes focus when the pause opens, and a
-click anywhere on it returns focus. Keys typed into a text field are left
-alone.
-
-| Key | Action |
-| --- | --- |
-| `1`-`9` | Toggle that frame |
-| `A` | Select all |
-| `N` | Select none |
-| `Enter` | Keep selected |
-| `Escape` | Cancel the run |
-
-## Outputs
-
-- **frames**: The kept frames as a BHWC batch, in source order.
-- **count**: How many frames were kept.
-- **indices**: The kept one-based indices, comma-joined (`1,4,9`).
-
-Thumbnails are written to ComfyUI's temp folder and disappear with its normal
-cleanup; answers travel over a local `/ausboss/frame_chooser` route. The last
-selection is remembered per node id for the current server session only. Each
-pause has a one-use token, so an older panel cannot answer a later pause that
-reuses the same node id.
-
-## One answer per pause
-
-Several things can end the same pause: a second browser tab, Escape chasing
-Enter, the countdown expiring in the instant an answer arrives, or the queue
-being stopped. The server settles that on the way in — the first one to reach
-the pause decides it, and every later attempt is refused rather than allowed
-to overwrite the decision. So a cancel that lands behind a keep cannot stop a
-run that is already continuing, an expired timer cannot discard the answer you
-just gave, and the panel that lost never claims it was the one that counted.
-Whichever way the pause went is broadcast to every open tab, which is what
-releases the other panels and fills in `pick_list`.

js/docs/AUSBOSS_NODES_FrameInterpolate.md

@@ -1,43 +1,50 @@
 # Frame Interpolate
 
-Resamples a frame batch from one frame rate to another, so `24 -> 30` works
-as naturally as doubling. Every output frame maps to a position on the source
-timeline: positions that land exactly on a source frame are copied untouched,
-and only the true in-betweens are synthesized.
+Changes a clip's frame rate, for example 24 to 30, by making the in-between
+pictures. Use it to smooth a generated clip or to match another clip's rate;
+`24 -> 30` works as naturally as doubling. Every output frame maps to a
+position on the source timeline: positions that land exactly on a source
+frame are copied untouched, and only the true in-betweens are synthesized.
 
 ## Methods
 
 - **blend**: A crossfade between the two neighboring frames. Instant and
   dependency-free, but fast motion looks soft because it averages instead of
   moving pixels.
-- **optical flow**: Estimates RAFT motion vectors in both directions, warps
-  both neighbors toward the in-between time, and blends the warps. Much
-  sharper on motion. It only reads the official RAFT-small checkpoint from
-  the torch hub cache and never downloads it during execution. If the file is
-  absent, the node reports its exact expected path and source URL; approve and
-  place the model there separately, or use **blend**.
+- **optical flow (RAFT)** (`optical flow (requires cached RAFT weights)`):
+  Estimates RAFT motion vectors in both directions, warps both neighbors
+  toward the in-between time, and blends the warps. Much sharper on motion.
+  It reads torchvision's official RAFT-small checkpoint,
+  `raft_small_C_T_V2-01064c6d.pth`, from the torch hub cache
+  (`~/.cache/torch/hub/checkpoints/` unless `TORCH_HOME` moves it) and never
+  downloads it during a run. Download it from
+  `https://download.pytorch.org/models/raft_small_C_T_V2-01064c6d.pth` into
+  that folder; without it the node names the exact path it looked in. Or use
+  **blend**.
 
 ## Scene cuts
 
 Interpolating across a hard cut produces morph artifacts: two unrelated
 shots smeared into each other for a frame or two. When the mean absolute
-difference between adjacent source frames rises above
-**scene_cut_threshold**, the node treats that pair as a cut and holds the
+difference between adjacent source frames rises above **Scene cut**
+(`scene_cut_threshold`), the node treats that pair as a cut and holds the
 last frame before it instead of morphing. Set the threshold to `0` to
 disable detection and interpolate everything.
 
 ## Controls
 
 - **frames**: Video frames as a BHWC `IMAGE` batch.
-- **source_fps**: Frame rate of the incoming batch; wire Load Video's fps
-  output to match the source.
-- **target_fps**: Frame rate to resample to. Matching the source rate passes
-  the batch through unchanged.
-- **method**: `blend` or `optical flow` as described above.
-- **scene_cut_threshold**: Cut sensitivity from 0 to 1; `0.35` suits most
-  footage, `0` disables.
-- **batch_size**: In-between frames computed per batch. Higher is faster but
-  uses more VRAM; results land in system memory as each batch finishes.
+- **FPS**, left box (`source_fps`): Frame rate of the incoming batch; wire
+  Load Video's fps output to match the source.
+- **FPS**, right box (`target_fps`): Frame rate to change to. Matching the
+  source rate passes the batch through unchanged. A new node starts at
+  24 → 30.
+- **Method** (`method`): `blend` or **optical flow (RAFT)**, as described above.
+- **Scene cut** (`scene_cut_threshold`): Cut sensitivity from 0 to 1; `0.35`
+  suits most footage, `0` disables.
+- **Batch** (`batch_size`, starts at `8`): In-between frames computed per batch. Higher is
+  faster but uses more VRAM; results land in system memory as each batch
+  finishes.
 
 ## Outputs
 

js/docs/AUSBOSS_NODES_FreeMemory.md

@@ -0,0 +1,33 @@
+# Free Memory
+
+Passes anything through unchanged and frees graphics memory on the way. Put
+it between two heavy steps — after a video decode, before an upscale — so
+the second one starts with free memory instead of an out-of-memory error.
+
+## Controls
+
+- **value**: Any wire — the node's input and output are wildcard-typed, so
+  it splices into an `IMAGE`, `LATENT`, `MODEL`, or any other connection
+  without adapters.
+
+## Output
+
+- **value**: The input, passed through unchanged.
+
+## Behavior
+
+- What it frees, in order: ComfyUI's loaded models are unloaded, ComfyUI's
+  own cache is emptied, Python garbage is collected, and the CUDA allocator
+  cache is emptied.
+- Every release step is best-effort. If ComfyUI moves or renames one of the
+  APIs involved, that step is skipped and the wire still flows; the node
+  never becomes the reason a workflow fails. What was actually freed is
+  printed to the console each run.
+- The comfy imports happen when the node runs, not when the pack loads, so a
+  core change surfaces as a skipped step rather than deleting the node from
+  the menu.
+- Like any node, it only runs when its input changes — it does not force
+  re-execution, so inserting it never breaks ComfyUI's caching downstream.
+  Freeing happens on the runs where work actually flows through.
+- Models unloaded here are reloaded by the next node that needs them; that
+  reload costs time, which is the trade for the freed VRAM.

js/docs/AUSBOSS_NODES_H3PromptWriter.md

@@ -0,0 +1,268 @@
+# H3 Prompt Writer
+
+Type what happens, one line for each moment. Leave a blank line to cut to a new
+place. The node writes H3's full prompt for you, and you never see its format.
+
+Use it with MiniMax H3 or Pika H3 Flex. Connect up to four pictures and give each
+one a job. Copy the moves from a video, keep a clip going, or add a voice or a
+song.
+
+## How to write it
+
+Every line is a moment, and the lines play in order in one shot. The bar under
+the box shows the second each one starts, before you spend a run.
+
+```
+@1 walks through a crowded night market toward us, looking over her shoulder.
+@1 stops and looks up at the lanterns.
+
+@1 stands at the edge of a rooftop in the rain, her back to us.
+@1 slowly turns her head toward us.
+```
+
+That is two shots in two places. `@1` is Picture 1. With one person you can
+write `She` or `He` instead.
+
+The node also fills in two things H3 misses by itself. A moment gets its own
+sound when it names something that makes one, like rain, footsteps or thunder.
+And what changes stays changed: when the lights go out, the next moments in that
+place say they are still out.
+
+## The words box and the bar
+
+The words the node acts on light up as you type: `@1` in teal (amber when
+nothing is plugged in there), a time like `3s:` in amber, words in quotes in
+yellow, and a blank line shows as a line marked CUT. Hover the `?` beside
+"What happens" for a short list of everything you can type.
+
+Typing `@` lists the pictures you plugged in, with their job. The first letters
+of a line offer `sound:`, `music:`, `camera:` or `look:`, and after `camera:` or
+`look:` you get the node's own choices. Tab picks one, Esc closes the list.
+
+The bar under the box is the clip from start to end, one block for each moment
+with the pictures it names:
+
+- **Drag a block** along the bar to move its line. The times and cuts stay
+  where they are.
+- **Drag the left edge** of a block to set when that moment starts. The node
+  types the time (`3s:`) into its line for you.
+- **Click the left edge** to add or take out a cut there.
+- **Click a block** to pick out its line in the words, ready to change.
+
+Everything on the bar changes the words, so Ctrl+Z undoes it.
+
+## Give each picture a job
+
+Pick a job for each picture under the words, then name it in your lines with
+`@1`, `@2`, `@3` or `@4`.
+
+- **person**: this person goes wherever your lines say. Name the place in the
+  line, or name none and they stay where the picture shows. Use a clear photo.
+- **character sheet**: one character drawn from several sides. Only the
+  character is used, not the panels.
+- **place**: where it happens. Use a picture with nobody in it.
+- **outfit**: clothes for your person. Works best with no head in the picture.
+- **thing**: an object or a product. Works best with nobody in the picture.
+- **style**: only the look is used, for the whole clip.
+- **start on it**: the clip starts from this picture and stays in its place.
+- **end on it**: the clip lands on this picture. It can't be named in a line.
+
+Some scripts, with the jobs they need:
+
+```
+@1 sits at the counter in @2.                     Picture 2 is a place
+@1 and @2 sit side by side on a night bus.        Picture 2 is a person
+@1 walks down a runway wearing @2.                Picture 2 is an outfit
+@1 spins slowly on a black glass table.           Picture 1 is a thing
+```
+
+A picture that is off simply isn't counted. If a line still names it, the node
+stops and tells you which one. It needs at least one picture or a video to start
+from.
+
+## Use a video
+
+Connect a video, then pick what it is for:
+
+- **copy its moves**: your person does the moves in the video. It needs a
+  picture of your person. Say where in your lines:
+  `@1 dances on a rooftop at sunset.` The clothes can come from words or from an
+  outfit picture.
+- **swap the person**: your person takes over from the one in the video. The
+  place, the moves and the camera stay. With two person pictures, the first
+  replaces the person on the left and the second replaces the person on the
+  right. To choose who goes, type one line per picture, for example
+  `@1 replaces the man in the hat`. Put spoken words in quotes and name
+  the speaker. If a voice comes from off screen, say so in the line.
+- **change something**: keep the video and describe the change, for example
+  `She wears a red raincoat`. Be specific about what should change.
+- **keep going**: more of the same clip, from where it ends. Say what happens
+  next, or leave the box empty and it just carries on. Connect the whole clip:
+  the node sends H3 only the last 2 seconds.
+- **new voice**: the same clip with a new voice. Connect the voice, and type
+  what they say in quotes.
+
+If your swap keeps the video's audio, connect it to **video_sound** and turn on
+**More → Clip's own sound**. The writer uses the clip to estimate when each
+line is spoken and keeps only the incoming people's words in the swap prompt.
+Type a time such as `3.2s:` to set it yourself. This switch starts off.
+
+With an active video, **swap the person**, **change something** and **new voice**
+use the incoming clip to set the frame count. **Length** says **From the clip**;
+set the clip's length upstream. The bar does not show a guessed duration or offer
+retiming controls for these jobs. H3 rounds the frame count to a supported length.
+Other video jobs, or turning the video off, use the editable **Length** again.
+
+For a swap, you can optionally describe the replacement on its own line:
+
+```
+the woman with black hair walking toward the camera
+@1 looks like a woman with blonde hair and a black hoodie.
+```
+
+The first line chooses who goes; the `@1 looks like` line describes the connected
+replacement person in Picture 1. Use the number of that picture, with its job set
+to **person** or **character sheet**. This helps describe the intended appearance;
+it does not guarantee an exact identity match. The line is optional: existing
+workflows and scripts keep their previous behavior when it is absent.
+
+## What you can type
+
+- **A time**: start a line with `3s:` and it happens at 3 seconds.
+- **A cut in the same place**: start the line with a kind of shot, like
+  `a close-up of her hand`. Any other line after a blank line goes to a new
+  place.
+- **One long take**: type `no cuts` and blank lines stop being cuts.
+- **An ending**: start a line with `ends on`, wherever it sits:
+  `ends on her sitting by the window`.
+- **Speech**: put the words in quotes: `@1 says "we are late."` Each person
+  keeps their own voice.
+- **Words on a sign**: name the sign: `a neon sign reads "OPEN"`.
+- **Sound and music**: use the **Sound** and **Music** boxes, or type
+  `sound: rain on a tin roof` and `music: slow sad piano`. With no music you get
+  none, and the clip comes out quieter.
+- **Camera and look**: pick them on the node, or type your own:
+  `camera: slow push in`, `look: a 1970s film`.
+
+A `camera:` or `sound:` line inside a group of lines belongs to that shot. On its
+own, with blank lines around it, it is for the whole clip.
+
+Already wrote H3's six parts yourself? Paste them in and they go through as
+they are.
+
+## What you can plug in
+
+- **picture_1** to **picture_4**: your pictures.
+- **video** and **video_sound**: the frames and the sound of a video. **keep
+  going** sends the last part of the sound to H3. A swap uses the sound to find
+  speech timing when **Clip's own sound** is on. To keep source audio in a swap
+  or **change something**, route the original loader's audio to the save node.
+- **voice**: a clip of someone talking, about 10 seconds, plus words in quotes
+  in your script. It goes to whoever speaks first. It works with your own voice,
+  or one you have permission to use. Put the spoken line last: with time left
+  after it, H3 tends to keep talking.
+- **song**: your music. It is cut to the length of the clip and plays as it is,
+  and each moment moves onto its beat.
+- **clip**: a small text model such as Qwen3-VL 8B. Type one line and it adds
+  what happens next, and it names the sound of the place. Your line always stays
+  first.
+
+A voice and a song work together. H3 can't keep a song while someone speaks, so
+the node keeps the song out of H3's way and hands it on as **song_under**, turned
+down, to mix under the finished clip.
+
+Then wire the node's outputs into H3: **prompt** into its prompt, **frames** into
+its length, each **picture** into its next `ref_image`, **video** into `ref_video`,
+**video_sound** into `ref_video_audio`, **voice** into its first `ref_audio`,
+**song** into the next one. The pictures come out in the order the prompt counts
+them, so a picture that is off leaves no gap. **width** and **height** go into
+H3's width and height: the clip takes the shape of your video, or else of your
+first picture. **song_under** goes into `audio2` of Audio Merge, with the clip's
+sound in `audio1`.
+
+**keeps_clip_sound** is on when a video is connected and **Clip's own sound** is
+on, or the video job is **change something**. Use it to select the source audio
+for the finished clip. It is the last output; the existing outputs keep their
+positions. Keeping source audio still needs the workflow to pass that audio to
+its save node.
+
+Nothing plugged in means nothing is added. So a page can turn each one on and off
+with [Workflow Switches](#AUSBOSS_NODES_WorkflowSwitches): a bypassed loader reads
+as not plugged in.
+
+## The controls
+
+- **Sound** (`sound`): what the clip sounds like, for the whole clip. Same as a
+  `sound:` line.
+- **Music** (`music`): the music for the whole clip. Same as a `music:` line.
+- **Length** (`seconds`): how long the clip is, 5 to 15.
+- **Camera** (`camera`): how the camera moves the whole way through.
+- **Look** (`look`): from the picture keeps your photo's look. The others redraw
+  the clip. Clay and 3D don't work from words, so change your picture first with
+  an edit model.
+- **Picture 1** to **Picture 4** (`job_1` to `job_4`): what each picture is
+  for, on the picture chips under the bar. An empty slot shows as a faint `+ @3`.
+- **Video** (`video_job`): what the video is for, on the video chip.
+- **Song starts at** (`song_start`, under **More**): the second of the song to
+  start from, so the clip gets the good part.
+- **Moments on the beat** (`cut_on_beat`, under **More**): moves each moment onto
+  the nearest beat of the song. Off keeps your own seconds.
+- **Language** (`language`, under **More**): the language of the words in quotes.
+
+## Tips
+
+- About one moment a second is the most H3 can play. The line under the rows
+  warns you, and it warns you when a spoken line won't fit its moment.
+- Say which way they face, and think about where they end up. If someone walks
+  away from us, we see their back until a line turns them.
+- H3 draws each shot on its own. A cut to a new place hides that. A cut inside one
+  place shows every gap, so keep a place in one shot and move the camera instead.
+- Nothing moves or exists unless a line says so. If the birds should fly, say so
+  in that shot.
+- Say what you would see, not what someone feels. `She smiles` works.
+  `She feels happy` doesn't.
+- A clip came out wrong? Run again with a new seed.
+
+## Slots
+
+| Slot | Direction | Type | Purpose |
+| --- | --- | --- | --- |
+| `script` | input | STRING | What happens, one line for each moment. |
+| `seconds` | input | INT | How long the clip is. |
+| `clip` | input, optional | CLIP | A small text model that fills in a one-line idea. |
+| `picture_1` to `picture_4` | input, optional | IMAGE | Your pictures. |
+| `video` | input, optional | IMAGE | The frames of a video. |
+| `video_sound` | input, optional | AUDIO | The video's own sound. |
+| `voice` | input, optional | AUDIO | A clip of the voice to use. |
+| `song` | input, optional | AUDIO | The music to use. |
+| `prompt` | output | STRING | The finished prompt. |
+| `picture_1` to `picture_4` | output | IMAGE | Your pictures, in the order the prompt counts them. |
+| `video` | output | IMAGE | The video, or only its end to keep going from. |
+| `video_sound` | output | AUDIO | The video's sound, when it should reach H3. |
+| `voice` | output | AUDIO | The voice, 15 seconds at most. |
+| `song` | output | AUDIO | The song, cut to the clip. Empty when a voice is connected too. |
+| `song_under` | output | AUDIO | With a voice and a song, the song to mix under the finished clip. |
+| `frames` | output | INT | The clip's length in frames. |
+| `width`, `height` | output | INT | The shape of your video, or else of your first picture. |
+| `keeps_clip_sound` | output | BOOLEAN | Whether the finished clip should use the video's own sound. |
+
+## Technical details
+
+Code does the reading, so nothing typed can be lost or moved. It follows Pika's
+and MiniMax's published prompt guides: every picture is defined once, each one
+states what is kept and how, and a person who changes clothes or moves to a new
+place is marked that way.
+
+A timed shot mark makes H3 jump, whatever the words around it say: in tests 31 of
+36 one-take clips jumped within half a second of a mark. So a mark is written only
+for a real cut, and the moments of one take are sentences inside one shot. Clips
+written that way had no jumps in 4 of 4 tries.
+
+The prompt always tells H3 not to keep the background of a person's picture. With
+a place in your lines the clip stayed there to the end on 2 of 2 tries; without
+that sentence the picture's street came back halfway through on 2 of 2. With no
+place in your lines H3 has nothing else to use, so it stayed in the picture's
+place on 2 of 2.
+
+H3's own rewriter runs only on paid services, and the open model reads a prompt as
+it is. This node does that job on your machine, with no model needed.

js/docs/AUSBOSS_NODES_ImageCropRotatePad.md

@@ -1,26 +1,299 @@
 # Image Crop + Rotate + Pad
 
-Loads an image and applies one reusable **rotate → crop → pad** transform. Click **Open editor** for the full-screen canvas; normal queued and API execution use the saved widget values without needing the editor.
+Loads a picture and lets you turn it, crop it and add empty space around it, by
+dragging handles on the node. Use it to frame a picture for a model, or to add
+space around a picture that the model then fills in (outpainting).
 
-## Controls
+The picture is turned first, then cropped, then padded. The node also makes the
+**mask** that tells the model where to paint, and a **stitcher** that puts your
+original back over the result.
 
-- **image**: Image picker/upload from ComfyUI's input folder.
-- **rotation_degrees**: Clockwise rotation before crop and padding.
-- **crop_aspect_ratio**: Free crop, source ratio, or a fixed ratio.
-- **crop_x / crop_y / crop_width / crop_height**: Crop in rotated-image pixels. Width and height `0` mean the full available dimension.
-- **pad_left / pad_top / pad_right / pad_bottom**: New pixels around the crop.
-- **feather**: Feathers the mask into kept pixels and fades the image edge into the fill color, so outpaints blend instead of ending at a hard seam.
-- **canvas_multiple**: Rounds the final canvas up by adding the minimum extra pixels to the right and bottom.
-- **fill_color**: `#RRGGBB` or three RGB values used for generated pixels.
+## Quick start
+
+1. Choose a file above the preview, or click **Load**. Dropping a
+   picture onto the node works too.
+2. Drag the handles on the picture. Cyan squares crop. Orange diamonds add space
+   on one side. Orange corners make the whole canvas bigger or smaller. The
+   green knob turns the picture.
+3. Or tap a ratio such as **16:9** to pad the picture to that shape.
+4. Wire **image** and **mask** to your model, and **stitcher** to Stitch Inpaint
+   after the sampler.
+
+**Open editor** shows the same handles on a full-screen canvas, with zoom and
+pan. **Save & close** keeps your edits. **Cancel** or Escape puts everything
+back, and asks first if anything changed. You do not need the editor: a run
+uses what the node shows.
+
+## On the node
+
+From top to bottom:
+
+- **File picker**: choose **Inputs** for uploaded pictures or **Outputs** for renders, newest first. The list shows the
+  picture under the pointer and filters as you type. **Load** adds one. A
+  picture ComfyUI made, named like `photo.png [output]`, loads too, as it does
+  in core Load Image. The gear holds the node's display options.
+- **The picture**, with its handles.
+- **The size line**: each step that sets the output size, ending with the size
+  the run gives you.
+- **Crop, pad & resize**: a collapsible group (closed to start, with the fill
+  swatch and a short summary on its bar) holding:
+  - **Aspect ratio** and **Fit to ratio** (Crop or Pad), above the orientation button, the ratios (1:1, 4:3, 3:2, 16:9,
+    21:9) and the padlock.
+  - **Align** and the two **Center** buttons.
+  - **Fill** and **Feather**.
+  - **Resize**, with **Megapixels** and **Step** alongside it when Resize is on.
+- **Open editor**, **Reset crop** and **Reset**.
+
+Crop and padding have no number boxes. You set them by dragging, and the size
+line shows the result. Picking another picture starts the framing over
+(rotation, crop and padding); Fill, Feather, Align, Resize and a lit
+ratio stay.
+
+### Ratios, Fit and the padlock
+
+Tap a ratio under the picture to pad the picture to it: every pixel stays and
+fill bands are added around it, centred. Set **Fit** to crop and the ratio trims
+the picture instead. Tap the lit ratio again to go back to the whole picture.
+You can set **Fit to ratio** before picking a ratio. If a ratio is already lit, switching between Crop and Pad applies it immediately.
+
+- **A lit ratio is the shape the canvas has now.** Drag a handle to another
+  shape and the ratio goes dark; the row says **Custom** and the size line under
+  the picture gives the real ratio (`1.49:1`).
+- **A picture that already has the shape gets nothing added.** Within about 1%
+  counts, so a nearly 9:16 photo gets no 1 px band. The size line under the
+  picture says so ("already 9:16: pick another ratio or turn it"), and while a
+  ratio is lit it names it where it acted (`pad to 16:9 2532×1424`). A lit ratio
+  saved in a workflow is used again on every new picture you load.
+- **The padlock** at the end of the row keeps the shape while you drag: pull one
+  side out and the other side's padding follows, split evenly. The row says
+  **Held** while it is on. On the untouched picture (the row says **Source**)
+  there is no shape to hold, so it stays off. **Reset** and tapping the lit ratio
+  turn it off, and **Reset crop** also takes away the bands it added.
+- **The orientation button** at the start of the row turns the shape on its side:
+  16:9 becomes 9:16, padded around the picture (crop mode turns the crop box
+  about its centre). The picture itself never rotates. With nothing picked it
+  only turns the ratios, so the next tap goes that way.
+- **Drag the picture itself** to move it inside its padding; the canvas keeps its
+  size. Over the picture, the cursor and small arrows show which ways it can go.
+- Rotating keeps a lit ratio: the padding follows the turned picture.
+
+### Corner handles and Center
+
+The four orange corners outside the picture make the whole canvas bigger or
+smaller and keep its shape: drag one out to add room on two sides at once, for
+example to zoom out before an outpaint. The corner across from the one you drag
+stays where it is. Hold **Alt** (Option on a Mac) while you drag to change all four
+sides at once, so the picture keeps its place in the middle. You can press or let
+go of Alt during the drag. A corner stops when one of its two sides has no padding
+left to take away.
+
+**Center** moves the crop to the middle of the rotated source, side to side or
+top to bottom. If there is padding on that axis, the same click also balances
+the bands around the crop. The crop and output keep their sizes, and the
+generated mask follows the new placement. Each button dims when its axis is
+as centered as the pixels allow.
+
+The orange diamonds move one side at a time, and the padlock works on them as
+described above. The corners keep the shape with or without the padlock. The
+green rotate knob moves aside when a corner handle sits where it usually goes.
+
+### Fill, Feather and Resize
+
+- **Fill** (`fill_color`): the colour of the added space and of the empty
+  corners a turn leaves. It starts gray. Added space on the picture is drawn in
+  the real fill colour with a faint hatch, and only the part the crop cuts away
+  is darkened.
+- **Feather** (`feather`, 24 px to start): softens the edge of the **mask** into
+  the kept picture, so the model and the stitch blend the seam. The image itself
+  keeps a hard edge against the fill. That solid band is what outpaint models
+  and LoRAs recognise as the area to paint.
+- **Resize** (`resize_to_megapixels`, off to start): resizes the finished output
+  to a size budget and keeps its shape. Turning it on opens a row with
+  **Megapixels** (`megapixels`, the budget) and **Step** (`resolution_steps`,
+  the number each resized side rounds to; 8 or 64 suits most image models).
+  **Method** (`resize_method`) is in the editor, under **Resize output**.
+  The edge between your picture and the fill stays one clean line at any size.
+
+### Align
+
+**Align** (`canvas_multiple`) makes the width and height divide evenly by
+the number you pick. Some models need sizes divisible by 8, 16 or 32. At 1 it is
+off. Its arrows go 1, 8, 16, 24 and so on; hold Shift to step by 1.
+
+Where you padded, the padding grows by the few pixels needed: on the right or
+bottom band if there is one, otherwise on the left or top. Where you did not
+pad, no fill is added. The picture is trimmed by a few pixels instead, evenly
+from both edges, so an edge you did not pad never gets a thin strip for the
+model to paint. A picture smaller than the number itself is padded on the right
+or bottom.
+
+### The size line
+
+The line under the picture names every step that sets the output size, in the
+order the run applies them, with the size the run emits last and brightest:
+`crop 2080×1170 → pad 2208×1298 → round to 64 2240×1344 → resize 1344×768`. A step
+that changes nothing is left out, and "round to" is **Align** at work. An
+amber line warns when rounding each side to the Step stretches the picture by
+more than 1% (`Resize makes the picture 1.5% taller`); its tooltip names a
+Step that avoids it, and with Fit on pad, **Pad to keep shape** adds a few pixels of
+padding so nothing stretches. It also warns when the resize undoes **Align**. Hover the line for the same breakdown line by line; the editor's right
+panel shows it too.
+
+The amber line keeps still while you drag a handle or a number. If the drag
+makes it untrue it goes away, and the line for the new size comes back a
+moment after you let go. The space for the warning stays under the dimensions. On a narrow node, hover
+over shortened text to read it in full.
+
+### Reset crop and Reset
+
+**Reset crop** shows the whole picture again without changing rotation or
+padding. **Reset** clears rotation, crop and padding and turns the padlock off;
+Fill, Feather and **Align** stay.
+
+## Drawing a mask
+
+Right-click the node and choose **Open in MaskEditor** to paint over the parts
+you want the model to repaint. After **Save**, the picture on the node shows
+them in teal, and the teal moves with the picture when you crop, turn or pad
+it. The full editor shows it too. The run treats painted parts like the
+padding: it fills them with the fill colour and marks them in the **mask**,
+so under the teal you see the fill colour, not your picture.
+
+**Keeping your picture under the paint.** Some workflows need what was under
+the paint: an inpaint with denoise under 1, or an edit model that has to see
+what it changes. Open the editor and set **Painted area** to **keep**, in the
+**Inpaint & Stitch** section. The **mask** still marks the painted parts, and
+your picture stays under them in **image**, **original** and
+**prompt_image**. The picture on the node still shows the fill colour under
+the teal.
+
+See-through parts of a PNG show in teal the same way, because the node paints
+them too. To hide the teal, click the gear next to **Load** and turn off **Show the mask on the picture**. The choice applies
+to every Image Crop + Rotate + Pad in this browser.
 
 ## Outputs
 
-- **image**: BHWC float image batch. Animated image frames receive the identical transform.
-- **mask**: BHW generated-area mask combining source transparency, empty rotation corners, and padding.
+- **image**: the turned, cropped and padded picture. Every frame of an animated
+  image gets the same framing.
+- **mask**: White where the model paints: the padding, the empty corners a turn leaves, and the see-through parts of your picture.
+- **stitcher**: Wire to Stitch Inpaint to restore the kept canvas around an outpaint result, blended into the source by **Blend** (32 px unless changed). It follows the final resized canvas. After a hand crop, set **Paste onto** to original in Stitch Inpaint's gear menu to get your whole picture back with the edit in place.
+- **original**: your picture before rotation, crop, padding or resize, with
+  see-through parts shown as white (your picture there when **Painted area**
+  is on keep).
+- **width** / **height**: The output size after the transform and any resize.
+- **prompt_image**: The image again, with see-through parts shown as white instead of the fill colour. Wire it to whatever writes your prompt. It is the same as **image** for a picture with no see-through parts, and when **Painted area** is on keep.
 
-## Editor gestures
+## See-through pictures
 
-Drag cyan squares to resize the crop, drag inside to move it, orange diamonds to add padding, and the green handle to rotate. Hold `Shift` while rotating to snap to 15 degrees. Use the wheel to zoom and middle mouse or `Alt`-drag to pan. The same handles work directly on the node's compact preview (fit-only there — the wheel keeps zooming the graph); zoom and pan are editor-only.
+A PNG can have see-through parts: a product cutout with no background, a
+photo with round corners, a picture with a hole in it. The node treats those
+parts like the padding. They are filled with the fill colour, marked in the
+mask, and the model paints them. Stitch Inpaint never puts them back over
+the painted result.
 
-The node performs no network requests and writes no files beyond a normal user-initiated ComfyUI upload.
+Use **prompt_image** for the node that writes your prompt. There the
+see-through parts show as white, the way a picture viewer shows them, so the
+prompt describes a real backdrop. Shown the gray fill instead, a prompt
+writer calls it a "gray backdrop" and the model keeps the flat gray. The
+model itself still gets **image**, with the fill colour it was trained on.
 
+A picture with no see-through parts comes out exactly as before.
+
+### Technical details
+
+- A pixel counts as see-through when it is less than 90% as solid (alpha)
+  as the most solid pixel in the picture. Measuring against the most solid
+  pixel keeps a picture saved at, say, 50% opacity throughout whole instead
+  of painting it over.
+- A picture that is at least 90% solid everywhere is left exactly as it was
+  loaded. Generated pictures often carry alpha values of 249-254 in places,
+  and those pictures do not change.
+- Kept pixels are used fully solid, in their own stored colour. See-through
+  pixels never reach the canvas: their stored colour (often black, or the
+  old background) is what used to leave a dark or light ring round a cutout.
+- Why 90%: on an oval photo whose edge stores colours darkened by their
+  alpha, a 50% cut kept a rim up to half dark, the ring the model painted
+  back. At 90% the kept rim is at most 10% darker, and matting noise inside
+  solid subjects stays above it, so no holes open there.
+- A turned picture's see-through parts turn with it, like its corners. In
+  **prompt_image** they show white while the padding and the corners keep
+  the fill colour.
+- The MaskEditor saves its mask as see-through parts of the picture, so the
+  same rule applies: a stroke more than 10% strong is painted in full,
+  including one at the MaskEditor's default 70% opacity.
+
+## The editor
+
+**Open editor** opens the full-screen canvas. Its left side holds the node's own
+controls: the same ratio row with its orientation button and padlock, the same
+**Fit** switch, and the same number boxes (drag to scrub, click to type, Shift
+for fine steps). The editor adds a few things the node does not show:
+
+- **Rotate → Degrees** (`rotation_degrees`): type an exact turn, clockwise.
+  Each step is 1°, or 0.1° with Shift. **Reset rotation** sets it back to 0.
+- **Padding & mask → Reset padding** removes all padding. The same section has
+  Fill, Feather, Align and a **Center** row.
+- **Resize output → Method** (`resize_method`): how the resize samples the
+  picture. `lanczos`, the default, is the sharp one.
+- **More**: ratios you added in `ausboss_presets.json` that no button shows.
+  The list only appears when you have some.
+- **Reset view** undoes zoom and pan. **Reset transform**
+  clears rotation, crop, padding, fill, feather and Align; the picture,
+  resize and stitch settings stay.
+- **Preview**: a small picture of the finished output while you work.
+
+A ratio replaces the existing crop and padding and keeps rotation, fill and
+resize settings. **Align** and the resize **Step** can slightly change
+the fitted shape. The size box on the stage sits clear of the handles.
+
+### Handles and gestures
+
+Drag cyan squares to resize the crop, drag inside to move it, orange diamonds to add padding on one side, orange corners to make the canvas bigger or smaller in its own shape (hold `Alt`, Option on a Mac, for all four sides), and the green handle to rotate. Hold `Shift` while rotating to snap to 15 degrees. The knob turns all the way round either way: past 180° it carries on from -180°, so an upside-down picture turns back up whichever way you drag. Rotating keeps the crop's size and keeps it over the same part of the picture, whichever control turns it (knob, number box, Reset rotation); with no crop the canvas grows to hold the tilted picture. The knob keeps clear of the padding handles and crop squares. Use the wheel to zoom and middle mouse or `Alt`-drag on an empty spot to pan. The same handles work directly on the node's compact preview (fit-only there — the wheel keeps zooming the graph); zoom and pan are editor-only.
+
+### Inpaint & Stitch
+
+The editor's right side holds the stitcher's settings, the same as on the clip node:
+
+- **Blend** (`stitch_blend`, default 32): the ramp, in output pixels, where generated
+  pixels fade over the source. It is separate from **Feather**, which shapes the mask.
+- **Show blend** tints the stage with the paste mask: the generated area (painted and
+  see-through parts included), the feather, then grow and blend applied through any resize.
+- **Advanced → Grow paste** (`stitch_grow`, default 0) moves the paste boundary first:
+  a few positive pixels let the generation repaint the source edge when a seam still shows.
+- **Painted area** (`painted_area`, default `fill`): what a part you painted in the
+  MaskEditor is handed on as. **fill**: the fill colour, so the model never sees what was
+  there. **keep** (`keep picture`): your picture stays under the paint and only the mask
+  marks it. See-through parts of a PNG follow the same switch; a cutout usually stores
+  black or its old background there, so leave a cutout on fill.
+
+## Technical details
+
+- **Saved values.** The handles write plain number values that save with the
+  workflow and that an API workflow can set directly. None of them shows as a
+  row on the node:
+  - `crop_x` / `crop_y` / `crop_width` / `crop_height`: the crop, in pixels of
+    the turned picture. Width and height `0` mean the full size.
+  - `pad_left` / `pad_top` / `pad_right` / `pad_bottom`: the added space on
+    each side, in pixels.
+  - `crop_aspect_ratio`: `free`, `source` or a fixed ratio that the crop box
+    keeps. It stays `free` unless Fit is on crop and the padlock is on.
+  - `fill_color`: `#RGB` or `#RRGGBB`, three numbers (`R, G, B`), one gray
+    number, or a colour name. Anything it cannot read becomes mid-gray.
+- **Corners.** A corner follows the pointer along the canvas diagonal, and the
+  shape it keeps is the canvas before **Align** rounds it. With
+  Align on, **Center** counts the fill it adds, so the bands you see
+  come out even.
+- **Resize.** It works like core's *Scale Image to Total Pixels*: the budget is
+  `megapixels × 1024 × 1024`, the shape is kept, and each side rounds to a
+  multiple of **Step**. Your picture is resized by itself, with the chosen
+  **Method**, and the fill is put around it afterwards, so no fill is mixed
+  into the picture's edge and each band is a whole number of pixels wide. A
+  band that would come to under half a pixel is left out. The mask inside the
+  picture (the feather, the corners of a turn, see-through parts) is resized
+  with it, bilinear so its edges cannot ring.
+- **Your own ratios.** Copy `ausboss_presets_example.json` in the pack's folder
+  to `ausboss_presets.json` and edit the list, then reload the browser tab.
+- Restoring a workflow or undoing a change refreshes the picture without
+  resetting the saved framing.
+- The node performs no network requests and writes no files beyond a normal
+  user-initiated ComfyUI upload.

js/docs/AUSBOSS_NODES_ImageFolder.md

@@ -0,0 +1,132 @@
+# Image Folder
+
+Pick a folder, tick the pictures you want, and run the workflow on each one.
+
+Use it when the same job has to be done on many pictures: change one thing in
+all of them, caption them, resize them, make pairs for training.
+
+## How to use it
+
+1. Bring your folder in. Drop it on the node from your file explorer. Or
+   press **Browse**, then **Copy a folder from your computer**, and choose
+   it. Its pictures are copied into ComfyUI's `input` folder and show as
+   tiles.
+2. A folder that is already inside ComfyUI's `input` or `output` folder is
+   chosen with **Browse**.
+3. Click a tile to take a picture out or put it back. **Shift + click** does
+   every tile from the last one you clicked to this one. **All** and **None**
+   do the whole folder.
+4. Wire **image** into your workflow, and **filename** into Save Image's
+   `filename` so each result keeps its picture's name.
+5. Press **Run**.
+
+## A folder from anywhere on your computer
+
+The node only reads folders inside ComfyUI's own `input` and `output`
+folders. A folder from anywhere else is copied in:
+
+- **Drop it on the node**, or choose it with **Browse → Copy a folder from
+  your computer** or **Add → A whole folder**. Your file explorer opens for
+  the last two.
+- **Your browser asks first** when you choose a folder in the file explorer.
+  It shows its own question, such as "Upload 74 files to this site?". The
+  site is your ComfyUI, and the upload is the copy into its input folder.
+  The node cannot change those words. A folder dropped on the node is
+  copied without that question.
+- Its pictures go into `input/<the folder's name>`, folders inside it too,
+  and the node moves to that copy.
+- **A really big folder asks first.** With more than 300 pictures or more
+  than 1 GB, the node says how many and how much, and waits for your yes.
+  Copying takes that much disk space again.
+- Bringing the same folder in again writes over its copies. It does not
+  pile up doubles.
+- A path typed or pasted into **Folder** works when it lies inside ComfyUI's
+  input or output folder. For any other path the node says so, with a
+  button that opens the file explorer.
+
+## One run, or one picture per run
+
+**Run** decides how the pictures go through.
+
+- **all in one run**: one press of Run does every picked picture, one after
+  the other. If one picture stops the workflow, the ones after it are not
+  done.
+- **one per run**: each run loads one picture, and **Picture** moves on by
+  one when the run is queued. Set ComfyUI's run count to the number of
+  pictures and they are all queued at once. A picture that fails only skips
+  itself. The tile with the white ring is the next one, and a double click on
+  a tile makes it the next.
+
+After the last picture, **At the end** either stops the run with a message
+or starts over at the first. With **start over**, Picture goes back to 1 and
+the pictures repeat in order for as many runs as you queue.
+
+## The card
+
+- **From** (`source`): ComfyUI's **input** folder, or its **output** folder
+  for pictures you made.
+- **Folder** (`folder`): the folder inside it. Empty is the input or output
+  folder itself. **Browse** lists the folders there.
+- **Subfolders** (`subfolders`): also take the pictures in the folders inside.
+- **Order** (`sort`): by name, or newest or oldest first.
+- **Run** (`run`): see above.
+- **Picture** (`position`): with one per run, the picked picture the next
+  run loads, counted from 1.
+- **After a run** (`after_run`): **next** moves Picture on, **stay** keeps
+  loading the same one, **random** jumps to any of the picked ones.
+- **At the end** (`at_the_end`): after the last picture, **stop the run**
+  stops with a message, and **start over** goes back to the first and keeps
+  going.
+
+## The tiles
+
+- The line above them says how many are picked, and with one per run which
+  one is next.
+- A picked tile is bright with a tick and its number. The others are dim.
+- A number on teal means that picture went through since you opened the
+  workflow.
+- **Add** copies pictures, or a whole folder, from your computer into
+  ComfyUI's input folder.
+- **↻** looks in the folder again.
+
+## Outputs
+
+- **image**: each picked picture, one at a time. What comes after runs once
+  for each.
+- **mask**: white where the picture is see-through. A picture with no
+  see-through part gives the same empty mask Load Image does.
+- **filename**: the file name without its ending.
+- **index**: the picture's number among the picked ones, from 1.
+- **count**: how many pictures are picked.
+
+## Technical details
+
+- **Only ComfyUI's own folders.** The node reads folders inside ComfyUI's
+  input or output folder and nothing else. A path that leads anywhere else is
+  refused, and so is a link inside those folders that points out of them.
+  There is no setting that changes this.
+- The picked pictures are saved in the workflow as a list of names
+  (`pictures`). Empty means every picture, so a picture added to the folder
+  later is in too. A name that is no longer in the folder is skipped. It
+  takes no wire: the ticks on the node write it.
+- Pictures are PNG, JPG, WebP, BMP, GIF (first frame) and TIFF. A photo that
+  was taken turned comes out upright. Files whose names start with a dot are
+  skipped.
+- By name means the way a person sorts: `photo_2` before `photo_10`.
+- With **Subfolders** on, a picture's `filename` carries its folder in
+  front (`trips/beach.png` gives `trips_beach`), so two files with one name
+  never save over each other.
+- **image**, **mask**, **filename** and **index** are lists. Pictures keep
+  their own sizes. They are not resized or stacked into one batch.
+- Moving Picture on is done by the editor when a run is queued. A workflow
+  sent through the API loads exactly the picture `position` names.
+- With **start over**, a Picture number past the last picture counts round
+  from the first. A workflow saved with such a number loads that picture and
+  moves on from there.
+- The node runs again when a picked file is added, removed or rewritten.
+- A folder lists up to 5,000 pictures, and a folder that is brought in is
+  copied up to 3,000.
+- Bringing a folder in is done by your browser through ComfyUI's own upload.
+  The server never opens a path outside ComfyUI's input and output folders.
+- A mask painted in the MaskEditor is not part of a folder picture. Use Mask
+  by Name, or load that one picture with a single-picture loader.

js/docs/AUSBOSS_NODES_ImageResize.md

@@ -0,0 +1,76 @@
+# Image Resize
+
+Resizes a picture. Choose how to set the new size: an exact width and
+height, the longest or shortest edge, a megapixel budget, or a multiplier.
+A mask can ride along and gets the same resize, and the new width and
+height come out as numbers you can wire onward.
+
+A new node starts on **Megapixels** at 1 MP, with **Fit** on fit,
+**Multiple** 1 and the lanczos filter.
+
+## Target modes
+
+**Target** (`target_mode`) picks the mode. The card shows only that mode's
+size row, and the other size values are ignored.
+
+- **Width × height** (`width+height`): The two **Size** fields, W and H
+  (`width`, `height`). Their input sockets sit with the node's inputs,
+  under `image` and `mask`; a linked one greys its field out. `0` keeps that
+  source dimension, and with only one set the other follows the source
+  aspect.
+- **Longest edge** / **Shortest edge** (`longest_edge`, `shortest_edge`):
+  Scales until that edge equals **Edge** (`edge_length`) exactly; the other
+  edge keeps the aspect. `0` keeps the source size.
+- **Megapixels** (`megapixels`): Scales (aspect preserved) until width ×
+  height is about **Budget** (`megapixels`) million pixels. `0` keeps the
+  source size.
+- **Scale factor** (`scale_factor`): Multiplies both dimensions by **Scale**
+  — `0.5` halves, `2.0` doubles. `0` keeps the source size.
+
+## Fit
+
+**Fit** (`keep_proportion`) decides what happens when the target aspect
+differs from the source. It only matters in **Width × height** mode: in the
+other modes the picture always keeps its shape, whatever Fit says.
+
+- **stretch**: Distorts straight to the target.
+- **fit**: Shrinks the target box to the source aspect — the output can be
+  smaller than requested, but there are never bars and nothing is cropped.
+- **cover** (`cover_crop`): Fills the target completely and center-crops
+  the overflow.
+- **pad**: Fits inside the target and fills the rest with **Fill**
+  (`fill_color`: hex, `R, G, B`, one grayscale number, or a CSS name; a
+  color the node cannot read becomes mid-gray). The
+  new bars are `1.0` in the mask output — the same generated-area contract
+  as the pack's other pad nodes, so it feeds an inpainter directly.
+
+## Notes
+
+- **Multiple** (`divisible_by`) snaps each output dimension to the nearest
+  multiple (never below one step) — `16` for WAN, `8` for most latent
+  spaces. It wins over exact proportion, so a dimension can shift by up to
+  half a step. It applies even when everything else says "keep the source".
+- **Bars only appear in Width × height mode with Fit on pad and both W and
+  H set.** In every other target mode the box is derived from the source's
+  own aspect, so there is nothing to letterbox against: the proportion modes
+  all resolve a `divisible_by` snap with an invisible sub-half-step resize,
+  and the mask output stays black. A Width × height box with a `0` in it
+  follows the source the same way, so pad adds no bar to it. With both set,
+  bars (white in the mask) fill whatever the picture does not cover. That
+  includes a bar a pixel or two wide when the size is rounded, for example
+  a 1000×700 picture with W 1000, H 700 and **Multiple** 16 becomes
+  1008×704 with a 2 px bar.
+- **Filter** (`interpolation`): `lanczos` (PIL, in float — the sharpest
+  all-rounder), `bicubic`, `bilinear`, `nearest` (pixel art, hard masks),
+  `area` (best for strong downscales). A resize that changes nothing passes
+  the tensor through bit-identical.
+- The mask output is the input mask through the same transform, plus the
+  pad bars. With no mask wired it is black, except for pad bars, which are
+  white. IMAGE is BHWC, MASK is BHW, and batches flow through frame by
+  frame.
+
+## Outputs
+
+- **image**: the resized picture.
+- **mask**: the mask, resized the same way.
+- **width** / **height**: the new size in pixels.

js/docs/AUSBOSS_NODES_ImageSize.md

@@ -1,13 +1,16 @@
 # Image Size
 
 Reads an image's dimensions and hands them out as INTs: **width**,
-**height**, **longest_edge**, and **shortest_edge**.
+**height**, **longest_edge**, **shortest_edge**, and **count**.
 
 Wire them wherever a workflow wants numbers that must match the actual
 image — an Empty Latent sized to the source, a resize keyed off the longest
 edge, aspect-aware math with the shortest. Because the values come off the
 wire, they can never drift out of date the way retyped numbers do.
 
+After a run the node shows each number beside its output, such as
+`width: 1024`, so you can read the size without wiring anything to it.
+
 ## Outputs
 
 - **width** / **height**: The frame size in pixels.
@@ -15,9 +18,16 @@ wire, they can never drift out of date the way retyped numbers do.
   keys on.
 - **shortest_edge**: `min(width, height)` — the number crop-to-fill and
   many preprocessing pipelines key on.
+- **count**: The number of images in the batch — `1` for a single image,
+  the frame count for video frames.
 
 ## Notes
 
 A batch reports the size its frames share (IMAGE batches are uniform by
 construction). The node does no work worth caching or canceling — it reads
-two numbers off the tensor's shape.
+its numbers off the tensor's shape.
+
+The numbers beside the outputs are from the last run. They are saved with
+the workflow, so a workflow you open again shows them, and they are cleared
+when you wire in another picture. If the node measured a list of batches in
+one run, it shows no numbers, since no one number is true for all of them.

js/docs/AUSBOSS_NODES_Integer.md

@@ -0,0 +1,51 @@
+# Integer
+
+A whole number. Set a step count, a size, or any other whole number once and
+wire it to every node that needs it.
+
+## Controls
+
+- **Value** (`value`): The whole number to send out. It starts at `0`. The
+  arrows and a drag move it by 1, or click and type. It holds numbers as
+  big as a seed.
+- The gear, right: **Look**. **normal** is the usual box with its label.
+  **big** shows the number large in the middle of the node, with an arrow
+  on each side, for a setting people change on every run, such as the
+  length of a clip. A drag and typing work the same. Each node keeps its own look, and it is
+  saved with the workflow.
+
+## Limits
+
+Wire the output to a setting that has limits and the box takes them over.
+Wired to a sampler's **steps**, it goes from 1 to 10000: type 0 and you get
+1. The card shows **1–10000** beside the value.
+
+- It works through a Reroute and into a box (subgraph) too.
+- Wired to two settings, it keeps to what both allow.
+- Unwire it and it takes any whole number again.
+- A new box takes the value of the first setting you wire it to, so wiring
+  it up changes nothing until you move it. A box you have already set, or
+  one that came with a workflow, keeps its own value.
+
+## Output
+
+- **int**: The value, unchanged.
+
+For arithmetic on the way — halving a size, adding a margin — feed this into
+**Math Expression 🆎** instead of retyping derived numbers.
+
+## Technical details
+
+- The limits are those of the input the wire lands on, the way ComfyUI's own
+  Primitive node takes them.
+- A value that is outside the limits when the wire is made is brought to the
+  nearest one.
+- The limits are kept by the node's face. A value sent straight through the
+  API is passed on as it is.
+- On its own the box goes up to 9,007,199,254,740,991, the largest whole
+  number a browser holds exactly. It stopped at 2,147,483,647 before, which
+  most seeds are above.
+- The look is stored in the node's properties as `ausboss_text_look: "big"`, the
+  same as Text 🆎. It is not an input, so the saved value and what the node
+  sends are the same in both looks, and an older version of the pack shows
+  the usual box.

js/docs/AUSBOSS_NODES_Krea2Encode.md

@@ -0,0 +1,71 @@
+# Krea 2 Encode
+
+The prompt node for Krea 2. Type your prompt and negative prompt here, and
+optionally give it a picture for the result to follow, all in one node.
+
+Wire a VAE and a reference image and the reference is attached to the
+positive output. Leave them unwired and this is a plain two-prompt encoder.
+The negative comes out of the same node, so a turbo graph running at CFG 1.0
+still has something to plug in without a second text encode sitting there
+doing nothing.
+
+For an outpaint with the AnyPaint LoRA, also wire the **mask** from the node
+that padded your picture. Without it, a dark or very colourful picture can
+come back with the new area still gray, like a gray frame or a gray corner.
+
+## Controls
+
+- **clip**: The Krea 2 text encoder.
+- The big text box (`prompt`): Describe the whole finished canvas, not just
+  the new area — the model generates all of it and matches the reference
+  where it must. The two boxes have no labels, only gray hint text.
+- The small text box (`negative_prompt`): Ignored at CFG 1.0, which is where
+  turbo runs. Empty is the normal case there.
+- **vae**: Needed to turn the reference images into latents. Without it no
+  reference is attached to the result. If **VLM reference** is on, the text
+  encoder still looks at the pictures.
+- **reference**: The image the result follows. For AnyPaint that is the
+  padded `image` from Image Crop + Rotate + Pad 🆎 or Load Image + Pad 🆎;
+  for Registered Outpaint, Load Image + Pad 🆎's unpadded `reference`
+  output. Any image works; it is fitted to a multiple of 16 first.
+- **extra_image**: A second reference, e.g. a style or character plate.
+- **VLM reference** (`vlm_reference`, off by default): Also show the
+  references to the vision tower, so the text encoder describes them. On for
+  AnyPaint with the padded
+  canvas as the reference; off for Registered Outpaint with the unpadded
+  source, where the description tends to pull the result toward a paraphrase
+  of the source. The Krea 2 Outpaint Model Patch page covers both setups.
+- **mask**: The area to paint: the `mask` output of Image Crop + Rotate +
+  Pad 🆎 or Load Image + Pad 🆎, or the painted mask of an inpaint. Wire it
+  for AnyPaint. The reference then shows that area in your picture's own
+  colour instead of the gray fill, and the model paints it.
+
+## Outputs
+
+- **positive**: Prompt conditioning with the reference latents attached.
+- **negative**: Negative prompt conditioning.
+
+## Notes and limitations
+
+- **References are downscaled to a 384px long edge and snapped to a multiple
+  of 16.** The VAE downsamples by 8 and the DiT patchifies by 2, so an edge off
+  a multiple of 16 lands on a partial patch and the token grid stops lining up
+  with the canvas grid. The cap is deliberate — a reference is there to say
+  "this is the picture", and the canvas latent carries the detail.
+- Attaching reference latents alone does not tell the model *where* they go.
+  Pair this with Krea 2 Outpaint Model Patch 🆎 for outpainting.
+- On a core without the Krea 2 prompt template, `vlm_reference` still works —
+  it falls back to tokenizing without the template.
+
+## Technical details: why the mask matters
+
+AnyPaint was trained with the new area of its reference filled with the
+median colour of the rest of the picture, never with a fixed gray. The
+padded canvas carries a flat `#808080` gray instead. Next to a picture whose
+median is close to mid-gray that makes no difference, but next to a dark or
+saturated picture the model reads the gray as part of the scene and paints
+it back, as a flat gray frame or corner. The mask's new area (where it is
+above 0.5) is refilled with the median colour of everything else before the
+reference goes to the VAE and to the vision tower. The canvas the rest of
+the graph uses keeps its gray, so the prompt writer and the stitch are
+unchanged. Only `reference` is refilled; `extra_image` is left as it is.

js/docs/AUSBOSS_NODES_Krea2OutpaintModelPatch.md

@@ -0,0 +1,103 @@
+# Krea 2 Outpaint Model Patch
+
+Tells Krea 2 **where** a reference image sits on the canvas. Use it when you
+extend a picture with Krea 2 (outpainting), so the model carries your picture
+on instead of painting something that only looks similar.
+
+Place it **after** any LoRA loader and **before** the sampler.
+
+How it works: a reference normally reaches the model with no position, so
+the model treats it as a loose style hint. It borrows the look and reinvents
+the content. This patch pins the reference to the rectangle the stitcher
+reports.
+
+## Controls
+
+The node's card shows **Reference** (`source rect` / `whole canvas`) and
+**KV cache** (`every step` / `once per run`). Both accept links and retain
+their saved values when the workflow is reloaded.
+
+- **model**: A Krea 2 model. Patch last, so a LoRA loaded afterwards does not
+  replace the patched forward pass.
+- **stitcher**: From Load Image + Pad 🆎 or a Crop + Rotate + Pad 🆎 node.
+  It tells the patch where your picture sits on the canvas. With
+  a stitcher from Crop For Inpaint 🆎, set **Reference** to `whole canvas`:
+  on `source rect` the reference is pinned to where the crop sat in the
+  full picture, not spread over the crop.
+- **KV cache** (`kv_cache`, `once per run` by default): Compute the
+  reference's keys and values once per run instead of once per step. The
+  reference does not change while sampling, so this is free speed. Set it to
+  `every step` only to rule the cache out when debugging.
+- **Reference** (`placement`): Where the reference tokens go. `source rect`
+  (`source rectangle`, the default) pins them to the rectangle the stitcher
+  reports. `whole canvas` spreads them over the full frame. Which one is
+  right depends on the LoRA — see below.
+
+## Output
+
+- **model**: The model with reference tokens registered into the canvas grid.
+
+## Two LoRAs, two placements
+
+The base Krea 2 weights were never trained on registered references; what
+makes this patch work is a LoRA trained for it, and the two that exist want
+different placements.
+
+**Every side at once — `whole canvas` + AnyPaint.** yijunwang2's
+[Krea 2 AnyPaint](https://huggingface.co/yijunwang2/krea2-anypaint)
+(`krea2_anypaint_rank32.safetensors`) was trained with the padded canvas
+itself as the reference, spread over the whole frame, and the known pixels
+held in place by the sampler. In its training the new area of that reference
+was always a flat patch of the picture's own median colour. Wire it like the
+*Krea 2 Outpaint* example:
+
+- A pad node with any padding you like: Image Crop + Rotate + Pad 🆎, as in
+  the example, or Load Image + Pad 🆎. Left, right, top and bottom together
+  are fine. Flat colour fill.
+- Krea 2 Encode 🆎 with the pad node's **image** output (the padded canvas,
+  not Load Image + Pad's unpadded *reference* output) as the reference,
+  `vlm_reference` **on**, and the pad node's **mask** wired into its `mask`
+  input. The mask makes the encode refill the new area with the picture's
+  median colour, as in training. Without it a dark or very colourful picture
+  can come back with the gray padding painted in as a gray frame.
+- This patch on `whole canvas`.
+- VAE Encode the padded canvas, Set Latent Noise Mask with the pad mask, and
+  sample from that latent at full denoise. The mask is what keeps the source
+  pixels; the reference is what tells the model what they are.
+
+To repaint part of a picture instead of extending it, use the *Krea 2
+Inpaint Masked* example: Crop For Inpaint 🆎 cuts out the area you painted,
+and this patch runs on `whole canvas` with the same LoRA. Load Image + Pad 🆎
+itself does not take a painted mask.
+
+**One axis per pass — `source rectangle` + Registered Outpaint.** The same
+author's [Registered Outpaint](https://huggingface.co/yijunwang2/krea2-outpaint)
+(`krea2_outpaint_rank32.safetensors`) is the LoRA this placement was built
+for: the *unpadded* source goes in as the reference (Load Image + Pad 🆎's
+`reference` output, **VLM reference** off) and is pinned to its rectangle. It
+was trained on a source spanning one whole canvas axis — pad left/right and
+the source must span the full height, pad top/bottom and it must span the
+full width. Padding both axes in one pass is outside its training and the
+new region can break up; the node says so in the console when it sees it,
+and the cure is two passes: pad one axis, run, load the result, pad the
+other. **A thin strip counts.** More than 8 px of padding on the other
+axis, such as a few pixels left over from a drag, means the source no
+longer spans it. **Align** on the Crop + Rotate + Pad nodes and
+Load Image + Pad's **Multiple** never add a strip on a side you did not
+pad. The warning reports the spare pixels on each axis.
+
+Without either LoRA the patch still places the reference, but the bare
+Turbo model treats it loosely and results are hit and miss.
+
+## Notes and limitations
+
+- **Nothing happens without reference latents.** If the conditioning carries
+  none, the patched forward pass calls straight through to the original. Wire
+  Krea 2 Encode 🆎 with a VAE and a reference image.
+- **It patches comfy internals.** The placement reaches into the flux
+  attention layers, so a ComfyUI release that moves them can break this node
+  specifically. It imports those internals when you run it rather than at
+  startup, so a break surfaces as an error on this node instead of the node
+  disappearing from the menu.
+- Reference tokens cost attention. The reference is shrunk so its longest
+  side is 384 px before encoding for that reason — see Krea 2 Encode 🆎.

js/docs/AUSBOSS_NODES_LaMaInpaint.md

@@ -1,28 +1,65 @@
 # LaMa Inpaint
 
-Removes masked content with a TorchScript LaMa checkpoint. It processes video
-frames one at a time to keep VRAM bounded and composites the result through the
-input mask so pixels where the mask is zero remain unchanged.
+Removes whatever you paint over, such as a watermark or an object, and fills
+the gap to match what is around it. It works on pictures and on video, and
+everything outside the mask stays exactly as it was.
+
+It uses the LaMa model, which you download once (see below). Video frames are
+done one at a time, so a long clip does not need more graphics memory.
 
 ## Model setup
 
-Place `big-lama.pt` in:
+Download [`big-lama.pt`](https://github.com/Sanster/models/releases/download/add_big_lama/big-lama.pt)
+and place it in:
 
 ```text
 ComfyUI/models/lama/big-lama.pt
 ```
 
 The node never downloads a model. After adding or replacing a checkpoint,
-refresh the browser or restart ComfyUI so the model list is updated.
+refresh the browser or restart ComfyUI so the model list is updated. Until
+the file is there, the list still shows `big-lama.pt`, and a run stops with a
+message that says where to put it.
+
+The node only opens known copies of this file, whatever you name them: the
+download above, or the one from
+[fashn-ai/LaMa](https://huggingface.co/fashn-ai/LaMa). A LaMa model file can
+run code when it opens, so any other file stops the run with a message and is
+never loaded.
 
 ## Controls
 
 - **image**: BHWC images or video frames.
 - **mask**: BHW mask where white identifies content to replace. One mask is
-  broadcast across the batch; otherwise supply one mask per image.
-- **model**: A `.pt` or `.pth` TorchScript checkpoint from `models/lama`.
+  broadcast across the batch; otherwise supply one mask per image. A mask of
+  another size is stretched to fit the picture. A picture with no mask
+  painted on it stops the run with "No mask painted" instead of coming back
+  unchanged.
+- **Model** (`model`): A known copy of `big-lama.pt` from `models/lama`.
 
 ## Output
 
 - **image**: A finite BHWC image batch with the original batch size, dimensions,
   data type, extra channels, and unmasked pixels preserved.
+
+## Preview
+
+The panel shows the inpainted result, and before a run it falls back to a
+thumbnail of whatever feeds the **image** input. A video inpaint streams each
+finished frame to the panel as it goes, so a long run shows its progress
+rather than sitting blank. A small badge above the node counts the frames
+("frame 3/120"); **Settings → AusBoss → Chrome → Live status** turns the
+badges off. When the run ends, the panel keeps the first frame.
+
+There is one preview surface: ComfyUI's own result preview for this node is
+stood down so the picture does not appear twice, once in the panel and again
+underneath the node.
+
+The node performs no network requests. It writes one preview PNG per run into
+ComfyUI's temp folder, alongside what `PreviewImage` writes.
+
+The small **preview** switch at the right of the bar above the picture turns
+it off: the picture's box disappears, the node is that much shorter, and no
+preview file is written. Turn it back on and the node returns to its height
+with the last result in it; if the node ran while the switch was off, it asks
+you to run the workflow again. The switch is the node's optional `preview` input.

js/docs/AUSBOSS_NODES_LayoutBoxes.md

@@ -0,0 +1,213 @@
+# Layout Boxes
+
+Draw boxes on a canvas and say what goes in each one: a thing, or words to
+write in the picture. The picture you make then has each thing where you put
+it. Use it for layout prompts, such as MOSS-Image's.
+
+It does what ComfyUI's own Create Bounding Boxes does and gives the same
+outputs. Its canvas also works in the classic node look, where Create Bounding
+Boxes only shows "Node 2.0 only".
+
+## How to use it
+
+1. Set the canvas size in **Canvas** (W × H), or wire `width` and `height` from
+   Latent Size, so the boxes and your picture have the same size.
+2. Drag on the canvas to draw a box. Its tag shows its number and its type,
+   such as **1 object**.
+3. Under the canvas, the row **Box 1 is** sets what the chosen box holds,
+   **object** or **text**. Then type its words:
+   - **object**: the **Description** says what is in the box, for example "a
+     red bicycle leaning on a brick wall".
+   - **text**: the **Text** is the words to write in the picture, for example
+     "OPEN 24 HOURS". The **Description** says how they look, for example
+     "pink neon letters".
+4. Wire `elements` to the `element` input of MOSS-Image Layout Prompt, and give
+   that node the same width and height.
+
+Wire `preview` to a Preview Image to see the boxes with their numbers and words.
+
+## Change the words in a picture
+
+The `mask` output is white inside every box. Use it to change only one part
+of a picture, such as the words on a sign or a shirt.
+
+1. Wire a Load Image into `background` and pick your picture. It shows on the
+   canvas right away.
+2. Draw a box over the old words, a little wider than the old words on every
+   side (about 12 pixels), or bits of the old letters can show at its edge.
+   Keep faces and hands out of it: whatever is in the box is drawn again.
+   The arrow keys move the chosen box one pixel at a time.
+3. If the words run at a slant, turn the box to match them: drag the round
+   handle over the box (see **Turning a box** below).
+4. Make it a **text** box. Type the new words in **Text**, and how they look in
+   **Description**, for example "white letters on a red sign".
+5. Soften the edge of `mask`, for example with Mask Refine 🆎 at a blur of
+   about 6, or a line can show around the box. Then wire it into the inpaint
+   part of your workflow: Set Latent Noise Mask, so only the box is drawn
+   again, and Image Composite Masked, so everything else stays as it was.
+6. With MOSS-Image, wire `elements` to MOSS-Image Layout Prompt. The model
+   gets the new words from the box, and your prompt only describes the picture.
+
+## Turning a box
+
+Words on a sign or a shirt often run at a slant. Turn the box to lie along
+them, and only the slanted words are drawn again.
+
+1. Click the box to choose it. A round handle shows over the middle of its
+   top edge.
+2. Drag the handle around the box. Hold Shift to turn it in steps of 5
+   degrees.
+3. Or type the angle in **Turn**, under the canvas: plus turns the box
+   clockwise. **0°**, or a double-click on the round handle, makes the box
+   level again.
+
+The box's tag shows how far it is turned, for example **1 text 25°**. A turned
+box still moves, sizes and takes the arrow keys. Its corners may reach past
+the edge of the picture, so it can cover words that run to the edge.
+
+A turned **text** box tells the model the slant for you: its description in
+`elements` gets "tilted about 25 degrees, running downhill to the right" (or
+"uphill") added, so you do not have to type it.
+
+If the picture is resized on its way to the model, resize the mask with it:
+Image Resize 🆎 takes a mask and gives it the same size and crop.
+
+## Drawing and moving boxes
+
+| Do this | To get this |
+|---|---|
+| Drag on an empty spot | Draw a new box |
+| Shift + drag over a box | Draw a new box on top of it |
+| Drag a box | Move it |
+| Drag a corner or an edge of the chosen box | Make it bigger or smaller |
+| Drag the round handle over the chosen box | Turn it (Shift: steps of 5 degrees) |
+| Double-click the round handle | Make the box level again |
+| Double-click a box | Type its words |
+| Click a box's chip under the canvas (**1 text**, **2 object**) | Choose that box, also one hidden under another. When there are more boxes than chips, **‹ ›** step through them |
+| Delete | Remove the chosen box |
+| Arrow keys | Move the chosen box one pixel (Shift + arrow: ten pixels) |
+| Ctrl + D | Copy the chosen box |
+| Esc | Let go of the box, or put back a box you are dragging |
+| Hold Ctrl (or Alt) while dragging | Place the box freely, off the grid |
+
+The keys work while the canvas has the focus: click the canvas, or a box's
+chip, first.
+
+The handles and the tags keep their size on your screen when you zoom the
+graph in or out, and a box too small for eight handles keeps its corners.
+Over a picture the boxes are see-through and show no words, so you can read
+what is under them; the chosen box's words are under the canvas.
+
+An **object** box does not write words. If you typed words while it was a
+**text** box, a line under the canvas says they are kept: click **text** and
+they come back.
+
+## The order of the boxes
+
+Box 1 is at the back, and the last box is in front, so draw the things at the
+back first. The two square buttons under the canvas move the chosen box back or
+forward. MOSS-Image Layout Prompt's `character_boxes` takes these numbers.
+
+## Colors
+
+A box can have up to five colors for the model to use on that thing. **+** adds
+a color, a click on a color changes it, and a right-click (or its cross)
+removes it. The first color also colors the box on the canvas.
+
+## The bar above the canvas
+
+- **Grid**: boxes snap to a grid while you draw, move and size them with the
+  mouse. It is on for an empty canvas and off over a picture on `background`,
+  so a box can go anywhere on the picture. Click it to turn it on or off; the
+  node keeps your choice. Hold Ctrl (or Alt) while dragging to leave the grid
+  for one drag. The cells are 32 pixels, bigger on a very big canvas. A
+  turned box does not snap: it moves and sizes one pixel at a time.
+- **Layouts**: start from a ready arrangement: one in the middle, two side by
+  side, three across, top and bottom, a title over a picture, four corners.
+  The boxes you already have move into the new places, level, and keep their
+  words.
+- The canvas size, and where it comes from: **picture** when a picture is on
+  `background`, **wired** when width and height are wired.
+- **Clear** removes every box.
+- **⚙** (the gear): **Grid size**, the pixels from one grid line to the next:
+  Auto (32 pixels, more on a very big canvas), 8, 16, 32 or 64. The node keeps
+  it.
+
+## Inputs
+
+| Input | What it does |
+|---|---|
+| `background` | A picture to draw on. It shows under the boxes, and the canvas takes its size and shape, also when `width` and `height` are wired: the boxes are drawn on the picture, where the `mask` is made. The Canvas row dims while a picture is wired. |
+| `bboxes` | Boxes to start from: bounding boxes, prompt elements (such as the `elements` of another Layout Boxes), or either as JSON text. New boxes on this wire fill the canvas when the workflow runs. Your changes on the canvas then stay until the boxes on the wire change. After **Clear**, the next run fills the canvas from the wire again. |
+| `width`, `height` | The canvas size in pixels. Wired from Latent Size, the canvas takes that size and shape at once. |
+
+## Outputs
+
+| Output | Use |
+|---|---|
+| `preview` | A picture of the boxes with their numbers, words and colors, to check the layout. Turned boxes are drawn turned. |
+| `bboxes` | The boxes in pixels of the canvas (x, y, width, height), for nodes that take bounding boxes. A turned box gives the straight box around it. |
+| `elements` | The boxes as prompt elements. Wire it to MOSS-Image Layout Prompt. A turned box gives the straight box around it, and a turned text box says its slant in its description. |
+| `mask` | White inside every box, black elsewhere, to change only those places of a picture. A turned box is white inside its turned shape only. |
+
+## In place of Create Bounding Boxes
+
+Layout Boxes has the same inputs and the same outputs in the same order (and
+`mask` after them), so the wires move straight over. For the same boxes it
+gives the same `bboxes` and `elements`, and MOSS-Image Layout Prompt makes the
+same prompt from them.
+
+The boxes drawn on a Create Bounding Boxes do not move over by themselves. To
+take them along, wire that node's `elements` into `bboxes` of Layout Boxes and
+run once: they fill the canvas. Then remove the old node.
+
+## Technical details
+
+- The boxes are kept on the node as text, in the hidden `layout` input. Each
+  box's place is kept as parts of the canvas from 0 to 1, so a new canvas size
+  keeps every box at the same place. An API prompt can set it:
+  `{"v": 1, "boxes": [{"x": 0.25, "y": 0.1, "w": 0.5, "h": 0.8, "type": "obj", "text": "", "desc": "a cat", "palette": ["#ff3399"]}]}`.
+  A list of pixel boxes in Create Bounding Boxes' own form is read as well.
+- A turned box also has `"angle"`: degrees, clockwise on the screen, from -90
+  to 90, about the box's centre. `x`, `y`, `w` and `h` stay the box as it was
+  drawn, before the turn. Only turned boxes carry the key, and a box without
+  it is level, so layouts saved before boxes could turn give exactly what
+  they gave. The turn is made in pixels of the canvas the box was drawn on
+  (the picture on `background`, when there is one), so a turned box is a true
+  rectangle there whatever the canvas's shape.
+- For a turned box, `mask` is white at every pixel whose centre is inside the
+  turned rectangle. `bboxes` and `elements` hold the straight box around it,
+  cut to the canvas: those types only know straight boxes. A text box turned
+  2 degrees or more gets "tilted about N degrees, running downhill to the
+  right" (clockwise) or "running uphill to the right" added to its
+  description in `elements`, after a comma, or as its own sentence when the
+  description ends with a full stop; not when the description already says
+  it. Object boxes get no such words.
+- `elements` holds one element per box, in order:
+  `{"type": "obj" or "text", "bbox": [ymin, xmin, ymax, xmax], "text", "desc", "color_palette"}`.
+  The place is on a 0 to 1000 grid over the canvas, `text` is there for text
+  boxes only, and `color_palette` holds up to five colors when the box has any.
+- `bboxes` is a list holding one list of boxes, the form ComfyUI's
+  bounding-box nodes pass on. With no boxes it is empty.
+- `mask` is one mask (1 x height x width): 1 inside every box, 0 elsewhere,
+  with hard edges. With a picture on `background` it has the picture's own
+  size, and each box covers the same part of the picture that it covers on
+  the canvas. Without a picture it has the canvas size and covers the same
+  pixels as `bboxes`. With no boxes it is all 0.
+- With a picture on `background`, the canvas on the node is the picture at
+  its own size, so the arrow keys move a box one pixel of the picture.
+  `width` and `height` still set the pixels `bboxes` counts in and the size of
+  `preview`.
+- The picture shows before a run when `background` comes from a Load Image,
+  straight or through Reroutes. Through a node that changes the picture
+  first, such as a resize, it shows after a run.
+- Before a run, the canvas can only know a wired size it can read from the
+  node it comes from: Latent Size, Integer or a Primitive. From any other
+  node, the canvas keeps its own size until a run, and then shows the size
+  the run used. Either way the boxes keep their place on the size that
+  arrives.
+- Like Create Bounding Boxes, it is an output node: it runs with the workflow
+  even when nothing is wired to its outputs, so new boxes on the `bboxes` wire
+  reach the canvas.
+- The background is saved, shrunk, in ComfyUI's temp folder for the node's
+  face. Nothing else is written.

js/docs/AUSBOSS_NODES_LmStudioChat.md

@@ -1,54 +0,0 @@
-# LM Studio Chat
-
-Sends a prompt — and optionally an image — to a local LM Studio server and
-returns the reply as text. Anything that speaks the OpenAI-compatible chat
-API works too: Ollama's compatibility mode, llama.cpp's server, a remote
-box. Typical jobs: expanding a rough idea into a full prompt, captioning an
-image for img2img, or rewriting text mid-workflow.
-
-## Controls
-
-- **prompt**: What to ask. Required unless an image is connected — an image
-  with an empty prompt asks for a plain description.
-- **system_prompt** (optional): Role and rules, e.g. *"You write
-  single-paragraph Stable Diffusion prompts. No preamble, no quotes."*
-  Empty sends no system message.
-- **endpoint**: The server's base URL — LM Studio shows it on the Developer
-  tab, default `http://127.0.0.1:1234/v1`. A bare `host:port` or a full
-  `/v1` path both work.
-- **model**: Model identifier as LM Studio lists it. **Empty uses whatever
-  the server has loaded**, which is the everyday case — no fetched dropdown
-  to go stale when LM Studio was not running at ComfyUI startup.
-- **temperature**: 0 is near-deterministic, 0.7 balanced. Captioning likes
-  0.2–0.5.
-- **max_tokens**: Longest allowed reply; `-1` leaves it to the server.
-  Reasoning models spend tokens thinking before answering — give them room.
-- **seed**: Sent to the server, and either way a changed seed re-runs the
-  node instead of replaying the cached reply. This is the re-roll knob.
-- **timeout_seconds**: How long to wait. Cold-loading a big model or a long
-  think can need minutes.
-- **image_max_edge**: Downscale a connected image so its longest edge fits
-  this before sending (`0` = full size). Vision models resize internally
-  anyway, and a smaller upload prefills much faster.
-- **image** (optional): For vision models. Only the **first frame** of a
-  batch is sent — pick one with Select Frame 🆎 for video. A
-  text-only model will refuse an image server-side.
-
-## Outputs
-
-- **text**: The reply with any `<think>` blocks removed — safe to wire
-  straight into a text encoder.
-- **thinking**: What a reasoning model thought before answering; empty for
-  ordinary models. Handy in a preview node while tuning prompts.
-
-## Behavior
-
-- Runs off the executor thread, so the UI stays responsive during a long
-  generation; the timeout is the backstop.
-- Caches like any node: identical inputs replay the saved reply instantly.
-  Change the seed to force a fresh generation.
-- Errors are actionable: a refused connection says how to start the server,
-  an HTTP error carries the server's own message (e.g. *"Model not
-  found"*), and a non-JSON reply points at the endpoint setting.
-
-Nothing is sent anywhere except the endpoint you configured.