Upload folder using huggingface_hub

.gitattributes

@@ -15,9 +15,19 @@ models/unet/wan2.2_i2v_low_noise_14B_fp8_scaled.safetensors filter=lfs diff=lfs
 models/vae/wan_2.1_vae.safetensors filter=lfs diff=lfs merge=lfs -text
 output/video/ComfyUI_00001_.mp4 filter=lfs diff=lfs merge=lfs -text
 user/comfyui.db filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/docs/rgthree_advanced.png filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/docs/rgthree_advanced_metadata.png filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/docs/rgthree_context.png filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/docs/rgthree_context_metadata.png filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/src_web/lib/tree-sitter-python.wasm filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/src_web/lib/tree-sitter.wasm filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/web/lib/tree-sitter-python.wasm filter=lfs diff=lfs merge=lfs -text
+custom_nodes/rgthree-comfy/web/lib/tree-sitter.wasm filter=lfs diff=lfs merge=lfs -text
 models/loras/DR34ML4Y_I2V_14B_HIGH_V2.safetensors filter=lfs diff=lfs merge=lfs -text
 models/loras/DR34ML4Y_I2V_14B_LOW_V2.safetensors filter=lfs diff=lfs merge=lfs -text
 models/loras/NSFW-22-H-e8.safetensors filter=lfs diff=lfs merge=lfs -text
 models/loras/NSFW-22-L-e8.safetensors filter=lfs diff=lfs merge=lfs -text
+models/loras/wan2.2-i2v-high-pov-insertion-v1.0.safetensors filter=lfs diff=lfs merge=lfs -text
+models/loras/wan2.2-i2v-low-pov-insertion-v1.0.safetensors filter=lfs diff=lfs merge=lfs -text
 models/loras/wan22-m4crom4sti4-i2v-20epoc-high-k3nk.safetensors filter=lfs diff=lfs merge=lfs -text
 models/loras/wan22-m4crom4sti4-i2v-20epoc-low-k3nk.safetensors filter=lfs diff=lfs merge=lfs -text

custom_nodes/rgthree-comfy/.github/workflows/publish_comfy_registry_action.yml

@@ -0,0 +1,20 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+    paths:
+      - "pyproject.toml"
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@main
+        with:
+          personal_access_token: ${{ secrets.COMFY_REGISTRY_ACCESS_TOKEN }}

custom_nodes/rgthree-comfy/.gitignore

@@ -0,0 +1,13 @@
+__pycache__
+*.ini
+wildcards/**
+.vscode/
+.idea/
+node_modules/
+rgthree_config.json
+web/rgthree_config.js
+web/comfyui/rgthree_config.js
+userdata/
+userdata/**
+web/comfyui/testing/
+web/comfyui/tests/

custom_nodes/rgthree-comfy/.prettierrc.json

@@ -0,0 +1,5 @@
+{
+  "printWidth": 100,
+  "bracketSpacing": false,
+  "bracketSameLine": true
+}

custom_nodes/rgthree-comfy/.pylintrc

@@ -0,0 +1,633 @@
+[MAIN]
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+# Clear in-memory caches upon conclusion of linting. Useful if running pylint
+# in a server-like mode.
+clear-cache-post-run=no
+
+# Load and enable all available extensions. Use --list-extensions to see a list
+# all available extensions.
+#enable-all-extensions=
+
+# In error mode, messages with a category besides ERROR or FATAL are
+# suppressed, and no reports are done by default. Error mode is compatible with
+# disabling specific errors.
+#errors-only=
+
+# Always return a 0 (non-error) status code, even if lint errors are found.
+# This is primarily useful in continuous integration scripts.
+#exit-zero=
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code.
+extension-pkg-allow-list=
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code. (This is an alternative name to extension-pkg-allow-list
+# for backward compatibility.)
+extension-pkg-whitelist=
+
+# Return non-zero exit code if any of these messages/categories are detected,
+# even if score is above --fail-under value. Syntax same as enable. Messages
+# specified are enabled, while categories only check already-enabled messages.
+fail-on=
+
+# Specify a score threshold under which the program will exit with error.
+fail-under=10
+
+# Interpret the stdin as a python script, whose filename needs to be passed as
+# the module_or_package argument.
+#from-stdin=
+
+# Files or directories to be skipped. They should be base names, not paths.
+ignore=CVS
+
+# Add files or directories matching the regular expressions patterns to the
+# ignore-list. The regex matches against paths and can be in Posix or Windows
+# format. Because '\\' represents the directory delimiter on Windows systems,
+# it can't be used as an escape character.
+ignore-paths=
+
+# Files or directories matching the regular expression patterns are skipped.
+# The regex matches against base names, not paths. The default value ignores
+# Emacs file locks
+ignore-patterns=^\.#
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis). It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
+# number of processors available to use, and will cap the count on Windows to
+# avoid hangs.
+jobs=1
+
+# Control the amount of potential inferred values when inferring a single
+# object. This can help the performance when dealing with large functions or
+# complex, nested conditions.
+limit-inference-results=100
+
+# List of plugins (as comma separated values of python module names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# Minimum Python version to use for version dependent checks. Will default to
+# the version used to run pylint.
+py-version=3.10
+
+# Discover python modules and packages in the file system subtree.
+recursive=no
+
+# Add paths to the list of the source roots. Supports globbing patterns. The
+# source root is an absolute path or a path relative to the current working
+# directory used to determine a package namespace for modules located under the
+# source root.
+source-roots=
+
+# When enabled, pylint would attempt to guess common misconfiguration and emit
+# user-friendly hints instead of false-positive error messages.
+suggestion-mode=yes
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+# In verbose mode, extra non-checker-related info will be displayed.
+#verbose=
+
+
+[BASIC]
+
+# Naming style matching correct argument names.
+argument-naming-style=snake_case
+
+# Regular expression matching correct argument names. Overrides argument-
+# naming-style. If left empty, argument names will be checked with the set
+# naming style.
+#argument-rgx=
+
+# Naming style matching correct attribute names.
+attr-naming-style=snake_case
+
+# Regular expression matching correct attribute names. Overrides attr-naming-
+# style. If left empty, attribute names will be checked with the set naming
+# style.
+#attr-rgx=
+
+# Bad variable names which should always be refused, separated by a comma.
+bad-names=foo,
+          bar,
+          baz,
+          toto,
+          tutu,
+          tata
+
+# Bad variable names regexes, separated by a comma. If names match any regex,
+# they will always be refused
+bad-names-rgxs=
+
+# Naming style matching correct class attribute names.
+class-attribute-naming-style=any
+
+# Regular expression matching correct class attribute names. Overrides class-
+# attribute-naming-style. If left empty, class attribute names will be checked
+# with the set naming style.
+#class-attribute-rgx=
+
+# Naming style matching correct class constant names.
+class-const-naming-style=UPPER_CASE
+
+# Regular expression matching correct class constant names. Overrides class-
+# const-naming-style. If left empty, class constant names will be checked with
+# the set naming style.
+#class-const-rgx=
+
+# Naming style matching correct class names.
+class-naming-style=PascalCase
+
+# Regular expression matching correct class names. Overrides class-naming-
+# style. If left empty, class names will be checked with the set naming style.
+#class-rgx=
+
+# Naming style matching correct constant names.
+const-naming-style=UPPER_CASE
+
+# Regular expression matching correct constant names. Overrides const-naming-
+# style. If left empty, constant names will be checked with the set naming
+# style.
+#const-rgx=
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=-1
+
+# Naming style matching correct function names.
+function-naming-style=snake_case
+
+# Regular expression matching correct function names. Overrides function-
+# naming-style. If left empty, function names will be checked with the set
+# naming style.
+#function-rgx=
+
+# Good variable names which should always be accepted, separated by a comma.
+good-names=i,
+           j,
+           k,
+           ex,
+           Run,
+           _
+
+# Good variable names regexes, separated by a comma. If names match any regex,
+# they will always be accepted
+good-names-rgxs=
+
+# Include a hint for the correct naming format with invalid-name.
+include-naming-hint=no
+
+# Naming style matching correct inline iteration names.
+inlinevar-naming-style=any
+
+# Regular expression matching correct inline iteration names. Overrides
+# inlinevar-naming-style. If left empty, inline iteration names will be checked
+# with the set naming style.
+#inlinevar-rgx=
+
+# Naming style matching correct method names.
+method-naming-style=snake_case
+
+# Regular expression matching correct method names. Overrides method-naming-
+# style. If left empty, method names will be checked with the set naming style.
+#method-rgx=
+
+# Naming style matching correct module names.
+module-naming-style=snake_case
+
+# Regular expression matching correct module names. Overrides module-naming-
+# style. If left empty, module names will be checked with the set naming style.
+#module-rgx=
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=^_
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+# These decorators are taken in consideration only for invalid-name.
+property-classes=abc.abstractproperty
+
+# Regular expression matching correct type alias names. If left empty, type
+# alias names will be checked with the set naming style.
+#typealias-rgx=
+
+# Regular expression matching correct type variable names. If left empty, type
+# variable names will be checked with the set naming style.
+#typevar-rgx=
+
+# Naming style matching correct variable names.
+variable-naming-style=snake_case
+
+# Regular expression matching correct variable names. Overrides variable-
+# naming-style. If left empty, variable names will be checked with the set
+# naming style.
+#variable-rgx=
+
+
+[CLASSES]
+
+# Warn about protected attribute access inside special methods
+check-protected-access-in-special-methods=no
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,
+                      __new__,
+                      setUp,
+                      asyncSetUp,
+                      __post_init__
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,_fields,_replace,_source,_make,os._exit
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+
+[DESIGN]
+
+# List of regular expressions of class ancestor names to ignore when counting
+# public methods (see R0903)
+exclude-too-few-public-methods=
+
+# List of qualified class names to ignore when counting class parents (see
+# R0901)
+ignored-parents=
+
+# Maximum number of arguments for function / method.
+max-args=5
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Maximum number of boolean expressions in an if statement (see R0916).
+max-bool-expr=5
+
+# Maximum number of branch for function / method body.
+max-branches=12
+
+# Maximum number of locals for function / method body.
+max-locals=15
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of return / yield for function / method body.
+max-returns=6
+
+# Maximum number of statements in function / method body.
+max-statements=50
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when caught.
+overgeneral-exceptions=builtins.BaseException,builtins.Exception
+
+
+[FORMAT]
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Number of spaces of indent required inside a hanging or continued line.
+indent-after-paren=4
+
+# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
+# tab).
+indent-string='  '
+
+# Maximum number of characters on a single line.
+max-line-length=100
+
+# Maximum number of lines in a module.
+max-module-lines=1000
+
+# Allow the body of a class to be on the same line as the declaration if body
+# contains single statement.
+single-line-class-stmt=no
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+
+[IMPORTS]
+
+# List of modules that can be imported at any level, not just the top level
+# one.
+allow-any-import-level=
+
+# Allow explicit reexports by alias from a package __init__.
+allow-reexport-from-package=no
+
+# Allow wildcard imports from modules that define __all__.
+allow-wildcard-with-all=no
+
+# Deprecated modules which should not be used, separated by a comma.
+deprecated-modules=
+
+# Output a graph (.gv or any supported image format) of external dependencies
+# to the given file (report RP0402 must not be disabled).
+ext-import-graph=
+
+# Output a graph (.gv or any supported image format) of all (i.e. internal and
+# external) dependencies to the given file (report RP0402 must not be
+# disabled).
+import-graph=
+
+# Output a graph (.gv or any supported image format) of internal dependencies
+# to the given file (report RP0402 must not be disabled).
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=enchant
+
+# Couples of modules and preferred modules, separated by a comma.
+preferred-modules=
+
+
+[LOGGING]
+
+# The type of string formatting that logging methods do. `old` means using %
+# formatting, `new` is for `{}` formatting.
+logging-format-style=old
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format.
+logging-modules=logging
+
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE,
+# UNDEFINED.
+confidence=HIGH,
+           CONTROL_FLOW,
+           INFERENCE,
+           INFERENCE_FAILURE,
+           UNDEFINED
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once). You can also use "--disable=all" to
+# disable everything first and then re-enable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use "--disable=all --enable=classes
+# --disable=W".
+disable=raw-checker-failed,
+        bad-inline-option,
+        locally-disabled,
+        file-ignored,
+        suppressed-message,
+        useless-suppression,
+        deprecated-pragma,
+        use-symbolic-message-instead,
+        C0103, # invalid-name :: constant case
+        W0603 # global-statements
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+enable=c-extension-no-member
+
+
+[METHOD_ARGS]
+
+# List of qualified names (i.e., library.method) which require a timeout
+# parameter e.g. 'requests.api.get,requests.api.post'
+timeout-methods=requests.api.delete,requests.api.get,requests.api.head,requests.api.options,requests.api.patch,requests.api.post,requests.api.put,requests.api.request
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,
+      XXX,
+      TODO
+
+# Regular expression of note tags to take in consideration.
+notes-rgx=
+
+
+[REFACTORING]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+# Complete name of functions that never returns. When checking for
+# inconsistent-return-statements if a never returning function is called then
+# it will be considered as an explicit return statement and no message will be
+# printed.
+never-returning-functions=sys.exit,argparse.parse_error
+
+
+[REPORTS]
+
+# Python expression which should return a score less than or equal to 10. You
+# have access to the variables 'fatal', 'error', 'warning', 'refactor',
+# 'convention', and 'info' which contain the number of messages in each
+# category, as well as 'statement' which is the total number of statements
+# analyzed. This score is used by the global evaluation report (RP0004).
+evaluation=max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10))
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details.
+msg-template=
+
+# Set the output format. Available formats are text, parseable, colorized, json
+# and msvs (visual studio). You can also give a reporter class, e.g.
+# mypackage.mymodule.MyReporterClass.
+#output-format=
+
+# Tells whether to display a full report or only the messages.
+reports=no
+
+# Activate the evaluation score.
+score=yes
+
+
+[SIMILARITIES]
+
+# Comments are removed from the similarity computation
+ignore-comments=yes
+
+# Docstrings are removed from the similarity computation
+ignore-docstrings=yes
+
+# Imports are removed from the similarity computation
+ignore-imports=yes
+
+# Signatures are removed from the similarity computation
+ignore-signatures=yes
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+
+[SPELLING]
+
+# Limits count of emitted suggestions for spelling mistakes.
+max-spelling-suggestions=4
+
+# Spelling dictionary name. No available dictionaries : You need to install
+# both the python package and the system dependency for enchant to work..
+spelling-dict=
+
+# List of comma separated words that should be considered directives if they
+# appear at the beginning of a comment and should not be checked.
+spelling-ignore-comment-directives=fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=
+
+# A path to a file that contains the private dictionary; one word per line.
+spelling-private-dict-file=
+
+# Tells whether to store unknown words to the private dictionary (see the
+# --spelling-private-dict-file option) instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[STRING]
+
+# This flag controls whether inconsistent-quotes generates a warning when the
+# character used as a quote delimiter is used inconsistently within a module.
+check-quote-consistency=no
+
+# This flag controls whether the implicit-str-concat should generate a warning
+# on implicit string concatenation in sequences defined over several lines.
+check-str-concat-over-line-jumps=no
+
+
+[TYPECHECK]
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=
+
+# Tells whether to warn about missing members when the owner of the attribute
+# is inferred to be None.
+ignore-none=yes
+
+# This flag controls whether pylint should warn about no-member and similar
+# checks whenever an opaque object is returned when inferring. The inference
+# can return multiple potential results while evaluating a Python object, but
+# some branches might not be evaluated, which results in partial inference. In
+# that case, it might be useful to still emit no-member and other checks for
+# the rest of the inferred objects.
+ignore-on-opaque-inference=yes
+
+# List of symbolic message names to ignore for Mixin members.
+ignored-checks-for-mixins=no-member,
+                          not-async-context-manager,
+                          not-context-manager,
+                          attribute-defined-outside-init
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local,argparse.Namespace
+
+# Show a hint with possible names when a member name was not found. The aspect
+# of finding the hint is based on edit distance.
+missing-member-hint=yes
+
+# The minimum edit distance a name should have in order to be considered a
+# similar match for a missing member name.
+missing-member-hint-distance=1
+
+# The total number of similar names that should be taken in consideration when
+# showing a hint for a missing member.
+missing-member-max-choices=1
+
+# Regex pattern to define which classes are considered mixins.
+mixin-class-rgx=.*[Mm]ixin
+
+# List of decorators that change the signature of a decorated function.
+signature-mutators=
+
+
+[VARIABLES]
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid defining new builtins when possible.
+additional-builtins=
+
+# Tells whether unused global variables should be treated as a violation.
+allow-global-unused-variables=yes
+
+# List of names allowed to shadow builtins
+allowed-redefined-builtins=
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,
+          _cb
+
+# A regular expression matching the name of dummy variables (i.e. expected to
+# not be used).
+dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
+
+# Argument names that match this expression will be ignored.
+ignored-argument-names=_.*|^ignored_|^unused_
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io

custom_nodes/rgthree-comfy/.style.yapf

@@ -0,0 +1,11 @@
+# https://github.com/google/yapf
+[style]
+based_on_style = google
+INDENT_WIDTH = 2
+CONTINUATION_INDENT_WIDTH = 2
+COLUMN_LIMIT = 100
+DISABLE_ENDING_COMMA_HEURISTIC = true
+DEDENT_CLOSING_BRACKETS = true
+FORCE_MULTILINE_DICT = false
+coalesce_brackets=True
+ALLOW_SPLIT_BEFORE_DICT_VALUE  = false

custom_nodes/rgthree-comfy/.tracking

@@ -0,0 +1,257 @@
+.github/workflows/publish_comfy_registry_action.yml
+.gitignore
+.prettierrc.json
+.pylintrc
+.style.yapf
+LICENSE
+README.md
+__build__.py
+__commit__.py
+__init__.py
+__update_comfy__.py
+docs/rgthree_advanced.png
+docs/rgthree_advanced_metadata.png
+docs/rgthree_context.png
+docs/rgthree_context_metadata.png
+docs/rgthree_router.png
+docs/rgthree_seed.png
+package-lock.json
+package.json
+pnpm-lock.yaml
+prestartup_script.py
+py/__init__.py
+py/any_switch.py
+py/config.py
+py/constants.py
+py/context.py
+py/context_big.py
+py/context_merge.py
+py/context_merge_big.py
+py/context_switch.py
+py/context_switch_big.py
+py/context_utils.py
+py/display_any.py
+py/dynamic_context.py
+py/dynamic_context_switch.py
+py/image_comparer.py
+py/image_inset_crop.py
+py/image_or_latent_size.py
+py/image_resize.py
+py/ksampler_config.py
+py/log.py
+py/lora_stack.py
+py/power_lora_loader.py
+py/power_primitive.py
+py/power_prompt.py
+py/power_prompt_simple.py
+py/power_prompt_utils.py
+py/power_puter.py
+py/pyproject.py
+py/sdxl_empty_latent_image.py
+py/sdxl_power_prompt_postive.py
+py/sdxl_power_prompt_simple.py
+py/seed.py
+py/server/rgthree_server.py
+py/server/routes_config.py
+py/server/routes_model_info.py
+py/server/utils_info.py
+py/server/utils_server.py
+py/utils.py
+py/utils_userdata.py
+pyproject.toml
+requirements.txt
+rgthree_config.json.default
+src_web/comfyui/any_switch.ts
+src_web/comfyui/base_any_input_connected_node.ts
+src_web/comfyui/base_node.ts
+src_web/comfyui/base_node_collector.ts
+src_web/comfyui/base_node_mode_changer.ts
+src_web/comfyui/base_power_prompt.ts
+src_web/comfyui/bookmark.ts
+src_web/comfyui/bypasser.ts
+src_web/comfyui/comfy_ui_bar.ts
+src_web/comfyui/config.ts
+src_web/comfyui/constants.ts
+src_web/comfyui/context.ts
+src_web/comfyui/dialog_info.ts
+src_web/comfyui/display_any.ts
+src_web/comfyui/dynamic_context.ts
+src_web/comfyui/dynamic_context_base.ts
+src_web/comfyui/dynamic_context_switch.ts
+src_web/comfyui/fast_actions_button.ts
+src_web/comfyui/fast_groups_bypasser.ts
+src_web/comfyui/fast_groups_muter.ts
+src_web/comfyui/feature_group_fast_toggle.ts
+src_web/comfyui/feature_import_individual_nodes.ts
+src_web/comfyui/image_comparer.ts
+src_web/comfyui/image_inset_crop.ts
+src_web/comfyui/image_or_latent_size.ts
+src_web/comfyui/label.ts
+src_web/comfyui/menu_auto_nest.ts
+src_web/comfyui/menu_copy_image.ts
+src_web/comfyui/menu_queue_node.ts
+src_web/comfyui/muter.ts
+src_web/comfyui/node_collector.ts
+src_web/comfyui/node_mode_relay.ts
+src_web/comfyui/node_mode_repeater.ts
+src_web/comfyui/power_conductor.ts
+src_web/comfyui/power_lora_loader.ts
+src_web/comfyui/power_primitive.ts
+src_web/comfyui/power_prompt.ts
+src_web/comfyui/power_puter.ts
+src_web/comfyui/random_unmuter.ts
+src_web/comfyui/reroute.ts
+src_web/comfyui/rgthree.scss
+src_web/comfyui/rgthree.ts
+src_web/comfyui/seed.ts
+src_web/comfyui/services/bookmarks_services.ts
+src_web/comfyui/services/config_service.ts
+src_web/comfyui/services/context_service.ts
+src_web/comfyui/services/fast_groups_service.ts
+src_web/comfyui/services/key_events_services.ts
+src_web/comfyui/testing/comfyui_env.ts
+src_web/comfyui/testing/runner.ts
+src_web/comfyui/testing/utils_test.ts
+src_web/comfyui/tests/context_dynamic_tests.ts
+src_web/comfyui/tests/image_or_latent_size_tests.ts
+src_web/comfyui/tests/power_puter.ts
+src_web/comfyui/utils.ts
+src_web/comfyui/utils_canvas.ts
+src_web/comfyui/utils_deprecated_comfyui.ts
+src_web/comfyui/utils_inputs_outputs.ts
+src_web/comfyui/utils_menu.ts
+src_web/comfyui/utils_widgets.ts
+src_web/common/comfyui_shim.ts
+src_web/common/comfyui_shim_pnginfo.ts
+src_web/common/components/base_custom_element.ts
+src_web/common/css/buttons.scss
+src_web/common/css/dialog.scss
+src_web/common/css/dialog_lora_chooser.scss
+src_web/common/css/dialog_model_info.scss
+src_web/common/css/menu.scss
+src_web/common/css/pages_base.scss
+src_web/common/dialog.ts
+src_web/common/link_fixer.ts
+src_web/common/media/rgthree.svg
+src_web/common/media/svgs.ts
+src_web/common/menu.ts
+src_web/common/model_info_service.ts
+src_web/common/progress_bar.ts
+src_web/common/prompt_service.ts
+src_web/common/py_parser.ts
+src_web/common/rgthree_api.ts
+src_web/common/shared_utils.ts
+src_web/common/utils_dom.ts
+src_web/common/utils_templates.ts
+src_web/common/utils_workflow.ts
+src_web/lib/tree-sitter-python.wasm
+src_web/lib/tree-sitter.js
+src_web/lib/tree-sitter.wasm
+src_web/link_fixer/icon_file_json.png
+src_web/link_fixer/index.html
+src_web/link_fixer/link_page.ts
+src_web/models/components/model-info-card.html
+src_web/models/components/model-info-card.scss
+src_web/models/components/model-info-card.ts
+src_web/models/index.html
+src_web/models/models.scss
+src_web/models/models_info_page.ts
+src_web/scripts_comfy/README.md
+src_web/scripts_comfy/api.ts
+src_web/scripts_comfy/app.ts
+src_web/scripts_comfy/widgets.ts
+src_web/typings/comfy.d.ts
+src_web/typings/index.d.ts
+src_web/typings/litegraph.d.ts
+src_web/typings/rgthree.d.ts
+src_web/typings/web-tree-sitter.d.ts
+tsconfig.json
+web/comfyui/any_switch.js
+web/comfyui/base_any_input_connected_node.js
+web/comfyui/base_node.js
+web/comfyui/base_node_collector.js
+web/comfyui/base_node_mode_changer.js
+web/comfyui/base_power_prompt.js
+web/comfyui/bookmark.js
+web/comfyui/bypasser.js
+web/comfyui/comfy_ui_bar.js
+web/comfyui/config.js
+web/comfyui/constants.js
+web/comfyui/context.js
+web/comfyui/dialog_info.js
+web/comfyui/display_any.js
+web/comfyui/dynamic_context.js
+web/comfyui/dynamic_context_base.js
+web/comfyui/dynamic_context_switch.js
+web/comfyui/fast_actions_button.js
+web/comfyui/fast_groups_bypasser.js
+web/comfyui/fast_groups_muter.js
+web/comfyui/feature_group_fast_toggle.js
+web/comfyui/feature_import_individual_nodes.js
+web/comfyui/image_comparer.js
+web/comfyui/image_inset_crop.js
+web/comfyui/image_or_latent_size.js
+web/comfyui/label.js
+web/comfyui/menu_auto_nest.js
+web/comfyui/menu_copy_image.js
+web/comfyui/menu_queue_node.js
+web/comfyui/muter.js
+web/comfyui/node_collector.js
+web/comfyui/node_mode_relay.js
+web/comfyui/node_mode_repeater.js
+web/comfyui/power_conductor.js
+web/comfyui/power_lora_loader.js
+web/comfyui/power_primitive.js
+web/comfyui/power_prompt.js
+web/comfyui/power_puter.js
+web/comfyui/random_unmuter.js
+web/comfyui/reroute.js
+web/comfyui/rgthree.css
+web/comfyui/rgthree.js
+web/comfyui/seed.js
+web/comfyui/services/bookmarks_services.js
+web/comfyui/services/config_service.js
+web/comfyui/services/context_service.js
+web/comfyui/services/fast_groups_service.js
+web/comfyui/services/key_events_services.js
+web/comfyui/utils.js
+web/comfyui/utils_canvas.js
+web/comfyui/utils_deprecated_comfyui.js
+web/comfyui/utils_inputs_outputs.js
+web/comfyui/utils_menu.js
+web/comfyui/utils_widgets.js
+web/common/comfyui_shim.js
+web/common/comfyui_shim_pnginfo.js
+web/common/components/base_custom_element.js
+web/common/css/buttons.css
+web/common/css/dialog.css
+web/common/css/dialog_lora_chooser.css
+web/common/css/dialog_model_info.css
+web/common/css/menu.css
+web/common/css/pages_base.css
+web/common/dialog.js
+web/common/link_fixer.js
+web/common/media/rgthree.svg
+web/common/media/svgs.js
+web/common/menu.js
+web/common/model_info_service.js
+web/common/progress_bar.js
+web/common/prompt_service.js
+web/common/py_parser.js
+web/common/rgthree_api.js
+web/common/shared_utils.js
+web/common/utils_dom.js
+web/common/utils_templates.js
+web/common/utils_workflow.js
+web/lib/tree-sitter-python.wasm
+web/lib/tree-sitter.js
+web/lib/tree-sitter.wasm
+web/link_fixer/icon_file_json.png
+web/link_fixer/index.html
+web/link_fixer/link_page.js
+web/models/components/model-info-card.css
+web/models/components/model-info-card.html
+web/models/components/model-info-card.js
+web/models/index.html
+web/models/models.css
+web/models/models_info_page.js

custom_nodes/rgthree-comfy/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Regis Gaughan, III (rgthree)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

custom_nodes/rgthree-comfy/README.md

@@ -0,0 +1,434 @@
+<h1 align="center">
+    rgthree-comfy
+    <br>
+    <sub><sup><i>Making ComfyUI more comfortable!</i></sup></sub>
+    <br>
+</h1>
+<p align="center">
+    <a href="#️-the-nodes">The Nodes</a> &nbsp; | &nbsp; <a href="#-improvements--features">Improvements & Features</a>  &nbsp; | &nbsp; <a href="#-link-fixer">Link Fixer</a>
+</p>
+<hr>
+
+A collection of nodes and improvements created while messing around with ComfyUI. I made them for myself to make my workflow cleaner, easier, and faster. You're welcome to try them out. But remember, I made them for my own use cases :)
+
+![Context Node](./docs/rgthree_advanced.png)
+
+# Get Started
+
+## Install
+
+1. Install the great [ComfyUi](https://github.com/comfyanonymous/ComfyUI).
+2. Clone this repo into `custom_modules`:
+    ```
+    cd ComfyUI/custom_nodes
+    git clone https://github.com/rgthree/rgthree-comfy.git
+    ```
+3. Start up ComfyUI.
+
+## Settings
+
+You can configure certain aspect of rgthree-comfy. For instance, perhaps a future ComfyUI change breaks rgthree-comfy, or you already have another extension that does something similar and you want to turn it off for rgthree-comfy.
+
+You can get to rgthree-settings by right-clicking on the empty part of the graph, and selecting `rgthree-comfy > Settings (rgthree-comfy)` or by clicking the `rgthree-comfy settings` in the ComfyUI settings dialog.
+
+_(Note, settings are stored in an `rgthree_config.json` in the `rgthree-comfy` directory. There are other advanced settings that can only be configured there; You can copy default settings from `rgthree_config.json.default` before `rgthree_config.json` before modifying)_.
+
+<br>
+
+# ✴️ The Nodes
+
+Note, you can right-click on a bunch of the rgthree-comfy nodes and select `🛟 Node Help` menu item for in-app help when available.
+
+## Seed
+> An intuitive seed control node for ComfyUI that works very much like Automatic1111's seed control.
+> <details>
+>    <summary>ℹ️ <i>See More Information</i></summary>
+>
+>    - Set the seed value to "-1" to use a random seed every time
+>    - Set any other number in there to use as a static/fixed seed
+>    - Quick actions to randomize, or (re-)use the last queued seed.
+>    - Images metadata will store the seed value _(so dragging an image in, will have the seed field already fixed to its seed)_.
+>    - _Secret Features_: You can manually set the seed value to "-2" or "-3" to increment or decrement the last seed value. If there was not last seed value, it will randomly use on first.
+>
+>    ![Router Node](./docs/rgthree_seed.png)
+>    </details>
+
+
+## Reroute
+> Keep your workflow neat with this much improved Reroute node with, like, actual rerouting with multiple directions and sizes.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - Use the right-click context menu to change the width, height and connection layout
+>    - Also toggle resizability (min size is 40x43 if resizing though), and title/type display.
+>
+>    ![Router Node](./docs/rgthree_router.png)
+>    </details>
+
+## Bookmark (🔖)
+> Place the bookmark node anywhere on screen to quickly navigate to that with a shortcut key.
+> <details>
+>    <summary>ℹ️ <i>See More Information</i></summary>
+>
+>    - Define the `shortcut_key` to press to go right to that bookmark node, anchored in the top left.
+>    - You can also define the zoom level as well!
+>    - Pro tip: `shortcut_key` can be multiple keys. For instance "alt + shift + !" would require
+>      pressing the alt key, the shift key, and the "!" (as in the "1" key, but with shift pressed)
+>      in order to trigger.
+>    </details>
+
+
+## Context / Context Big
+> Pass along in general flow properties, and merge in new data. Similar to some other node suites "pipes" but easier merging, is more easily interoperable with standard nodes by both combining and exploding all in a single node.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - Context and Context Big are backwards compatible with each other. That is, an input connected to a Context Big will be passed through the CONTEXT outputs through normal Context nodes and available as an output on either (or, Context Big if the output is only on that node, like "steps").
+>    - Pro Tip: When dragging a Context output over a nother node, hold down "ctrl" and release to automatically connect the other Context outputs to the hovered node.
+>    - Pro Tip: You can change between Context and Context Big nodes from the menu.
+>
+>    ![Context Node](./docs/rgthree_context.png)
+>    </details>
+
+## Image Comparer
+> The Image Comparer node compares two images on top of each other.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - **Note:** The right-click menu may show image options (Open Image, Save Image, etc.) which will correspond to the first image (image_a) if clicked on the left-half of the node, or the second image if on the right half of the node.
+>    - **Inputs:**
+>      - `image_a` _Required._ The first image to use to compare. If image_b is not supplied and image_a is a batch, the comparer will use the first two images of image_a.
+>      - `image_b` _Optional._ The second image to use to compare. Optional only if image_a is a batch with two images.
+>    - **Properties:** You can change the following properties (by right-clicking on the node, and select "Properties" or "Properties Panel" from the menu):
+>      - `comparer_mode` - Choose between "Slide" and "Click". Defaults to "Slide".
+
+
+## Image Inset Crop
+> The node that lets you crop an input image by either pixel value, or percentage value.
+
+
+## Display Any
+> Displays most any piece of text data from the backend _after execution_.
+
+## Power Lora Loader
+> A super-simply Lora Loader node that can load multiple Loras at once, and quick toggle each, all in an ultra-condensed node.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - Add as many Lora's as you would like by clicking the "+ Add Lora" button. There's no real limit!
+>    - Right-click on a Lora widget for special options to move the lora up or down
+>      _(no affect on image, just presentation)_, toggle it on/off, or delete the row all together.
+>    - from the properties, change the `Show Strengths` to choose between showing a single, simple
+>      strength value (which will be used for both model and clip), or a more advanced view with
+>      both model and clip strengths being modifiable.
+>    </details>
+
+
+## ~~Lora Loader Stack~~
+> _**Deprecated.** Used the `Power Lora Loader` instead._
+>
+> A simplified Lora Loader stack. Much like other suites, but more interoperable with standard inputs/outputs.
+
+
+## Power Prompt
+> Power up your prompt and get drop downs for adding your embeddings, loras, and even have saved prompt snippets.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - At the core, you can use Power Prompt almost as a String Primitive node with additional features of dropdowns for choosing your embeddings, and even loras, with no further processing. This will output just the raw `TEXT` to another node for any lora processing, CLIP Encoding, etc.
+>    - Connect a `CLIP` to the input to encode the text, with both the `CLIP` and `CONDITIONING` output right from the node.
+>    - Connect a `MODEL` to the input to parse and load any `<lora:...>` tags in the text automatically, without
+>      needing a separate Lora Loaders
+>    </details>
+
+## Power Prompt - Simple
+> Same as Power Prompt above, but without LORA support; made for a slightly cleaner negative prompt _(since negative prompts do not support loras)_.
+
+## SDXL Power Prompt - Positive
+> The SDXL sibling to the Power Prompt above. It contains the text_g and text_l as separate text inputs, as well a couple more input slots necessary to ensure proper clipe encoding. Combine with
+
+## SDXL Power Prompt - Simple
+> Like the non-SDXL `Power Prompt - Simple` node, this one is essentially the same as the SDXL Power Prompt but without lora support for either non-lora positive prompts or SDXL negative prompts _(since negative prompts do not support loras)_.
+
+## SDXL Config
+> Just some configuration fields for SDXL prompting. Honestly, could be used for non SDXL too.
+
+## Context Switch / Context Switch Big
+> A powerful node to branch your workflow. Works by choosing the first Context input that is not null/empty.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - Pass in several context nodes and the Context Switch will automatically choose the first non-null context to continue onward with.
+>    - Wondering how to toggle contexts to null? Use in conjuction with the **Fast Muter** or **Fast Groups Muter**
+>
+>    </details>
+
+## Any Switch
+> A powerful node to similar to the Context Switch above, that chooses the first input that is not null/empty.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - Pass in several inmputs of the same type and the Any Switch will automatically choose the first non-null value to continue onward with.
+>    - Wondering how to toggle contexts to null? Use in conjuction with the **Fast Muter** or **Fast Groups Muter**
+>
+>    </details>
+
+
+## Power Primitive
+> A single node that can output primitives (STRING, INT, FLOAT, BOOLEAN). If connecting an input, it will cast/convert the primitive input to the desired output.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - You can hide the type selector input from the right-click menu or properties.
+>    - You can also fast-switch the output type from the right-click menu as well.
+>
+>    </details>
+
+
+## Power Puter
+> A  powerful and versatile node that opens the door for a wide range of utility by offering mult-line code parsing for output. This node can be used for simple string concatenation, or math operations; to an image dimension or a node's widgets with advanced list comprehension. If you want to output something in your workflow, this is the node to do it.
+>
+> Additional documentation available in the [wiki](https://github.com/rgthree/rgthree-comfy/wiki/Node:-Power-Puter)
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - Evaluate almost any kind of input and more, and choose your output from INT, FLOAT, STRING, or BOOLEAN.
+>    - Connect some nodes and do simply math operations like `a + b` or `ceil(1 / 2)`.
+>    - Or do more advanced things, like input an image, and get the width like `a.shape[2]`.
+>    - Even more powerful, you can target nodes in the prompt that's sent to the backend. For instance; if you have a Power Lora Loader node at id #5, and want to get a comma-delimited list of the enabled loras, you could enter:
+>
+>      ```
+>      loras = [v.lora for v in node(5).inputs.values() if 'lora' in v and v.on]
+>      ', '.join(loras)
+>      ```
+>
+>    </details>
+
+## Fast Groups Muter
+> The Fast Groups Muter is an input-less node that automatically collects all groups in your current workflow and allows you to quickly mute and unmute all nodes within the group.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - Groups will automatically be shown, though you can filter, sort and more from the **node Properties** _(by right-clicking on the node, and select "Properties" or "Properties Panel" from the menu)_. Properties include:
+>    -  `matchColors` - Only add groups that match the provided colors. Can be ComfyUI colors (red, pale_blue) or hex codes (#a4d399). Multiple can be added, comma delimited.
+>    -  `matchTitle` - Filter the list of toggles by title match (string match, or regular expression).
+>    -  `showNav` - Add / remove a quick navigation arrow to take you to the group. (default: true)
+>    -  `showAllGraphs` - Show groups from all [sub]graphs in the workflow. (default: true)
+>    -  `sort` - Sort the toggles' order by "alphanumeric", graph "position", or "custom alphabet". (default: "position")
+>    -  `customSortAlphabet` - When the sort property is "custom alphabet" you can define the alphabet to use here, which will match the beginning of each group name and sort against it. If group titles do not match any custom alphabet entry, then they will be put after groups that do, ordered alphanumerically.
+>
+>        This can be a list of single characters, like "zyxw..." or comma delimited strings for more control, like "sdxl,pro,sd,n,p".
+>
+>        Note, when two group title match the same custom alphabet entry, the normal alphanumeric alphabet breaks the tie. For instance, a custom alphabet of "e,s,d" will order groups names like "SDXL, SEGS, Detailer" eventhough the custom alphabet has an "e" before "d" (where one may expect "SE" to be before "SD").
+>
+>        To have "SEGS" appear before "SDXL" you can use longer strings. For instance, the custom alphabet value of "se,s,f" would work here.
+>    -  `toggleRestriction` - Optionally, attempt to restrict the number of widgets that can be enabled to a maximum of one, or always one.
+>
+>        _Note: If using "max one" or "always one" then this is only enforced when clicking a toggle on this node; if nodes within groups are changed outside of the initial toggle click, then these restriction will not be enforced, and could result in a state where more than one toggle is enabled. This could also happen if nodes are overlapped with multiple groups._
+>    </details>
+
+## Fast Groups Bypasser
+> _Same as **Fast Groups Muter** above, but sets the connected nodes to "Bypass" instead of "Mute"_
+
+
+## Fast Muter
+> A powerful 'control panel' node to quickly toggle connected nodes allowing them to quickly be muted or enabled
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - Add a collection of all connected nodes allowing a single-spot as a "dashboard" to quickly enable and disable nodes. Two distinct nodes; one for "Muting" connected nodes, and one for "Bypassing" connected nodes.
+>    </details>
+
+
+## Fast Bypasser
+> Same as Fast Muter but sets the connected nodes to "Bypass"
+
+## Fast Actions Button
+> Oh boy, this node allows you to semi-automate connected nodes and/or ConfyUI.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - Connect nodes and, at the least, mute, bypass or enable them when the button is pressed.
+>    - Certain nodes expose additional actions. For instance, the `Seed` node you can set `Randomize Each Time` or `Use Last Queued Seed` when the button is pressed.
+>    - Also, from the node properties, set a shortcut key to toggle the button actions, without needing a click!
+>    </details>
+
+
+## Node Collector
+> Used to cleanup noodles, this will accept any number of input nodes and passes it along to another node.
+>
+> ⚠️ *Currently, this should really only be connected to **Fast Muter**, **Fast Bypasser**, or **Mute / Bypass Relay**.*
+
+
+## Mute / Bypass Repeater
+> A powerful node that will dispatch its Mute/Bypass/Active mode to all connected input nodes or, if in a group w/o any connected inputs, will dispatch its Mute/Bypass/Active mode to all nodes in that group.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - 💡 Pro Tip #1: Connect this node's output to a **Fast Muter** or **Fast Bypasser** to have a single toggle there that can mute/bypass/enable many nodes with one click.
+>
+>    - 💡 Pro Tip #2: Connect a **Mute / Bypass Relay** node to this node's inputs to have the relay automatically dispatch a mute/bypass/enable change to the repeater.
+>    </details>
+
+
+## Mute / Bypass Relay
+> An advanced node that, when working with a **Mute / Bypass Repeater**, will relay its input nodes'
+> modes (Mute, Bypass, or Active) to a connected repeater (which would then repeat that mode change
+> to all of its inputs).
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - When all connected input nodes are muted, the relay will set a connected repeater to mute (by
+>      default).
+>    - When all connected input nodes are bypassed, the relay will set a connected repeater to
+>      bypass (by default).
+>    - When _any_ connected input nodes are active, the relay will set a connected repeater to
+>      active (by default).
+>    - **Note:** If no inputs are connected, the relay will set a connected repeater to its mode
+>      _when its own mode is changed_. **Note**, if any inputs are connected, then the above bullets
+>      will occur and the Relay's mode does not matter.
+>    - **Pro Tip:** You can change which signals get sent on the above in the `Properties`.
+>       For instance, you could configure an inverse relay which will send a MUTE when any of its
+>       inputs are active (instead of sending an ACTIVE signal), and send an ACTIVE signal when all
+>       of its inputs are muted (instead of sending a MUTE signal), etc.
+>    </details>
+
+
+## Random Unmuter
+> An advanced node used to unmute one of its inputs randomly when the graph is queued (and, immediately mute it back).
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - **Note:** All input nodes MUST be muted to start; if not this node will not randomly unmute another. (This is powerful, as the generated image can be dragged in and the chosen input will already by unmuted and work w/o any further action.)
+>    - **Tip:** Connect a Repeater's output to this nodes input and place that Repeater on a group without any other inputs, and it will mute/unmute the entire group.
+>    </details>
+
+
+## Label
+> A purely visual node, this allows you to add a floating label to your workflow.
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - The text shown is the "Title" of the node and you can adjust the the font size, font family,
+>      font color, text alignment as well as a background color, padding, background border
+>      radius, and angle (in degrees) from the node's properties. You can double-click the node to
+>      open the properties panel.
+>    - The Title also supports the literal sequence "\\n" to insert a newline when drawing the label.
+>    - ~**Pro Tip #1:** You can add multiline text from the properties panel _(because ComfyUI let's
+>      you shift + enter there, only)._~
+>    - **Pro Tip #2:** You can use ComfyUI's native "pin" option in the right-click menu to make the
+>      label stick to the workflow and clicks to "go through". You can right-click at any time to
+>      unpin.
+>    - **Pro Tip #3:** Color values are hexidecimal strings, like "#FFFFFF" for white, or "#660000"
+>      for dark red. You can supply a 7th & 8th value (or 5th if using shorthand) to create a
+>      transluscent color. For instance, "#FFFFFF88" is semi-transparent white.
+>    </details>
+
+
+# Advanced Techniques
+
+## First, a word on muting
+
+A lot of the power of these nodes comes from *Muting*. Muting is the basis of correctly implementing multiple paths for a workflow utlizing the Context Switch node.
+
+While other extensions may provide switches, they often get it wrong causing your workflow to do more work than is needed. While other switches may have a selector to choose which input to pass along, they don't stop the execution of the other inputs, which will result in wasted work. Instead, Context Switch works by choosing the first non-empty context to pass along and correctly Muting is one way to make a previous node empty, and causes no extra work to be done when set up correctly.
+
+### To understand muting, is to understand the graph flow
+
+Muting, and therefore using Switches, can often confuse people at first because it _feels_ like muting a node, or using a switch, should be able to stop or direct the _forward_ flow of the graph. However, this is not the case and, in fact, the graph actually starts working backwards.
+
+If you have a workflow that has a path like `... > Context > KSampler > VAE Decode > Save Image` it may initially _feel_ like you should be able to mute that first Context node and the graph would stop there when moving forward and skip the rest of that workflow.
+
+But you'll quickly find that will cause an error, becase the graph doesn't actually move forward. When a workflow is processed, it _first moves backwards_ starting at each "Output Node" (Preview Image, Save Image, even "Display String" etc.) and then walking backwards to all possible paths to get there.
+
+So, with that `... > Context > KSampler > VAE Decode > Save Image` example from above, we actually want to mute the `Save Image` node to stop this path. Once we do, since the output node is gone, none of these nodes will be run.
+
+Let's take a look at an example.
+
+### A powerful combination: Using Context, Context Switch, & Fast Muter
+
+![Context Node](./docs/rgthree_advanced.png)
+
+1. Using the **Context Switch** (aqua colored in screenshot) feed context inputs in order of preference. In the workflow above, the `Upscale Out` context is first so, if that one is enabled, it will be chosen for the output. If not, the second input slot which comes from the context rerouted from above (before the Upscaler booth) will be chosen.
+
+    - Notice the `Upscale Preview` is _after_ the `Upscale Out` context node, using the image from it instead of the image from the upscale `VAE Decoder`. This is on purpose so, when we disable the `Upscale Out` context, none of the Upscaler nodes will run, saving precious GPU cycles. If we had the preview hooked up directly to the `VAE Decoder` the upscaler would always run to generate the preview, even if we had the `Upscale Out` context node disabled.
+
+2. We can now disable the `Upscale Out` context node by _muting_ it. Highlighting it and pressing `ctrl + m` will work. By doing so, it's output will be None, and it will not pass anthing onto the further nodes. In the diagram you can see the `Upscale Preview` is red, but that's OK; there are no actual errors to stop execution.
+
+3. Now, let's hook it up to the `Fast Muter` node. `The Fast Muter` node works as dashboard by adding quick toggles for any connected node (ignoring reroutes). In the diagram, we have both the `Upscaler Out` context node, and the `Save File` context node hooked up. So, we can quickly enable and disable those.
+
+    - The workflow seen here would be a common one where we can generate a handful of base previews cheaply with a random seed, and then choose one to upscale and save to disk.
+
+4. Lastly, and optionally, you can see the `Node Collector`. Use it to clean up noodles if you want and connect it to the muter. You can connect anything to it, but doing so may break your workflow's execution.
+
+<br>
+
+# ⚡ Improvements & Features
+
+rgthree-comfy adds several improvements, features, and optimizations to ComfyUI that are not directly tied to nodes.
+
+## Progress Bar
+> A minimal progress bar that run alongs the top of the app window that shows the queue size, the current progress of the a prompt execution (within the same window), and the progress of multi-step nodes as well.
+>
+> <i>You can remove/enable from rgthree-comfy settings, as well as configure the height/size.</i>
+
+
+## ~~ComfyUI Recursive Optimization~~
+> 🎉 The newest version of ComfyUI no longer suffers from poor execution recursion! This feature
+> has been removed from rgthree-comfy.
+
+
+## "Queue Selected Output Nodes" in right-click menu
+> Sometimes you want to just queue one or two paths to specific output node(s) without executing the entire workflow. Well, now you can do just that by right-clicking on an output node and selecting `Queue Selected Output Nodes (rgthree)`.
+>
+> <details>
+>    <summary>ℹ️ <i>More Information</i></summary>
+>
+>    - Select the _output_ nodes you want to execute.
+>
+>    - Note: Only output nodes are captured and traversed, not all selected nodes. So if you select an output AND a node from a different path, only the path connected to the output will be executed and not non-output nodes, even if they were selected.
+>
+>    - Note: The whole workflow is serialized, and then we trim what we don't want for the backend. So things like all seed random/increment/decrement will run even if that node isn't being sent in the end, etc.
+>
+> </details>
+
+
+## Auto-Nest Subdirectories in long Combos
+> _(Off by default while experimenting, turn on in rgthree-comfy settings)_.
+>
+> Automatically detect top-level subdirectories in long combo lists (like, Load Checkpoint) and break out into sub directories.
+
+
+## Quick Mute/Bypass Toggles in Group Headers
+> _(Off by default while experimenting, turn on in rgthree-comfy settings)_.
+>
+> Adds a mute and/or bypass toggle icons in the top-right of Group Headers for one-click toggling of groups you may be currently looking at.
+
+
+## Import Individual Node Widgets (Drag & Drop)
+> _(Off by default while experimenting, turn on in rgthree-comfy settings)_.
+>
+> Allows dragging and dropping an image/JSON workflow from a previous generation and overriding the same node's widgets
+> (that match with the same id & type). This is useful if you have several generations using the same general workflow
+> and would like to import just some data, like a previous generation's seed, or prompt, etc.
+
+
+
+## "Copy Image" in right-click menu
+> Right clicking on a node that has an image should have a context-menu item of "Copy Image" will allow you to copy the image right to your clipboard
+>
+> <i>🎓 I believe this has graduated, with ComfyUI recently adding this setting too. You won't get two menu items; my code checks that there isn't already a "Copy Image" item there before adding it.</i>
+
+
+## Other/Smaller Fixes
+- Fixed the width of ultra-wide node chooser on double click.
+- Fixed z-indexes for textareas that would overlap above other elements, like Properties Panel, or @pythongosssss's image viewer.
+- Check for bad links when loading a workflow and log to console, by default. _(See Link Fixer below)._
+
+<br>
+
+# 📄 Link Fixer
+
+If your workflows sometimes have missing connections, or even errors on load, start up ComfyUI and go to http://127.0.0.1:8188/rgthree/link_fixer which will allow you to drop in an image or workflow json file and check for and fix any bad links.
+
+You can also enable a link fixer check in the rgthree-comfy settings to give you an alert if you load a workflow with bad linking data to start.

custom_nodes/rgthree-comfy/__build__.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+
+import subprocess
+import os
+from shutil import rmtree, copytree, ignore_patterns
+from glob import glob
+import time
+import re
+import argparse
+
+from py.log import COLORS
+from py.config import RGTHREE_CONFIG
+
+step_msg = ''
+step_start = 0
+step_infos = []
+
+def log_step(msg=None, status=None):
+  """ Logs a step keeping track of timing and initial msg. """
+  global step_msg  # pylint: disable=W0601
+  global step_start  # pylint: disable=W0601
+  global step_infos  # pylint: disable=W0601
+  if msg:
+    tag = f'{COLORS["YELLOW"]}[ Notice ]' if status == 'Notice' else f'{COLORS["RESET"]}[Starting]'
+    step_msg = f'▻ {tag}{COLORS["RESET"]} {msg}...'
+    step_start = time.time()
+    step_infos = []
+    print(step_msg, end="\r")
+  elif status:
+    if status != 'Error':
+      warnings = [w for w in step_infos if w["type"] == 'warn']
+      status = "Warn" if warnings else status
+    step_time = round(time.time() - step_start, 3)
+    if status == 'Error':
+      status_msg = f'{COLORS["RED"]}⤫ {status}{COLORS["RESET"]}'
+    elif status == 'Warn':
+      status_msg = f'{COLORS["YELLOW"]}! {status}{COLORS["RESET"]}'
+    else:
+      status_msg = f'{COLORS["BRIGHT_GREEN"]}🗸 {status}{COLORS["RESET"]}'
+    print(f'{step_msg.ljust(64, ".")} {status_msg} ({step_time}s)')
+    for info in step_infos:
+      print(info["msg"])
+
+def log_step_info(msg:str, status='info'):
+  global step_infos  # pylint: disable=W0601
+  step_infos.append({"msg": f'  - {msg}', "type": status})
+
+
+def build(without_tests = True, fix = False):
+
+  THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+  DIR_SRC_WEB = os.path.abspath(f'{THIS_DIR}/src_web/')
+  DIR_WEB = os.path.abspath(f'{THIS_DIR}/web/')
+  DIR_WEB_COMFYUI = os.path.abspath(f'{DIR_WEB}/comfyui/')
+
+  if fix:
+    tss = glob(os.path.join(DIR_SRC_WEB, "**", "*.ts"), recursive=True)
+    log_step(msg=f'Fixing {len(tss)} ts files')
+    for ts in tss:
+      with open(ts, 'r', encoding="utf-8") as f:
+        content = f.read()
+      # (\s*from\s*['"](?!.*[.]js['"]).*?)(['"];) in vscode.
+      content, n = re.subn(r'(\s*from [\'"](?!.*[.]js[\'"]).*?)([\'"];)', '\\1.js\\2', content)
+      if n > 0:
+        filename = os.path.basename(ts)
+        log_step_info(
+          f'{filename} has {n} import{"s" if n > 1 else ""} that do not end in ".js"', 'warn')
+        with open(ts, 'w', encoding="utf-8") as f:
+          f.write(content)
+    log_step(status="Done")
+
+  log_step(msg='Copying web directory')
+  rmtree(DIR_WEB)
+  copytree(DIR_SRC_WEB, DIR_WEB, ignore=ignore_patterns("typings*", "*.ts", "*.scss"))
+  log_step(status="Done")
+
+  ts_version_result = subprocess.run(["node", "./node_modules/typescript/bin/tsc", "-v"],
+                                    capture_output=True,
+                                    text=True,
+                                    check=True)
+  ts_version = re.sub(r'^.*Version\s*([\d\.]+).*', 'v\\1', ts_version_result.stdout, flags=re.DOTALL)
+
+  log_step(msg=f'TypeScript ({ts_version})')
+  checked = subprocess.run(["node", "./node_modules/typescript/bin/tsc"], check=True)
+  log_step(status="Done")
+
+  if not without_tests:
+    log_step(msg='Removing directories (KEEPING TESTING)', status="Notice")
+  else:
+    log_step(msg='Removing unneeded directories')
+    test_path = os.path.join(DIR_WEB, 'comfyui', 'tests')
+    if os.path.exists(test_path):
+      rmtree(test_path)
+    rmtree(os.path.join(DIR_WEB, 'comfyui', 'testing'))
+  # Always remove the dummy scripts_comfy directory
+  rmtree(os.path.join(DIR_WEB, 'scripts_comfy'))
+  log_step(status="Done")
+
+  scsss = glob(os.path.join(DIR_SRC_WEB, "**", "*.scss"), recursive=True)
+  log_step(msg=f'SASS for {len(scsss)} files')
+  scsss = [i.replace(THIS_DIR, '.') for i in scsss]
+  cmds = ["node", "./node_modules/sass/sass"]
+  for scss in scsss:
+    out = scss.replace('src_web', 'web').replace('.scss', '.css')
+    cmds.append(f'{scss}:{out}')
+  cmds.append('--no-source-map')
+  checked = subprocess.run(cmds, check=True)
+  log_step(status="Done")
+
+  # Handle the common directories. Because ComfyUI loads under /extensions/rgthree-comfy we can't
+  # easily share sources outside of the `DIR_WEB_COMFYUI` _and_ allow typescript to resolve them in
+  # src view, so we set the path in the tsconfig to map an import of "rgthree/common" to the
+  # "src_web/common" directory, but then need to rewrite the comfyui JS files to load from
+  # "../../rgthree/common" (which we map correctly in rgthree_server.py).
+  log_step(msg='Cleaning Imports')
+  js_files = glob(os.path.join(DIR_WEB, '**', '*.js'), recursive=True)
+  for file in js_files:
+    rel_path = file.replace(f'{DIR_WEB}/', "")
+    with open(file, 'r', encoding="utf-8") as f:
+      filedata = f.read()
+    num = rel_path.count(os.sep)
+    if rel_path.startswith('comfyui'):
+      filedata = re.sub(r'(from\s+["\'])rgthree/', f'\\1{"../" * (num + 1)}rgthree/', filedata)
+      filedata = re.sub(r'(from\s+["\'])scripts/', f'\\1{"../" * (num + 1)}scripts/', filedata)
+      # Dynamic Imports
+      filedata = re.sub(r'(import\(["\'])rgthree/', f'\\1{"../" * (num + 1)}rgthree/', filedata)
+    else:
+      filedata = re.sub(r'(from\s+["\'])rgthree/', f'\\1{"../" * num}', filedata)
+      filedata = re.sub(r'(from\s+["\'])scripts/', f'\\1{"../" * (num + 1)}scripts/', filedata)
+      # Dynamic Imports
+      filedata = re.sub(r'(import\(["\'])rgthree/', f'\\1{"../" * num}', filedata)
+
+    filedata, n = re.subn(r'(\s*from [\'"](?!.*[.]js[\'"]).*?)([\'"];)', '\\1.js\\2', filedata)
+    if n > 0:
+      filename = file.split('rgthree-comfy')[1]
+      log_step_info(
+        f'{filename} has {n} import{"s" if n > 1 else ""} that do not end in ".js"', 'warn')
+    with open(file, 'w', encoding="utf-8") as f:
+      f.write(filedata)
+  log_step(status="Done")
+
+
+if __name__ == "__main__":
+  parser = argparse.ArgumentParser()
+  parser.add_argument("-t", "--no-tests", default=False, action="store_true")
+  parser.add_argument("-f", "--fix", default=False, action="store_true")
+  args = parser.parse_args()
+
+  start = time.time()
+  build(without_tests=args.no_tests, fix=args.fix)
+  print(f'Finished all in {round(time.time() - start, 3)}s')

custom_nodes/rgthree-comfy/__commit__.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+
+import subprocess
+import os
+import re
+import datetime
+import time
+import argparse
+
+from __build__ import build, log_step, log_step_info
+
+_THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+_FILE_PY_PROJECT = os.path.join(_THIS_DIR, 'pyproject.toml')
+
+parser = argparse.ArgumentParser()
+parser.add_argument(
+  "-m", "--message", help="The git commit message", required=True, action="store", type=str
+)
+args = parser.parse_args()
+
+start = time.time()
+build()
+
+log_step(msg='Updating version in pyproject.toml')
+py_project = ''
+with open(_FILE_PY_PROJECT, "r", encoding='utf-8') as f:
+  py_project = f.read()
+
+version = re.search(r'^\s*version\s*=\s*"(.*?)"', py_project, flags=re.MULTILINE)
+version_old = version[1]
+
+now = datetime.datetime.now()
+version_new = version_old.split('.')
+version_new[-1] = f'{str(now.year)[2:]}{now.month:02}{now.day:02}{now.hour:02}{now.minute:02}'
+version_new = '.'.join(version_new)
+
+log_step_info(f'Updating from v{version_old} to v{version_new}')
+py_project = py_project.replace(version_old, version_new)
+with open(_FILE_PY_PROJECT, "w", encoding='utf-8') as f:
+  f.write(py_project)
+log_step(status="Done")
+
+log_step('Running git add')
+process = subprocess.Popen(['git', 'add', '.'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+stdout, stderr = process.communicate()
+log_step(status="Done")
+
+log_step('Running git commit')
+process = subprocess.Popen(['git', 'commit', '-a', '-v', '-m', args.message],
+                           stdout=subprocess.PIPE,
+                           stderr=subprocess.PIPE)
+stdout, stderr = process.communicate()
+log_step(status="Done")
+
+print(f'Finished all in {round(time.time() - start, 3)}s')

custom_nodes/rgthree-comfy/__init__.py

@@ -0,0 +1,126 @@
+"""
+@author: rgthree
+@title: Comfy Nodes
+@nickname: rgthree
+@description: A bunch of nodes I created that I also find useful.
+"""
+
+from glob import glob
+import json
+import os
+import shutil
+import re
+import random
+
+import execution
+
+from .py.log import log
+from .py.config import get_config_value
+from .py.server.rgthree_server import *
+
+from .py.context import RgthreeContext
+from .py.context_switch import RgthreeContextSwitch
+from .py.context_switch_big import RgthreeContextSwitchBig
+from .py.display_any import RgthreeDisplayAny, RgthreeDisplayInt
+from .py.lora_stack import RgthreeLoraLoaderStack
+from .py.seed import RgthreeSeed
+from .py.sdxl_empty_latent_image import RgthreeSDXLEmptyLatentImage
+from .py.power_prompt import RgthreePowerPrompt
+from .py.power_prompt_simple import RgthreePowerPromptSimple
+from .py.image_inset_crop import RgthreeImageInsetCrop
+from .py.context_big import RgthreeBigContext
+from .py.dynamic_context import RgthreeDynamicContext
+from .py.dynamic_context_switch import RgthreeDynamicContextSwitch
+from .py.ksampler_config import RgthreeKSamplerConfig
+from .py.sdxl_power_prompt_postive import RgthreeSDXLPowerPromptPositive
+from .py.sdxl_power_prompt_simple import RgthreeSDXLPowerPromptSimple
+from .py.any_switch import RgthreeAnySwitch
+from .py.context_merge import RgthreeContextMerge
+from .py.context_merge_big import RgthreeContextMergeBig
+from .py.image_comparer import RgthreeImageComparer
+from .py.power_lora_loader import RgthreePowerLoraLoader
+from .py.power_primitive import RgthreePowerPrimitive
+from .py.image_or_latent_size import RgthreeImageOrLatentSize
+from .py.image_resize import RgthreeImageResize
+from .py.power_puter import RgthreePowerPuter
+
+NODE_CLASS_MAPPINGS = {
+  RgthreeBigContext.NAME: RgthreeBigContext,
+  RgthreeContext.NAME: RgthreeContext,
+  RgthreeContextSwitch.NAME: RgthreeContextSwitch,
+  RgthreeContextSwitchBig.NAME: RgthreeContextSwitchBig,
+  RgthreeContextMerge.NAME: RgthreeContextMerge,
+  RgthreeContextMergeBig.NAME: RgthreeContextMergeBig,
+  RgthreeDisplayInt.NAME: RgthreeDisplayInt,
+  RgthreeDisplayAny.NAME: RgthreeDisplayAny,
+  RgthreeLoraLoaderStack.NAME: RgthreeLoraLoaderStack,
+  RgthreeSeed.NAME: RgthreeSeed,
+  RgthreeImageInsetCrop.NAME: RgthreeImageInsetCrop,
+  RgthreePowerPrompt.NAME: RgthreePowerPrompt,
+  RgthreePowerPromptSimple.NAME: RgthreePowerPromptSimple,
+  RgthreeKSamplerConfig.NAME: RgthreeKSamplerConfig,
+  RgthreeSDXLEmptyLatentImage.NAME: RgthreeSDXLEmptyLatentImage,
+  RgthreeSDXLPowerPromptPositive.NAME: RgthreeSDXLPowerPromptPositive,
+  RgthreeSDXLPowerPromptSimple.NAME: RgthreeSDXLPowerPromptSimple,
+  RgthreeAnySwitch.NAME: RgthreeAnySwitch,
+  RgthreeImageComparer.NAME: RgthreeImageComparer,
+  RgthreePowerLoraLoader.NAME: RgthreePowerLoraLoader,
+  RgthreePowerPrimitive.NAME: RgthreePowerPrimitive,
+  RgthreeImageOrLatentSize.NAME: RgthreeImageOrLatentSize,
+  RgthreeImageResize.NAME: RgthreeImageResize,
+  RgthreePowerPuter.NAME: RgthreePowerPuter,
+}
+
+if get_config_value('unreleased.dynamic_context.enabled') is True:
+  NODE_CLASS_MAPPINGS[RgthreeDynamicContext.NAME] = RgthreeDynamicContext
+  NODE_CLASS_MAPPINGS[RgthreeDynamicContextSwitch.NAME] = RgthreeDynamicContextSwitch
+
+# WEB_DIRECTORY is the comfyui nodes directory that ComfyUI will link and auto-load.
+WEB_DIRECTORY = "./web/comfyui"
+
+THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+DIR_WEB = os.path.abspath(f'{THIS_DIR}/{WEB_DIRECTORY}')
+DIR_PY = os.path.abspath(f'{THIS_DIR}/py')
+
+# remove old directories
+OLD_DIRS = [
+  os.path.abspath(f'{THIS_DIR}/../../web/extensions/rgthree'),
+  os.path.abspath(f'{THIS_DIR}/../../web/extensions/rgthree-comfy'),
+]
+for old_dir in OLD_DIRS:
+  if os.path.exists(old_dir):
+    shutil.rmtree(old_dir)
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'WEB_DIRECTORY']
+
+NOT_NODES = ['constants', 'log', 'utils', 'rgthree', 'rgthree_server', 'image_clipbaord', 'config']
+
+nodes = []
+for file in glob(os.path.join(DIR_PY, '*.py')) + glob(os.path.join(DIR_WEB, '*.js')):
+  name = os.path.splitext(os.path.basename(file))[0]
+  if name in NOT_NODES or name in nodes:
+    continue
+  if name.startswith('_') or name.startswith('base') or 'utils' in name:
+    continue
+  nodes.append(name)
+  if name == 'display_any':
+    nodes.append('display_int')
+
+print()
+adjs = ['exciting', 'extraordinary', 'epic', 'fantastic', 'magnificent']
+log(f'Loaded {len(nodes)} {random.choice(adjs)} nodes. 🎉', color='BRIGHT_GREEN')
+print()
+
+if get_config_value('announcements.comfy-nodes-20.incompatible', True):
+  message = (
+    "ComfyUI's new Node 2.0 rendering may be incompatible with some rgthree-comfy nodes "
+    "and features, breaking some rendering as well as losing the ability to "
+    "access a node's properties (a vital part of many nodes). It also appears to run MUCH more "
+    "slowly spiking CPU usage and causing jankiness and unresponsiveness, especially with large "
+    "workflows. Personally I am not planning to use the new Nodes 2.0 and, unfortunately, am not "
+    "able to invest the time to investigate and overhaul rgthree-comfy where needed. "
+    "If you have issues when Nodes 2.0 is enabled, I'd urge you to switch it off as well and "
+    "join me in hoping ComfyUI is not planning to deprecate the existing, stable canvas rendering "
+    "all together.\n"
+  )
+  log(message, color='YELLOW', id='announcements.comfy-nodes-20.incompatible', at_most_secs=60)

custom_nodes/rgthree-comfy/__update_comfy__.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+
+# A nicer output for git pulling custom nodes (and ComfyUI).
+# Quick shell version: ls | xargs -I % sh -c 'echo; echo %; git -C % pull'
+
+import os
+from subprocess import Popen, PIPE, STDOUT
+
+
+def pull_path(path):
+  p = Popen(["git", "-C", path, "pull"], stdout=PIPE, stderr=STDOUT)
+  output, error = p.communicate()
+  return output.decode()
+
+THIS_DIR=os.path.dirname(os.path.abspath(__file__))
+
+def show_output(output):
+  if output.startswith('Already up to date'):
+    print(f' \33[32m🗸 {output}\33[0m', end ='')
+  elif output.startswith('error:'):
+    print(f' \33[31m🞫 Error.\33[0m \n {output}')
+  else:
+    print(f' \33[33m🡅 Needs update.\33[0m \n {output}', end='')
+
+
+os.chdir(THIS_DIR)
+os.chdir("../")
+
+# Get the list or custom nodes, so we can format the output a little more nicely.
+custom_extensions = []
+custom_extensions_name_max = 0
+for directory in os.listdir(os.getcwd()):
+  if os.path.isdir(directory) and directory != "__pycache__": #and directory != "rgthree-comfy" :
+    custom_extensions.append({
+      'directory': directory
+    })
+    if len(directory) > custom_extensions_name_max:
+      custom_extensions_name_max = len(directory)
+
+if len(custom_extensions) == 0:
+  custom_extensions_name_max = 15
+else:
+  custom_extensions_name_max += 6
+
+# Update ComfyUI itself.
+label = "{0:.<{max}}".format('Updating ComfyUI ', max=custom_extensions_name_max)
+print(label, end = '')
+show_output(pull_path('../'))
+
+# If we have custom nodes, update them as well.
+if len(custom_extensions) > 0:
+  print(f'\nUpdating custom_nodes ({len(custom_extensions)}):')
+  for custom_extension in custom_extensions:
+    directory = custom_extension['directory']
+    label = "{0:.<{max}}".format(f'🗀  {directory} ', max=custom_extensions_name_max)
+    print(label, end = '')
+    show_output(pull_path(directory))

custom_nodes/rgthree-comfy/package-lock.json

@@ -0,0 +1,568 @@
+{
+  "name": "rgthree-comfy",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "devDependencies": {
+        "@comfyorg/comfyui-frontend-types": "^1.32.4",
+        "prettier": "^3.3.3",
+        "sass": "^1.77.8",
+        "typescript": "^5.5.4",
+        "web-tree-sitter": "0.25.6"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz",
+      "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==",
+      "dev": true,
+      "peer": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
+      "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==",
+      "dev": true,
+      "peer": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.0.tgz",
+      "integrity": "sha512-iaepho73/2Pz7w2eMS0Q5f83+0RKI7i4xmiYeBmDzfRVbQtTOG7Ts0S4HzJVsTMGI9keU8rNfuZr8DKfSt7Yyg==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@babel/types": "^7.27.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.0.tgz",
+      "integrity": "sha512-H45s8fVLYjbhFH62dIJ3WtmJ6RSPt/3DRO0ZcT2SUiYiQyz3BLVb9ADEnLl91m74aQPS3AzzeajZHYOalWe3bg==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@comfyorg/comfyui-frontend-types": {
+      "version": "1.32.4",
+      "resolved": "https://registry.npmjs.org/@comfyorg/comfyui-frontend-types/-/comfyui-frontend-types-1.32.4.tgz",
+      "integrity": "sha512-9EBFwQPaSMLI151caWN5nA0qVmY5S9BR9lHP5NboPnTsmkFwnWdrAPadAnafwmZcK40ZWntKJZxO0Uuju0jw/w==",
+      "dev": true,
+      "peerDependencies": {
+        "vue": "^3.5.13",
+        "zod": "^3.23.8"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
+      "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+      "dev": true,
+      "peer": true
+    },
+    "node_modules/@vue/compiler-core": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.13.tgz",
+      "integrity": "sha512-oOdAkwqUfW1WqpwSYJce06wvt6HljgY3fGeM9NcVA1HaYOij3mZG9Rkysn0OHuyUAGMbEbARIpsG+LPVlBJ5/Q==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@babel/parser": "^7.25.3",
+        "@vue/shared": "3.5.13",
+        "entities": "^4.5.0",
+        "estree-walker": "^2.0.2",
+        "source-map-js": "^1.2.0"
+      }
+    },
+    "node_modules/@vue/compiler-dom": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.13.tgz",
+      "integrity": "sha512-ZOJ46sMOKUjO3e94wPdCzQ6P1Lx/vhp2RSvfaab88Ajexs0AHeV0uasYhi99WPaogmBlRHNRuly8xV75cNTMDA==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@vue/compiler-core": "3.5.13",
+        "@vue/shared": "3.5.13"
+      }
+    },
+    "node_modules/@vue/compiler-sfc": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.13.tgz",
+      "integrity": "sha512-6VdaljMpD82w6c2749Zhf5T9u5uLBWKnVue6XWxprDobftnletJ8+oel7sexFfM3qIxNmVE7LSFGTpv6obNyaQ==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@babel/parser": "^7.25.3",
+        "@vue/compiler-core": "3.5.13",
+        "@vue/compiler-dom": "3.5.13",
+        "@vue/compiler-ssr": "3.5.13",
+        "@vue/shared": "3.5.13",
+        "estree-walker": "^2.0.2",
+        "magic-string": "^0.30.11",
+        "postcss": "^8.4.48",
+        "source-map-js": "^1.2.0"
+      }
+    },
+    "node_modules/@vue/compiler-ssr": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.13.tgz",
+      "integrity": "sha512-wMH6vrYHxQl/IybKJagqbquvxpWCuVYpoUJfCqFZwa/JY1GdATAQ+TgVtgrwwMZ0D07QhA99rs/EAAWfvG6KpA==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.13",
+        "@vue/shared": "3.5.13"
+      }
+    },
+    "node_modules/@vue/reactivity": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.13.tgz",
+      "integrity": "sha512-NaCwtw8o48B9I6L1zl2p41OHo/2Z4wqYGGIK1Khu5T7yxrn+ATOixn/Udn2m+6kZKB/J7cuT9DbWWhRxqixACg==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@vue/shared": "3.5.13"
+      }
+    },
+    "node_modules/@vue/runtime-core": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.13.tgz",
+      "integrity": "sha512-Fj4YRQ3Az0WTZw1sFe+QDb0aXCerigEpw418pw1HBUKFtnQHWzwojaukAs2X/c9DQz4MQ4bsXTGlcpGxU/RCIw==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@vue/reactivity": "3.5.13",
+        "@vue/shared": "3.5.13"
+      }
+    },
+    "node_modules/@vue/runtime-dom": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.13.tgz",
+      "integrity": "sha512-dLaj94s93NYLqjLiyFzVs9X6dWhTdAlEAciC3Moq7gzAc13VJUdCnjjRurNM6uTLFATRHexHCTu/Xp3eW6yoog==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@vue/reactivity": "3.5.13",
+        "@vue/runtime-core": "3.5.13",
+        "@vue/shared": "3.5.13",
+        "csstype": "^3.1.3"
+      }
+    },
+    "node_modules/@vue/server-renderer": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.13.tgz",
+      "integrity": "sha512-wAi4IRJV/2SAW3htkTlB+dHeRmpTiVIK1OGLWV1yeStVSebSQQOwGwIq0D3ZIoBj2C2qpgz5+vX9iEBkTdk5YA==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@vue/compiler-ssr": "3.5.13",
+        "@vue/shared": "3.5.13"
+      },
+      "peerDependencies": {
+        "vue": "3.5.13"
+      }
+    },
+    "node_modules/@vue/shared": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.13.tgz",
+      "integrity": "sha512-/hnE/qP5ZoGpol0a5mDi45bOd7t3tjYJBjsgCsivow7D48cJeV5l05RD82lPqi7gRiphZM37rnhW1l6ZoCNNnQ==",
+      "dev": true,
+      "peer": true
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
+      "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.5.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
+      "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://paulmillr.com/funding/"
+        }
+      ],
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
+      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
+      "dev": true,
+      "peer": true
+    },
+    "node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "dev": true,
+      "peer": true,
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "dev": true,
+      "peer": true
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/immutable": {
+      "version": "4.3.5",
+      "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.3.5.tgz",
+      "integrity": "sha512-8eabxkth9gZatlwl5TBuJnCsoTADlL6ftEr7A4qgdaTsPyreilDSnUk57SO+jfKcNtxPa22U5KK6DSeAYhpBJw==",
+      "dev": true
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.17",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
+      "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "peer": true,
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "peer": true
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.3",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.3.tgz",
+      "integrity": "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "peer": true,
+      "dependencies": {
+        "nanoid": "^3.3.8",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/prettier": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.3.3.tgz",
+      "integrity": "sha512-i2tDNA0O5IrMO757lfrdQZCc2jPNDVntV0m/+4whiDfWaTKfMNgR7Qz0NAeGz/nRqF4m5/6CLzbP4/liHt12Ew==",
+      "dev": true,
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/sass": {
+      "version": "1.77.8",
+      "resolved": "https://registry.npmjs.org/sass/-/sass-1.77.8.tgz",
+      "integrity": "sha512-4UHg6prsrycW20fqLGPShtEvo/WyHRVRHwOP4DzkUrObWoWI05QBSfzU71TVB7PFaL104TwNaHpjlWXAZbQiNQ==",
+      "dev": true,
+      "dependencies": {
+        "chokidar": ">=3.0.0 <4.0.0",
+        "immutable": "^4.0.0",
+        "source-map-js": ">=0.6.2 <2.0.0"
+      },
+      "bin": {
+        "sass": "sass.js"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz",
+      "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
+      "dev": true,
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/vue": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.13.tgz",
+      "integrity": "sha512-wmeiSMxkZCSc+PM2w2VRsOYAZC8GdipNFRTsLSfodVqI9mbejKeXEGr8SckuLnrQPGe3oJN5c3K0vpoU9q/wCQ==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.13",
+        "@vue/compiler-sfc": "3.5.13",
+        "@vue/runtime-dom": "3.5.13",
+        "@vue/server-renderer": "3.5.13",
+        "@vue/shared": "3.5.13"
+      },
+      "peerDependencies": {
+        "typescript": "*"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/web-tree-sitter": {
+      "version": "0.25.6",
+      "resolved": "https://registry.npmjs.org/web-tree-sitter/-/web-tree-sitter-0.25.6.tgz",
+      "integrity": "sha512-WG+/YGbxw8r+rLlzzhV+OvgiOJCWdIpOucG3qBf3RCBFMkGDb1CanUi2BxCxjnkpzU3/hLWPT8VO5EKsMk9Fxg==",
+      "dev": true
+    },
+    "node_modules/zod": {
+      "version": "3.24.2",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.2.tgz",
+      "integrity": "sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ==",
+      "dev": true,
+      "peer": true,
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

custom_nodes/rgthree-comfy/package.json

@@ -0,0 +1,12 @@
+{
+  "devDependencies": {
+    "prettier": "^3.3.3",
+    "typescript": "^5.5.4",
+    "sass": "^1.77.8",
+    "@comfyorg/comfyui-frontend-types": "^1.32.4",
+    "web-tree-sitter": "0.25.6"
+  },
+  "scripts": {
+    "build": "./__build__.py || python .\\__build__.py"
+  }
+}

custom_nodes/rgthree-comfy/pnpm-lock.yaml

@@ -0,0 +1,507 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    devDependencies:
+      '@comfyorg/comfyui-frontend-types':
+        specifier: ^1.32.4
+        version: 1.32.4(vue@3.5.24(typescript@5.9.3))(zod@3.25.76)
+      prettier:
+        specifier: ^3.3.3
+        version: 3.6.2
+      sass:
+        specifier: ^1.77.8
+        version: 1.93.3
+      typescript:
+        specifier: ^5.5.4
+        version: 5.9.3
+      web-tree-sitter:
+        specifier: 0.25.6
+        version: 0.25.6
+
+packages:
+
+  '@babel/helper-string-parser@7.27.1':
+    resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-identifier@7.28.5':
+    resolution: {integrity: sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/parser@7.28.5':
+    resolution: {integrity: sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  '@babel/types@7.28.5':
+    resolution: {integrity: sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==}
+    engines: {node: '>=6.9.0'}
+
+  '@comfyorg/comfyui-frontend-types@1.32.4':
+    resolution: {integrity: sha512-9EBFwQPaSMLI151caWN5nA0qVmY5S9BR9lHP5NboPnTsmkFwnWdrAPadAnafwmZcK40ZWntKJZxO0Uuju0jw/w==}
+    peerDependencies:
+      vue: ^3.5.13
+      zod: ^3.23.8
+
+  '@jridgewell/sourcemap-codec@1.5.5':
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
+  '@parcel/watcher-android-arm64@2.5.1':
+    resolution: {integrity: sha512-KF8+j9nNbUN8vzOFDpRMsaKBHZ/mcjEjMToVMJOhTozkDonQFFrRcfdLWn6yWKCmJKmdVxSgHiYvTCef4/qcBA==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm64]
+    os: [android]
+
+  '@parcel/watcher-darwin-arm64@2.5.1':
+    resolution: {integrity: sha512-eAzPv5osDmZyBhou8PoF4i6RQXAfeKL9tjb3QzYuccXFMQU0ruIc/POh30ePnaOyD1UXdlKguHBmsTs53tVoPw==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@parcel/watcher-darwin-x64@2.5.1':
+    resolution: {integrity: sha512-1ZXDthrnNmwv10A0/3AJNZ9JGlzrF82i3gNQcWOzd7nJ8aj+ILyW1MTxVk35Db0u91oD5Nlk9MBiujMlwmeXZg==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@parcel/watcher-freebsd-x64@2.5.1':
+    resolution: {integrity: sha512-SI4eljM7Flp9yPuKi8W0ird8TI/JK6CSxju3NojVI6BjHsTyK7zxA9urjVjEKJ5MBYC+bLmMcbAWlZ+rFkLpJQ==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@parcel/watcher-linux-arm-glibc@2.5.1':
+    resolution: {integrity: sha512-RCdZlEyTs8geyBkkcnPWvtXLY44BCeZKmGYRtSgtwwnHR4dxfHRG3gR99XdMEdQ7KeiDdasJwwvNSF5jKtDwdA==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm]
+    os: [linux]
+
+  '@parcel/watcher-linux-arm-musl@2.5.1':
+    resolution: {integrity: sha512-6E+m/Mm1t1yhB8X412stiKFG3XykmgdIOqhjWj+VL8oHkKABfu/gjFj8DvLrYVHSBNC+/u5PeNrujiSQ1zwd1Q==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm]
+    os: [linux]
+
+  '@parcel/watcher-linux-arm64-glibc@2.5.1':
+    resolution: {integrity: sha512-LrGp+f02yU3BN9A+DGuY3v3bmnFUggAITBGriZHUREfNEzZh/GO06FF5u2kx8x+GBEUYfyTGamol4j3m9ANe8w==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@parcel/watcher-linux-arm64-musl@2.5.1':
+    resolution: {integrity: sha512-cFOjABi92pMYRXS7AcQv9/M1YuKRw8SZniCDw0ssQb/noPkRzA+HBDkwmyOJYp5wXcsTrhxO0zq1U11cK9jsFg==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@parcel/watcher-linux-x64-glibc@2.5.1':
+    resolution: {integrity: sha512-GcESn8NZySmfwlTsIur+49yDqSny2IhPeZfXunQi48DMugKeZ7uy1FX83pO0X22sHntJ4Ub+9k34XQCX+oHt2A==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [x64]
+    os: [linux]
+
+  '@parcel/watcher-linux-x64-musl@2.5.1':
+    resolution: {integrity: sha512-n0E2EQbatQ3bXhcH2D1XIAANAcTZkQICBPVaxMeaCVBtOpBZpWJuf7LwyWPSBDITb7In8mqQgJ7gH8CILCURXg==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [x64]
+    os: [linux]
+
+  '@parcel/watcher-win32-arm64@2.5.1':
+    resolution: {integrity: sha512-RFzklRvmc3PkjKjry3hLF9wD7ppR4AKcWNzH7kXR7GUe0Igb3Nz8fyPwtZCSquGrhU5HhUNDr/mKBqj7tqA2Vw==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@parcel/watcher-win32-ia32@2.5.1':
+    resolution: {integrity: sha512-c2KkcVN+NJmuA7CGlaGD1qJh1cLfDnQsHjE89E60vUEMlqduHGCdCLJCID5geFVM0dOtA3ZiIO8BoEQmzQVfpQ==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@parcel/watcher-win32-x64@2.5.1':
+    resolution: {integrity: sha512-9lHBdJITeNR++EvSQVUcaZoWupyHfXe1jZvGZ06O/5MflPcuPLtEphScIBL+AiCWBO46tDSHzWyD0uDmmZqsgA==}
+    engines: {node: '>= 10.0.0'}
+    cpu: [x64]
+    os: [win32]
+
+  '@parcel/watcher@2.5.1':
+    resolution: {integrity: sha512-dfUnCxiN9H4ap84DvD2ubjw+3vUNpstxa0TneY/Paat8a3R4uQZDLSvWjmznAY/DoahqTHl9V46HF/Zs3F29pg==}
+    engines: {node: '>= 10.0.0'}
+
+  '@vue/compiler-core@3.5.24':
+    resolution: {integrity: sha512-eDl5H57AOpNakGNAkFDH+y7kTqrQpJkZFXhWZQGyx/5Wh7B1uQYvcWkvZi11BDhscPgj8N7XV3oRwiPnx1Vrig==}
+
+  '@vue/compiler-dom@3.5.24':
+    resolution: {integrity: sha512-1QHGAvs53gXkWdd3ZMGYuvQFXHW4ksKWPG8HP8/2BscrbZ0brw183q2oNWjMrSWImYLHxHrx1ItBQr50I/q2zw==}
+
+  '@vue/compiler-sfc@3.5.24':
+    resolution: {integrity: sha512-8EG5YPRgmTB+YxYBM3VXy8zHD9SWHUJLIGPhDovo3Z8VOgvP+O7UP5vl0J4BBPWYD9vxtBabzW1EuEZ+Cqs14g==}
+
+  '@vue/compiler-ssr@3.5.24':
+    resolution: {integrity: sha512-trOvMWNBMQ/odMRHW7Ae1CdfYx+7MuiQu62Jtu36gMLXcaoqKvAyh+P73sYG9ll+6jLB6QPovqoKGGZROzkFFg==}
+
+  '@vue/reactivity@3.5.24':
+    resolution: {integrity: sha512-BM8kBhtlkkbnyl4q+HiF5R5BL0ycDPfihowulm02q3WYp2vxgPcJuZO866qa/0u3idbMntKEtVNuAUp5bw4teg==}
+
+  '@vue/runtime-core@3.5.24':
+    resolution: {integrity: sha512-RYP/byyKDgNIqfX/gNb2PB55dJmM97jc9wyF3jK7QUInYKypK2exmZMNwnjueWwGceEkP6NChd3D2ZVEp9undQ==}
+
+  '@vue/runtime-dom@3.5.24':
+    resolution: {integrity: sha512-Z8ANhr/i0XIluonHVjbUkjvn+CyrxbXRIxR7wn7+X7xlcb7dJsfITZbkVOeJZdP8VZwfrWRsWdShH6pngMxRjw==}
+
+  '@vue/server-renderer@3.5.24':
+    resolution: {integrity: sha512-Yh2j2Y4G/0/4z/xJ1Bad4mxaAk++C2v4kaa8oSYTMJBJ00/ndPuxCnWeot0/7/qafQFLh5pr6xeV6SdMcE/G1w==}
+    peerDependencies:
+      vue: 3.5.24
+
+  '@vue/shared@3.5.24':
+    resolution: {integrity: sha512-9cwHL2EsJBdi8NY22pngYYWzkTDhld6fAD6jlaeloNGciNSJL6bLpbxVgXl96X00Jtc6YWQv96YA/0sxex/k1A==}
+
+  braces@3.0.3:
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+    engines: {node: '>=8'}
+
+  chokidar@4.0.3:
+    resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==}
+    engines: {node: '>= 14.16.0'}
+
+  csstype@3.1.3:
+    resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==}
+
+  detect-libc@1.0.3:
+    resolution: {integrity: sha512-pGjwhsmsp4kL2RTz08wcOlGN83otlqHeD/Z5T8GXZB+/YcpQ/dgo+lbU8ZsGxV0HIvqqxo9l7mqYwyYMD9bKDg==}
+    engines: {node: '>=0.10'}
+    hasBin: true
+
+  entities@4.5.0:
+    resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==}
+    engines: {node: '>=0.12'}
+
+  estree-walker@2.0.2:
+    resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
+
+  fill-range@7.1.1:
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+    engines: {node: '>=8'}
+
+  immutable@5.1.4:
+    resolution: {integrity: sha512-p6u1bG3YSnINT5RQmx/yRZBpenIl30kVxkTLDyHLIMk0gict704Q9n+thfDI7lTRm9vXdDYutVzXhzcThxTnXA==}
+
+  is-extglob@2.1.1:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+
+  is-glob@4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+
+  is-number@7.0.0:
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
+
+  magic-string@0.30.21:
+    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+
+  micromatch@4.0.8:
+    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
+    engines: {node: '>=8.6'}
+
+  nanoid@3.3.11:
+    resolution: {integrity: sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  node-addon-api@7.1.1:
+    resolution: {integrity: sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  picomatch@2.3.1:
+    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+    engines: {node: '>=8.6'}
+
+  postcss@8.5.6:
+    resolution: {integrity: sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  prettier@3.6.2:
+    resolution: {integrity: sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==}
+    engines: {node: '>=14'}
+    hasBin: true
+
+  readdirp@4.1.2:
+    resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==}
+    engines: {node: '>= 14.18.0'}
+
+  sass@1.93.3:
+    resolution: {integrity: sha512-elOcIZRTM76dvxNAjqYrucTSI0teAF/L2Lv0s6f6b7FOwcwIuA357bIE871580AjHJuSvLIRUosgV+lIWx6Rgg==}
+    engines: {node: '>=14.0.0'}
+    hasBin: true
+
+  source-map-js@1.2.1:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  to-regex-range@5.0.1:
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
+
+  typescript@5.9.3:
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  vue@3.5.24:
+    resolution: {integrity: sha512-uTHDOpVQTMjcGgrqFPSb8iO2m1DUvo+WbGqoXQz8Y1CeBYQ0FXf2z1gLRaBtHjlRz7zZUBHxjVB5VTLzYkvftg==}
+    peerDependencies:
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+
+  web-tree-sitter@0.25.6:
+    resolution: {integrity: sha512-WG+/YGbxw8r+rLlzzhV+OvgiOJCWdIpOucG3qBf3RCBFMkGDb1CanUi2BxCxjnkpzU3/hLWPT8VO5EKsMk9Fxg==}
+
+  zod@3.25.76:
+    resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==}
+
+snapshots:
+
+  '@babel/helper-string-parser@7.27.1': {}
+
+  '@babel/helper-validator-identifier@7.28.5': {}
+
+  '@babel/parser@7.28.5':
+    dependencies:
+      '@babel/types': 7.28.5
+
+  '@babel/types@7.28.5':
+    dependencies:
+      '@babel/helper-string-parser': 7.27.1
+      '@babel/helper-validator-identifier': 7.28.5
+
+  '@comfyorg/comfyui-frontend-types@1.32.4(vue@3.5.24(typescript@5.9.3))(zod@3.25.76)':
+    dependencies:
+      vue: 3.5.24(typescript@5.9.3)
+      zod: 3.25.76
+
+  '@jridgewell/sourcemap-codec@1.5.5': {}
+
+  '@parcel/watcher-android-arm64@2.5.1':
+    optional: true
+
+  '@parcel/watcher-darwin-arm64@2.5.1':
+    optional: true
+
+  '@parcel/watcher-darwin-x64@2.5.1':
+    optional: true
+
+  '@parcel/watcher-freebsd-x64@2.5.1':
+    optional: true
+
+  '@parcel/watcher-linux-arm-glibc@2.5.1':
+    optional: true
+
+  '@parcel/watcher-linux-arm-musl@2.5.1':
+    optional: true
+
+  '@parcel/watcher-linux-arm64-glibc@2.5.1':
+    optional: true
+
+  '@parcel/watcher-linux-arm64-musl@2.5.1':
+    optional: true
+
+  '@parcel/watcher-linux-x64-glibc@2.5.1':
+    optional: true
+
+  '@parcel/watcher-linux-x64-musl@2.5.1':
+    optional: true
+
+  '@parcel/watcher-win32-arm64@2.5.1':
+    optional: true
+
+  '@parcel/watcher-win32-ia32@2.5.1':
+    optional: true
+
+  '@parcel/watcher-win32-x64@2.5.1':
+    optional: true
+
+  '@parcel/watcher@2.5.1':
+    dependencies:
+      detect-libc: 1.0.3
+      is-glob: 4.0.3
+      micromatch: 4.0.8
+      node-addon-api: 7.1.1
+    optionalDependencies:
+      '@parcel/watcher-android-arm64': 2.5.1
+      '@parcel/watcher-darwin-arm64': 2.5.1
+      '@parcel/watcher-darwin-x64': 2.5.1
+      '@parcel/watcher-freebsd-x64': 2.5.1
+      '@parcel/watcher-linux-arm-glibc': 2.5.1
+      '@parcel/watcher-linux-arm-musl': 2.5.1
+      '@parcel/watcher-linux-arm64-glibc': 2.5.1
+      '@parcel/watcher-linux-arm64-musl': 2.5.1
+      '@parcel/watcher-linux-x64-glibc': 2.5.1
+      '@parcel/watcher-linux-x64-musl': 2.5.1
+      '@parcel/watcher-win32-arm64': 2.5.1
+      '@parcel/watcher-win32-ia32': 2.5.1
+      '@parcel/watcher-win32-x64': 2.5.1
+    optional: true
+
+  '@vue/compiler-core@3.5.24':
+    dependencies:
+      '@babel/parser': 7.28.5
+      '@vue/shared': 3.5.24
+      entities: 4.5.0
+      estree-walker: 2.0.2
+      source-map-js: 1.2.1
+
+  '@vue/compiler-dom@3.5.24':
+    dependencies:
+      '@vue/compiler-core': 3.5.24
+      '@vue/shared': 3.5.24
+
+  '@vue/compiler-sfc@3.5.24':
+    dependencies:
+      '@babel/parser': 7.28.5
+      '@vue/compiler-core': 3.5.24
+      '@vue/compiler-dom': 3.5.24
+      '@vue/compiler-ssr': 3.5.24
+      '@vue/shared': 3.5.24
+      estree-walker: 2.0.2
+      magic-string: 0.30.21
+      postcss: 8.5.6
+      source-map-js: 1.2.1
+
+  '@vue/compiler-ssr@3.5.24':
+    dependencies:
+      '@vue/compiler-dom': 3.5.24
+      '@vue/shared': 3.5.24
+
+  '@vue/reactivity@3.5.24':
+    dependencies:
+      '@vue/shared': 3.5.24
+
+  '@vue/runtime-core@3.5.24':
+    dependencies:
+      '@vue/reactivity': 3.5.24
+      '@vue/shared': 3.5.24
+
+  '@vue/runtime-dom@3.5.24':
+    dependencies:
+      '@vue/reactivity': 3.5.24
+      '@vue/runtime-core': 3.5.24
+      '@vue/shared': 3.5.24
+      csstype: 3.1.3
+
+  '@vue/server-renderer@3.5.24(vue@3.5.24(typescript@5.9.3))':
+    dependencies:
+      '@vue/compiler-ssr': 3.5.24
+      '@vue/shared': 3.5.24
+      vue: 3.5.24(typescript@5.9.3)
+
+  '@vue/shared@3.5.24': {}
+
+  braces@3.0.3:
+    dependencies:
+      fill-range: 7.1.1
+    optional: true
+
+  chokidar@4.0.3:
+    dependencies:
+      readdirp: 4.1.2
+
+  csstype@3.1.3: {}
+
+  detect-libc@1.0.3:
+    optional: true
+
+  entities@4.5.0: {}
+
+  estree-walker@2.0.2: {}
+
+  fill-range@7.1.1:
+    dependencies:
+      to-regex-range: 5.0.1
+    optional: true
+
+  immutable@5.1.4: {}
+
+  is-extglob@2.1.1:
+    optional: true
+
+  is-glob@4.0.3:
+    dependencies:
+      is-extglob: 2.1.1
+    optional: true
+
+  is-number@7.0.0:
+    optional: true
+
+  magic-string@0.30.21:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  micromatch@4.0.8:
+    dependencies:
+      braces: 3.0.3
+      picomatch: 2.3.1
+    optional: true
+
+  nanoid@3.3.11: {}
+
+  node-addon-api@7.1.1:
+    optional: true
+
+  picocolors@1.1.1: {}
+
+  picomatch@2.3.1:
+    optional: true
+
+  postcss@8.5.6:
+    dependencies:
+      nanoid: 3.3.11
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  prettier@3.6.2: {}
+
+  readdirp@4.1.2: {}
+
+  sass@1.93.3:
+    dependencies:
+      chokidar: 4.0.3
+      immutable: 5.1.4
+      source-map-js: 1.2.1
+    optionalDependencies:
+      '@parcel/watcher': 2.5.1
+
+  source-map-js@1.2.1: {}
+
+  to-regex-range@5.0.1:
+    dependencies:
+      is-number: 7.0.0
+    optional: true
+
+  typescript@5.9.3: {}
+
+  vue@3.5.24(typescript@5.9.3):
+    dependencies:
+      '@vue/compiler-dom': 3.5.24
+      '@vue/compiler-sfc': 3.5.24
+      '@vue/runtime-dom': 3.5.24
+      '@vue/server-renderer': 3.5.24(vue@3.5.24(typescript@5.9.3))
+      '@vue/shared': 3.5.24
+    optionalDependencies:
+      typescript: 5.9.3
+
+  web-tree-sitter@0.25.6: {}
+
+  zod@3.25.76: {}

custom_nodes/rgthree-comfy/prestartup_script.py

@@ -0,0 +1,5 @@
+import folder_paths
+
+# Removed Saved Prompts feature; No sure it worked any longer. UI should fail gracefully.
+# TODO: See if anyone actually used this.
+# folder_paths.folder_names_and_paths['saved_prompts'] = ([], set(['.txt']))

custom_nodes/rgthree-comfy/py/any_switch.py

@@ -0,0 +1,38 @@
+from .context_utils import is_context_empty
+from .constants import get_category, get_name
+from .utils import FlexibleOptionalInputType, any_type
+
+
+def is_none(value):
+  """Checks if a value is none. Pulled out in case we want to expand what 'None' means."""
+  if value is not None:
+    if isinstance(value, dict) and 'model' in value and 'clip' in value:
+      return is_context_empty(value)
+  return value is None
+
+
+class RgthreeAnySwitch:
+  """The dynamic Any Switch. """
+
+  NAME = get_name("Any Switch")
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {},
+      "optional": FlexibleOptionalInputType(any_type),
+    }
+
+  RETURN_TYPES = (any_type,)
+  RETURN_NAMES = ('*',)
+  FUNCTION = "switch"
+
+  def switch(self, **kwargs):
+    """Chooses the first non-empty item to output."""
+    any_value = None
+    for key, value in kwargs.items():
+      if key.startswith('any_') and not is_none(value):
+        any_value = value
+        break
+    return (any_value,)

custom_nodes/rgthree-comfy/py/config.py

@@ -0,0 +1,111 @@
+import os
+import json
+
+from .utils import get_dict_value, set_dict_value, dict_has_key, load_json_file
+from .pyproject import VERSION
+
+
+def get_config_value(key, default=None):
+  return get_dict_value(RGTHREE_CONFIG, key, default)
+
+
+def extend_config(default_config, user_config):
+  """ Returns a new config dict combining user_config into defined keys for default_config."""
+  cfg = {}
+  for key, value in default_config.items():
+    if key not in user_config:
+      cfg[key] = value
+    elif isinstance(value, dict):
+      cfg[key] = extend_config(value, user_config[key])
+    else:
+      cfg[key] = user_config[key] if key in user_config else value
+  return cfg
+
+
+def set_user_config(data: dict):
+  """ Sets the user configuration."""
+  count = 0
+  for key, value in data.items():
+    if dict_has_key(DEFAULT_CONFIG, key):
+      set_dict_value(USER_CONFIG, key, value)
+      set_dict_value(RGTHREE_CONFIG, key, value)
+      count += 1
+  if count > 0:
+    write_user_config()
+
+
+def get_rgthree_default_config():
+  """ Gets the default configuration."""
+  return load_json_file(DEFAULT_CONFIG_FILE, default={})
+
+
+def get_rgthree_user_config():
+  """ Gets the user configuration."""
+  return load_json_file(USER_CONFIG_FILE, default={})
+
+
+def write_user_config():
+  """ Writes the user configuration."""
+  with open(USER_CONFIG_FILE, 'w+', encoding='UTF-8') as file:
+    json.dump(USER_CONFIG, file, sort_keys=True, indent=2, separators=(",", ": "))
+
+
+THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+DEFAULT_CONFIG_FILE = os.path.join(THIS_DIR, '..', 'rgthree_config.json.default')
+USER_CONFIG_FILE = os.path.join(THIS_DIR, '..', 'rgthree_config.json')
+
+DEFAULT_CONFIG = {}
+USER_CONFIG = {}
+RGTHREE_CONFIG = {}
+
+
+def refresh_config():
+  """Refreshes the config."""
+  global DEFAULT_CONFIG, USER_CONFIG, RGTHREE_CONFIG
+  DEFAULT_CONFIG = get_rgthree_default_config()
+  USER_CONFIG = get_rgthree_user_config()
+
+  # Migrate old config options into "features"
+  needs_to_write_user_config = False
+  if 'patch_recursive_execution' in USER_CONFIG:
+    del USER_CONFIG['patch_recursive_execution']
+    needs_to_write_user_config = True
+
+  if 'features' in USER_CONFIG and 'patch_recursive_execution' in USER_CONFIG['features']:
+    del USER_CONFIG['features']['patch_recursive_execution']
+    needs_to_write_user_config = True
+
+  if 'show_alerts_for_corrupt_workflows' in USER_CONFIG:
+    if 'features' not in USER_CONFIG:
+      USER_CONFIG['features'] = {}
+    USER_CONFIG['features']['show_alerts_for_corrupt_workflows'] = USER_CONFIG[
+      'show_alerts_for_corrupt_workflows']
+    del USER_CONFIG['show_alerts_for_corrupt_workflows']
+    needs_to_write_user_config = True
+
+  if 'monitor_for_corrupt_links' in USER_CONFIG:
+    if 'features' not in USER_CONFIG:
+      USER_CONFIG['features'] = {}
+    USER_CONFIG['features']['monitor_for_corrupt_links'] = USER_CONFIG['monitor_for_corrupt_links']
+    del USER_CONFIG['monitor_for_corrupt_links']
+    needs_to_write_user_config = True
+
+  if needs_to_write_user_config is True:
+    print('writing new user config.')
+    write_user_config()
+
+  RGTHREE_CONFIG = {"version": VERSION} | extend_config(DEFAULT_CONFIG, USER_CONFIG)
+
+  if "unreleased" in USER_CONFIG and "unreleased" not in RGTHREE_CONFIG:
+    RGTHREE_CONFIG["unreleased"] = USER_CONFIG["unreleased"]
+
+  if "debug" in USER_CONFIG and "debug" not in RGTHREE_CONFIG:
+    RGTHREE_CONFIG["debug"] = USER_CONFIG["debug"]
+
+
+def get_config():
+  """Returns the congfig."""
+  return RGTHREE_CONFIG
+
+
+refresh_config()

custom_nodes/rgthree-comfy/py/constants.py

@@ -0,0 +1,11 @@
+
+NAMESPACE='rgthree'
+
+def get_name(name):
+    return '{} ({})'.format(name, NAMESPACE)
+
+def get_category(sub_dirs = None):
+    if sub_dirs is None:
+        return NAMESPACE
+    else:
+        return "{}/utils".format(NAMESPACE)

custom_nodes/rgthree-comfy/py/context.py

@@ -0,0 +1,33 @@
+"""The Context node."""
+from .context_utils import (ORIG_CTX_OPTIONAL_INPUTS, ORIG_CTX_RETURN_NAMES, ORIG_CTX_RETURN_TYPES,
+                            get_orig_context_return_tuple, new_context)
+from .constants import get_category, get_name
+
+
+class RgthreeContext:
+  """The initial Context node.
+
+  For now, this nodes' outputs will remain as-is, as they are perfect for most 1.5 application, but
+  is also backwards compatible with other Context nodes.
+  """
+
+  NAME = get_name("Context")
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {},
+      "optional": ORIG_CTX_OPTIONAL_INPUTS,
+      "hidden": {
+        "version": "FLOAT"
+      },
+    }
+
+  RETURN_TYPES = ORIG_CTX_RETURN_TYPES
+  RETURN_NAMES = ORIG_CTX_RETURN_NAMES
+  FUNCTION = "convert"
+
+  def convert(self, base_ctx=None, **kwargs):  # pylint: disable = missing-function-docstring
+    ctx = new_context(base_ctx, **kwargs)
+    return get_orig_context_return_tuple(ctx)

custom_nodes/rgthree-comfy/py/context_big.py

@@ -0,0 +1,31 @@
+"""The Conmtext big node."""
+from .constants import get_category, get_name
+from .context_utils import (ALL_CTX_OPTIONAL_INPUTS, ALL_CTX_RETURN_NAMES, ALL_CTX_RETURN_TYPES,
+                            new_context, get_context_return_tuple)
+
+
+class RgthreeBigContext:
+  """The Context Big node.
+
+  This context node will expose all context fields as inputs and outputs. It is backwards compatible
+  with other context nodes and can be intertwined with them.
+  """
+
+  NAME = get_name("Context Big")
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name,missing-function-docstring
+    return {
+      "required": {},
+      "optional": ALL_CTX_OPTIONAL_INPUTS,
+      "hidden": {},
+    }
+
+  RETURN_TYPES = ALL_CTX_RETURN_TYPES
+  RETURN_NAMES = ALL_CTX_RETURN_NAMES
+  FUNCTION = "convert"
+
+  def convert(self, base_ctx=None, **kwargs):  # pylint: disable = missing-function-docstring
+    ctx = new_context(base_ctx, **kwargs)
+    return get_context_return_tuple(ctx)

custom_nodes/rgthree-comfy/py/context_merge.py

@@ -0,0 +1,37 @@
+"""The Context Switch (Big)."""
+from .constants import get_category, get_name
+from .context_utils import (ORIG_CTX_RETURN_TYPES, ORIG_CTX_RETURN_NAMES, merge_new_context,
+                            get_orig_context_return_tuple, is_context_empty)
+from .utils import FlexibleOptionalInputType
+
+
+class RgthreeContextMerge:
+  """The Context Merge node."""
+
+  NAME = get_name("Context Merge")
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {},
+      "optional": FlexibleOptionalInputType("RGTHREE_CONTEXT"),
+    }
+
+  RETURN_TYPES = ORIG_CTX_RETURN_TYPES
+  RETURN_NAMES = ORIG_CTX_RETURN_NAMES
+  FUNCTION = "merge"
+
+  def get_return_tuple(self, ctx):
+    """Returns the context data. Separated so it can be overridden."""
+    return get_orig_context_return_tuple(ctx)
+
+  def merge(self, **kwargs):
+    """Merges any non-null passed contexts; later ones overriding earlier."""
+    ctxs = [
+      value for key, value in kwargs.items()
+      if key.startswith('ctx_') and not is_context_empty(value)
+    ]
+    ctx = merge_new_context(*ctxs)
+
+    return self.get_return_tuple(ctx)

custom_nodes/rgthree-comfy/py/context_merge_big.py

@@ -0,0 +1,16 @@
+"""The Context Switch (Big)."""
+from .constants import get_category, get_name
+from .context_utils import (ALL_CTX_RETURN_TYPES, ALL_CTX_RETURN_NAMES, get_context_return_tuple)
+from .context_merge import RgthreeContextMerge
+
+
+class RgthreeContextMergeBig(RgthreeContextMerge):
+  """The Context Merge Big node."""
+
+  NAME = get_name("Context Merge Big")
+  RETURN_TYPES = ALL_CTX_RETURN_TYPES
+  RETURN_NAMES = ALL_CTX_RETURN_NAMES
+
+  def get_return_tuple(self, ctx):
+    """Returns the context data. Separated so it can be overridden."""
+    return get_context_return_tuple(ctx)

custom_nodes/rgthree-comfy/py/context_switch.py

@@ -0,0 +1,36 @@
+"""The original Context Switch."""
+from .constants import get_category, get_name
+from .context_utils import (ORIG_CTX_RETURN_TYPES, ORIG_CTX_RETURN_NAMES, is_context_empty,
+                            get_orig_context_return_tuple)
+from .utils import FlexibleOptionalInputType
+
+
+class RgthreeContextSwitch:
+  """The (original) Context Switch node."""
+
+  NAME = get_name("Context Switch")
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {},
+      "optional": FlexibleOptionalInputType("RGTHREE_CONTEXT"),
+    }
+
+  RETURN_TYPES = ORIG_CTX_RETURN_TYPES
+  RETURN_NAMES = ORIG_CTX_RETURN_NAMES
+  FUNCTION = "switch"
+
+  def get_return_tuple(self, ctx):
+    """Returns the context data. Separated so it can be overridden."""
+    return get_orig_context_return_tuple(ctx)
+
+  def switch(self, **kwargs):
+    """Chooses the first non-empty Context to output."""
+    ctx = None
+    for key, value in kwargs.items():
+      if key.startswith('ctx_') and not is_context_empty(value):
+        ctx = value
+        break
+    return self.get_return_tuple(ctx)

custom_nodes/rgthree-comfy/py/context_switch_big.py

@@ -0,0 +1,16 @@
+"""The Context Switch (Big)."""
+from .constants import get_category, get_name
+from .context_utils import (ALL_CTX_RETURN_TYPES, ALL_CTX_RETURN_NAMES, get_context_return_tuple)
+from .context_switch import RgthreeContextSwitch
+
+
+class RgthreeContextSwitchBig(RgthreeContextSwitch):
+  """The Context Switch Big node."""
+
+  NAME = get_name("Context Switch Big")
+  RETURN_TYPES = ALL_CTX_RETURN_TYPES
+  RETURN_NAMES = ALL_CTX_RETURN_NAMES
+
+  def get_return_tuple(self, ctx):
+    """Overrides the RgthreeContextSwitch `get_return_tuple` to return big context data."""
+    return get_context_return_tuple(ctx)

custom_nodes/rgthree-comfy/py/context_utils.py

@@ -0,0 +1,118 @@
+"""A set of constants and utilities for handling contexts.
+
+Sets up the inputs and outputs for the Context going forward, with additional functions for
+creating and exporting context objects.
+"""
+import comfy.samplers
+import folder_paths
+
+_all_context_input_output_data = {
+  "base_ctx": ("base_ctx", "RGTHREE_CONTEXT", "CONTEXT"),
+  "model": ("model", "MODEL", "MODEL"),
+  "clip": ("clip", "CLIP", "CLIP"),
+  "vae": ("vae", "VAE", "VAE"),
+  "positive": ("positive", "CONDITIONING", "POSITIVE"),
+  "negative": ("negative", "CONDITIONING", "NEGATIVE"),
+  "latent": ("latent", "LATENT", "LATENT"),
+  "images": ("images", "IMAGE", "IMAGE"),
+  "seed": ("seed", "INT", "SEED"),
+  "steps": ("steps", "INT", "STEPS"),
+  "step_refiner": ("step_refiner", "INT", "STEP_REFINER"),
+  "cfg": ("cfg", "FLOAT", "CFG"),
+  "ckpt_name": ("ckpt_name", folder_paths.get_filename_list("checkpoints"), "CKPT_NAME"),
+  "sampler": ("sampler", comfy.samplers.KSampler.SAMPLERS, "SAMPLER"),
+  "scheduler": ("scheduler", comfy.samplers.KSampler.SCHEDULERS, "SCHEDULER"),
+  "clip_width": ("clip_width", "INT", "CLIP_WIDTH"),
+  "clip_height": ("clip_height", "INT", "CLIP_HEIGHT"),
+  "text_pos_g": ("text_pos_g", "STRING", "TEXT_POS_G"),
+  "text_pos_l": ("text_pos_l", "STRING", "TEXT_POS_L"),
+  "text_neg_g": ("text_neg_g", "STRING", "TEXT_NEG_G"),
+  "text_neg_l": ("text_neg_l", "STRING", "TEXT_NEG_L"),
+  "mask": ("mask", "MASK", "MASK"),
+  "control_net": ("control_net", "CONTROL_NET", "CONTROL_NET"),
+}
+
+force_input_types = ["INT", "STRING", "FLOAT"]
+force_input_names = ["sampler", "scheduler", "ckpt_name"]
+
+
+def _create_context_data(input_list=None):
+  """Returns a tuple of context inputs, return types, and return names to use in a node"s def"""
+  if input_list is None:
+    input_list = _all_context_input_output_data.keys()
+  list_ctx_return_types = []
+  list_ctx_return_names = []
+  ctx_optional_inputs = {}
+  for inp in input_list:
+    data = _all_context_input_output_data[inp]
+    list_ctx_return_types.append(data[1])
+    list_ctx_return_names.append(data[2])
+    ctx_optional_inputs[data[0]] = tuple([data[1]] + ([{
+      "forceInput": True
+    }] if data[1] in force_input_types or data[0] in force_input_names else []))
+
+  ctx_return_types = tuple(list_ctx_return_types)
+  ctx_return_names = tuple(list_ctx_return_names)
+  return (ctx_optional_inputs, ctx_return_types, ctx_return_names)
+
+
+ALL_CTX_OPTIONAL_INPUTS, ALL_CTX_RETURN_TYPES, ALL_CTX_RETURN_NAMES = _create_context_data()
+
+_original_ctx_inputs_list = [
+  "base_ctx", "model", "clip", "vae", "positive", "negative", "latent", "images", "seed"
+]
+ORIG_CTX_OPTIONAL_INPUTS, ORIG_CTX_RETURN_TYPES, ORIG_CTX_RETURN_NAMES = _create_context_data(
+  _original_ctx_inputs_list)
+
+
+def new_context(base_ctx, **kwargs):
+  """Creates a new context from the provided data, with an optional base ctx to start."""
+  context = base_ctx if base_ctx is not None else None
+  new_ctx = {}
+  for key in _all_context_input_output_data:
+    if key == "base_ctx":
+      continue
+    v = kwargs[key] if key in kwargs else None
+    new_ctx[key] = v if v is not None else context[
+      key] if context is not None and key in context else None
+  return new_ctx
+
+
+def merge_new_context(*args):
+  """Creates a new context by merging provided contexts with the latter overriding same fields."""
+  new_ctx = {}
+  for key in _all_context_input_output_data:
+    if key == "base_ctx":
+      continue
+    v = None
+    # Move backwards through the passed contexts until we find a value and use it.
+    for ctx in reversed(args):
+      v = ctx[key] if not is_context_empty(ctx) and key in ctx else None
+      if v is not None:
+        break
+    new_ctx[key] = v
+  return new_ctx
+
+
+def get_context_return_tuple(ctx, inputs_list=None):
+  """Returns a tuple for returning in the order of the inputs list."""
+  if inputs_list is None:
+    inputs_list = _all_context_input_output_data.keys()
+  tup_list = [
+    ctx,
+  ]
+  for key in inputs_list:
+    if key == "base_ctx":
+      continue
+    tup_list.append(ctx[key] if ctx is not None and key in ctx else None)
+  return tuple(tup_list)
+
+
+def get_orig_context_return_tuple(ctx):
+  """Returns a tuple for returning from a node with only the original context keys."""
+  return get_context_return_tuple(ctx, _original_ctx_inputs_list)
+
+
+def is_context_empty(ctx):
+  """Checks if the provided ctx is None or contains just None values."""
+  return not ctx or all(v is None for v in ctx.values())

custom_nodes/rgthree-comfy/py/display_any.py

@@ -0,0 +1,77 @@
+import json
+from .constants import get_category, get_name
+from .utils import any_type, get_dict_value
+
+
+class RgthreeDisplayAny:
+  """Display any data node."""
+
+  NAME = get_name('Display Any')
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {
+        "source": (any_type, {}),
+      },
+      "hidden": {
+        "unique_id": "UNIQUE_ID",
+        "extra_pnginfo": "EXTRA_PNGINFO",
+      },
+    }
+
+  RETURN_TYPES = ()
+  FUNCTION = "main"
+  OUTPUT_NODE = True
+
+  def main(self, source=None, unique_id=None, extra_pnginfo=None):
+    value = 'None'
+    if isinstance(source, str):
+      value = source
+    elif isinstance(source, (int, float, bool)):
+      value = str(source)
+    elif source is not None:
+      try:
+        value = json.dumps(source)
+      except Exception:
+        try:
+          value = str(source)
+        except Exception:
+          value = 'source exists, but could not be serialized.'
+
+    # Save the output to the pnginfo so it's pre-filled when loading the data.
+    if extra_pnginfo and unique_id:
+      for node in get_dict_value(extra_pnginfo, 'workflow.nodes', []):
+        if str(node['id']) == str(unique_id):
+          node['widgets_values'] = [value]
+          break
+
+    return {"ui": {"text": (value,)}}
+
+
+class RgthreeDisplayInt:
+  """Old DisplayInt node.
+
+  Can be ported over to DisplayAny if https://github.com/comfyanonymous/ComfyUI/issues/1527 fixed.
+  """
+
+  NAME = get_name('Display Int')
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(s):
+    return {
+      "required": {
+        "input": ("INT", {
+          "forceInput": True
+        }),
+      },
+    }
+
+  RETURN_TYPES = ()
+  FUNCTION = "main"
+  OUTPUT_NODE = True
+
+  def main(self, input=None):
+    return {"ui": {"text": (input,)}}

custom_nodes/rgthree-comfy/py/dynamic_context.py

@@ -0,0 +1,56 @@
+"""The Dynamic Context node."""
+from mimetypes import add_type
+from .constants import get_category, get_name
+from .utils import ByPassTypeTuple, FlexibleOptionalInputType
+
+
+class RgthreeDynamicContext:
+  """The Dynamic Context node.
+
+  Similar to the static Context and Context Big nodes, this allows users to add any number and
+  variety of inputs to a Dynamic Context node, and return the outputs by key name.
+  """
+
+  NAME = get_name("Dynamic Context")
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name,missing-function-docstring
+    return {
+      "required": {},
+      "optional": FlexibleOptionalInputType(add_type),
+      "hidden": {},
+    }
+
+  RETURN_TYPES = ByPassTypeTuple(("RGTHREE_DYNAMIC_CONTEXT",))
+  RETURN_NAMES = ByPassTypeTuple(("CONTEXT",))
+  FUNCTION = "main"
+
+  def main(self, **kwargs):
+    """Creates a new context from the provided data, with an optional base ctx to start.
+
+    This node takes a list of named inputs that are the named keys (with an optional "+ " prefix)
+    which are to be stored within the ctx dict as well as a list of keys contained in `output_keys`
+    to determine the list of output data.
+    """
+
+    base_ctx = kwargs.get('base_ctx', None)
+    output_keys = kwargs.get('output_keys', None)
+
+    new_ctx = base_ctx.copy() if base_ctx is not None else {}
+
+    for key_raw, value in kwargs.items():
+      if key_raw in ['base_ctx', 'output_keys']:
+        continue
+      key = key_raw.upper()
+      if key.startswith('+ '):
+        key = key[2:]
+      new_ctx[key] = value
+
+    print(new_ctx)
+
+    res = [new_ctx]
+    output_keys = output_keys.split(',') if output_keys is not None else []
+    for key in output_keys:
+      res.append(new_ctx[key] if key in new_ctx else None)
+    return tuple(res)

custom_nodes/rgthree-comfy/py/dynamic_context_switch.py

@@ -0,0 +1,39 @@
+"""The original Context Switch."""
+from .constants import get_category, get_name
+from .context_utils import is_context_empty
+from .utils import ByPassTypeTuple, FlexibleOptionalInputType
+
+
+class RgthreeDynamicContextSwitch:
+  """The initial Context Switch node."""
+
+  NAME = get_name("Dynamic Context Switch")
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {},
+      "optional": FlexibleOptionalInputType("RGTHREE_DYNAMIC_CONTEXT"),
+    }
+
+  RETURN_TYPES = ByPassTypeTuple(("RGTHREE_DYNAMIC_CONTEXT",))
+  RETURN_NAMES = ByPassTypeTuple(("CONTEXT",))
+  FUNCTION = "switch"
+
+  def switch(self, **kwargs):
+    """Chooses the first non-empty Context to output."""
+
+    output_keys = kwargs.get('output_keys', None)
+
+    ctx = None
+    for key, value in kwargs.items():
+      if key.startswith('ctx_') and not is_context_empty(value):
+        ctx = value
+        break
+
+    res = [ctx]
+    output_keys = output_keys.split(',') if output_keys is not None else []
+    for key in output_keys:
+      res.append(ctx[key] if ctx is not None and key in ctx else None)
+    return tuple(res)

custom_nodes/rgthree-comfy/py/image_comparer.py

@@ -0,0 +1,42 @@
+from nodes import PreviewImage
+
+from .constants import get_category, get_name
+
+
+class RgthreeImageComparer(PreviewImage):
+  """A node that compares two images in the UI."""
+
+  NAME = get_name('Image Comparer')
+  CATEGORY = get_category()
+  FUNCTION = "compare_images"
+  DESCRIPTION = "Compares two images with a hover slider, or click from properties."
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {},
+      "optional": {
+        "image_a": ("IMAGE",),
+        "image_b": ("IMAGE",),
+      },
+      "hidden": {
+        "prompt": "PROMPT",
+        "extra_pnginfo": "EXTRA_PNGINFO"
+      },
+    }
+
+  def compare_images(self,
+                     image_a=None,
+                     image_b=None,
+                     filename_prefix="rgthree.compare.",
+                     prompt=None,
+                     extra_pnginfo=None):
+
+    result = { "ui": { "a_images":[], "b_images": [] } }
+    if image_a is not None and len(image_a) > 0:
+      result['ui']['a_images'] = self.save_images(image_a, filename_prefix, prompt, extra_pnginfo)['ui']['images']
+
+    if image_b is not None and len(image_b) > 0:
+      result['ui']['b_images'] = self.save_images(image_b, filename_prefix, prompt, extra_pnginfo)['ui']['images']
+
+    return result

custom_nodes/rgthree-comfy/py/image_inset_crop.py

@@ -0,0 +1,93 @@
+"""Image Inset Crop, with percentages."""
+from .log import log_node_info
+from .constants import get_category, get_name
+from nodes import MAX_RESOLUTION
+
+
+def get_new_bounds(width, height, left, right, top, bottom):
+  """Returns the new bounds for an image with inset crop data."""
+  left = 0 + left
+  right = width - right
+  top = 0 + top
+  bottom = height - bottom
+  return (left, right, top, bottom)
+
+
+class RgthreeImageInsetCrop:
+  """Image Inset Crop, with percentages."""
+
+  NAME = get_name('Image Inset Crop')
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {
+        "image": ("IMAGE",),
+        "measurement": (['Pixels', 'Percentage'],),
+        "left": ("INT", {
+          "default": 0,
+          "min": 0,
+          "max": MAX_RESOLUTION,
+          "step": 8
+        }),
+        "right": ("INT", {
+          "default": 0,
+          "min": 0,
+          "max": MAX_RESOLUTION,
+          "step": 8
+        }),
+        "top": ("INT", {
+          "default": 0,
+          "min": 0,
+          "max": MAX_RESOLUTION,
+          "step": 8
+        }),
+        "bottom": ("INT", {
+          "default": 0,
+          "min": 0,
+          "max": MAX_RESOLUTION,
+          "step": 8
+        }),
+      },
+    }
+
+  RETURN_TYPES = ("IMAGE",)
+  FUNCTION = "crop"
+
+  # pylint: disable = too-many-arguments
+  def crop(self, measurement, left, right, top, bottom, image=None):
+    """Does the crop."""
+
+    _, height, width, _ = image.shape
+
+    if measurement == 'Percentage':
+      left = int(width - (width * (100 - left) / 100))
+      right = int(width - (width * (100 - right) / 100))
+      top = int(height - (height * (100 - top) / 100))
+      bottom = int(height - (height * (100 - bottom) / 100))
+
+    # Snap to 8 pixels
+    left = left // 8 * 8
+    right = right // 8 * 8
+    top = top // 8 * 8
+    bottom = bottom // 8 * 8
+
+    if left == 0 and right == 0 and bottom == 0 and top == 0:
+      return (image,)
+
+    inset_left, inset_right, inset_top, inset_bottom = get_new_bounds(width, height, left, right,
+                                                                      top, bottom)
+    if inset_top > inset_bottom:
+      raise ValueError(
+        f"Invalid cropping dimensions top ({inset_top}) exceeds bottom ({inset_bottom})")
+    if inset_left > inset_right:
+      raise ValueError(
+        f"Invalid cropping dimensions left ({inset_left}) exceeds right ({inset_right})")
+
+    log_node_info(
+      self.NAME, f'Cropping image {width}x{height} width inset by {inset_left},{inset_right}, ' +
+      f'and height inset by {inset_top}, {inset_bottom}')
+    image = image[:, inset_top:inset_bottom, inset_left:inset_right, :]
+
+    return (image,)

custom_nodes/rgthree-comfy/py/image_or_latent_size.py

@@ -0,0 +1,31 @@
+from .utils import FlexibleOptionalInputType, any_type
+from .constants import get_category, get_name
+
+
+class RgthreeImageOrLatentSize:
+  """The ImageOrLatentSize Node."""
+
+  NAME = get_name('Image or Latent Size')
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {},
+      "optional": FlexibleOptionalInputType(any_type),
+    }
+
+  RETURN_TYPES = ("INT", "INT")
+  RETURN_NAMES = ('WIDTH', 'HEIGHT')
+  FUNCTION = "main"
+
+  def main(self, **kwargs):
+    """Does the node's work."""
+    image_or_latent_or_mask = kwargs.get('input', None)
+
+    if isinstance(image_or_latent_or_mask, dict) and 'samples' in image_or_latent_or_mask:
+      count, _, height, width = image_or_latent_or_mask['samples'].shape
+      return (width * 8, height * 8)
+
+    batch, height, width, channel = image_or_latent_or_mask.shape
+    return (width, height)

custom_nodes/rgthree-comfy/py/image_resize.py

@@ -0,0 +1,117 @@
+import torch
+import comfy.utils
+import nodes
+
+from .constants import get_category, get_name
+
+
+class RgthreeImageResize:
+  """Image Resize."""
+
+  NAME = get_name("Image Resize")
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {
+        "image": ("IMAGE",),
+        "measurement": (["pixels", "percentage"],),
+        "width": (
+          "INT", {
+            "default": 0,
+            "min": 0,
+            "max": nodes.MAX_RESOLUTION,
+            "step": 1,
+            "tooltip": (
+              "The width of the desired resize. A pixel value if measurement is 'pixels' or a"
+              " 100% scale percentage value if measurement is 'percentage'. Passing '0' will"
+              " calculate the dimension based on the height."
+            ),
+          },
+        ),
+        "height": ("INT", {
+          "default": 0,
+          "min": 0,
+          "max": nodes.MAX_RESOLUTION,
+          "step": 1
+        }),
+        "fit": (["crop", "pad", "contain"], {
+          "tooltip": (
+            "'crop' resizes so the image covers the desired width and height, and center-crops the"
+            " excess, returning exactly the desired width and height."
+            "\n'pad' resizes so the image fits inside the desired width and height, and fills the"
+            " empty space returning exactly the desired width and height."
+            "\n'contain' resizes so the image fits inside the desired width and height, and"
+            " returns the image with it's new size, with one side liekly smaller than the desired."
+            "\n\nNote, if either width or height is '0', the effective fit is 'contain'."
+          )
+        },
+               ),
+        "method": (nodes.ImageScale.upscale_methods,),
+      },
+    }
+
+  RETURN_TYPES = ("IMAGE", "INT", "INT",)
+  RETURN_NAMES = ("IMAGE", "WIDTH", "HEIGHT",)
+  FUNCTION = "main"
+  DESCRIPTION = """Resize the image."""
+
+  def main(self, image, measurement, width, height, method, fit):
+    """Resizes the image."""
+    _, H, W, _ = image.shape
+
+    if measurement == "percentage":
+      width = round(width * W / 100)
+      height = round(height * H / 100)
+
+    if (width == 0 and height == 0) or (width == W and height == H):
+      return (image, W, H)
+
+    # If one dimension is 0, then calculate the desired value from the ratio of the set dimension.
+    # This also implies a 'contain' fit since the width and height will be scaled with a locked
+    # aspect ratio.
+    if width == 0 or height == 0:
+      width = round(height / H * W) if width == 0 else width
+      height = round(width / W * H) if height == 0 else height
+      fit = "contain"
+
+    # At this point, width and height are our output height, but our resize sizes will be different.
+    resized_width = width
+    resized_height = height
+    if fit == "crop":
+      # If we resize against the opposite ratio, then choose the ratio that has the overhang.
+      if (height / H * W) > width:
+        resized_width = round(height / H * W)
+      elif (width / W * H) > height:
+        resized_height = round(width / W * H)
+    elif fit == "contain" or fit == "pad":
+      # If we resize against the opposite ratio, then choose the ratio that has the overhang.
+      if (height / H * W) > width:
+        resized_height = round(width / W * H)
+      elif (width / W * H) > height:
+        resized_width = round(height / H * W)
+
+    out_image = comfy.utils.common_upscale(
+      image.clone().movedim(-1, 1), resized_width, resized_height, method, crop="disabled"
+    ).movedim(1, -1)
+    OB, OH, OW, OC = out_image.shape
+
+    if fit != "contain":
+      # First, we crop, then we pad; no need to check fit (other than not 'contain') since the size
+      # should already be correct.
+      if OW > width:
+        out_image = out_image.narrow(-2, (OW - width) // 2, width)
+      if OH > height:
+        out_image = out_image.narrow(-3, (OH - height) // 2, height)
+
+      OB, OH, OW, OC = out_image.shape
+      if width != OW or height != OH:
+        padded_image = torch.zeros((OB, height, width, OC), dtype=image.dtype, device=image.device)
+        x = (width - OW) // 2
+        y = (height - OH) // 2
+        for b in range(OB):
+          padded_image[b, y:y + OH, x:x + OW, :] = out_image[b]
+        out_image = padded_image
+
+    return (out_image, out_image.shape[2], out_image.shape[1])

custom_nodes/rgthree-comfy/py/ksampler_config.py

@@ -0,0 +1,56 @@
+"""Some basic config stuff I use for SDXL."""
+
+from .constants import get_category, get_name
+from nodes import MAX_RESOLUTION
+import comfy.samplers
+
+
+class RgthreeKSamplerConfig:
+  """Some basic config stuff I started using for SDXL, but useful in other spots too."""
+
+  NAME = get_name('KSampler Config')
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {
+        "steps_total": ("INT", {
+          "default": 30,
+          "min": 1,
+          "max": MAX_RESOLUTION,
+          "step": 1,
+        }),
+        "refiner_step": ("INT", {
+          "default": 24,
+          "min": 1,
+          "max": MAX_RESOLUTION,
+          "step": 1,
+        }),
+        "cfg": ("FLOAT", {
+          "default": 8.0,
+          "min": 0.0,
+          "max": 100.0,
+          "step": 0.5,
+        }),
+        "sampler_name": (comfy.samplers.KSampler.SAMPLERS,),
+        "scheduler": (comfy.samplers.KSampler.SCHEDULERS,),
+        #"refiner_ascore_pos": ("FLOAT", {"default": 6.0, "min": 0.0, "max": 1000.0, "step": 0.01}),
+        #"refiner_ascore_neg": ("FLOAT", {"default": 6.0, "min": 0.0, "max": 1000.0, "step": 0.01}),
+      },
+    }
+
+  RETURN_TYPES = ("INT", "INT", "FLOAT", comfy.samplers.KSampler.SAMPLERS,
+                  comfy.samplers.KSampler.SCHEDULERS)
+  RETURN_NAMES = ("STEPS", "REFINER_STEP", "CFG", "SAMPLER", "SCHEDULER")
+  FUNCTION = "main"
+
+  def main(self, steps_total, refiner_step, cfg, sampler_name, scheduler):
+    """main"""
+    return (
+      steps_total,
+      refiner_step,
+      cfg,
+      sampler_name,
+      scheduler,
+    )

custom_nodes/rgthree-comfy/py/log.py

@@ -0,0 +1,100 @@
+import datetime
+import time
+from .pyproject import NAME
+
+# https://stackoverflow.com/questions/4842424/list-of-ansi-color-escape-sequences
+# https://en.wikipedia.org/wiki/ANSI_escape_code#3-bit_and_4-bit
+COLORS = {
+  'BLACK': '\33[30m',
+  'RED': '\33[31m',
+  'GREEN': '\33[32m',
+  'YELLOW': '\33[33m',
+  'BLUE': '\33[34m',
+  'MAGENTA': '\33[35m',
+  'CYAN': '\33[36m',
+  'WHITE': '\33[37m',
+  'GREY': '\33[90m',
+  'BRIGHT_RED': '\33[91m',
+  'BRIGHT_GREEN': '\33[92m',
+  'BRIGHT_YELLOW': '\33[93m',
+  'BRIGHT_BLUE': '\33[94m',
+  'BRIGHT_MAGENTA': '\33[95m',
+  'BRIGHT_CYAN': '\33[96m',
+  'BRIGHT_WHITE': '\33[97m',
+  # Styles.
+  'RESET': '\33[0m',  # Note, Portainer doesn't like 00 here, so we'll use 0. Should be fine...
+  'BOLD': '\33[01m',
+  'NORMAL': '\33[22m',
+  'ITALIC': '\33[03m',
+  'UNDERLINE': '\33[04m',
+  'BLINK': '\33[05m',
+  'BLINK2': '\33[06m',
+  'SELECTED': '\33[07m',
+  # Backgrounds
+  'BG_BLACK': '\33[40m',
+  'BG_RED': '\33[41m',
+  'BG_GREEN': '\33[42m',
+  'BG_YELLOW': '\33[43m',
+  'BG_BLUE': '\33[44m',
+  'BG_MAGENTA': '\33[45m',
+  'BG_CYAN': '\33[46m',
+  'BG_WHITE': '\33[47m',
+  'BG_GREY': '\33[100m',
+  'BG_BRIGHT_RED': '\33[101m',
+  'BG_BRIGHT_GREEN': '\33[102m',
+  'BG_BRIGHT_YELLOW': '\33[103m',
+  'BG_BRIGHT_BLUE': '\33[104m',
+  'BG_BRIGHT_MAGENTA': '\33[105m',
+  'BG_BRIGHT_CYAN': '\33[106m',
+  'BG_BRIGHT_WHITE': '\33[107m',
+}
+
+
+def log_node_success(node_name, message, msg_color='RESET'):
+  """Logs a success message."""
+  _log_node("BRIGHT_GREEN", node_name, message, msg_color=msg_color)
+
+
+def log_node_info(node_name, message, msg_color='RESET'):
+  """Logs an info message."""
+  _log_node("CYAN", node_name, message, msg_color=msg_color)
+
+
+def log_node_error(node_name, message, msg_color='RESET'):
+  """Logs an info message."""
+  _log_node("RED", node_name, message, msg_color=msg_color)
+
+
+def log_node_warn(node_name, message, msg_color='RESET'):
+  """Logs an warn message."""
+  _log_node("YELLOW", node_name, message, msg_color=msg_color)
+
+
+def log_node(node_name, message, msg_color='RESET'):
+  """Logs a message."""
+  _log_node("CYAN", node_name, message, msg_color=msg_color)
+
+
+def _log_node(color, node_name, message, msg_color='RESET'):
+  """Logs for a node message."""
+  log(message, color=color, prefix=node_name.replace(" (rgthree)", ""), msg_color=msg_color)
+
+LOGGED = {}
+
+def log(message, color=None, msg_color=None, prefix=None, id=None, at_most_secs=None):
+  """Basic logging."""
+  now = int(time.time())
+  if id:
+    if at_most_secs is None:
+      raise ValueError('at_most_secs should be set if an id is set.')
+    if id in LOGGED:
+      last_logged = LOGGED[id]
+      if now < last_logged + at_most_secs:
+        return
+    LOGGED[id] = now
+  color = COLORS[color] if color is not None and color in COLORS else COLORS["BRIGHT_GREEN"]
+  msg_color = COLORS[msg_color] if msg_color is not None and msg_color in COLORS else ''
+  prefix = f'[{prefix}]' if prefix is not None else ''
+  msg = f'{color}[{NAME}]{prefix}'
+  msg += f'{msg_color} {message}{COLORS["RESET"]}'
+  print(msg)

custom_nodes/rgthree-comfy/py/lora_stack.py

@@ -0,0 +1,46 @@
+from .constants import get_category, get_name
+from nodes import LoraLoader
+import folder_paths
+
+
+class RgthreeLoraLoaderStack:
+
+    NAME = get_name('Lora Loader Stack')
+    CATEGORY = get_category()
+
+    @classmethod
+    def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+        return {
+            "required": {
+                "model": ("MODEL",),
+                "clip": ("CLIP", ),
+
+                "lora_01": (['None'] + folder_paths.get_filename_list("loras"), ),
+                "strength_01":("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+
+                "lora_02": (['None'] + folder_paths.get_filename_list("loras"), ),
+                "strength_02":("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+
+                "lora_03": (['None'] + folder_paths.get_filename_list("loras"), ),
+                "strength_03":("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+
+                "lora_04": (['None'] + folder_paths.get_filename_list("loras"), ),
+                "strength_04":("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+            }
+        }
+
+    RETURN_TYPES = ("MODEL", "CLIP")
+    FUNCTION = "load_lora"
+
+    def load_lora(self, model, clip, lora_01, strength_01, lora_02, strength_02, lora_03, strength_03, lora_04, strength_04):
+        if lora_01 != "None" and strength_01 != 0:
+            model, clip = LoraLoader().load_lora(model, clip, lora_01, strength_01, strength_01)
+        if lora_02 != "None" and strength_02 != 0:
+            model, clip = LoraLoader().load_lora(model, clip, lora_02, strength_02, strength_02)
+        if lora_03 != "None" and strength_03 != 0:
+            model, clip = LoraLoader().load_lora(model, clip, lora_03, strength_03, strength_03)
+        if lora_04 != "None" and strength_04 != 0:
+            model, clip = LoraLoader().load_lora(model, clip, lora_04, strength_04, strength_04)
+
+        return (model, clip)
+

custom_nodes/rgthree-comfy/py/power_lora_loader.py

@@ -0,0 +1,101 @@
+import folder_paths
+
+from typing import Union
+
+from nodes import LoraLoader
+from .constants import get_category, get_name
+from .power_prompt_utils import get_lora_by_filename
+from .utils import FlexibleOptionalInputType, any_type
+from .server.utils_info import get_model_info_file_data
+from .log import log_node_warn
+
+NODE_NAME = get_name('Power Lora Loader')
+
+
+class RgthreePowerLoraLoader:
+  """ The Power Lora Loader is a powerful, flexible node to add multiple loras to a model/clip."""
+
+  NAME = NODE_NAME
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {
+      },
+      # Since we will pass any number of loras in from the UI, this needs to always allow an
+      "optional": FlexibleOptionalInputType(type=any_type, data={
+        "model": ("MODEL",),
+        "clip": ("CLIP",),
+      }),
+      "hidden": {},
+    }
+
+  RETURN_TYPES = ("MODEL", "CLIP")
+  RETURN_NAMES = ("MODEL", "CLIP")
+  FUNCTION = "load_loras"
+
+  def load_loras(self, model=None, clip=None, **kwargs):
+    """Loops over the provided loras in kwargs and applies valid ones."""
+    for key, value in kwargs.items():
+      key = key.upper()
+      if key.startswith('LORA_') and 'on' in value and 'lora' in value and 'strength' in value:
+        strength_model = value['strength']
+        # If we just passed one strength value, then use it for both, if we passed a strengthTwo
+        # as well, then our `strength` will be for the model, and `strengthTwo` for clip.
+        strength_clip = value['strengthTwo'] if 'strengthTwo' in value else None
+        if clip is None:
+          if strength_clip is not None and strength_clip != 0:
+            log_node_warn(NODE_NAME, 'Recieved clip strength eventhough no clip supplied!')
+          strength_clip = 0
+        else:
+          strength_clip = strength_clip if strength_clip is not None else strength_model
+        if value['on'] and (strength_model != 0 or strength_clip != 0):
+          lora = get_lora_by_filename(value['lora'], log_node=self.NAME)
+          if model is not None and lora is not None:
+            model, clip = LoraLoader().load_lora(model, clip, lora, strength_model, strength_clip)
+
+    return (model, clip)
+
+  @classmethod
+  def get_enabled_loras_from_prompt_node(cls,
+                                         prompt_node: dict) -> list[dict[str, Union[str, float]]]:
+    """Gets enabled loras of a node within a server prompt."""
+    result = []
+    for name, lora in prompt_node['inputs'].items():
+      if name.startswith('lora_') and lora['on']:
+        lora_file = get_lora_by_filename(lora['lora'], log_node=cls.NAME)
+        if lora_file is not None:  # Add the same safety check
+          lora_dict = {
+            'name': lora['lora'],
+            'strength': lora['strength'],
+            'path': folder_paths.get_full_path("loras", lora_file)
+          }
+          if 'strengthTwo' in lora:
+            lora_dict['strength_clip'] = lora['strengthTwo']
+          result.append(lora_dict)
+    return result
+
+  @classmethod
+  def get_enabled_triggers_from_prompt_node(cls, prompt_node: dict, max_each: int = 1):
+    """Gets trigger words up to the max for enabled loras of a node within a server prompt."""
+    loras = [l['name'] for l in cls.get_enabled_loras_from_prompt_node(prompt_node)]
+    trained_words = []
+    for lora in loras:
+      info = get_model_info_file_data(lora, 'loras', default={})
+      if not info or not info.keys():
+        log_node_warn(
+          NODE_NAME,
+          f'No info found for lora {lora} when grabbing triggers. Have you generated an info file'
+          ' from the Power Lora Loader "Show Info" dialog?'
+        )
+        continue
+      if 'trainedWords' not in info or not info['trainedWords']:
+        log_node_warn(
+          NODE_NAME,
+          f'No trained words for lora {lora} when grabbing triggers. Have you fetched data from'
+          'civitai or manually added words?'
+        )
+        continue
+      trained_words += [w for wi in info['trainedWords'][:max_each] if (wi and (w := wi['word']))]
+    return trained_words

custom_nodes/rgthree-comfy/py/power_primitive.py

@@ -0,0 +1,83 @@
+import re
+
+from .utils import FlexibleOptionalInputType, any_type
+from .constants import get_category, get_name
+
+
+def cast_to_str(x):
+  """Handles our cast to a string."""
+  if x is None:
+    return ''
+  try:
+    return str(x)
+  except (ValueError, TypeError):
+    return ''
+
+
+def cast_to_float(x):
+  """Handles our cast to a float."""
+  try:
+    return float(x)
+  except (ValueError, TypeError):
+    return 0.0
+
+
+def cast_to_bool(x):
+  """Handles our cast to a bool."""
+  try:
+    return bool(float(x))
+  except (ValueError, TypeError):
+    return str(x).lower() not in ['0', 'false', 'null', 'none', '']
+
+
+output_to_type = {
+  'STRING': {
+    'cast': cast_to_str,
+    'null': '',
+  },
+  'FLOAT': {
+    'cast': cast_to_float,
+    'null': 0.0,
+  },
+  'INT': {
+    'cast': lambda x: int(cast_to_float(x)),
+    'null': 0,
+  },
+  'BOOLEAN': {
+    'cast': cast_to_bool,
+    'null': False,
+  },
+  # This can be removed soon, there was a bug where this should have been BOOLEAN
+  'BOOL': {
+    'cast': cast_to_bool,
+    'null': False,
+  },
+}
+
+
+class RgthreePowerPrimitive:
+  """The Power Primitive Node."""
+
+  NAME = get_name('Power Primitive')
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {},
+      "optional": FlexibleOptionalInputType(any_type),
+    }
+
+  RETURN_TYPES = (any_type,)
+  RETURN_NAMES = ('*',)
+  FUNCTION = "main"
+
+  def main(self, **kwargs):
+    """Outputs the expected type."""
+    output = kwargs.get('value', None)
+    output_type = re.sub(r'\s*\([^\)]*\)\s*$', '', kwargs.get('type', ''))
+    output_type = output_to_type[output_type]
+    cast = output_type['cast']
+    output = cast(output)
+
+    return (output,)

custom_nodes/rgthree-comfy/py/power_prompt.py

@@ -0,0 +1,95 @@
+import os
+
+from .log import log_node_warn, log_node_info, log_node_success
+
+from .constants import get_category, get_name
+from .power_prompt_utils import get_and_strip_loras
+from nodes import LoraLoader, CLIPTextEncode
+import folder_paths
+
+NODE_NAME = get_name('Power Prompt')
+
+
+class RgthreePowerPrompt:
+
+  NAME = NODE_NAME
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    # Removed Saved Prompts feature; No sure it worked any longer. UI should fail gracefully,
+    # TODO: Rip out saved prompt input data
+    SAVED_PROMPTS_FILES=[]
+    SAVED_PROMPTS_CONTENT=[]
+    return {
+      'required': {
+        'prompt': ('STRING', {
+          'multiline': True,
+          'dynamicPrompts': True
+        }),
+      },
+      'optional': {
+        "opt_model": ("MODEL",),
+        "opt_clip": ("CLIP",),
+        'insert_lora': (['CHOOSE', 'DISABLE LORAS'] +
+                        [os.path.splitext(x)[0] for x in folder_paths.get_filename_list('loras')],),
+        'insert_embedding': ([
+          'CHOOSE',
+        ] + [os.path.splitext(x)[0] for x in folder_paths.get_filename_list('embeddings')],),
+        'insert_saved': ([
+          'CHOOSE',
+        ] + SAVED_PROMPTS_FILES,),
+      },
+      'hidden': {
+        'values_insert_saved': (['CHOOSE'] + SAVED_PROMPTS_CONTENT,),
+      }
+    }
+
+  RETURN_TYPES = (
+    'CONDITIONING',
+    'MODEL',
+    'CLIP',
+    'STRING',
+  )
+  RETURN_NAMES = (
+    'CONDITIONING',
+    'MODEL',
+    'CLIP',
+    'TEXT',
+  )
+  FUNCTION = 'main'
+
+  def main(self,
+           prompt,
+           opt_model=None,
+           opt_clip=None,
+           insert_lora=None,
+           insert_embedding=None,
+           insert_saved=None,
+           values_insert_saved=None):
+    if insert_lora == 'DISABLE LORAS':
+      prompt, loras, skipped, unfound = get_and_strip_loras(prompt, log_node=NODE_NAME, silent=True)
+      log_node_info(
+        NODE_NAME,
+        f'Disabling all found loras ({len(loras)}) and stripping lora tags for TEXT output.')
+    elif opt_model is not None and opt_clip is not None:
+      prompt, loras, skipped, unfound = get_and_strip_loras(prompt, log_node=NODE_NAME)
+      if len(loras) > 0:
+        for lora in loras:
+          opt_model, opt_clip = LoraLoader().load_lora(opt_model, opt_clip, lora['lora'],
+                                                       lora['strength'], lora['strength'])
+          log_node_success(NODE_NAME, f'Loaded "{lora["lora"]}" from prompt')
+        log_node_info(NODE_NAME, f'{len(loras)} Loras processed; stripping tags for TEXT output.')
+    elif '<lora:' in prompt:
+      prompt, loras, skipped, unfound = get_and_strip_loras(prompt, log_node=NODE_NAME, silent=True)
+      total_loras = len(loras) + len(skipped) + len(unfound)
+      if total_loras:
+        log_node_warn(
+          NODE_NAME, f'Found {len(loras)} lora tags in prompt but model & clip were not supplied!')
+        log_node_info(NODE_NAME, 'Loras not processed, keeping for TEXT output.')
+
+    conditioning = None
+    if opt_clip is not None:
+      conditioning = CLIPTextEncode().encode(opt_clip, prompt)[0]
+
+    return (conditioning, opt_model, opt_clip, prompt)

custom_nodes/rgthree-comfy/py/power_prompt_simple.py

@@ -0,0 +1,42 @@
+import os
+import folder_paths
+from nodes import CLIPTextEncode
+from .constants import get_category, get_name
+from .power_prompt import RgthreePowerPrompt
+
+class RgthreePowerPromptSimple(RgthreePowerPrompt):
+
+    NAME=get_name('Power Prompt - Simple')
+    CATEGORY = get_category()
+
+    @classmethod
+    def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+        # Removed Saved Prompts feature; No sure it worked any longer. UI should fail gracefully,
+        # TODO: Rip out saved prompt input data
+        SAVED_PROMPTS_FILES=[]
+        SAVED_PROMPTS_CONTENT=[]
+        return {
+            'required': {
+                'prompt': ('STRING', {'multiline': True, 'dynamicPrompts': True}),
+            },
+            'optional': {
+                "opt_clip": ("CLIP", ),
+                'insert_embedding': (['CHOOSE',] + [os.path.splitext(x)[0] for x in folder_paths.get_filename_list('embeddings')],),
+                'insert_saved': (['CHOOSE',] + SAVED_PROMPTS_FILES,),
+            },
+            'hidden': {
+                'values_insert_saved': (['CHOOSE'] + SAVED_PROMPTS_CONTENT,),
+            }
+        }
+
+    RETURN_TYPES = ('CONDITIONING', 'STRING',)
+    RETURN_NAMES = ('CONDITIONING', 'TEXT',)
+    FUNCTION = 'main'
+
+    def main(self, prompt, opt_clip=None, insert_embedding=None, insert_saved=None, values_insert_saved=None):
+        conditioning=None
+        if opt_clip != None:
+            conditioning = CLIPTextEncode().encode(opt_clip, prompt)[0]
+
+        return (conditioning, prompt)
+

custom_nodes/rgthree-comfy/py/power_prompt_utils.py

@@ -0,0 +1,104 @@
+"""Utilities for Power Prompt nodes."""
+import re
+import os
+import folder_paths
+
+from .log import log_node_warn, log_node_info
+
+
+def get_and_strip_loras(prompt, silent=False, log_node="Power Prompt"):
+  """Collects and strips lora tags from a prompt."""
+  pattern = r'<lora:([^:>]*?)(?::(-?\d*(?:\.\d*)?))?>'
+  lora_paths = folder_paths.get_filename_list('loras')
+
+  matches = re.findall(pattern, prompt)
+
+  loras = []
+  unfound_loras = []
+  skipped_loras = []
+  for match in matches:
+    tag_path = match[0]
+
+    strength = float(match[1] if len(match) > 1 and len(match[1]) else 1.0)
+    if strength == 0:
+      if not silent:
+        log_node_info(log_node, f'Skipping "{tag_path}" with strength of zero')
+      skipped_loras.append({'lora': tag_path, 'strength': strength})
+      continue
+
+    lora_path = get_lora_by_filename(tag_path, lora_paths, log_node=None if silent else log_node)
+    if lora_path is None:
+      unfound_loras.append({'lora': tag_path, 'strength': strength})
+      continue
+
+    loras.append({'lora': lora_path, 'strength': strength})
+
+  return (re.sub(pattern, '', prompt), loras, skipped_loras, unfound_loras)
+
+
+# pylint: disable = too-many-return-statements, too-many-branches
+def get_lora_by_filename(file_path, lora_paths=None, log_node=None):
+  """Returns a lora by filename, looking for exactl paths and then fuzzier matching."""
+  lora_paths = lora_paths if lora_paths is not None else folder_paths.get_filename_list('loras')
+
+  if file_path in lora_paths:
+    return file_path
+
+  lora_paths_no_ext = [os.path.splitext(x)[0] for x in lora_paths]
+
+  # See if we've entered the exact path, but without the extension
+  if file_path in lora_paths_no_ext:
+    found = lora_paths[lora_paths_no_ext.index(file_path)]
+    return found
+
+  # Same check, but ensure file_path is without extension.
+  file_path_force_no_ext = os.path.splitext(file_path)[0]
+  if file_path_force_no_ext in lora_paths_no_ext:
+    found = lora_paths[lora_paths_no_ext.index(file_path_force_no_ext)]
+    return found
+
+  # See if we passed just the name, without paths.
+  lora_filenames_only = [os.path.basename(x) for x in lora_paths]
+  if file_path in lora_filenames_only:
+    found = lora_paths[lora_filenames_only.index(file_path)]
+    if log_node is not None:
+      log_node_info(log_node, f'Matched Lora input "{file_path}" to "{found}".')
+    return found
+
+  # Same, but force the input to be without paths
+  file_path_force_filename = os.path.basename(file_path)
+  lora_filenames_only = [os.path.basename(x) for x in lora_paths]
+  if file_path_force_filename in lora_filenames_only:
+    found = lora_paths[lora_filenames_only.index(file_path_force_filename)]
+    if log_node is not None:
+      log_node_info(log_node, f'Matched Lora input "{file_path}" to "{found}".')
+    return found
+
+  # Check the filenames and without extension.
+  lora_filenames_and_no_ext = [os.path.splitext(os.path.basename(x))[0] for x in lora_paths]
+  if file_path in lora_filenames_and_no_ext:
+    found = lora_paths[lora_filenames_and_no_ext.index(file_path)]
+    if log_node is not None:
+      log_node_info(log_node, f'Matched Lora input "{file_path}" to "{found}".')
+    return found
+
+  # And, one last forcing the input to be the same
+  file_path_force_filename_and_no_ext = os.path.splitext(os.path.basename(file_path))[0]
+  if file_path_force_filename_and_no_ext in lora_filenames_and_no_ext:
+    found = lora_paths[lora_filenames_and_no_ext.index(file_path_force_filename_and_no_ext)]
+    if log_node is not None:
+      log_node_info(log_node, f'Matched Lora input "{file_path}" to "{found}".')
+    return found
+
+  # Finally, super fuzzy, we'll just check if the input exists in the path at all.
+  for index, lora_path in enumerate(lora_paths):
+    if file_path in lora_path:
+      found = lora_paths[index]
+      if log_node is not None:
+        log_node_warn(log_node, f'Fuzzy-matched Lora input "{file_path}" to "{found}".')
+      return found
+
+  if log_node is not None:
+    log_node_warn(log_node, f'Lora "{file_path}" not found, skipping.')
+
+  return None

custom_nodes/rgthree-comfy/py/power_puter.py

@@ -0,0 +1,842 @@
+"""The Power Puter is a powerful node that can compute and evaluate Python-like code safely allowing
+for complex operations for primitives and workflow items for output. From string concatenation, to
+math operations, list comprehension, and node value output.
+
+Originally based off https://github.com/pythongosssss/ComfyUI-Custom-Scripts/blob/aac13aa7ce35b07d43633c3bbe654a38c00d74f5/py/math_expression.py
+under an MIT License https://github.com/pythongosssss/ComfyUI-Custom-Scripts/blob/aac13aa7ce35b07d43633c3bbe654a38c00d74f5/LICENSE
+"""
+
+import math
+import ast
+import json
+import random
+import dataclasses
+import re
+import time
+import operator as op
+import datetime
+import numpy as np
+
+from typing import Any, Callable, Iterable, Optional, Union
+from types import MappingProxyType
+
+from .constants import get_category, get_name
+from .utils import ByPassTypeTuple, FlexibleOptionalInputType, any_type, get_dict_value
+from .log import log_node_error, log_node_warn, log_node_info
+
+from .power_lora_loader import RgthreePowerLoraLoader
+
+from nodes import ImageBatch
+from comfy_extras.nodes_latent import LatentBatch
+
+
+class LoopBreak(Exception):
+  """A special error type that is caught in a loop for correct breaking behavior."""
+
+  def __init__(self):
+    super().__init__('Cannot use "break" outside of a loop.')
+
+
+class LoopContinue(Exception):
+  """A special error type that is caught in a loop for correct continue behavior."""
+
+  def __init__(self):
+    super().__init__('Cannot use "continue" outside of a loop.')
+
+
+@dataclasses.dataclass(frozen=True)  # Note, kw_only=True is only python 3.10+
+class Function():
+  """Function data.
+
+  Attributes:
+    name: The name of the function as called from the node.
+    call: The callable (reference, lambda, etc), or a string if on _Puter instance.
+    args: A tuple that represents the minimum and maximum number of args (or arg for no limit).
+  """
+
+  name: str
+  call: Union[Callable, str]
+  args: tuple[int, Optional[int]]
+
+
+def purge_vram(purge_models=True):
+  """Purges vram and, optionally, unloads models."""
+  import gc
+  import torch
+  gc.collect()
+  if torch.cuda.is_available():
+    torch.cuda.empty_cache()
+    torch.cuda.ipc_collect()
+  if purge_models:
+    import comfy
+    comfy.model_management.unload_all_models()
+    comfy.model_management.soft_empty_cache()
+
+
+def batch(*args):
+  """Batches multiple image or latents together."""
+
+  def check_is_latent(item) -> bool:
+    return isinstance(item, dict) and 'samples' in item
+
+  args = list(args)
+  result = args.pop(0)
+  is_latent = check_is_latent(result)
+  node = LatentBatch() if is_latent else ImageBatch()
+
+  for arg in args:
+    if is_latent != check_is_latent(arg):
+      raise ValueError(
+        f'batch() error: Expecting "{"LATENT" if is_latent else "IMAGE"}"'
+        f' but got "{"IMAGE" if is_latent else "LATENT"}".'
+      )
+    result = node.batch(result, arg)[0]
+  return result
+
+
+_BUILTIN_FN_PREFIX = '__rgthreefn.'
+
+
+def _get_built_in_fn_key(fn: Function) -> str:
+  """Returns a key for a built-in function."""
+  return f'{_BUILTIN_FN_PREFIX}{hash(fn.name)}'
+
+
+def _get_built_in_fn_by_key(fn_key: str):
+  """Returns the `Function` for the provided key (purposefully, not name)."""
+  if not fn_key.startswith(_BUILTIN_FN_PREFIX) or fn_key not in _BUILT_INS_BY_NAME_AND_KEY:
+    raise ValueError('No built in function found.')
+  return _BUILT_INS_BY_NAME_AND_KEY[fn_key]
+
+
+_BUILT_IN_FNS_LIST = [
+  Function(name="round", call=round, args=(1, 2)),
+  Function(name="ceil", call=math.ceil, args=(1, 1)),
+  Function(name="floor", call=math.floor, args=(1, 1)),
+  Function(name="sqrt", call=math.sqrt, args=(1, 1)),
+  Function(name="min", call=min, args=(2, None)),
+  Function(name="max", call=max, args=(2, None)),
+  Function(name=".random_int", call=random.randint, args=(2, 2)),
+  Function(name=".random_choice", call=random.choice, args=(1, 1)),
+  Function(name=".random_seed", call=random.seed, args=(1, 1)),
+  Function(name="re", call=re.compile, args=(1, 1)),
+  Function(name="len", call=len, args=(1, 1)),
+  Function(name="enumerate", call=enumerate, args=(1, 1)),
+  Function(name="range", call=range, args=(1, 3)),
+  # Casts
+  Function(name="int", call=int, args=(1, 1)),
+  Function(name="float", call=float, args=(1, 1)),
+  Function(name="str", call=str, args=(1, 1)),
+  Function(name="bool", call=bool, args=(1, 1)),
+  Function(name="list", call=list, args=(1, 1)),
+  Function(name="tuple", call=tuple, args=(1, 1)),
+  # Special
+  Function(name="dir", call=dir, args=(1, 1)),
+  Function(name="type", call=type, args=(1, 1)),
+  Function(name="print", call=print, args=(0, None)),
+  # Comfy Specials
+  Function(name="node", call='_get_node', args=(0, 1)),
+  Function(name="nodes", call='_get_nodes', args=(0, 1)),
+  Function(name="input_node", call='_get_input_node', args=(0, 1)),
+  Function(name="purge_vram", call=purge_vram, args=(0, 1)),
+  Function(name="batch", call=batch, args=(2, None)),
+]
+
+_BUILT_INS_BY_NAME_AND_KEY = {
+  fn.name: fn for fn in _BUILT_IN_FNS_LIST
+} | {
+  key: fn for fn in _BUILT_IN_FNS_LIST if (key := _get_built_in_fn_key(fn))
+}
+
+_BUILT_INS = MappingProxyType(
+  {fn.name: key for fn in _BUILT_IN_FNS_LIST if (key := _get_built_in_fn_key(fn))} | {
+    'random':
+      MappingProxyType({
+        'int': _get_built_in_fn_key(_BUILT_INS_BY_NAME_AND_KEY['.random_int']),
+        'choice': _get_built_in_fn_key(_BUILT_INS_BY_NAME_AND_KEY['.random_choice']),
+        'seed': _get_built_in_fn_key(_BUILT_INS_BY_NAME_AND_KEY['.random_seed']),
+      }),
+  }
+)
+
+# A dict of types to blocked attributes/methods. Used to disallow file system access or other
+# invocations we may want to block. Necessary for any instance type that is possible to create from
+# the code or standard ComfyUI inputs.
+#
+# For instance, a user does not have access to the numpy module directly, so they cannot invoke
+# `numpy.save`. However, a user can access a numpy.ndarray instance from a tensor and, from there,
+# an attempt to call `tofile` or `dump` etc. would need to be blocked.
+_BLOCKED_METHODS_OR_ATTRS = MappingProxyType({np.ndarray: ['tofile', 'dump']})
+
+# Special functions by class type (called from the Attrs.)
+_SPECIAL_FUNCTIONS = {
+  RgthreePowerLoraLoader.NAME: {
+    # Get a list of the enabled loras from a power lora loader.
+    "loras": RgthreePowerLoraLoader.get_enabled_loras_from_prompt_node,
+    "triggers": RgthreePowerLoraLoader.get_enabled_triggers_from_prompt_node,
+  }
+}
+
+# Series of regex checks for usage of a non-deterministic function. Using these is fine, but means
+# the output can't be cached because it's either random, or is associated with another node that is
+# not connected to ours (like looking up a node in the prompt). Using these means downstream nodes
+# would always be run; that is fine for something like a final JSON output, but less so for a prompt
+# text.
+_NON_DETERMINISTIC_FUNCTION_CHECKS = [r'(?<!input_)(nodes?)\(',]
+
+_OPERATORS = {
+  # operator
+  ast.Add: op.add,
+  ast.Sub: op.sub,
+  ast.Mult: op.mul,
+  ast.MatMult: op.matmul,
+  ast.Div: op.truediv,
+  ast.Mod: op.mod,
+  ast.Pow: op.pow,
+  ast.RShift: op.rshift,
+  ast.LShift: op.lshift,
+  ast.BitOr: op.or_,
+  ast.BitXor: op.xor,
+  ast.BitAnd: op.and_,
+  ast.FloorDiv: op.floordiv,
+  # boolop
+  ast.And: lambda a, b: a and b,
+  ast.Or: lambda a, b: a or b,
+  # unaryop
+  ast.Invert: op.invert,
+  ast.Not: lambda a: 0 if a else 1,
+  ast.USub: op.neg,
+  # cmpop
+  ast.Eq: op.eq,
+  ast.NotEq: op.ne,
+  ast.Lt: op.lt,
+  ast.LtE: op.le,
+  ast.Gt: op.gt,
+  ast.GtE: op.ge,
+  ast.Is: op.is_,
+  ast.IsNot: op.is_not,
+  ast.In: lambda a, b: a in b,
+  ast.NotIn: lambda a, b: a not in b,
+
+}
+
+_NODE_NAME = get_name("Power Puter")
+
+
+def _update_code(code: str, unique_id: str, log=False):
+  """Updates the code to either newer syntax or general cleaning."""
+
+  # Change usage of `input_node` so the passed variable is a string, if it isn't. So, instead of
+  # `input_node(a)` it needs to be `input_node('a')`
+  code = re.sub(r'input_node\(([^\'"].*?)\)', r'input_node("\1")', code)
+
+  # Update use of `random_int` to `random.int`
+  srch = re.compile(r'random_int\(')
+  if re.search(srch, code):
+    if log:
+      log_node_warn(
+        _NODE_NAME, f"Power Puter node #{unique_id} should update to use the `random.int`"
+        " built-in instead of `random_int`."
+      )
+    code = re.sub(srch, 'random.int(', code)
+
+  # Update use of `random_choice` to `random.choice`
+  srch = re.compile(r'random_choice\(')
+  if re.search(srch, code):
+    if log:
+      log_node_warn(
+        _NODE_NAME, f"Power Puter node #{unique_id} should update to use the `random.choice`"
+        " built-in instead of `random_choice`."
+      )
+    code = re.sub(srch, 'random.choice(', code)
+  return code
+
+
+class RgthreePowerPuter:
+  """A powerful node that can compute and evaluate expressions and output as various types."""
+
+  NAME = _NODE_NAME
+  CATEGORY = get_category()
+
+  @classmethod
+  def INPUT_TYPES(cls):  # pylint: disable = invalid-name, missing-function-docstring
+    return {
+      "required": {},
+      "optional": FlexibleOptionalInputType(any_type),
+      "hidden": {
+        "unique_id": "UNIQUE_ID",
+        "extra_pnginfo": "EXTRA_PNGINFO",
+        "prompt": "PROMPT",
+        "dynprompt": "DYNPROMPT"
+      },
+    }
+
+  RETURN_TYPES = ByPassTypeTuple((any_type,))
+  RETURN_NAMES = ByPassTypeTuple(("*",))
+  FUNCTION = "main"
+
+  @classmethod
+  def IS_CHANGED(cls, **kwargs):
+    """Forces a changed state if we could be unaware of data changes (like using `node()`)."""
+
+    code = _update_code(kwargs['code'], unique_id=kwargs['unique_id'])
+    # Strip string literals and comments.
+    code = re.sub(r"'[^']+?'", "''", code)
+    code = re.sub(r'"[^"]+?"', '""', code)
+    code = re.sub(r'#.*\n', '\n', code)
+
+    # If we have a non-deterministic function, then we'll always consider ourself changed since we
+    # cannot be sure that the data would be the same (random, another unconnected node, etc).
+    for check in _NON_DETERMINISTIC_FUNCTION_CHECKS:
+      matches = re.search(check, code)
+      if matches:
+        log_node_warn(
+          _NODE_NAME,
+          f"Note, Power Puter (node #{kwargs['unique_id']}) cannot be cached b/c it's using a"
+          f" non-deterministic function call. Matches function call for '{matches.group(1)}'."
+        )
+        return time.time()
+
+    # Advanced checks.
+    has_rand_seed = re.search(r'random\.seed\(', code)
+    has_rand_int_or_choice = re.search(r'(?<!\.)(random\.(int|choice))\(', code)
+    if has_rand_int_or_choice:
+      if not has_rand_seed or has_rand_seed.span()[0] > has_rand_int_or_choice.span()[0]:
+        log_node_warn(
+          _NODE_NAME,
+          f"Note, Power Puter (node #{kwargs['unique_id']}) cannot be cached b/c it's using a"
+          " non-deterministic function call. Matches function call for"
+          f" `{has_rand_int_or_choice.group(1)}`."
+        )
+        return time.time()
+      if has_rand_seed:
+        log_node_info(
+          _NODE_NAME,
+          f"Power Puter node #{kwargs['unique_id']} WILL be cached eventhough it's using"
+          f" a non-deterministic random call `{has_rand_int_or_choice.group(1)}` because it also"
+          f" calls `random.seed` first. NOTE: Please ensure that the seed value is deterministic."
+        )
+
+    return 42
+
+  def main(self, **kwargs):
+    """Does the nodes' work."""
+    code = kwargs['code']
+    unique_id = kwargs['unique_id']
+    pnginfo = kwargs['extra_pnginfo']
+    workflow = pnginfo["workflow"] if "workflow" in pnginfo else {"nodes": []}
+    prompt = kwargs['prompt']
+    dynprompt = kwargs['dynprompt']
+
+    outputs = get_dict_value(kwargs, 'outputs.outputs', None)
+    if not outputs:
+      output = kwargs.get('output', None)
+      if not output:
+        output = 'STRING'
+      outputs = [output]
+
+    ctx = {}
+    # Set variable names, defaulting to None instead of KeyErrors
+    for c in list('abcdefghijklmnopqrstuvwxyz'):
+      ctx[c] = kwargs[c] if c in kwargs else None
+
+    code = _update_code(kwargs['code'], unique_id=kwargs['unique_id'], log=True)
+
+    eva = _Puter(
+      code=code,
+      ctx=ctx,
+      workflow=workflow,
+      prompt=prompt,
+      dynprompt=dynprompt,
+      unique_id=unique_id
+    )
+    values = eva.execute()
+
+    # Check if we have multiple outputs that the returned value is a tuple and raise if not.
+    if len(outputs) > 1 and not isinstance(values, tuple):
+      t = re.sub(r'^<[a-z]*\s(.*?)>$', r'\1', str(type(values)))
+      msg = (
+        f"When using multiple node outputs, the value from the code should be a 'tuple' with the"
+        f" number of items equal to the number of outputs. But value from code was of type {t}."
+      )
+      log_node_error(_NODE_NAME, f'{msg}\n')
+      raise ValueError(msg)
+
+    if len(outputs) == 1:
+      values = (values,)
+
+    if len(values) > len(outputs):
+      log_node_warn(
+        _NODE_NAME,
+        f"Expected value from code to be tuple with {len(outputs)} items, but value from code had"
+        f" {len(values)} items. Extra values will be dropped."
+      )
+    elif len(values) < len(outputs):
+      log_node_warn(
+        _NODE_NAME,
+        f"Expected value from code to be tuple with {len(outputs)} items, but value from code had"
+        f" {len(values)} items. Extra outputs will be null."
+      )
+
+    # Now, we'll go over out return tuple, and cast as the output types.
+    response = []
+    for i, output in enumerate(outputs):
+      value = values[i] if len(values) > i else None
+      if value is not None:
+        if output == 'INT':
+          value = int(value)
+        elif output == 'FLOAT':
+          value = float(value)
+        # Accidentally defined "BOOL" when should have been "BOOLEAN."
+        # TODO: Can prob get rid of BOOl after a bit when UIs would be updated from sending
+        # BOOL incorrectly.
+        elif output in ('BOOL', 'BOOLEAN'):
+          value = bool(value)
+        elif output == 'STRING':
+          if isinstance(value, (dict, list)):
+            value = json.dumps(value, indent=2)
+          else:
+            value = str(value)
+        elif output == '*':
+          # Do nothing, the output will be passed as-is. This could be anything and it's up to the
+          # user to control the intended output, like passing through an input value, etc.
+          pass
+      response.append(value)
+    return tuple(response)
+
+
+class _Puter:
+  """The main computation evaluator, using ast.parse the code.
+
+  See https://www.basicexamples.com/example/python/ast for examples.
+  """
+
+  def __init__(self, *, code: str, ctx: dict[str, Any], workflow, prompt, dynprompt, unique_id):
+    ctx = ctx or {}
+    self._ctx = {**ctx}
+    self._code = code
+    self._workflow = workflow
+    self._prompt = prompt
+    self._unique_id = unique_id
+    self._dynprompt = dynprompt
+    # These are now expanded lazily when needed.
+    self._prompt_nodes = None
+    self._prompt_node = None
+
+  def execute(self, code=Optional[str]) -> Any:
+    """Evaluates a the code block."""
+
+    # Always store random state and initialize a new seed. We'll restore the state later.
+    initial_random_state = random.getstate()
+    random.seed(datetime.datetime.now().timestamp())
+    last_value = None
+    try:
+      code = code or self._code
+      node = ast.parse(self._code)
+      ctx = {**self._ctx}
+      for body in node.body:
+        last_value = self._eval_statement(body, ctx)
+        # If we got a return, then that's it folks.
+        if isinstance(body, ast.Return):
+          break
+    except:
+      random.setstate(initial_random_state)
+      raise
+    random.setstate(initial_random_state)
+    return last_value
+
+  def _get_prompt_nodes(self):
+    """Expands the prompt nodes lazily from the dynamic prompt.
+
+    https://github.com/comfyanonymous/ComfyUI/blob/fc657f471a29d07696ca16b566000e8e555d67d1/comfy_execution/graph.py#L22
+    """
+    if self._prompt_nodes is None:
+      self._prompt_nodes = []
+      if self._dynprompt:
+        all_ids = self._dynprompt.all_node_ids()
+        self._prompt_nodes = [{'id': k} | {**self._dynprompt.get_node(k)} for k in all_ids]
+    return self._prompt_nodes
+
+  def _get_prompt_node(self):
+    if self._prompt_nodes is None:
+      self._prompt_node = [n for n in self._get_prompt_nodes() if n['id'] == self._unique_id][0]
+    return self._prompt_node
+
+  def _get_nodes(self, node_id: Union[int, str, re.Pattern, None] = None) -> list[Any]:
+    """Get a list of the nodes that match the node_id, or all the nodes in the prompt."""
+    nodes = self._get_prompt_nodes().copy()
+    if not node_id:
+      return nodes
+
+    if isinstance(node_id, re.Pattern):
+      found = [n for n in nodes if re.search(node_id, get_dict_value(n, '_meta.title', ''))]
+    else:
+      node_id = str(node_id)
+      found = None
+      if re.match(r'\d+$', node_id):
+        found = [n for n in nodes if node_id == n['id']]
+      if not found:
+        found = [n for n in nodes if node_id == get_dict_value(n, '_meta.title', '')]
+    return found
+
+  def _get_node(self, node_id: Union[int, str, re.Pattern, None] = None) -> Union[Any, None]:
+    """Returns a prompt-node from the hidden prompt."""
+    if node_id is None:
+      return self._get_prompt_node()
+    nodes = self._get_nodes(node_id)
+    if nodes and len(nodes) > 1:
+      log_node_warn(_NODE_NAME, f"More than one node found for '{node_id}'. Returning first.")
+    return nodes[0] if nodes else None
+
+  def _get_input_node(self, input_name, node=None):
+    """Gets the (non-muted) node of an input connection from a node (default to the power puter)."""
+    node = node if node else self._get_prompt_node()
+    try:
+      connected_node_id = node['inputs'][input_name][0]
+      return [n for n in self._get_prompt_nodes() if n['id'] == connected_node_id][0]
+    except (TypeError, IndexError, KeyError):
+      log_node_warn(_NODE_NAME, f'No input node found for "{input_name}". ')
+    return None
+
+  def _eval_statement(self, stmt: ast.AST, ctx: dict, prev_stmt: Union[ast.AST, None] = None):
+    """Evaluates an ast.stmt."""
+
+    if '__returned__' in ctx:
+      return ctx['__returned__']
+
+    # print('\n\n----: _eval_statement')
+    # print(type(stmt))
+    # print(ctx)
+
+    if isinstance(stmt, (ast.FormattedValue, ast.Expr)):
+      return self._eval_statement(stmt.value, ctx=ctx)
+
+    if isinstance(stmt, (ast.Constant, ast.Num)):
+      return stmt.n
+
+    if isinstance(stmt, ast.BinOp):
+      left = self._eval_statement(stmt.left, ctx=ctx)
+      right = self._eval_statement(stmt.right, ctx=ctx)
+      return _OPERATORS[type(stmt.op)](left, right)
+
+    if isinstance(stmt, ast.BoolOp):
+      is_and = isinstance(stmt.op, ast.And)
+      is_or = isinstance(stmt.op, ast.Or)
+      stmt_value_eval = None
+      for stmt_value in stmt.values:
+        stmt_value_eval = self._eval_statement(stmt_value, ctx=ctx)
+        # If we're an and operator and have a falsyt value, then we stop and return. Likewise, if
+        # we're an or operator and have a truthy value, we can stop and return.
+        if (is_and and not stmt_value_eval) or (is_or and stmt_value_eval):
+          return stmt_value_eval
+      # Always return the last if we made it here w/o success.
+      return stmt_value_eval
+
+    if isinstance(stmt, ast.UnaryOp):
+      return _OPERATORS[type(stmt.op)](self._eval_statement(stmt.operand, ctx=ctx))
+
+    if isinstance(stmt, (ast.Attribute, ast.Subscript)):
+      # Like: node(14).inputs.sampler_name (Attribute)
+      # Like: node(14)['inputs']['sampler_name'] (Subscript)
+      item = self._eval_statement(stmt.value, ctx=ctx)
+      attr = None
+      # if hasattr(stmt, 'attr'):
+      if isinstance(stmt, ast.Attribute):
+        attr = stmt.attr
+      else:
+        # Slice could be a name or a constant; evaluate it
+        attr = self._eval_statement(stmt.slice, ctx=ctx)
+      # Check if we're blocking access to this attribute/method on this item type.
+      for typ, names in _BLOCKED_METHODS_OR_ATTRS.items():
+        if isinstance(item, typ) and isinstance(attr, str) and attr in names:
+          raise ValueError(f'Disallowed access to "{attr}" for type {typ}.')
+      try:
+        val = item[attr]
+      except (TypeError, IndexError, KeyError):
+        try:
+          val = getattr(item, attr)
+        except AttributeError:
+          # If we're a dict, then just return None instead of error; saves time.
+          if isinstance(item, dict):
+            # Any special cases in the _SPECIAL_FUNCTIONS
+            class_type = get_dict_value(item, "class_type")
+            if class_type in _SPECIAL_FUNCTIONS and attr in _SPECIAL_FUNCTIONS[class_type]:
+              val = _SPECIAL_FUNCTIONS[class_type][attr]
+              # If our previous statment was a Call, then send back a tuple of the callable and
+              # the evaluated item, and it will make the call; perhaps also adding other arguments
+              # only it knows about.
+              if isinstance(prev_stmt, ast.Call):
+                return (val, item)
+              val = val(item)
+            else:
+              val = None
+          else:
+            raise
+      return val
+
+    if isinstance(stmt, (ast.List, ast.Tuple)):
+      value = []
+      for elt in stmt.elts:
+        value.append(self._eval_statement(elt, ctx=ctx))
+      return tuple(value) if isinstance(stmt, ast.Tuple) else value
+
+    if isinstance(stmt, ast.Dict):
+      the_dict = {}
+      if stmt.keys:
+        if len(stmt.keys) != len(stmt.values):
+          raise ValueError('Expected same number of keys as values for dict.')
+        for i, k in enumerate(stmt.keys):
+          item_key = self._eval_statement(k, ctx=ctx)
+          item_value = self._eval_statement(stmt.values[i], ctx=ctx)
+          the_dict[item_key] = item_value
+      return the_dict
+
+    # f-strings: https://www.basicexamples.com/example/python/ast-JoinedStr
+    # Note, this will str() all evaluated items in the fstrings, and doesn't handle f-string
+    # directives, like padding, etc.
+    if isinstance(stmt, ast.JoinedStr):
+      vals = [str(self._eval_statement(v, ctx=ctx)) for v in stmt.values]
+      val = ''.join(vals)
+      return val
+
+    if isinstance(stmt, ast.Slice):
+      if not stmt.lower or not stmt.upper:
+        raise ValueError('Unhandled Slice w/o lower or upper.')
+      slice_lower = self._eval_statement(stmt.lower, ctx=ctx)
+      slice_upper = self._eval_statement(stmt.upper, ctx=ctx)
+      if stmt.step:
+        slice_step = self._eval_statement(stmt.step, ctx=ctx)
+        return slice(slice_lower, slice_upper, slice_step)
+      return slice(slice_lower, slice_upper)
+
+    if isinstance(stmt, ast.Name):
+      if stmt.id in ctx:
+        val = ctx[stmt.id]
+        return val
+      if stmt.id in _BUILT_INS:
+        val = _BUILT_INS[stmt.id]
+        return val
+      raise NameError(f"Name not found: {stmt.id}")
+
+    if isinstance(stmt, ast.For):
+      for_iter = self._eval_statement(stmt.iter, ctx=ctx)
+      for item in for_iter:
+        # Set the for var(s)
+        if isinstance(stmt.target, ast.Name):
+          ctx[stmt.target.id] = item
+        elif isinstance(stmt.target, ast.Tuple):  # dict, like `for k, v in d.entries()`
+          for i, elt in enumerate(stmt.target.elts):
+            ctx[elt.id] = item[i]
+        bodies = stmt.body if isinstance(stmt.body, list) else [stmt.body]
+        breaked = False
+        for body in bodies:
+          # Catch any breaks or continues and handle inside the loop normally.
+          try:
+            value = self._eval_statement(body, ctx=ctx)
+          except (LoopBreak, LoopContinue) as e:
+            breaked = isinstance(e, LoopBreak)
+            break
+        if breaked:
+          break
+      return None
+
+    if isinstance(stmt, ast.While):
+      while self._eval_statement(stmt.test, ctx=ctx):
+        bodies = stmt.body if isinstance(stmt.body, list) else [stmt.body]
+        breaked = False
+        for body in bodies:
+          # Catch any breaks or continues and handle inside the loop normally.
+          try:
+            value = self._eval_statement(body, ctx=ctx)
+          except (LoopBreak, LoopContinue) as e:
+            breaked = isinstance(e, LoopBreak)
+            break
+        if breaked:
+          break
+      return None
+
+    if isinstance(stmt, ast.ListComp):
+      # Like: [v.lora for name, v in node(19).inputs.items() if name.startswith('lora_')]
+      # Like: [v.lower() for v in lora_list]
+      # Like: [v for v in l if v.startswith('B')]
+      # Like: [v.lower() for v in l if v.startswith('B') or v.startswith('F')]
+      # ---
+      # Like: [l for n in nodes(re('Loras')).values() if (l := n.loras)]
+      final_list = []
+
+      gen_ctx = {**ctx}
+
+      generators = [*stmt.generators]
+
+      def handle_gen(generators: list[ast.comprehension]):
+        gen = generators.pop(0)
+        if isinstance(gen.target, ast.Name):
+          gen_ctx[gen.target.id] = None
+        elif isinstance(gen.target, ast.Tuple):  # dict, like `for k, v in d.entries()`
+          for elt in gen.target.elts:
+            gen_ctx[elt.id] = None
+        else:
+          raise ValueError('Na')
+
+        gen_iters = None
+        # A call, like my_dct.items(), or a named ctx list
+        if isinstance(gen.iter, ast.Call):
+          gen_iters = self._eval_statement(gen.iter, ctx=gen_ctx)
+        elif isinstance(gen.iter, (ast.Name, ast.Attribute, ast.List, ast.Tuple)):
+          gen_iters = self._eval_statement(gen.iter, ctx=gen_ctx)
+
+        if not isinstance(gen_iters, Iterable):
+          raise ValueError('No iteraors found for list comprehension')
+
+        for gen_iter in gen_iters:
+          if_ctx = {**gen_ctx}
+          if isinstance(gen.target, ast.Tuple):  # dict, like `for k, v in d.entries()`
+            for i, elt in enumerate(gen.target.elts):
+              if_ctx[elt.id] = gen_iter[i]
+          else:
+            if_ctx[gen.target.id] = gen_iter
+          good = True
+          for ifcall in gen.ifs:
+            if not self._eval_statement(ifcall, ctx=if_ctx):
+              good = False
+              break
+          if not good:
+            continue
+          gen_ctx.update(if_ctx)
+          if len(generators):
+            handle_gen(generators)
+          else:
+            final_list.append(self._eval_statement(stmt.elt, gen_ctx))
+        generators.insert(0, gen)
+
+      handle_gen(generators)
+      return final_list
+
+    if isinstance(stmt, ast.Call):
+      call = None
+      args = []
+      kwargs = {}
+      if isinstance(stmt.func, ast.Attribute):
+        call = self._eval_statement(stmt.func, prev_stmt=stmt, ctx=ctx)
+        if isinstance(call, tuple):
+          args.append(call[1])
+          call = call[0]
+        if not call:
+          raise ValueError(f'No call for ast.Call {stmt.func}')
+
+      name = ''
+      if isinstance(stmt.func, ast.Name):
+        name = stmt.func.id
+        if name in _BUILT_INS:
+          call = _BUILT_INS[name]
+
+      if isinstance(call, str) and call.startswith(_BUILTIN_FN_PREFIX):
+        fn = _get_built_in_fn_by_key(call)
+        call = fn.call
+        if isinstance(call, str):
+          call = getattr(self, call)
+        num_args = len(stmt.args)
+        if num_args < fn.args[0] or (fn.args[1] is not None and num_args > fn.args[1]):
+          toErr = " or more" if fn.args[1] is None else f" to {fn.args[1]}"
+          raise SyntaxError(f"Invalid function call: {fn.name} requires {fn.args[0]}{toErr} args")
+
+      if not call:
+        raise ValueError(f'No call for ast.Call {name}')
+
+      for arg in stmt.args:
+        args.append(self._eval_statement(arg, ctx=ctx))
+      for kwarg in stmt.keywords:
+        kwargs[kwarg.arg] = self._eval_statement(kwarg.value, ctx=ctx)
+      return call(*args, **kwargs)
+
+    if isinstance(stmt, ast.Compare):
+      l = self._eval_statement(stmt.left, ctx=ctx)
+      r = self._eval_statement(stmt.comparators[0], ctx=ctx)
+      if isinstance(stmt.ops[0], ast.Eq):
+        return 1 if l == r else 0
+      if isinstance(stmt.ops[0], ast.NotEq):
+        return 1 if l != r else 0
+      if isinstance(stmt.ops[0], ast.Gt):
+        return 1 if l > r else 0
+      if isinstance(stmt.ops[0], ast.GtE):
+        return 1 if l >= r else 0
+      if isinstance(stmt.ops[0], ast.Lt):
+        return 1 if l < r else 0
+      if isinstance(stmt.ops[0], ast.LtE):
+        return 1 if l <= r else 0
+      if isinstance(stmt.ops[0], ast.In):
+        return 1 if l in r else 0
+      if isinstance(stmt.ops[0], ast.Is):
+        return 1 if l is r else 0
+      if isinstance(stmt.ops[0], ast.IsNot):
+        return 1 if l is not r else 0
+      raise NotImplementedError("Operator " + stmt.ops[0].__class__.__name__ + " not supported.")
+
+    if isinstance(stmt, (ast.If, ast.IfExp)):
+      value = self._eval_statement(stmt.test, ctx=ctx)
+      if value:
+        # ast.If is a list, ast.IfExp is an object.
+        bodies = stmt.body if isinstance(stmt.body, list) else [stmt.body]
+        for body in bodies:
+          value = self._eval_statement(body, ctx=ctx)
+      elif stmt.orelse:
+        # ast.If is a list, ast.IfExp is an object. TBH, I don't know why the If is a list, it's
+        # only ever one item AFAICT.
+        orelses = stmt.orelse if isinstance(stmt.orelse, list) else [stmt.orelse]
+        for orelse in orelses:
+          value = self._eval_statement(orelse, ctx=ctx)
+      return value
+
+    # Assign a variable and add it to our ctx.
+    if isinstance(stmt, (ast.Assign, ast.AugAssign)):
+      if isinstance(stmt, ast.AugAssign):
+        left = self._eval_statement(stmt.target, ctx=ctx)
+        right = self._eval_statement(stmt.value, ctx=ctx)
+        value = _OPERATORS[type(stmt.op)](left, right)
+        target = stmt.target
+      else:
+        value = self._eval_statement(stmt.value, ctx=ctx)
+        if len(stmt.targets) != 1:
+          raise ValueError('Expected length of assign targets to be 1')
+        target = stmt.targets[0]
+
+      if isinstance(target, ast.Tuple):  # like `a, z = (1,2)` (ast.Assign only)
+        for i, elt in enumerate(target.elts):
+          ctx[elt.id] = value[i]
+      elif isinstance(target, ast.Name):  # like `a = 1``
+        ctx[target.id] = value
+      elif isinstance(target, ast.Subscript) and isinstance(target.value, ast.Name):  # `a[0] = 1`
+        ctx[target.value.id][self._eval_statement(target.slice, ctx=ctx)] = value
+      else:
+        raise ValueError('Unhandled target type for Assign.')
+      return value
+
+    # For assigning a var in a list comprehension.
+    # Like [name for node in node_list if (name := node.name)]
+    if isinstance(stmt, ast.NamedExpr):
+      value = self._eval_statement(stmt.value, ctx=ctx)
+      ctx[stmt.target.id] = value
+      return value
+
+    if isinstance(stmt, ast.Return):
+      if stmt.value is None:
+        value = None
+      else:
+        value = self._eval_statement(stmt.value, ctx=ctx)
+      # Mark that we have a return value, as we may be deeper in evaluation, like going through an
+      # if condition's body.
+      ctx['__returned__'] = value
+      return value
+
+    # Raise an error for break or continue, which should be caught and handled inside of loops,
+    # otherwise the error will be raised (which is desired when used outside of a loop).
+    if isinstance(stmt, ast.Break):
+      raise LoopBreak()
+    if isinstance(stmt, ast.Continue):
+      raise LoopContinue()
+
+    # Literally nothing.
+    if isinstance(stmt, ast.Pass):
+      return None
+
+    raise TypeError(stmt)