diff --git a/CHANGELOG.md b/CHANGELOG.md index 8e68e6caf..d25d0ed96 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,62 @@ history. ### Added +- `comfy knowledge resolve` suggests canonical model ids for an incomplete + family/version name such as `Qwen 2.1`. The command still fails with + `knowledge_unknown_model` and exit 1, but `error.details.candidate_ids` lists + up to five sorted, distinct ids whose id or alias has the same family word + and the same numeric components in order, and the hint names them and asks + which model is intended before retrying `comfy knowledge resolve `. + A single candidate is still only a suggestion: nothing is auto-resolved, + downloaded or run. Substituted family words, different versions and names + with non-ASCII letters or digits get no candidates. Exact id and alias + resolution, `close_matches` and the hint for a name with no candidates are + unchanged. + +- `comfy model upload` previews an import into the standard environment and + uploads only the approved file digest to the approved workspace. It verifies + model-folder capabilities, collisions and returned content identity, and sends + a private snapshot of the approved bytes. + +- Read-only `comfy deploy ui` and `comfy workflow ui` return editor links only + after checking the workspace, supported capability and exact saved target. + Workflow links require a matching normal saved document and explicitly select + the requested standard or custom environment. Canvas validation follows the + frontend schemas and WHATWG URL semantics for model metadata. + +- A `comfy-run-on-cloud` skill, installed by default, takes one local workflow + onto Comfy Cloud. It checks Comfy Cloud's standard environment with the + original dependencies, including supported user model/LoRA uploads, then + reuses a compatible existing custom environment (a workspace Build) before + considering conversion. Lossless conversions (the same file in another folder, + removing memory- or speed-only nodes, exact core equivalents) happen without + asking; a lossy one (a different model, LoRA, upscaler or implementation) + needs the user's yes, with a custom environment offered as the exact alternative and + its costs stated. It pre-flights every converted copy on the server, asks once + per file before uploading models or inputs from disk on every route, and + verifies a real job on the selected target before handoff. It asks before freeing + a release, Build or deployment slot only when the planned operation needs it. + Its reference skill `comfy-run-on-cloud-local-install` covers finding the install behind a + workflow, Comfy Desktop's split layout included. + +- `comfy build inventory ` (hidden while the skill above is its only + caller) reports what one workflow loads: active classes and the packs and + versions it recorded, model values with their subfolders, `embedding:` + references, input files, muted and bypassed nodes, and loaders that pull + weights no widget names. `--models-root` (repeatable), `--desktop` and + `--hash` find each model on disk; `--input-root` hashes each input file to the + name Cloud stores an upload of it under; `--server` joins a running ComfyUI's + classes. `--cloud` reports `covered`, `covered_after_lossless_fixes` (folder + remaps with a ready `set_widget`, removable memory-only nodes), + `covered_needs_check` or `needs_build_or_lossy_conversion`, compares each + local model's size with Cloud's same-named file (`weights: different_size` is + a different model; matching sizes still require identity verification), and + says whether each input is already on Cloud. Only active subgraph instances + contribute dependencies, each model use is checked against its loader, and + ambiguous input basenames are not guessed. API inventories include the exact + deployment asset-upload plan, including custom-node file inputs, so approvals + can cover every file before a smoke run. + - `comfy assets library upload --type ` puts a `.safetensors` model file of up to 2 GB into your Comfy Cloud workspace's model library, e.g. `comfy assets library upload my_style.safetensors --type loras`. The @@ -34,17 +90,6 @@ history. `asset_upload_refused`; new codes `asset_upload_invalid`, `asset_upload_failed` and `asset_upload_timeout` cover the other ways it can end. -- `comfy knowledge resolve` suggests canonical model ids for an incomplete - family/version name such as `Qwen 2.1`. The command still fails with - `knowledge_unknown_model` and exit 1, but `error.details.candidate_ids` lists - up to five sorted, distinct ids whose id or alias has the same family word - and the same numeric components in order, and the hint names them and asks - which model is intended before retrying `comfy knowledge resolve `. - A single candidate is still only a suggestion: nothing is auto-resolved, - downloaded or run. Substituted family words, different versions and names - with non-ASCII letters or digits get no candidates. Exact id and alias - resolution, `close_matches` and the hint for a name with no candidates are - unchanged. ### Changed @@ -60,9 +105,74 @@ history. ### Fixed -- `comfy assets library ls` reports a 401 or 403 as `cloud_unauthorized` even - when the server drops the connection partway through its error body, instead - of crashing with `IncompleteRead`. +- Run-on-Cloud inventories resolve the selected Desktop instance's effective + paths, retain uncertain dependencies, distinguish runtime inputs from model + coverage, and report missing or conflicting model identity. Verified private + models now pass Cloud model-enum preflight without relaxing other validation. + +- Run-on-Cloud guidance reuses compatible Builds before conversion, binds file + approval to the reviewed bytes and destination, and stops build repair when + the proposed package has no verified installation mechanism. The installed + wheel now includes the skill's prompt template. + +- Successful previews using bundled ffmpeg no longer report a false trust error. + Cloud asset listings encode multiple tags using the server's supported query + format, and CLI subprocess tests isolate their credential stores. + +- Desktop discovery reads both modern and legacy registries. Callers with + running-server launch metadata select that exact instance, resolve its model + YAML and effective data/input/output paths, and keep ambiguous or relative + runtime identities unresolved. The optional discovery fields are documented + in the which/env schemas; unrelated launch arguments are excluded. + +- Parallel build and deploy requests rejected on an old access token now adopt + a peer's refreshed token under the shared refresh lock instead of rotating it + again. Each rejected request retries at most once. If session recovery still + fails while a refreshable sign-in remains stored, the watch reports that the + remote work may continue instead of telling you to sign in again. + `comfy build release create --watch`, `comfy deploy up`, `promote`, + `rollback` and `comfy deploy status --watch` now end with the new code + `watch_auth_lost` and exit code 75, as `deploy_watch_lost` does. Its hint + names the command that reads the release or deployment again. A 401 before + anything was accepted, on a workspace API key, or when no refreshable sign-in + remains still reports `build_not_signed_in` or `deploy_not_signed_in`. + +- `comfy build push --dry-run` now runs the push's registry-pin check, so a + pin the builder cannot place fails the dry run with the push's own + `build_registry_pin_missing` error instead of passing it. A version the + registry has Flagged was the common case: the dry run passed, and the push + was refused only after the plan had been disclosed. The check asks the + builder's snapshot importer to place each public pack, a read that writes + nothing, and the dry run still uploads and saves nothing. A spec that pins + a public pack now needs sign-in for its dry run (`build_not_signed_in` + otherwise); a spec whose packs are all local still sends no request. + +- `comfy workflow save --where cloud` saves the workflow where the Cloud + Workflows sidebar lists it, as `workflows/.json`, so it shows there and + opens from it. It used to create only an `/api/workflows` record, which the + sidebar never shows. Cloud keeps a record for the file, and `workflow_id` and + `latest_version` are read back from it by name; when exactly one record by + that name with matching content can't be read back they are null, with a + `workflow_record_unresolved` warning, and the save still succeeds. `--json` + also carries `filename`, `size` and `modified`. `saved_file_id` identifies + the actual userdata file, separately from `workflow_id`; it is null with + `saved_file_identity_unavailable` when the server write receipt cannot + certify it. A same-name save replaces the + workflow, as the Cloud editor's Save does, where it used to add a second + record with the same name; the new `--no-overwrite` refuses it with + `workflow_exists` instead, on both routes. On Cloud `--description` is now + ignored with a `description_ignored` warning, since the file has no + description field. A save named `.index.json`, the folder's favorites file, + is refused, as are Cloud dotfiles or hidden folders that the sidebar never + lists. Cloud deletion now removes the sidebar file as well as its record; + ambiguous same-name records are refused before deletion, and partial cleanup + reports `workflow_delete_incomplete` with the file's deletion state. + +- `comfy which` and `comfy env` report Desktop's split code, data and model + roots without changing launch/install selection. A nonexistent selected + workspace no longer succeeds in `which`; discovery reports malformed Desktop + configuration and marks inferred data roots as unverified. + - A typed `comfy model download` with no `--relative-path` now saves into the folder the running local ComfyUI scans for that model type, and says where. On Comfy Desktop that is the shared library, not the install's `models/`. @@ -112,6 +222,10 @@ history. value. Saves with a real marker have one more value than sockets and still go through the filter. +- `comfy assets library ls` reports a 401 or 403 as `cloud_unauthorized` even + when the server drops the connection partway through its error body, instead + of crashing with `IncompleteRead`. + ## [1.24.0] - 2026-10-29 [Full notes](https://github.com/Comfy-Org/comfy-cli/releases/tag/v1.24.0) · 25 commits since v1.23.0. diff --git a/comfy_cli/agent/command.py b/comfy_cli/agent/command.py index f24c25b69..4b4a6b428 100644 --- a/comfy_cli/agent/command.py +++ b/comfy_cli/agent/command.py @@ -113,7 +113,7 @@ def _cli_invocation() -> str: path that answered "Access is denied". """ argv0 = Path(sys.argv[0] or "") - if argv0.name == "__main__.py": + if argv0.name == "__main__.py" and argv0.parent.name == "comfy_cli": return f"{Path(sys.executable).name} -m comfy_cli" name = argv0.name[:-4] if argv0.name.lower().endswith(".exe") else argv0.name return name if name in _CLI_NAMES else "comfy" diff --git a/comfy_cli/builder_api.py b/comfy_cli/builder_api.py index 6bad57a92..1d7cd0ea4 100644 --- a/comfy_cli/builder_api.py +++ b/comfy_cli/builder_api.py @@ -137,6 +137,7 @@ def __init__( # handed a token (COMFY_BUILDER_TOKEN, COMFY_CLOUD_AUTH_TOKEN) or a key keeps # it and lets a 401 surface. self._refreshes_on_401 = False + self._sign_in_base_url: str | None = None # What to replace once the builder refuses this client's credential. self._refused_hint = ( credentials.refused_key_hint(api_key) @@ -175,9 +176,15 @@ def from_session(cls, base_url: str) -> BuilderClient: raise BuilderAuthError("not signed in: run `comfy cloud login` or set COMFY_CLOUD_API_KEY") client = cls(base_url, session.access_token) client._refreshes_on_401 = True + client._sign_in_base_url = session.base_url client._refused_hint = "run `comfy cloud login` first" return client + @property + def sign_in_base_url(self) -> str | None: + """The environment of the stored sign-in this client's token came from; None for a key or a handed token.""" + return self._sign_in_base_url if self._refreshes_on_401 else None + def _send(self, url: str, **kwargs) -> tuple[int, dict | list | None]: """Every builder request goes through here, so a long wait survives its token expiring. diff --git a/comfy_cli/cloud/oauth.py b/comfy_cli/cloud/oauth.py index cb6029c62..68e4f7ed2 100644 --- a/comfy_cli/cloud/oauth.py +++ b/comfy_cli/cloud/oauth.py @@ -782,6 +782,7 @@ def ensure_fresh_session( force: bool = False, allow_clear: bool = True, expect: Callable[[CloudSession], bool] | None = None, + rejected_access_token: str | None = None, ): """Return the stored cloud session, refreshing it first when the access token is expired (or within ``leeway_s`` of expiring) and a refresh token @@ -803,6 +804,10 @@ def ensure_fresh_session( ``expires_at`` recorded — still thinks it is valid. The refresh token is still required; without one this is a no-op. + ``rejected_access_token`` identifies the token that received the 401. If a + peer already replaced it, adopt that session instead of refreshing again. + This also covers a late 401 that arrives after the peer released the lock. + ``allow_clear=False`` keeps the stored session on disk even when a refresh hits a fatal token error (reuse-detection / ``invalid_grant``). Background, read-mostly callers (the detached ``comfy run`` watcher) pass this so a @@ -855,6 +860,7 @@ def ensure_fresh_session( force=force, allow_clear=allow_clear, expect=expect, + rejected_access_token=rejected_access_token, ) except TimeoutError: # A peer has held the lock longer than a refresh should take. Don't @@ -875,6 +881,7 @@ def _locked_refresh( force: bool, allow_clear: bool = True, expect: Callable[[CloudSession], bool] | None = None, + rejected_access_token: str | None = None, ): """Decide → POST → persist, executed while holding the secrets lock. @@ -890,11 +897,25 @@ def _locked_refresh( if session is None or not session.refresh_token: return session + # The rejected request may have been in flight while a peer finished its + # refresh, before even our first store read. Don't rotate that peer's token + # again just because this client's older request was refused. + if ( + rejected_access_token is not None + and session.access_token != rejected_access_token + and session.expires_at is not None + and not session.is_expired(leeway_s=leeway_s) + ): + return session + # Double-check after acquiring the lock. A peer may have refreshed while we # blocked: if the stored refresh token rotated away from what we observed # before locking, the family already advanced — use it, never re-send the # consumed token (that is exactly what trips reuse-detection). - if session.refresh_token != observed_refresh_token: + # A usable reactive peer already returned above. Otherwise refresh its + # current family, never replaying the older token observed before locking. + # Ordinary proactive callers still coalesce on any peer rotation. + if session.refresh_token != observed_refresh_token and rejected_access_token is None: return session if not force and not session.is_expired(leeway_s=leeway_s): # Peer advanced the access token's expiry without us noticing a token diff --git a/comfy_cli/cloud_model_validation.py b/comfy_cli/cloud_model_validation.py new file mode 100644 index 000000000..30ef2abb7 --- /dev/null +++ b/comfy_cli/cloud_model_validation.py @@ -0,0 +1,150 @@ +"""Resolve only verified private-model enum drift against authenticated assets. + +The CQL engine stays pure and offline. Cloud callers may supplement a stale +static model enum with exact, accessible model records; an unavailable or +ambiguous lookup preserves the original validation diagnostics. +""" + +from __future__ import annotations + +import os +import re +import urllib.error +import urllib.parse + +from comfy_cli.http import ResponseTooLarge, request_json +from comfy_cli.target import resolve_target + +# Verified filename widgets from the frontend's MODEL_NODE_MAPPINGS. Do not +# generalize this to every combo widget or to id/preset/auto-loader widgets. +_MODEL_INPUTS = { + ("CheckpointLoaderSimple", "ckpt_name"): "checkpoints", + ("ImageOnlyCheckpointLoader", "ckpt_name"): "checkpoints", + ("LoraLoader", "lora_name"): "loras", + ("LoraLoaderModelOnly", "lora_name"): "loras", + ("VAELoader", "vae_name"): "vae", + ("ControlNetLoader", "control_net_name"): "controlnet", + ("UNETLoader", "unet_name"): "diffusion_models", + ("UpscaleModelLoader", "model_name"): "upscale_models", + ("StyleModelLoader", "style_model_name"): "style_models", + ("GLIGENLoader", "gligen_name"): "gligen", + ("CLIPVisionLoader", "clip_name"): "clip_vision", + ("CLIPLoader", "clip_name"): "text_encoders", + ("AudioEncoderLoader", "audio_encoder_name"): "audio_encoders", + ("ModelPatchLoader", "name"): "model_patches", + ("LatentUpscaleModelLoader", "model_name"): "latent_upscale_models", + ("IPAdapterModelLoader", "ipadapter_file"): "ipadapter", + ("WanVideoLoraSelect", "lora"): "loras", + ("LTXICLoRALoaderModelOnly", "lora_name"): "loras", +} +_MAX_ASSET_BYTES = 2 * 1024 * 1024 +_MAX_LOOKUPS = 16 + + +def _content_hash(value: object) -> str | None: + # Cloud has returned both algorithm-prefixed hashes and storage filenames. + match = re.fullmatch(r"(?:blake3:)?([a-f0-9]{64})(?:\.[A-Za-z0-9]+)?", value) if isinstance(value, str) else None + return "blake3:" + match[1] if match else None + + +def _lookup(target, folder: str, name: str) -> dict | None: + # A single tag is compatible across Cloud versions. Verify the required + # folder tag locally; do not depend on multi-tag query encoding. + query = urllib.parse.urlencode( + [ + ("include_tags", "models"), + ("include_public", "false"), + ("name_contains", name), + ("limit", 200), + ] + ) + status, body = request_json(target.url("assets") + "?" + query, target, max_bytes=_MAX_ASSET_BYTES, timeout=10) + if status != 200 or not isinstance(body, dict) or body.get("has_more") is not False: + return None + rows = body.get("assets") + if not isinstance(rows, list) or any(not isinstance(row, dict) for row in rows): + return None + # The service search is substring-based. Only an exact name or explicit + # server-provided loader_path can satisfy the workflow's unchanged value. + matches = [row for row in rows if row.get("name") == name or row.get("loader_path") == name] + if not matches: + return None + hashes = set() + for row in matches: + tags = row.get("tags") + digest = _content_hash(row.get("hash")) + if ( + not isinstance(row.get("id"), str) + or not row["id"].strip() + or not isinstance(tags, list) + or not all(isinstance(tag, str) for tag in tags) + or not {"models", folder}.issubset(tags) + or digest is None + or row.get("deleted_at") is not None + or row.get("deletedAt") is not None + or row.get("is_deleted") is True + ): + return None + hashes.add(digest) + if len(hashes) != 1: + return None + return {"asset_id": matches[0]["id"], "content_hash": hashes.pop(), "model_folder": folder} + + +def resolve_cloud_model_errors(validation: dict, workflow: dict, *, where: str | None, offline: bool = False) -> dict: + """Supplement only Cloud model-name enum errors; leave other findings intact. + + Explicit catalog files and the environment-pinned catalog retain a strict + no-network contract. No model value is substituted, and no asset is created. + """ + if where != "cloud" or offline or os.environ.get("COMFY_OBJECT_INFO_FILE"): + return validation + errors = validation.get("errors") + if not isinstance(errors, list): + return validation + candidates = [] + for index, error in enumerate(errors): + if not isinstance(error, dict) or error.get("code") != "unknown_enum_value": + continue + node_id, field = error.get("node_id"), error.get("field") + node = workflow.get(str(node_id)) + if not isinstance(node, dict) or not isinstance(field, str): + continue + folder = _MODEL_INPUTS.get((node.get("class_type"), field)) + inputs = node.get("inputs") + value = inputs.get(field) if isinstance(inputs, dict) else None + if folder and isinstance(value, str) and 0 < len(value) <= 1024 and not any(ord(c) < 32 for c in value): + candidates.append((index, error, folder, value)) + if not candidates: + return validation + try: + target = resolve_target(where="cloud", allow_clear=False) + if not target.is_cloud or not (target.auth_token or target.api_key): + return validation + verified, cache = {}, {} + for index, error, folder, value in candidates: + key = folder, value + if key not in cache: + if len(cache) >= _MAX_LOOKUPS: + continue + cache[key] = _lookup(target, folder, value) + evidence = cache[key] + if evidence is not None: + verified[index] = { + "node_id": error["node_id"], + "field": error["field"], + "code": "cloud_model_asset_verified", + "message": f"{value!r} is an exact accessible Cloud model asset absent from the static enum", + **evidence, + } + except (OSError, ValueError, ResponseTooLarge): + return validation + if not verified: + return validation + remaining = [error for index, error in enumerate(errors) if index not in verified] + return { + **validation, + "valid": not remaining, + "errors": remaining, + "warnings": [*validation.get("warnings", []), *verified.values()], + } diff --git a/comfy_cli/cloud_workflow_schema.py b/comfy_cli/cloud_workflow_schema.py new file mode 100644 index 000000000..2774bf93e --- /dev/null +++ b/comfy_cli/cloud_workflow_schema.py @@ -0,0 +1,170 @@ +"""Matching frontend canvas schemas plus exact input-only refinement checks. + +The generated structural schemas remain byte-identical to their source export. +Runtime annotations restore refinements that Zod's JSON Schema export omits; +opaque workflow metadata and widget objects are never traversed as graph nodes. +""" + +from __future__ import annotations + +import functools +import json +import re +from importlib.resources import files + +from jsonschema import Draft202012Validator, FormatChecker + +_SAFE_INTEGER = 9007199254740991 +_JS_WHITESPACE = "\u0009\u000a\u000b\u000c\u000d\u0020\u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u2028\u2029\u202f\u205f\u3000\ufeff" +_REPO_ID = re.compile(r"[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?\Z", re.ASCII) +_GITHUB_USER = re.compile(r"(?!-)(?!.*--)[a-zA-Z0-9-]+(? bool: + if not isinstance(value, str): + return True # Existing integer schema enforces numeric safe-int bounds. + text = value.lstrip(_JS_WHITESPACE) + if text.startswith(("+", "-")): + text = text[1:] + if text.startswith(("0x", "0X")): + return re.match(r"[0-9a-fA-F]", text[2:]) is not None + # parseInt accepts a digit prefix even if it rounds/overflows to Infinity. + return re.match(r"[0-9]", text) is not None + + +def _repo_id(value) -> bool: + # Python regex '$' also accepts a trailing LF; the frontend's JS check + # does not. Fullmatch preserves the source predicate across engines. + return not isinstance(value, str) or (1 <= len(value) <= 100 and _REPO_ID.fullmatch(value) is not None) + + +def _aux_id(value) -> bool: + if not isinstance(value, str): + return True + parts = value.split("/") + return ( + len(parts) == 2 + and 1 <= len(parts[0]) <= 39 + and 1 <= len(parts[1]) <= 100 + and _GITHUB_USER.fullmatch(parts[0]) is not None + and _REPO_ID.fullmatch(parts[1]) is not None + ) + + +def _version(value) -> bool: + if not isinstance(value, str): + return True + if value == "unknown": + return True + stripped = value[1:] if value.startswith("v") else value + return _HASH.fullmatch(stripped) is not None or _SEMVER.fullmatch(stripped) is not None + + +def _link_id(value) -> bool: + if not isinstance(value, str) or re.fullmatch(r"(?:0|-?[1-9][0-9]*)", value) is None: + return False + if len(value.lstrip("-")) > 16: + return False + return abs(int(value)) <= _SAFE_INTEGER + + +def _guid(value) -> bool: + return ( + not isinstance(value, str) + or re.fullmatch(r"[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}", value) is not None + ) + + +def _uri(value) -> bool: + if not isinstance(value, str): + return True # The generated schema owns the string-type check. + try: + # Load native code only when a canvas actually declares a model URL. + from ada_url import URL + + # Browser URL() receives a USVString: merge valid UTF-16 pairs and + # replace lone surrogates with U+FFFD. Do not rewrite the stored graph. + scalar_value = value.encode("utf-16-le", "surrogatepass").decode("utf-16-le", "replace") + return URL.can_parse(scalar_value) # No base: relative references fail. + except (ImportError, OSError, ValueError): + return False + + +def _annotate(schema: dict) -> None: + if "$ref" in schema and (not isinstance(schema["$ref"], str) or not schema["$ref"].startswith("#")): + raise ValueError("Remote graph schema references are not permitted") + props = schema.get("properties") + if isinstance(props, dict): + for key in ("slot_index", "origin_slot", "target_slot"): + if isinstance(props.get(key), dict): + props[key]["format"] = "comfy-slot-index" + if isinstance(props.get("cnr_id"), dict): + props["cnr_id"]["format"] = "comfy-cnr-id" + if isinstance(props.get("aux_id"), dict): + props["aux_id"]["format"] = "comfy-aux-id" + if isinstance(props.get("ver"), dict): + props["ver"]["format"] = "comfy-pack-version" + presentation = props.get("linkPresentation") + if isinstance(presentation, dict) and isinstance(presentation.get("propertyNames"), dict): + presentation["propertyNames"]["format"] = "comfy-link-id" + links = props.get("links") + item = links.get("items") if isinstance(links, dict) else None + items = item.get("prefixItems") if isinstance(item, dict) else None + if isinstance(items, list) and len(items) == 6: + for index in (2, 4): + items[index]["format"] = "comfy-slot-index" + for value in schema.values(): + if isinstance(value, dict): + _annotate(value) + elif isinstance(value, list): + for item in value: + if isinstance(item, dict): + _annotate(item) + + +@functools.lru_cache(maxsize=2) +def _validator(version: str) -> Draft202012Validator: + schema = json.loads(files("comfy_cli.schemas").joinpath(f"cloud_workflow_{version}.json").read_text()) + _annotate(schema) + checker = FormatChecker() + checks = { + "uuid": _guid, + "uri": _uri, + "comfy-slot-index": _slot_index, + "comfy-cnr-id": _repo_id, + "comfy-aux-id": _aux_id, + "comfy-pack-version": _version, + "comfy-link-id": _link_id, + } + for name, check in checks.items(): + checker.checks(name, raises=(ValueError, TypeError))(check) + + def known_formats(item): + if isinstance(item, dict): + if "format" in item and item["format"] not in checks: + raise ValueError("Unsupported graph schema format") + for value in item.values(): + known_formats(value) + elif isinstance(item, list): + for value in item: + known_formats(value) + + known_formats(schema) + Draft202012Validator.check_schema(schema) + return Draft202012Validator(schema, format_checker=checker) + + +def is_supported_canvas(graph: object) -> bool: + """Whether the pinned frontend consumer accepts this JSON canvas input.""" + if not isinstance(graph, dict): + return False + try: + json.dumps(graph, allow_nan=False) + return _validator("1_0" if graph.get("version") == 1 else "0_4").is_valid(graph) + except (ValueError, TypeError, RecursionError, OSError): + return False diff --git a/comfy_cli/cmdline.py b/comfy_cli/cmdline.py index 7f71001ec..caadde0f6 100644 --- a/comfy_cli/cmdline.py +++ b/comfy_cli/cmdline.py @@ -2775,7 +2775,8 @@ def set_default( @tracking.track_command() def which(): renderer = get_renderer() - comfy_path = workspace_manager.workspace_path + workspace = workspace_manager.discovery_data() + comfy_path = workspace["path"] if comfy_path is None: renderer.error( code="not_in_workspace", @@ -2784,15 +2785,25 @@ def which(): ) raise typer.Exit(code=1) - workspace_type_value = ( - workspace_manager.workspace_type.value if workspace_manager.workspace_type is not None else None - ) + workspace_type_value = workspace["type"] + if not workspace["exists"]: + details = {"path": comfy_path, "workspace_type": workspace_type_value} + if "desktop" in workspace: + details["desktop"] = workspace["desktop"] + renderer.error( + code="workspace_not_found", + message=f"Workspace directory does not exist: {comfy_path}", + hint="run: comfy install (or pass --workspace /path/to/ComfyUI)", + details=details, + ) + raise typer.Exit(code=1) if renderer.is_pretty(): import sys as _sys from comfy_cli.env_checker import _display_url from comfy_cli.local_address import resolve_local_host_port from comfy_cli.output.panels import which_panel + from comfy_cli.output.sanitize import sanitize_value host, port = resolve_local_host_port(None, None, background=ConfigManager().background) try: @@ -2808,12 +2819,17 @@ def which(): server_running=server_running, server_url=_display_url(host, port), version=ConfigManager().get_cli_version(), + desktop=workspace.get("desktop"), ) ) + for warning in workspace.get("warnings", []): + renderer.console().print(sanitize_value(warning["message"]), markup=False) renderer.emit( { "workspace_path": str(comfy_path), "workspace_type": workspace_type_value, + "exists": workspace["exists"], + **{key: workspace[key] for key in ("desktop", "warnings") if key in workspace}, }, command="which", ) @@ -2893,6 +2909,9 @@ def env(): # JSON path: collect structured data without printing the table. data = EnvChecker().fill_data() data["workspace"] = workspace_manager.fill_data() + warnings = data["workspace"].pop("warnings", None) + if warnings: + data["warnings"] = warnings renderer.emit(data, command="env") diff --git a/comfy_cli/comfy_client.py b/comfy_cli/comfy_client.py index a5b9a2a76..9da94d86b 100644 --- a/comfy_cli/comfy_client.py +++ b/comfy_cli/comfy_client.py @@ -342,6 +342,14 @@ def _request( retry_after=_parse_retry_after(getattr(e, "headers", None)), ) from e + def get_current_workspace(self) -> Any: + """Read the authenticated Cloud workspace from the server.""" + return self._request("GET", ("workspaces", "current")) + + def list_workspace_deployments(self, workspace_id: str) -> Any: + """Read the server-gated editor deployment listing for one workspace.""" + return self._request("GET", ("workspaces", urllib.parse.quote(workspace_id, safe=""), "deployments")) + # ----- submit ----- def submit_prompt( diff --git a/comfy_cli/command/assets_library.py b/comfy_cli/command/assets_library.py index f522bf70b..2a2cbd6fa 100644 --- a/comfy_cli/command/assets_library.py +++ b/comfy_cli/command/assets_library.py @@ -155,10 +155,10 @@ def ls_cmd( params: list[tuple[str, Any]] = [("limit", min(max(limit, 1), 500))] if name: params.append(("name_contains", name)) - for t in tags.split(",") if tags else []: - t = t.strip() - if t: - params.append(("include_tags", t)) + tag_list = [tag.strip() for tag in tags.split(",") if tag.strip()] if tags else [] + if tag_list: + # Cloud declares this array `explode: false`; repeated keys are a 400. + params.append(("include_tags", ",".join(tag_list))) url = target.url("assets") + "?" + urllib.parse.urlencode(params) try: diff --git a/comfy_cli/command/build.py b/comfy_cli/command/build.py index 695a3df9e..93be028cd 100644 --- a/comfy_cli/command/build.py +++ b/comfy_cli/command/build.py @@ -101,6 +101,7 @@ ) from comfy_cli.command.pack_scan import read_pyproject from comfy_cli.constants import SUPPORTED_PT_EXTENSIONS +from comfy_cli.http import ResponseTooLarge from comfy_cli.interaction import confirm, require_option from comfy_cli.output import get_renderer from comfy_cli.registry.api import sanitize_error_body @@ -1879,6 +1880,37 @@ def _write_spec(renderer, path: Path, spec: dict) -> None: raise typer.Exit(code=1) from error +def _require_public_pins(renderer, client, public_nodes: list[dict], spec_file: Path) -> None: + """Ask the builder's importer to place every public pack, and refuse with + ``build_registry_pin_missing`` naming each identity it could not place: a + registry version it does not publish (a Flagged one among them), or a + repository it cannot normalize. + + The importer reads the snapshot and writes nothing, which is what lets + ``push --dry-run`` make the same call and refuse the same way. A lookup that + itself fails exits through ``_builder_call`` rather than passing the pins.""" + imported = _builder_call( + renderer, + lambda: client.resolve_snapshot(snapshot_from_definition({"customNodes": public_nodes})), + ) + checked = (imported.get("definition") or {}).get("customNodes") or [] + try: + missing = public_node_identities(public_nodes) - public_node_identities( + public_node_projection({"customNodes": checked}) + ) + except BuildSpecInvalidError as error: + renderer.error(code=error.code, message=str(error), details={"path": str(spec_file)}) + raise typer.Exit(code=1) from error + if missing: + labels = sorted(f"{identity.kind}:{identity.value}@{identity.version or '-'}" for identity in missing) + renderer.error( + code="build_registry_pin_missing", + message="the builder could not resolve these custom node identities: " + ", ".join(labels), + hint="edit the spec to name a published registry version or normalized repository, or remove the node", + ) + raise typer.Exit(code=1) + + @app.command("push", help="Push the local comfy-build spec to the builder.") @tracking.track_command("build") def push_cmd( @@ -1912,7 +1944,13 @@ def push_cmd( help="With --release, cut the release even though the save warned about a model link.", ), ] = False, - dry_run: Annotated[bool, typer.Option("--dry-run", help="Compute uploads locally; send no HTTP requests.")] = False, + dry_run: Annotated[ + bool, + typer.Option( + "--dry-run", + help="Compute uploads locally and check public custom node pins with the builder; upload and save nothing.", + ), + ] = False, models_dir: Annotated[ str | None, typer.Option("--models-dir", help="Models folder used to resolve model localPath values."), @@ -1927,7 +1965,7 @@ def push_cmd( if release and dry_run: renderer.error( code="build_missing_input", - message="--release cuts a release from a real push, and --dry-run sends nothing.", + message="--release cuts a release from a real push, and --dry-run saves nothing.", hint="drop --dry-run to cut the release, or drop --release to preview the push", details={"conflict": ["--release", "--dry-run"]}, ) @@ -2008,15 +2046,30 @@ def push_cmd( if reported: payload["skipped_symlinks"] = reported if dry_run: + # The pin check is the one question a dry run asks the builder: it is a + # read, it costs nothing, and it is the refusal a push otherwise meets + # only after the plan was disclosed. A spec without a public pin asks + # nothing, so it needs no sign-in. + public_nodes = public_node_projection(preparation.definition) + if public_nodes: + _require_public_pins(renderer, _builder_client(renderer, builder_url), public_nodes, paths.spec_file) # The envelope is the whole answer and prints nothing in pretty mode, so a # person gets the real push's opening line and word that nothing moved. # "Already held" is what the spec records; the builder, never asked, # may hold more. if renderer.is_pretty(): renderer.info(plan_line(len(uploads), payload["upload_bytes"], already_held_count(preparation))) - renderer.info( - "--dry-run: nothing was sent; the builder may already hold more of these than the spec records." - ) + if public_nodes: + count = len(public_nodes) + renderer.info(f"The builder resolved {count} public custom node pin{'' if count == 1 else 's'}.") + renderer.info( + "--dry-run: nothing was uploaded or saved; the builder may already hold more of these " + "than the spec records." + ) + else: + renderer.info( + "--dry-run: nothing was sent; the builder may already hold more of these than the spec records." + ) if _has_models(spec): renderer.info(f"--dry-run reads no folder list from the builder, so {_FOLDER_CASE_UNCHECKED}.") renderer.emit(payload, command="build push", changed=False) @@ -2033,26 +2086,7 @@ def push_cmd( public_nodes = public_node_projection(preparation.definition) if public_nodes: - imported = _builder_call( - renderer, - lambda: client.resolve_snapshot(snapshot_from_definition({"customNodes": public_nodes})), - ) - checked = (imported.get("definition") or {}).get("customNodes") or [] - try: - missing = public_node_identities(public_nodes) - public_node_identities( - public_node_projection({"customNodes": checked}) - ) - except BuildSpecInvalidError as error: - renderer.error(code=error.code, message=str(error), details={"path": str(paths.spec_file)}) - raise typer.Exit(code=1) from error - if missing: - labels = sorted(f"{identity.kind}:{identity.value}@{identity.version or '-'}" for identity in missing) - renderer.error( - code="build_registry_pin_missing", - message="the builder could not resolve these custom node identities: " + ", ".join(labels), - hint="edit the spec to name a published registry version or normalized repository, or remove the node", - ) - raise typer.Exit(code=1) + _require_public_pins(renderer, client, public_nodes, paths.spec_file) # Said before the first byte moves, and said even when nothing will: a # multi-GB upload is otherwise silent until it ends, and "0 files" is @@ -3139,6 +3173,40 @@ def _selected_release_id(renderer, client, scope: _BuildScope, release: str | No return _newest_release_id(renderer, client, _resolve_build_id(renderer, client, scope)) +#: The exit a watch that lost its sign-in ends with, as `comfy deploy`'s watches do +#: (``deploy_runtime.EXIT_WATCH_LOST``): only the watch ended, so it must not exit 1, +#: which says the release failed. 75 is EX_TEMPFAIL in sysexits.h. +_EXIT_WATCH_LOST: Final = 75 + + +def _watched_release(renderer, client, release_id: str) -> dict: + """One read of a release this command has already cut. + + The builder accepted the cut with this sign-in, so a 401 session recovery did + not clear ends the watch while a refreshable sign-in remains stored. The + release may continue remotely. A key, a handed token, or a sign-in without + a refresh token keeps ``build_not_signed_in``. + """ + from comfy_cli import credentials + from comfy_cli.builder_api import BuilderCredentialRefused + + try: + return client.get_release(release_id) + except BuilderCredentialRefused as error: + if not credentials.sign_in_still_stored(getattr(client, "sign_in_base_url", None)): + raise + renderer.error( + code="watch_auth_lost", + message=f"the builder refused the sign-in (401) after attempting session recovery; " + f"release {release_id} may still be building on the server", + hint=f"read it with `comfy build release show {release_id}` until its status is complete; " + "the stored sign-in was preserved", + details={"releaseId": release_id}, + exit_code=_EXIT_WATCH_LOST, + ) + raise typer.Exit(code=_EXIT_WATCH_LOST) from error + + def _poll_call(renderer, fn, usable=None): """``_builder_call`` for one poll of a watch, which a single timed-out or dropped request must not end: the release keeps building either way. A @@ -3196,7 +3264,7 @@ def _poll_status(renderer, client, release_id: str) -> dict: word and ends the watch at the caller.""" return _poll_call( renderer, - lambda: client.get_release(release_id), + lambda: _watched_release(renderer, client, release_id), usable=lambda release: isinstance(release, dict) and isinstance(release.get("status"), str), ) @@ -3506,6 +3574,311 @@ def validate_cmd( renderer.emit(result, command="build validate") +def _inventory_fetch_json(url: str) -> Any: + from comfy_cli.local_server_identity import fetch_json + + return fetch_json(url).data + + +def _inventory_fetch_server_stats(url: str) -> tuple[dict[str, Any], bool]: + from comfy_cli.local_server_identity import fetch_json + + document = fetch_json(url, verify_filesystem=True) + if not isinstance(document.data, dict): + raise ValueError("/system_stats did not return an object") + return document.data, document.filesystem_verified + + +def _inventory_local_server(report: dict[str, Any], server: str, stats: dict[str, Any] | None = None) -> dict[str, Any]: + from comfy_cli.local_address import parse_local_url + from comfy_cli.workflow_inventory import join_server + + host, port = parse_local_url(server) + netloc = f"[{host}]" if ":" in host else host + base = f"http://{netloc}:{port or 8188}" + section: dict[str, Any] = {"server": base} + try: + stats = stats if stats is not None else _inventory_fetch_json(f"{base}/system_stats") + object_info = _inventory_fetch_json(f"{base}/object_info") + if not isinstance(stats, dict) or not isinstance(object_info, dict): + raise ValueError("server stats and object_info must be objects") + if stats.get("system") is not None and not isinstance(stats["system"], dict): + raise ValueError("server stats.system must be an object") + except (OSError, ValueError, ResponseTooLarge) as error: + # The server only adds detail; the workflow's own report stands without it. + section["error"] = f"{type(error).__name__}: {error}" + return section + section.update(join_server(report, object_info, stats)) + from comfy_cli.desktop_install import server_launch_paths + + paths = server_launch_paths(stats) + if paths: + section["launch_paths"] = paths + return section + + +def _inventory_cloud_model_size(target: Any, name: str) -> int | None: + """Byte size of Cloud's model file with exactly this name, or None when it can't be read.""" + import urllib.parse + + from comfy_cli.command.models.search import _http_get_json + + query = urllib.parse.urlencode({"include_tags": "models", "name_contains": name, "limit": 200}) + try: + body = _http_get_json(target.url("assets") + "?" + query, target) + except (OSError, ValueError, ResponseTooLarge): + return None + assets = body.get("assets") if isinstance(body, dict) else None + for asset in assets or []: + if isinstance(asset, dict) and name in (asset.get("name"), asset.get("display_name")): + size = asset.get("size") + return size if isinstance(size, int) else None + return None + + +def _check_server_option(value: str | None) -> str | None: + """Reject a malformed ``--server`` at parse time, so nothing runs on a typo.""" + from comfy_cli.local_address import parse_local_url + + if value is not None: + try: + parse_local_url(value) + except ValueError as error: + raise typer.BadParameter(f"{error}; pass e.g. http://127.0.0.1:8000") from error + return value + + +def _desktop_model_roots( + server_stats: dict[str, Any] | None = None, *, server_filesystem_verified: bool = False +) -> tuple[list[str], str | None]: + from comfy_cli import desktop_install + + found = desktop_install.detect(server_stats=server_stats, server_filesystem_verified=server_filesystem_verified) + if found is not None: + if found.selected is None or (server_stats is None and sum(item.exists for item in found.installs) > 1): + return [], "--desktop: select the actual install with --server or explicit --models-root; " + "; ".join( + found.problems + ) + return [root.path for root in found.selected.model_roots], "; ".join(found.problems) or None + # Earlier Desktop releases keep only settings.json. Never combine libraries + # from different app registries or infer that one belongs to a supplied server. + candidates = list(desktop_install.app_data_dirs()) + settings = list(dict.fromkeys(path / "settings.json" for path in candidates if (path / "settings.json").is_file())) + if len(settings) != 1 or server_stats is not None: + return [], "--desktop: cannot identify one Desktop model library; pass each verified folder with --models-root" + try: + dirs = json.loads(settings[0].read_text(encoding="utf-8")).get("modelsDirs") + except (OSError, ValueError, AttributeError) as error: + return [], f"--desktop: could not read {settings[0]}: {error}" + if dirs is not None and not isinstance(dirs, list): + return [], f"--desktop: {settings[0]}: modelsDirs must be a list; pass each verified folder with --models-root" + return desktop_install._str_list(dirs), None + + +@app.command( + "inventory", + hidden=True, + help=( + "Report what one workflow loads (classes, models with subfolders, embeddings, input files, recorded " + "pack versions), which of those files are on this machine, and whether Comfy Cloud's standard " + "environment already runs it. Read-only; reads the Cloud node catalog only with --cloud." + ), +) +@tracking.track_command("build") +def inventory_cmd( + workflow: Annotated[str, typer.Argument(help="Workflow JSON, UI or API format.")], + cloud: Annotated[ + bool, + typer.Option( + "--cloud", help="Check the workflow against Comfy Cloud's standard-environment node catalog. Needs sign-in." + ), + ] = False, + server: Annotated[ + str | None, + typer.Option( + "--server", + show_default=False, + callback=_check_server_option, + help="A running local ComfyUI, e.g. http://127.0.0.1:8000 (Comfy Desktop) or 127.0.0.1:8188.", + ), + ] = None, + models_root: Annotated[ + list[str] | None, + typer.Option("--models-root", show_default=False, help="A models folder to search. Repeatable."), + ] = None, + desktop: Annotated[ + bool, + typer.Option( + "--desktop", + help="Search the selected Desktop install and model library. Use --server to identify a running instance.", + ), + ] = False, + hash_files: Annotated[ + bool, + typer.Option("--hash", help="sha256 every local match, to compare against public sources. Slow on big files."), + ] = False, + input_root: Annotated[ + list[str] | None, + typer.Option( + "--input-root", + show_default=False, + help="A ComfyUI input folder. Repeatable. Each input file found is hashed to the name Cloud stores it under.", + ), + ] = None, +): + from comfy_cli.hashing import blake3_file + from comfy_cli.workflow_inventory import inventory, join_cloud, join_inputs, join_local + + renderer = get_renderer() + path = Path(workflow).expanduser() + try: + data = json.loads(path.read_text(encoding="utf-8")) + except OSError as error: + renderer.error( + code="workflow_not_found", + message=f"Could not read {path}: {error.strerror or error}", + hint="check the path", + details={"path": str(path)}, + ) + raise typer.Exit(code=1) from error + except ValueError as error: + renderer.error( + code="workflow_invalid_json", + message=f"{path} is not valid JSON: {error}", + hint="save the workflow again from ComfyUI (Workflow > Save, or Export)", + details={"path": str(path)}, + ) + raise typer.Exit(code=1) from error + if not isinstance(data, dict): + renderer.error( + code="workflow_invalid_json", + message=f"{path} holds a JSON {type(data).__name__}, not a workflow object.", + hint="pass a workflow saved from ComfyUI (UI format) or an API export", + details={"path": str(path)}, + ) + raise typer.Exit(code=1) + + try: + report = inventory(data) + except ValueError as error: + renderer.error( + code="workflow_invalid_json", + message=f"{path} is not a valid workflow: {error}", + hint="pass a workflow saved from ComfyUI (UI format) or an API export", + details={"path": str(path)}, + ) + raise typer.Exit(code=1) from error + report["workflow"] = str(path) + roots = list(models_root or []) + inputs = list(input_root or []) + outputs: list[str] = [] + server_stats = None + server_filesystem_verified = False + if desktop: + from comfy_cli import desktop_install + + if server: + from comfy_cli.local_address import parse_local_url + + host, port = parse_local_url(server) + netloc = f"[{host}]" if ":" in host else host + try: + server_stats, server_filesystem_verified = _inventory_fetch_server_stats( + f"http://{netloc}:{port or 8188}/system_stats" + ) + except (OSError, ValueError, ResponseTooLarge) as error: + report["warnings"].append(f"--desktop: cannot verify running server: {error}; pass explicit roots") + # A supplied but unreachable server must not fall back to an unrelated install. + desktop_roots, warning = _desktop_model_roots( + server_stats if server_stats is not None else ({} if server else None), + server_filesystem_verified=server_filesystem_verified, + ) + roots += [r for r in desktop_roots if r not in roots] + if warning: + report["warnings"].append(warning) + found = desktop_install.detect( + server_stats=server_stats if server_stats is not None else ({} if server else None), + server_filesystem_verified=server_filesystem_verified, + ) + if found is not None: + report["desktop"] = found.to_dict() + if found.selected is not None and desktop_roots: + if not input_root: + inputs = [found.input_dir or str(Path(found.selected.data_dir) / "input")] + if found.output_dir is not None: + outputs = [found.output_dir] + for kind, paths in (("models", roots), ("input", inputs), ("output", outputs)): + for root in paths: + if not Path(root).expanduser().is_dir(): + report["warnings"].append(f"root_not_found: {kind} root is not a directory: {root}") + # Local files first: the Cloud join compares their sizes with Cloud's same-named files. + if roots: + report["models_roots"] = roots + join_local(report, roots, hash_files=hash_files) + if inputs: + report["input_roots"] = inputs + join_inputs(report, inputs, lambda path: blake3_file(Path(path))) + if report["format"] == "api": + from comfy_cli.command.deploy_workflow import ( + DeployWorkflowAssetError, + resolve_asset_roots, + scan_workflow_inputs, + ) + + # Use the run command's scanner, not a loader allowlist: custom nodes + # can reference files too. Run from the same spec folder and pass the + # same --input-root directories as deploy run's --asset-root values. + asset_roots = resolve_asset_roots(extra_roots=tuple(Path(root) for root in (*inputs, *outputs))) + try: + plan = scan_workflow_inputs(data, asset_roots=asset_roots) + report["deployment_assets"] = [ + { + "local_path": str(asset.local_path), + "file_path": asset.file_path, + "bytes": asset.local_path.stat().st_size, + } + for asset in plan.assets + ] + except DeployWorkflowAssetError as error: + renderer.error(code=error.code, message=str(error), hint=error.hint, details=error.details) + raise typer.Exit(code=1) from error + report["deployment_asset_roots"] = [str(root) for root in asset_roots] + if cloud: + from comfy_cli.command.nodes import _get_graph + from comfy_cli.target import resolve_target + + graph = _get_graph(None, None, None, where="cloud") + target = resolve_target(where="cloud") + sizes: dict[str, int | None] = {} + + def lookup(class_type: str) -> Mapping[str, Any] | None: + node = graph.node(class_type) + return graph.morphism_to_dict(node) if node is not None else None + + def size_of(name: str) -> int | None: + if name not in sizes: + sizes[name] = _inventory_cloud_model_size(target, name) + return sizes[name] + + report["cloud"] = join_cloud(report, lookup, size_of if roots else None) + if server: + report["local_server"] = _inventory_local_server(report, server, server_stats) + + if renderer.is_pretty(): + renderer.print( + f"{len(report['classes'])} classes, {len(report['models'])} models, {len(report['inputs'])} inputs" + ) + if "cloud" in report: + blocking = ", ".join(report["cloud"]["blocking"]) or "nothing" + renderer.print(f"Comfy Cloud standard environment: {report['cloud']['verdict']} (blocking: {blocking})") + for model in report["models"]: + found = "" if "local" not in model else f" [{len(model['local'])} local]" + renderer.print(f" {model['path']} ({model['node']}){found}") + for warning in report["warnings"]: + renderer.warn(warning) + renderer.emit(report, command="build inventory") + + @app.command("delete", help="Delete a build (soft-delete).") @tracking.track_command("build") def delete_cmd( diff --git a/comfy_cli/command/build_validation.py b/comfy_cli/command/build_validation.py index 12ad58d3a..4c4d3ef34 100644 --- a/comfy_cli/command/build_validation.py +++ b/comfy_cli/command/build_validation.py @@ -204,7 +204,9 @@ def _validate_local_path(entry: JsonObject, context: LocalPathContext) -> None: case unreachable: assert_never(unreachable) if not correct_kind: - raise BuildSpecInvalidError(f"{context.location}.localPath must resolve to a {expected}: {local_path!r}") + raise BuildSpecInvalidError( + f"{context.location}.localPath must resolve to a {expected} under {context.root}: {local_path!r}" + ) def _validate_authoring_definition(definition: JsonObject, paths: BuildPaths) -> None: diff --git a/comfy_cli/command/deploy.py b/comfy_cli/command/deploy.py index f675d0d2c..3f2626976 100644 --- a/comfy_cli/command/deploy.py +++ b/comfy_cli/command/deploy.py @@ -18,6 +18,7 @@ from comfy_cli.command import deploy_rename as _deploy_rename from comfy_cli.command import deploy_rollback as _deploy_rollback from comfy_cli.command import deploy_run as _deploy_run +from comfy_cli.command import deploy_ui as _deploy_ui from comfy_cli.command.build_paths import BuildSpecNotFoundError from comfy_cli.command.build_spec import BuildSpecInvalidError, JsonObject from comfy_cli.command.deploy_compute import prompt_gpu as _prompt_gpu @@ -206,6 +207,12 @@ def ls_cmd( _deploy_ls.run_ls(_deploy_ls.ListRequest(path, include_deleted, workspace, status, limit)) +@app.command("ui", help="Print a verified authenticated Cloud editor URL for a ready deployment. Read-only.") +@tracking.track_command("deploy") +def ui_cmd(path: DeployPath = None, deployment_id: DeploymentOption = None) -> None: + _deploy_ui.run_ui(_deploy_read.ReadRequest(path, deployment_id)) + + @app.command("show", help="Show one deployment's raw control-plane record.") @tracking.track_command("deploy") def show_cmd(path: DeployPath = None, deployment_id: DeploymentOption = None) -> None: @@ -298,7 +305,7 @@ def _render_move_replaced(renderer, builder, error: MoveReplacedError) -> NoRetu renderer.error( code="deploy_update_replaced", message=replaced_message(error.deployment_id, error.release, replacing), - hint=f"run `comfy deploy status --deployment {error.deployment_id}` to see the update that replaced it", + hint=f"run `comfy deploy show --deployment {error.deployment_id}` to see the update that replaced it", details={ "deployment_id": error.deployment_id, "release_id": error.release["id"], diff --git a/comfy_cli/command/deploy_progress.py b/comfy_cli/command/deploy_progress.py index 519e5049c..89ad638ff 100644 --- a/comfy_cli/command/deploy_progress.py +++ b/comfy_cli/command/deploy_progress.py @@ -234,7 +234,7 @@ def live_line(progress: JsonObject, *, now: datetime) -> str: def reattach_hint(deployment_id: str) -> str: - return f"comfy deploy status --deployment {deployment_id} --watch" + return f"comfy deploy show --deployment {deployment_id}" class DeployWatchReporter: @@ -303,7 +303,8 @@ def interrupted(self) -> None: self.close() self._say( f"Stopped watching. Deployment {self._deployment_id} keeps coming up on our side.", - hint=f"run `{reattach_hint(self._deployment_id)}` to watch it again", + hint=f"run `{reattach_hint(self._deployment_id)}` to inspect it; watching requires " + f"`comfy deploy status --deployment {self._deployment_id} --watch` with this Build's spec", ) # ----- internals ----- diff --git a/comfy_cli/command/deploy_rollback.py b/comfy_cli/command/deploy_rollback.py index 0ea127468..900205eb8 100644 --- a/comfy_cli/command/deploy_rollback.py +++ b/comfy_cli/command/deploy_rollback.py @@ -104,7 +104,7 @@ def __init__(self, deployment_id: str, selector: str) -> None: ), "PENDING_UPDATE_EXISTS": ( "is waiting on an update, so the rollback was refused", - "wait until `comfy deploy status --deployment {id}` shows no update, then roll back", + "wait until `comfy deploy show --deployment {id}` shows no update, then roll back", ), "RELEASE_DELETED": ( "cannot go back to that release, because it was deleted", diff --git a/comfy_cli/command/deploy_runtime.py b/comfy_cli/command/deploy_runtime.py index 9f477cf51..7632a26d1 100644 --- a/comfy_cli/command/deploy_runtime.py +++ b/comfy_cli/command/deploy_runtime.py @@ -12,6 +12,7 @@ import typer from typing_extensions import assert_never +from comfy_cli import credentials from comfy_cli.builder_api import BuilderClient, BuilderCredentialRefused from comfy_cli.command.build import DEFAULT_BUILDER_URL from comfy_cli.command.build_paths import BuildSpecNotFoundError, resolve_build_paths @@ -121,6 +122,8 @@ def terminal_status_error(deployment_id: str, status: str) -> JsonObject: class DeployWatchLostError(Exception): """The deploy API left a watch's reads unanswered for the whole retry window.""" + code = "deploy_watch_lost" + def __init__(self, deployment_id: str, cause: Exception | None = None, *, message: str | None = None) -> None: super().__init__( message or f"the deploy API stopped answering while following deployment {deployment_id} ({cause})" @@ -128,6 +131,23 @@ def __init__(self, deployment_id: str, cause: Exception | None = None, *, messag self.deployment_id = deployment_id +class DeployWatchAuthLostError(DeployWatchLostError): + """The deploy API refused a watch's read while a refreshable sign-in remains stored. + + The client has already attempted shared session recovery and at most one + retry. The deployment may continue remotely, so it is the watch that ended. + """ + + code = "watch_auth_lost" + + def __init__(self, deployment_id: str) -> None: + super().__init__( + deployment_id, + message=f"the deploy API refused the sign-in (401) while following deployment {deployment_id}, " + "after attempting session recovery", + ) + + def _unanswered(error: Exception) -> bool: """A read the service never answered: a 5xx, or no response at all. @@ -139,12 +159,29 @@ def _unanswered(error: Exception) -> bool: return error.code == "deploy_server_error" and (error.status is None or error.status >= 500) +def _sign_in_refused(client: DeployUpClient, error: Exception) -> bool: + """A 401 on a watch's read, from a client whose refreshable sign-in remains. + + A key, a handed token, or a sign-in without a refresh token keeps the + sign-in code, because changing that credential is the fix. + """ + if not isinstance(error, DeployAPIError) or error.status != 401: + return False + return credentials.sign_in_still_stored(getattr(client, "sign_in_base_url", None)) + + def exit_watch_lost(renderer: Renderer, error: DeployWatchLostError, hint: str | None = None) -> NoReturn: """Say it is the watch that gave out, not the deployment, and how to pick it up again.""" + hint = hint or ( + f"run `{reattach_hint(error.deployment_id)}` to inspect it; watching requires " + f"`comfy deploy status --deployment {error.deployment_id} --watch` with this Build's spec" + ) + if isinstance(error, DeployWatchAuthLostError): + hint = f"{hint}; the stored sign-in was preserved" renderer.error( - code="deploy_watch_lost", + code=error.code, message=f"{error}; the deployment may still be coming up", - hint=hint or f"run `{reattach_hint(error.deployment_id)}` to watch it again", + hint=hint, details={"deployment_id": error.deployment_id}, exit_code=EXIT_WATCH_LOST, ) @@ -172,7 +209,9 @@ def poll_deployment( The progress a watcher shows rides the same read the loop already makes, so watching costs the service nothing it was not already answering. A read the service does not answer is retried, and the first of each run of them goes to - ``on_unanswered``; past the window this raises ``DeployWatchLostError``. + ``on_unanswered``; past the window this raises ``DeployWatchLostError``. A + 401 session recovery did not clear, with a refreshable sign-in still stored, + raises ``DeployWatchAuthLostError`` at once. """ failures, since, started = 0, 0.0, clock() while True: @@ -186,6 +225,8 @@ def poll_deployment( # The client maps a timeout, but a connection dropped before the status # line or partway through a 200's body escapes it unmapped. except (DeployAPIError, ConnectionError, http.client.HTTPException) as error: + if _sign_in_refused(client, error): + raise DeployWatchAuthLostError(deployment_id) from error if not _unanswered(error): raise if failures == 0: diff --git a/comfy_cli/command/deploy_ui.py b/comfy_cli/command/deploy_ui.py new file mode 100644 index 000000000..79883b2ff --- /dev/null +++ b/comfy_cli/command/deploy_ui.py @@ -0,0 +1,128 @@ +"""Read-only discovery of an authenticated deployment editor link.""" + +from __future__ import annotations + +import json +import re +import urllib.error +import urllib.parse +from collections.abc import Callable +from typing import Any + +from comfy_cli.comfy_client import Client, HTTPError, Unauthenticated +from comfy_cli.command.build_spec import JsonObject +from comfy_cli.command.deploy_read import DeploymentReadClient, ReadRequest, _run_read +from comfy_cli.command.deploy_resolve import BuilderReleaseClient, DeployResolveError +from comfy_cli.command.deploy_types import required_string +from comfy_cli.http import ResponseTooLarge +from comfy_cli.output.renderer import Renderer +from comfy_cli.target import Target, resolve_target + + +class EditorUnavailableError(DeployResolveError): + code = "deploy_ui_unavailable" + hint = "run `comfy cloud login`, verify the workspace and ready deployment, or use `comfy deploy run`" + + def __init__(self, message: str, *, status: int | None = None) -> None: + self.details: JsonObject = {"status": status} if status is not None else {} + super().__init__(message) + + +def _ready_release(deployment: JsonObject, deployment_id: str) -> str: + if ( + deployment.get("id") != deployment_id + or deployment.get("status") != "ready" + or deployment.get("deletedAt") is not None + ): + raise EditorUnavailableError("the selected deployment is not a verified ready target") + if "editor" in deployment and deployment["editor"] is not True: + raise EditorUnavailableError("the selected deployment's editor is disabled or could not be verified") + return required_string(deployment, "releaseId") + + +def _editor_origin(target: Target) -> urllib.parse.SplitResult: + if not target.auth_token or target.api_key: + raise EditorUnavailableError("opening a custom environment requires a signed-in Cloud session, not an API key") + origin = urllib.parse.urlsplit(target.base_url) + if origin.username is not None or origin.password is not None or not origin.hostname: + raise EditorUnavailableError("the configured Cloud origin is not a safe editor URL") + return origin + + +def _cloud_read(request: Callable[[], Any]) -> Any: + try: + return request() + except HTTPError as error: + try: + body = json.loads(error.body) + except ValueError: + body = None + reason = body.get("message") if isinstance(body, dict) else None + recognized = { + "listing deployments needs a signed-in session, not an API key", + "running Cloud on a Build is not enabled for this workspace yet", + "deployment picking is not available in this environment", + "Workspace not found", + "Authentication required", + } + message = ( + reason + if isinstance(reason, str) and reason in recognized + else "Cloud refused or could not verify editor access" + ) + raise EditorUnavailableError(f"{message} (HTTP {error.status})", status=error.status) from error + except Unauthenticated as error: + raise EditorUnavailableError("the Cloud sign-in could not be refreshed; run `comfy cloud login`") from error + except (ResponseTooLarge, urllib.error.URLError, OSError, ValueError) as error: + raise EditorUnavailableError("could not verify editor access with Cloud; no link was generated") from error + + +def verify_deployment_editor_target( + cloud: Client, *, workspace_id: str, deployment_id: str, deployment: JsonObject +) -> dict[str, str]: + """Verify one ready target against the authenticated workspace's editor listing; mutate nothing.""" + release_id = _ready_release(deployment, deployment_id) + origin = _editor_origin(cloud.target) + if not isinstance(workspace_id, str) or not re.fullmatch(r"[A-Za-z0-9_-]+", workspace_id): + raise EditorUnavailableError("Cloud did not identify the authenticated workspace") + listing = _cloud_read(lambda: cloud.list_workspace_deployments(workspace_id)) + rows = listing.get("items") if isinstance(listing, dict) else None + matches = ( + [row for row in rows if isinstance(row, dict) and row.get("deployment_id") == deployment_id] + if isinstance(rows, list) + else [] + ) + if len(matches) != 1 or matches[0].get("status") != "ready" or matches[0].get("release_id") != release_id: + raise EditorUnavailableError("Cloud did not confirm this workspace's ready deployment and served release") + url = urllib.parse.urlunsplit( + ( + origin.scheme, + origin.netloc, + "/", + urllib.parse.urlencode({"workspace": workspace_id, "deployment": deployment_id}), + "", + ) + ) + return {"workspaceId": workspace_id, "deploymentId": deployment_id, "releaseId": release_id, "url": url} + + +def _ui(renderer: Renderer, builder: BuilderReleaseClient, client: DeploymentReadClient, deployment_id: str) -> None: + deployment = client.get_deployment(deployment_id) + _ready_release(deployment, deployment_id) + target = resolve_target(where="cloud") + _editor_origin(target) + cloud = Client(target) + workspace = _cloud_read(cloud.get_current_workspace) + workspace_id = workspace.get("id") if isinstance(workspace, dict) else None + if not isinstance(workspace_id, str): + raise EditorUnavailableError("Cloud did not identify the authenticated workspace") + result = verify_deployment_editor_target( + cloud, workspace_id=workspace_id, deployment_id=deployment_id, deployment=deployment + ) + if renderer.is_pretty(): + renderer.print(result["url"]) + renderer.emit(result, command="deploy ui", changed=False) + + +def run_ui(request: ReadRequest) -> None: + _run_read(request, _ui) diff --git a/comfy_cli/command/deploy_up.py b/comfy_cli/command/deploy_up.py index f48fb5dfd..20ef40fe8 100644 --- a/comfy_cli/command/deploy_up.py +++ b/comfy_cli/command/deploy_up.py @@ -450,7 +450,7 @@ def refuse_unmovable(target: JsonObject, command: str = "up") -> None: "deploy_conflict", f"deployment {deployment_id} is {status}, so `{command}` will not move it to another release", details={"deploymentId": deployment_id, "status": status}, - hint=f"wait until `comfy deploy status --deployment {deployment_id}` shows it stopped, " + hint=f"wait until `comfy deploy show --deployment {deployment_id}` shows it stopped, " "running `comfy deploy stop` again if the stop failed", ) diff --git a/comfy_cli/command/models/models.py b/comfy_cli/command/models/models.py index be55c1e09..d50b1f73e 100644 --- a/comfy_cli/command/models/models.py +++ b/comfy_cli/command/models/models.py @@ -18,6 +18,7 @@ from comfy_cli import constants, download_state, tracking, ui from comfy_cli.command.models import search as models_search_command +from comfy_cli.command.models.upload import app as model_upload_app from comfy_cli.config_manager import ConfigManager from comfy_cli.constants import DEFAULT_COMFY_MODEL_PATH from comfy_cli.file_utils import ( @@ -2459,3 +2460,5 @@ def list_command( # setup on the whole noun would leak it onto those. app.registered_commands.extend(models_search_command.app.registered_commands) app.registered_groups.extend(models_search_command.app.registered_groups) + +app.registered_commands.extend(model_upload_app.registered_commands) diff --git a/comfy_cli/command/models/upload.py b/comfy_cli/command/models/upload.py new file mode 100644 index 000000000..7d9f401a5 --- /dev/null +++ b/comfy_cli/command/models/upload.py @@ -0,0 +1,322 @@ +"""Explicit, content-bound imports into the authenticated Cloud model library.""" + +from __future__ import annotations + +import hashlib +import json +import re +import tempfile +import urllib.error +import urllib.parse +import urllib.request +import uuid +from pathlib import Path +from typing import Annotated, BinaryIO + +import blake3 +import typer + +from comfy_cli import tracking +from comfy_cli.command.cloud_http import cloud_target_or_local_error +from comfy_cli.http import ResponseTooLarge, no_redirect_urlopen, read_capped, request_json, target_auth_headers +from comfy_cli.output import get_renderer +from comfy_cli.workflow_inventory import MODEL_EXTENSIONS + +app = typer.Typer() +_CHUNK_BYTES = 1024 * 1024 + + +def _content_hash(value) -> str | None: + # Older Cloud versions return the BLAKE3 storage filename, newer ones the + # algorithm-prefixed digest. Both forms describe the same asset bytes. + match = re.fullmatch(r"(?:blake3:)?([a-f0-9]{64})(?:\.[A-Za-z0-9]+)?", value) if isinstance(value, str) else None + return "blake3:" + match[1] if match else None + + +def _refuse(renderer, reason: str, message: str): + renderer.error( + code="model_upload_refused", + message=message, + hint="inspect `comfy model upload --help`; preview with --dry-run and approve the exact file and workspace", + details={"reason": reason, "uploaded": False}, + ) + raise typer.Exit(code=1) + + +class _Body: + def __init__(self, file: BinaryIO, prefix: bytes, suffix: bytes, size: int): + self.file, self.prefix, self.suffix, self.size = file, prefix, suffix, size + self.content_length = len(prefix) + size + len(suffix) + + def __iter__(self): + yield self.prefix + self.file.seek(0) + while chunk := self.file.read(_CHUNK_BYTES): + yield chunk + yield self.suffix + + +def _snapshot(source: Path, snapshot: BinaryIO) -> tuple[str, str, int]: + sha = hashlib.sha256() + content_hash = blake3.blake3() + size = 0 + with source.open("rb") as file: + while chunk := file.read(_CHUNK_BYTES): + snapshot.write(chunk) + sha.update(chunk) + content_hash.update(chunk) + size += len(chunk) + snapshot.seek(0) + return sha.hexdigest(), "blake3:" + content_hash.hexdigest(), size + + +def _request(target, file, size: int, name: str, model_type: str): + boundary = uuid.uuid4().hex + fields = {"tags": json.dumps(["models", model_type]), "name": name} + prefix = b"".join( + f'--{boundary}\r\nContent-Disposition: form-data; name="{key}"\r\n\r\n{value}\r\n'.encode() + for key, value in fields.items() + ) + prefix += ( + f'--{boundary}\r\nContent-Disposition: form-data; name="file"; filename="{name}"\r\n' + "Content-Type: application/octet-stream\r\n\r\n" + ).encode() + body = _Body(file, prefix, f"\r\n--{boundary}--\r\n".encode(), size) + request = urllib.request.Request(target.url("assets"), data=body, method="POST") + request.add_header("Content-Type", f"multipart/form-data; boundary={boundary}") + request.add_header("Content-Length", str(body.content_length)) + for key, value in target_auth_headers(target).items(): + request.add_header(key, value) + return request + + +@app.command( + "upload", help="Import an approved local model into the standard Cloud model library; preview with --dry-run." +) +@tracking.track_command("model") +def upload_cmd( + file: Annotated[Path, typer.Argument(help="The exact local model file to import.")], + model_type: Annotated[ + str, typer.Option("--type", help="Exact model folder advertised by `model list-folders --where cloud`.") + ], + workspace: Annotated[ + str, + typer.Option( + "--workspace", help="Approved destination workspace ID; must match current authenticated workspace." + ), + ], + dry_run: Annotated[ + bool, typer.Option("--dry-run", help="Read capabilities and prepare a file plan; never upload.") + ] = False, + yes: Annotated[ + bool, typer.Option("--yes", help="Confirm approval for this named file, digest and destination.") + ] = False, + expected_sha256: Annotated[ + str | None, typer.Option("--expected-sha256", help="Approved file SHA256, required for an upload.") + ] = None, + name: Annotated[ + str | None, typer.Option("--name", help="Approved destination filename; defaults to the source basename.") + ] = None, + where: Annotated[str | None, typer.Option("--where")] = None, +): + renderer = get_renderer() + destination_name = name if name is not None else file.name + if ( + not destination_name + or any(c in destination_name for c in '/\\"\r\n\x00') + or destination_name in (".", "..") + or not destination_name.lower().endswith(MODEL_EXTENSIONS) + ): + _refuse(renderer, "invalid_name", "Use a model filename without directory or multipart framing characters.") + if not file.is_file(): + _refuse(renderer, "file_not_found", f"Model file not found: {file}") + if not dry_run and (not yes or not expected_sha256 or not re.fullmatch(r"[a-fA-F0-9]{64}", expected_sha256)): + _refuse(renderer, "approval_required", "Uploading requires --yes and the exact approved --expected-sha256.") + target = cloud_target_or_local_error(where, renderer) + try: + _, current = request_json(target.url("workspaces", "current"), target, max_bytes=1024 * 1024) + if not isinstance(current, dict) or current.get("id") != workspace: + _refuse( + renderer, "workspace_mismatch", "The approved workspace does not match the authenticated destination." + ) + _, features = request_json(target.url("features"), target, max_bytes=1024 * 1024) + if not isinstance(features, dict) or features.get("private_models_enabled") is not True: + _refuse( + renderer, "unavailable", "Private model import is unavailable or unverified for this account/workspace." + ) + _, folders = request_json(target.url("experiment", "models"), target, max_bytes=1024 * 1024) + names = ( + [item.get("name") if isinstance(item, dict) else item for item in folders] + if isinstance(folders, list) + else [] + ) + supported = {item for item in names if isinstance(item, str)} + if model_type not in supported or model_type.lower().strip() == "nlf": + _refuse( + renderer, + "unsupported_type", + f"The selected environment does not advertise a supported import folder: {model_type}", + ) + # Snapshot before comparing the approved digest. Upload only this private + # handle, so source edits during the network request cannot change bytes. + with tempfile.TemporaryFile(mode="w+b") as snapshot: + digest, content_hash, size = _snapshot(file, snapshot) + if expected_sha256 and digest != expected_sha256.lower(): + _refuse( + renderer, "file_changed", "The file bytes differ from the approved SHA256; review the new file." + ) + query = urllib.parse.urlencode( + {"include_tags": "models", "name_contains": destination_name, "include_public": "true", "limit": 500} + ) + status, existing = request_json(target.url("assets") + "?" + query, target, max_bytes=5 * 1024 * 1024) + if ( + status != 200 + or not isinstance(existing, dict) + or not isinstance(existing.get("assets"), list) + or any(not isinstance(row, dict) for row in existing["assets"]) + or existing.get("has_more") is not False + ): + _refuse( + renderer, + "collision_unverified", + "Could not verify destination-name collisions; no file was uploaded.", + ) + matches = [ + row for row in existing["assets"] if isinstance(row, dict) and row.get("name") == destination_name + ] + if any(_content_hash(row.get("hash")) != content_hash for row in matches): + _refuse( + renderer, + "name_collision", + "That model name already identifies different or unverified bytes; approve a unique --name.", + ) + owned_matches = [] + if matches: + # Public visibility establishes a collision, not ownership. + # Cloud's from-hash endpoint requires this workspace to own + # the bytes, so verify that with a separate scoped listing. + owned_query = urllib.parse.urlencode( + { + "include_tags": "models", + "name_contains": destination_name, + "include_public": "false", + "limit": 500, + } + ) + status, owned = request_json( + target.url("assets") + "?" + owned_query, target, max_bytes=5 * 1024 * 1024 + ) + if ( + status != 200 + or not isinstance(owned, dict) + or not isinstance(owned.get("assets"), list) + or any(not isinstance(row, dict) for row in owned["assets"]) + or owned.get("has_more") is not False + ): + _refuse( + renderer, + "ownership_unverified", + "Could not verify workspace-owned model assets; no file was uploaded.", + ) + owned_matches = [row for row in owned["assets"] if row.get("name") == destination_name] + if any(_content_hash(row.get("hash")) != content_hash for row in owned_matches): + _refuse( + renderer, + "name_collision", + "That model name already identifies different or unverified bytes; approve a unique --name.", + ) + plan = { + "file": str(file.resolve()), + "name": destination_name, + "model_type": model_type, + "size_bytes": size, + "sha256": digest, + "hash": content_hash, + "workspace_id": workspace, + "workspace_name": current.get("name"), + "destination": target.url("assets"), + "environment": "standard", + "uploaded": False, + "deduped": False, + "dry_run": dry_run, + "license": "unknown", + "nsfw": "unknown", + "estimated_upload_seconds": None, + "upload_cost": None, + "storage_cost": None, + "compute_cost": None, + "execution_state": "prepared, not run", + } + if dry_run: + renderer.emit(plan, command="model upload", where="cloud", changed=False) + return + if owned_matches: + _, body = request_json( + target.url("assets", "from-hash"), + target, + method="POST", + body={"hash": content_hash, "tags": ["models", model_type]}, + max_bytes=1024 * 1024, + ) + else: + request = _request(target, snapshot, size, destination_name, model_type) + with no_redirect_urlopen(request, timeout=3600) as response: + raw = read_capped(response, target.url("assets"), max_bytes=1024 * 1024) + body = json.loads(raw) + if not isinstance(body, dict) or _content_hash(body.get("hash")) != content_hash or not body.get("id"): + renderer.error( + code="model_upload_failed", + message="Upload response did not verify the exact approved model bytes.", + hint="inspect the asset library before retrying; the server may have received the file", + details={"uploaded": "unknown", "workspace_id": workspace}, + ) + raise typer.Exit(code=1) + tags = body.get("tags") + loader_path = body.get("loader_path") + file_path = body.get("file_path") + folder_verified = (isinstance(file_path, str) and file_path.startswith(f"models/{model_type}/")) or ( + isinstance(tags, list) and "/" not in model_type and model_type.lower() in tags + ) + # Before loader_path was served, the inference model resolver used + # Asset.Name verbatim. Derive only after verifying its folder and + # exact bytes, never from the requested local filename alone. + if loader_path is None and folder_verified: + loader_path = body.get("name") + if ( + not isinstance(tags, list) + or "models" not in tags + or not folder_verified + or not isinstance(loader_path, str) + or not loader_path + or "\\" in loader_path + or loader_path.startswith("/") + or any(part in (".", "..", "") for part in loader_path.split("/")) + ): + renderer.error( + code="model_upload_failed", + message="Model bytes were stored but a usable model-library path was not verified.", + hint="inspect the returned asset in the selected workspace before running", + details={"uploaded": True, "asset_id": body["id"], "workspace_id": workspace}, + ) + raise typer.Exit(code=1) + renderer.emit( + { + **plan, + "uploaded": not bool(owned_matches), + "deduped": bool(owned_matches), + "asset_id": body["id"], + "loader_path": loader_path, + "created_new": body.get("created_new"), + }, + command="model upload", + where="cloud", + changed=True, + ) + except (OSError, ValueError, RecursionError, ResponseTooLarge, urllib.error.URLError) as error: + renderer.error( + code="model_upload_failed", + message=f"Model import could not be completed: {type(error).__name__}", + hint="check account/network and the asset library before retrying; do not assume a failed request stored nothing", + details={"status": getattr(error, "code", None), "uploaded": "unknown"}, + ) + raise typer.Exit(code=1) from error diff --git a/comfy_cli/command/preview.py b/comfy_cli/command/preview.py index 6bec4f8e2..d15d3ce25 100644 --- a/comfy_cli/command/preview.py +++ b/comfy_cli/command/preview.py @@ -223,7 +223,7 @@ def preview_cmd( message="ffmpeg not found on PATH — `comfy preview` needs it to render.", hint="install ffmpeg (`brew install ffmpeg` / `apt install ffmpeg`) or `pip install imageio-ffmpeg`", ) - else: + elif not exc.is_absent: # Installed, but the match was refused. Saying "install ffmpeg" here # would send a user who already has it down the wrong path *and* bury # the interesting part: something named ffmpeg is sitting in the diff --git a/comfy_cli/command/run/preflight.py b/comfy_cli/command/run/preflight.py index b7702c498..a5c34924b 100644 --- a/comfy_cli/command/run/preflight.py +++ b/comfy_cli/command/run/preflight.py @@ -123,6 +123,9 @@ def _preflight_validate( graph = Graph.from_object_info(object_info) validation = graph.validate_workflow(workflow) + from comfy_cli.cloud_model_validation import resolve_cloud_model_errors + + validation = resolve_cloud_model_errors(validation, workflow, where=where) errors = list(validation.get("errors", [])) if not validation.get("valid", True) else [] if submitted_workflow is not None and submitted_workflow is not workflow: skipped = graph.validate_workflow({k: v for k, v in submitted_workflow.items() if k not in workflow}) diff --git a/comfy_cli/command/workflow.py b/comfy_cli/command/workflow.py index 4627c4708..1dcda54d8 100644 --- a/comfy_cli/command/workflow.py +++ b/comfy_cli/command/workflow.py @@ -23,6 +23,7 @@ import json import shlex import unicodedata +from enum import Enum from pathlib import Path from typing import Annotated, Any @@ -47,6 +48,21 @@ # --------------------------------------------------------------------------- +def _same_json(left: Any, right: Any) -> bool: + """Compare JSON values without equating booleans with numbers. + + JSON has one number type, so integer and floating-point representations of + the same number still match. Objects are unordered; arrays are ordered. + """ + if type(left) is not type(right): + return type(left) in (int, float) and type(right) in (int, float) and left == right + if isinstance(left, dict): + return left.keys() == right.keys() and all(_same_json(left[key], right[key]) for key in left) + if isinstance(left, list): + return len(left) == len(right) and all(_same_json(a, b) for a, b in zip(left, right)) + return left == right + + def _is_frontend_format(data: Any) -> bool: """Heuristic: frontend format has ``nodes`` as a list. API format has it as a dict keyed by IDs.""" return isinstance(data, dict) and isinstance(data.get("nodes"), list) @@ -800,6 +816,14 @@ def print_cmd( # ``flux.json`` or ``sub/dir/flux.json``) — that same string is what # ``get``/``delete`` take and what ``save`` returns. # +# ``save`` writes a ``/userdata`` file on BOTH routes. On cloud that file is what +# the Workflows sidebar lists: a record made only through ``POST /api/workflows`` +# has no file behind it and never shows there. Cloud's userdata POST mirrors the +# file into the ``/api/workflows`` store itself (a record named after the file, +# ``workflows/My Flow.json`` → ``My Flow``), so ``save`` writes the file only and +# reads the record id back by that exact name. ``list``/``get``/``delete`` still +# address the record store. +# # The two paths share the ``--json`` envelope shape as far as feasible; the # per-verb docstrings + PR note the deltas (local has no versioning, no # server-side description, and reports raw file ``size``/``modified``/``created`` @@ -809,6 +833,14 @@ def print_cmd( # The userdata subdirectory the ComfyUI frontend stores saved workflows in. _WORKFLOWS_DIR = "workflows" +# The frontend keeps its favorites list in this file inside ``workflows/``. A save +# under that name would replace the user's bookmarks rather than add a workflow. +_WORKFLOWS_INDEX_FILE = ".index.json" + +# Rows per ``/api/workflows`` page when ``save`` reads back the record Cloud made +# for the file. A full page may be truncated, so it resolves nothing. +_RECORD_LOOKUP_LIMIT = 100 + # Cap on a single ``/userdata`` response we buffer into memory. We read one byte # past the cap so we can *detect* truncation and fail loudly, rather than # silently writing a partial workflow and reporting success. @@ -948,7 +980,7 @@ def _reject_unsafe_workflow_key(renderer, key: str) -> str: ): renderer.error( code="invalid_argument", - message=f"workflow id {key!r} is not a valid path under the local workflows/ dir", + message=f"workflow id {key!r} is not a valid path under the workflows/ dir", hint="use a relative name like `flux.json` or `sub/flux.json` (no `..`, no leading `/`)", ) raise typer.Exit(code=1) @@ -1293,9 +1325,8 @@ def _local_get(renderer, target, workflow_id: str, out: str | None) -> None: renderer.emit(payload, command="workflow get", where="local") -def _local_save(renderer, target, workflow_file: str, name: str, description: str | None) -> None: - import urllib.error - +def _read_workflow_for_save(renderer, workflow_file: str) -> tuple[Path, str, dict]: + """Read and parse the workflow file ``save`` uploads: ``(path, text, parsed)``.""" path = Path(workflow_file).expanduser() if not path.is_file(): renderer.error( @@ -1329,15 +1360,67 @@ def _local_save(renderer, target, workflow_file: str, name: str, description: st hint="use ComfyUI's `File > Save` to export", ) raise typer.Exit(code=1) + return path, text, workflow_json + + +def _saved_workflow_key(renderer, name: str, *, ext_case_sensitive: bool) -> str: + """The file ``save`` writes under ``workflows/`` for ``--name``. + + ``.json`` is appended unless the name already ends in it. Cloud creates a + workflow record only for a file ending in a lowercase ``.json``, so the cloud + route matches the extension case-sensitively (``Flow.JSON`` → ``Flow.JSON.json``); + the local route keeps its case-insensitive match. + """ + has_ext = name.endswith(".json") if ext_case_sensitive else name.lower().endswith(".json") + key = _reject_unsafe_workflow_key(renderer, name if has_ext else f"{name}.json") + if ext_case_sensitive and any(part.startswith(".") for part in key.split("/")): + renderer.error( + code="invalid_argument", + message=f"{key!r} is hidden from the Cloud Workflows sidebar", + hint="use a name with no dot-prefixed file or folder components", + ) + raise typer.Exit(code=1) + if key.rsplit("/", 1)[-1] == _WORKFLOWS_INDEX_FILE: + renderer.error( + code="invalid_argument", + message=f"{key!r} is the workflows/ folder's favorites index, not a workflow name", + hint="pass a different `--name`", + ) + raise typer.Exit(code=1) + return key + + +def _workflow_exists_error(renderer, key: str) -> typer.Exit: + renderer.error( + code="workflow_exists", + message=f"a saved workflow named {key!r} already exists; --no-overwrite left it unchanged", + hint="pass a different `--name`, or drop `--no-overwrite` to replace it", + details={"filename": key}, + ) + return typer.Exit(code=1) + + +def _overwrite_query(overwrite: bool) -> dict: + return {"overwrite": "true" if overwrite else "false", "full_info": "true"} + + +def _local_save( + renderer, target, workflow_file: str, name: str, description: str | None, *, overwrite: bool = True +) -> None: + import urllib.error - key = name if name.lower().endswith(".json") else f"{name}.json" - key = _reject_unsafe_workflow_key(renderer, key) - url = _userdata_file_url(target, key, query={"overwrite": "true", "full_info": "true"}) + path, text, _workflow_json = _read_workflow_for_save(renderer, workflow_file) + key = _saved_workflow_key(renderer, name, ext_case_sensitive=False) + url = _userdata_file_url(target, key, query=_overwrite_query(overwrite)) try: _, raw = _userdata_request( url, target, method="POST", data=text.encode("utf-8"), content_type="application/json" ) - except (urllib.error.HTTPError, urllib.error.URLError, OSError, _ResponseTooLarge) as e: + except urllib.error.HTTPError as e: + if e.code == 409: + raise _workflow_exists_error(renderer, key) from e + raise _handle_local_http_error(renderer, e, operation="save", workflow_id=key) from e + except (urllib.error.URLError, OSError, _ResponseTooLarge) as e: raise _handle_local_http_error(renderer, e, operation="save", workflow_id=key) from e info = None @@ -1366,10 +1449,145 @@ def _local_save(renderer, target, workflow_file: str, name: str, description: st {"code": "description_ignored", "message": "--description is ignored on the local path (no metadata store)"} ] if renderer.is_pretty(): - rprint(f"[green]✓[/green] saved [dim]{stored_id}[/dim]") + rprint(f"[green]✓[/green] saved [dim]{sanitize_markup(stored_id)}[/dim]") renderer.emit(payload, command="workflow save", where="local", changed=True) +def _cloud_record_name(key: str) -> str | None: + """The name Cloud gives the record it mirrors from ``workflows/``. + + Cloud drops ``.json`` and cleans the path (``sub/.json`` → ``sub``); an empty + or dot-only result gets no record. ``key`` has passed ``_saved_workflow_key``, + so it ends in ``.json`` and carries no ``..`` segment. + """ + import posixpath + + stem = key[: -len(".json")] + name = posixpath.normpath(stem) if stem else "" + return None if name in ("", ".", "..") else name + + +def _find_mirrored_record(target, record_name: str, workflow_json: dict | None = None) -> dict | None: + """The one ``/api/workflows`` record named exactly ``record_name``, else ``None``. + + Best-effort: the file is already saved when this runs, so a failed or + ambiguous read must not fail the save. Cloud's ``name`` filter is a + case-insensitive substring match, so the exact compare happens here; two + records under one name (``/api/workflows`` allows that) or a page that may be + truncated resolve nothing rather than a guess. + """ + import urllib.error + import urllib.parse + + query = urllib.parse.urlencode({"limit": _RECORD_LOOKUP_LIMIT, "name": record_name}) + try: + _, body = _http_request(target.url("workflows") + "?" + query, target) + except (urllib.error.URLError, OSError, _ResponseUnparseable, _ResponseTooLarge): + return None + rows = body.get("data") if isinstance(body, dict) else None + if not isinstance(rows, list) or len(rows) >= _RECORD_LOOKUP_LIMIT: + return None + matches = [r for r in rows if isinstance(r, dict) and r.get("name") == record_name] + if len(matches) != 1 or not isinstance(matches[0].get("id"), str) or not matches[0]["id"]: + return None + record = matches[0] + if workflow_json is not None: + # SyncFromUserdata is best-effort: an old record may still exist after + # its update failed. Do not hand out an id whose `get` returns stale data. + try: + _, content = _http_request( + target.url("workflows", urllib.parse.quote(record["id"], safe=""), "content"), target + ) + except (urllib.error.URLError, OSError, _ResponseUnparseable, _ResponseTooLarge): + return None + if not isinstance(content, dict) or not _same_json(content.get("workflow_json"), workflow_json): + return None + return record + + +def _saved_file_id(info: object, key: str) -> str | None: + """Use only the actual userdata write receipt, never a mirrored record ID.""" + from comfy_cli.saved_file_identity import canonical_saved_file_id + + if not isinstance(info, dict) or info.get("path") != f"{_WORKFLOWS_DIR}/{key}": + return None + return canonical_saved_file_id(info.get("id")) + + +def _cloud_save( + renderer, target, workflow_file: str, name: str, description: str | None, *, overwrite: bool = True +) -> None: + import urllib.error + + path, _text, workflow_json = _read_workflow_for_save(renderer, workflow_file) + key = _saved_workflow_key(renderer, name, ext_case_sensitive=True) + # The Cloud frontend's own save: the graph JSON as the body of a userdata + # write under workflows/. This file is what the Workflows sidebar lists. + url = _userdata_file_url(target, key, query=_overwrite_query(overwrite)) + try: + _, info = _http_request(url, target, method="POST", body=workflow_json) + except urllib.error.HTTPError as e: + if e.code == 409: + raise _workflow_exists_error(renderer, key) from e + raise _handle_cloud_http_error(renderer, e, operation="save") from e + except (urllib.error.URLError, OSError, _ResponseUnparseable, _ResponseTooLarge) as e: + raise _handle_cloud_http_error(renderer, e, operation="save") from e + + saved_file_id = _saved_file_id(info, key) + record_name = _cloud_record_name(key) + record = _find_mirrored_record(target, record_name, workflow_json) if record_name else None + latest = record.get("latest_version") if record else None + payload: dict[str, Any] = { + "workflow_id": record["id"] if record else None, + "saved_file_id": saved_file_id, + "name": record_name or key, + "filename": key, + "latest_version": latest if isinstance(latest, int) and not isinstance(latest, bool) else None, + "source": str(path), + "size": info.get("size") if isinstance(info, dict) else None, + "modified": info.get("modified") if isinstance(info, dict) else None, + } + warnings: list[dict[str, str]] = [] + if description: + warnings.append( + { + "code": "description_ignored", + "message": "--description is ignored: the Cloud Workflows sidebar file has no description field", + } + ) + if saved_file_id is None: + warnings.append( + { + "code": "saved_file_identity_unavailable", + "message": "The file was saved, but this server did not return its canonical saved_file_id; " + "a private saved-file link cannot be certified. Verify the file in the Cloud Workflows sidebar; " + "do not repeat the save or uploads to obtain an ID. workflow_id identifies a separate record.", + } + ) + if record is None: + warnings.append( + { + "code": "workflow_record_unresolved", + "message": f"saved {key!r} to the Workflows sidebar, but no single Cloud workflow record named " + f"{record_name!r} with matching content could be read back, so workflow_id is null; " + "open the file from the sidebar and inspect `comfy --json workflow list --name `; " + "do not repeat the save", + } + ) + if warnings: + payload["warnings"] = warnings + if renderer.is_pretty(): + shown = sanitize_markup(f"{_WORKFLOWS_DIR}/{key}") + rprint( + f"[green]✓[/green] saved to the Cloud Workflows sidebar as [bold]{shown}[/bold]" + + (f" → [dim]{sanitize_markup(record['id'])}[/dim]" if record else "") + ) + rprint("[dim]refresh an open Comfy Cloud tab to see it in the sidebar[/dim]") + for w in warnings: + rprint(f"[yellow]![/yellow] {sanitize_markup(w['message'])}") + renderer.emit(payload, command="workflow save", where="cloud", changed=True) + + def _local_delete(renderer, target, workflow_id: str) -> None: import urllib.error @@ -1386,6 +1604,93 @@ def _local_delete(renderer, target, workflow_id: str) -> None: renderer.emit(payload, command="workflow delete", where="local", changed=True) +def _cloud_delete(renderer, target, workflow_id: str) -> None: + """Delete the sidebar file and record; the record API alone leaves the file. + + Cloud's userdata delete also deletes a same-name record best-effort. Finish + that cleanup explicitly, accepting a 404 only after the file was removed. + Legacy record-only workflows still delete through the record endpoint. + """ + import urllib.error + import urllib.parse + + url = target.url("workflows", urllib.parse.quote(workflow_id, safe="")) + file_deleted = False + key = None + try: + _, record = _http_request(url, target) + if not isinstance(record, dict): + raise _ResponseUnparseable() + name = record.get("name") + if isinstance(name, str) and name: + key = _reject_unsafe_workflow_key(renderer, f"{name}.json") + if key != f"{name}.json": + renderer.error( + code="workflow_filename_ambiguous", + message="the record name would be normalized to a different sidebar filename", + hint="inspect the record and sidebar file; verify the name, content, and ownership before any manual cleanup", + details={"workflow_id": workflow_id, "filename": key}, + ) + raise typer.Exit(code=1) + if key.rsplit("/", 1)[-1] == _WORKFLOWS_INDEX_FILE: + renderer.error( + code="invalid_argument", + message="refusing to delete the workflows favorites index", + hint="delete this record directly through the Cloud workflow API", + ) + raise typer.Exit(code=1) + file_url = _userdata_file_url(target, key) + try: + _, file_content = _http_request(file_url, target) + except urllib.error.HTTPError as e: + if e.code != 404: + raise + else: + # Userdata belongs to the current user, but workflow reads are + # workspace-wide and a best-effort sync may leave stale content. + # A unique name alone cannot associate this file with the record. + mirror = _find_mirrored_record(target, name, file_content) if isinstance(file_content, dict) else None + owner_matches = False + if mirror is not None and mirror["id"] == workflow_id: + _, user = _http_request(target.url("user"), target) + user_id = user.get("id") if isinstance(user, dict) else None + owner_matches = isinstance(user_id, str) and bool(user_id) and record.get("created_by") == user_id + if not owner_matches: + renderer.error( + code="workflow_filename_ambiguous", + message=f"cannot safely associate sidebar file {key!r} with record {workflow_id!r}", + hint="inspect same-name records with `comfy --json workflow list --name `; " + "verify the file name, content, and ownership before any manual cleanup", + details={"workflow_id": workflow_id, "filename": key}, + ) + raise typer.Exit(code=1) + _http_request(file_url, target, method="DELETE") + file_deleted = True + try: + _http_request(url, target, method="DELETE") + except urllib.error.HTTPError as e: + if e.code != 404 or not file_deleted: + raise + except (urllib.error.URLError, OSError, _ResponseUnparseable, _ResponseTooLarge) as e: + if file_deleted: + renderer.error( + code="workflow_delete_incomplete", + message="the sidebar file was deleted, but workflow record cleanup could not be confirmed", + hint=f"check `comfy --json workflow list`, then retry `comfy workflow delete {workflow_id}` " + "if that record remains", + details={"workflow_id": workflow_id, "filename": key, "file_deleted": True}, + ) + raise typer.Exit(code=1) from e + raise _handle_cloud_http_error(renderer, e, operation="delete", workflow_id=workflow_id) from e + + payload = {"workflow_id": workflow_id, "deleted": True} + if file_deleted: + payload["filename"] = key + if renderer.is_pretty(): + rprint(f"[green]✓[/green] deleted [dim]{sanitize_markup(workflow_id)}[/dim]") + renderer.emit(payload, command="workflow delete", where="cloud", changed=True) + + @app.command("list", help="List saved workflows (cloud store, or local ComfyUI /userdata with --where local).") @tracking.track_command("workflow") def list_cmd( @@ -1554,6 +1859,47 @@ def list_cmd( renderer.emit(payload, command="workflow list", where="cloud") +class WorkflowUiEnvironment(str, Enum): + STANDARD = "standard" + CUSTOM = "custom" + + +@app.command( + "ui", + help="Print a capability-verified private saved-workflow URL. Read-only; selects the browser environment without changing compute.", +) +@tracking.track_command("workflow") +def ui_cmd( + workspace: Annotated[ + str, + typer.Option( + "--workspace", help="Exact approved workspace ID; must match the authenticated current workspace." + ), + ], + environment: Annotated[ + WorkflowUiEnvironment, typer.Option("--environment", help="Explicit standard or custom environment.") + ], + deployment_id: Annotated[ + str | None, typer.Option("--deployment", help="Exact ready deployment ID, required only for custom.") + ] = None, + workflow_id: Annotated[ + str | None, typer.Argument(help="Legacy workflow-record UUID; refuses with regeneration guidance.") + ] = None, + saved_file_id: Annotated[ + str | None, typer.Option("--saved-file", help="Exact userdata saved_file_id UUID from a supported Cloud save.") + ] = None, +) -> None: + from comfy_cli.command.workflow_ui import run_ui + + run_ui( + workflow_id, + saved_file_id=saved_file_id, + workspace=workspace, + environment=environment.value, + deployment_id=deployment_id, + ) + + @app.command( "get", help="Fetch a saved workflow's content (cloud, or local with --where local); writes JSON to --out or stdout.", @@ -1631,7 +1977,13 @@ def get_cmd( @app.command( "save", - help="Save a workflow JSON to the saved-workflow store (cloud, or local ComfyUI /userdata with --where local).", + help=( + "Save a workflow JSON as workflows/.json. On Comfy Cloud it appears in the Workflows sidebar " + "(refresh an open tab) and opens from there; Cloud also keeps a workflow record for it, returned as " + "workflow_id and, when the server returns it, the separate userdata saved_file_id. " + "With --where local it lands in the local ComfyUI's /userdata workflows/ folder. " + "A save under an existing name replaces it unless --no-overwrite." + ), ) @tracking.track_command("workflow") def save_cmd( @@ -1639,72 +1991,34 @@ def save_cmd( name: Annotated[ str, typer.Option( - "--name", help="Cloud: display name. Local: filename under workflows/ ('.json' appended if absent)." + "--name", + help="Filename under workflows/ ('.json' appended if absent; subfolders like team/flux allowed). " + "On Cloud it is also the sidebar entry and the workflow record's name.", ), ], description: Annotated[ str | None, - typer.Option("--description", show_default=False, help="Optional description (cloud only; ignored on local)."), + typer.Option( + "--description", + show_default=False, + help="Ignored, with a description_ignored warning: the saved workflow file has no description field.", + ), ] = None, + overwrite: Annotated[ + bool, + typer.Option( + "--overwrite/--no-overwrite", + help="Replace a saved workflow of the same name (default). --no-overwrite refuses with " + "workflow_exists instead.", + ), + ] = True, where: Annotated[str | None, typer.Option("--where", show_default=False)] = None, ): - import urllib.error - renderer = get_renderer() target = _resolve_where_target(where) if not target.is_cloud: - return _local_save(renderer, target, workflow_file, name, description) - - path = Path(workflow_file).expanduser() - if not path.is_file(): - renderer.error( - code="workflow_not_found", - message=f"local workflow file not found: {path}", - hint="check the path", - ) - raise typer.Exit(code=1) - try: - workflow_json = json.loads(path.read_text(encoding="utf-8")) - except json.JSONDecodeError as e: - renderer.error( - code="workflow_invalid_json", - message=f"{path} is not valid JSON: {e}", - hint="re-export the workflow from ComfyUI", - ) - raise typer.Exit(code=1) from e - if not isinstance(workflow_json, dict): - renderer.error( - code="workflow_not_api_format", - message="workflow_json must be a JSON object", - hint="use ComfyUI's `File > Save` to export", - ) - raise typer.Exit(code=1) - - body: dict[str, Any] = {"name": name, "workflow_json": workflow_json} - if description: - body["description"] = description - url = target.url("workflows") - try: - _, resp = _http_request(url, target, method="POST", body=body) - except ( - urllib.error.HTTPError, - urllib.error.URLError, - OSError, - _ResponseUnparseable, - _ResponseTooLarge, - ) as e: - raise _handle_cloud_http_error(renderer, e, operation="save") from e - - workflow_id = (resp or {}).get("id") if isinstance(resp, dict) else None - payload = { - "workflow_id": workflow_id, - "name": name, - "latest_version": (resp or {}).get("latest_version") if isinstance(resp, dict) else None, - "source": str(path), - } - if renderer.is_pretty(): - rprint(f"[green]✓[/green] saved {name!r} → [dim]{workflow_id}[/dim]") - renderer.emit(payload, command="workflow save", where="cloud", changed=True) + return _local_save(renderer, target, workflow_file, name, description, overwrite=overwrite) + return _cloud_save(renderer, target, workflow_file, name, description, overwrite=overwrite) @app.command("delete", help="Delete a saved workflow (cloud, or local ComfyUI /userdata with --where local).") @@ -1716,31 +2030,12 @@ def delete_cmd( ], where: Annotated[str | None, typer.Option("--where", show_default=False)] = None, ): - import urllib.error - renderer = get_renderer() target = _resolve_where_target(where) if not target.is_cloud: return _local_delete(renderer, target, workflow_id) - import urllib.parse as _up - - url = target.url("workflows", _up.quote(workflow_id, safe="")) - try: - _, _body = _http_request(url, target, method="DELETE") - except ( - urllib.error.HTTPError, - urllib.error.URLError, - OSError, - _ResponseUnparseable, - _ResponseTooLarge, - ) as e: - raise _handle_cloud_http_error(renderer, e, operation="delete", workflow_id=workflow_id) from e - - payload = {"workflow_id": workflow_id, "deleted": True} - if renderer.is_pretty(): - rprint(f"[green]✓[/green] deleted [dim]{workflow_id}[/dim]") - renderer.emit(payload, command="workflow delete", where="cloud", changed=True) + return _cloud_delete(renderer, target, workflow_id) # --------------------------------------------------------------------------- @@ -2006,6 +2301,10 @@ def validate_api_workflow( with full_enum_options(full_options): result = graph.validate_workflow(wf_data) + from comfy_cli.cloud_model_validation import resolve_cloud_model_errors + + result = resolve_cloud_model_errors(result, wf_data, where=mode, offline=input_path is not None) + # When the caller handed us a CANVAS graph, they have never seen the # flattened ids the lowering mints for subgraph interiors (`57:3`) — their # edit surface (slots / set-widget) speaks `57/3`. Key every issue by the diff --git a/comfy_cli/command/workflow_ui.py b/comfy_cli/command/workflow_ui.py new file mode 100644 index 000000000..40eb15678 --- /dev/null +++ b/comfy_cli/command/workflow_ui.py @@ -0,0 +1,213 @@ +"""Read-only, capability-gated URLs for normal private saved-workflow identity.""" + +from __future__ import annotations + +import json +import re +import urllib.error +import urllib.parse + +import typer + +from comfy_cli.builder_api import BuilderAuthError +from comfy_cli.comfy_client import Client, HTTPError, Unauthenticated +from comfy_cli.command.deploy_resolve import DeployResolveError +from comfy_cli.command.deploy_ui import EditorUnavailableError, verify_deployment_editor_target +from comfy_cli.deploy_api_errors import DeployAPIError +from comfy_cli.http import ResponseTooLarge, assert_safe_url, request_json +from comfy_cli.output import get_renderer +from comfy_cli.saved_file_identity import canonical_saved_file_id +from comfy_cli.target import resolve_target + +_SAFE_ID = re.compile(r"[A-Za-z0-9_-]+") +_MAX_CONTROL_BYTES = 256 * 1024 +_MAX_WORKFLOW_BYTES = 16 * 1024 * 1024 +_HINT = ( + "If sidebar read-back succeeded, open the saved name from Cloud → Workflows. " + "If the normal sidebar file is unverified or record-only, retain the local workflow and explain that limitation. " + "For a custom environment, use verified deployment API commands until the complete private handoff is verified." +) + + +class WorkflowUiUnavailable(Exception): + def __init__(self, reason: str, message: str, *, status: int | None = None): + super().__init__(message) + self.reason, self.status = reason, status + + +def _refuse(reason: str, message: str) -> None: + raise WorkflowUiUnavailable(reason, message) + + +def _get(target, *parts: str, max_bytes: int = _MAX_CONTROL_BYTES): + try: + status, body = request_json(target.url(*parts), target, method="GET", max_bytes=max_bytes, timeout=15) + except urllib.error.HTTPError as error: + raise WorkflowUiUnavailable( + "unavailable", "Cloud could not verify this saved workflow.", status=error.code + ) from error + if status != 200: + raise WorkflowUiUnavailable("unavailable", "Cloud could not verify this saved workflow.", status=status) + return body + + +def _safe_name(name: object) -> bool: + return ( + isinstance(name, str) + and 0 < len(name) <= 1024 + and not name.startswith(("/", "~")) + and "\\" not in name + and not any(ord(c) < 32 or ord(c) == 127 for c in name) + and all(part.rstrip(" .") not in ("", ".", "..") for part in name.split("/")) + ) + + +def _deployment_client(): + from comfy_cli.deploy_api import DeployClient + + return DeployClient.from_credentials() + + +def verify_workflow_link( + saved_file_id: str, *, workspace: str, environment: str, deployment_id: str | None = None +) -> dict: + """Verify current access, normal file-backed identity and selected environment. + + No save/share operation, browser launch, environment mutation or compute + operation occurs. A capability absent on an older release is a hard refusal. + """ + canonical_id = canonical_saved_file_id(saved_file_id.lower()) if isinstance(saved_file_id, str) else None + if canonical_id is None: + _refuse("invalid_identity", "Use the exact saved_file_id UUID from the userdata save receipt.") + if not isinstance(workspace, str) or not _SAFE_ID.fullmatch(workspace): + _refuse("invalid_workspace", "Use the exact destination workspace ID.") + if environment not in ("standard", "custom"): + _refuse("invalid_environment", "Choose standard or custom explicitly.") + if (environment == "standard" and deployment_id is not None) or (environment == "custom" and not deployment_id): + _refuse("environment_conflict", "A custom environment requires its deployment ID; standard excludes it.") + if deployment_id is not None and (not isinstance(deployment_id, str) or not _SAFE_ID.fullmatch(deployment_id)): + _refuse("invalid_deployment", "Use an exact deployment ID, not a path or name selector.") + + try: + target = resolve_target(where="cloud", allow_clear=False) + if not target.is_cloud or not target.auth_token or target.api_key: + _refuse("authentication_required", "A private workflow link requires an authenticated Cloud OAuth session.") + origin = urllib.parse.urlsplit(target.base_url) + if ( + origin.scheme not in ("https", "http") + or not origin.hostname + or origin.username is not None + or origin.password is not None + ): + _refuse("invalid_origin", "The configured Cloud origin cannot produce a safe editor URL.") + assert_safe_url(target.base_url) + current = _get(target, "workspaces", "current") + if not isinstance(current, dict) or current.get("id") != workspace: + _refuse("workspace_mismatch", "The approved workspace is not the current authenticated workspace.") + features = _get(target, "features") + if not isinstance(features, dict) or features.get("private_saved_file_links_enabled") is not True: + _refuse( + "capability_unavailable", "This Cloud release has not enabled verified private saved-workflow links." + ) + snapshot = _get(target, "userdata-files", canonical_id, max_bytes=_MAX_WORKFLOW_BYTES) + if not isinstance(snapshot, dict) or snapshot.get("id") != canonical_id: + _refuse("invalid_identity", "Cloud did not return the exact saved file identity.") + filename = snapshot.get("path") + if ( + not _safe_name(filename) + or not filename.startswith("workflows/") + or not filename.endswith(".json") + or filename.rsplit("/", 1)[-1] in (".json", ".index.json") + ): + _refuse("file_unavailable", "Cloud did not return a safe normal Workflows file path.") + for key in ("modified", "size"): + value = snapshot.get(key) + if type(value) is not int or not 0 <= value <= 9007199254740991: + _refuse("metadata_unverified", "Cloud did not return valid saved-file metadata.") + text = snapshot.get("content") + if not isinstance(text, str) or len(text.encode("utf-8")) != snapshot["size"]: + _refuse("content_unverified", "Cloud did not return the exact saved-file content.") + graph = json.loads(text) + from comfy_cli.cloud_workflow_schema import is_supported_canvas + + if not is_supported_canvas(graph): + _refuse("content_unverified", "Cloud did not return a supported saved canvas.") + # Browser JSON.parse rejects NaN/Infinity, including opaque metadata. + json.dumps(graph, allow_nan=False) + query = {"savedFile": canonical_id, "workspace": workspace} + result = { + "savedFileId": canonical_id, + "workspaceId": workspace, + "environment": environment, + "filename": filename, + "verified": True, + } + if environment == "custom": + deployment = _deployment_client().get_deployment(deployment_id) + selected = verify_deployment_editor_target( + Client(target), workspace_id=workspace, deployment_id=deployment_id, deployment=deployment + ) + if selected.get("workspaceId") != workspace or selected.get("deploymentId") != deployment_id: + _refuse("deployment_unverified", "The selected custom environment was not verified.") + result.update({"deploymentId": deployment_id, "releaseId": selected["releaseId"]}) + query["deployment"] = deployment_id + else: + query["environment"] = "standard" + result["url"] = urllib.parse.urlunsplit((origin.scheme, origin.netloc, "/", urllib.parse.urlencode(query), "")) + return result + except WorkflowUiUnavailable: + raise + except EditorUnavailableError as error: + raise WorkflowUiUnavailable( + "deployment_unverified", "The selected custom environment could not be verified." + ) from error + except ( + HTTPError, + Unauthenticated, + BuilderAuthError, + DeployResolveError, + DeployAPIError, + OSError, + ValueError, + ResponseTooLarge, + RecursionError, + ) as error: + # Workflow content, prompts and transport bodies never enter errors. + raise WorkflowUiUnavailable( + "unavailable", "Cloud could not verify this private workflow and target; no link was generated." + ) from error + + +def run_ui( + workflow_id: str | None = None, + *, + saved_file_id: str | None = None, + workspace: str, + environment: str, + deployment_id: str | None = None, +) -> None: + renderer = get_renderer() + try: + if workflow_id is not None or not saved_file_id: + _refuse( + "legacy_identity_unsupported" if workflow_id is not None else "invalid_identity", + "Workflow-record links are unavailable. Regenerate with `workflow ui --saved-file ` " + "using the userdata UUID returned by a supported save, or open the verified file in Cloud → Workflows. " + "Do not repeat saves or uploads solely to obtain an ID.", + ) + result = verify_workflow_link( + saved_file_id, workspace=workspace, environment=environment, deployment_id=deployment_id + ) + except WorkflowUiUnavailable as error: + renderer.error( + code="workflow_ui_unavailable", + message=str(error), + hint=_HINT, + details={"reason": error.reason, "status": error.status}, + where="cloud", + command="workflow ui", + ) + raise typer.Exit(code=1) from error + if renderer.is_pretty(): + renderer.print(result["url"]) + renderer.emit(result, command="workflow ui", where="cloud", changed=False) diff --git a/comfy_cli/credentials.py b/comfy_cli/credentials.py index 9cf75efd4..bcba23d50 100644 --- a/comfy_cli/credentials.py +++ b/comfy_cli/credentials.py @@ -92,6 +92,7 @@ def get_session( force: bool = False, allow_clear: bool = True, expect: Callable[[CloudSession], bool] | None = None, + rejected_access_token: str | None = None, ) -> CloudSession | None: """Read the stored Comfy Cloud OAuth session. @@ -104,6 +105,8 @@ def get_session( ``force=True`` (implies the refresh path) refreshes unconditionally, ignoring the local expiry check. Reserved for the *reactive* path: after a server 401, the token is known-rejected even if our clock disagrees. + ``rejected_access_token`` lets that path adopt a peer's newer access token + instead of rotating it again; the comparison happens under the refresh lock. ``allow_clear=False`` forwards to ``ensure_fresh_session`` so a fatal refresh failure does NOT clear the stored session. Background watchers pass @@ -117,9 +120,12 @@ def get_session( if refresh or force: from comfy_cli.cloud import oauth + options = {} if expect is not None: - return oauth.ensure_fresh_session(force=force, allow_clear=allow_clear, expect=expect) - return oauth.ensure_fresh_session(force=force, allow_clear=allow_clear) + options["expect"] = expect + if rejected_access_token is not None: + options["rejected_access_token"] = rejected_access_token + return oauth.ensure_fresh_session(force=force, allow_clear=allow_clear, **options) from comfy_cli.auth import store as auth_store return auth_store.get_cloud_session() @@ -140,14 +146,52 @@ def refreshed_access_token( :func:`get_session`. """ if expect is not None: - session = get_session(refresh=True, force=True, allow_clear=allow_clear, expect=expect) + session = get_session( + refresh=True, force=True, allow_clear=allow_clear, expect=expect, rejected_access_token=rejected + ) else: - session = get_session(refresh=True, force=True, allow_clear=allow_clear) + session = get_session(refresh=True, force=True, allow_clear=allow_clear, rejected_access_token=rejected) if session is None or not session.access_token or session.access_token == rejected: return None return session.access_token +def sign_in_still_stored(base_url: str | None) -> bool: + """Whether a refreshable sign-in for the refused client's environment remains. + + A 401 that outlives :func:`refreshed_access_token` and one retry does not show + that nobody is signed in: a peer process can hold the refresh lock past this + one's timeout, a refresh that fails on the network keeps the old token, and + the server can refuse a token it minted a moment ago. A sign-in without a + refresh token cannot recover this way and retains the sign-in guidance. + ``base_url`` is the environment the client's sign-in came from; ``None``, + for a key or a handed token, never matches. + """ + if base_url is None: + return False + from comfy_cli import locking + from comfy_cli.auth import store as auth_store + + try: + # Do not spend another lock budget after session recovery timed out. + # The store's nested read reuses this thread's lock reentrantly. + with locking.file_lock(auth_store.lock_path(), timeout=0): + session = get_session(refresh=False) + except TimeoutError: + # Contention cannot prove the held sign-in disappeared. End only the + # watch, rather than hanging or prescribing another login. + return True + except OSError as error: + _log.warning("could not re-read the stored sign-in after a 401: %s", error) + return False + return ( + session is not None + and bool(session.access_token) + and bool(session.refresh_token) + and session.base_url == base_url + ) + + class DataPlaneToken: """The bearer one long command sends to a deployment endpoint, kept fresh. diff --git a/comfy_cli/desktop_install.py b/comfy_cli/desktop_install.py new file mode 100644 index 000000000..789af470c --- /dev/null +++ b/comfy_cli/desktop_install.py @@ -0,0 +1,581 @@ +"""Find a Comfy Desktop 2 install from the records Desktop keeps on disk. + +Desktop 2 splits one install across up to three places, and none of them is +where comfy-cli's own default workspace lives: + +* the **code dir** — a ComfyUI checkout at ``/ComfyUI``; +* the **data dir** — ``models/``, ``custom_nodes/``, ``user/`` and the venv. + For an install adopted from Desktop 1 that is ``adoptedBaseDir`` (Desktop + launches it with ``--base-directory``); otherwise it is the code dir; +* **model roots** — the data dir's ``models/`` plus the shared library in + ``settings.json`` → ``modelsDirs`` (unless the install opted out with + ``useSharedModels: false``) plus the install's own ``modelDirs``. + +Everything is read from files Desktop maintains in its app-data dir +(``installations.json``, ``settings.json``). Nothing here starts Desktop, +talks to a server, or writes a file. +""" + +from __future__ import annotations + +import json +import os +import re +from dataclasses import dataclass, field, replace +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +from comfy_cli.constants import OS +from comfy_cli.utils import get_os + +#: Desktop 2's Electron ``userData`` folder name. +APP_DIR_NAME = "Comfy Desktop" +MODERN_APP_DIR_NAME = "comfyui-desktop-2" +#: Desktop 1's ``userData`` folder, which holds ``config.json`` → ``basePath``. +LEGACY_APP_DIR_NAME = "ComfyUI" + +_BARE_RELEASE_RE = re.compile(r"^\d+(?:\.\d+)+$") +_VERSION_MARKER_RE = re.compile(r"""^__version__\s*=\s*['"]([^'"\n]+)['"]""", re.MULTILINE) + + +def desktop_app_data_dir() -> Path | None: + """Desktop 2's app-data dir on this OS (where ``installations.json`` lives).""" + current = get_os() + if current == OS.MACOS: + return Path.home() / "Library" / "Application Support" / APP_DIR_NAME + if current == OS.WINDOWS: + appdata = os.environ.get("APPDATA") + return Path(appdata) / APP_DIR_NAME if appdata else None + base = os.environ.get("XDG_DATA_HOME") or str(Path.home() / ".local" / "share") + return Path(base) / APP_DIR_NAME + + +def legacy_config_dir() -> Path | None: + """Desktop 1's app-data dir (``config.json`` → ``basePath``); none on Linux.""" + current = get_os() + if current == OS.MACOS: + return Path.home() / "Library" / "Application Support" / LEGACY_APP_DIR_NAME + if current == OS.WINDOWS: + appdata = os.environ.get("APPDATA") + return Path(appdata) / LEGACY_APP_DIR_NAME if appdata else None + return None + + +@dataclass(frozen=True) +class ModelRoot: + path: str + #: ``data`` (the install's own ``models/``), ``shared`` (``settings.json`` + #: ``modelsDirs``) or ``install`` (the install record's own ``modelDirs``). + source: str + exists: bool + + def to_dict(self) -> dict[str, Any]: + return {"path": self.path, "source": self.source, "exists": self.exists} + + +@dataclass(frozen=True) +class DesktopInstall: + install_id: str | None + name: str | None + code_dir: str + data_dir: str + python: str | None + model_roots: tuple[ModelRoot, ...] + comfyui_version: str | None + comfyui_commit: str | None + adopted: bool + status: str | None + last_launched_ms: int | None + #: The code dir holds a ComfyUI checkout (``main.py``) — only such an + #: install can be selected. + exists: bool + #: Internal registry ownership for generated config identity; never serialized. + registry_dir: str | None = field(default=None, repr=False) + + @property + def last_launched_at(self) -> str | None: + if not self.last_launched_ms: + return None + try: + stamp = datetime.fromtimestamp(self.last_launched_ms / 1000, tz=timezone.utc) + except (OSError, OverflowError, ValueError): + return None + return stamp.isoformat(timespec="seconds").replace("+00:00", "Z") + + def summary(self, *, selected: bool) -> dict[str, Any]: + """One row of ``desktop.installs``: enough to tell the installs apart.""" + return { + "install_id": self.install_id, + "name": self.name, + "code_dir": self.code_dir, + "data_dir": self.data_dir, + "comfyui_version": self.comfyui_version, + "last_launched_at": self.last_launched_at, + "status": self.status, + "exists": self.exists, + "selected": selected, + } + + +@dataclass(frozen=True) +class DesktopDetection: + app_data_dir: str + installs: tuple[DesktopInstall, ...] = () + selected: DesktopInstall | None = None + selected_reason: str | None = None + #: Records that exist but could not be read, as ``": "``. + problems: tuple[str, ...] = field(default_factory=tuple) + input_dir: str | None = None + output_dir: str | None = None + output_dir_source: str | None = None + + def to_dict(self) -> dict[str, Any]: + """The ``desktop`` block of ``comfy which`` / ``comfy env``. + + The selected install's fields sit at the top level so an agent reads + ``desktop.data_dir`` directly; ``installs`` lists every local install. + """ + chosen = self.selected + block: dict[str, Any] = { + "install_id": chosen.install_id if chosen else None, + "name": chosen.name if chosen else None, + "code_dir": chosen.code_dir if chosen else None, + "data_dir": chosen.data_dir if chosen else None, + "custom_nodes_dir": os.path.join(chosen.data_dir, "custom_nodes") if chosen else None, + "python": chosen.python if chosen else None, + "model_roots": [root.to_dict() for root in chosen.model_roots] if chosen else [], + "comfyui_version": chosen.comfyui_version if chosen else None, + "comfyui_commit": chosen.comfyui_commit if chosen else None, + "selected_reason": self.selected_reason, + "installs": [install.summary(selected=install is chosen) for install in self.installs], + "app_data_dir": self.app_data_dir, + } + if self.input_dir is not None: + block["input_dir"] = self.input_dir + if self.output_dir is not None: + block["output_dir"] = self.output_dir + block["output_dir_source"] = self.output_dir_source + return block + + +def _same_path(a: str, b: str) -> bool: + try: + return os.path.samefile(a, b) + except OSError: + return os.path.normcase(os.path.realpath(a)) == os.path.normcase(os.path.realpath(b)) + + +def _read_json(path: Path) -> Any: + with open(path, encoding="utf-8") as fh: + return json.load(fh) + + +def _venv_python(venv: Path) -> Path | None: + for candidate in (venv / "bin" / "python3", venv / "bin" / "python", venv / "Scripts" / "python.exe"): + if candidate.is_file(): + return candidate + return None + + +def _code_dir(install_path: Path) -> Path: + """Mirror Desktop's ``resolveComfyDir``: ``/ComfyUI``, or the + install path itself when the checkout sits there directly.""" + nested = install_path / "ComfyUI" + if not nested.is_dir() and (install_path / "main.py").is_file(): + return install_path + return nested + + +def _version_from_marker(code_dir: Path) -> str | None: + try: + match = _VERSION_MARKER_RE.search((code_dir / "comfyui_version.py").read_text(encoding="utf-8")) + except (OSError, UnicodeDecodeError): + return None + return match.group(1) if match else None + + +def _as_tag(version: str) -> str: + version = version.strip() + return "v" + version if _BARE_RELEASE_RE.match(version) else version + + +def _str_list(value: Any) -> list[str]: + return [item for item in value if isinstance(item, str) and item] if isinstance(value, list) else [] + + +def _model_roots(data_dir: Path, record: dict, shared_dirs: list[str]) -> tuple[ModelRoot, ...]: + """Every root ComfyUI searches for this install, in search order, de-duplicated. + + Desktop writes the shared and per-install dirs into an + ``--extra-model-paths-config`` YAML at launch; ComfyUI always searches the + data dir's own ``models/`` as well. + """ + candidates: list[tuple[str, str]] = [(str(data_dir / "models"), "data")] + if record.get("useSharedModels") is not False: + candidates += [(os.path.abspath(os.path.expanduser(d)), "shared") for d in shared_dirs] + candidates += [(os.path.abspath(os.path.expanduser(d)), "install") for d in _str_list(record.get("modelDirs"))] + roots: list[ModelRoot] = [] + for path, source in candidates: + if any(_same_path(path, root.path) for root in roots): + continue + roots.append(ModelRoot(path=path, source=source, exists=os.path.isdir(path))) + return tuple(roots) + + +def _install_from_record( + record: dict, shared_dirs: list[str], legacy_base_path: str | None, *, registry_dir: Path | None = None +) -> DesktopInstall | None: + install_path = record.get("installPath") + if not isinstance(install_path, str) or not install_path: + return None # a remote entry (Comfy Cloud) has no local files + install_root = Path(os.path.expanduser(install_path)) + code_dir = _code_dir(install_root) + adopted = record.get("adopted") is True + base_dir = record.get("adoptedBaseDir") if adopted else None + if adopted and not (isinstance(base_dir, str) and base_dir): + base_dir = legacy_base_path + data_dir = Path(os.path.expanduser(base_dir)) if isinstance(base_dir, str) and base_dir else code_dir + + python: Path | None = None + adopted_python = record.get("adoptedPythonPath") if adopted else None + if isinstance(adopted_python, str) and Path(adopted_python).is_file(): + python = Path(adopted_python) + if python is None: + python = _venv_python(data_dir / ".venv") + + version_record = record.get("comfyVersion") if isinstance(record.get("comfyVersion"), dict) else {} + base_tag = version_record.get("baseTag") + version = base_tag if isinstance(base_tag, str) and base_tag else _version_from_marker(code_dir) + commit = version_record.get("commit") + last_launched = record.get("lastLaunchedAt") + + return DesktopInstall( + install_id=record.get("id") if isinstance(record.get("id"), str) else None, + name=record.get("name") if isinstance(record.get("name"), str) else None, + code_dir=str(code_dir), + data_dir=str(data_dir), + python=str(python) if python else None, + model_roots=_model_roots(data_dir, record, shared_dirs), + comfyui_version=_as_tag(version) if version else None, + comfyui_commit=commit if isinstance(commit, str) and commit else None, + adopted=adopted, + status=record.get("status") if isinstance(record.get("status"), str) else None, + last_launched_ms=last_launched if isinstance(last_launched, (int, float)) and last_launched > 0 else None, + exists=(code_dir / "main.py").is_file(), + registry_dir=str(registry_dir) if registry_dir is not None else None, + ) + + +def _select(installs: tuple[DesktopInstall, ...]) -> tuple[DesktopInstall | None, str | None]: + """Pick the install an agent should assume, and say why.""" + usable = [install for install in installs if install.exists] + if not usable: + return None, None + if len(usable) == 1: + return usable[0], "the only Comfy Desktop install with a ComfyUI checkout on disk" + launched = [install for install in usable if install.last_launched_at] + if launched: + chosen = max(launched, key=lambda install: install.last_launched_ms or 0) + return chosen, ( + f"the most recently launched of {len(usable)} Comfy Desktop installs (last launched " + f"{chosen.last_launched_at}); pass --workspace to pick another" + ) + return usable[0], ( + f"the first of {len(usable)} Comfy Desktop installs in installations.json (none has been launched); " + "pass --workspace to pick another" + ) + + +def app_data_dirs() -> tuple[Path, ...]: + """Known registry folders, keeping an explicit/test override isolated.""" + primary = desktop_app_data_dir() + if primary is None: + return () + if primary.name not in (APP_DIR_NAME, MODERN_APP_DIR_NAME): + return (primary,) + return tuple(dict.fromkeys((primary, primary.parent / MODERN_APP_DIR_NAME, primary.parent / APP_DIR_NAME))) + + +def _argv_values(argv: list[str], flag: str) -> list[str]: + values: list[str] = [] + for index, item in enumerate(argv): + if item.startswith(flag + "="): + values.append(item.split("=", 1)[1]) + elif item == flag and index + 1 < len(argv): + for value in argv[index + 1 :]: + if value.startswith("--"): + break + values.append(value) + if flag != "--extra-model-paths-config": + break + return values + + +def server_launch_paths(stats: dict[str, Any]) -> dict[str, list[str]]: + """Return only known filesystem launch arguments, excluding unrelated credential flags.""" + system = stats.get("system") or {} + argv = system.get("argv") if isinstance(system, dict) else None + if not isinstance(argv, list) or not all(isinstance(arg, str) for arg in argv): + return {} + return { + name: values + for name in ("base_directory", "input_directory", "output_directory", "extra_model_paths_config") + if (values := _argv_values(argv, "--" + name.replace("_", "-"))) + } + + +def _config_identifies_install(config: str, install: DesktopInstall) -> bool: + install_id = install.install_id + if ( + not install.registry_dir + or not install_id + or install_id in (".", "..") + or any(c in install_id for c in "/\\:\x00") + ): + return False + path = Path(config).expanduser() + if not path.is_absolute(): + return False + expected = Path(install.registry_dir) / "instance-model-paths" / f"{install_id}.yaml" + return _same_path(str(path), str(expected)) + + +def _for_server( + found: DesktopDetection, stats: dict[str, Any], *, filesystem_verified: bool = False +) -> DesktopDetection: + """Select using launch identity, never a remembered last-launched record.""" + if not filesystem_verified: + return replace( + found, + selected=None, + selected_reason=None, + input_dir=None, + output_dir=None, + output_dir_source=None, + problems=(*found.problems, "running server filesystem is unverified; pass explicit model/input roots"), + ) + system = stats.get("system") or {} + if not isinstance(system, dict): + system = {} + argv = system.get("argv") or [] + if not isinstance(argv, list) or not all(isinstance(arg, str) for arg in argv): + argv = [] + bases = _argv_values(argv, "--base-directory") + configs = _argv_values(argv, "--extra-model-paths-config") + scripts = [arg for arg in argv if Path(arg).is_absolute() and Path(arg).name == "main.py"] + matches = [ + install + for install in found.installs + if install.exists + and ( + any(_same_path(base, install.data_dir) for base in bases) + or any(_same_path(str(Path(script).parent), install.code_dir) for script in scripts) + or any(_config_identifies_install(config, install) for config in configs) + ) + ] + if len(matches) != 1: + detail = "does not identify one recorded Desktop installation" + return replace( + found, + selected=None, + selected_reason=None, + problems=(*found.problems, f"running server {detail}; pass explicit model/input roots"), + ) + chosen = matches[0] + outputs = _argv_values(argv, "--output-directory") + if any( + not Path(path).expanduser().is_absolute() + for path in (*bases, *_argv_values(argv, "--input-directory"), *outputs) + ): + return replace( + found, + selected=None, + selected_reason=None, + problems=( + *found.problems, + "running server uses relative data/input/output paths; verify its working directory", + ), + ) + data_dir = str(Path(bases[-1]).expanduser()) if bases else chosen.data_dir + roots = [root for root in chosen.model_roots if root.source != "data"] if not configs else [] + roots.insert(0, ModelRoot(str(Path(data_dir) / "models"), "data", (Path(data_dir) / "models").is_dir())) + problems = list(found.problems) + for config in configs: + config_path = Path(config).expanduser() + if not config_path.is_absolute(): + problems.append(f"running server model config is relative: {config}; verify its working directory") + continue + try: + import yaml + + contents = yaml.safe_load(config_path.read_text(encoding="utf-8")) + if not isinstance(contents, dict): + raise ValueError("expected a mapping") + for row in contents.values(): + if not isinstance(row, dict): + continue + base = row.get("base_path") + base_path = None + if isinstance(base, str) and base: + base_path = Path(os.path.expandvars(base)).expanduser() + if not base_path.is_absolute(): + base_path = config_path.parent / base_path + base_path = base_path.resolve() + paths = [base_path] if base_path is not None else [] + for kind, value in row.items(): + if kind in ("base_path", "is_default"): + continue + if not isinstance(value, str): + raise ValueError(f"{kind}: expected newline-separated model paths") + for entry in value.splitlines(): + if not entry: + continue + path = Path(entry) + if not path.is_absolute(): + path = (base_path or config_path.parent) / path + path = path.resolve() + # A base covers its descendant type folders. Keep a + # separate root for absolute paths outside that base. + if base_path is None or not path.is_relative_to(base_path): + paths.append(path) + for path in paths: + if not any(_same_path(str(path), root.path) for root in roots): + roots.append(ModelRoot(str(path), "install", path.is_dir())) + except (OSError, ValueError, yaml.YAMLError) as error: + problems.append(f"{config}: {error}") + python = system.get("python") + version = system.get("comfyui_version") + chosen = replace( + chosen, + comfyui_version=_as_tag(version) if isinstance(version, str) and version else chosen.comfyui_version, + data_dir=data_dir, + model_roots=tuple(roots), + python=python if isinstance(python, str) and Path(python).is_file() else None, + ) + inputs = _argv_values(argv, "--input-directory") + input_dir = str(Path(inputs[-1]).expanduser()) if inputs else str(Path(data_dir) / "input") + return replace( + found, + selected=chosen, + selected_reason="matches the running server launch arguments", + installs=tuple(chosen if item is matches[0] else item for item in found.installs), + input_dir=input_dir, + output_dir=str(Path(outputs[-1]).expanduser()) if outputs else str(Path(data_dir) / "output"), + output_dir_source="server_argv" if outputs else "server_default", + problems=tuple(problems), + ) + + +def detect( + app_data_dir: Path | None = None, + legacy_dir: Path | None = None, + *, + server_stats: dict[str, Any] | None = None, + server_filesystem_verified: bool = False, +) -> DesktopDetection | None: + """Read Desktop 2's install records. ``None`` means Desktop 2 is not installed. + + The app-data dirs default to this OS's; tests pass fixture dirs instead. + Server paths require caller-established local process/filesystem provenance; + matching strings or a loopback URL alone are insufficient. + """ + if app_data_dir is None: + detections = [found for directory in app_data_dirs() if (found := detect(directory, legacy_dir)) is not None] + if not detections: + return None + installs = tuple(install for found in detections for install in found.installs) + selected, reason = _select(installs) + origin = next( + (found.app_data_dir for found in detections if selected in found.installs), detections[0].app_data_dir + ) + found = DesktopDetection( + origin, installs, selected, reason, tuple(problem for item in detections for problem in item.problems) + ) + return ( + _for_server(found, server_stats, filesystem_verified=server_filesystem_verified) + if server_stats is not None + else found + ) + app_dir = app_data_dir + if app_dir is None: + return None + installations_file = app_dir / "installations.json" + if not installations_file.is_file(): + return None + + problems: list[str] = [] + try: + records = _read_json(installations_file) + except (OSError, UnicodeDecodeError, ValueError) as error: + return DesktopDetection(app_data_dir=str(app_dir), problems=(f"{installations_file}: {error}",)) + if not isinstance(records, list): + return DesktopDetection( + app_data_dir=str(app_dir), problems=(f"{installations_file}: expected a list of installs",) + ) + + shared_dirs: list[str] = [] + settings_file = app_dir / "settings.json" + if settings_file.is_file(): + try: + settings = _read_json(settings_file) + shared_dirs = _str_list(settings.get("modelsDirs")) if isinstance(settings, dict) else [] + except (OSError, UnicodeDecodeError, ValueError) as error: + problems.append(f"{settings_file}: {error} (shared model roots are missing from model_roots)") + + legacy_base_path: str | None = None + legacy = legacy_dir if legacy_dir is not None else legacy_config_dir() + if legacy is not None and (legacy / "config.json").is_file(): + try: + config = _read_json(legacy / "config.json") + base = config.get("basePath") if isinstance(config, dict) else None + legacy_base_path = base if isinstance(base, str) and base else None + except (OSError, UnicodeDecodeError, ValueError) as error: + legacy_base_path = None + problems.append(f"{legacy / 'config.json'}: {error}") + + if legacy_base_path is None and any( + isinstance(record, dict) + and record.get("adopted") is True + and not (isinstance(record.get("adoptedBaseDir"), str) and record["adoptedBaseDir"]) + for record in records + ): + problems.append( + "an adopted Desktop installation has no readable data path; its data_dir and derived model roots " + "fall back to the code directory and are unverified" + ) + + installs = tuple( + install + for install in ( + _install_from_record(record, shared_dirs, legacy_base_path, registry_dir=app_dir) + for record in records + if isinstance(record, dict) + ) + if install is not None + ) + selected, reason = _select(installs) + found = DesktopDetection( + app_data_dir=str(app_dir), + installs=installs, + selected=selected, + selected_reason=reason, + problems=tuple(problems), + ) + return ( + _for_server(found, server_stats, filesystem_verified=server_filesystem_verified) + if server_stats is not None + else found + ) + + +def install_for_dir(path: str | os.PathLike[str], detection: DesktopDetection | None = None) -> DesktopInstall | None: + """The Desktop install whose code dir or data dir is ``path``, if any.""" + found = detection if detection is not None else detect() + if found is None: + return None + target = os.fspath(path) + for install in found.installs: + if _same_path(target, install.data_dir) or _same_path(target, install.code_dir): + return install + return None diff --git a/comfy_cli/discovery.py b/comfy_cli/discovery.py index 3568735e8..1581a623e 100644 --- a/comfy_cli/discovery.py +++ b/comfy_cli/discovery.py @@ -22,6 +22,7 @@ # commands that already emit structured output. New commands should register # here as they migrate. COMMAND_SCHEMAS: dict[str, str] = { + "comfy model upload": "model_upload", "comfy env": "env", "comfy which": "which", "comfy run": "run", @@ -46,6 +47,7 @@ "comfy build release manifest": "build_release_manifest", "comfy build release delete": "build_release_delete", "comfy build validate": "build_validate", + "comfy build inventory": "build_inventory", "comfy build delete": "build_delete", "comfy build update": "build_update", "comfy build refs resolve": "build_refs_resolve", @@ -62,6 +64,7 @@ "comfy deploy status": "deploy_status", "comfy deploy ls": "deploy_ls", "comfy deploy show": "deploy_show", + "comfy deploy ui": "deploy_ui", "comfy deploy logs": "deploy_logs", "comfy deploy events": "deploy_events", "comfy deploy scale": "deploy_scale", @@ -120,6 +123,7 @@ "comfy workflow foreach": "workflow", # workflow cloud CRUD + fragment composition "comfy workflow list": "workflow", + "comfy workflow ui": "workflow_ui", "comfy workflow get": "workflow", "comfy workflow save": "workflow", "comfy preview": "preview", diff --git a/comfy_cli/error_codes.py b/comfy_cli/error_codes.py index ff11c8db7..de143558e 100644 --- a/comfy_cli/error_codes.py +++ b/comfy_cli/error_codes.py @@ -37,6 +37,19 @@ class ErrorCode: # --------------------------------------------------------------------------- REGISTRY: tuple[ErrorCode, ...] = ( + ErrorCode( + "model_upload_refused", + "A model import was refused before uploading: missing exact-file approval, changed bytes, " + "wrong workspace, unavailable capability, unsupported type, or a destination-name collision. " + "`details.reason` names the condition; `details.uploaded` is false.", + "preview the import with `comfy model upload --dry-run` and approve the exact file, SHA256 and workspace", + ), + ErrorCode( + "model_upload_failed", + "A model import request or its verification failed. A file may already have reached Cloud; " + "`details.uploaded` is true or unknown. Do not assume retrying is free of effects.", + "inspect the selected workspace's model library before retrying", + ), # --- output / cancellation / lifecycle ----------------------------------- ErrorCode( "cancelled", @@ -65,6 +78,16 @@ class ErrorCode: "Resolved no workspace where one was required (e.g. `comfy which`).", "run `comfy install`, or pass `--workspace`", ), + ErrorCode( + "workspace_not_found", + "The workspace reported by `comfy which` does not exist on disk; details.path names the missing directory.", + "run `comfy install`, or pass `--workspace /path/to/ComfyUI`", + ), + ErrorCode( + "desktop_config_unreadable", + "Comfy Desktop installation records or settings could not be read; discovery may be incomplete.", + "check the Desktop configuration file named in the warning", + ), # --- launch / stop lifecycle --------------------------------------------- ErrorCode( "server_already_running", @@ -149,9 +172,46 @@ class ErrorCode: "truncate it into a corrupt/partial file. `details.limit_bytes` carries the cap.", "the saved workflow is unexpectedly large; inspect it directly on the server", ), + ErrorCode( + "workflow_exists", + "`comfy workflow save --no-overwrite` found a saved workflow file with that name already (HTTP 409 " + "from the `/userdata` write), so nothing was written. `details.filename` is the file under " + "`workflows/`.", + "pass a different `--name`, or drop `--no-overwrite` to replace it", + ), + ErrorCode( + "saved_file_identity_unavailable", + "`comfy workflow save --where cloud` saved the sidebar file, but its write receipt did not return " + "a usable canonical userdata UUID for that exact path. `saved_file_id` is null. Surfaced in " + "`data.warnings[]`: the save succeeded; a same-name or equal-content workflow record does not " + "certify file identity.", + "verify the file in Cloud's Workflows sidebar; do not repeat the save or uploads solely to obtain an ID", + ), + ErrorCode( + "workflow_record_unresolved", + "`comfy workflow save --where cloud` saved the file the Workflows sidebar lists, but could not read " + "back exactly one Cloud workflow record with that name and matching content (none yet, two sharing it, " + "stale mirrored content, or the `/api/workflows` read failed), so `workflow_id` is null. " + "Surfaced in `data.warnings[]`, not as an " + "error envelope: the save succeeded, so do not re-run it.", + "find the record with `comfy --json workflow list --name `", + ), + ErrorCode( + "workflow_filename_ambiguous", + "Cloud `workflow delete` could not safely associate a sidebar filename or file with the requested record " + "because its name, content, or ownership could not be verified. Nothing was deleted.", + "inspect the record and sidebar file; verify the name, content, and ownership before any manual cleanup", + ), + ErrorCode( + "workflow_delete_incomplete", + "Cloud `workflow delete` removed the sidebar file, but could not confirm cleanup of its workflow " + "record. `details.file_deleted` is true; `details.workflow_id` identifies the record to check.", + "check `comfy --json workflow list`, then retry deleting the record if it remains", + ), ErrorCode( "workflow_unparseable", - "A cloud `/api/workflows` call returned a non-empty 200 body that couldn't be decoded as JSON " + "A cloud `/api/workflows` call, or the cloud `/userdata` write `workflow save` makes, returned a " + "non-empty 200 body that couldn't be decoded as JSON " "(non-UTF-8 bytes or a non-JSON body such as an HTML proxy/error page). Distinct from an empty " "body (legitimately no data): the malformed body is surfaced as a hard error rather than a " "misleading empty list / null id. `details.operation` carries the verb.", @@ -956,10 +1016,10 @@ class ErrorCode: ), ErrorCode( "description_ignored", - "`comfy workflow save --where local --description` was given a description, but the local " - "file-backed `/userdata` store has nowhere to keep it. Surfaced in `data.warnings[]` " - "(not as an error envelope) so the save still succeeds.", - "descriptions are a Comfy Cloud feature; drop `--description` on the local path", + "`comfy workflow save --description` was given a description, but the saved workflow is a " + "`/userdata` file (on Cloud, the one the Workflows sidebar lists) with nowhere to keep it. " + "Surfaced in `data.warnings[]` (not as an error envelope) so the save still succeeds.", + "drop `--description`; put notes in the workflow itself, e.g. a Note node", ), ErrorCode( "cql_query_invalid", @@ -1442,7 +1502,9 @@ class ErrorCode: "build_registry_pin_missing", "`comfy build push` sent its identity-keyed public-node subset to the builder's snapshot importer, " "which could not vouch for one or more pins. Pushing anyway would save a definition that cannot " - "reconstruct every requested public node.", + "reconstruct every requested public node. `push --dry-run` makes the same read-only check and " + "refuses the same way, uploading and saving nothing. A version the registry has Flagged " + "is refused here too, though the message does not say so.", "edit the spec to name a published registry version or normalized repository, or remove the node", ), ErrorCode( @@ -1680,6 +1742,23 @@ class ErrorCode: "The deployment id does not exist or is outside the signed-in workspace.", "check the deployment id with `comfy deploy ls --workspace`", ), + ErrorCode( + "cloud_model_asset_verified", + "An informational workflow-validation warning: a model absent from the static enum was verified as " + "an exact accessible authenticated model asset, including folder and content hash. It is not an inference result.", + "compare the recorded asset identity to approved original weights before submitting the workflow", + ), + ErrorCode( + "workflow_ui_unavailable", + "A private saved-workflow URL could not be verified: disabled release capability, wrong workspace, " + "inaccessible or mismatched record/sidebar file, or unavailable custom target. No link or mutation occurred.", + "use Cloud Workflows only after sidebar read-back; otherwise retain the local file or verified deployment API fallback", + ), + ErrorCode( + "deploy_ui_unavailable", + "The authenticated Cloud editor cannot verify this workspace's ready deployment and served release.", + "run `comfy cloud login`, verify the workspace and ready deployment, or use `comfy deploy run`", + ), ErrorCode( "deploy_forbidden", "The signed-in workspace is not allowed to perform the requested deployment operation.", @@ -1747,10 +1826,25 @@ class ErrorCode: "without it landing. Only the watch " "ended: the deployment's outcome is unknown and it may still be coming up. The exit code is 75, not 1, so a " "script can tell this from a deployment that failed. `details.deployment_id` names the deployment.", - "re-attach with `comfy deploy status --deployment --watch` once the deploy service answers again; " + "read `comfy deploy show --deployment ` once the deploy service answers again; watching requires " + "`comfy deploy status --deployment --watch` with this Build's spec; " "after a move, read `comfy deploy show --deployment ` instead: the move has landed once it shows no " "pendingUpdate and its releaseId is the release asked for", ), + ErrorCode( + "watch_auth_lost", + "A watch over work the server had already accepted (`comfy build release create --watch`, `comfy deploy " + "up`, `promote` and `rollback`, `comfy deploy status --watch`) was refused with HTTP 401 despite " + "serialized session recovery and at most one retry, while a refreshable sign-in remains stored. " + "Only the watch ended: the release may still be building and the deployment may still be coming up. " + "The exit code is 75, not 1. `details.releaseId` (build) or " + "`details.deployment_id` (deploy) names what is still running. A 401 before anything was accepted, on a " + "workspace API key, or with no refreshable sign-in remaining stays `build_not_signed_in` or " + "`deploy_not_signed_in`.", + "the stored sign-in was preserved: re-read the work with `comfy build " + "release show ` or `comfy deploy show --deployment `; deployment watching requires " + "`comfy deploy status --deployment --watch` with this Build's spec", + ), ErrorCode( "deploy_update_failed", "`comfy deploy up`, `promote` or `rollback` moved a deployment onto another release, and the watch saw " @@ -1768,7 +1862,7 @@ class ErrorCode: "deployment, and the service cancelled this one. The deployment keeps its id and URL. " "`details.release_id` names the release this move asked for and `details.replacing_release_id` the one " "the newer update moves to.", - "run `comfy deploy status --deployment ` to see the newer update, and, while it still waits, " + "run `comfy deploy show --deployment ` to see the newer update, and, while it still waits, " "`comfy deploy cancel --deployment ` to end it", ), ErrorCode( diff --git a/comfy_cli/local_server_identity.py b/comfy_cli/local_server_identity.py new file mode 100644 index 000000000..08446e698 --- /dev/null +++ b/comfy_cli/local_server_identity.py @@ -0,0 +1,210 @@ +"""Bind inventory metadata to a direct endpoint and, when provable, a local process. + +No server-supplied path establishes filesystem provenance. Process inspection is +read-only, and inability to inspect an owner leaves metadata useful but unverified. +""" + +from __future__ import annotations + +import ipaddress +import json +import os +import socket +import sys +import urllib.error +import urllib.parse +import urllib.request +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +import psutil + +from comfy_cli.command.stop_port import Listener, _is_python_ish, _proc_net_connections +from comfy_cli.http import NoRedirectHandler, build_http_only_opener, read_capped + +_MAX_BYTES = 64 * 1024 * 1024 +_PROCESS_ERRORS = (psutil.AccessDenied, psutil.NoSuchProcess, psutil.ZombieProcess, OSError, NotImplementedError) + + +@dataclass(frozen=True) +class ServerDocument: + data: Any + filesystem_verified: bool = False + + +def _ip(value: str): + address = ipaddress.ip_address(value) + if isinstance(address, ipaddress.IPv6Address): + return address.ipv4_mapped or address + return address + + +def _is_local_address(address: str) -> bool: + candidate = _ip(address) + if candidate.is_loopback: + return True + try: + return any( + candidate == _ip(item.address) + for addresses in psutil.net_if_addrs().values() + for item in addresses + if item.family in (socket.AF_INET, socket.AF_INET6) + ) + except (psutil.Error, OSError, ValueError): + return False + + +def _listener(address: str, port: int) -> Listener | None: + """Find exactly one owner of this local address/port, never a remote namesake.""" + if not _is_local_address(address): + return None + candidate = _ip(address) + owners = {} + try: + processes = list(psutil.process_iter(["pid"])) + except _PROCESS_ERRORS: + return None + for candidate_process in processes: + try: + # process_iter caches Process instances (including create_time). + # A fresh instance per scan must observe PID reuse across the GET. + proc = psutil.Process(candidate_process.pid) + for conn in _proc_net_connections(proc): + bound = conn.laddr + if conn.status != psutil.CONN_LISTEN or not bound or bound.port != port: + continue + ip = _ip(bound.ip) + if ip != candidate and not (ip.is_unspecified and ip.version == candidate.version): + continue + owners[proc.pid] = Listener( + proc.pid, + proc.cmdline(), + proc.cwd(), + proc.name(), + bound.ip, + proc.create_time(), + ) + except _PROCESS_ERRORS: + # A hidden potential owner is not positive evidence. Other matching + # visible owners are still considered; no system-wide privileged API. + continue + return next(iter(owners.values())) if len(owners) == 1 else None + + +def _same_filesystem_namespace(pid: int) -> bool: + if sys.platform.startswith("linux"): + try: + return Path(f"/proc/{pid}/ns/mnt").samefile("/proc/self/ns/mnt") and Path(f"/proc/{pid}/root").samefile("/") + except OSError: + return False + return sys.platform in ("darwin", "win32") + + +def _python_script_argv(cmdline: list[str]) -> list[str] | None: + """The actual script entrypoint, not a later main.py passed as data.""" + if not cmdline or not _is_python_ish(cmdline[0]): + return None + index = 1 + while index < len(cmdline): + token = cmdline[index] + if token == "--": + index += 1 + break + if token in ("-u", "-B", "-E", "-I", "-s", "-S", "-O", "-OO", "-q", "-v", "-b", "-bb", "-d", "-R"): + index += 1 + elif token in ("-X", "-W"): + index += 2 + elif token.startswith(("-X", "-W")) and len(token) > 2: + index += 1 + else: + break + if index >= len(cmdline) or os.path.basename(cmdline[index]) != "main.py": + return None + return cmdline[index:] + + +def _verified(stats: Any, before: Listener | None, after: Listener | None) -> bool: + if before is None or before.create_time is None or before != after: + return False + if not _same_filesystem_namespace(before.pid): + return False + system = stats.get("system") if isinstance(stats, dict) else None + if ( + not isinstance(system, dict) + or not isinstance(system.get("comfyui_version"), str) + or not system["comfyui_version"] + ): + return False + argv = system.get("argv") + if not isinstance(argv, list) or not argv or not all(isinstance(arg, str) for arg in argv): + return False + process_argv = _python_script_argv(before.cmdline) + if process_argv is None or argv[1:] != process_argv[1:]: + return False + script = process_argv[0] + if not os.path.isabs(script): + if not before.cwd or not os.path.isabs(before.cwd): + return False + script = os.path.join(before.cwd, script) + reported = argv[0] + if not os.path.isabs(reported): + if not before.cwd or not os.path.isabs(before.cwd): + return False + reported = os.path.join(before.cwd, reported) + # Windows cross-drive joins can remain drive-relative (C:main.py). + # Such a path would otherwise use the CLI's per-drive cwd, not the owner. + if not os.path.isabs(script) or not os.path.isabs(reported): + return False + try: + return Path(script).is_file() and Path(script).samefile(reported) + except OSError: + return False + + +def fetch_json(url: str, *, verify_filesystem: bool = False) -> ServerDocument: + """Read one direct HTTP endpoint, pinning DNS once and preserving its Host header. + + Proxies and redirects cannot supply local filesystem proof. Address fallback + still supports hostnames resolving to an unavailable IPv6 then a live IPv4 + endpoint. Metadata remains available when local process evidence is missing. + """ + parsed = urllib.parse.urlsplit(url) + if parsed.scheme != "http" or not parsed.hostname or parsed.username or parsed.password: + raise ValueError("inventory requires an uncredentialed http server address") + port = parsed.port or 8188 + addresses = [] + for family, _, _, _, sockaddr in socket.getaddrinfo(parsed.hostname, port, type=socket.SOCK_STREAM): + address = sockaddr[0] + if family == socket.AF_INET6 and sockaddr[3] and "%" not in address: + address += f"%{sockaddr[3]}" + if address not in addresses: + addresses.append(address) + opener = build_http_only_opener(urllib.request.ProxyHandler({}), NoRedirectHandler()) + last_error = None + for address in addresses: + # A wildcard bind address is commonly supplied as --server. Connect to + # its own family's loopback, never treat an unspecified address as proof. + ip = _ip(address) + if ip.is_unspecified: + address = "127.0.0.1" if ip.version == 4 else "::1" + numeric_host = f"[{urllib.parse.quote(address, safe=':')}]" if ":" in address else address + bound_url = urllib.parse.urlunsplit(("http", f"{numeric_host}:{port}", parsed.path, parsed.query, "")) + before = _listener(address, port) if verify_filesystem else None + request = urllib.request.Request(bound_url, headers={"Host": parsed.netloc}) + try: + response = opener.open(request, timeout=10) + except urllib.error.HTTPError: + raise # An HTTP reply is not a failed connection to try elsewhere. + except OSError as error: + last_error = error + continue + # Once this endpoint has answered, a body failure must not select a + # different server from another DNS address. + with response: + data = json.loads(read_capped(response, url, max_bytes=_MAX_BYTES)) + after = _listener(address, port) if before is not None else None + return ServerDocument(data, _verified(data, before, after)) + if last_error is not None: + raise last_error + raise OSError("server hostname resolved to no HTTP addresses") diff --git a/comfy_cli/output/panels.py b/comfy_cli/output/panels.py index e98e31266..0db8d4bcb 100644 --- a/comfy_cli/output/panels.py +++ b/comfy_cli/output/panels.py @@ -224,6 +224,7 @@ def which_panel( server_running: bool = False, server_url: str | None = None, version: str = "0.0.0", + desktop: Mapping[str, Any] | None = None, ) -> Panel: type_badge = Text(workspace_type or "—", style="bold green") if workspace_type else Text("—", style="dim") python_value = Text("—", style="dim") @@ -247,11 +248,21 @@ def which_panel( ) rows: list[tuple[str, Any]] = [ - ("Path", Text(workspace_path, style="bold white")), + ("Path", Text(sanitize_value(workspace_path), style="bold white")), ("Type", type_badge), ("Python", python_value), ("Server", server_value), ] + if desktop: + rows.extend( + [ + ("Desktop code", Text(sanitize_value(desktop["code_dir"]))), + ("Desktop data", Text(sanitize_value(desktop["data_dir"]))), + ("Desktop Python", Text(sanitize_value(desktop["python"] or "—"))), + ("Model roots", Text("\n".join(sanitize_value(root["path"]) for root in desktop["model_roots"]))), + ("Selected because", Text(sanitize_value(desktop["selected_reason"] or "—"))), + ] + ) tbl = Table.grid(padding=(0, 2), expand=False) tbl.add_column(justify="right", style="bold cyan", no_wrap=True) tbl.add_column(overflow="fold") diff --git a/comfy_cli/saved_file_identity.py b/comfy_cli/saved_file_identity.py new file mode 100644 index 000000000..46d7621c0 --- /dev/null +++ b/comfy_cli/saved_file_identity.py @@ -0,0 +1,17 @@ +"""Saved userdata UUID contract shared by save receipts and link publication.""" + +from __future__ import annotations + +import re + +# Browser consumer: uuid11.1.1 validate(), plus lowercase canonical wire form. +# Accept RFC9562 versions1..8 and variants8..b, plus its explicit NIL/MAX cases. +_SAVED_FILE_UUID = re.compile( + r"(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}" + r"|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)" +) + + +def canonical_saved_file_id(value: object) -> str | None: + """Return a received canonical ID, without deriving or coercing one.""" + return value if isinstance(value, str) and _SAVED_FILE_UUID.fullmatch(value) else None diff --git a/comfy_cli/schemas/build_inventory.json b/comfy_cli/schemas/build_inventory.json new file mode 100644 index 000000000..3bd23a053 --- /dev/null +++ b/comfy_cli/schemas/build_inventory.json @@ -0,0 +1,347 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://comfy.org/schemas/build_inventory.json", + "title": "comfy build inventory --json data payload", + "description": "What one workflow loads, which of those files are on this machine, and whether Comfy Cloud's standard environment runs it. `cloud`, `local_server`, `models_roots` and `models_not_on_disk` appear only when --cloud, --server and --models-root/--desktop ask for them.", + "type": "object", + "required": [ + "workflow", + "format", + "classes", + "packs", + "models", + "embeddings", + "inputs", + "skipped", + "implicit", + "warnings", + "node_versions" + ], + "additionalProperties": true, + "properties": { + "workflow": { + "type": "string" + }, + "format": { + "enum": [ + "ui", + "api" + ] + }, + "classes": { + "type": "object", + "description": "Active node classes (muted/bypassed nodes excluded): count, the pack that recorded them, and the versions recorded.", + "additionalProperties": { + "type": "object", + "required": [ + "count", + "pack", + "ver" + ], + "properties": { + "count": { + "type": "integer" + }, + "pack": { + "type": "string" + }, + "ver": { + "type": "array", + "items": { + "type": "string" + } + } + } + } + }, + "packs": { + "type": "object", + "additionalProperties": { + "type": "array", + "items": { + "type": "string" + } + } + }, + "models": { + "type": "array", + "items": { + "type": "object", + "required": [ + "value", + "path", + "basename", + "subfolder", + "node", + "node_id" + ], + "properties": { + "value": { + "type": [ + "string", + "null" + ], + "description": "The widget value as saved." + }, + "path": { + "type": "string", + "description": "`value` with Windows separators turned into `/`." + }, + "basename": { + "type": "string" + }, + "subfolder": { + "type": [ + "string", + "null" + ] + }, + "url_hint": { + "type": [ + "string", + "null" + ] + }, + "node": { + "type": "string" + }, + "node_id": {}, + "local": { + "type": "array", + "items": { + "type": "object" + } + } + } + } + }, + "model_hints": { + "type": "array", + "items": {"type": "object"}, + "description": "Unselected template download hints. These are not required model references; verify against the runtime graph/source." + }, + "embeddings": { + "type": "array", + "items": { + "type": "object" + } + }, + "inputs": { + "type": "array", + "items": { + "type": "object", + "required": [ + "file", + "node" + ], + "properties": { + "file": { + "type": "string" + }, + "node": { + "type": "string" + }, + "node_id": {}, + "local_path": { + "type": [ + "string", + "null" + ], + "description": "Where --input-root found the file." + }, + "cloud_name": { + "type": "string", + "description": "blake3 of the file's bytes plus its extension: the name Cloud stores an upload of it under." + }, + "on_cloud": { + "type": "boolean", + "description": "cloud_name is listed in the loader's Cloud choices. False means not listed, which is not proof it is absent." + } + } + } + }, + "skipped": { + "type": "array", + "items": { + "type": "object" + } + }, + "implicit": { + "type": "array", + "items": { + "type": "object", + "required": [ + "class", + "note" + ] + } + }, + "warnings": { + "type": "array", + "items": { + "type": "string" + } + }, + "unverified": { + "type": "array", + "items": {"type": "string"}, + "description": "UI bindings requiring a local API export before dependencies can be verified." + }, + "deployment_assets": { + "type": "array", + "description": "API workflows only: exact local file plan from deploy run's scanner; no file is uploaded.", + "items": { + "type": "object", + "required": ["local_path", "file_path", "bytes"], + "properties": { + "local_path": {"type": "string"}, + "file_path": {"type": "string"}, + "bytes": {"type": "integer", "minimum": 0} + } + } + }, + "deployment_asset_roots": { + "type": "array", + "items": {"type": "string"}, + "description": "Resolved automatic and explicit roots used for deployment_assets. Use the same cwd and roots when running." + }, + "node_versions": { + "type": "object" + }, + "models_roots": { + "type": "array", + "items": { + "type": "string" + } + }, + "models_not_on_disk": { + "type": "array", + "items": { + "type": "string" + } + }, + "local_server": { + "type": "object", + "properties": { + "launch_paths": { + "type": "object", + "description": "Known path-only launch arguments; unrelated argv flags and credentials are excluded.", + "properties": { + "base_directory": {"type": "array", "items": {"type": "string"}}, + "input_directory": {"type": "array", "items": {"type": "string"}}, + "output_directory": {"type": "array", "items": {"type": "string"}}, + "extra_model_paths_config": {"type": "array", "items": {"type": "string"}} + } + } + } + }, + "cloud": { + "type": "object", + "required": [ + "verdict", + "blocking", + "missing_classes", + "cloud_disabled", + "lossless_removable", + "models", + "unverified" + ], + "properties": { + "verdict": { + "enum": [ + "covered", + "covered_after_lossless_fixes", + "covered_needs_check", + "needs_build_or_lossy_conversion" + ] + }, + "blocking": { + "type": "array", + "items": { + "type": "string" + } + }, + "missing_classes": { + "type": "array", + "items": { + "type": "string" + } + }, + "cloud_disabled": { + "type": "array", + "items": { + "type": "string" + } + }, + "models": { + "type": "array", + "items": { + "type": "object", + "required": [ + "path", + "status" + ], + "properties": { + "status": { + "enum": [ + "present", + "remap", + "absent", + "node_missing" + ] + }, + "weights": { + "enum": [ + "same_size", + "different_size", + "no_local_copy", + "unknown", + "not_checked", + "ambiguous_local_copies" + ], + "description": "Local copy vs Cloud's same-named file. different_size proves a mismatch. All other states leave model identity unverified; ambiguous_local_copies means multiple local candidates were not proved identical by SHA256." + } + } + } + }, + "unverified": { + "type": "array", + "items": { + "type": "string" + } + }, + "readiness": { + "type": "object", + "description": "Runtime inputs are checked separately from dependency compatibility. Neither status establishes a successful job.", + "required": ["status", "unresolved_inputs"], + "properties": { + "status": {"enum": ["needs_inputs", "not_run"]}, + "unresolved_inputs": { + "type": "array", + "items": { + "type": "object", + "required": ["node_id", "file", "reason"], + "properties": { + "node_id": {}, + "file": {"type": "string"}, + "reason": {"type": "string"} + } + } + } + } + }, + "lossless_removable": { + "type": "array", + "description": "Memory- or speed-only nodes Cloud lacks; removing them does not change the output.", + "items": { + "type": "object", + "required": [ + "class", + "why" + ] + } + } + } + } + } +} diff --git a/comfy_cli/schemas/cloud_workflow_0_4.json b/comfy_cli/schemas/cloud_workflow_0_4.json new file mode 100644 index 000000000..4039d5248 --- /dev/null +++ b/comfy_cli/schemas/cloud_workflow_0_4.json @@ -0,0 +1,2716 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "revision": { + "type": "number" + }, + "config": { + "anyOf": [ + { + "type": "object", + "properties": { + "links_ontop": { + "type": "boolean" + }, + "align_to_grid": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + { + "type": "null" + } + ] + }, + "subgraphs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "size": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "flags": { + "type": "object", + "properties": { + "collapsed": { + "type": "boolean" + }, + "pinned": { + "type": "boolean" + }, + "allow_interaction": { + "type": "boolean" + }, + "horizontal": { + "type": "boolean" + }, + "skip_repeated_outputs": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + "order": { + "type": "number" + }, + "mode": { + "type": "number" + }, + "inputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "outputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "widgets_values": { + "anyOf": [ + { + "type": "array", + "items": {} + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + } + ] + }, + "color": { + "type": "string" + }, + "bgcolor": { + "type": "string" + } + }, + "required": [ + "id", + "type", + "pos", + "size", + "flags", + "order", + "mode" + ], + "additionalProperties": {} + } + }, + "last_node_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "last_link_id": { + "type": "number" + }, + "nodes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "type": "string" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "size": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "flags": { + "type": "object", + "properties": { + "collapsed": { + "type": "boolean" + }, + "pinned": { + "type": "boolean" + }, + "allow_interaction": { + "type": "boolean" + }, + "horizontal": { + "type": "boolean" + }, + "skip_repeated_outputs": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + "order": { + "type": "number" + }, + "mode": { + "type": "number" + }, + "inputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + }, + "required": [ + "name", + "type" + ], + "additionalProperties": {} + } + }, + "outputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "links": { + "anyOf": [ + { + "type": "array", + "items": { + "type": "number" + } + }, + { + "type": "null" + } + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + }, + "required": [ + "name", + "type" + ], + "additionalProperties": {} + } + }, + "properties": { + "type": "object", + "properties": { + "Node name for S&R": { + "type": "string" + }, + "cnr_id": { + "type": "string", + "minLength": 1, + "maxLength": 100, + "pattern": "^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$" + }, + "aux_id": { + "type": "string", + "pattern": "^[^/]+\\/[^/]+$" + }, + "ver": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "string", + "const": "unknown" + } + ] + }, + "models": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "url": { + "type": "string", + "format": "uri" + }, + "hash": { + "type": "string" + }, + "hash_type": { + "type": "string" + }, + "directory": { + "type": "string" + } + }, + "required": [ + "name", + "url", + "directory" + ] + } + } + }, + "additionalProperties": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + }, + { + "type": "array", + "items": {} + } + ] + } + }, + "widgets_values": { + "anyOf": [ + { + "type": "array", + "items": {} + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + } + ] + }, + "color": { + "type": "string" + }, + "bgcolor": { + "type": "string" + } + }, + "required": [ + "id", + "type", + "pos", + "size", + "flags", + "order", + "mode", + "properties" + ], + "additionalProperties": {} + } + }, + "links": { + "type": "array", + "items": { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + } + ], + "items": false, + "minItems": 6, + "maxItems": 6 + } + }, + "floatingLinks": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "origin_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "origin_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "parentId": { + "type": "number" + }, + "hidden": { + "type": "boolean" + }, + "label": { + "type": "string" + } + }, + "required": [ + "id", + "origin_id", + "origin_slot", + "target_id", + "target_slot", + "type" + ], + "additionalProperties": {} + } + }, + "groups": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "title": { + "type": "string" + }, + "bounding": { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 4, + "maxItems": 4 + }, + "color": { + "type": "string" + }, + "font_size": { + "type": "number" + }, + "locked": { + "type": "boolean" + } + }, + "required": [ + "title", + "bounding" + ], + "additionalProperties": {} + } + }, + "extra": { + "anyOf": [ + { + "type": "object", + "properties": { + "ds": { + "type": "object", + "properties": { + "scale": { + "type": "number" + }, + "offset": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + } + }, + "required": [ + "scale", + "offset" + ], + "additionalProperties": {} + }, + "frontendVersion": { + "type": "string" + }, + "linkExtensions": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "parentId": { + "type": "number" + } + }, + "required": [ + "id", + "parentId" + ], + "additionalProperties": {} + } + }, + "linkPresentation": { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": { + "type": "object", + "properties": { + "hidden": { + "type": "boolean" + }, + "label": { + "type": "string" + } + }, + "additionalProperties": {} + } + }, + "reroutes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "parentId": { + "type": "number" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "linkIds": { + "anyOf": [ + { + "type": "array", + "items": { + "type": "number" + } + }, + { + "type": "null" + } + ] + }, + "floating": { + "type": "object", + "properties": { + "slotType": { + "type": "string", + "enum": [ + "input", + "output" + ] + } + }, + "required": [ + "slotType" + ] + } + }, + "required": [ + "id", + "pos" + ], + "additionalProperties": {} + } + }, + "workflowRendererVersion": { + "type": "string", + "enum": [ + "LG", + "Vue", + "Vue-corrected" + ] + }, + "BlueprintDescription": { + "type": "string" + }, + "BlueprintSearchAliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "linearMode": { + "type": "boolean" + }, + "linearData": { + "type": "object", + "properties": { + "inputs": { + "type": "array", + "items": { + "anyOf": [ + { + "type": "array", + "prefixItems": [ + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "type": "string" + }, + { + "type": "object", + "properties": { + "height": { + "type": "number" + } + }, + "additionalProperties": {} + } + ], + "items": false, + "minItems": 3, + "maxItems": 3 + }, + { + "type": "array", + "prefixItems": [ + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "type": "string" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + } + }, + "outputs": { + "type": "array", + "items": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + } + } + } + }, + "additionalProperties": {} + }, + { + "type": "null" + } + ] + }, + "version": { + "type": "number" + }, + "models": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "url": { + "type": "string", + "format": "uri" + }, + "hash": { + "type": "string" + }, + "hash_type": { + "type": "string" + }, + "directory": { + "type": "string" + } + }, + "required": [ + "name", + "url", + "directory" + ] + } + }, + "definitions": { + "type": "object", + "properties": { + "subgraphs": { + "type": "array", + "items": { + "$ref": "#/$defs/__schema0" + } + } + }, + "required": [ + "subgraphs" + ] + } + }, + "required": [ + "last_node_id", + "last_link_id", + "nodes", + "links", + "version" + ], + "additionalProperties": {}, + "$defs": { + "__schema0": { + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "revision": { + "type": "number" + }, + "config": { + "anyOf": [ + { + "type": "object", + "properties": { + "links_ontop": { + "type": "boolean" + }, + "align_to_grid": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + { + "type": "null" + } + ] + }, + "subgraphs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "size": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "flags": { + "type": "object", + "properties": { + "collapsed": { + "type": "boolean" + }, + "pinned": { + "type": "boolean" + }, + "allow_interaction": { + "type": "boolean" + }, + "horizontal": { + "type": "boolean" + }, + "skip_repeated_outputs": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + "order": { + "type": "number" + }, + "mode": { + "type": "number" + }, + "inputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "outputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "widgets_values": { + "anyOf": [ + { + "type": "array", + "items": {} + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + } + ] + }, + "color": { + "type": "string" + }, + "bgcolor": { + "type": "string" + } + }, + "required": [ + "id", + "type", + "pos", + "size", + "flags", + "order", + "mode" + ], + "additionalProperties": {} + } + }, + "version": { + "type": "number", + "const": 1 + }, + "state": { + "type": "object", + "properties": { + "lastGroupId": { + "type": "number" + }, + "lastNodeId": { + "type": "number" + }, + "lastLinkId": { + "type": "number" + }, + "lastRerouteId": { + "type": "number" + } + }, + "required": [ + "lastGroupId", + "lastNodeId", + "lastLinkId", + "lastRerouteId" + ], + "additionalProperties": {} + }, + "groups": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "title": { + "type": "string" + }, + "bounding": { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 4, + "maxItems": 4 + }, + "color": { + "type": "string" + }, + "font_size": { + "type": "number" + }, + "locked": { + "type": "boolean" + } + }, + "required": [ + "title", + "bounding" + ], + "additionalProperties": {} + } + }, + "nodes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "type": "string" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "size": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "flags": { + "type": "object", + "properties": { + "collapsed": { + "type": "boolean" + }, + "pinned": { + "type": "boolean" + }, + "allow_interaction": { + "type": "boolean" + }, + "horizontal": { + "type": "boolean" + }, + "skip_repeated_outputs": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + "order": { + "type": "number" + }, + "mode": { + "type": "number" + }, + "inputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + }, + "required": [ + "name", + "type" + ], + "additionalProperties": {} + } + }, + "outputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "links": { + "anyOf": [ + { + "type": "array", + "items": { + "type": "number" + } + }, + { + "type": "null" + } + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + }, + "required": [ + "name", + "type" + ], + "additionalProperties": {} + } + }, + "properties": { + "type": "object", + "properties": { + "Node name for S&R": { + "type": "string" + }, + "cnr_id": { + "type": "string", + "minLength": 1, + "maxLength": 100, + "pattern": "^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$" + }, + "aux_id": { + "type": "string", + "pattern": "^[^/]+\\/[^/]+$" + }, + "ver": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "string", + "const": "unknown" + } + ] + }, + "models": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "url": { + "type": "string", + "format": "uri" + }, + "hash": { + "type": "string" + }, + "hash_type": { + "type": "string" + }, + "directory": { + "type": "string" + } + }, + "required": [ + "name", + "url", + "directory" + ] + } + } + }, + "additionalProperties": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + }, + { + "type": "array", + "items": {} + } + ] + } + }, + "widgets_values": { + "anyOf": [ + { + "type": "array", + "items": {} + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + } + ] + }, + "color": { + "type": "string" + }, + "bgcolor": { + "type": "string" + } + }, + "required": [ + "id", + "type", + "pos", + "size", + "flags", + "order", + "mode", + "properties" + ], + "additionalProperties": {} + } + }, + "links": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "origin_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "origin_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "parentId": { + "type": "number" + }, + "hidden": { + "type": "boolean" + }, + "label": { + "type": "string" + } + }, + "required": [ + "id", + "origin_id", + "origin_slot", + "target_id", + "target_slot", + "type" + ], + "additionalProperties": {} + } + }, + "floatingLinks": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "origin_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "origin_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "parentId": { + "type": "number" + }, + "hidden": { + "type": "boolean" + }, + "label": { + "type": "string" + } + }, + "required": [ + "id", + "origin_id", + "origin_slot", + "target_id", + "target_slot", + "type" + ], + "additionalProperties": {} + } + }, + "reroutes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "parentId": { + "type": "number" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "linkIds": { + "anyOf": [ + { + "type": "array", + "items": { + "type": "number" + } + }, + { + "type": "null" + } + ] + }, + "floating": { + "type": "object", + "properties": { + "slotType": { + "type": "string", + "enum": [ + "input", + "output" + ] + } + }, + "required": [ + "slotType" + ] + } + }, + "required": [ + "id", + "pos" + ], + "additionalProperties": {} + } + }, + "extra": { + "anyOf": [ + { + "type": "object", + "properties": { + "ds": { + "type": "object", + "properties": { + "scale": { + "type": "number" + }, + "offset": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + } + }, + "required": [ + "scale", + "offset" + ], + "additionalProperties": {} + }, + "frontendVersion": { + "type": "string" + }, + "linkExtensions": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "parentId": { + "type": "number" + } + }, + "required": [ + "id", + "parentId" + ], + "additionalProperties": {} + } + }, + "linkPresentation": { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": { + "type": "object", + "properties": { + "hidden": { + "type": "boolean" + }, + "label": { + "type": "string" + } + }, + "additionalProperties": {} + } + }, + "reroutes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "parentId": { + "type": "number" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "linkIds": { + "anyOf": [ + { + "type": "array", + "items": { + "type": "number" + } + }, + { + "type": "null" + } + ] + }, + "floating": { + "type": "object", + "properties": { + "slotType": { + "type": "string", + "enum": [ + "input", + "output" + ] + } + }, + "required": [ + "slotType" + ] + } + }, + "required": [ + "id", + "pos" + ], + "additionalProperties": {} + } + }, + "workflowRendererVersion": { + "type": "string", + "enum": [ + "LG", + "Vue", + "Vue-corrected" + ] + }, + "BlueprintDescription": { + "type": "string" + }, + "BlueprintSearchAliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "linearMode": { + "type": "boolean" + }, + "linearData": { + "type": "object", + "properties": { + "inputs": { + "type": "array", + "items": { + "anyOf": [ + { + "type": "array", + "prefixItems": [ + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "type": "string" + }, + { + "type": "object", + "properties": { + "height": { + "type": "number" + } + }, + "additionalProperties": {} + } + ], + "items": false, + "minItems": 3, + "maxItems": 3 + }, + { + "type": "array", + "prefixItems": [ + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "type": "string" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + } + }, + "outputs": { + "type": "array", + "items": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + } + } + } + }, + "additionalProperties": {} + }, + { + "type": "null" + } + ] + }, + "models": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "url": { + "type": "string", + "format": "uri" + }, + "hash": { + "type": "string" + }, + "hash_type": { + "type": "string" + }, + "directory": { + "type": "string" + } + }, + "required": [ + "name", + "url", + "directory" + ] + } + }, + "definitions": { + "type": "object", + "properties": { + "subgraphs": { + "type": "array", + "items": { + "$ref": "#/$defs/__schema0" + } + } + }, + "required": [ + "subgraphs" + ] + }, + "name": { + "type": "string" + }, + "description": { + "type": "string" + }, + "category": { + "type": "string" + }, + "essentials_category": { + "type": "string" + }, + "inputNode": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "bounding": { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 4, + "maxItems": 4 + }, + "pinned": { + "type": "boolean" + } + }, + "required": [ + "id", + "bounding" + ] + }, + "outputNode": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "bounding": { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 4, + "maxItems": 4 + }, + "pinned": { + "type": "boolean" + } + }, + "required": [ + "id", + "bounding" + ] + }, + "inputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "outputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "widgets": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "name": { + "type": "string" + } + }, + "required": [ + "id", + "name" + ] + } + } + }, + "required": [ + "id", + "revision", + "version", + "state", + "nodes", + "name", + "inputNode", + "outputNode" + ], + "additionalProperties": {} + } + } +} \ No newline at end of file diff --git a/comfy_cli/schemas/cloud_workflow_1_0.json b/comfy_cli/schemas/cloud_workflow_1_0.json new file mode 100644 index 000000000..f0ea26c75 --- /dev/null +++ b/comfy_cli/schemas/cloud_workflow_1_0.json @@ -0,0 +1,2820 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "revision": { + "type": "number" + }, + "config": { + "anyOf": [ + { + "type": "object", + "properties": { + "links_ontop": { + "type": "boolean" + }, + "align_to_grid": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + { + "type": "null" + } + ] + }, + "subgraphs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "size": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "flags": { + "type": "object", + "properties": { + "collapsed": { + "type": "boolean" + }, + "pinned": { + "type": "boolean" + }, + "allow_interaction": { + "type": "boolean" + }, + "horizontal": { + "type": "boolean" + }, + "skip_repeated_outputs": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + "order": { + "type": "number" + }, + "mode": { + "type": "number" + }, + "inputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "outputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "widgets_values": { + "anyOf": [ + { + "type": "array", + "items": {} + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + } + ] + }, + "color": { + "type": "string" + }, + "bgcolor": { + "type": "string" + } + }, + "required": [ + "id", + "type", + "pos", + "size", + "flags", + "order", + "mode" + ], + "additionalProperties": {} + } + }, + "version": { + "type": "number", + "const": 1 + }, + "state": { + "type": "object", + "properties": { + "lastGroupId": { + "type": "number" + }, + "lastNodeId": { + "type": "number" + }, + "lastLinkId": { + "type": "number" + }, + "lastRerouteId": { + "type": "number" + } + }, + "required": [ + "lastGroupId", + "lastNodeId", + "lastLinkId", + "lastRerouteId" + ], + "additionalProperties": {} + }, + "groups": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "title": { + "type": "string" + }, + "bounding": { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 4, + "maxItems": 4 + }, + "color": { + "type": "string" + }, + "font_size": { + "type": "number" + }, + "locked": { + "type": "boolean" + } + }, + "required": [ + "title", + "bounding" + ], + "additionalProperties": {} + } + }, + "nodes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "type": "string" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "size": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "flags": { + "type": "object", + "properties": { + "collapsed": { + "type": "boolean" + }, + "pinned": { + "type": "boolean" + }, + "allow_interaction": { + "type": "boolean" + }, + "horizontal": { + "type": "boolean" + }, + "skip_repeated_outputs": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + "order": { + "type": "number" + }, + "mode": { + "type": "number" + }, + "inputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + }, + "required": [ + "name", + "type" + ], + "additionalProperties": {} + } + }, + "outputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "links": { + "anyOf": [ + { + "type": "array", + "items": { + "type": "number" + } + }, + { + "type": "null" + } + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + }, + "required": [ + "name", + "type" + ], + "additionalProperties": {} + } + }, + "properties": { + "type": "object", + "properties": { + "Node name for S&R": { + "type": "string" + }, + "cnr_id": { + "type": "string", + "minLength": 1, + "maxLength": 100, + "pattern": "^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$" + }, + "aux_id": { + "type": "string", + "pattern": "^[^/]+\\/[^/]+$" + }, + "ver": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "string", + "const": "unknown" + } + ] + }, + "models": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "url": { + "type": "string", + "format": "uri" + }, + "hash": { + "type": "string" + }, + "hash_type": { + "type": "string" + }, + "directory": { + "type": "string" + } + }, + "required": [ + "name", + "url", + "directory" + ] + } + } + }, + "additionalProperties": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + }, + { + "type": "array", + "items": {} + } + ] + } + }, + "widgets_values": { + "anyOf": [ + { + "type": "array", + "items": {} + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + } + ] + }, + "color": { + "type": "string" + }, + "bgcolor": { + "type": "string" + } + }, + "required": [ + "id", + "type", + "pos", + "size", + "flags", + "order", + "mode", + "properties" + ], + "additionalProperties": {} + } + }, + "links": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "origin_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "origin_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "parentId": { + "type": "number" + }, + "hidden": { + "type": "boolean" + }, + "label": { + "type": "string" + } + }, + "required": [ + "id", + "origin_id", + "origin_slot", + "target_id", + "target_slot", + "type" + ], + "additionalProperties": {} + } + }, + "floatingLinks": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "origin_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "origin_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "parentId": { + "type": "number" + }, + "hidden": { + "type": "boolean" + }, + "label": { + "type": "string" + } + }, + "required": [ + "id", + "origin_id", + "origin_slot", + "target_id", + "target_slot", + "type" + ], + "additionalProperties": {} + } + }, + "reroutes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "parentId": { + "type": "number" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "linkIds": { + "anyOf": [ + { + "type": "array", + "items": { + "type": "number" + } + }, + { + "type": "null" + } + ] + }, + "floating": { + "type": "object", + "properties": { + "slotType": { + "type": "string", + "enum": [ + "input", + "output" + ] + } + }, + "required": [ + "slotType" + ] + } + }, + "required": [ + "id", + "pos" + ], + "additionalProperties": {} + } + }, + "extra": { + "anyOf": [ + { + "type": "object", + "properties": { + "ds": { + "type": "object", + "properties": { + "scale": { + "type": "number" + }, + "offset": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + } + }, + "required": [ + "scale", + "offset" + ], + "additionalProperties": {} + }, + "frontendVersion": { + "type": "string" + }, + "linkExtensions": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "parentId": { + "type": "number" + } + }, + "required": [ + "id", + "parentId" + ], + "additionalProperties": {} + } + }, + "linkPresentation": { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": { + "type": "object", + "properties": { + "hidden": { + "type": "boolean" + }, + "label": { + "type": "string" + } + }, + "additionalProperties": {} + } + }, + "reroutes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "parentId": { + "type": "number" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "linkIds": { + "anyOf": [ + { + "type": "array", + "items": { + "type": "number" + } + }, + { + "type": "null" + } + ] + }, + "floating": { + "type": "object", + "properties": { + "slotType": { + "type": "string", + "enum": [ + "input", + "output" + ] + } + }, + "required": [ + "slotType" + ] + } + }, + "required": [ + "id", + "pos" + ], + "additionalProperties": {} + } + }, + "workflowRendererVersion": { + "type": "string", + "enum": [ + "LG", + "Vue", + "Vue-corrected" + ] + }, + "BlueprintDescription": { + "type": "string" + }, + "BlueprintSearchAliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "linearMode": { + "type": "boolean" + }, + "linearData": { + "type": "object", + "properties": { + "inputs": { + "type": "array", + "items": { + "anyOf": [ + { + "type": "array", + "prefixItems": [ + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "type": "string" + }, + { + "type": "object", + "properties": { + "height": { + "type": "number" + } + }, + "additionalProperties": {} + } + ], + "items": false, + "minItems": 3, + "maxItems": 3 + }, + { + "type": "array", + "prefixItems": [ + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "type": "string" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + } + }, + "outputs": { + "type": "array", + "items": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + } + } + } + }, + "additionalProperties": {} + }, + { + "type": "null" + } + ] + }, + "models": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "url": { + "type": "string", + "format": "uri" + }, + "hash": { + "type": "string" + }, + "hash_type": { + "type": "string" + }, + "directory": { + "type": "string" + } + }, + "required": [ + "name", + "url", + "directory" + ] + } + }, + "definitions": { + "type": "object", + "properties": { + "subgraphs": { + "type": "array", + "items": { + "$ref": "#/$defs/__schema0" + } + } + }, + "required": [ + "subgraphs" + ] + } + }, + "required": [ + "version", + "state", + "nodes" + ], + "additionalProperties": {}, + "$defs": { + "__schema0": { + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "revision": { + "type": "number" + }, + "config": { + "anyOf": [ + { + "type": "object", + "properties": { + "links_ontop": { + "type": "boolean" + }, + "align_to_grid": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + { + "type": "null" + } + ] + }, + "subgraphs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "size": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "flags": { + "type": "object", + "properties": { + "collapsed": { + "type": "boolean" + }, + "pinned": { + "type": "boolean" + }, + "allow_interaction": { + "type": "boolean" + }, + "horizontal": { + "type": "boolean" + }, + "skip_repeated_outputs": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + "order": { + "type": "number" + }, + "mode": { + "type": "number" + }, + "inputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "outputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "widgets_values": { + "anyOf": [ + { + "type": "array", + "items": {} + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + } + ] + }, + "color": { + "type": "string" + }, + "bgcolor": { + "type": "string" + } + }, + "required": [ + "id", + "type", + "pos", + "size", + "flags", + "order", + "mode" + ], + "additionalProperties": {} + } + }, + "version": { + "type": "number", + "const": 1 + }, + "state": { + "type": "object", + "properties": { + "lastGroupId": { + "type": "number" + }, + "lastNodeId": { + "type": "number" + }, + "lastLinkId": { + "type": "number" + }, + "lastRerouteId": { + "type": "number" + } + }, + "required": [ + "lastGroupId", + "lastNodeId", + "lastLinkId", + "lastRerouteId" + ], + "additionalProperties": {} + }, + "groups": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "title": { + "type": "string" + }, + "bounding": { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 4, + "maxItems": 4 + }, + "color": { + "type": "string" + }, + "font_size": { + "type": "number" + }, + "locked": { + "type": "boolean" + } + }, + "required": [ + "title", + "bounding" + ], + "additionalProperties": {} + } + }, + "nodes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "type": "string" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "size": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "flags": { + "type": "object", + "properties": { + "collapsed": { + "type": "boolean" + }, + "pinned": { + "type": "boolean" + }, + "allow_interaction": { + "type": "boolean" + }, + "horizontal": { + "type": "boolean" + }, + "skip_repeated_outputs": { + "type": "boolean" + } + }, + "additionalProperties": {} + }, + "order": { + "type": "number" + }, + "mode": { + "type": "number" + }, + "inputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + }, + "required": [ + "name", + "type" + ], + "additionalProperties": {} + } + }, + "outputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "links": { + "anyOf": [ + { + "type": "array", + "items": { + "type": "number" + } + }, + { + "type": "null" + } + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + }, + "required": [ + "name", + "type" + ], + "additionalProperties": {} + } + }, + "properties": { + "type": "object", + "properties": { + "Node name for S&R": { + "type": "string" + }, + "cnr_id": { + "type": "string", + "minLength": 1, + "maxLength": 100, + "pattern": "^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$" + }, + "aux_id": { + "type": "string", + "pattern": "^[^/]+\\/[^/]+$" + }, + "ver": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "string", + "const": "unknown" + } + ] + }, + "models": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "url": { + "type": "string", + "format": "uri" + }, + "hash": { + "type": "string" + }, + "hash_type": { + "type": "string" + }, + "directory": { + "type": "string" + } + }, + "required": [ + "name", + "url", + "directory" + ] + } + } + }, + "additionalProperties": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "number" + }, + { + "type": "boolean" + }, + { + "type": "null" + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + }, + { + "type": "array", + "items": {} + } + ] + } + }, + "widgets_values": { + "anyOf": [ + { + "type": "array", + "items": {} + }, + { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": {} + } + ] + }, + "color": { + "type": "string" + }, + "bgcolor": { + "type": "string" + } + }, + "required": [ + "id", + "type", + "pos", + "size", + "flags", + "order", + "mode", + "properties" + ], + "additionalProperties": {} + } + }, + "links": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "origin_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "origin_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "parentId": { + "type": "number" + }, + "hidden": { + "type": "boolean" + }, + "label": { + "type": "string" + } + }, + "required": [ + "id", + "origin_id", + "origin_slot", + "target_id", + "target_slot", + "type" + ], + "additionalProperties": {} + } + }, + "floatingLinks": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "origin_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "origin_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "target_slot": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "type": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "array", + "items": { + "type": "string" + } + }, + { + "type": "number" + } + ] + }, + "parentId": { + "type": "number" + }, + "hidden": { + "type": "boolean" + }, + "label": { + "type": "string" + } + }, + "required": [ + "id", + "origin_id", + "origin_slot", + "target_id", + "target_slot", + "type" + ], + "additionalProperties": {} + } + }, + "reroutes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "parentId": { + "type": "number" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "linkIds": { + "anyOf": [ + { + "type": "array", + "items": { + "type": "number" + } + }, + { + "type": "null" + } + ] + }, + "floating": { + "type": "object", + "properties": { + "slotType": { + "type": "string", + "enum": [ + "input", + "output" + ] + } + }, + "required": [ + "slotType" + ] + } + }, + "required": [ + "id", + "pos" + ], + "additionalProperties": {} + } + }, + "extra": { + "anyOf": [ + { + "type": "object", + "properties": { + "ds": { + "type": "object", + "properties": { + "scale": { + "type": "number" + }, + "offset": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + } + }, + "required": [ + "scale", + "offset" + ], + "additionalProperties": {} + }, + "frontendVersion": { + "type": "string" + }, + "linkExtensions": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "parentId": { + "type": "number" + } + }, + "required": [ + "id", + "parentId" + ], + "additionalProperties": {} + } + }, + "linkPresentation": { + "type": "object", + "propertyNames": { + "type": "string" + }, + "additionalProperties": { + "type": "object", + "properties": { + "hidden": { + "type": "boolean" + }, + "label": { + "type": "string" + } + }, + "additionalProperties": {} + } + }, + "reroutes": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "number" + }, + "parentId": { + "type": "number" + }, + "pos": { + "anyOf": [ + { + "type": "object", + "properties": { + "0": { + "type": "number" + }, + "1": { + "type": "number" + } + }, + "required": [ + "0", + "1" + ], + "additionalProperties": {} + }, + { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + }, + "linkIds": { + "anyOf": [ + { + "type": "array", + "items": { + "type": "number" + } + }, + { + "type": "null" + } + ] + }, + "floating": { + "type": "object", + "properties": { + "slotType": { + "type": "string", + "enum": [ + "input", + "output" + ] + } + }, + "required": [ + "slotType" + ] + } + }, + "required": [ + "id", + "pos" + ], + "additionalProperties": {} + } + }, + "workflowRendererVersion": { + "type": "string", + "enum": [ + "LG", + "Vue", + "Vue-corrected" + ] + }, + "BlueprintDescription": { + "type": "string" + }, + "BlueprintSearchAliases": { + "type": "array", + "items": { + "type": "string" + } + }, + "linearMode": { + "type": "boolean" + }, + "linearData": { + "type": "object", + "properties": { + "inputs": { + "type": "array", + "items": { + "anyOf": [ + { + "type": "array", + "prefixItems": [ + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "type": "string" + }, + { + "type": "object", + "properties": { + "height": { + "type": "number" + } + }, + "additionalProperties": {} + } + ], + "items": false, + "minItems": 3, + "maxItems": 3 + }, + { + "type": "array", + "prefixItems": [ + { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + { + "type": "string" + } + ], + "items": false, + "minItems": 2, + "maxItems": 2 + } + ] + } + }, + "outputs": { + "type": "array", + "items": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + } + } + } + } + }, + "additionalProperties": {} + }, + { + "type": "null" + } + ] + }, + "models": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "url": { + "type": "string", + "format": "uri" + }, + "hash": { + "type": "string" + }, + "hash_type": { + "type": "string" + }, + "directory": { + "type": "string" + } + }, + "required": [ + "name", + "url", + "directory" + ] + } + }, + "definitions": { + "type": "object", + "properties": { + "subgraphs": { + "type": "array", + "items": { + "$ref": "#/$defs/__schema0" + } + } + }, + "required": [ + "subgraphs" + ] + }, + "name": { + "type": "string" + }, + "description": { + "type": "string" + }, + "category": { + "type": "string" + }, + "essentials_category": { + "type": "string" + }, + "inputNode": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "bounding": { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 4, + "maxItems": 4 + }, + "pinned": { + "type": "boolean" + } + }, + "required": [ + "id", + "bounding" + ] + }, + "outputNode": { + "type": "object", + "properties": { + "id": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "bounding": { + "type": "array", + "prefixItems": [ + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + }, + { + "type": "number" + } + ], + "items": false, + "minItems": 4, + "maxItems": 4 + }, + "pinned": { + "type": "boolean" + } + }, + "required": [ + "id", + "bounding" + ] + }, + "inputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "outputs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "type": { + "type": "string" + }, + "link": { + "type": [ + "number", + "null" + ] + }, + "slot_index": { + "anyOf": [ + { + "type": "integer", + "minimum": -9007199254740991, + "maximum": 9007199254740991 + }, + { + "type": "string" + } + ] + }, + "id": { + "type": "string", + "format": "uuid", + "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$" + }, + "linkIds": { + "type": "array", + "items": { + "type": "number" + } + } + }, + "required": [ + "name", + "type", + "id" + ], + "additionalProperties": {} + } + }, + "widgets": { + "type": "array", + "items": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "name": { + "type": "string" + } + }, + "required": [ + "id", + "name" + ] + } + } + }, + "required": [ + "id", + "revision", + "version", + "state", + "nodes", + "name", + "inputNode", + "outputNode" + ], + "additionalProperties": {} + } + } +} \ No newline at end of file diff --git a/comfy_cli/schemas/cloud_workflow_provenance.md b/comfy_cli/schemas/cloud_workflow_provenance.md new file mode 100644 index 000000000..8dadcbeaf --- /dev/null +++ b/comfy_cli/schemas/cloud_workflow_provenance.md @@ -0,0 +1,28 @@ +# Saved-canvas schema provenance + +These files are generated from the matching frontend consumer, not a handwritten subset. + +Frontend base commit: `78492d6a93837f192a4ae21582cdf05ef8bcb9ad`. The source hashes also capture uncommitted changes. + +- `src/platform/workflow/validation/schemas/workflowSchema.ts` SHA256 `9485268f5cd12305ffb03d4ffc711588846a59fb603bb4311add0a16063e4a49` +- `src/types/linkId.ts` SHA256 `ebcec86190f31e0e3a5738659cdf00d8b07850388b7ac7d663cbe9beaf0546e0` +- `src/lib/litegraph/src/types/widgets.ts` SHA256 `31af22f25acb97b868b7006b9b6ca9fb4f5d401608019040f774fdde8243ca85` + +Generated structural schema files (byte-identical input exports): + +- `cloud_workflow_0_4.json` SHA256 `6b0b93c0b37ae24947723f98e99e13b9d53ced9ef45ff6d83dc0c83d4decbf5f` +- `cloud_workflow_1_0.json` SHA256 `e76e9948865b34b14fe6616b4a37a7932143bcde225eb6b6d544117c6d371377` + +Regenerate from the frontend checkout with its locked dependencies: + +```sh +FRONTEND_ROOT="$PWD" node --import tsx /path/to/cli/scripts/export_cloud_workflow_schemas.mjs /path/to/cli/comfy_cli/schemas +``` + +The export uses `z.toJSONSchema(schema, {io: "input", unrepresentable: "any"})`, matching the frontend generator. `cloud_workflow_schema.py` annotates only known schema positions to restore the omitted input acceptance checks: slot parseInt validity, aux_id repository rules, pack version rules, canonical presentation link IDs, and a strict cnr_id fullmatch to bridge Python/JavaScript final-newline regex semantics. It never interprets opaque widget/metadata object keys as graph structure. Vector normalization changes frontend output, not acceptance; widget custom validation accepts every plain JSON value. + +`tests/comfy_cli/fixtures/cloud_workflow_consumer/corpus.json` has 826 inputs accepted/rejected by actual `validateComfyWorkflow`; the generator records normalized outputs. Regenerate that corpus after every schema source change and compare Python acceptance before releasing a private-link capability. + +URL input acceptance uses the WHATWG Ada parser through `ada-url>=4,<5` (verified with 4.0.0). The Python adapter converts strings to Unicode scalar values using UTF-16 surrogate replacement, matching browser USVString handling, and calls `URL.can_parse` without a base or network access. It validates acceptance only and preserves the original graph bytes. The official 4.0.0 wheels require Python 3.10 or newer and cover the project's existing CPython Windows, macOS, and Linux CI targets; other architectures/interpreters may require the source distribution. No Node runtime is required by the CLI. + +All 826 frontend oracle inputs match Python acceptance, including 466 URL cases, with three additional adapter tests for network independence, absent implicit base, and fail-closed parser unavailability. The complete 829-test group also passes independently on Python 3.10.21 and 3.12.11. These results apply to the recorded frontend source and corpus; repeat the comparison when either changes. diff --git a/comfy_cli/schemas/deploy_ui.json b/comfy_cli/schemas/deploy_ui.json new file mode 100644 index 000000000..fbe11dcb0 --- /dev/null +++ b/comfy_cli/schemas/deploy_ui.json @@ -0,0 +1,15 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://comfy.org/schemas/deploy_ui.json", + "title": "comfy deploy ui --json data payload", + "description": "A Cloud editor URL confirmed against the authenticated workspace's editor deployment listing and the ready control-plane record. Contains no credentials; opening it still requires the browser's signed-in session.", + "type": "object", + "required": ["workspaceId", "deploymentId", "releaseId", "url"], + "additionalProperties": false, + "properties": { + "workspaceId": {"type": "string", "minLength": 1}, + "deploymentId": {"type": "string", "minLength": 1}, + "releaseId": {"type": "string", "minLength": 1}, + "url": {"type": "string", "format": "uri"} + } +} diff --git a/comfy_cli/schemas/env.json b/comfy_cli/schemas/env.json index fced0c67a..0e91f88f9 100644 --- a/comfy_cli/schemas/env.json +++ b/comfy_cli/schemas/env.json @@ -6,6 +6,14 @@ "required": ["python", "config", "workspace", "server"], "additionalProperties": true, "properties": { + "warnings": { + "type": "array", + "items": { + "type": "object", + "required": ["code", "message"], + "properties": {"code": {"type": "string"}, "message": {"type": "string"}} + } + }, "python": { "type": "object", "required": ["version", "executable"], @@ -31,6 +39,36 @@ "type": "object", "additionalProperties": true, "properties": { + "exists": {"type": "boolean", "description": "Whether the workspace directory exists on disk."}, + "desktop": { + "type": "object", + "description": "Desktop installation records, including separate code, data, Python, and model roots.", + "properties": { + "code_dir": {"type": ["string", "null"]}, + "data_dir": {"type": ["string", "null"]}, + "custom_nodes_dir": {"type": ["string", "null"]}, + "python": {"type": ["string", "null"]}, + "input_dir": {"type": "string", "description": "Effective input directory of the selected running Desktop server."}, + "output_dir": {"type": "string", "description": "Effective output directory of the selected running Desktop server."}, + "output_dir_source": {"enum": ["server_argv", "server_default"]}, + "selected_reason": {"type": ["string", "null"]}, + "comfyui_version": {"type": ["string", "null"]}, + "model_roots": { + "type": "array", + "items": { + "type": "object", + "required": ["path", "source", "exists"], + "properties": { + "path": {"type": "string"}, + "source": {"enum": ["data", "shared", "install"]}, + "exists": {"type": "boolean"} + } + } + }, + "installs": {"type": "array", "items": {"type": "object"}}, + "problems": {"type": "array", "items": {"type": "string"}} + } + }, "path": {"type": ["string", "null"]}, "type": {"type": ["string", "null"]}, "manager_mode": {"type": ["string", "null"]}, diff --git a/comfy_cli/schemas/model_upload.json b/comfy_cli/schemas/model_upload.json new file mode 100644 index 000000000..57bb683f2 --- /dev/null +++ b/comfy_cli/schemas/model_upload.json @@ -0,0 +1,34 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://comfy.org/schemas/model_upload.json", + "title": "comfy model upload --json data payload", + "description": "Content-bound model-library import plan or verified upload. No job is submitted. Null estimates/costs are unknown, never zero. --dry-run never uploads; mutation requires --yes and the approved SHA256/workspace.", + "type": "object", + "required": ["file", "name", "model_type", "size_bytes", "sha256", "hash", "workspace_id", "destination", "environment", "uploaded", "dry_run", "execution_state"], + "properties": { + "file": {"type": "string"}, + "name": {"type": "string"}, + "model_type": {"type": "string"}, + "size_bytes": {"type": "integer", "minimum": 0}, + "sha256": {"type": "string", "pattern": "^[0-9a-f]{64}$"}, + "hash": {"type": "string", "pattern": "^blake3:[0-9a-f]{64}$"}, + "workspace_id": {"type": "string"}, + "workspace_name": {"type": ["string", "null"]}, + "destination": {"type": "string", "format": "uri"}, + "environment": {"const": "standard"}, + "uploaded": {"type": "boolean"}, + "deduped": {"type": "boolean"}, + "dry_run": {"type": "boolean"}, + "license": {"type": "string"}, + "nsfw": {"type": "string"}, + "estimated_upload_seconds": {"type": ["number", "null"]}, + "upload_cost": {"type": ["number", "null"]}, + "storage_cost": {"type": ["number", "null"]}, + "compute_cost": {"type": ["number", "null"]}, + "execution_state": {"const": "prepared, not run"}, + "asset_id": {"type": "string"}, + "loader_path": {"type": "string"}, + "created_new": {"type": ["boolean", "null"]} + }, + "additionalProperties": false +} diff --git a/comfy_cli/schemas/which.json b/comfy_cli/schemas/which.json index a727e4510..f160595ef 100644 --- a/comfy_cli/schemas/which.json +++ b/comfy_cli/schemas/which.json @@ -6,6 +6,44 @@ "required": ["workspace_path"], "additionalProperties": true, "properties": { + "exists": {"type": "boolean", "description": "Whether the workspace directory exists on disk."}, + "desktop": { + "type": "object", + "description": "Desktop installation records, including separate code, data, Python, and model roots.", + "properties": { + "code_dir": {"type": ["string", "null"]}, + "data_dir": {"type": ["string", "null"]}, + "custom_nodes_dir": {"type": ["string", "null"]}, + "python": {"type": ["string", "null"]}, + "input_dir": {"type": "string", "description": "Effective input directory of the selected running Desktop server."}, + "output_dir": {"type": "string", "description": "Effective output directory of the selected running Desktop server."}, + "output_dir_source": {"enum": ["server_argv", "server_default"]}, + "selected_reason": {"type": ["string", "null"]}, + "comfyui_version": {"type": ["string", "null"]}, + "model_roots": { + "type": "array", + "items": { + "type": "object", + "required": ["path", "source", "exists"], + "properties": { + "path": {"type": "string"}, + "source": {"enum": ["data", "shared", "install"]}, + "exists": {"type": "boolean"} + } + } + }, + "installs": {"type": "array", "items": {"type": "object"}}, + "problems": {"type": "array", "items": {"type": "string"}} + } + }, + "warnings": { + "type": "array", + "items": { + "type": "object", + "required": ["code", "message"], + "properties": {"code": {"type": "string"}, "message": {"type": "string"}} + } + }, "workspace_path": {"type": ["string", "null"]}, "workspace_type": {"type": ["string", "null"]} } diff --git a/comfy_cli/schemas/workflow.json b/comfy_cli/schemas/workflow.json index 2869ab1f3..5b52ecf01 100644 --- a/comfy_cli/schemas/workflow.json +++ b/comfy_cli/schemas/workflow.json @@ -5,6 +5,11 @@ "type": "object", "properties": { "workflow": { "type": "string" }, + "saved_file_id": { + "type": ["string", "null"], + "format": "uuid", + "description": "Cloud save: actual userdata UUID from the write receipt, distinct from the mirrored workflow_id record. Null when the server cannot certify file identity; do not repeat the save." + }, "count": { "type": "integer" }, "total": { "type": "integer", diff --git a/comfy_cli/schemas/workflow_ui.json b/comfy_cli/schemas/workflow_ui.json new file mode 100644 index 000000000..15650a319 --- /dev/null +++ b/comfy_cli/schemas/workflow_ui.json @@ -0,0 +1,23 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://comfy.org/schemas/workflow_ui.json", + "title": "comfy workflow ui --json data payload", + "description": "Read-only normal private saved-workflow identity and environment link, emitted only with the matching release capability, authenticated workspace and exact UUID-bound userdata snapshot. Opening still requires the browser's signed-in session; it changes browser selection without mutating compute.", + "type": "object", + "additionalProperties": false, + "required": ["savedFileId", "workspaceId", "environment", "filename", "verified", "url"], + "properties": { + "savedFileId": {"type": "string", "format": "uuid"}, + "workspaceId": {"type": "string", "minLength": 1}, + "environment": {"enum": ["standard", "custom"]}, + "filename": {"type": "string", "pattern": "^workflows/.+\\.json$"}, + "verified": {"const": true}, + "url": {"type": "string", "format": "uri"}, + "deploymentId": {"type": "string", "minLength": 1}, + "releaseId": {"type": "string", "minLength": 1} + }, + "allOf": [ + {"if": {"properties": {"environment": {"const": "custom"}}}, "then": {"required": ["deploymentId", "releaseId"]}}, + {"if": {"properties": {"environment": {"const": "standard"}}}, "then": {"not": {"anyOf": [{"required": ["deploymentId"]}, {"required": ["releaseId"]}]}}} + ] +} diff --git a/comfy_cli/skills/__init__.py b/comfy_cli/skills/__init__.py index c813bafdb..ede42a7b8 100644 --- a/comfy_cli/skills/__init__.py +++ b/comfy_cli/skills/__init__.py @@ -49,6 +49,7 @@ ("comfy-build", "comfy-build"), ("comfy-deploy", "comfy-deploy"), ("comfy-custom-nodes", "comfy-custom-nodes"), + ("comfy-run-on-cloud", "comfy-run-on-cloud"), ) @@ -82,6 +83,7 @@ ("comfy-custom-nodes-frontend", "comfy-custom-nodes-frontend"), ("comfy-custom-nodes-migration", "comfy-custom-nodes-migration"), ("comfy-custom-nodes-caching", "comfy-custom-nodes-caching"), + ("comfy-run-on-cloud-local-install", "comfy-run-on-cloud-local-install"), ) diff --git a/comfy_cli/skills/comfy-build-failures/SKILL.md b/comfy_cli/skills/comfy-build-failures/SKILL.md index 02bb12b51..03d5d0ae4 100644 --- a/comfy_cli/skills/comfy-build-failures/SKILL.md +++ b/comfy_cli/skills/comfy-build-failures/SKILL.md @@ -102,8 +102,13 @@ can take (a model's `sourceUri`, a node's `registryVersion` or `repository`), fi - `resolves to a duplicate node directory` — two entries claim one folder, so one of them goes. - `build_registry_pin_missing` — the builder could not place a public pack. - The message names each identity; correct the `registryVersion` against a - registry search, or remove the pack. + `push --dry-run` refuses the same way, before anything is uploaded or saved. + The message names each identity but not why. A version the registry has + Flagged lands here: check its `status` at + `https://api.comfy.org/nodes//versions`, and pin a version that is not + `NodeVersionStatusFlagged`, or the pack's `repository` and a commit `gitRef`. + Otherwise correct the `registryVersion` against a registry search, or remove + the pack. - `build_spec_stale` — the remote moved under you, or `--id` names a Build the spec's `syncedRevision` does not belong to. See *Revising*. @@ -153,6 +158,18 @@ cause completely, in one cut. Do not split its edits across cuts, and do not gue at a second cause in the same cut. Before each new cut, tell the user the cause, the exact edit, and which build this is, and wait. +**A missing import needs an installation mechanism before another cut.** Read +the selected pack's verified source and declared requirements, or establish a +supported builder installation path. A `pipDependencies` constraint only pins a +package installed by another mechanism; adding `PyYAML==` does not by +itself install a missing `yaml` import. First verify what will install the +package, then select a compatible constraint if needed. A changed local source +bundle also needs approval for its changed contents and bytes before upload. +When no verified installation mechanism exists, report that blocker and ask for +the missing source or supported installation choice. Do not propose or create a +fresh paid cut merely to try an otherwise unsupported pin, even if the previous +repair plan was approved. + **Read in this order.** 1. `comfy build release show` — **`failureReason` is per target, at diff --git a/comfy_cli/skills/comfy-build/SKILL.md b/comfy_cli/skills/comfy-build/SKILL.md index 83a2e85ce..e3faf5878 100644 --- a/comfy_cli/skills/comfy-build/SKILL.md +++ b/comfy_cli/skills/comfy-build/SKILL.md @@ -76,7 +76,10 @@ blob ls (hidden; workspace private blobs that reaches the builder need it; a plain scan and a plain `validate` do not. A CI job sets a workspace API key in `COMFY_CLOUD_API_KEY` instead, and that key wins over a stored sign-in, so when the hint says that key was refused, - signing in cannot help: replace the key. + signing in cannot help: replace the key. `watch_auth_lost` (exit 75) means + `release create --watch` was refused after the cut despite session recovery, + while a refreshable sign-in remains stored. The release may still be building. + Read it with `comfy build release show ` before considering a new sign-in. On `build_not_enabled` the platform is in limited beta and this account is not enabled — stop and say so. @@ -103,6 +106,11 @@ the one the situation calls for rather than guessing at its contents: All four converge on the same file, then the same `validate → push → release` tail. +If the goal is one workflow running on Comfy Cloud ("Run on Cloud", or "put this +workflow on Cloud") rather than an environment, read +`comfy skills show comfy-run-on-cloud` first: Comfy Cloud's standard environment or an existing +custom environment may already run it, and a build it needs carries only what that workflow loads. + --- ## Path A — from a ComfyUI install @@ -114,10 +122,13 @@ comfy build validate comfy build push --dry-run ``` -Everything above is offline and spends nothing. `validate` reads the spec, and -`--dry-run` computes every upload without instantiating an HTTP client at all. -Read what it plans, decide the pins, run the conflict prediction in -`comfy-build-pins`, disclose, get a yes. Only then: +Everything above spends nothing. `validate` reads the spec offline. `--dry-run` +computes every upload locally and makes one read: it asks the builder to place +each public pack, and refuses with `build_registry_pin_missing` exactly as `push` +would, so a pin the push cannot save fails here, before you disclose the plan. +A spec that pins a public pack therefore needs sign-in for the dry run; one whose +packs are all local sends nothing. Read what it plans, decide the pins, run the +conflict prediction in `comfy-build-pins`, disclose, get a yes. Only then: ```shell comfy build push @@ -192,7 +203,8 @@ comfy --json build init --name --from-workflow .json never carries — `comfy-build-authoring` is that procedure. - **The pack pins are the registry's newest published version**, because a workflow names none. Importing the same file next week can then build something - else. Say that out loud. + else. Say that out loud. The newest can be a version the registry has Flagged, + which the builder will not place, so run `push --dry-run` before you disclose. - **A workflow names no ComfyUI version either**, so set one before cutting: `comfy build update --comfy-version `, or edit `baseComfyVersion`. - **`unresolvedClasses` is the list to take to the user.** Those node classes are @@ -227,7 +239,11 @@ show the user rather than as instructions to act on. - **Whether a registry pin exists.** `push` asks the builder to place every public pack before it saves, and refuses with `build_registry_pin_missing` naming each identity it could not resolve. If that lookup itself fails, the - command **exits** — it does not warn and proceed. + command **exits** — it does not warn and proceed. `push --dry-run` makes the + same check. A version the registry has **Flagged** is refused this way too, + and the message does not say so: read the version's `status` from + `https://api.comfy.org/nodes//versions`, then pin a version that is not + `NodeVersionStatusFlagged`, or pin the pack by `repository` and a commit `gitRef`. **A local pack is uploaded from the spec.** `push` packages each custom node directory and uploads it, so a pack that publishes nothing still travels. diff --git a/comfy_cli/skills/comfy-deploy-failures/SKILL.md b/comfy_cli/skills/comfy-deploy-failures/SKILL.md index cb44d581b..201613bae 100644 --- a/comfy_cli/skills/comfy-deploy-failures/SKILL.md +++ b/comfy_cli/skills/comfy-deploy-failures/SKILL.md @@ -51,10 +51,11 @@ argument you pass. | `deploy_ambiguous_build` | Two or more Builds share the name before the slash | Name the Build by its id, as `/` | | `deploy_forbidden` | The workspace does not permit this | Confirm which workspace is signed in | | `deploy_not_signed_in` | No usable Cloud session or workspace API key, or the key was refused | Replace the key the hint names; otherwise `comfy cloud login` | -| `deploy_server_error` | Control plane unavailable or 5xx | Re-read `status` before retrying, so a retry cannot double-create | -| `deploy_update_replaced` | A watched `up`, `promote` or `rollback` was replaced by a newer update; `details.replacing_release_id` names its release | Follow it with `comfy deploy status --deployment `, or end it with `comfy deploy cancel --deployment ` | +| `deploy_server_error` | Control plane unavailable or 5xx | Re-read `comfy deploy show --deployment ` before retrying, so a retry cannot double-create | +| `deploy_update_replaced` | A watched `up`, `promote` or `rollback` was replaced by a newer update; `details.replacing_release_id` names its release | Read it with `comfy deploy show --deployment `, or end it with `comfy deploy cancel --deployment ` | | `deploy_updates_unavailable` | `promote`, `rollback`, `history`, `cancel` or `events --release` on a deployment with no `revision`, or `cancel` against a deploy service too old for it | `promote` or `rollback`: `up --create` on the release instead. `history`: read `events`. `cancel`: wait for the update to land or fail. `events`: drop `--release`; those events do not say which release made them | -| `deploy_watch_lost` | The watch's reads went unanswered for a minute, or a move by `up`, `promote` or `rollback` did not land within an hour (exit 75); the deployment may still be coming up | `comfy deploy status --deployment --watch`, or after a move `comfy deploy show --deployment ` until it shows no `pendingUpdate`; do not redeploy | +| `deploy_watch_lost` | The watch's reads went unanswered for a minute, or a move by `up`, `promote` or `rollback` did not land within an hour (exit 75); the deployment may still be coming up | Read `comfy deploy show --deployment ` from any folder; watching requires `comfy deploy status --deployment --watch` with this Build's verified spec. After a move, read until no `pendingUpdate`; do not redeploy | +| `watch_auth_lost` | A watch's read was refused with a 401 despite session recovery, and a refreshable sign-in remains stored (exit 75); the deployment may still be coming up | Reattach as for `deploy_watch_lost` before considering a new sign-in; do not redeploy | | `deploy_delete_needs_confirm` | `delete` without `--yes` non-interactively | Confirm with the user, then pass `--yes` | ### Submitting a workflow diff --git a/comfy_cli/skills/comfy-deploy/SKILL.md b/comfy_cli/skills/comfy-deploy/SKILL.md index 46893eceb..9e4454955 100644 --- a/comfy_cli/skills/comfy-deploy/SKILL.md +++ b/comfy_cli/skills/comfy-deploy/SKILL.md @@ -171,11 +171,17 @@ provisioning". Things to read correctly: - No `progress` at all is an older service, or a status other than the two above. Interrupting the wait leaves the deployment coming up on the service's side; -`comfy deploy status --deployment --watch` attaches again. A deploy API that +read `comfy deploy show --deployment ` from any folder. To watch again, +use `comfy deploy status --deployment --watch` with this Build's +verified spec. A deploy API that stops answering (a 5xx or a dropped connection, as during its own rollout) is retried for about a minute; if it is still down, the wait ends with `deploy_watch_lost` and **exit 75**, not 1. That is not a failed deployment: attach again with the command in the hint rather than redeploying. +`watch_auth_lost`, also exit 75, is a read refused with a 401 despite session +recovery, while a refreshable sign-in remains stored. Parallel requests adopt a +peer's refreshed token and retry at most once. Attach again the same way before +considering a new sign-in; the deployment may still be coming up. `status` also reports **why** a deployment stopped, as `stopReason`: `user`, `credits`, or `policy`. `credits` is a billing problem and not something a retry diff --git a/comfy_cli/skills/comfy-run-on-cloud-local-install/SKILL.md b/comfy_cli/skills/comfy-run-on-cloud-local-install/SKILL.md new file mode 100644 index 000000000..eb1cb16c7 --- /dev/null +++ b/comfy_cli/skills/comfy-run-on-cloud-local-install/SKILL.md @@ -0,0 +1,85 @@ +--- +name: comfy-run-on-cloud-local-install +description: "Reference skill cited by comfy-run-on-cloud. Read it with `comfy skills show comfy-run-on-cloud-local-install` when finding the local ComfyUI install behind a workflow: the running server, Comfy Desktop's split layout on macOS, extra model roots, what to do when the server is not running, and what each finding means for the build." +--- + +# comfy-run-on-cloud-local-install + +Use `comfy --json which` / `comfy --json env` for verified paths and the `desktop` +block (code/data directories, interpreter, model roots, selection reason and candidate +installs). Older CLI versions can report a nonexistent default with `ok: true`; +confirm paths on disk. Last-launched selection is a discovery hint, not evidence +that it is the server running the workflow. +A missing selected workspace leaves the Desktop candidate in `which` error `details.desktop` or `env` data `workspace.desktop`; that candidate is neither the selected workspace nor proof of the running process. + +## Best source: the running server + +When ComfyUI is running, it already knows its version, its classes and which pack provides +each one. + +| Install | Default port | +|---|---| +| Comfy Desktop | 8000 | +| OSS / comfy-cli | 8188 | + +```shell +curl -s http://127.0.0.1:/system_stats # system.comfyui_version, argv, python +curl -s http://127.0.0.1:/object_info # per class: python_module = custom_nodes. +``` + +`comfy --json build inventory --server ` joins these against the workflow. +It returns the classes missing locally and the local pack directory behind each custom class. + +## Comfy Desktop (macOS) layout + +Desktop splits one install across up to three places: + +| What | Where to read it | +|---|---| +| Data dir: `models/`, `custom_nodes/`, `.venv/`, `user/` | Selected install's `adoptedBaseDir` for adopted installs (legacy `ComfyUI/config.json` → `basePath` fallback); otherwise its code directory. The running server's `--base-directory` overrides these records. | +| Code dir: the ComfyUI git checkout | Both `~/Library/Application Support/comfyui-desktop-2/installations.json` and the older `…/Comfy Desktop/installations.json` → `installPath` (usually `/ComfyUI`). Each registry can list several installs. | +| Extra or shared model roots | The selected registry's `settings.json` → `modelsDirs` and install record's `modelDirs`/`useSharedModels`. With a verified local process, use its `--extra-model-paths-config` YAML files at their full registry-owned paths instead of stale settings. The startup log prints effective search paths. OSS installs use `extra_model_paths.yaml`. Keep libraries from different registries separate. | +| ComfyUI version | `installations.json` → `comfyVersion.baseTag`. `git -C describe --tags` works too. | + +`build inventory --desktop --server ` requires direct-endpoint, local Python +process and shared-filesystem proof before automatic Desktop selection; a loopback +address alone is insufficient. It then matches an absolute code/data path or the full generated +`/instance-model-paths/.yaml` path to one recorded +install, reads its effective model roots, and uses `--input-directory` (default +`/input`) unless explicit `--input-root` values were supplied. It reports +`desktop` and `input_roots`. +The selected server's `--output-directory` (default `/output`) is reported +as `desktop.output_dir`, with `output_dir_source` distinguishing an explicit +argument from the server default. That directory joins the exact deployment asset +scan so a referenced prior output can be approved as an input; unrelated outputs +are not included. Pass the reported `deployment_asset_roots` explicitly to the +run's `--asset-root` values. `local_server.launch_paths` contains only known path +arguments, without unrelated credentials or the raw process argument list. +Remote, forwarded or unverified endpoints retain reported catalog/metadata but +need explicit verified local roots, as do unmatched or ambiguous installs and +relative launch paths with unknown working directory. Missing roots produce +`root_not_found` warnings; resolve them before claiming complete inventory. +Without a server, `--desktop` uses one unambiguous install or one settings-only +library. It does not combine several unrelated installations. + +If several installs are listed and their versions or data dirs differ, ask which one runs +the workflow; the newest is not necessarily the one. If they agree, use it without asking. + +## When the server is not running + +Do not start it just to read it. Fall back to files: + +- version: `installations.json` → `comfyVersion.baseTag`, or `git describe` in the code dir; +- packs: one directory per pack under `/custom_nodes/`. Read each `pyproject.toml` + (`[project] name`, `version`, `[tool.comfy] PublisherId`) and `git -C rev-parse HEAD` + if it is a checkout. Without `object_info`, map a workflow class to a pack by the node's + `cnr_id`, or by grepping `NODE_CLASS_MAPPINGS` in the pack source; +- models: `build inventory --models-root` over every root; it does not need the server. + +## Consequences for the build + +- **Search every model root,** not just `/models`. `--models-dir` takes one directory; pass every root to `build inventory` with `--models-root`. +- **Keep shared-root inventory separate from upload scope.** Read-only inventory must search every active root, including shared libraries. A workflow-scoped build includes only selected dependencies. Whole-instance packaging includes a shared root only after the user approves that named root and its listed uploads. +- **Pass the verified interpreter** from the selected install's `desktop.python` (or the running process's interpreter) to any `comfy build` command that needs one. Check it exists. Adopted installs may use `adoptedPythonPath`; do not assume every instance uses `/.venv/bin/python`. +- **A spec written with `-o` outside the install needs `--models-dir` and `--custom-nodes-dir`** on every later `validate`, `push` and `status`. Without them, local `localPath` entries fail to resolve. +- **Do not use the Desktop snapshot path (`--from-snapshot`) as the definition source.** It can predate the installed packs and return an empty build with no warning. diff --git a/comfy_cli/skills/comfy-run-on-cloud/PROMPT-TEMPLATE.md b/comfy_cli/skills/comfy-run-on-cloud/PROMPT-TEMPLATE.md new file mode 100644 index 000000000..b186d644c --- /dev/null +++ b/comfy_cli/skills/comfy-run-on-cloud/PROMPT-TEMPLATE.md @@ -0,0 +1,75 @@ +# The Run on Cloud handoff + +Modal title: **Run on Comfy Cloud** + +Body: **We’ll start your local agent to get this workflow running on Comfy Cloud. You’ll approve any local file uploads along the way.** + +CTA: **Let’s go** + +Let’s go sends this prompt to the integrated local agent. **Copy prompt** supplies the same handoff for Claude or Codex when integration is unavailable; keep **Open in platform** as a fallback. Do not put build name, GPU, new/update or scope fields in this modal. Ask build choices in the agent conversation only when a custom Build is needed; if reusing a Build needs a new deployment, ask only the missing deployment choices and approval. + +Save the canvas to a workflow JSON file first. The **Workflow** path is required and must be real. Fill known context from the running app; omit unknown optional lines rather than guessing. If the local agent cannot read that path, resolve it before proceeding. + +```text +Run my ComfyUI workflow on Comfy Cloud. + +Read the skill first and follow it: + comfy skills show comfy-run-on-cloud +(If comfy is missing: uv tool install comfy-cli — it is separate from ComfyUI Desktop. +Verify this skill and build inventory are supported. Upgrade once through the existing +package manager if needed; if still unavailable, report the version/blocker and stop.) + +Workflow: {absolute path to the saved workflow JSON} +ComfyUI: {running local server URL} · {Desktop | source | portable} {version} +Workspace: {workspace name and id, if known} + +Check Comfy Cloud's standard environment with my original dependencies, including +supported bring-your-own models/LoRAs. If it cannot run the original, check compatible +existing custom environments (workspace Builds) before considering conversion. Reuse a +compatible custom environment without changing my graph. An inventory verdict of +covered_after_lossless_fixes still requires this reuse check before applying any fix. +Verify model SHA256/source identity and the selected deployment's served release, +not filename/size or the newest undeployed release; ask about unresolved differences. +Only if none fits, make verified lossless changes on a copy, or explain quality-changing +node/model substitutions and ask: convert, or keep the original in a custom environment. +An approved conversion runs in the standard environment; a declined conversion or non-convertible +workflow goes to custom-build choices. Preserve my original workflow. + +If a custom build is needed, ask for any choices I have not already supplied: just this +workflow versus whole instance, new versus specifically named update, build name, GPU and +region. Suggest suitable GPUs from cheapest to most expensive using current information. +Explain current costs/timing or unknowns and 0–1 worker bounds before I approve it. +If reusing a custom environment's Build needs a new deployment, ask only its missing target/release, name, +GPU/region and cost choices; reuse the Build without rebuilding it. +Check required pack installability before recommending the exact custom option. +Ask before uploading every local model, input asset or custom-node source bundle, +identifying each file, size, purpose, destination/workspace, estimated time and costs +or explicit unknowns, plus known license/NSFW metadata. Bind approval to the exact +bytes and target; changed bytes, new files or a changed destination need a new answer. +Verify a supported model-import destination before offering that upload. When supported, +preview model upload --type --workspace --dry-run, then use +--yes --expected-sha256 only after named-file approval; use the +verified returned loader_path on a copy. Otherwise continue to existing Builds. +If a resource cap blocks the plan, list named/ID candidates and live-use status, then +ask which specific resource to stop/delete; never choose one silently. + +Approval for uploads applies to every route, including reusing a custom environment. If I decline +a required file, do not upload or substitute it; report the route as prepared, not run. +Pre-flight converted workflows and verify a real job on the selected target with its +required approved inputs before saying it runs. Return a verified authenticated UI link +only when the target supports it. Prefer read-only workflow ui --saved-file --workspace +--environment standard, or --environment custom --deployment , after the normal +actual userdata UUID/path/content snapshot is verified and private_saved_file_links_enabled is literal true. Keep workflow_id record IDs distinct; legacy positional/record links require regeneration. If saved_file_id is unavailable on an older server, keep the successful save and use verified sidebar recovery without repeating saves or uploads. +This retains the normal saved-workflow identity and selects the browser environment +without changing compute. When unavailable, explain the Workflows-sidebar/API fallback; +a verified deploy ui URL opens only the custom environment, not the saved workflow. A standard-environment save does not select a custom environment. +Retain accepted job IDs across timeouts; download outputs beside the workflow copy. +Lead the report with execution state, then include the route, changes/approvals, files, +job result/output paths and handoff. For custom environments include workspace and +Build/release/deployment IDs, GPU/region, actual worker bounds, current costs, actual +idle policy and stop command. Prepared or simulated work must be labeled as such. +``` + +If the user already explicitly chose a plan, append only those choices as **Previously approved choices**, including the exact Build/deployment IDs for an update. Do not derive approval from the bare modal click or silently fill defaults. Honor existing answers; newly discovered files or a changed target need an answer. + +The prompt carries the workflow and its prompts to the requested service as part of the handoff. It does not authorize sending unrelated files or embedded secrets. A named-file upload approval is still required on every route. diff --git a/comfy_cli/skills/comfy-run-on-cloud/SKILL.md b/comfy_cli/skills/comfy-run-on-cloud/SKILL.md new file mode 100644 index 000000000..e56aac6e3 --- /dev/null +++ b/comfy_cli/skills/comfy-run-on-cloud/SKILL.md @@ -0,0 +1,215 @@ +--- +name: comfy-run-on-cloud +description: Use when a developer clicked "Run on Cloud" in local ComfyUI or Comfy Desktop, pasted a Run-on-Cloud prompt, or wants a local workflow (or the whole install behind it) running on Comfy Cloud with a link to open it. Also use for a requested update to an existing build, or a pasted repair prompt after such a build or deployment failed. +--- + +# comfy-run-on-cloud + +One workflow in, one link out. Users care that the workflow runs on Cloud, not how. + +Comfy Cloud has two kinds of environment. Use these names with the user, never "stock Cloud": + +- **Comfy Cloud – standard environment:** the shared node and model catalog every account gets. Pay per run; nothing to build or deploy. +- **Comfy Cloud – custom environment:** a deployment of a workspace Build, with its own packs and models. Build, release and deployment are the CLI's nouns for how one is made. + +So: + +- Use the **standard environment** with the original dependencies when supported, including bringing the user's own models/LoRAs only through a verified supported import path and with upload approval. +- Otherwise, reuse a compatible **existing custom environment** (a workspace Build) **before considering conversion**, preserving the original graph and dependencies. +- With no compatible Build, **convert** for the standard environment: automatically for verified lossless changes, or with an informed yes for lossy changes. +- Make a new **custom environment** (or explicitly update one) only when conversion is impossible or the user chooses to keep the original dependencies. + +Whichever route you take: + +- Package **only what the workflow loads**, unless the user chooses the whole instance for a custom build. +- **Never change what the workflow generates without a yes.** A lossless fix is yours to make; a lossy one is the user's call. +- Never upload a file from disk without a per-file yes. +- Hand back the link only once the target can run. + +Run this orchestration in the **local agent**: inspect local custom-node source, Git origins, file paths and model hashes as needed. Reuse the agent's existing sign-in flow if the user is not signed in. When a local workflow is slow, memory-constrained or would benefit from batch/parallel runs, suggest Cloud with that concrete benefit; wait for the user's choice before starting the handoff. + +For Build and deployment operations, this skill sequences two others. Read them when a step points there; do not restate them. + +- `comfy skills show comfy-build`, plus its `comfy-build-authoring`, `comfy-build-pins` and `comfy-build-failures` references. +- `comfy skills show comfy-deploy`, plus `comfy-deploy-failures`. + +## What the click authorizes, and what it does not + +The local modal is deliberately simple: **Run on Comfy Cloud**, “We’ll start your local agent to get this workflow running on Comfy Cloud. You’ll approve any local file uploads along the way.”, **Let’s go**. The handoff supplies the saved workflow path, running server and available distribution/version/workspace context. Build name, GPU, new versus update and workflow versus whole-instance scope are not required modal fields. + +Sending it **is** the user's yes to: + +- run that workflow on Cloud, including **lossless** conversions; +- inspect and prepare that workflow, checking the standard environment and then compatible existing custom environments before considering conversion or proposing a custom build. + +If a custom build is needed, collect only the choices not already supplied: workspace, scope, new versus specifically named update, name, GPU and region. Disclose current costs/timing or unknowns and **`--min 0 --max 1`**, then obtain approval for that plan before building/deploying. Honor an explicit plan already approved in the prompt or earlier conversation; do not ask again for the same target and terms. A bare **Let’s go** does not choose a GPU or authorize a new Build. + +If reusing a Build requires a new deployment, ask only the missing deployment choices (target/release, name, GPU/region), costs and 0/1 bounds. Obtain that deployment approval without reopening Build creation or scope choices. + +It is **never** a yes to any of these, and each needs its own answer in chat: + +- a **lossy** conversion (step 3); +- uploading any file from this machine: models, LoRAs, input images/video/audio, or local custom-node source bundles (step 4); +- replacing, stopping or deleting an existing Build, release or deployment, except the specific update named in the user's prompt; +- a different GPU or region from the approved plan, or worker bounds other than 0/1. + +Batch the decisions currently known into one short message. Honor answers already given for the named files and target; a newly discovered file, changed file bytes or changed destination/workspace needs its own answer. A general "don't ask me anything" does not identify which files may be uploaded. + +## The procedure + +**1. Find the workflow and the install.** +- comfy-cli is a separate install, not bundled with Desktop. If `comfy` is missing, install it with `uv tool install comfy-cli`. Check `comfy --version`, `comfy skills show comfy-run-on-cloud` and `comfy build inventory --help` (inventory is hidden from `build --help`) before installing the skill. If unsupported, upgrade once through the existing package manager and recheck. If still unavailable, report the installed version and missing feature, preserve the workflow and stop this handoff. A release may predate this skill; never loop upgrades, silently install an unreviewed Git checkout, or treat a manual guess as the missing helper. A separately approved, reviewed pinned distribution is another installation choice. +- If the prompt names no workflow file, ask which file. Never package an install instead, and never invent a path. +- Use `comfy --json which` / `comfy --json env` when they expose a verified existing path and Desktop code/data/model roots. Older versions can report a nonexistent default as success; check paths on disk. Use the running server and Desktop config when discovery is incomplete: `comfy skills show comfy-run-on-cloud-local-install`. + +**2. Inventory the workflow against the standard environment.** Run it against the running server, **every** model root and the ComfyUI input folder: + +```shell +comfy --json build inventory --cloud --server http://127.0.0.1: \ + --desktop --models-root --input-root +``` + +It reports what the workflow loads (active classes, models with subfolders, `embedding:` refs, input files with the name Cloud would store each under, recorded pack versions, `implicit` loaders) and a `cloud` section: `verdict`, `blocking`, `unverified`, `lossless_removable`, and per model a `status` (`present` / `remap` / `absent`) and `weights` (`same_size` / `different_size` / `no_local_copy` / `unknown` / `not_checked`). **The report is the scope.** Resolve `unverified` before treating the workflow as covered. For each `implicit` row, read the pack source and add the weights it loads. A size match only rules out an obvious mismatch: establish model identity with a verified digest/public source before calling a local-to-Cloud model match lossless. Compare local SHA256 with verified public candidates from `comfy --json build refs resolve `, then establish that the selected target serves those same bytes/source. `asset.hash` and `metadata.source_hash` are not file SHA256 unless their response explicitly identifies that algorithm. A resolver candidate alone does not establish target availability. If identity cannot be verified, retain that unresolved check for step 3 and ask before selecting the uncertain Cloud copy. + +An `absent` model/LoRA is missing from the catalog, not proof that the standard environment cannot run the original. Discover the supported model import/upload path and its type, workspace and access constraints using current tools/help. Keep the original model when supported and ask before uploading it. Do not substitute a similar catalog model or require a custom Build solely because the original is not listed. Verify that destination before asking for upload approval. `comfy upload` is an input-asset upload, not evidence of model import; library deduplication is not evidence that arbitrary model bytes can be imported. If the available tools cannot establish a supported model path, report the limitation and continue to compatible Builds; do not offer an unsupported upload, invent a command or claim coverage. + +**Supported standard-environment model import:** when `comfy model upload --help` exposes it, discover the exact folder with `comfy --json model list-folders --where cloud`, then preview `comfy --json model upload --type --workspace --where cloud --dry-run`. The preview checks the current workspace, private-model entitlement, advertised model folder and destination-name collisions; it uploads nothing. Use its exact path/size/SHA256/destination in the step-4 question, supplementing known license/NSFW metadata rather than replacing known values with unknown. + +After that named-file approval, execute the same command with `--yes --expected-sha256 ` instead of `--dry-run`. An approved destination filename can be supplied with `--name `; a collision or changed name/target needs review. The command uploads an immutable snapshot matching the approved SHA256 and verifies the returned content hash/loader path. Verify workspace and returned asset identity, put the returned `loader_path` on a workflow copy, then pre-flight and test that exact model. A refusal is a blocker to report, not permission to omit approval flags or select different weights. On older CLI versions or unentitled accounts, inspect enabled tools for an equivalent verified capability; if none exists, continue to the existing-Build check. + +The UI inventory is a conservative candidate list: remove disconnected branches no executable output depends on. `model_hints` are template download metadata, not evidence that a file is selected; reconcile them with the actual loader/source before including them. Resolve linked primitive/Get/Set widgets and subgraph host overrides through the local server's API export, then inventory that API graph too. Keep the original UI workflow for the Cloud canvas. If no trustworthy API export is possible, report the unresolved dependencies instead of declaring coverage. + +**3. Pick the route in this order; classify conversions only after the reuse check.** + +1. **Standard environment, original workflow:** check whether every executable dependency is supported, including the original models/LoRAs through a verified bring-your-own path. Only an unchanged original with resolved identities qualifies here. `covered_after_lossless_fixes`, a required remap or a removable compatibility node goes through the existing-Build check before applying that fix: a lossless fix is still a conversion. Resolve unknowns; if the unchanged original is supported, go to route A. +2. **Existing custom environment:** if the standard environment cannot run the original, check workspace Builds for the original packs, versions and model identities **before converting anything or asking about a lossy swap**. Inspect `comfy --json build ls`, `build show --id`, `comfy --json deploy show --deployment ` and `comfy --json build release manifest `. Compare required pack versions, model type/name and verified SHA256 against the release actually served, plus the deployment logs; the latest undeployed release and a Build blobId are insufficient. A differing version is compatible only when its source/schema establishes the same required behavior; otherwise explain the difference and ask before selecting it. Node-class names alone do not establish equivalence. A verified match takes route B; keep the graph and dependencies. Approve any required local uploads and run a smoke job on that deployment before claiming success. If the Build has no usable deployment, ask only the missing deployment choices/approval and reuse the Build; do not create a new Build merely to deploy it. +3. **Conversion:** only when no compatible existing Build fits, classify the proposed changes below. All verified lossless changes → apply on a copy and take route A. Any lossy change → explain the substitutions and ask; approval → route A, declining conversion/choosing exact dependencies → route C. No viable standard-environment equivalent → route C. + +Honor an explicit route or named update already chosen by the user. Read-only checks do not authorize changing that target. + +| Kind | What counts | What you do | +|---|---|---| +| **Lossless** | Only these: a `remap` of a verified identical model file into another folder; removing a `lossless_removable` node, bypassing its model passthrough where present and disconnecting its settings from the loader; a utility node swapped for its verified exact core equivalent (math, string concat, a model-only LoRA stack → chained `LoraLoaderModelOnly` at the same strengths, a context pipe → direct links); removing a node no output depends on; setting a widget that a newer pack added to the value that reproduces the old behavior. | On the conversion route, do it on a **copy**, without asking. List each change in the report. Preserve both model and CLIP effects for stacks that modify both. | +| **Lossy** | Anything else that changes inputs to generation: a different model, LoRA, VAE, ControlNet, upscaler or embedding, including a Cloud file with your file's name but `different_size` weights; dropping a LoRA, embedding or any node that touches pixels; a different implementation of the same job (e.g. a Nunchaku loader → core `UNETLoader`). | **Ask** (below). Never apply one without a yes. | +| **Not convertible** | A node class Cloud lacks that does the core work, with no standard-environment equivalent (e.g. InstantID). | Custom environment (route C). | + +| Route | When | Next | +|---|---|---| +| **A. Standard environment** | Original dependencies supported, or no compatible Build fits and all needed conversions are verified lossless or explicitly approved as lossy. No blockers or unresolved checks remain. | Approve any required model/LoRA/input uploads in step 4. Pre-flight the runnable copy after assets are prepared, then run a real Cloud job and save/handoff in step 6. | +| **B. Existing custom environment** | The original dependency check found a compatible Build. Verify the selected deployment's required-pack imports before running; if a deployment must be created, check its logs after it is ready. | Keep the original graph. Use step 4's upload gate for any needed local models/assets; skip custom-build spec creation. Reuse its deployment (`deploy start` if stopped), perform the shared step-5 checks/smoke run, then hand off to that environment in step 6. | +| **Ask** | No compatible Build fits, and at least one proposed change is lossy or model identity remains uncertain. | Explain the difference and ask (below), then A or C. | +| **C. New or updated custom environment** | No compatible Build fits and conversion is impossible, or the user declined conversion/chose exact dependencies or a named update. | Ask only missing new/update, scope and GPU/region choices; then steps 4–6. Recommend GPUs that fit the model/workflow, ordered cheapest to most expensive using current prices and availability. Preserve choices already supplied. | + +**Unverified model identity uses the same informed two-option question.** After checking supported original-model import and existing Builds, give both named exits: **Use the unverified catalog copy** (name it and explain that its weights/output may differ) / **Keep my exact local weights** (a verified supported import or a buildable custom environment, with its plan/cost/upload choices). If preserving the original is currently blocked, name that blocker rather than promising it works. A yes/no question about the catalog copy alone omits the required original-dependency alternative. + +**Asking about a lossy conversion.** One message, in this shape: + +1. **What changes:** one line per swap, `original → Cloud replacement`, naming the affected nodes/models and expected behavior/quality differences or uncertainty. A visual before/after is not required. Offer replacement models from the same family only (SD1.5 / SDXL / Flux / Wan version), taken from the loader's complete `choices` in `comfy --json nodes show --where cloud --all-choices` (check help on older versions). Read truncation metadata; the first page is not the complete catalog. If you can't tell the family, offer only option 2. +2. **The options:** + - **Convert:** uses the standard environment after required files and validation, pays per run, nothing to build. Output may differ from the local run. Apply the substitutions only after a yes, then pre-flight and test. + - **Keep the original models and graph (custom environment):** preserves the workflow's dependencies; runtime and hardware differences can still affect results. Disclose build, storage and GPU charges from current information, build time and cold-start estimate or "unknown", and the workspace's release usage. Check whether deployment Open UI is available; otherwise explain the API handoff (`comfy deploy run`) before the user chooses. +3. The **build scope** question (below), for option 2. +4. Any **upload** questions from step 4, in the same message. + +Recommend one option in a clause, then wait. An approved conversion continues to route A; a declined conversion/choice to keep the original continues to route C's build choices, not to the conversion step. If both are declined, stop and report the blocker. A user note such as "demo in 20 minutes" informs the recommendation; it does not choose for the user. + +**Check buildability before offering the exact-dependency option.** Inspect required packs' imports and declared requirements against the supported builder environment. Packages already declared in requirements are installed by the builder; `pipDependencies` only pins packages otherwise installed. If a required wheel/import has no supported installation path (for example `nunchaku`), explain that blocker before recommending or approving a Build. Offer a viable informed lossy alternative if one exists; removing a core task node does not preserve the task. If neither exact nor converted execution is viable, report the blocker. + +**Verify workspace selection:** read `comfy --json cloud status` and compare `cloud_workspace.id` with the requested/approved workspace before uploads or custom-environment mutations. `deploy ls --workspace` is a boolean listing flag for the authenticated workspace; it does not select a workspace by name or ID. If they differ, use a supported explicit workspace-selection flow or ask how to switch; do not silently operate in the current one. + +**Current custom-environment prices:** use `comfy --json deploy refs compute` and current workspace data before the plan or lossy/custom choice. List suitable GPUs cheapest first, distinguishing available from requestable capacity. Disclose build/storage/compute charges, build/cold-start estimates or explicit unknowns. For reuse, read the selected deployment's `warmHourlyCents`, `storageMonthlyCents` and `computeConfig.keepWarmSeconds`; use unknown only when the current surface omits a value. + +**Build scope: ask it whenever a custom build is on the table** (option 2 above, or route C). Same message: + +- **Just this workflow** (the default; recommend it unless the user wants more): only the packs and models the inventory lists. Smaller, faster to build, and fewer files to upload. +- **The whole instance:** every custom node pack in the install and every model in its models folders, so any workflow from this install runs on the deployment. State the real size before they choose: the pack count (`ls /custom_nodes`), the model count and total GB per models root (`du -sh`), and how many of those files have no public source and would need an upload. Build time, storage cost and the chance of a dependency conflict all grow with it. List a shared models root (a Desktop `modelsDirs` entry outside the data dir) separately; it holds weights for other work and is never included without its own yes. + +On "whole instance", write the spec from the install per `comfy-build` Path A (`comfy build init --name --python `) instead of `--from-workflow`, then prune it per `comfy-build-authoring`. Uploads are still gated: show the full list of files with no public source, and a yes to that listed set counts as the per-file yes. A file added later is not covered. + +Before you send it, **check the workspace limits** (below), so the custom-build option says whether a slot must be freed first. **A swap only works where its replacement exists:** the standard environment's models are not inside a custom environment, and a Build's models are not in the standard environment. Never offer "swap on the existing Build" unless that Build lists the replacement. + +**Pre-flight every converted copy on the server** before saving or running it. The inventory cannot see settings a pack version shifted: + +```shell +comfy --json run --workflow --print-prompt --where cloud > preview.json +jq '.data.prompt' preview.json > api.json +comfy --json workflow validate --workflow api.json --where cloud +``` + +A `shape_mismatch` can indicate shifted widget layout or a malformed value. Compare the saved pack's schema/source with Cloud's schema before changing a widget. Set it by name with `comfy --json workflow set-widget . --where cloud` only when the value reproduces the saved behavior. A Cloud default alone is not evidence of equivalence. If equivalence is unknown, ask. + +**Workspace limits** (before proposing an operation that consumes a slot; see the pricing page): releases (10 per workspace observed; count with `build release ls --id` per Build), active deployments (5; `deploy ls --workspace`, stopped ones don't count), and Builds (10 on Pro; `build_limit` on push). Reusing a running deployment needs no new Build/release/deployment slot; creating or restarting a deployment needs no new Build/release slot. Check current limits rather than treating these observed counts as guarantees. If the planned operation is blocked, fetch the applicable resource lists and deployment references, show a short list with names/IDs and live-use status (unused resources first), then ask which specific resource to stop/delete. Never pick or mutate one before that answer. No cleanup is needed merely because a full workspace can still reuse a running target. + +**4. Approve uploads on every route; prepare a custom-build spec only for route C.** + +Routes A/B use the shared upload question below for any required local file, including models/LoRAs and input assets. They skip spec initialization, pinning and pushing. After the required files are approved and prepared for the selected target, route A goes to step 6; route B goes to the shared verification in step 5. + +**Route C only:** for "just this workflow", write the spec workflow-scoped (for "whole instance", see Build scope in step 3): + +```shell +comfy --json build init --name --from-workflow --comfy-version +``` + +**For a named update**, first read `build show --id ` and the intended deployment. In a separate build folder, initialize a staging spec, then `comfy build pull --id --yes` to bind the existing id and `syncedRevision`. Apply the approved workflow-scoped changes to that pulled spec; preserve unrelated existing dependencies unless removal was approved. Verify its id before pushing and the returned id afterward. A matching name does not bind a Build, and pushing a fresh `id: null` spec creates a new one. Handle a stale revision by re-reading and reconciling; do not force-overwrite another person's changes. + +Then fix it by hand per `comfy-build-authoring`, from the inventory: +- **Pack pins**, in order: the locally installed version; a pin a workspace Build already deployed cleanly; the workflow's recorded `ver`; the newest registry version that is not Flagged (all Flagged → `repository` + `gitRef`). +- Recheck the step-3 buildability decision after selecting pins. A missing required import blocks the build plan until a supported installation path or informed viable conversion is selected. +- **Model `type`:** the folder under `models/` plus the widget's subfolder (e.g. `checkpoints/sdxl`). +- **Model entries:** a local file whose SHA256 matches a verified `comfy build refs resolve` candidate becomes a disclosed `sourceUri` fetch. A local file with no public match is an **upload**: `{type, filename, localPath, sha256, sizeBytes, source: local}`. Model `localPath` is relative to `/models/` (for `/models/loras/private.safetensors`, use `loras/private.safetensors`); local-node `localPath` is relative to `/custom_nodes/` (use `my-pack` for `/custom_nodes/my-pack`). Validate these files before push. + +Then `comfy build validate` and `comfy build push --dry-run`. Newer CLI versions check public registry/repository pins with a read-only builder request while uploading and saving nothing. Older versions skip that check; verify the chosen registry version/status separately before the real push. A Flagged version must not be selected. + +**Skip inputs the selected target already has.** For the standard environment, uploaded inputs are named by the blake3 of their bytes, and the inventory computes that name. If an input's `on_cloud` is `true`, set the loader to its `cloud_name` and don't ask. `false` only means the loader's list doesn't show it; the lists can omit uploads. A standard-environment asset listing does not establish availability in a custom environment; verify the exact file on that target before skipping an upload. + +**The upload question** lists one line per file, for models, LoRAs, **input files** (images, video, audio) and **local custom-node source bundles** alike: name, size, why it must come from this machine, destination and workspace (the selected target's model storage or input library), estimated upload duration or "unknown", and applicable upload/storage/deployment costs or "unknown". Use **Upload models** / **Cancel upload** for models and **Upload assets** / **Cancel upload** for inputs/source bundles. For a source bundle, list its included files, exclusions and resulting size; exclude secrets, caches and unrelated files before requesting approval. Keep an approval ledger of exact path, size, digest, destination/workspace and decision. Immediately before upload, recheck those bytes and target; changed content, a new file or a changed destination needs a new answer. An explicitly listed set can be approved together. These checks reduce races; prose is not an atomic upload lock. Declining a required file leaves this route blocked; preserve the original workflow and report "prepared, not run" with what cannot run. Do not upload it or silently substitute another file. Give known licenses and NSFW flags (for example Hugging Face `cardData.license`); mark missing metadata unknown. Before `init --from-workflow`, disclose that it sends workflow JSON, including prompts, to the builder. The Run on Cloud handoff permits sending that workflow; it does not permit sending unrelated files or embedded secrets. + +Use this question shape, filling every field (use `unknown` for unavailable metadata): + +```text +Prepared, not run: waiting for the required file approval. + | | SHA256 | | +Upload time: ; upload/storage/compute cost: . +License: ; NSFW: . +Upload assets / Cancel upload: approve these exact bytes to this destination? +``` + +Use `Upload models / Cancel upload` for models. Repeat the file line and metadata for each file in a listed set. Include source-bundle contents/exclusions when applicable. A changed-file question uses the same complete shape, plus the old/new size or digest; an earlier question does not supply metadata for changed bytes. + +**5. Build/deploy only when needed; verify routes B/C on the selected deployment.** +- **Route C only:** `comfy build push`, then `comfy build release create --target linux/nvidia --watch`. On failure read `comfy-build-failures`: one cause per cut, at most three cuts. Before another missing-import cut, verify the exact supported mechanism that installs the missing distribution. A constraint/pin alone does not install it. If no declared requirement, supported wheel or other verified installation mechanism exists, stop and report the blocker; prior repair approval does not authorize a speculative paid cut. +- **Route C:** `comfy deploy up --gpu --region --min 0 --max 1 --watch`, with the GPU and region approved in the agent conversation or an explicit prior plan. For an update, select the approved deployment explicitly with `--deployment `. Check its `revision`/update capability first: updates-enabled workspaces move it in place; older workspaces can create a second deployment and keep the first billing. Disclose and obtain that additional-deployment decision before proceeding. Read returned `supersedes` and verify target ids plus the actual served release after the update; stopping an older deployment still needs the user's approval. On a refusal, say so and ask; never switch GPUs on your own. +- **Route B without a deployment:** read `comfy-deploy`, verify a compatible deployable release of the selected Build, and use `comfy deploy up --release ` with the approved deployment choices. Do not push a spec or create another Build/release to reuse an already deployable release. +- **Both B/C:** the remaining checks apply to the selected deployment, including reused deployments. Route B skips build push/release creation and leaves the existing Build's dependencies unchanged. Without a local spec, address it with the verified `--deployment ` on show/logs/start/run/stop rather than initializing a new spec. +- Report the idle scale-down from the deployment's own `keepWarmSeconds`, not a remembered default. Outside a Build folder, read a deployment with `comfy --json deploy show --deployment /`; `deploy status` needs the spec folder. +- **`ready` is not working.** Require both: + - the ComfyUI log (`comfy --json deploy logs` → `data.comfyuiLog`) shows no `IMPORT FAILED` and no `ModuleNotFoundError` for any pack the workflow uses; + - one smoke run against the selected deployment. Build the API file from node definitions that include the build's packs: `comfy --json run --workflow --print-prompt --where local > preview.json` against a running local ComfyUI that has them, then extract `.data.prompt` to a separate `api.json`. Converting `--where cloud` can drop widgets of a class the standard environment lacks. With no such server, inspect the pack's `INPUT_TYPES`; do not guess missing inputs. +- **Reconcile the complete asset plan before any deployment run.** From the intended run directory, run `comfy --json build inventory --input-root ` (repeat roots as needed). Its `deployment_assets` and `deployment_asset_roots` come from the exact deployment scanner, including custom-node input strings and automatic model/input/output roots. Match every planned local path to its per-file approval; files found here but absent from the earlier UI inventory need approval too. Use the same API file, cwd and root list for `comfy deploy run --deployment --workflow --asset-root --wait --output-dir /outputs`; no spec is needed for an explicit deployment id. `deploy run` waits/downloads by default and accepts `--wait`, while `--watch` is a release/deployment-monitor flag; check command-specific help before adding flags. Until the plan is reconciled, keep `--no-upload`; this flag prevents file uploads but can still submit a job if assets already exist, so it is not a free dry run. If a file changes after approval, review its new content/size before sending it. +- Run comfy commands sequentially. On a transient 401, retry/re-read once with `comfy --json build release show ` or `comfy --json deploy show --deployment `; use `deploy status` only inside its valid spec folder. If auth still fails, distinguish persistent authentication from a job/resource failure before asking for login; never resubmit an already accepted job to repair a watch error. +- A smoke run on the build can fail validation where Cloud passed (a pack version requires an input Cloud's version lacks, e.g. USDU's `batch_size`). Add the input with the default that reproduces the saved behavior and re-run. + +**6. Save, then link.** +- Upload input files only with the step-4 yes; set each loader to the returned `cloud_name` on the copy, then pre-flight and test. Cloud's dropdowns can omit uploads; verify the actual load in the test job. +- **Test every route before claiming it runs.** Route A: `comfy --json run --workflow --where cloud --wait`, then `comfy --json download --where cloud --out-dir /outputs`. Routes B/C: the step-5 `deploy run --wait --output-dir ...` already waits and downloads deployment outputs; root `download` targets ordinary local/standard-environment prompt history, so do not use it with a deployment job ID. If deployment output recovery is needed, use only supported job links/tools for that deployment or report the missing recovery capability; never submit another paid job just to recover a download. Retain accepted job/prompt IDs across timeouts and resume watching the same job. Download outputs beside the workflow copy in a durable user-accessible directory, and verify returned files; a download failure is not a job failure. If a required input, approval or working dependency is missing, lead the report with **Prepared, not run** and the exact blocker. Simulated jobs must be labeled simulated. +- Check `comfy workflow save --help` for the installed save capability. Save the workflow (the converted copy on route A) so it shows in the Workflows sidebar. Use `comfy --json workflow save --name --no-overwrite --where cloud` when its version writes the sidebar userdata file and verifies the save. A name collision needs a different name or explicit permission to overwrite that saved workflow. Older versions create only a record: use the Comfy Cloud connector's inline `save_workflow` if available, or return the local file and the CLI limitation. The skill must work without that connector. Confirm read-back/listing; with `list_saved_workflows`, a usable save has a size and is not `filename_ambiguous`. +- **Prefer the normal private saved-workflow identity when verified.** Check `comfy workflow ui --help`. After a sidebar-backed save returns an actual userdata `saved_file_id`, use `comfy --json workflow ui --saved-file --workspace --environment standard` for route A, or `--environment custom --deployment ` for routes B/C. This read-only producer requires the release capability `private_saved_file_links_enabled: true`, exact current OAuth workspace, and the authenticated `/api/userdata-files/` snapshot containing that exact UUID, canonical stored path and original workflow JSON text; custom links also verify the selected ready deployment and served release. The URL uses `?savedFile=` and the existing workspace/environment selectors. `workflow_id` remains a separate record ID; same-name or equal-content records do not certify a file. Legacy positional `workflow ui ` and `?workflow=` links are unavailable and require newly generated saved-file links. Return only the verified URL. The standard link explicitly selects the standard environment in the browser; neither kind changes compute, starts/stops deployments or creates an unsaved scratch copy. +- A new CLI does not enable this backend/frontend release capability. If the capability or `saved_file_id` is absent, false, malformed, refused, record-only or mismatched, report that limit. Older servers may save successfully without a certifiable file UUID; retain that success and do not repeat saves or approved uploads to obtain an ID. The capability gates CLI publication only; it is not a browser kill switch. Route A falls back to "https://cloud.comfy.org → Workflows → ``" after verified sidebar read-back. Routes B/C may discover `comfy deploy ui --help` and use `comfy --json deploy ui --deployment ` for a verified environment-only editor URL; label it as opening the environment, not the saved workflow. Return the retained UI/API files and verified deployment run/stop commands when the complete workflow handoff is unavailable. A standard-environment archive does not select a custom environment. A UUID or `#` fragment alone is not a private workflow link. Offer a public share link only with permission to publish. + +**Report:** start with the execution state (verified job succeeded, simulated verification, or prepared/not run with blocker). Include the route; each lossless change and approved lossy change; upload approvals and files actually uploaded/reused; job/prompt ID, result and durable output paths; save/read-back evidence and verified UI/sidebar/API handoff or limitation. For routes B/C include workspace, Build/release/deployment IDs, GPU, region, actual worker bounds, actual idle policy/`keepWarmSeconds`, current disclosed costs and `comfy deploy stop --deployment `. State unresolved checks and the next user decision. A ready deployment or saved record alone is not a successful run. + +## Common mistakes + +| Mistake | Instead | +|---|---| +| Converting or building because Cloud lacks a node class | Check for a compatible existing Build first; only then consider verified lossless or approved lossy conversion | +| Substituting a model/LoRA because it is absent from the catalog | Check a supported bring-your-own path and ask before uploading the original | +| Sending Build reuse straight to save/link | Approve required local uploads, check logs and run a real job on the selected deployment; hand off to that environment | +| Swapping a model because "the user said don't ask" | A lossy swap changes the output; ask once, with the custom-build alternative | +| Treating a Cloud file with your file's name as your file | Check `weights`; `different_size` is a different model, so using Cloud's is lossy | +| Saving a converted copy the inventory called covered | Pre-flight it on the server; pack versions shift widget meanings | +| Calling a deployment done at `ready`, or reusing one because its Build lists the packs | Read the import log and make one smoke run | +| Scanning the whole install without asking | Ask the build-scope question; default to just this workflow | +| Treating the modal click as upload consent | Ask per file, for models and input files | +| Running several `--watch` commands in parallel | Run comfy commands one at a time | +| Treating a 401 mid-watch as a reason to log in again | Retry once; re-read with `build release show ` or `deploy show --deployment `; keep the accepted job ID | diff --git a/comfy_cli/skills/comfy/SKILL.md b/comfy_cli/skills/comfy/SKILL.md index b6637532f..c6104fa84 100644 --- a/comfy_cli/skills/comfy/SKILL.md +++ b/comfy_cli/skills/comfy/SKILL.md @@ -20,7 +20,8 @@ know what exists, and reach for the right one rather than improvising its job:** `comfy-director` (multi-shot narrative video — story, continuity, conform), `comfy-build` (build a custom ComfyUI environment on the developer platform), `comfy-deploy` (run a build release as a serverless deployment, and stop it -costing money), `comfy-custom-nodes` (write or fix a custom node pack — preferred V3, +costing money), `comfy-run-on-cloud` (get one local workflow running on Comfy Cloud — +the standard environment first, a custom environment only for what's missing), `comfy-custom-nodes` (write or fix a custom node pack — preferred V3, compatible V1, reference routing, widgets, validation and restart/discovery), `comfy-debug` (any failed job: error code → fix), `comfy-relay` (surface a workflow/result in chat, never leave it in /tmp). When a task spans several, load them up front instead of discovering the gap mid-render. @@ -703,10 +704,26 @@ JSON files on disk via `workflow slots/set-slot/vary` instead. comfy --json workflow list # paginated, sorted by create_time comfy --json workflow list --name "wan" --limit 5 # case-insensitive name filter comfy --json workflow get --out my.json # writes workflow JSON -comfy --json workflow save my.json --name "X" --description "Y" +comfy --json workflow save my.json --name "X" # → workflows/X.json in the sidebar +comfy --json workflow save my.json --name "X" --no-overwrite # refuse if X exists comfy --json workflow delete ``` +`workflow save` writes `workflows/.json`, the file the Cloud +**Workflows sidebar** lists, so tell the user it is there under that name +(an open tab needs a refresh) and opens from it. `data.filename` is that +entry; `data.workflow_id` is the record Cloud keeps for it. A +`workflow_record_unresolved` warning means only the id read-back failed — +the save landed, but the record may be missing or stale, so don't re-run it. +A same-name save replaces the +workflow; `--no-overwrite` refuses with `workflow_exists` instead. +`--description` is ignored (the file has no such field). +Cloud `workflow delete ` removes the sidebar file and record. If duplicate +names make the file association ambiguous, it leaves both unchanged with +`workflow_filename_ambiguous`; inspect the same-name records and remove the +intended file in the sidebar first. `workflow_delete_incomplete` means the file +was removed but record cleanup needs checking with `workflow list`. + ## Cancel a running job ```bash diff --git a/comfy_cli/skills/command.py b/comfy_cli/skills/command.py index 4558fde62..9da737b17 100644 --- a/comfy_cli/skills/command.py +++ b/comfy_cli/skills/command.py @@ -4,7 +4,7 @@ agent on the machine how to call ``comfy`` natively. One file per skill, three targets, zero protocol. -Bundled skills (6 total) — see ``comfy skills list`` for descriptions: +Bundled skills — see ``comfy skills list`` for descriptions: - ``comfy`` — the consolidated driver skill (command surface, output contract, routing, discovery, execution, @@ -18,6 +18,10 @@ - ``comfy-deploy`` — running a Build release as a serverless deployment: compute choice, worker bounds, submitting workflows, and what keeps costing money + - ``comfy-custom-nodes`` — authoring custom nodes + - ``comfy-run-on-cloud`` — one local workflow onto Comfy Cloud: the standard + environment first, an existing custom environment + next, a workflow-scoped new one last, with every disk upload gated Reference skills (``REFERENCE_SKILLS``) are the other half: ``show`` resolves them and no default install writes them, so a parent skill can cite one by name diff --git a/comfy_cli/workflow_inventory.py b/comfy_cli/workflow_inventory.py new file mode 100644 index 000000000..311da93dd --- /dev/null +++ b/comfy_cli/workflow_inventory.py @@ -0,0 +1,680 @@ +"""What one ComfyUI workflow needs, and how much of it this machine and Comfy Cloud already have. + +``comfy build init --from-workflow`` asks the builder which packs a workflow uses, but +it drops what a build needs to be complete: model subfolders, the pack versions the +workflow recorded, ``embedding:`` references, and weights a loader picks without a +widget naming them. A build made from an install instead carries everything installed. +This module reads the workflow itself so the scope of a build is exactly what the +workflow loads, and nothing else on the machine. + +``inventory`` is pure: it reads the JSON (UI/editing format or an API export) and +reports. The ``join_*`` functions add what is known elsewhere: + +- ``join_local`` — every local file a model value could be, across model roots; +- ``join_server`` — the running ComfyUI's version and which pack directory provides + each class; +- ``join_cloud`` — whether Comfy Cloud's standard environment runs the workflow as-is, with dropdown + remaps, or needs a build. + +The caller fetches; these functions only compare, so every one is testable offline. +""" + +from __future__ import annotations + +import hashlib +import os +import re +from collections.abc import Callable, Iterable, Iterator, Mapping +from typing import Any + +MODEL_EXTENSIONS = (".safetensors", ".ckpt", ".pt", ".pth", ".bin", ".gguf", ".onnx", ".sft") + +# Loaders whose first widget names a run-time input file (an image, a video, a clip). +INPUT_LOADERS = frozenset( + { + "LoadImage", + "LoadImageMask", + "LoadImageOutput", + "LoadVideo", + "LoadAudio", + "VHS_LoadVideo", + "VHS_LoadVideoPath", + "VHS_LoadAudioUpload", + } +) +INPUT_WIDGETS = { + "LoadImage": "image", + "LoadImageMask": "image", + "LoadImageOutput": "image", + "LoadVideo": "file", + "LoadAudio": "audio", + "VHS_LoadVideo": "video", + "VHS_LoadVideoPath": "video", + "VHS_LoadAudioUpload": "audio", +} + +# Node modes the executor skips: these nodes load nothing, so nothing they name travels. +SKIPPED_MODES = {2: "muted", 4: "bypassed"} + +# Canvas-only nodes. No object_info carries them and they load nothing. +UI_ONLY_NODES = frozenset({"Note", "MarkdownNote", "Reroute", "PrimitiveNode", "GetNode", "SetNode"}) + +# Prune only with evidence about execution roots. Unknown/custom classes may be +# OUTPUT_NODEs even when they also return values; retain them conservatively. +KNOWN_OUTPUT_NODES = frozenset({"SaveImage", "PreviewImage"}) +KNOWN_NON_OUTPUT_NODES = frozenset( + { + "CheckpointLoaderSimple", + "CheckpointLoader", + "LoraLoader", + "LoraLoaderModelOnly", + "VAELoader", + "UNETLoader", + "CLIPLoader", + "DualCLIPLoader", + "UpscaleModelLoader", + "CLIPTextEncode", + "KSampler", + "KSamplerAdvanced", + "VAEDecode", + "VAEEncode", + "EmptyLatentImage", + "LoadImage", + "LoadImageMask", + } +) + +# Loaders known to load weights that no widget names. A build that misses these +# fails at run time, not at build time. Extend as packs are learned. +IMPLICIT_LOADERS = { + "IPAdapterUnifiedLoader": "picks ipadapter/* and clip_vision/* weights by preset name", + "IPAdapterUnifiedLoaderFaceID": "as IPAdapterUnifiedLoader, plus insightface models and a FaceID LoRA", + "InstantIDFaceAnalysis": "loads insightface/models/antelopev2/*.onnx", + "IPAdapterInsightFaceLoader": "loads insightface/models//*.onnx", + "DownloadAndLoadDepthAnythingV3Model": "downloads its model on first run unless it is declared under depthanything3/", + "UltralyticsDetectorProvider": "needs the Impact Subpack companion pack", +} + +# Nodes whose only effect is memory or speed. Cloud lacking one is a lossless fix: remove it +# and pass its model input straight to its consumer. Add a class only when the pack documents +# it as memory- or speed-only; anything that can change pixels does not belong here. +PERF_ONLY_NODES = { + "WanVideoBlockSwap": "block-swap args for the model loader (VRAM only)", + "WanVideoSetBlockSwap": "passes the model through with block swap set (VRAM only)", + "WanVideoVRAMManagement": "VRAM management args (memory only)", + "WanVideoTorchCompileSettings": "torch.compile settings (speed only)", +} + +_EMBEDDING_RE = re.compile(r"embedding:([^\s,:()\[\]]+)", re.IGNORECASE) + +# Where Comfy Desktop keeps its settings, including `modelsDirs`. Only the macOS +# location is confirmed; on other platforms callers pass `--models-root` instead. +DESKTOP_SETTINGS_MACOS = "~/Library/Application Support/Comfy Desktop/settings.json" + + +def is_model_value(value: Any) -> bool: + return ( + isinstance(value, str) + and value.lower().endswith(MODEL_EXTENSIONS) + and not _EMBEDDING_RE.search(value) + and "\n" not in value + and "\r" not in value + ) + + +def _posix(value: str) -> str: + """Windows separators become ``/``: a saved ``sdxl\\model.safetensors`` names a subfolder.""" + return value.replace("\\", "/") + + +def _widget_strings(node: Mapping[str, Any]) -> list[str]: + values = node.get("widgets_values") + if isinstance(values, dict): + values = list(values.values()) + strings: list[str] = [] + for value in values or []: + if isinstance(value, str): + strings.append(value) + elif isinstance(value, dict): # LoRA stacks store rows such as {"lora": "...", "on": true} + strings.extend(v for v in value.values() if isinstance(v, str)) + return strings + + +def _model_strings(node: Mapping[str, Any]) -> list[str]: + """Exclude known text widgets without rejecting filenames containing spaces.""" + if str(node.get("type", "")).startswith("CLIPTextEncode"): + return [] + return [value for value in _widget_strings(node) if is_model_value(value)] + + +def is_api_format(workflow: Any) -> bool: + return ( + isinstance(workflow, dict) + and "nodes" not in workflow + and bool(workflow) + and all(isinstance(v, dict) and "class_type" in v for v in workflow.values()) + ) + + +def _disconnected_nodes(nodes: list[Mapping[str, Any]], edges: Iterable[tuple[Any, Any]]) -> set[str]: + """Return provably unused nodes; an incomplete graph keeps its full scope.""" + by_id = {str(node.get("id")): node for node in nodes} + parents: dict[str, set[str]] = {} + for source, target in edges: + if str(source) in by_id and str(target) in by_id: + parents.setdefault(str(target), set()).add(str(source)) + else: + return set() + if not parents: + return set() + roots: set[str] = set() + has_output = False + for identifier, node in by_id.items(): + if node.get("mode") == 2: + continue + kind = node.get("type") + explicit = node.get("output_node", (node.get("properties") or {}).get("output_node")) + # Workflow metadata is caller-controlled. A false marker cannot veto a + # known output or prove an unknown custom class has no execution effect. + output = explicit is True or kind in KNOWN_OUTPUT_NODES + has_output |= output + if output or kind not in KNOWN_NON_OUTPUT_NODES: + roots.add(identifier) + if not has_output: + return set() + pending = list(roots) + reachable: set[str] = set() + while pending: + identifier = pending.pop() + if identifier not in reachable: + reachable.add(identifier) + pending.extend(parents.get(identifier, ())) + return set(by_id) - reachable + + +def _ui_nodes(workflow: Mapping[str, Any]) -> Iterator[Mapping[str, Any]]: + definitions = {sg["id"]: sg for sg in (workflow.get("definitions") or {}).get("subgraphs") or [] if sg.get("id")} + + def visit(nodes, links=(), prefix="", ancestors=()): + edges = [] + for link in links: + if isinstance(link, dict): + edges.append((link.get("origin_id"), link.get("target_id"))) + elif isinstance(link, (list, tuple)) and len(link) >= 4: + edges.append((link[1], link[3])) + else: + edges.append((None, None)) # Incomplete metadata cannot justify pruning. + disconnected = _disconnected_nodes(nodes, edges) + for node in nodes: + node_id = f"{prefix}/{node.get('id')}" if prefix else node.get("id") + scoped = {**node, "id": node_id} + if str(node.get("id")) in disconnected: + yield {**scoped, "inventory_disconnected": True} + continue + definition = definitions.get(node.get("type")) + if definition is None or node.get("mode") in SKIPPED_MODES: + yield scoped + elif node.get("type") not in ancestors: + yield scoped + yield from visit( + definition.get("nodes") or [], + definition.get("links") or [], + str(node_id), + (*ancestors, node.get("type")), + ) + else: + raise ValueError(f"cyclic subgraph definition at node {node_id}") + + yield from visit(workflow.get("nodes") or [], workflow.get("links") or []) + + +def _api_nodes(workflow: Mapping[str, Any]) -> Iterator[Mapping[str, Any]]: + nodes = [{**node, "id": node_id, "type": node.get("class_type")} for node_id, node in workflow.items()] + disconnected = _disconnected_nodes( + nodes, + ( + (value[0], node_id) + for node_id, node in workflow.items() + for value in (node.get("inputs") or {}).values() + if isinstance(value, list) + and len(value) == 2 + and isinstance(value[0], str) + and isinstance(value[1], int) + and not isinstance(value[1], bool) + ), + ) + for node_id, node in workflow.items(): + inputs = node.get("inputs") or {} + yield { + "type": node.get("class_type"), + "id": node_id, + "mode": 0, + "inventory_disconnected": str(node_id) in disconnected, + "named_inputs": inputs, + # A list value is a link to another node's output, not a widget. + "widgets_values": [v for v in inputs.values() if not isinstance(v, list)], + } + + +def inventory(workflow: Mapping[str, Any]) -> dict[str, Any]: + """Report every class, model, embedding and input file the workflow's active nodes use. + + Muted and bypassed nodes are listed under ``skipped`` with the models they would + have loaded, so a caller can say what was left out and why. + """ + if workflow.get("schema") == "envelope/1": + raise ValueError( + "This file is a CLI response envelope. Extract data.prompt as the API graph " + "(jq '.data.prompt' preview.json > api.json), then inventory api.json." + ) + api = is_api_format(workflow) + if api: + if any(not isinstance(n.get("inputs", {}), dict) for n in workflow.values()): + raise ValueError("API workflow node inputs must be objects") + else: + if not isinstance(workflow.get("nodes"), list): + raise ValueError("UI workflow must contain a nodes list, or pass an API workflow export") + definitions = workflow.get("definitions") or {} + if not isinstance(definitions, dict) or not isinstance(definitions.get("subgraphs", []), list): + raise ValueError("workflow definitions.subgraphs must be a list") + groups = [workflow] + for definition in definitions.get("subgraphs", []): + if not isinstance(definition, dict) or not isinstance(definition.get("nodes", []), list): + raise ValueError("each subgraph definition must be an object with a nodes list") + groups.append(definition) + for group in groups: + for node in group.get("nodes", []): + if not isinstance(node, dict) or not isinstance(node.get("type"), str): + raise ValueError("each UI workflow node must be an object with a string type") + report: dict[str, Any] = { + "format": "api" if api else "ui", + "classes": {}, + "packs": {}, + "models": [], + "model_hints": [], + "embeddings": [], + "inputs": [], + "skipped": [], + "implicit": [], + "warnings": [], + "unverified": [], + # The pack versions the frontend recorded when the workflow was saved. + "node_versions": {} if api else (workflow.get("extra") or {}).get("node_versions") or {}, + } + subgraph_ids = ( + set() + if api + else {sg.get("id") for sg in (workflow.get("definitions") or {}).get("subgraphs") or [] if sg.get("id")} + ) + classes: dict[str, dict[str, Any]] = {} + packs: dict[str, set[str]] = {} + seen_paths: set[tuple[Any, str, str]] = set() + + def add_model(entry: dict[str, Any]) -> None: + # Catalog choices are per loader. The same filename used by two loaders + # must be checked twice, and every remap needs its own widget address. + key = (entry["node_id"], entry["node"], entry["path"]) + if entry["path"] and key not in seen_paths: + seen_paths.add(key) + report["models"].append(entry) + + for node in _api_nodes(workflow) if api else _ui_nodes(workflow): + class_type = node.get("type") + if node.get("inventory_disconnected") and node.get("mode", 0) not in SKIPPED_MODES: + report["skipped"].append( + { + "id": node.get("id"), + "class": class_type, + "why": "disconnected", + "models": [_posix(value) for value in _model_strings(node)], + } + ) + continue + if node.get("mode", 0) not in SKIPPED_MODES: + if class_type in {"PrimitiveNode", "GetNode", "SetNode"}: + report["unverified"].append( + f"{class_type} #{node.get('id')}: linked widget values need a local API export before inventory" + ) + elif class_type in subgraph_ids and node.get("widgets_values"): + report["unverified"].append( + f"subgraph #{node.get('id')}: host widget overrides need a local API export before inventory" + ) + node_id = node.get("id") + strings = _widget_strings(node) + model_strings = _model_strings(node) + mode = node.get("mode", 0) + if mode in SKIPPED_MODES: + report["skipped"].append( + { + "id": node_id, + "class": class_type, + "why": SKIPPED_MODES[mode], + "models": [_posix(s) for s in model_strings], + } + ) + continue + # A subgraph instance's type is its definition id; its interior nodes are walked separately. + if not class_type or class_type in UI_ONLY_NODES or class_type in subgraph_ids: + continue + + properties = node.get("properties") or {} + pack = properties.get("cnr_id") or properties.get("aux_id") or "unknown" + row = classes.setdefault(class_type, {"count": 0, "pack": pack, "ver": set()}) + row["count"] += 1 + if properties.get("ver"): + row["ver"].add(str(properties["ver"])) + packs.setdefault(pack, set()).add(class_type) + + for value in strings: + if value in model_strings: + path = _posix(value) + if "\\" in value: + report["warnings"].append( + f"{class_type} #{node_id}: Windows path {value!r} will not match on Linux; keep the " + "subfolder in the model's type and expect the user to re-pick it" + ) + add_model( + { + "value": value, + "path": path, + "basename": os.path.basename(path), + "subfolder": os.path.dirname(path), + "node": class_type, + "node_id": node_id, + } + ) + for name in _EMBEDDING_RE.findall(value): + report["embeddings"].append({"name": name, "node": class_type, "node_id": node_id}) + + # Download hints the frontend embeds next to a node (name, directory, url). + for hint in properties.get("models") or []: + if not isinstance(hint, dict): + continue + path = _posix(str(hint.get("name") or "")) + hint_entry = { + "value": hint.get("name"), + "path": path, + "basename": os.path.basename(path), + "subfolder": hint.get("directory"), + "url_hint": hint.get("url"), + "node": class_type, + "node_id": node_id, + } + selected = next( + (model for model in report["models"] if model["node_id"] == node_id and model["path"] == path), None + ) + if selected is not None: + selected["url_hint"] = hint.get("url") + elif path: + # Template download metadata can survive a model dropdown + # change. Keep it as evidence, never as a required upload. + report["model_hints"].append(hint_entry) + + if class_type in INPUT_LOADERS: + named = node.get("named_inputs") + saved_widgets = node.get("widgets_values") + if named is not None: + input_file = named.get(INPUT_WIDGETS[class_type]) + elif isinstance(saved_widgets, dict): + input_file = saved_widgets.get(INPUT_WIDGETS[class_type]) + else: + input_file = strings[0] if strings else None + if isinstance(input_file, str) and input_file and not input_file.startswith(("http://", "https://")): + report["inputs"].append({"file": input_file, "node": class_type, "node_id": node_id}) + + if class_type in IMPLICIT_LOADERS: + report["implicit"].append({"class": class_type, "note": IMPLICIT_LOADERS[class_type]}) + elif "loader" in class_type.lower() and not any(is_model_value(s) for s in strings): + report["implicit"].append( + { + "class": class_type, + "note": "loader with no model widget: read the pack source for weights it fetches or picks", + } + ) + + report["classes"] = {name: {**row, "ver": sorted(row["ver"])} for name, row in classes.items()} + report["packs"] = {name: sorted(members) for name, members in packs.items()} + return report + + +def sha256_file(path: str, chunk_size: int = 8 << 20) -> str: + digest = hashlib.sha256() + with open(path, "rb") as handle: + while chunk := handle.read(chunk_size): + digest.update(chunk) + return digest.hexdigest() + + +def join_local(report: dict[str, Any], roots: Iterable[str], *, hash_files: bool = False) -> None: + """Attach every local file each model value could be, by basename, across ``roots``. + + Basename matching is deliberate: a workflow saved on another machine names its + own subfolders, and the user's copy may sit anywhere under a root. ``type_dir`` is + the first folder under the root (``checkpoints``, ``loras``…), the build's model type. + """ + index: dict[str, list[tuple[str, str, str]]] = {} + for root in roots: + root = os.path.expanduser(root) + for dirpath, _dirs, files in os.walk(root, followlinks=True): + for filename in files: + if filename.lower().endswith(MODEL_EXTENSIONS) and not filename.startswith("."): + full = os.path.join(dirpath, filename) + index.setdefault(filename, []).append((root, os.path.relpath(full, root), full)) + for model in report["models"]: + model["local"] = [] + for root, rel, full in index.get(model["basename"], []): + try: + size = os.stat(full).st_size + except OSError: + continue + parts = rel.split(os.sep) + match: dict[str, Any] = { + "path": full, + "root": root, + "rel": rel.replace(os.sep, "/"), + "bytes": size, + "type_dir": parts[0] if len(parts) > 1 else None, + } + if hash_files: + match["sha256"] = sha256_file(full) + model["local"].append(match) + report["models_not_on_disk"] = [m["path"] for m in report["models"] if not m.get("local")] + + +def join_server( + report: Mapping[str, Any], object_info: Mapping[str, Any], system_stats: Mapping[str, Any] | None +) -> dict[str, Any]: + """Which classes the running ComfyUI lacks, and which pack directory provides each one it has.""" + missing: list[str] = [] + by_pack_dir: dict[str, list[str]] = {} + for class_type in report["classes"]: + info = object_info.get(class_type) + if not isinstance(info, dict): + missing.append(class_type) + continue + module = str(info.get("python_module") or "") + pack_dir = module.split(".", 2)[1] if module.startswith("custom_nodes.") else "core" + by_pack_dir.setdefault(pack_dir, []).append(class_type) + return { + "comfyui_version": ((system_stats or {}).get("system") or {}).get("comfyui_version"), + "classes_missing_locally": missing, + "classes_by_local_pack_dir": by_pack_dir, + } + + +def join_inputs(report: dict[str, Any], roots: Iterable[str], hash_file: Callable[[str], str]) -> None: + """Find each run-time input file under ``roots`` and the name Cloud would store it under. + + Cloud names an uploaded input by the blake3 of its bytes, so ``cloud_name`` is the name an + existing upload of the same file already has. ``join_cloud`` then says whether it is listed. + """ + index: dict[str, set[str]] = {} + exact: dict[str, set[str]] = {} + for root in roots: + root = os.path.expanduser(root) + for dirpath, _dirs, files in os.walk(root): + for filename in files: + full = os.path.join(dirpath, filename) + index.setdefault(filename, set()).add(full) + exact.setdefault(_posix(os.path.relpath(full, root)), set()).add(full) + for item in report["inputs"]: + requested = _posix(item["file"]) + matches = exact.get(requested) or index.get(os.path.basename(requested), set()) + path = next(iter(matches)) if len(matches) == 1 else None + item["local_path"] = path + if len(matches) > 1: + report["warnings"].append(f"{item['file']}: ambiguous input file; choose the local path before uploading") + if path: + digest = hash_file(path).split(":", 1)[-1] + item["cloud_name"] = digest + os.path.splitext(path)[1].lower() + + +def _weights(model: Mapping[str, Any], cloud_name: str, size_of: Callable[[str], int | None] | None) -> str: + """Same name is not same weights: compare the local copy's size with Cloud's file.""" + local = model.get("local") + if local is None: + return "not_checked" + if not local: + return "no_local_copy" + if len(local) > 1: + digests = {match.get("sha256") for match in local} + if None in digests or len(digests) != 1: + return "ambiguous_local_copies" + size = size_of(cloud_name) if size_of else None + if size is None: + return "unknown" + return "same_size" if local[0]["bytes"] == size else "different_size" + + +def _combo_choices(node: Mapping[str, Any]) -> dict[str, str]: + """Every string choice a node's inputs accept, mapped to the input that accepts it.""" + choices: dict[str, str] = {} + for item in node.get("inputs") or []: + for choice in item.get("choices") or []: + if isinstance(choice, str): + choices.setdefault(choice, item.get("name")) + return choices + + +def join_cloud( + report: Mapping[str, Any], + lookup: Callable[[str], Mapping[str, Any] | None], + size_of: Callable[[str], int | None] | None = None, +) -> dict[str, Any]: + """Can Comfy Cloud's standard environment run this workflow as-is, after lossless fixes, or not at all? + + ``lookup(class_type)`` returns the Cloud catalog's ``nodes show`` payload for a class + (``inputs[].choices``, ``cloud_disabled``), or ``None`` when Cloud lacks the class. + ``size_of(name)`` returns the byte size of Cloud's model file with that exact name. + + A model is ``present`` when Cloud's dropdown lists the saved value, ``remap`` when + exactly one Cloud choice has the same file name under a different folder (the + saved value must be rewritten with ``set_widget``), and ``absent`` otherwise. Its + ``weights`` compares sizes with the local copy: ``different_size`` means Cloud's file + is a different model under the same name, so using it is a lossy change. + A missing class in ``PERF_ONLY_NODES`` is ``lossless_removable`` rather than blocking. + Embeddings and implicit loaders stay ``unverified``: no dropdown lists them. + """ + result: dict[str, Any] = { + "missing_classes": [], + "cloud_disabled": [], + "lossless_removable": [], + "models": [], + "unverified": list(report.get("unverified", [])), + } + choices_by_class: dict[str, dict[str, str]] = {} + for class_type in report["classes"]: + node = lookup(class_type) + if node is None: + if class_type in PERF_ONLY_NODES: + result["lossless_removable"].append({"class": class_type, "why": PERF_ONLY_NODES[class_type]}) + else: + result["missing_classes"].append(class_type) + continue + if node.get("cloud_disabled"): + result["cloud_disabled"].append(class_type) + for item in node.get("inputs") or []: + if item.get("choices_truncated"): + result["unverified"].append(f"{class_type}.{item.get('name')}: Cloud's choice list was truncated") + choices_by_class[class_type] = _combo_choices(node) + + for model in report["models"]: + choices = choices_by_class.get(model["node"]) + if choices is None: + result["models"].append({"path": model["path"], "status": "node_missing"}) + continue + if model["value"] in choices: + weights = _weights(model, model["value"], size_of) + result["models"].append({"path": model["path"], "status": "present", "weights": weights}) + continue + same_name = sorted(c for c in choices if os.path.basename(_posix(c)) == model["basename"]) + if len(same_name) == 1: + widget = choices[same_name[0]] + result["models"].append( + { + "path": model["path"], + "status": "remap", + "node_id": model["node_id"], + "widget": widget, + "from": model["value"], + "to": same_name[0], + "set_widget": f"{model['node_id']}.{widget}", + "weights": _weights(model, same_name[0], size_of), + } + ) + else: + result["models"].append({"path": model["path"], "status": "absent", "candidates": same_name}) + + for embedding in report["embeddings"]: + result["unverified"].append( + f"embedding:{embedding['name']} (no loader lists embeddings; check the Cloud model library)" + ) + for implicit in report["implicit"]: + result["unverified"].append(f"{implicit['class']}: {implicit['note']}") + + unresolved_inputs = [] + for item in report["inputs"]: + if item.get("cloud_name"): + item["on_cloud"] = item["cloud_name"] in choices_by_class.get(item["node"], {}) + if not item.get("local_path") and not item.get("on_cloud"): + unresolved_inputs.append( + { + "node_id": item.get("node_id"), + "file": item["file"], + "reason": "local file not found and target availability unverified", + } + ) + # Dependency compatibility alone never establishes a successful run. Keep + # missing runtime inputs separate so callers cannot mistake `covered` for it. + result["readiness"] = { + "status": "needs_inputs" if unresolved_inputs else "not_run", + "unresolved_inputs": unresolved_inputs, + } + + for model in result["models"]: + if model.get("weights") in ("same_size", "unknown", "not_checked", "no_local_copy", "ambiguous_local_copies"): + result["unverified"].append( + f"{model['path']}: model identity is unverified; matching names and sizes do not prove identical bytes" + ) + + blocking = ( + result["missing_classes"] + + result["cloud_disabled"] + + [m["path"] for m in result["models"] if m["status"] in ("absent", "node_missing")] + + [ + f"{m['path']} (Cloud's file differs in size from yours)" + for m in result["models"] + if m.get("weights") == "different_size" + ] + ) + if blocking: + verdict = "needs_build_or_lossy_conversion" + elif result["unverified"]: + verdict = "covered_needs_check" + elif result["lossless_removable"] or any(m["status"] == "remap" for m in result["models"]): + verdict = "covered_after_lossless_fixes" + else: + verdict = "covered" + result["verdict"] = verdict + result["blocking"] = blocking + return result diff --git a/comfy_cli/workspace_manager.py b/comfy_cli/workspace_manager.py index 4be5b4af7..53d5b774b 100644 --- a/comfy_cli/workspace_manager.py +++ b/comfy_cli/workspace_manager.py @@ -12,6 +12,7 @@ # Route prints through the output shim so they land on stderr in JSON mode # rather than corrupting the envelope on stdout. from comfy_cli.output import rprint as print # noqa: A001 - intentional shadowing +from comfy_cli.output.sanitize import sanitize_markup from comfy_cli.utils import singleton @@ -378,6 +379,36 @@ def _reported_manager_state(self) -> tuple[str, str]: return mode, detected + def discovery_data(self) -> dict: + """Describe the selected workspace, including Desktop's split layout. + + Registry-derived Desktop candidates remain separate from the workspace + used by commands that install or launch code. + """ + from dataclasses import replace + + from comfy_cli import desktop_install + + path = self.workspace_path + kind = self.workspace_type.value if self.workspace_type is not None else None + exists = bool(path and os.path.isdir(path)) + data = {"path": str(path) if path else None, "type": kind, "exists": exists} + found = desktop_install.detect() + selected = desktop_install.install_for_dir(path, found) if path and found else None + if found and (selected or not data["exists"]): + if selected: + reason = found.selected_reason if selected is found.selected else "matches the selected workspace" + found = replace(found, selected=selected, selected_reason=reason) + data["desktop"] = found.to_dict() + if found.problems: + data["desktop"]["problems"] = list(found.problems) + data["warnings"] = [{"code": "desktop_config_unreadable", "message": p} for p in found.problems] + if not data["exists"]: + data.setdefault("warnings", []).insert( + 0, {"code": "workspace_not_found", "message": f"Workspace directory does not exist: {data['path']}"} + ) + return data + def fill_print_table(self): config_manager = ConfigManager() mode, _detected = self._reported_manager_state() @@ -398,11 +429,25 @@ def fill_print_table(self): else: uv_compile_status = "[dim]Disabled[/dim]" - return [ - ("Current selected workspace", f"[bold green]→ {self.workspace_path}[/bold green]"), + discovery = self.discovery_data() + rows = [ + ("Current selected workspace", f"[bold green]→ {sanitize_markup(discovery['path'])}[/bold green]"), ("Manager", manager_status), ("UV Compile Default", uv_compile_status), ] + desktop = discovery.get("desktop") + if desktop and desktop["code_dir"]: + rows.extend( + [ + ("Desktop code", sanitize_markup(desktop["code_dir"])), + ("Desktop data", sanitize_markup(desktop["data_dir"])), + ] + ) + rows.append( + ("Desktop model roots", "\n".join(sanitize_markup(root["path"]) for root in desktop["model_roots"])) + ) + rows.extend(("Warning", sanitize_markup(warning["message"])) for warning in discovery.get("warnings", [])) + return rows def fill_data(self) -> dict: """Structured workspace info for ``comfy env --json``.""" @@ -410,8 +455,7 @@ def fill_data(self) -> dict: uv_compile_value = config_manager.get(constants.CONFIG_KEY_UV_COMPILE_DEFAULT) mode, detected = self._reported_manager_state() return { - "path": str(self.workspace_path) if self.workspace_path else None, - "type": self.workspace_type.value if self.workspace_type is not None else None, + **self.discovery_data(), "manager_mode": mode, "manager_detected": detected, "uv_compile_default": (str(uv_compile_value).lower() == "true" if uv_compile_value is not None else False), diff --git a/docs/adr/CLOUD-HANDOFF-0004-verify-upload-bytes-and-editor-identity.md b/docs/adr/CLOUD-HANDOFF-0004-verify-upload-bytes-and-editor-identity.md new file mode 100644 index 000000000..b1a7e4102 --- /dev/null +++ b/docs/adr/CLOUD-HANDOFF-0004-verify-upload-bytes-and-editor-identity.md @@ -0,0 +1,174 @@ +# ADR-CLOUD-HANDOFF-0004: Verify Upload Bytes and Editor Identity + +Date: 2026-10-25 + +## Status + +Proposed + +Relation: Builds on [ADR-AUTOMATION-0003](AUTOMATION-0003-one-versioned-machine-output-dialect.md), +[ADR-OPERATIONS-0002](OPERATIONS-0002-version-structured-workflow-operations.md), and +[ADR-DEPENDENCIES-0001](DEPENDENCIES-0001-delegate-unified-resolution-to-comfyui-manager.md). +The versioned output/error dialect, frozen operation vocabulary, and Manager's +ownership of unified dependency resolution remain unchanged. + +## Context + +A local Run on Cloud handoff crosses several boundaries: file upload approval, +workspace ownership, model identity, deployment readiness, and the saved document +opened by a browser. A matching filename, successful upload, ready deployment, or +saved record alone does not establish a runnable workflow or a usable private +editor link. The frontend also accepts canvas formats with JavaScript-specific +refinements; a second handwritten Python subset can accept unusable handoffs or +reject valid saved documents. + +The user approved exact-file model import and private document/environment link +support. They explicitly retained the general agent ledger and immediate recheck +contract for existing build/deployment uploads; a universal atomic upload-plan +protocol is outside this change. + +## Decision + +### Approval and model import + +- The skill records each approved path, byte size, digest, workspace and + destination. It reconciles the final API asset plan with the actual run cwd and + roots immediately before upload. New files, changed bytes or another target + require a new decision. This reduces races; it is not an atomic filesystem lock. +- The new `model upload` command requires an explicit workspace, named-file + approval and expected SHA256. It creates a private temporary snapshot, verifies + that digest, and uploads only that immutable snapshot. Capability/type/name + checks occur before sending bytes. A dry run creates no model asset or job. +- Content identity and ownership are separate. Only an identical asset already + owned by the authenticated workspace qualifies for reuse without byte upload. + An identical public asset alone does not establish ownership. Different bytes + at the destination name are a collision, not permission to overwrite. +- A successful import verifies the returned model folder and content hash and + reports its actual loader path. Upload failure may have remote effects, so an + uncertain result must not imply that an automatic retry is effect-free. A real + job is still required before claiming the imported model runs. +- General build repair must establish a supported installation mechanism before + cutting for a missing import. A constraint pins a package installed by another + mechanism; it does not by itself install one. This adds handoff policy without + reimplementing Manager's resolver. + +### Read-only editor discovery + +- `deploy ui` and `workflow ui` discover links without selecting an environment, + opening a browser, uploading a file, modifying a workflow or starting compute. + They use the existing versioned envelope/error registry, not a new dialect. +- Deployment links require the authenticated current workspace plus an exact + ready, nondeleted deployment whose served release agrees with the backend's + editor listing. The backend remains authoritative for membership, SSO, OAuth + scope, rollout and selection eligibility. API-key job access does not prove + browser-editor access. Credential precedence remains the shared CLI policy, + including explicitly forwarded environment credentials; discovery does not + weaken server authorization or embed credentials in links. +- Private workflow links require the literal server capability + `private_saved_file_links_enabled: true`. Absence or false is unsupported until + the matching backend snapshot/identity-guard API and frontend saved-document consumer are deployed and the operator enables it. This advertises CLI publication; the browser does not use it as a kill switch. +- A private link uses `savedFile=` only after reading the exact + authenticated `/api/userdata-files/{id}` snapshot: its row UUID, canonical + `workflows/*.json` path and original UTF-8 JSON content. The `--saved-file` + command input is explicit. A workflow record ID, name or equal content cannot + establish userdata identity; old positional commands and `workflow=` links + require regeneration. Missing, malformed, incompatible or mismatched evidence + fails closed. Cloud save exposes `saved_file_id` separately from record-based + `workflow_id`; older save responses remain successful with a null file ID and + an explicit limitation, without duplicate saves/uploads. A custom link also verifies the exact + deployment and served release; a standard link explicitly selects the standard + environment in the browser. The browser rechecks access and performs selection. +- An unavailable complete handoff returns a precise limitation and verified + sidebar/environment/API fallback. A UUID fragment or guessed URL is not proof + of document access. A public share requires its own publishing approval. + +### Frontend consumer parity and URL dependency + +- Bundle input JSON Schemas generated from the matching frontend consumer, with + commit/file provenance. Restore only the input refinements that schema export + cannot represent. Opaque metadata/widget objects are not traversed as nodes. +- Validate acceptance without normalizing or rewriting the user's graph. Compare + both canvas versions against the actual frontend oracle corpus whenever its + schemas/refinements change; retain valid unusual inputs and reject invalid + graph fields at the same structural positions as the consumer. +- Use `ada-url>=4,<5` for WHATWG URL acceptance, including browser-equivalent + Unicode scalar conversion, no implicit base and no network access. Parser + unavailability fails closed. The CLI needs no Node runtime; Node is used only + to regenerate source schemas and replay the frontend oracle during development. + +## Alternatives considered + +- Make every existing upload atomic through a universal manifest token. Deferred + by explicit user choice; it requires a separate protocol spanning current + build/deployment upload mechanisms. The new immutable model-upload snapshot is + a bounded addition, not a claim that this protocol already exists elsewhere. +- Treat public visibility as workspace ownership, or filenames/sizes as model + identity. Rejected because visibility and approximate metadata do not establish + ownership or the approved bytes. +- Construct editor URLs from local ready status or metadata alone. Rejected + because authorization, rollout, selected release and saved-file identity can + disagree independently. +- Maintain a minimal handwritten Python canvas schema or approximate URL regex. + Rejected because frontend acceptance includes structured refinements and + WHATWG behavior. A Node subprocess at runtime was also rejected because it adds + a second deployment/runtime requirement to the Python CLI. + +## What we reject + +Implicit upload/publishing approval, changed targets hidden behind a reused name, +silent lossy model substitution, guessed private links, weakening unrelated CQL +validation to admit imported models, and synthetic success presented as live +execution evidence. New output/error variants remain additive under +ADR-AUTOMATION-0003, and workflow edits do not bypass ADR-OPERATIONS-0002. + +## Consequences + +### Positive + +Approved model bytes cannot change during the upload stream. Link discovery +exposes verified point-in-time identities and supports older releases with honest +fallbacks. Frontend changes have an executable acceptance-drift signal. + +### Negative + +Model upload needs temporary disk space for a full file snapshot. Read-only +identity checks add authenticated reads and can refuse when evidence is +incomplete. Ada adds a bounded compiled dependency and platform-wheel obligation. +Schema/corpus regeneration needs the matching frontend development environment. + +### Known limits + +General ledger/rehash checks retain filesystem race limits. Discovery cannot +promise that a deployment or permission remains unchanged until the link opens; +the browser/backend must recheck. Publication of the CLI and deployment/enablement +of matching frontend/backend capability are separate release actions. Local and +simulated tests do not establish original-workflow inference quality. + +## Validation + +- `tests/comfy_cli/command/test_model_upload.py` covers approval, workspace/type + gating, immutable byte snapshots, collision/ownership behavior and uncertain + HTTP results. `test_cloud_model_validation.py` retains unrelated validation + failures and bounds authenticated exact-asset lookup. +- `test_deploy_ui.py` and `test_workflow_ui.py` cover authorization/target/release + mismatch, disabled capability, exact UUID snapshots, legacy refusal and read-only + behavior. Existing save tests retain collision protection and read-back proof. +- `test_cloud_workflow_schema.py` replays the actual frontend consumer corpus, + including URL acceptance, opaque object boundaries, no network/base and + fail-closed dependency absence. Source provenance lives in + [cloud_workflow_provenance.md](../../comfy_cli/schemas/cloud_workflow_provenance.md). +- Skill/reference tests and frozen agent scenarios distinguish per-file decisions, + repair limits, prepared state and simulated verification from actual jobs. +- Run `python scripts/check_adrs.py`, the repository's full pytest suite, Ruff + lint and formatting checks. A production rollout additionally needs the matching + browser/backend release and capability checks; an unavailable capability stays + disabled rather than falling back to guessed links. + +## Revisit triggers + +Reopen this decision if any changed source byte reaches model upload despite a +matching expected digest; if a public-only match is reported as owned reuse; if +any private link selects a different userdata row/workspace/release; if frontend/Python +acceptance differs on one oracle case; or if a supported Python/OS target lacks a +usable Ada installation. A request for atomic guarantees on another upload +mechanism requires a separately reviewed protocol decision. diff --git a/docs/adr/DESKTOP-DISCOVERY-0005-preserve-runtime-path-identity.md b/docs/adr/DESKTOP-DISCOVERY-0005-preserve-runtime-path-identity.md new file mode 100644 index 000000000..5b6070efe --- /dev/null +++ b/docs/adr/DESKTOP-DISCOVERY-0005-preserve-runtime-path-identity.md @@ -0,0 +1,100 @@ +# ADR-DESKTOP-DISCOVERY-0005: Preserve Runtime Path Identity + +Date: 2026-10-25 + +## Status + +Proposed + +Relation: Builds on [ADR-AUTOMATION-0003](AUTOMATION-0003-one-versioned-machine-output-dialect.md). +The versioned envelope, additive field/error compatibility and separation of +human diagnostics from machine output remain unchanged. + +## Context + +Desktop separates its code checkout, data directory, interpreter and shared +model folders. Modern and legacy registries can coexist, and an existing +last-launched installation is not necessarily the process serving a workflow. +Model-path YAML and launch flags can override the remembered data/input/output +roots. Choosing another installation silently can inventory or upload unrelated +files while reporting the wrong version. + +## Decision + +- Discover modern `comfyui-desktop-2`, `Comfy Desktop`, and supported legacy + records. Keep each registry's model-root provenance with its installation; + explicit caller/test registry overrides remain isolated. +- Without running-server evidence, describe selection as a registry-derived + candidate and expose its selection reason. Do not claim it identifies the + running process. +- Server launch metadata is not evidence of a shared filesystem, even for a + loopback endpoint (which may be a forwarder). Before using its paths to select + a local Desktop installation or read local configurations/interpreters/roots, + require caller-established direct-endpoint and local-process provenance. Bind + the request to its resolved address, bypass proxies, refuse redirects, match + the address-specific socket owner across the request using PID/create time, + and corroborate the actual Python script/argv/cwd. On Linux, require the same + mount namespace and process root as the CLI; inability to read that evidence + leaves provenance unknown. The pure discovery API defaults provenance to + unknown. Remote, forwarded, container, inaccessible or ambiguous endpoints + retain their reported catalog/metadata but require explicit local roots. +- With verified shared-filesystem provenance, require one recorded existing + installation to match its absolute code/data path or the full resolved generated + config path: that record's owning registry directory plus + `instance-model-paths/.yaml`. A copied filename/stem is insufficient; + retain per-record ownership across coexisting registries and reject path + separators and Windows drive/stream separators in IDs used for config identity. This preserves bundled/shared-code + discovery without conflating registries. Internal ownership adds no public + output fields. Zero or conflicting matches leave selection unresolved instead of combining + unrelated installations. +- Derive effective code/data/model/input/output roots from that selected process. + Resolve its model-path configuration and retain external paths explicitly. + Report the running version when supplied. The output root is the explicit + launch path or that process's data/output default, with its source recorded. +- Relative data/input/output paths cannot be resolved without the process's cwd: + retain uncertainty rather than anchoring them to the agent's cwd. Relative or + unreadable model config paths remain diagnostic evidence, never a claim that + all required model folders were found. +- Surface missing directories with existence flags and warnings. Discovery is + read-only: it creates no default workspace, installs nothing and grants no + permission to inspect/upload every file under a shared root. +- Optional which/env discovery fields remain additive. Runtime launch reporting + contains known path flags only, not arbitrary argv values or credentials. + File-upload scope and approvals belong to the calling operation; discovering + an output directory does not authorize uploading its whole contents. + +## Alternatives considered + +Selecting the newest registry entry alone is insufficient when a caller has +actual process evidence. Combining every existing install/model directory hides +identity errors and expands scope. Guessing relative paths from the CLI's cwd +can point at unrelated files. These approaches are rejected even when their +paths happen to exist. + +## Consequences + +Discovery can support both installed Desktop generations while callers retain +explicit path/selection provenance. Ambiguous, stale or relative process metadata +can require a user's verified path/cwd instead of automatic continuation. +Registry layouts and server metadata remain external compatibility surfaces; +unknown/malformed records are diagnostics rather than evidence of availability. +An interpreter is not inferred solely from a remembered data directory when +verified instance/process information is available. + +## Validation + +`test_desktop_install.py` covers registry isolation, actual process matching, +model-config roots, explicit/default input/output paths, relative-cwd ambiguity +and serialization. `test_which_desktop.py`, workspace-manager and Manager GUI +tests cover public reporting, missing roots and warning compatibility. Run those +tests with the worktree's package first on `PYTHONPATH`, plus Ruff lint/format, +`python scripts/check_adrs.py` and its native validator tests. + +## Revisit triggers + +Reopen if one running process resolves to another installation, if an unresolved +relative path is reported as verified, if server metadata bypasses direct local +process/filesystem proof, if shared folders lose provenance, or if +new Desktop layouts/launch flags require an additional documented discovery +source. A change that allows discovery to mutate installations or grants upload +permission requires a separate decision. diff --git a/docs/cloud-model-import.md b/docs/cloud-model-import.md new file mode 100644 index 000000000..44541ce3e --- /dev/null +++ b/docs/cloud-model-import.md @@ -0,0 +1,47 @@ +# Import a local model into the standard environment + +`comfy model upload` imports a named local model through Cloud's authenticated +`POST /api/assets` multipart API. It does not start a job or create a custom +Build. The current workspace must match the explicitly approved workspace ID, +`private_models_enabled` must be true, and `--type` must be a folder currently +advertised by `comfy model list-folders --where cloud`. + +Preview the exact file and target before asking the user: + +```sh +comfy --json model upload /absolute/path/original.safetensors \ + --type loras --workspace --dry-run --where cloud +``` + +The plan names the file, SHA256, size, destination and workspace. Null timing and +cost fields mean unknown. Add any known license/NSFW metadata to the approval +question; this command does not infer it. A plan is not upload approval. After +the user approves that exact file and target: + +```sh +comfy --json model upload /absolute/path/original.safetensors \ + --type loras --workspace \ + --expected-sha256 --yes --where cloud +``` + +The command copies the file into a private temporary snapshot, checks the +approved digest, and streams only that snapshot. It needs temporary disk space +for one copy; the snapshot is closed and removed on success or failure. Edits +made to the source during upload cannot change the approved bytes. A different +same-named Cloud asset blocks the import: approve a unique `--name` instead of +silently replacing it. An identical asset already owned by the authenticated +workspace is reused by hash, without re-uploading the file. An identical public +asset alone does not establish ownership; the command uploads the approved +snapshot instead. + +Success verifies the returned BLAKE3 digest and model folder, and returns the +actual `loader_path`. Older Cloud responses express BLAKE3 as a storage filename; +these are normalized under the documented asset-hash contract. Legacy loader +names are derived only from the verified model asset's name and folder. Put the +returned path on a workflow copy and validate/run that copy before claiming it +works. Imported bytes alone do not establish a successful model load or job. + +Network or malformed-response failures may happen after storage. Inspect the +asset library before retrying; the error's upload state is intentionally unknown +when it cannot be proved. Credentials are sent only to the authenticated Cloud +origin, and upload redirects are refused. diff --git a/docs/deployment-editor.md b/docs/deployment-editor.md new file mode 100644 index 000000000..a7b370619 --- /dev/null +++ b/docs/deployment-editor.md @@ -0,0 +1,27 @@ +# Open a custom environment in Comfy Cloud + +`comfy --json deploy ui --deployment ` discovers an authenticated editor link without opening a browser, selecting a deployment, uploading a file or starting a job. It accepts the same deployment name/id and optional spec path as `deploy show`. + +A successful result contains `workspaceId`, `deploymentId`, `releaseId` and `url`. The URL has the established Cloud editor shape: + +``` +https://cloud.comfy.org/?workspace=&deployment= +``` + +The command checks both the ready, nondeleted deployment control record and the authenticated Cloud workspace's editor deployment listing. The exact deployment and served release must agree. The Cloud listing owns rollout eligibility, current membership and workspace access. A ready deployment API endpoint alone does not establish editor access. + +An explicit `editor: false` (as set by `deploy up --no-editor`) or malformed editor value refuses the link, even if the deployment listing says ready. Older control-plane releases that omit the field still require the same authenticated listing verification. URL discovery never turns the editor server back on; enabling it is a separate deployment change. The same check applies to custom-environment saved-workflow links. + +A Cloud sign-in is required. API keys can run deployment API jobs, but do not establish a browser session or permission to select an editor environment. Refused, missing or inconsistent capability data returns `deploy_ui_unavailable` without a guessed URL. Opening a successful link still requires the browser to sign in as an account with access; no credential is embedded in the URL. + +The frontend switches to the named workspace, asks the backend to select the exact deployment for that browser and reloads onto the selected release's node catalog. The backend rechecks access at selection and execution time. Discovery is a point-in-time check; a deployment can change or be deleted before a link is opened. + +The returned link targets an environment; opening it selects that environment in the browser. A standard-environment workflow sidebar save does not select its custom environment. A specific saved workflow needs its own authenticated workflow-opening contract; `#` is not that contract. Where advertised, `comfy workflow ui` verifies that contract and the normal saved document before returning a private link. + +## Contract owners + +- Platform: `composables/useDeploymentEditorLink.ts` (`deploymentEditorUrl`, readiness and server capability checks). +- ComfyUI frontend: `src/platform/workspace/composables/useDeploymentUrlLoader.ts` (workspace switch, authenticated pick and reload). +- Cloud ingest: `GET /api/workspaces/{id}/deployments` (`ListWorkspaceDeployments`), `PUT /api/workspaces/{id}/deployment` (`PickWorkspaceDeployment`), the selected release catalog and prompt delegation. + +These source contracts describe available implementation. They do not prove that a particular backend/frontend revision or rollout is deployed. The CLI obtains the server's current answer on each discovery. diff --git a/docs/json-output.md b/docs/json-output.md index 523082a5f..ef463790b 100644 --- a/docs/json-output.md +++ b/docs/json-output.md @@ -572,6 +572,14 @@ watch ends with the error code `deploy_watch_lost` and exit code **75**, never 1 only the watch ended, and the deployment may still be coming up. Its `hint` carries the command that re-attaches and `details.deployment_id` the deployment. +A 401 on a watch's read triggers serialized session recovery: the client adopts +a peer's newer token or refreshes the rejected one, then retries at most once. +If recovery fails while a refreshable sign-in for the same environment remains +stored, the watch ends with `watch_auth_lost`, again with exit code **75** and +the same `details`. Its `hint` reattaches the watch without a re-login prompt. +The remote work may continue. A 401 with no refreshable sign-in remaining, or +on a workspace API key, stays `deploy_not_signed_in`. + ## Success envelope On `--wait` success, `data` carries: diff --git a/docs/workflow-save.md b/docs/workflow-save.md new file mode 100644 index 000000000..efe8a5009 --- /dev/null +++ b/docs/workflow-save.md @@ -0,0 +1,18 @@ +# Saving a workflow to the Cloud sidebar + +`comfy --json workflow save workflow.json --name "My workflow" --where cloud` +writes the normal `workflows/My workflow.json` userdata file once. It returns +`filename` and, when supported by the server, `saved_file_id`: the actual userdata +UUID from that write receipt. The UUID survives ordinary saves and renames; a +deleted and recreated file has a new identity. + +`workflow_id` remains the separate mirrored workflow-record ID used by the +record-based list/get/delete commands. A same-name record with equal content does +not establish the saved file's UUID. Never substitute `workflow_id` for +`saved_file_id` or construct a private editor URL from either value alone. + +Older servers can save successfully without returning a usable file UUID. In +that case `saved_file_id` is null and `saved_file_identity_unavailable` explains +that private file-link certification is unavailable. Verify the saved file in +Cloud's Workflows sidebar; do not repeat the save or any local file uploads to +obtain an ID. File identity metadata does not grant upload permission. diff --git a/pylock.toml b/pylock.toml index 84f471736..94cf92517 100644 --- a/pylock.toml +++ b/pylock.toml @@ -4,6 +4,54 @@ lock-version = "1.0" created-by = "uv" requires-python = ">=3.10" +[[packages]] +name = "ada-url" +version = "4.0.0" +index = "https://pypi.org/simple" +sdist = { url = "https://files.pythonhosted.org/packages/98/4e/f62ef579f693298f62a4657a0429823444025f342161d53f5c1f7bd629c6/ada_url-4.0.0.tar.gz", upload-time = 2026-07-28T19:29:53Z, size = 265328, hashes = { sha256 = "9f399ec867349800a4c2d3aa8df8c533c340494b04d34b1f082b97d9a8b76a07" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/0d/fcd5baaf23238abeb34e0cfc7e5be3100dfddcc71e6b91e4d57a2d55b6e8/ada_url-4.0.0-cp310-cp310-macosx_10_15_universal2.whl", upload-time = 2026-07-28T19:28:52Z, size = 701622, hashes = { sha256 = "28a1d13716d127afe59bb46d91e19c4e02de103eabf965394d7944dccf7540fa" } }, + { url = "https://files.pythonhosted.org/packages/7b/fe/80b2c37bc58579e17e9d95f21573f126ba2e29944411c659e07d24bdd614/ada_url-4.0.0-cp310-cp310-macosx_10_15_x86_64.whl", upload-time = 2026-07-28T19:28:54Z, size = 486263, hashes = { sha256 = "19a73177721fa710cd336be18cfbd8c7de1d81201f895fb1df00b3a15b06c9f3" } }, + { url = "https://files.pythonhosted.org/packages/5b/d9/8195d44667f89697b279c7441e81af63d607d6e357c8a2e7f3c9d6cee0ff/ada_url-4.0.0-cp310-cp310-macosx_11_0_arm64.whl", upload-time = 2026-07-28T19:28:56Z, size = 481514, hashes = { sha256 = "e8ae79506463092bc01c3f430fb8784720ab6f3fe49ce65427ad7dd838cb1b4a" } }, + { url = "https://files.pythonhosted.org/packages/27/b4/b304d6b74961888f2f0756542848025f5c03a7709d124aac0b0c3c9405bb/ada_url-4.0.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-07-28T19:28:57Z, size = 1829883, hashes = { sha256 = "2094db65d134d3d87c65d28fb7ab5ce4b7c16480e02c3a5da4da0756bcab5025" } }, + { url = "https://files.pythonhosted.org/packages/07/67/0179da20490a258922071cf87d8d5558ec24c83e23831ddb304b44002442/ada_url-4.0.0-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-28T19:28:59Z, size = 1861219, hashes = { sha256 = "e18557b30431aa1e19fb570416d4a0186a470202d113c47283c311757f08cf1f" } }, + { url = "https://files.pythonhosted.org/packages/99/c0/eb5c9fb3e6478213e376b78d75bf1d44cf3e098c7568f74db0069630fa62/ada_url-4.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", upload-time = 2026-07-28T19:29:00Z, size = 2767525, hashes = { sha256 = "a0e0464aff6800b21d22f9f9683fd5625d1e9539967032291c88305361d2f6da" } }, + { url = "https://files.pythonhosted.org/packages/da/a4/0e0469f7d2fe343fdfcfa353c8886a3d8a99e21441a3ec59cdaa5d43ee4e/ada_url-4.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", upload-time = 2026-07-28T19:29:02Z, size = 2876126, hashes = { sha256 = "0d8081fd0e939823162afa6d69cfeb5815c0035b56227cda2aa66357ba63917d" } }, + { url = "https://files.pythonhosted.org/packages/77/53/a3052700fca22443defe1d856654a9db94f1a61a5fc731439c07a31071dc/ada_url-4.0.0-cp310-cp310-win_amd64.whl", upload-time = 2026-07-28T19:29:04Z, size = 434044, hashes = { sha256 = "9ec145a74027c7be028c5558813302d27d9bdcc848947b9c00ff5e0e92c6aed1" } }, + { url = "https://files.pythonhosted.org/packages/06/25/4b6407fd8584debd46cde4775c8593bb1173d523de51bf2912db3b32a511/ada_url-4.0.0-cp311-cp311-macosx_10_15_universal2.whl", upload-time = 2026-07-28T19:29:05Z, size = 701619, hashes = { sha256 = "6b49f6bb47c3252f673eeafed5f24a10449829a16ca02852cc19b2d1fa39c2d2" } }, + { url = "https://files.pythonhosted.org/packages/17/61/8932be53b468a4f3cdf70fee7089624d532883e0e1ba72c934646e2741d1/ada_url-4.0.0-cp311-cp311-macosx_10_15_x86_64.whl", upload-time = 2026-07-28T19:29:06Z, size = 486262, hashes = { sha256 = "39b4223ef9a226a3d673c8905f551308051f7c10781a25383f806bd7e33cf681" } }, + { url = "https://files.pythonhosted.org/packages/b7/49/aa3c27d40b6eee2cdb74781bd4d1ec4dce654a922475a07331f757400e31/ada_url-4.0.0-cp311-cp311-macosx_11_0_arm64.whl", upload-time = 2026-07-28T19:29:08Z, size = 481514, hashes = { sha256 = "8c0a10891bb775ebf9b5eac2a7a14150a208a43d94ff5c5e98829fa7770b7d99" } }, + { url = "https://files.pythonhosted.org/packages/9e/2f/0203f4d74dfd718e0f117c28906c0b9d90ac89dd90766efe61ce944e0a8a/ada_url-4.0.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-07-28T19:29:09Z, size = 1829834, hashes = { sha256 = "74e7aff0596381d35a2db6a473beb38bc9ca5e16f64a97e20c0ae3206059dfa2" } }, + { url = "https://files.pythonhosted.org/packages/96/5f/3b3f5a17f75f690fd757183f31cc27f39101a14e664dfb0c5c6f71bf30f3/ada_url-4.0.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-28T19:29:11Z, size = 1861233, hashes = { sha256 = "e86c86ffe4d310095ed50701afe5c1e76c2efd1c268ecdc91bfcd8a4609d80b4" } }, + { url = "https://files.pythonhosted.org/packages/7d/8f/8f76f385fb47b50148d81bc215295cc9b61cd2969df3f1ba5041fd6767cc/ada_url-4.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", upload-time = 2026-07-28T19:29:12Z, size = 2767523, hashes = { sha256 = "d25ad705c3e720661b5defac4af046087a048330d6afe80b892053d1c47c23ac" } }, + { url = "https://files.pythonhosted.org/packages/d3/56/1ec2bb5240810e53998eef2b8fb540fe25c0fefd5c26ff2bd25a1f9c3871/ada_url-4.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", upload-time = 2026-07-28T19:29:14Z, size = 2876096, hashes = { sha256 = "3f5efa01409553d15b8b27b4640cb43427a53c2995d2e2c5de505bd1faa9fb55" } }, + { url = "https://files.pythonhosted.org/packages/f3/61/34e2575622c6db1f30d1bd20f709c1cf16359a7a1d1dee5add01ac2dc07e/ada_url-4.0.0-cp311-cp311-win_amd64.whl", upload-time = 2026-07-28T19:29:15Z, size = 434042, hashes = { sha256 = "0641ecdeb6b226967077f52404af455a11e2957bcbb31b5921d6eb405859f831" } }, + { url = "https://files.pythonhosted.org/packages/49/6e/13bd71c47fa7096a3c74ae6536a8b465c2defedca43135e2881e3c590ccd/ada_url-4.0.0-cp312-cp312-macosx_10_15_universal2.whl", upload-time = 2026-07-28T19:29:16Z, size = 706191, hashes = { sha256 = "909658402abad0c35422b3306d1464131c25b926cd203399b18bc1667f0778d4" } }, + { url = "https://files.pythonhosted.org/packages/9a/aa/6718ba57b57090db0b2f675d78a3762318e0f2c477ba718f76c6d8ec7e30/ada_url-4.0.0-cp312-cp312-macosx_10_15_x86_64.whl", upload-time = 2026-07-28T19:29:18Z, size = 488395, hashes = { sha256 = "75785fb7242411d1d0ada6e6abbe5cedcb87bee7d38272a1fd8beb5fc512bc2d" } }, + { url = "https://files.pythonhosted.org/packages/3f/8e/65fac4fa8846bffdc3d8c4e17294ee435385fcc8980ba141ed3b6f03b224/ada_url-4.0.0-cp312-cp312-macosx_11_0_arm64.whl", upload-time = 2026-07-28T19:29:19Z, size = 483727, hashes = { sha256 = "b3c6fd8148c1efde18f71a7c241d3e0ea98de36091a12940656cfa545a84da14" } }, + { url = "https://files.pythonhosted.org/packages/26/3e/5d931d6eba90657470f0ee9d4049685f177e34a452a1805aad5fe1c8885e/ada_url-4.0.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-07-28T19:29:21Z, size = 1830343, hashes = { sha256 = "d85ab449fe23d2ac612d34a869dd6a0b5968b45819ebcae40d6307c7f951db69" } }, + { url = "https://files.pythonhosted.org/packages/23/7c/144b315890c7c6bc6367bcd9101bd29f4343bc2a93a944bc5815dafbf48a/ada_url-4.0.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-28T19:29:23Z, size = 1861921, hashes = { sha256 = "da1510328ffbb5a505815f322061137527946a3698bbb70dc53ec086b8086e21" } }, + { url = "https://files.pythonhosted.org/packages/f6/f3/ed5f9b121dc460c2cc555393394e0d14a660bb1ed753abc0f1d60de04297/ada_url-4.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", upload-time = 2026-07-28T19:29:24Z, size = 2768370, hashes = { sha256 = "8e975816ec664690d78f26b479f41098f6cb1e3142b42821eef9eb9ee199f287" } }, + { url = "https://files.pythonhosted.org/packages/dc/22/6a5d890f541266f5b7c345947c633bdb686a856c734502131161c52e3ccc/ada_url-4.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", upload-time = 2026-07-28T19:29:26Z, size = 2877324, hashes = { sha256 = "4608f6aa98fc736a4edd751dd017c9f146b8d3d86e08d86bfc0df5cb7f3eae8b" } }, + { url = "https://files.pythonhosted.org/packages/b2/fe/13e01dbdc2ab9d7b9d150c386437d68ce0db9f3c3d2028130613cc10949b/ada_url-4.0.0-cp312-cp312-win_amd64.whl", upload-time = 2026-07-28T19:29:28Z, size = 434129, hashes = { sha256 = "d5ab0c75e227d46dca70376193eb70387c605eb43866cf425a03df9655e02303" } }, + { url = "https://files.pythonhosted.org/packages/d5/74/426e9a200d80dbc368c26441e5978e8b2ebc7e3d9af08726d36439ef584e/ada_url-4.0.0-cp313-cp313-macosx_10_15_universal2.whl", upload-time = 2026-07-28T19:29:29Z, size = 706191, hashes = { sha256 = "da4040f51e6c17cf827f38031d3546e4a940c1440523ec0d0319048da21de174" } }, + { url = "https://files.pythonhosted.org/packages/4d/6b/4357e137aa0c894671ddbe975d4056dc2855626f0d1e09398c4e4a81fbea/ada_url-4.0.0-cp313-cp313-macosx_10_15_x86_64.whl", upload-time = 2026-07-28T19:29:30Z, size = 488396, hashes = { sha256 = "e1abb7c8bf5acbee94a5bb0b2e3100dcaf0aa3b4294e31e17c5645c85f473595" } }, + { url = "https://files.pythonhosted.org/packages/d8/19/6f881a4c36ac84f7ab12426594a12fc2155e82976bf2ff7ea1d080779ad7/ada_url-4.0.0-cp313-cp313-macosx_11_0_arm64.whl", upload-time = 2026-07-28T19:29:32Z, size = 483727, hashes = { sha256 = "be53094f4cf0d435b51cf738486de8decaeafdc465d0b24a1462ecf88fbb2f58" } }, + { url = "https://files.pythonhosted.org/packages/88/ac/d02f27798ed2b15067d25e62cec97b6d1626cf9cc9ac8b3d3a45877a830c/ada_url-4.0.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-07-28T19:29:33Z, size = 1830312, hashes = { sha256 = "0f691beab142575e6546a37cac142e3abfe3bb7d0b586b648fc56917b5b88ec3" } }, + { url = "https://files.pythonhosted.org/packages/5d/67/525a42ce8f4de030423c497b1a70261921f0347070cb3b22f9ae6ce6a14a/ada_url-4.0.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-28T19:29:35Z, size = 1861928, hashes = { sha256 = "bdb9e57c9f2d2c4c29dc2b49eeb7c370a8c9550fcd95a44d8434444e236537a2" } }, + { url = "https://files.pythonhosted.org/packages/91/0c/4e7d2ae2c72c963d1c0ee004a88a088ee8c0c669c9910947ea722e144eaa/ada_url-4.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", upload-time = 2026-07-28T19:29:36Z, size = 2768337, hashes = { sha256 = "4bc8c4f6cdc816379c14d49ae987a9e35bb5e8ee35517735a49afed08fd16e9e" } }, + { url = "https://files.pythonhosted.org/packages/02/66/a673c258d4aa76b888758d5a468f231bb12686dc3c10ee51c2e5c2dffd7e/ada_url-4.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", upload-time = 2026-07-28T19:29:38Z, size = 2877325, hashes = { sha256 = "6f13b0cff78ad3ff48c4179f2eafaa0231be1ca1a4f52d841565a69dd3c7ceeb" } }, + { url = "https://files.pythonhosted.org/packages/25/39/498e9e2a848a8fc0744c2d3fd36436de837bc0bd58a99041ddee832e37ea/ada_url-4.0.0-cp313-cp313-win_amd64.whl", upload-time = 2026-07-28T19:29:40Z, size = 434130, hashes = { sha256 = "5563001339c7f19586df57d832238c45ab065c012c7d884cfd5ed73db8be46d6" } }, + { url = "https://files.pythonhosted.org/packages/87/78/74c5cd93ca51841cbd78af1cb4b1b3cd2c09a9d7915138c402491f25219c/ada_url-4.0.0-cp314-cp314-macosx_10_15_universal2.whl", upload-time = 2026-07-28T19:29:41Z, size = 706351, hashes = { sha256 = "39f4bd73f700a69c5b8a90e961ef941a6a746a0702267626d1c963d375bb9262" } }, + { url = "https://files.pythonhosted.org/packages/f2/d2/5085234207eba6988714b1baa39f9ec02f2547d30f013fe99ee0689705e4/ada_url-4.0.0-cp314-cp314-macosx_10_15_x86_64.whl", upload-time = 2026-07-28T19:29:43Z, size = 488412, hashes = { sha256 = "528476f914bcc0f0f0d61edfaaad74762bb250577ba7a057fe498a01da74d0dd" } }, + { url = "https://files.pythonhosted.org/packages/e0/d9/b961166186fb879207606061c53c5f99ee541d932f9d8138ec6094ee321d/ada_url-4.0.0-cp314-cp314-macosx_11_0_arm64.whl", upload-time = 2026-07-28T19:29:44Z, size = 483816, hashes = { sha256 = "21fb572120df103bc5596ae7e1989aa9653ad67876ee1f0c0479c0b7dc1987b7" } }, + { url = "https://files.pythonhosted.org/packages/e8/af/52a41bd417d738bdf9f02c13dd4f9df14bcf632a780fe3bbd2d41942eb38/ada_url-4.0.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", upload-time = 2026-07-28T19:29:46Z, size = 1830000, hashes = { sha256 = "23992e6adf1ee199cda3f740dc4b180f766f2221b664e867822bcd769b4319e7" } }, + { url = "https://files.pythonhosted.org/packages/7b/11/d09f9563c844ca03a57000fd186ab4c478dd5e8c47f3ca968ac589edc9b9/ada_url-4.0.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", upload-time = 2026-07-28T19:29:47Z, size = 1861736, hashes = { sha256 = "ae36e49770036978ae9a3c31f24b69a1020d83dcc53b9a134a1ba5cafb85bd28" } }, + { url = "https://files.pythonhosted.org/packages/12/a5/51e2c2da49fb0e2f82ee8df154fb37e2e32222a7cea85cec33919cdda404/ada_url-4.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", upload-time = 2026-07-28T19:29:49Z, size = 2767953, hashes = { sha256 = "cc2c47eb1fc2e3fa164c8c64be6a3c63b5d30f72d5ceb3698d31c738bdbe953c" } }, + { url = "https://files.pythonhosted.org/packages/12/4e/daa6b344240c9ea7776d211f2875731638d607c32a7f6b66cd3fdec7f2b6/ada_url-4.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", upload-time = 2026-07-28T19:29:50Z, size = 2877652, hashes = { sha256 = "f24ac26a6e1c8cb00abfa84426e5419cbe619439d55ba1266db4c67b5af066ad" } }, + { url = "https://files.pythonhosted.org/packages/97/f0/3a6bf91fc2e6a0ee808e7fbf0981f7b6bb44b466dbfad19f2d229d32185c/ada_url-4.0.0-cp314-cp314-win_amd64.whl", upload-time = 2026-07-28T19:29:52Z, size = 438477, hashes = { sha256 = "8ad116df43579c0c49dd1807e182137c38a3784927181a26ea4f5d051da155f0" } }, +] + [[packages]] name = "annotated-doc" version = "0.0.5" @@ -25,6 +73,13 @@ index = "https://pypi.org/simple" sdist = { url = "https://files.pythonhosted.org/packages/2e/00/0f6e8fcdb23ea632c866620cc872729ff43ed91d284c866b515c6342b173/arrow-1.3.0.tar.gz", upload-time = 2023-09-30T22:11:18Z, size = 131960, hashes = { sha256 = "d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85" } } wheels = [{ url = "https://files.pythonhosted.org/packages/f8/ed/e97229a566617f2ae958a6b13e7cc0f585470eac730a73e9e82c32a3cdd2/arrow-1.3.0-py3-none-any.whl", upload-time = 2023-09-30T22:11:16Z, size = 66419, hashes = { sha256 = "c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80" } }] +[[packages]] +name = "attrs" +version = "26.1.0" +index = "https://pypi.org/simple" +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", upload-time = 2026-03-19T14:22:25Z, size = 952055, hashes = { sha256 = "d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", upload-time = 2026-03-19T14:22:23Z, size = 67548, hashes = { sha256 = "c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309" } }] + [[packages]] name = "backoff" version = "2.2.1" @@ -132,6 +187,113 @@ index = "https://pypi.org/simple" sdist = { url = "https://files.pythonhosted.org/packages/dc/67/960ebe6bf230a96cda2e0abcf73af550ec4f090005363542f0765df162e0/certifi-2025.8.3.tar.gz", upload-time = 2025-08-03T03:07:47Z, size = 162386, hashes = { sha256 = "e564105f78ded564e3ae7c923924435e1daa7463faeab5bb932bc53ffae63407" } } wheels = [{ url = "https://files.pythonhosted.org/packages/e5/48/1549795ba7742c948d2ad169c1c8cdbae65bc450d6cd753d124b17c8cd32/certifi-2025.8.3-py3-none-any.whl", upload-time = 2025-08-03T03:07:45Z, size = 161216, hashes = { sha256 = "f6c12493cfb1b06ba2ff328595af9350c65d6644968e5d3a2ffd78699af217a5" } }] +[[packages]] +name = "cffi" +version = "2.1.1" +index = "https://pypi.org/simple" +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", upload-time = 2026-08-03T21:21:18Z, size = 530807, hashes = { sha256 = "dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/d2/2cde336b375f55c76ca670f0be3978cc048e31e24f3b4d7ce8473150a388/cffi-2.1.1-cp310-cp310-macosx_10_15_x86_64.whl", upload-time = 2026-08-03T21:19:15Z, size = 183779, hashes = { sha256 = "baed1e86cc735622097354b9d1281406caf42ff42a886d29faa8e8d1630333be" } }, + { url = "https://files.pythonhosted.org/packages/94/1a/4b2f7c92293ba05cbd4a9a1b28faaf0326272d9488e6354657571c48a7aa/cffi-2.1.1-cp310-cp310-macosx_11_0_arm64.whl", upload-time = 2026-08-03T21:19:16Z, size = 184178, hashes = { sha256 = "ca82be1a1d406ecfe1d25dc16cb33488e5a16bf4438c9fb590484ea29d92478b" } }, + { url = "https://files.pythonhosted.org/packages/17/0b/ba385d8ccedf926c3cd06e8e2f327027da5afe5f0eb30f1f7bc43ac55125/cffi-2.1.1-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", upload-time = 2026-08-03T21:19:17Z, size = 211037, hashes = { sha256 = "42e2f76b9455f5a9a844f770bf3e200ed3da0e15f5df3db9c31fe80b04b3d004" } }, + { url = "https://files.pythonhosted.org/packages/a3/b9/0f2e58b2cefa33255bff36935d42b13180fe559bba82596540eb404bde7d/cffi-2.1.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-08-03T21:19:18Z, size = 218652, hashes = { sha256 = "5a59cc1c4442bc3d5c703bf720b51138d0bfc173618807c9ee2490a7541dd3d9" } }, + { url = "https://files.pythonhosted.org/packages/37/15/180e0dab27b9312c7479003d14c9e547634b7dcb934e2cc4650e1b131a7a/cffi-2.1.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", upload-time = 2026-08-03T21:19:19Z, size = 205422, hashes = { sha256 = "9f8d177621de5cb38ee3e731eda45d421db093ec0739f46a5594babda7987a98" } }, + { url = "https://files.pythonhosted.org/packages/18/d4/03026f0c850cbbaa9030750490225b4a7f4d524ea4df72c3cc740a90f4ef/cffi-2.1.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", upload-time = 2026-08-03T21:19:21Z, size = 205444, hashes = { sha256 = "75f80557d1389eddbd0de2681f6a390a0c5338c31ddaa821381c203fc3fd50d9" } }, + { url = "https://files.pythonhosted.org/packages/75/77/60bebf6f818bec84210ac5b6979ce4eeadce6fbbaabc9c7ab23e506d1ce5/cffi-2.1.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-03T21:19:22Z, size = 218742, hashes = { sha256 = "194cffa889098ced9976c3fc6340305e43f6303657d298da55366907c05c22d6" } }, + { url = "https://files.pythonhosted.org/packages/b0/ae/679bf47e73fd77b352171727f07de559a003f14de5d02b904a6ec1fa73ca/cffi-2.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", upload-time = 2026-08-03T21:19:23Z, size = 221054, hashes = { sha256 = "5bb4e7ea95dcd6a014a6fef62e62467d67d8e582326443f3d68e71d6320a9fcf" } }, + { url = "https://files.pythonhosted.org/packages/09/b8/eefc0e06913b70aa153bf74c946094a18f58fd4aff11b7f372bfdfdca050/cffi-2.1.1-cp310-cp310-musllinux_1_2_i686.whl", upload-time = 2026-08-03T21:19:24Z, size = 213489, hashes = { sha256 = "3d22a20b1fb1632cc72c22f95f7b0d2961c3e1c235f245ba4c606c4771035659" } }, + { url = "https://files.pythonhosted.org/packages/6f/13/4e56852824a03cdf68523a35686f1c28eacd4bd30a7b0a78e682e6e6e1d3/cffi-2.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", upload-time = 2026-08-03T21:19:26Z, size = 220241, hashes = { sha256 = "1dea0e4d7d4f11f619fe8c1d76caf49e24405b4b5743c0e3be16a500ecd930c9" } }, + { url = "https://files.pythonhosted.org/packages/99/7f/040f9e163e4acac3ee3d85b02d00b2576e7ca980d8785f0a3a5f1a9bf7f5/cffi-2.1.1-cp310-cp310-win32.whl", upload-time = 2026-08-03T21:19:27Z, size = 174578, hashes = { sha256 = "7ce713ace7c0e4520535b42b77eaa742c16dab813978064913e5a3cf82973b41" } }, + { url = "https://files.pythonhosted.org/packages/ba/0b/644a2ec1a4eaba49c2939410bb1eb1d25b09d6d0582f5d2f95c537043725/cffi-2.1.1-cp310-cp310-win_amd64.whl", upload-time = 2026-08-03T21:19:28Z, size = 185082, hashes = { sha256 = "a48d62ab9d6f4f98c983223a547af44be6ca3691074c31cecced6facd3ba2dc1" } }, + { url = "https://files.pythonhosted.org/packages/70/d2/16d99a0c4948febc0ebd133a13b2f688ff7f8cb04da971e1128872ce0c03/cffi-2.1.1-cp311-cp311-macosx_10_15_x86_64.whl", upload-time = 2026-08-03T21:19:29Z, size = 183838, hashes = { sha256 = "c8d2c9fd1f2d16f780d15127abb050d13d1a76c03a4bd87d7e4980e45e511e12" } }, + { url = "https://files.pythonhosted.org/packages/cd/95/31b535a9f0220ae9f357de4a08d57ce89cb417653c2fd9f075f50822a388/cffi-2.1.1-cp311-cp311-macosx_11_0_arm64.whl", upload-time = 2026-08-03T21:19:30Z, size = 184168, hashes = { sha256 = "398aff33cee2767e3e781d2554c54bd0dff386bb437581e0d8011fde1a942ec1" } }, + { url = "https://files.pythonhosted.org/packages/ad/5a/4707a0dc1f203f5dde5a907b0d4e3c25d71120241048bd5bc6f1bb9d4e71/cffi-2.1.1-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", upload-time = 2026-08-03T21:19:31Z, size = 211805, hashes = { sha256 = "154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0" } }, + { url = "https://files.pythonhosted.org/packages/ad/66/c19feabb28485b6e0bbaaafa90837a1ef5d302e90f2178bd33f17a49879b/cffi-2.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-08-03T21:19:32Z, size = 218716, hashes = { sha256 = "3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813" } }, + { url = "https://files.pythonhosted.org/packages/a7/92/500760486c8baab49a7a8a58ba7fc3355ec3974b454b8a09e528efde9e1d/cffi-2.1.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", upload-time = 2026-08-03T21:19:34Z, size = 205569, hashes = { sha256 = "6e192623c49c94421616a5778fba35cf0d5a8d000650c1967ef4448ee5cdd990" } }, + { url = "https://files.pythonhosted.org/packages/a5/a7/a67c733254d6e7373f7822f8082d8d6beade791e0cf12a7611f376fa61c7/cffi-2.1.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", upload-time = 2026-08-03T21:19:35Z, size = 204907, hashes = { sha256 = "a6e721d4b0e45d5b65e87534470e67b18dcd092c83f68fba09f152b9cbc061af" } }, + { url = "https://files.pythonhosted.org/packages/f7/a4/4399daaf8f7dfee9d7c3327fdb0426ee041cc63edc358b93911ceb2bfc7a/cffi-2.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-03T21:19:36Z, size = 217807, hashes = { sha256 = "34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632" } }, + { url = "https://files.pythonhosted.org/packages/28/f7/dabe6da2466ecbd82dc62e7342dc6b1065dad990c06f00f0ede9ebf2a0ed/cffi-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", upload-time = 2026-08-03T21:19:37Z, size = 221252, hashes = { sha256 = "7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd" } }, + { url = "https://files.pythonhosted.org/packages/ce/87/616202d8e51342c07d2534c510111c4cc37201775ce8f60802c9335d1edd/cffi-2.1.1-cp311-cp311-musllinux_1_2_i686.whl", upload-time = 2026-08-03T21:19:38Z, size = 214214, hashes = { sha256 = "df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a" } }, + { url = "https://files.pythonhosted.org/packages/b4/c6/ab025d75d2c26c19b087c0124e75ee31cb65032f4fe345d356d8c507ab97/cffi-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", upload-time = 2026-08-03T21:19:39Z, size = 219408, hashes = { sha256 = "f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa" } }, + { url = "https://files.pythonhosted.org/packages/db/e2/7e8109f65445bdc673a7b54f02c677de462db75674220fd1335efc8eb598/cffi-2.1.1-cp311-cp311-win32.whl", upload-time = 2026-08-03T21:19:41Z, size = 174470, hashes = { sha256 = "f8ec5e643a9a937f64e1999eb9f75d072263751912dc5cd06d3c85f8f44be7c3" } }, + { url = "https://files.pythonhosted.org/packages/73/c0/77ba02423c2f7d7091143c45cd49e0e6575c4c1967394bb542bd923a9b74/cffi-2.1.1-cp311-cp311-win_amd64.whl", upload-time = 2026-08-03T21:19:42Z, size = 185096, hashes = { sha256 = "42f6930c31dc7f50732c9ae793c2786c7b6b044195967bbdde40bb9be81c4cc0" } }, + { url = "https://files.pythonhosted.org/packages/7c/47/9f1f85f9672ceda4984dc6c4f8824e8558992a2972c3d3c81fb8eb28d4ba/cffi-2.1.1-cp311-cp311-win_arm64.whl", upload-time = 2026-08-03T21:19:43Z, size = 179941, hashes = { sha256 = "c7659f22557c5a0bc4855cd635f55edec690cc008a40768527762cb9fb263455" } }, + { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", upload-time = 2026-08-03T21:19:44Z, size = 184821, hashes = { sha256 = "c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0" } }, + { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", upload-time = 2026-08-03T21:19:46Z, size = 184719, hashes = { sha256 = "f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf" } }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", upload-time = 2026-08-03T21:19:47Z, size = 214799, hashes = { sha256 = "811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a" } }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-08-03T21:19:48Z, size = 222389, hashes = { sha256 = "68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890" } }, + { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", upload-time = 2026-08-03T21:19:49Z, size = 210249, hashes = { sha256 = "4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50" } }, + { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", upload-time = 2026-08-03T21:19:50Z, size = 208775, hashes = { sha256 = "3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e" } }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-03T21:19:52Z, size = 221822, hashes = { sha256 = "c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf" } }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", upload-time = 2026-08-03T21:19:53Z, size = 225232, hashes = { sha256 = "208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517" } }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", upload-time = 2026-08-03T21:19:54Z, size = 223597, hashes = { sha256 = "210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735" } }, + { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", upload-time = 2026-08-03T21:19:55Z, size = 175292, hashes = { sha256 = "046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e" } }, + { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", upload-time = 2026-08-03T21:19:56Z, size = 185919, hashes = { sha256 = "f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a" } }, + { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", upload-time = 2026-08-03T21:19:58Z, size = 180093, hashes = { sha256 = "7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80" } }, + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", upload-time = 2026-08-03T21:19:59Z, size = 194248, hashes = { sha256 = "b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e" } }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", upload-time = 2026-08-03T21:20:00Z, size = 196908, hashes = { sha256 = "31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c" } }, + { url = "https://files.pythonhosted.org/packages/a7/46/2e5fdde8555706dd98139a910ca11be02809f3f605ce956f655d0214e100/cffi-2.1.1-cp313-cp313-macosx_10_15_x86_64.whl", upload-time = 2026-08-03T21:20:02Z, size = 184805, hashes = { sha256 = "9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6" } }, + { url = "https://files.pythonhosted.org/packages/55/41/4c7042f317b9217502988f0873af87e16ad606dc20f84e546e3e6ce9764c/cffi-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", upload-time = 2026-08-03T21:20:03Z, size = 184764, hashes = { sha256 = "19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971" } }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", upload-time = 2026-08-03T21:20:04Z, size = 214722, hashes = { sha256 = "6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c" } }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-08-03T21:20:05Z, size = 222369, hashes = { sha256 = "f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125" } }, + { url = "https://files.pythonhosted.org/packages/02/10/4b3c75dde3d9663c9e02ba05c2668b954f671d4bbe346413ca8c696b295a/cffi-2.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", upload-time = 2026-08-03T21:20:06Z, size = 210175, hashes = { sha256 = "fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264" } }, + { url = "https://files.pythonhosted.org/packages/df/62/14f74b9543e605d17701dc797b815958b8bb70b7624ce1b832ddad48ed6c/cffi-2.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", upload-time = 2026-08-03T21:20:08Z, size = 208670, hashes = { sha256 = "aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3" } }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-03T21:20:09Z, size = 221824, hashes = { sha256 = "a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2" } }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", upload-time = 2026-08-03T21:20:10Z, size = 225148, hashes = { sha256 = "a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b" } }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", upload-time = 2026-08-03T21:20:12Z, size = 223564, hashes = { sha256 = "e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7" } }, + { url = "https://files.pythonhosted.org/packages/70/ea/839b50531021a647fb5e929f72cf97bc1ff702b5472166164b5b6e76b851/cffi-2.1.1-cp313-cp313-win32.whl", upload-time = 2026-08-03T21:20:13Z, size = 175263, hashes = { sha256 = "334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac" } }, + { url = "https://files.pythonhosted.org/packages/60/a6/8b149b2c3f2e11aaa1618ef64500b45f50f22c57a977a4dff1aff1f91042/cffi-2.1.1-cp313-cp313-win_amd64.whl", upload-time = 2026-08-03T21:20:14Z, size = 185688, hashes = { sha256 = "1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d" } }, + { url = "https://files.pythonhosted.org/packages/01/9a/11f687cb39d6a3504060d5242f04f48c735afb4d3d533958a20594890cb2/cffi-2.1.1-cp313-cp313-win_arm64.whl", upload-time = 2026-08-03T21:20:15Z, size = 180078, hashes = { sha256 = "63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973" } }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", upload-time = 2026-08-03T21:20:17Z, size = 194064, hashes = { sha256 = "7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c" } }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", upload-time = 2026-08-03T21:20:18Z, size = 196720, hashes = { sha256 = "f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb" } }, + { url = "https://files.pythonhosted.org/packages/d9/99/c4b0c17cacdc9c3b8f280026286a9826d6a208c0f047591a3c3ce99b91fd/cffi-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", upload-time = 2026-08-03T21:20:19Z, size = 184964, hashes = { sha256 = "d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54" } }, + { url = "https://files.pythonhosted.org/packages/b3/a9/9db617d05d7367c1ad0ab00b3aa6e6f9281edd689b4ee9ea0e5a84e89c97/cffi-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", upload-time = 2026-08-03T21:20:20Z, size = 184962, hashes = { sha256 = "661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72" } }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-08-03T21:20:22Z, size = 222328, hashes = { sha256 = "58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1" } }, + { url = "https://files.pythonhosted.org/packages/80/10/c5c0cbf0a657aecf59ef511409734230bf556f05a0d6c9eed7aa5c0a0166/cffi-2.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", upload-time = 2026-08-03T21:20:23Z, size = 209985, hashes = { sha256 = "456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062" } }, + { url = "https://files.pythonhosted.org/packages/d5/6c/bfa0b87b03b9238148beca990292843c9396ba069b54496596594173de7b/cffi-2.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", upload-time = 2026-08-03T21:20:24Z, size = 208530, hashes = { sha256 = "a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03" } }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-03T21:20:25Z, size = 221525, hashes = { sha256 = "b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96" } }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", upload-time = 2026-08-03T21:20:26Z, size = 225053, hashes = { sha256 = "64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527" } }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", upload-time = 2026-08-03T21:20:28Z, size = 223213, hashes = { sha256 = "5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13" } }, + { url = "https://files.pythonhosted.org/packages/0b/e9/d0061c364cde06ee43168a0d076ac1da512cbc380d44767b844ba34fe2b6/cffi-2.1.1-cp314-cp314-win32.whl", upload-time = 2026-08-03T21:20:44Z, size = 177682, hashes = { sha256 = "1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c" } }, + { url = "https://files.pythonhosted.org/packages/a7/06/1c3e01e3ba14c39f6d10bfbac52753b7e22259e38088e5cfe1d704918690/cffi-2.1.1-cp314-cp314-win_amd64.whl", upload-time = 2026-08-03T21:20:45Z, size = 187949, hashes = { sha256 = "3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48" } }, + { url = "https://files.pythonhosted.org/packages/87/5b/da4e39efe18eeb89cf580ea9cfc66b6a7c3eadb808fc0cc1d3a295cb5a5d/cffi-2.1.1-cp314-cp314-win_arm64.whl", upload-time = 2026-08-03T21:20:46Z, size = 182947, hashes = { sha256 = "ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836" } }, + { url = "https://files.pythonhosted.org/packages/23/59/40338bf421c5accea1d45158170c87006ef1cd371b05c077e76476949728/cffi-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", upload-time = 2026-08-03T21:20:29Z, size = 188504, hashes = { sha256 = "7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3" } }, + { url = "https://files.pythonhosted.org/packages/7d/47/5ecf1023850036e674c77ec4de86182d309ae344e39e7cba984b7df5d647/cffi-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", upload-time = 2026-08-03T21:20:31Z, size = 188259, hashes = { sha256 = "0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2" } }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-08-03T21:20:32Z, size = 223864, hashes = { sha256 = "49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94" } }, + { url = "https://files.pythonhosted.org/packages/4d/45/ba4c93527bc38616a8bd36488acb69a2212d60486794f0c1f318949bbb76/cffi-2.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", upload-time = 2026-08-03T21:20:33Z, size = 211538, hashes = { sha256 = "e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc" } }, + { url = "https://files.pythonhosted.org/packages/80/e9/b6ef565e452acb932fb0cb5443f44a78efbd1233e566f02b5a83855e9115/cffi-2.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", upload-time = 2026-08-03T21:20:34Z, size = 210688, hashes = { sha256 = "28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29" } }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-03T21:20:36Z, size = 223803, hashes = { sha256 = "51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676" } }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", upload-time = 2026-08-03T21:20:37Z, size = 226763, hashes = { sha256 = "5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e" } }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", upload-time = 2026-08-03T21:20:38Z, size = 225688, hashes = { sha256 = "25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f" } }, + { url = "https://files.pythonhosted.org/packages/eb/d2/3b7176cb570a1d3e27faf67b72f591af508036e0d8b2be2ef9af9e8c84bb/cffi-2.1.1-cp314-cp314t-win32.whl", upload-time = 2026-08-03T21:20:40Z, size = 182868, hashes = { sha256 = "8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4" } }, + { url = "https://files.pythonhosted.org/packages/56/78/31f00c1bcd97c9bbf55f1bfdf5bc809a5de8887473e90bb9960dca825e80/cffi-2.1.1-cp314-cp314t-win_amd64.whl", upload-time = 2026-08-03T21:20:41Z, size = 194104, hashes = { sha256 = "616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e" } }, + { url = "https://files.pythonhosted.org/packages/7b/1b/58496f2ed0a35de575250c02a43ab3cc2c04d494a88fed31c1cabc0fd176/cffi-2.1.1-cp314-cp314t-win_arm64.whl", upload-time = 2026-08-03T21:20:43Z, size = 186402, hashes = { sha256 = "ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5" } }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", upload-time = 2026-08-03T21:20:48Z, size = 194043, hashes = { sha256 = "dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d" } }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", upload-time = 2026-08-03T21:20:49Z, size = 196737, hashes = { sha256 = "da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b" } }, + { url = "https://files.pythonhosted.org/packages/1b/8a/af668013284634733f02d683458a0728739c7d6ddb5e14cb0c20832266fe/cffi-2.1.1-cp315-cp315-macosx_10_15_x86_64.whl", upload-time = 2026-08-03T21:20:50Z, size = 184933, hashes = { sha256 = "fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4" } }, + { url = "https://files.pythonhosted.org/packages/0c/75/2f5207ff6d1a613133b23a5203cc0c2a628313b5eb3974d7956ae3c57950/cffi-2.1.1-cp315-cp315-macosx_11_0_arm64.whl", upload-time = 2026-08-03T21:20:52Z, size = 185002, hashes = { sha256 = "2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8" } }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-08-03T21:20:53Z, size = 222271, hashes = { sha256 = "507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6" } }, + { url = "https://files.pythonhosted.org/packages/50/e3/f6234a833e6e08c7007003074723c406559eecf9b48dfc97471e5a8eb7a0/cffi-2.1.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", upload-time = 2026-08-03T21:20:54Z, size = 209919, hashes = { sha256 = "246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80" } }, + { url = "https://files.pythonhosted.org/packages/0d/fc/5f74e293fced6edb51af3a46c4ccf6c23c9943774ecb375ddbd522c76add/cffi-2.1.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", upload-time = 2026-08-03T21:20:56Z, size = 208529, hashes = { sha256 = "471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779" } }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-03T21:20:57Z, size = 221630, hashes = { sha256 = "aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399" } }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", upload-time = 2026-08-03T21:20:58Z, size = 225134, hashes = { sha256 = "42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688" } }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", upload-time = 2026-08-03T21:20:59Z, size = 223197, hashes = { sha256 = "cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7" } }, + { url = "https://files.pythonhosted.org/packages/f8/7e/8debeb04f1ab9fe2a6963964cd6f1aaf7192627b83926586a6a4e089c9fa/cffi-2.1.1-cp315-cp315-win32.whl", upload-time = 2026-08-03T21:21:14Z, size = 177683, hashes = { sha256 = "4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac" } }, + { url = "https://files.pythonhosted.org/packages/e0/31/5158704cc474ab65c1647932e88be78dc0873f47130e253be38bcaf13d01/cffi-2.1.1-cp315-cp315-win_amd64.whl", upload-time = 2026-08-03T21:21:16Z, size = 187897, hashes = { sha256 = "e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960" } }, + { url = "https://files.pythonhosted.org/packages/cc/4b/b3a2da8570c704ffc0f9762cdc3ec0f02c8573798e0b5cf7f11c82bbb70f/cffi-2.1.1-cp315-cp315-win_arm64.whl", upload-time = 2026-08-03T21:21:17Z, size = 182935, hashes = { sha256 = "27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1" } }, + { url = "https://files.pythonhosted.org/packages/d0/ef/5443574510a1207e6f6bc38ba6e1f1de36cb48fef07b2728bb896a21f430/cffi-2.1.1-cp315-cp315t-macosx_10_15_x86_64.whl", upload-time = 2026-08-03T21:21:01Z, size = 188464, hashes = { sha256 = "c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc" } }, + { url = "https://files.pythonhosted.org/packages/7e/ae/a56fa8c4686ad50e148fcbc8d3ae0d03915ff5c30d795058988c24118cef/cffi-2.1.1-cp315-cp315t-macosx_11_0_arm64.whl", upload-time = 2026-08-03T21:21:02Z, size = 188262, hashes = { sha256 = "4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab" } }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", upload-time = 2026-08-03T21:21:03Z, size = 223779, hashes = { sha256 = "937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e" } }, + { url = "https://files.pythonhosted.org/packages/8a/f6/c3ad28bd19f77047a03084424fbd4cbe997303267c14423737324be0385d/cffi-2.1.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", upload-time = 2026-08-03T21:21:04Z, size = 211520, hashes = { sha256 = "df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358" } }, + { url = "https://files.pythonhosted.org/packages/a0/cd/ccac9013a5bd9fd764de118674ab9c805b5ca10c19270d90ee273f8b2240/cffi-2.1.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", upload-time = 2026-08-03T21:21:06Z, size = 210673, hashes = { sha256 = "a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231" } }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", upload-time = 2026-08-03T21:21:07Z, size = 223835, hashes = { sha256 = "363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6" } }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", upload-time = 2026-08-03T21:21:08Z, size = 226705, hashes = { sha256 = "770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94" } }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", upload-time = 2026-08-03T21:21:09Z, size = 225539, hashes = { sha256 = "7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5" } }, + { url = "https://files.pythonhosted.org/packages/6d/cd/a361394c94b2129d604bb846f624a8e88255a3ee33129c434a00d715e64f/cffi-2.1.1-cp315-cp315t-win32.whl", upload-time = 2026-08-03T21:21:11Z, size = 182707, hashes = { sha256 = "06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66" } }, + { url = "https://files.pythonhosted.org/packages/9b/b5/ba2b299993c26577d529b6ae29841f9e15b9fcf004d65f423f4fcf94ade9/cffi-2.1.1-cp315-cp315t-win_amd64.whl", upload-time = 2026-08-03T21:21:12Z, size = 193772, hashes = { sha256 = "d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3" } }, + { url = "https://files.pythonhosted.org/packages/aa/29/35e016098c814cd93de9cd320c66b5bfba14dc6ecedd3cb518fa7c408c69/cffi-2.1.1-cp315-cp315t-win_arm64.whl", upload-time = 2026-08-03T21:21:13Z, size = 186360, hashes = { sha256 = "d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692" } }, +] + [[packages]] name = "chardet" version = "5.2.0" @@ -304,6 +466,20 @@ index = "https://pypi.org/simple" sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", upload-time = 2025-03-05T20:05:02Z, size = 245115, hashes = { sha256 = "0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d" } } wheels = [{ url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", upload-time = 2025-03-05T20:05:00Z, size = 134899, hashes = { sha256 = "85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" } }] +[[packages]] +name = "jsonschema" +version = "4.26.0" +index = "https://pypi.org/simple" +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", upload-time = 2026-01-07T13:41:07Z, size = 366583, hashes = { sha256 = "0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", upload-time = 2026-01-07T13:41:05Z, size = 90630, hashes = { sha256 = "d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce" } }] + +[[packages]] +name = "jsonschema-specifications" +version = "2025.9.1" +index = "https://pypi.org/simple" +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", upload-time = 2025-09-08T01:34:59Z, size = 32855, hashes = { sha256 = "b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", upload-time = 2025-09-08T01:34:57Z, size = 18437, hashes = { sha256 = "98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe" } }] + [[packages]] name = "markdown-it-py" version = "3.0.0" @@ -426,6 +602,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", upload-time = 2025-02-13T21:54:37Z, size = 244885, hashes = { sha256 = "4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553" } }, ] +[[packages]] +name = "pycparser" +version = "3.11" +marker = "python_full_version < '3.11' and implementation_name != 'PyPy'" +index = "https://pypi.org/simple" +sdist = { url = "https://files.pythonhosted.org/packages/da/a8/c5fdbeee588bb8ada9458774f43adf1bdd30bd59157055142183e769a024/pycparser-3.11.tar.gz", upload-time = 2026-10-09T12:56:59Z, size = 113796, hashes = { sha256 = "d875f09c3507d00e1aba0eecc6dcadc1352f30fff09dc6bff2f1c2935e97c2bc" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/90/11/0e6f11117525ff0eec40ebac3d313376f102df93ca44ad9e893ee85e4f89/pycparser-3.11-py3-none-any.whl", upload-time = 2026-10-09T12:56:58Z, size = 51178, hashes = { sha256 = "51d5a8ba2be0bbe440b99d2112604c95bbbc3c2748a64260186c541e1729cd80" } }] + +[[packages]] +name = "pycparser" +version = "3.12" +marker = "python_full_version >= '3.11' and implementation_name != 'PyPy'" +index = "https://pypi.org/simple" +sdist = { url = "https://files.pythonhosted.org/packages/cb/27/eeb9f307bf07060f3d9f9aa0fb8c15b01bdfded0a941e4b2719c7f94cacd/pycparser-3.12.tar.gz", upload-time = 2026-10-22T13:40:03Z, size = 158785, hashes = { sha256 = "f03387877eab82ce01bbdfd0ba7252ee55a90b1c708d5129e2ce915475cf1db6" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/b6/ae/315bbeee126a769cbde43cf4908acb4b40408d8bf8bbf334dd7368d8dadf/pycparser-3.12-py3-none-any.whl", upload-time = 2026-10-22T13:40:02Z, size = 62600, hashes = { sha256 = "a076f3f489b39b43ed13563a1dafe42447445bec2e294154ec5c57fcdda4c85e" } }] + [[packages]] name = "pygments" version = "2.19.2" @@ -498,6 +690,13 @@ index = "https://pypi.org/simple" sdist = { url = "https://files.pythonhosted.org/packages/a8/b8/d16eb579277f3de9e56e5ad25280fab52fc5774117fb70362e8c2e016559/questionary-2.1.0.tar.gz", upload-time = 2024-12-29T11:49:17Z, size = 26775, hashes = { sha256 = "6302cdd645b19667d8f6e6634774e9538bfcd1aad9be287e743d96cacaf95587" } } wheels = [{ url = "https://files.pythonhosted.org/packages/ad/3f/11dd4cd4f39e05128bfd20138faea57bec56f9ffba6185d276e3107ba5b2/questionary-2.1.0-py3-none-any.whl", upload-time = 2024-12-29T11:49:16Z, size = 36747, hashes = { sha256 = "44174d237b68bc828e4878c763a9ad6790ee61990e0ae72927694ead57bab8ec" } }] +[[packages]] +name = "referencing" +version = "0.37.0" +index = "https://pypi.org/simple" +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", upload-time = 2025-10-13T15:30:48Z, size = 78036, hashes = { sha256 = "44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8" } } +wheels = [{ url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", upload-time = 2025-10-13T15:30:47Z, size = 26766, hashes = { sha256 = "381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231" } }] + [[packages]] name = "requests" version = "2.33.0" @@ -512,6 +711,267 @@ index = "https://pypi.org/simple" sdist = { url = "https://files.pythonhosted.org/packages/fe/75/af448d8e52bf1d8fa6a9d089ca6c07ff4453d86c65c145d0a300bb073b9b/rich-14.1.0.tar.gz", upload-time = 2025-07-25T07:32:58Z, size = 224441, hashes = { sha256 = "e497a48b844b0320d45007cdebfeaeed8db2a4f4bcf49f15e455cfc4af11eaa8" } } wheels = [{ url = "https://files.pythonhosted.org/packages/e3/30/3c4d035596d3cf444529e0b2953ad0466f6049528a879d27534700580395/rich-14.1.0-py3-none-any.whl", upload-time = 2025-07-25T07:32:56Z, size = 243368, hashes = { sha256 = "536f5f1785986d6dbdea3c75205c473f970777b4a0d6c6dd1b696aa05a3fa04f" } }] +[[packages]] +name = "rpds-py" +version = "0.30.0" +marker = "python_full_version < '3.11'" +index = "https://pypi.org/simple" +sdist = { url = "https://files.pythonhosted.org/packages/20/af/3f2f423103f1113b36230496629986e0ef7e199d2aa8392452b484b38ced/rpds_py-0.30.0.tar.gz", upload-time = 2025-11-30T20:24:38Z, size = 69469, hashes = { sha256 = "dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/06/0c/0c411a0ec64ccb6d104dcabe0e713e05e153a9a2c3c2bd2b32ce412166fe/rpds_py-0.30.0-cp310-cp310-macosx_10_12_x86_64.whl", upload-time = 2025-11-30T20:21:33Z, size = 370490, hashes = { sha256 = "679ae98e00c0e8d68a7fda324e16b90fd5260945b45d3b824c892cec9eea3288" } }, + { url = "https://files.pythonhosted.org/packages/19/6a/4ba3d0fb7297ebae71171822554abe48d7cab29c28b8f9f2c04b79988c05/rpds_py-0.30.0-cp310-cp310-macosx_11_0_arm64.whl", upload-time = 2025-11-30T20:21:34Z, size = 359751, hashes = { sha256 = "4cc2206b76b4f576934f0ed374b10d7ca5f457858b157ca52064bdfc26b9fc00" } }, + { url = "https://files.pythonhosted.org/packages/cd/7c/e4933565ef7f7a0818985d87c15d9d273f1a649afa6a52ea35ad011195ea/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-30T20:21:36Z, size = 389696, hashes = { sha256 = "389a2d49eded1896c3d48b0136ead37c48e221b391c052fba3f4055c367f60a6" } }, + { url = "https://files.pythonhosted.org/packages/5e/01/6271a2511ad0815f00f7ed4390cf2567bec1d4b1da39e2c27a41e6e3b4de/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2025-11-30T20:21:37Z, size = 403136, hashes = { sha256 = "32c8528634e1bf7121f3de08fa85b138f4e0dc47657866630611b03967f041d7" } }, + { url = "https://files.pythonhosted.org/packages/55/64/c857eb7cd7541e9b4eee9d49c196e833128a55b89a9850a9c9ac33ccf897/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2025-11-30T20:21:38Z, size = 524699, hashes = { sha256 = "f207f69853edd6f6700b86efb84999651baf3789e78a466431df1331608e5324" } }, + { url = "https://files.pythonhosted.org/packages/9c/ed/94816543404078af9ab26159c44f9e98e20fe47e2126d5d32c9d9948d10a/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2025-11-30T20:21:40Z, size = 412022, hashes = { sha256 = "67b02ec25ba7a9e8fa74c63b6ca44cf5707f2fbfadae3ee8e7494297d56aa9df" } }, + { url = "https://files.pythonhosted.org/packages/61/b5/707f6cf0066a6412aacc11d17920ea2e19e5b2f04081c64526eb35b5c6e7/rpds_py-0.30.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:21:42Z, size = 390522, hashes = { sha256 = "0c0e95f6819a19965ff420f65578bacb0b00f251fefe2c8b23347c37174271f3" } }, + { url = "https://files.pythonhosted.org/packages/13/4e/57a85fda37a229ff4226f8cbcf09f2a455d1ed20e802ce5b2b4a7f5ed053/rpds_py-0.30.0-cp310-cp310-manylinux_2_31_riscv64.whl", upload-time = 2025-11-30T20:21:43Z, size = 404579, hashes = { sha256 = "a452763cc5198f2f98898eb98f7569649fe5da666c2dc6b5ddb10fde5a574221" } }, + { url = "https://files.pythonhosted.org/packages/f9/da/c9339293513ec680a721e0e16bf2bac3db6e5d7e922488de471308349bba/rpds_py-0.30.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2025-11-30T20:21:44Z, size = 421305, hashes = { sha256 = "e0b65193a413ccc930671c55153a03ee57cecb49e6227204b04fae512eb657a7" } }, + { url = "https://files.pythonhosted.org/packages/f9/be/522cb84751114f4ad9d822ff5a1aa3c98006341895d5f084779b99596e5c/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_aarch64.whl", upload-time = 2025-11-30T20:21:46Z, size = 572503, hashes = { sha256 = "858738e9c32147f78b3ac24dc0edb6610000e56dc0f700fd5f651d0a0f0eb9ff" } }, + { url = "https://files.pythonhosted.org/packages/a2/9b/de879f7e7ceddc973ea6e4629e9b380213a6938a249e94b0cdbcc325bb66/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_i686.whl", upload-time = 2025-11-30T20:21:48Z, size = 598322, hashes = { sha256 = "da279aa314f00acbb803da1e76fa18666778e8a8f83484fba94526da5de2cba7" } }, + { url = "https://files.pythonhosted.org/packages/48/ac/f01fc22efec3f37d8a914fc1b2fb9bcafd56a299edbe96406f3053edea5a/rpds_py-0.30.0-cp310-cp310-musllinux_1_2_x86_64.whl", upload-time = 2025-11-30T20:21:50Z, size = 560792, hashes = { sha256 = "7c64d38fb49b6cdeda16ab49e35fe0da2e1e9b34bc38bd78386530f218b37139" } }, + { url = "https://files.pythonhosted.org/packages/e2/da/4e2b19d0f131f35b6146425f846563d0ce036763e38913d917187307a671/rpds_py-0.30.0-cp310-cp310-win32.whl", upload-time = 2025-11-30T20:21:51Z, size = 221901, hashes = { sha256 = "6de2a32a1665b93233cde140ff8b3467bdb9e2af2b91079f0333a0974d12d464" } }, + { url = "https://files.pythonhosted.org/packages/96/cb/156d7a5cf4f78a7cc571465d8aec7a3c447c94f6749c5123f08438bcf7bc/rpds_py-0.30.0-cp310-cp310-win_amd64.whl", upload-time = 2025-11-30T20:21:52Z, size = 235823, hashes = { sha256 = "1726859cd0de969f88dc8673bdd954185b9104e05806be64bcd87badbe313169" } }, + { url = "https://files.pythonhosted.org/packages/4d/6e/f964e88b3d2abee2a82c1ac8366da848fce1c6d834dc2132c3fda3970290/rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", upload-time = 2025-11-30T20:21:53Z, size = 370157, hashes = { sha256 = "a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425" } }, + { url = "https://files.pythonhosted.org/packages/94/ba/24e5ebb7c1c82e74c4e4f33b2112a5573ddc703915b13a073737b59b86e0/rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", upload-time = 2025-11-30T20:21:55Z, size = 359676, hashes = { sha256 = "dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d" } }, + { url = "https://files.pythonhosted.org/packages/84/86/04dbba1b087227747d64d80c3b74df946b986c57af0a9f0c98726d4d7a3b/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-30T20:21:57Z, size = 389938, hashes = { sha256 = "422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4" } }, + { url = "https://files.pythonhosted.org/packages/42/bb/1463f0b1722b7f45431bdd468301991d1328b16cffe0b1c2918eba2c4eee/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2025-11-30T20:21:58Z, size = 402932, hashes = { sha256 = "07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f" } }, + { url = "https://files.pythonhosted.org/packages/99/ee/2520700a5c1f2d76631f948b0736cdf9b0acb25abd0ca8e889b5c62ac2e3/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2025-11-30T20:21:59Z, size = 525830, hashes = { sha256 = "12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4" } }, + { url = "https://files.pythonhosted.org/packages/e0/ad/bd0331f740f5705cc555a5e17fdf334671262160270962e69a2bdef3bf76/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2025-11-30T20:22:00Z, size = 412033, hashes = { sha256 = "99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97" } }, + { url = "https://files.pythonhosted.org/packages/f8/1e/372195d326549bb51f0ba0f2ecb9874579906b97e08880e7a65c3bef1a99/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:22:02Z, size = 390828, hashes = { sha256 = "33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89" } }, + { url = "https://files.pythonhosted.org/packages/ab/2b/d88bb33294e3e0c76bc8f351a3721212713629ffca1700fa94979cb3eae8/rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", upload-time = 2025-11-30T20:22:04Z, size = 404683, hashes = { sha256 = "946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d" } }, + { url = "https://files.pythonhosted.org/packages/50/32/c759a8d42bcb5289c1fac697cd92f6fe01a018dd937e62ae77e0e7f15702/rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2025-11-30T20:22:05Z, size = 421583, hashes = { sha256 = "495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038" } }, + { url = "https://files.pythonhosted.org/packages/2b/81/e729761dbd55ddf5d84ec4ff1f47857f4374b0f19bdabfcf929164da3e24/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", upload-time = 2025-11-30T20:22:07Z, size = 572496, hashes = { sha256 = "d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7" } }, + { url = "https://files.pythonhosted.org/packages/14/f6/69066a924c3557c9c30baa6ec3a0aa07526305684c6f86c696b08860726c/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", upload-time = 2025-11-30T20:22:09Z, size = 598669, hashes = { sha256 = "8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed" } }, + { url = "https://files.pythonhosted.org/packages/5f/48/905896b1eb8a05630d20333d1d8ffd162394127b74ce0b0784ae04498d32/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", upload-time = 2025-11-30T20:22:11Z, size = 561011, hashes = { sha256 = "3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85" } }, + { url = "https://files.pythonhosted.org/packages/22/16/cd3027c7e279d22e5eb431dd3c0fbc677bed58797fe7581e148f3f68818b/rpds_py-0.30.0-cp311-cp311-win32.whl", upload-time = 2025-11-30T20:22:13Z, size = 221406, hashes = { sha256 = "55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c" } }, + { url = "https://files.pythonhosted.org/packages/fa/5b/e7b7aa136f28462b344e652ee010d4de26ee9fd16f1bfd5811f5153ccf89/rpds_py-0.30.0-cp311-cp311-win_amd64.whl", upload-time = 2025-11-30T20:22:14Z, size = 236024, hashes = { sha256 = "a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825" } }, + { url = "https://files.pythonhosted.org/packages/14/a6/364bba985e4c13658edb156640608f2c9e1d3ea3c81b27aa9d889fff0e31/rpds_py-0.30.0-cp311-cp311-win_arm64.whl", upload-time = 2025-11-30T20:22:16Z, size = 229069, hashes = { sha256 = "47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229" } }, + { url = "https://files.pythonhosted.org/packages/03/e7/98a2f4ac921d82f33e03f3835f5bf3a4a40aa1bfdc57975e74a97b2b4bdd/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", upload-time = 2025-11-30T20:22:17Z, size = 375086, hashes = { sha256 = "a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad" } }, + { url = "https://files.pythonhosted.org/packages/4d/a1/bca7fd3d452b272e13335db8d6b0b3ecde0f90ad6f16f3328c6fb150c889/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", upload-time = 2025-11-30T20:22:19Z, size = 359053, hashes = { sha256 = "6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05" } }, + { url = "https://files.pythonhosted.org/packages/65/1c/ae157e83a6357eceff62ba7e52113e3ec4834a84cfe07fa4b0757a7d105f/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-30T20:22:21Z, size = 390763, hashes = { sha256 = "ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28" } }, + { url = "https://files.pythonhosted.org/packages/d4/36/eb2eb8515e2ad24c0bd43c3ee9cd74c33f7ca6430755ccdb240fd3144c44/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2025-11-30T20:22:23Z, size = 408951, hashes = { sha256 = "a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd" } }, + { url = "https://files.pythonhosted.org/packages/d6/65/ad8dc1784a331fabbd740ef6f71ce2198c7ed0890dab595adb9ea2d775a1/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2025-11-30T20:22:25Z, size = 514622, hashes = { sha256 = "f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f" } }, + { url = "https://files.pythonhosted.org/packages/63/8e/0cfa7ae158e15e143fe03993b5bcd743a59f541f5952e1546b1ac1b5fd45/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2025-11-30T20:22:26Z, size = 414492, hashes = { sha256 = "d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1" } }, + { url = "https://files.pythonhosted.org/packages/60/1b/6f8f29f3f995c7ffdde46a626ddccd7c63aefc0efae881dc13b6e5d5bb16/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:22:27Z, size = 394080, hashes = { sha256 = "47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23" } }, + { url = "https://files.pythonhosted.org/packages/6d/d5/a266341051a7a3ca2f4b750a3aa4abc986378431fc2da508c5034d081b70/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", upload-time = 2025-11-30T20:22:29Z, size = 408680, hashes = { sha256 = "2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6" } }, + { url = "https://files.pythonhosted.org/packages/10/3b/71b725851df9ab7a7a4e33cf36d241933da66040d195a84781f49c50490c/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2025-11-30T20:22:31Z, size = 423589, hashes = { sha256 = "a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51" } }, + { url = "https://files.pythonhosted.org/packages/00/2b/e59e58c544dc9bd8bd8384ecdb8ea91f6727f0e37a7131baeff8d6f51661/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", upload-time = 2025-11-30T20:22:32Z, size = 573289, hashes = { sha256 = "73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5" } }, + { url = "https://files.pythonhosted.org/packages/da/3e/a18e6f5b460893172a7d6a680e86d3b6bc87a54c1f0b03446a3c8c7b588f/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", upload-time = 2025-11-30T20:22:34Z, size = 599737, hashes = { sha256 = "5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e" } }, + { url = "https://files.pythonhosted.org/packages/5c/e2/714694e4b87b85a18e2c243614974413c60aa107fd815b8cbc42b873d1d7/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", upload-time = 2025-11-30T20:22:35Z, size = 563120, hashes = { sha256 = "7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394" } }, + { url = "https://files.pythonhosted.org/packages/6f/ab/d5d5e3bcedb0a77f4f613706b750e50a5a3ba1c15ccd3665ecc636c968fd/rpds_py-0.30.0-cp312-cp312-win32.whl", upload-time = 2025-11-30T20:22:37Z, size = 223782, hashes = { sha256 = "1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf" } }, + { url = "https://files.pythonhosted.org/packages/39/3b/f786af9957306fdc38a74cef405b7b93180f481fb48453a114bb6465744a/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", upload-time = 2025-11-30T20:22:39Z, size = 240463, hashes = { sha256 = "a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b" } }, + { url = "https://files.pythonhosted.org/packages/f3/d2/b91dc748126c1559042cfe41990deb92c4ee3e2b415f6b5234969ffaf0cc/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", upload-time = 2025-11-30T20:22:40Z, size = 230868, hashes = { sha256 = "669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e" } }, + { url = "https://files.pythonhosted.org/packages/ed/dc/d61221eb88ff410de3c49143407f6f3147acf2538c86f2ab7ce65ae7d5f9/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", upload-time = 2025-11-30T20:22:41Z, size = 374887, hashes = { sha256 = "f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2" } }, + { url = "https://files.pythonhosted.org/packages/fd/32/55fb50ae104061dbc564ef15cc43c013dc4a9f4527a1f4d99baddf56fe5f/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", upload-time = 2025-11-30T20:22:43Z, size = 358904, hashes = { sha256 = "e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8" } }, + { url = "https://files.pythonhosted.org/packages/58/70/faed8186300e3b9bdd138d0273109784eea2396c68458ed580f885dfe7ad/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-30T20:22:44Z, size = 389945, hashes = { sha256 = "2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4" } }, + { url = "https://files.pythonhosted.org/packages/bd/a8/073cac3ed2c6387df38f71296d002ab43496a96b92c823e76f46b8af0543/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2025-11-30T20:22:46Z, size = 407783, hashes = { sha256 = "0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136" } }, + { url = "https://files.pythonhosted.org/packages/77/57/5999eb8c58671f1c11eba084115e77a8899d6e694d2a18f69f0ba471ec8b/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2025-11-30T20:22:47Z, size = 515021, hashes = { sha256 = "76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7" } }, + { url = "https://files.pythonhosted.org/packages/e0/af/5ab4833eadc36c0a8ed2bc5c0de0493c04f6c06de223170bd0798ff98ced/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2025-11-30T20:22:48Z, size = 414589, hashes = { sha256 = "692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2" } }, + { url = "https://files.pythonhosted.org/packages/b7/de/f7192e12b21b9e9a68a6d0f249b4af3fdcdff8418be0767a627564afa1f1/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:22:50Z, size = 394025, hashes = { sha256 = "9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6" } }, + { url = "https://files.pythonhosted.org/packages/91/c4/fc70cd0249496493500e7cc2de87504f5aa6509de1e88623431fec76d4b6/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", upload-time = 2025-11-30T20:22:51Z, size = 408895, hashes = { sha256 = "9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e" } }, + { url = "https://files.pythonhosted.org/packages/58/95/d9275b05ab96556fefff73a385813eb66032e4c99f411d0795372d9abcea/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2025-11-30T20:22:53Z, size = 422799, hashes = { sha256 = "a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d" } }, + { url = "https://files.pythonhosted.org/packages/06/c1/3088fc04b6624eb12a57eb814f0d4997a44b0d208d6cace713033ff1a6ba/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", upload-time = 2025-11-30T20:22:54Z, size = 572731, hashes = { sha256 = "5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7" } }, + { url = "https://files.pythonhosted.org/packages/d8/42/c612a833183b39774e8ac8fecae81263a68b9583ee343db33ab571a7ce55/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", upload-time = 2025-11-30T20:22:56Z, size = 599027, hashes = { sha256 = "ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31" } }, + { url = "https://files.pythonhosted.org/packages/5f/60/525a50f45b01d70005403ae0e25f43c0384369ad24ffe46e8d9068b50086/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", upload-time = 2025-11-30T20:22:58Z, size = 563020, hashes = { sha256 = "945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95" } }, + { url = "https://files.pythonhosted.org/packages/0b/5d/47c4655e9bcd5ca907148535c10e7d489044243cc9941c16ed7cd53be91d/rpds_py-0.30.0-cp313-cp313-win32.whl", upload-time = 2025-11-30T20:23:00Z, size = 223139, hashes = { sha256 = "b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d" } }, + { url = "https://files.pythonhosted.org/packages/f2/e1/485132437d20aa4d3e1d8b3fb5a5e65aa8139f1e097080c2a8443201742c/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", upload-time = 2025-11-30T20:23:02Z, size = 240224, hashes = { sha256 = "806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15" } }, + { url = "https://files.pythonhosted.org/packages/24/95/ffd128ed1146a153d928617b0ef673960130be0009c77d8fbf0abe306713/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", upload-time = 2025-11-30T20:23:03Z, size = 230645, hashes = { sha256 = "d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1" } }, + { url = "https://files.pythonhosted.org/packages/ff/1b/b10de890a0def2a319a2626334a7f0ae388215eb60914dbac8a3bae54435/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", upload-time = 2025-11-30T20:23:04Z, size = 364443, hashes = { sha256 = "eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a" } }, + { url = "https://files.pythonhosted.org/packages/0d/bf/27e39f5971dc4f305a4fb9c672ca06f290f7c4e261c568f3dea16a410d47/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", upload-time = 2025-11-30T20:23:06Z, size = 353375, hashes = { sha256 = "922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e" } }, + { url = "https://files.pythonhosted.org/packages/40/58/442ada3bba6e8e6615fc00483135c14a7538d2ffac30e2d933ccf6852232/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-30T20:23:07Z, size = 383850, hashes = { sha256 = "cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000" } }, + { url = "https://files.pythonhosted.org/packages/14/14/f59b0127409a33c6ef6f5c1ebd5ad8e32d7861c9c7adfa9a624fc3889f6c/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2025-11-30T20:23:09Z, size = 392812, hashes = { sha256 = "47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db" } }, + { url = "https://files.pythonhosted.org/packages/b3/66/e0be3e162ac299b3a22527e8913767d869e6cc75c46bd844aa43fb81ab62/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2025-11-30T20:23:11Z, size = 517841, hashes = { sha256 = "1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2" } }, + { url = "https://files.pythonhosted.org/packages/3d/55/fa3b9cf31d0c963ecf1ba777f7cf4b2a2c976795ac430d24a1f43d25a6ba/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2025-11-30T20:23:12Z, size = 408149, hashes = { sha256 = "39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa" } }, + { url = "https://files.pythonhosted.org/packages/60/ca/780cf3b1a32b18c0f05c441958d3758f02544f1d613abf9488cd78876378/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:23:14Z, size = 383843, hashes = { sha256 = "51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083" } }, + { url = "https://files.pythonhosted.org/packages/82/86/d5f2e04f2aa6247c613da0c1dd87fcd08fa17107e858193566048a1e2f0a/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", upload-time = 2025-11-30T20:23:16Z, size = 396507, hashes = { sha256 = "eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9" } }, + { url = "https://files.pythonhosted.org/packages/4b/9a/453255d2f769fe44e07ea9785c8347edaf867f7026872e76c1ad9f7bed92/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2025-11-30T20:23:17Z, size = 414949, hashes = { sha256 = "6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0" } }, + { url = "https://files.pythonhosted.org/packages/a3/31/622a86cdc0c45d6df0e9ccb6becdba5074735e7033c20e401a6d9d0e2ca0/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", upload-time = 2025-11-30T20:23:19Z, size = 565790, hashes = { sha256 = "c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94" } }, + { url = "https://files.pythonhosted.org/packages/1c/5d/15bbf0fb4a3f58a3b1c67855ec1efcc4ceaef4e86644665fff03e1b66d8d/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", upload-time = 2025-11-30T20:23:20Z, size = 590217, hashes = { sha256 = "61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08" } }, + { url = "https://files.pythonhosted.org/packages/6d/61/21b8c41f68e60c8cc3b2e25644f0e3681926020f11d06ab0b78e3c6bbff1/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", upload-time = 2025-11-30T20:23:22Z, size = 555806, hashes = { sha256 = "4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27" } }, + { url = "https://files.pythonhosted.org/packages/f9/39/7e067bb06c31de48de3eb200f9fc7c58982a4d3db44b07e73963e10d3be9/rpds_py-0.30.0-cp313-cp313t-win32.whl", upload-time = 2025-11-30T20:23:24Z, size = 211341, hashes = { sha256 = "3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6" } }, + { url = "https://files.pythonhosted.org/packages/0a/4d/222ef0b46443cf4cf46764d9c630f3fe4abaa7245be9417e56e9f52b8f65/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", upload-time = 2025-11-30T20:23:25Z, size = 225768, hashes = { sha256 = "f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d" } }, + { url = "https://files.pythonhosted.org/packages/86/81/dad16382ebbd3d0e0328776d8fd7ca94220e4fa0798d1dc5e7da48cb3201/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", upload-time = 2025-11-30T20:23:27Z, size = 362099, hashes = { sha256 = "68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0" } }, + { url = "https://files.pythonhosted.org/packages/2b/60/19f7884db5d5603edf3c6bce35408f45ad3e97e10007df0e17dd57af18f8/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", upload-time = 2025-11-30T20:23:29Z, size = 353192, hashes = { sha256 = "ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be" } }, + { url = "https://files.pythonhosted.org/packages/bf/c4/76eb0e1e72d1a9c4703c69607cec123c29028bff28ce41588792417098ac/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-30T20:23:30Z, size = 384080, hashes = { sha256 = "f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f" } }, + { url = "https://files.pythonhosted.org/packages/72/87/87ea665e92f3298d1b26d78814721dc39ed8d2c74b86e83348d6b48a6f31/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2025-11-30T20:23:32Z, size = 394841, hashes = { sha256 = "ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f" } }, + { url = "https://files.pythonhosted.org/packages/77/ad/7783a89ca0587c15dcbf139b4a8364a872a25f861bdb88ed99f9b0dec985/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2025-11-30T20:23:33Z, size = 516670, hashes = { sha256 = "3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87" } }, + { url = "https://files.pythonhosted.org/packages/5b/3c/2882bdac942bd2172f3da574eab16f309ae10a3925644e969536553cb4ee/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2025-11-30T20:23:35Z, size = 408005, hashes = { sha256 = "4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18" } }, + { url = "https://files.pythonhosted.org/packages/ce/81/9a91c0111ce1758c92516a3e44776920b579d9a7c09b2b06b642d4de3f0f/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:23:36Z, size = 382112, hashes = { sha256 = "47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad" } }, + { url = "https://files.pythonhosted.org/packages/cf/8e/1da49d4a107027e5fbc64daeab96a0706361a2918da10cb41769244b805d/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", upload-time = 2025-11-30T20:23:38Z, size = 399049, hashes = { sha256 = "b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07" } }, + { url = "https://files.pythonhosted.org/packages/df/5a/7ee239b1aa48a127570ec03becbb29c9d5a9eb092febbd1699d567cae859/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2025-11-30T20:23:40Z, size = 415661, hashes = { sha256 = "4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f" } }, + { url = "https://files.pythonhosted.org/packages/70/ea/caa143cf6b772f823bc7929a45da1fa83569ee49b11d18d0ada7f5ee6fd6/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", upload-time = 2025-11-30T20:23:42Z, size = 565606, hashes = { sha256 = "0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65" } }, + { url = "https://files.pythonhosted.org/packages/64/91/ac20ba2d69303f961ad8cf55bf7dbdb4763f627291ba3d0d7d67333cced9/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", upload-time = 2025-11-30T20:23:44Z, size = 591126, hashes = { sha256 = "ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f" } }, + { url = "https://files.pythonhosted.org/packages/21/20/7ff5f3c8b00c8a95f75985128c26ba44503fb35b8e0259d812766ea966c7/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", upload-time = 2025-11-30T20:23:46Z, size = 553371, hashes = { sha256 = "46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53" } }, + { url = "https://files.pythonhosted.org/packages/72/c7/81dadd7b27c8ee391c132a6b192111ca58d866577ce2d9b0ca157552cce0/rpds_py-0.30.0-cp314-cp314-win32.whl", upload-time = 2025-11-30T20:23:47Z, size = 215298, hashes = { sha256 = "ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed" } }, + { url = "https://files.pythonhosted.org/packages/3e/d2/1aaac33287e8cfb07aab2e6b8ac1deca62f6f65411344f1433c55e6f3eb8/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", upload-time = 2025-11-30T20:23:49Z, size = 228604, hashes = { sha256 = "95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950" } }, + { url = "https://files.pythonhosted.org/packages/e8/95/ab005315818cc519ad074cb7784dae60d939163108bd2b394e60dc7b5461/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", upload-time = 2025-11-30T20:23:50Z, size = 222391, hashes = { sha256 = "613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6" } }, + { url = "https://files.pythonhosted.org/packages/9e/68/154fe0194d83b973cdedcdcc88947a2752411165930182ae41d983dcefa6/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", upload-time = 2025-11-30T20:23:52Z, size = 364868, hashes = { sha256 = "7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb" } }, + { url = "https://files.pythonhosted.org/packages/83/69/8bbc8b07ec854d92a8b75668c24d2abcb1719ebf890f5604c61c9369a16f/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", upload-time = 2025-11-30T20:23:54Z, size = 353747, hashes = { sha256 = "a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8" } }, + { url = "https://files.pythonhosted.org/packages/ab/00/ba2e50183dbd9abcce9497fa5149c62b4ff3e22d338a30d690f9af970561/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-30T20:23:55Z, size = 383795, hashes = { sha256 = "0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7" } }, + { url = "https://files.pythonhosted.org/packages/05/6f/86f0272b84926bcb0e4c972262f54223e8ecc556b3224d281e6598fc9268/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2025-11-30T20:23:57Z, size = 393330, hashes = { sha256 = "5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898" } }, + { url = "https://files.pythonhosted.org/packages/cb/e9/0e02bb2e6dc63d212641da45df2b0bf29699d01715913e0d0f017ee29438/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2025-11-30T20:23:58Z, size = 518194, hashes = { sha256 = "9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e" } }, + { url = "https://files.pythonhosted.org/packages/ee/ca/be7bca14cf21513bdf9c0606aba17d1f389ea2b6987035eb4f62bd923f25/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2025-11-30T20:24:00Z, size = 408340, hashes = { sha256 = "e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419" } }, + { url = "https://files.pythonhosted.org/packages/c2/c7/736e00ebf39ed81d75544c0da6ef7b0998f8201b369acf842f9a90dc8fce/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:24:01Z, size = 383765, hashes = { sha256 = "626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551" } }, + { url = "https://files.pythonhosted.org/packages/4a/3f/da50dfde9956aaf365c4adc9533b100008ed31aea635f2b8d7b627e25b49/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", upload-time = 2025-11-30T20:24:03Z, size = 396834, hashes = { sha256 = "acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8" } }, + { url = "https://files.pythonhosted.org/packages/4e/00/34bcc2565b6020eab2623349efbdec810676ad571995911f1abdae62a3a0/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2025-11-30T20:24:05Z, size = 415470, hashes = { sha256 = "fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5" } }, + { url = "https://files.pythonhosted.org/packages/8c/28/882e72b5b3e6f718d5453bd4d0d9cf8df36fddeb4ddbbab17869d5868616/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", upload-time = 2025-11-30T20:24:06Z, size = 565630, hashes = { sha256 = "74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404" } }, + { url = "https://files.pythonhosted.org/packages/3b/97/04a65539c17692de5b85c6e293520fd01317fd878ea1995f0367d4532fb1/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", upload-time = 2025-11-30T20:24:08Z, size = 591148, hashes = { sha256 = "3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856" } }, + { url = "https://files.pythonhosted.org/packages/85/70/92482ccffb96f5441aab93e26c4d66489eb599efdcf96fad90c14bbfb976/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", upload-time = 2025-11-30T20:24:10Z, size = 556030, hashes = { sha256 = "dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40" } }, + { url = "https://files.pythonhosted.org/packages/20/53/7c7e784abfa500a2b6b583b147ee4bb5a2b3747a9166bab52fec4b5b5e7d/rpds_py-0.30.0-cp314-cp314t-win32.whl", upload-time = 2025-11-30T20:24:12Z, size = 211570, hashes = { sha256 = "dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0" } }, + { url = "https://files.pythonhosted.org/packages/d0/02/fa464cdfbe6b26e0600b62c528b72d8608f5cc49f96b8d6e38c95d60c676/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", upload-time = 2025-11-30T20:24:14Z, size = 226532, hashes = { sha256 = "27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3" } }, + { url = "https://files.pythonhosted.org/packages/69/71/3f34339ee70521864411f8b6992e7ab13ac30d8e4e3309e07c7361767d91/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", upload-time = 2025-11-30T20:24:16Z, size = 372292, hashes = { sha256 = "c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58" } }, + { url = "https://files.pythonhosted.org/packages/57/09/f183df9b8f2d66720d2ef71075c59f7e1b336bec7ee4c48f0a2b06857653/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", upload-time = 2025-11-30T20:24:18Z, size = 362128, hashes = { sha256 = "ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a" } }, + { url = "https://files.pythonhosted.org/packages/7a/68/5c2594e937253457342e078f0cc1ded3dd7b2ad59afdbf2d354869110a02/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2025-11-30T20:24:20Z, size = 391542, hashes = { sha256 = "3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb" } }, + { url = "https://files.pythonhosted.org/packages/49/5c/31ef1afd70b4b4fbdb2800249f34c57c64beb687495b10aec0365f53dfc4/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2025-11-30T20:24:22Z, size = 404004, hashes = { sha256 = "250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c" } }, + { url = "https://files.pythonhosted.org/packages/e3/63/0cfbea38d05756f3440ce6534d51a491d26176ac045e2707adc99bb6e60a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2025-11-30T20:24:24Z, size = 527063, hashes = { sha256 = "9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3" } }, + { url = "https://files.pythonhosted.org/packages/42/e6/01e1f72a2456678b0f618fc9a1a13f882061690893c192fcad9f2926553a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2025-11-30T20:24:25Z, size = 413099, hashes = { sha256 = "993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5" } }, + { url = "https://files.pythonhosted.org/packages/b8/25/8df56677f209003dcbb180765520c544525e3ef21ea72279c98b9aa7c7fb/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2025-11-30T20:24:27Z, size = 392177, hashes = { sha256 = "58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738" } }, + { url = "https://files.pythonhosted.org/packages/4a/b4/0a771378c5f16f8115f796d1f437950158679bcd2a7c68cf251cfb00ed5b/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", upload-time = 2025-11-30T20:24:29Z, size = 406015, hashes = { sha256 = "dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f" } }, + { url = "https://files.pythonhosted.org/packages/36/d8/456dbba0af75049dc6f63ff295a2f92766b9d521fa00de67a2bd6427d57a/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2025-11-30T20:24:31Z, size = 423736, hashes = { sha256 = "ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877" } }, + { url = "https://files.pythonhosted.org/packages/13/64/b4d76f227d5c45a7e0b796c674fd81b0a6c4fbd48dc29271857d8219571c/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", upload-time = 2025-11-30T20:24:32Z, size = 573981, hashes = { sha256 = "dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a" } }, + { url = "https://files.pythonhosted.org/packages/20/91/092bacadeda3edf92bf743cc96a7be133e13a39cdbfd7b5082e7ab638406/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", upload-time = 2025-11-30T20:24:35Z, size = 599782, hashes = { sha256 = "1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4" } }, + { url = "https://files.pythonhosted.org/packages/d1/b7/b95708304cd49b7b6f82fdd039f1748b66ec2b21d6a45180910802f1abf1/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", upload-time = 2025-11-30T20:24:36Z, size = 562191, hashes = { sha256 = "ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e" } }, +] + +[[packages]] +name = "rpds-py" +version = "2026.5.1" +marker = "python_full_version >= '3.11'" +index = "https://pypi.org/simple" +sdist = { url = "https://files.pythonhosted.org/packages/2e/43/25a8dcd3feedd735039a8f0b5b7e3b118232b5eae288c4fd9ab200d41094/rpds_py-2026.5.1.tar.gz", upload-time = 2026-05-28T12:02:13Z, size = 64459, hashes = { sha256 = "07b24fea40541e28570e5b795a4a38fbdcd12550c06bd0748005ecc8116ca256" } } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/a0/acf8b6fc20bfdcd3a45bd3f57680fb198e157b7e997b9123b10763798bd2/rpds_py-2026.5.1-cp311-cp311-macosx_10_12_x86_64.whl", upload-time = 2026-05-28T11:58:50Z, size = 355609, hashes = { sha256 = "3397a5ed7174dc2786bb214030232fc36fe8e5584fec43a9952cc542b1a12036" } }, + { url = "https://files.pythonhosted.org/packages/b6/95/f8203fd997484b1690a6869cd0e503b6c3c6be55b0ecc36d1a491fe742f0/rpds_py-2026.5.1-cp311-cp311-macosx_11_0_arm64.whl", upload-time = 2026-05-28T11:58:52Z, size = 348460, hashes = { sha256 = "99ab6ba7bfa2cb0f96a04e3652355bf04e3f51aceb1e943b8541dab7ba4828cc" } }, + { url = "https://files.pythonhosted.org/packages/33/8c/b47326ad2f0be545a5e5c1a55937a12afaea7d392ba2837bb9680f57e6c9/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-05-28T11:58:53Z, size = 381031, hashes = { sha256 = "d0efbe45632665e53e3db8fe1e5692db58fc5cb9bab4459d570b83efefe11164" } }, + { url = "https://files.pythonhosted.org/packages/22/0b/e83bbd97ffac6f6389b605cd4e1c8ac5761dc7e977769c9255d8c5adb7bd/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2026-05-28T11:58:55Z, size = 387121, hashes = { sha256 = "01d17b29c0c23d82b1f4751147ec49cf451f1fc2554eb9ef5f957e55d2656ead" } }, + { url = "https://files.pythonhosted.org/packages/fd/0e/d285d1bc8864245919c61e1ca82263e4a66d337759c3a4cef72766ff9afc/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2026-05-28T11:58:56Z, size = 501026, hashes = { sha256 = "7559f72b94ae52659086c595dfa017cde03155f7832071d30959049052cb3ece" } }, + { url = "https://files.pythonhosted.org/packages/86/06/ccb2109a1e543437b5e43816f2b43b9554cc6783145528a4e3711e05c011/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2026-05-28T11:58:58Z, size = 391865, hashes = { sha256 = "9e25b7088f9ccbfc0dfcaa52bf969300ca229e10ecf758974ebcbb080a4b37bb" } }, + { url = "https://files.pythonhosted.org/packages/3d/33/237173db1cfef10105b3839a24de00eb8d2a523711add4632447cdf0aedd/rpds_py-2026.5.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-05-28T11:58:59Z, size = 378012, hashes = { sha256 = "613fc4ee9eaef26dc5840666214dd6fbcebcf32f46e76f4abc473059f4e13dda" } }, + { url = "https://files.pythonhosted.org/packages/97/64/1eae54e34d5161f9969295e80bd6b62a55f2b6ac5f2a5b60d02c2140e758/rpds_py-2026.5.1-cp311-cp311-manylinux_2_31_riscv64.whl", upload-time = 2026-05-28T11:59:01Z, size = 391111, hashes = { sha256 = "85264a90ff4c05c1568dd65f5921c837614b67c60358fb4c17df3b7f2e90690a" } }, + { url = "https://files.pythonhosted.org/packages/d8/34/5bb334a5a0f65d77869217c4654f34c78a7d11b93938a3c076a2edeafc52/rpds_py-2026.5.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2026-05-28T11:59:02Z, size = 409225, hashes = { sha256 = "fe71bca7d547acb17027c7fd1624ff8aae623499c498d3e7011182c4de5c25e0" } }, + { url = "https://files.pythonhosted.org/packages/16/0f/007ec21283b5b040b4ec3bd95e0402591e22bfa7d5c93dfe01c465c2d2d7/rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", upload-time = 2026-05-28T11:59:04Z, size = 556487, hashes = { sha256 = "a05fa4f41f37ec97c9c260441a940450a192f78d774d2b097eee1379f1e1246a" } }, + { url = "https://files.pythonhosted.org/packages/ff/10/5437c94508169b6b22d8418fef7a66e9ffb5f3b9e9c94460f2eedafe06ff/rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_i686.whl", upload-time = 2026-05-28T11:59:05Z, size = 620798, hashes = { sha256 = "df1d2a1996755b24b9ecee92cb4d36c28f86f464a6a173349c26bab41e94b8c2" } }, + { url = "https://files.pythonhosted.org/packages/e0/d5/9937dce4d6bda74157b954e7d1460db05a22f5929dccfeeba1ed27a93df0/rpds_py-2026.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", upload-time = 2026-05-28T11:59:06Z, size = 584053, hashes = { sha256 = "8895840ac4809e5f60c88fd07617cd71326e73d6e5a8aa783c5c0f7c24985de2" } }, + { url = "https://files.pythonhosted.org/packages/6c/31/750617dd0ae1752471bf43f9e41d263398fae7cde7849d23b8574a70e617/rpds_py-2026.5.1-cp311-cp311-win32.whl", upload-time = 2026-05-28T11:59:08Z, size = 214390, hashes = { sha256 = "3684a59b158a7683aaeb8e25352e9a9dd2122cec78f2d8530266e4f91b4c7b3f" } }, + { url = "https://files.pythonhosted.org/packages/3c/bb/3dcab0e1d9516303f2eb672a5d6f62eca5a69e2886301e9c8c54b520c39b/rpds_py-2026.5.1-cp311-cp311-win_amd64.whl", upload-time = 2026-05-28T11:59:09Z, size = 231097, hashes = { sha256 = "7bd530e6a530bb3ea892f194fafa455f3516ac25ecf7143fd33c09be62b0470a" } }, + { url = "https://files.pythonhosted.org/packages/49/d6/c6bbf5cb1cf12b9732df8074b57f6ef8341ba884c95d40632ae8bddb44e4/rpds_py-2026.5.1-cp311-cp311-win_arm64.whl", upload-time = 2026-05-28T11:59:11Z, size = 226361, hashes = { sha256 = "0a5ae4dbe43c1076983b72616496919872ae7bbe7a1e21cc48336bc3154d130b" } }, + { url = "https://files.pythonhosted.org/packages/d4/e7/a78582dc57caa592dcc7d4fb69b61390561e908eb3d2f5df5928a8e354c0/rpds_py-2026.5.1-cp312-cp312-macosx_10_12_x86_64.whl", upload-time = 2026-05-28T11:59:12Z, size = 353040, hashes = { sha256 = "3abe24a66e57adcfa645d718063a5fa5103ecc71ddbf26d78af8f9368018ff1d" } }, + { url = "https://files.pythonhosted.org/packages/a3/43/35e3f136343aef451e545ce8c38d36c2f93c0ed88703db8b64ba2b205c68/rpds_py-2026.5.1-cp312-cp312-macosx_11_0_arm64.whl", upload-time = 2026-05-28T11:59:13Z, size = 345775, hashes = { sha256 = "58b1d94308ddf0b1982f61f2eb54bf92997c9ece8a8093ef014250f4a517906c" } }, + { url = "https://files.pythonhosted.org/packages/20/e1/0f2160c5982d3157734d5cb3ed63d8b2d583a73c9864f77b666449f32cf8/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-05-28T11:59:15Z, size = 376329, hashes = { sha256 = "0fa92420128dadce7f54bd73ba1825a273e9268fe9e35dbf7e6362890efa4e08" } }, + { url = "https://files.pythonhosted.org/packages/d0/11/ee0ba42aff83bf4effdbc576673c6be64c5e173978c3f6d537e94482f77d/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2026-05-28T11:59:16Z, size = 383539, hashes = { sha256 = "ca653c6546386227cd9800d1bef6a348099acf8db4250341da6d90f663d6dfcb" } }, + { url = "https://files.pythonhosted.org/packages/11/df/d94aa6a499d4ac40afe2d7620f2c597fd3c0f182e854ad7cf3f596a81cb6/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2026-05-28T11:59:17Z, size = 494674, hashes = { sha256 = "66c93681c4729e4e3ecba31b8179fae083ff3118841672835140338b4b9867c1" } }, + { url = "https://files.pythonhosted.org/packages/1f/75/33d30f43bb2f458de11979486a591b1bf6e5651765ed1704c6197c2dc773/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2026-05-28T11:59:19Z, size = 389268, hashes = { sha256 = "40ff257542e04796880e011e15cd4dc21c2599975df2aaa8f2c8495ca574e1a5" } }, + { url = "https://files.pythonhosted.org/packages/f4/1e/2c9096fc19d5fd084b0184ca2b651e659aa0a37e6fdbecf6ece47f147fe1/rpds_py-2026.5.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-05-28T11:59:21Z, size = 376280, hashes = { sha256 = "b6825cc329b290e93c5f6a9be2393118a763f6ccf6abd83704e0c102ca583644" } }, + { url = "https://files.pythonhosted.org/packages/b9/e5/61ec9f8be8211ea7f48448195549e4aaf02004083475493b0e137702ecb2/rpds_py-2026.5.1-cp312-cp312-manylinux_2_31_riscv64.whl", upload-time = 2026-05-28T11:59:22Z, size = 387233, hashes = { sha256 = "de42116e69cb53b911cc34aee5ab98f36c597b822545045d49e938818b99e5e4" } }, + { url = "https://files.pythonhosted.org/packages/0d/ca/bcec1005c4f4a234f92a29078631fee49206c7265ccae966f18fd332e80e/rpds_py-2026.5.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2026-05-28T11:59:23Z, size = 405009, hashes = { sha256 = "c0f920015df2a504bebaba6d4c31ccf3fcf942f92655c086da30b671aad19aa6" } }, + { url = "https://files.pythonhosted.org/packages/72/e6/4d5718c5cf26c522dc7c9999e238da1e77380b81d0c5d1df11e271ddfeb1/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", upload-time = 2026-05-28T11:59:25Z, size = 553113, hashes = { sha256 = "0408a24e44feb919423dc6d9da677cb5cddb894d2ca9e763967d156d9c60fab4" } }, + { url = "https://files.pythonhosted.org/packages/d4/25/2ee807bdb3e1f0b7eddf7782acd5665a8b5205a331a7d7244a52c4812fd9/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_i686.whl", upload-time = 2026-05-28T11:59:26Z, size = 618838, hashes = { sha256 = "cea68bcd53467561ae2f96a6bdad1544299ba97b5b0ddcd5ac3d376e5c781c24" } }, + { url = "https://files.pythonhosted.org/packages/6a/c1/7d4c26f167f8c41501cc073d30ee22082b16ce358cf5b00ec97cbc7804ea/rpds_py-2026.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", upload-time = 2026-05-28T11:59:28Z, size = 582436, hashes = { sha256 = "4be8b1d2a705cc37d08256004e1d07de143fa0075c8e85a3df020b776f62b732" } }, + { url = "https://files.pythonhosted.org/packages/04/1d/9d12b0a337bab46f4769f8857f4007e3b2d639e14f9a44a0efe157696e64/rpds_py-2026.5.1-cp312-cp312-win32.whl", upload-time = 2026-05-28T11:59:29Z, size = 212734, hashes = { sha256 = "6736718bd4fc49cbcb538ba30516fdbef161522acefb739657d48b97bd864fed" } }, + { url = "https://files.pythonhosted.org/packages/c5/93/e4116f2de7f56bc7406a76033dc501811ddeb22b7f056b92d632871ebb0c/rpds_py-2026.5.1-cp312-cp312-win_amd64.whl", upload-time = 2026-05-28T11:59:31Z, size = 229045, hashes = { sha256 = "0a7d1eec967df0e9b22614a5e177622e0c89611d03727fa0cb48e45028907870" } }, + { url = "https://files.pythonhosted.org/packages/cb/53/6c3419d85eb2ec5938a37627c585b42d76a63bb731d6e42ed4b079ebf486/rpds_py-2026.5.1-cp312-cp312-win_arm64.whl", upload-time = 2026-05-28T11:59:32Z, size = 223967, hashes = { sha256 = "1841d067089e117142d79b98aa0df2f08b52f2ecc1819dd2700636c0db74a473" } }, + { url = "https://files.pythonhosted.org/packages/6c/32/14c961ad295f490eb0849ada8b79683e93a59b9de3afdd983eaf55fa6867/rpds_py-2026.5.1-cp313-cp313-macosx_10_12_x86_64.whl", upload-time = 2026-05-28T11:59:33Z, size = 352787, hashes = { sha256 = "efef4ac29c6ff495531eb17ee705b62841ecaa291b7c7077e848ea03e237164d" } }, + { url = "https://files.pythonhosted.org/packages/ca/bb/d1b85117967c11191441a7274ae616c65d93901d082c588f89a50a8da5ae/rpds_py-2026.5.1-cp313-cp313-macosx_11_0_arm64.whl", upload-time = 2026-05-28T11:59:35Z, size = 345179, hashes = { sha256 = "c39f5b67a8a2e67179ada2a954227d670fe65fa9098457f698f56ddf248709b3" } }, + { url = "https://files.pythonhosted.org/packages/7c/46/d84105f062e626a1b233f863907288a4708c2d833b8b4c6fb2764bc080c0/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-05-28T11:59:36Z, size = 376173, hashes = { sha256 = "b5c30f3f04eef4fbd362226a6f31d7c8895ca4fbb6e0b790f6890a98d8da8559" } }, + { url = "https://files.pythonhosted.org/packages/e2/ae/469d7959ce5b1201e1de135dc735b86db3b35dd0d1734f6a44246d5f061c/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2026-05-28T11:59:37Z, size = 383162, hashes = { sha256 = "277f6c82f0580848796c7ecc8a7173aa3bfb928e4ff831261c2f60a81dc270db" } }, + { url = "https://files.pythonhosted.org/packages/dc/a2/57853d31a1116a561aa072794602ad3f6341e18d70a8523f1bd5b9fc1e5a/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2026-05-28T11:59:39Z, size = 495093, hashes = { sha256 = "63c2c4c213f1a4e3f3de28ecab029dbdee976324e729c0d7a55211be72576b02" } }, + { url = "https://files.pythonhosted.org/packages/99/63/3a8eabcad9314b7daf5c65f451d2c33d989235cd8a5762186cf2c3f5a4f8/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2026-05-28T11:59:40Z, size = 389829, hashes = { sha256 = "3350ec808fb538fe71a1f94dfaa0e29c598dfad805ce49f0caec5ae3183c652b" } }, + { url = "https://files.pythonhosted.org/packages/4b/25/05678d97fc25e2622df14dc530fb82023174ecfff6733991ed0d78f167bd/rpds_py-2026.5.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-05-28T11:59:42Z, size = 374786, hashes = { sha256 = "b1b964e3ab599e718dc46c018d104b1ebc007cbc6567d827c94a687fca56d77e" } }, + { url = "https://files.pythonhosted.org/packages/88/d1/8c90b6431e80a3b91b284a5c7c8c0c4f9c006444d90477a740d6e0f9c694/rpds_py-2026.5.1-cp313-cp313-manylinux_2_31_riscv64.whl", upload-time = 2026-05-28T11:59:44Z, size = 386920, hashes = { sha256 = "19cb09fab7b7fc96b2a6e28f2e34b72a3705ff27b37edb77455316e5d3f3dc9b" } }, + { url = "https://files.pythonhosted.org/packages/ff/99/4638f672ab356682d633ee0da9255f5b67ce6efd0b85eb94ad3e255e65a5/rpds_py-2026.5.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2026-05-28T11:59:47Z, size = 405059, hashes = { sha256 = "abe76bcdba31e576cb83eeb8797aa0d882b738fef6dc65d0601fc753806a5b46" } }, + { url = "https://files.pythonhosted.org/packages/66/3f/3546524b6eb4cc2e1f363a3d638fa52f6c24faae3500c25fb488b02f1740/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", upload-time = 2026-05-28T11:59:48Z, size = 553030, hashes = { sha256 = "8bff7073db3899158fff55ebf57b113a67030af26f80a18978f9f0aa60250ddf" } }, + { url = "https://files.pythonhosted.org/packages/c6/c3/7b3388c796fcf471bd17194242d4dc1a7608567c0fa422bcc1c5e79f9c1e/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_i686.whl", upload-time = 2026-05-28T11:59:50Z, size = 618975, hashes = { sha256 = "8ba264fa49be666cd9cc56bf34ec7002fb3d27a4aee5bcb4d43d0d18feb1bb6f" } }, + { url = "https://files.pythonhosted.org/packages/61/1e/a3cb07f2795075d1d88efddae2f541359fde5f08c81ee114c29c2949c90a/rpds_py-2026.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", upload-time = 2026-05-28T11:59:51Z, size = 581178, hashes = { sha256 = "4860b603ddda0475a8885499b3729e90229d480105b42651962a5397d995fa89" } }, + { url = "https://files.pythonhosted.org/packages/a1/74/e758c03a5ef46f04c37f2651a2893db846d569ba8a7bca469d4b58939bcd/rpds_py-2026.5.1-cp313-cp313-win32.whl", upload-time = 2026-05-28T11:59:53Z, size = 212481, hashes = { sha256 = "7944270ae71383f6e2657dd7d5ce4eeb4ac2d0059a6738f0510583d462ab4842" } }, + { url = "https://files.pythonhosted.org/packages/70/ec/a2aca432db9c7359b40fa393eeeaa0d166c2f70175be956e75fa24197c44/rpds_py-2026.5.1-cp313-cp313-win_amd64.whl", upload-time = 2026-05-28T11:59:54Z, size = 228519, hashes = { sha256 = "88647f43a73c4e01be19b04ceef0c8d3a1958153604d13c773becd8016f2a0cf" } }, + { url = "https://files.pythonhosted.org/packages/29/60/a73bfdd45b096574556acf303bbd9fa9eed36ca8a818b514e2a5d5fe2b9d/rpds_py-2026.5.1-cp313-cp313-win_arm64.whl", upload-time = 2026-05-28T11:59:56Z, size = 223446, hashes = { sha256 = "453895624ecf7db7063b1004e44037522bbaef9ff6a945e59bc71662d7a03abd" } }, + { url = "https://files.pythonhosted.org/packages/18/e2/408105fd611823f00882aea810f3989a30d26b1bab8b6beb20f98c724e0e/rpds_py-2026.5.1-cp313-cp313t-macosx_10_12_x86_64.whl", upload-time = 2026-05-28T11:59:57Z, size = 355287, hashes = { sha256 = "b4e4bc98639ec915f512fde3aa7a95e0041d95d9c3cc86eea841fa63cb1e8600" } }, + { url = "https://files.pythonhosted.org/packages/8d/58/5c4a43436843c90d0f6d19f82c200c80e3843ca9fa07b237623327f6d384/rpds_py-2026.5.1-cp313-cp313t-macosx_11_0_arm64.whl", upload-time = 2026-05-28T11:59:58Z, size = 347033, hashes = { sha256 = "cacedb7a6e167680acba45ad5716e89067d225dc80da0d7040cae8c81d4572fa" } }, + { url = "https://files.pythonhosted.org/packages/fb/c2/1a71acdacaf4e259b10278fb87b039ded3cf80041bcd89dd8a3ea702ded6/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-05-28T12:00:00Z, size = 376891, hashes = { sha256 = "68700371c5d7ae1412862ddfa719090925c93ecf351c566d66f09d04b136ea00" } }, + { url = "https://files.pythonhosted.org/packages/c2/c8/535f3d9b65addd8e28aa87b83c6e526799c3717a88273db8ea795beeef7a/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2026-05-28T12:00:02Z, size = 385646, hashes = { sha256 = "296c799becfa849c779c8725494fe9ed94959ed886787df4364b058465bad7f0" } }, + { url = "https://files.pythonhosted.org/packages/1c/91/dc033f313345c354ade914dbe73cdb90b615a4409ea02430d5356794f3d8/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2026-05-28T12:00:04Z, size = 498830, hashes = { sha256 = "d3858b908218ee108d0bbfb2095ccc237648053c9bf98affad7cb079acaf1d97" } }, + { url = "https://files.pythonhosted.org/packages/27/fc/90fcbea459dbb8ddc18a2e0fd1de9412b48bc84ffff2db771cf714bacfd6/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2026-05-28T12:00:05Z, size = 392830, hashes = { sha256 = "4fb8d2e7cb2f850b169806d61d1b991738acec96500a75c30f49caf064ce7cef" } }, + { url = "https://files.pythonhosted.org/packages/b2/1d/46cd11a228c9750684a798d98f878be6f614aa762438da7378f035e79e35/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-05-28T12:00:07Z, size = 379613, hashes = { sha256 = "27b74c10ed6a8f190f4287f53bcfea348b92a84a9c9f70d30183d1e6172d580d" } }, + { url = "https://files.pythonhosted.org/packages/24/4a/d9b0c6af3a1de03eb93741bbe8be2bdce84d8fda8224f3005451d86df389/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_31_riscv64.whl", upload-time = 2026-05-28T12:00:09Z, size = 388183, hashes = { sha256 = "b9a6528956191c48c52294a592dbd4a8386d7048bdb25c0efcb6b966466c6d83" } }, + { url = "https://files.pythonhosted.org/packages/c5/b4/db7aaabdda6d020afc87d981bcc2f57a434c7dec60ecfc2ab3dd50b20351/rpds_py-2026.5.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2026-05-28T12:00:10Z, size = 408578, hashes = { sha256 = "af03e34e860047bc7a352b842856fcf78798fbb81132cc98bd2f907ab4eb9cd2" } }, + { url = "https://files.pythonhosted.org/packages/08/d6/070f6a41cbb343e2ac4171859bf3f3623e0ab002f72619d6d505313ec2de/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_aarch64.whl", upload-time = 2026-05-28T12:00:12Z, size = 553573, hashes = { sha256 = "fea6e836d10abbe191d557d33bd58bd5987725fe63aa1eefe557d230209855bd" } }, + { url = "https://files.pythonhosted.org/packages/75/ab/1a71ea3589c4345dac0a0518f0e6a031cb42689277851b683c46d27463a5/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_i686.whl", upload-time = 2026-05-28T12:00:14Z, size = 620861, hashes = { sha256 = "fc0c0f878ea770a0a8a462456c5ad36fc9fe6358e6b76fdadc7f17575e0b8bf1" } }, + { url = "https://files.pythonhosted.org/packages/8a/22/9bf80a56069c0c443fcfefac639a86a744550a2898817a6dfd3e26654924/rpds_py-2026.5.1-cp313-cp313t-musllinux_1_2_x86_64.whl", upload-time = 2026-05-28T12:00:15Z, size = 585633, hashes = { sha256 = "e0b360f316d966b048b085857630b3cc51f3db2f07b06f440eac8f695374d1e3" } }, + { url = "https://files.pythonhosted.org/packages/da/68/3b2c0a75c9e04125696f84ebdbbf304acf5a40b58ba4481cdb98a922c3ba/rpds_py-2026.5.1-cp313-cp313t-win32.whl", upload-time = 2026-05-28T12:00:17Z, size = 210074, hashes = { sha256 = "a2999883eedf72fdfb7520b92c7d4ec2572a71ff40239377aa604cc529eecafc" } }, + { url = "https://files.pythonhosted.org/packages/e7/8b/609157d5a25d37d4f29f92840ba531f416907c34ae5c5739dd21fc2bef98/rpds_py-2026.5.1-cp313-cp313t-win_amd64.whl", upload-time = 2026-05-28T12:00:18Z, size = 228635, hashes = { sha256 = "e07be2a9d7122bd6e82dea89814ef8dc893feb1aae97fec1630f3263bbb30e55" } }, + { url = "https://files.pythonhosted.org/packages/d4/6f/19c1918a4b590d8de87e712e4abe4b3875771eff60216fb6153cf6665c68/rpds_py-2026.5.1-cp314-cp314-macosx_10_12_x86_64.whl", upload-time = 2026-05-28T12:00:20Z, size = 349756, hashes = { sha256 = "1f2c391c3059798093b65df23aca2cac150460ae9c630d99dec83d703d9485b9" } }, + { url = "https://files.pythonhosted.org/packages/e5/60/a06fe7da34eca79dacbf958a2ba0c6eea85bc2b29de20080bf40f72f66fa/rpds_py-2026.5.1-cp314-cp314-macosx_11_0_arm64.whl", upload-time = 2026-05-28T12:00:21Z, size = 343831, hashes = { sha256 = "413b424f7c4ee65ab5e5be91f5731be0f8b41a1ee2b12dfe810d716312e95a78" } }, + { url = "https://files.pythonhosted.org/packages/bf/ec/b2333b97b90e2a6ef6ca8ad386ee284968e74bcfe113b3f1a8d9036429a9/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-05-28T12:00:23Z, size = 375127, hashes = { sha256 = "2c595a1d9255dce0599e13130d1440ab2506654f2b50294226ee06402f8fef63" } }, + { url = "https://files.pythonhosted.org/packages/14/7f/e00aae54067f2b488c4637961d5f58204d470795fc791085fa3f15060d2e/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2026-05-28T12:00:24Z, size = 379034, hashes = { sha256 = "1c27c5f6102eac8c03e7595a00827a53b271ba40a53b59ff8709170e0855ea4a" } }, + { url = "https://files.pythonhosted.org/packages/be/cc/423999bbb8ae8dc93c77fc1d5e984ade5eb89d237d3bb884ccfa72ae2890/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2026-05-28T12:00:26Z, size = 490823, hashes = { sha256 = "6c7fcf61d44cacecaf3aea542b0e053db77972a4573e7ceda16fb2b399161195" } }, + { url = "https://files.pythonhosted.org/packages/0f/aa/c671bf660f12e68d3c52ff86c7066ed1372df5a0f4f2ff584e419b8207e7/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2026-05-28T12:00:28Z, size = 388144, hashes = { sha256 = "2c817a189d4ee14290420e5ff051e4dd6baa13f3edf84685071dee07a6d538ee" } }, + { url = "https://files.pythonhosted.org/packages/19/c8/d63bb75b68afe77b229e3021c6031bcaf01da5db5b0e69d0d10f9ba679a7/rpds_py-2026.5.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-05-28T12:00:30Z, size = 371959, hashes = { sha256 = "21846aac0ed2e0589f38c12dc44e77bb64e494b771eadbcf169cba00566ba7ba" } }, + { url = "https://files.pythonhosted.org/packages/82/35/c51122014d8274ff37dc606d60049c3db7d83da02b5b282511e5a906a9a6/rpds_py-2026.5.1-cp314-cp314-manylinux_2_31_riscv64.whl", upload-time = 2026-05-28T12:00:31Z, size = 383558, hashes = { sha256 = "b317c87a13f769a4e787819bd508aaa5d69aa09b0880de9af6d3a8a54571cdec" } }, + { url = "https://files.pythonhosted.org/packages/e3/f9/2790cb99c136a5363acdeacf5c27c56f3de0d4118a1f48fca83404c99c89/rpds_py-2026.5.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2026-05-28T12:00:33Z, size = 402789, hashes = { sha256 = "ce87129d9f2c14fa6c4a8601fb80eb4488c80d38a20cd13758ef11123e14995d" } }, + { url = "https://files.pythonhosted.org/packages/e5/1b/e4fb584f8c75d35c38150ff6a332cda949e6f97acba1f4fd123b14ab56fe/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", upload-time = 2026-05-28T12:00:34Z, size = 551405, hashes = { sha256 = "9cdddb6c1207d284d94fd1530adf57fbd797fe7c4b8704ba85f49414f2557e7d" } }, + { url = "https://files.pythonhosted.org/packages/d8/f7/a6731b4216cb3793ea1af5391da240f5683dacc0d13e034fe5fc3503f240/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_i686.whl", upload-time = 2026-05-28T12:00:36Z, size = 616975, hashes = { sha256 = "4e237e139f94d3c036fd28eb9f564c99055476ff4ff05cd42be55ce349b5aa02" } }, + { url = "https://files.pythonhosted.org/packages/2c/ea/2e051a81d95d8e63f4b35a1c463a87e8766bc3d083c067c5dfb6bf220747/rpds_py-2026.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", upload-time = 2026-05-28T12:00:37Z, size = 578701, hashes = { sha256 = "ed0954b524873214369184a9c82b0eaa45a3fbb9a798cd95b17e0d98499e7ea0" } }, + { url = "https://files.pythonhosted.org/packages/65/56/b5f6fdb2083e32bca8a8993d89e70db114b4756c9e2c38421328126689d2/rpds_py-2026.5.1-cp314-cp314-win32.whl", upload-time = 2026-05-28T12:00:39Z, size = 209806, hashes = { sha256 = "2d88621d6a7d4dfa633d21abe90f280bb205274e16b1d1e61c6ad4640b2453b7" } }, + { url = "https://files.pythonhosted.org/packages/fb/80/65a5aa96c155e611d1ed844e4e1f57f3e36b021f396d9f8585d756e6b90d/rpds_py-2026.5.1-cp314-cp314-win_amd64.whl", upload-time = 2026-05-28T12:00:40Z, size = 225985, hashes = { sha256 = "cef8ac28d26f4dda3533060c20fbf80a325458fa9fd23ea72a73cdfa8e978838" } }, + { url = "https://files.pythonhosted.org/packages/27/7c/ad185212e87b05f196daef92bc5f3caf07298eb47c295b5585c3dd3093ac/rpds_py-2026.5.1-cp314-cp314-win_arm64.whl", upload-time = 2026-05-28T12:00:43Z, size = 221219, hashes = { sha256 = "eaaea962c68cdc68d4a533ba985ab8e9484277910bbfaa2ab3ef7732667bfed8" } }, + { url = "https://files.pythonhosted.org/packages/23/58/e14ae18759020334646b031e708ab4158d653a938822bfb7b95ef2e93aa3/rpds_py-2026.5.1-cp314-cp314t-macosx_10_12_x86_64.whl", upload-time = 2026-05-28T12:00:44Z, size = 352148, hashes = { sha256 = "21942f52dbbd5f8758bf021213d28bd45c39e873e65e2407faf5f1846f5761ad" } }, + { url = "https://files.pythonhosted.org/packages/31/9b/5f4a1e2f960bca3ac5d052b139dd31eed97b259f9d909173821760d542e8/rpds_py-2026.5.1-cp314-cp314t-macosx_11_0_arm64.whl", upload-time = 2026-05-28T12:00:46Z, size = 345196, hashes = { sha256 = "f414556f6e3958300ff941e40c9f97e3dc9774ddd1b3434c475d73dd354bbed3" } }, + { url = "https://files.pythonhosted.org/packages/1a/71/1d9574d6a2fa20ab60eaa55c7467f5aa20cbc770f341a05f09c0876f59e2/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-05-28T12:00:47Z, size = 374981, hashes = { sha256 = "ef1013a8625c74043210190b246f5b1551e09757c1f356c6e4160ef96c5bc081" } }, + { url = "https://files.pythonhosted.org/packages/0c/9a/37e99f4915a80aa71670263c1267f7ae0af95f53a3f61e6c3bdc016d4515/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2026-05-28T12:00:49Z, size = 379961, hashes = { sha256 = "cc68e231a77a5f0d774ae278a1f8e55c0456501820847c1e4efb3829f3441df6" } }, + { url = "https://files.pythonhosted.org/packages/a8/ff/6e73f74b89d2e0715e0fc86b7dde893f9a61ae2f9b256ff3bdfe41ac4e94/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2026-05-28T12:00:51Z, size = 495965, hashes = { sha256 = "9baffb505aff33acc69b422a19f77806680f3c8632227d79f48de8a810d1c2c5" } }, + { url = "https://files.pythonhosted.org/packages/ea/e0/425faba25f59d74d4638b267f7c7a80e8649d2ef4db10a19b0c4a71e6e6f/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2026-05-28T12:00:52Z, size = 389526, hashes = { sha256 = "b8d2f912928d426e8cfa396f7f3f8d29a59e6689c86dcca3c420730c1096322b" } }, + { url = "https://files.pythonhosted.org/packages/c6/76/7a41960e3fddae47fab43a28684d5da981401dffd88253de0944148654cb/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-05-28T12:00:54Z, size = 376190, hashes = { sha256 = "90f628283be835db980c941767d41c9a27b5239e54ba0a9c1335247e82406964" } }, + { url = "https://files.pythonhosted.org/packages/27/60/5f38dc70824fc6951b51d35377e577a3a3a4c81a6769cc5a2de25ebe0ad1/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_31_riscv64.whl", upload-time = 2026-05-28T12:00:55Z, size = 383921, hashes = { sha256 = "1ebb2f0ab7e16132995a72de805170e0203df0c3dd22e1ef1cd1fdd90bd7a131" } }, + { url = "https://files.pythonhosted.org/packages/60/1a/d60a38caa1505f4b9483c3fbbde12c94e1079154f4f401a6da96f7e77621/rpds_py-2026.5.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2026-05-28T12:00:57Z, size = 404766, hashes = { sha256 = "f3df3d16ded76f1f8c9cdebd0e1ea55fdf4c23b812de189814da7cf229c22a81" } }, + { url = "https://files.pythonhosted.org/packages/87/ff/602fd3f174d6425f0bce05ad0dfbec0e96b38d0f7d08a79af5aa20083885/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", upload-time = 2026-05-28T12:00:58Z, size = 551343, hashes = { sha256 = "9af8905b8f854990e40d5206aa5ac58d9b0fe0b7f351ff2bb086c20f6c8c6a47" } }, + { url = "https://files.pythonhosted.org/packages/b8/c1/1be13327acdbead3eca1fde03b6a34dbb011f1e864e217f0d32cc1779a7f/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_i686.whl", upload-time = 2026-05-28T12:01:00Z, size = 618502, hashes = { sha256 = "036a36a87fb1cd3b214d11c4b3c4f7d2ddad933625dca1c900b56a057c07740a" } }, + { url = "https://files.pythonhosted.org/packages/f3/d7/afb49b49d7f2be8b7ba1a9f0977fa5168003437b93086726f066544e8351/rpds_py-2026.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", upload-time = 2026-05-28T12:01:02Z, size = 581916, hashes = { sha256 = "62ae3853454fe9ef283a03c96c2d835d39e84b14643a9d62c82ef0fb87d702ca" } }, + { url = "https://files.pythonhosted.org/packages/25/d1/dbef8c1f8a10f07beb62b5f054e20099fd9924b3ec001b8f0b6ac7813a85/rpds_py-2026.5.1-cp314-cp314t-win32.whl", upload-time = 2026-05-28T12:01:03Z, size = 207855, hashes = { sha256 = "6c3d771a46ec18b12af06ce36243a9a80b07a5d0515236332d90863ca8bb326a" } }, + { url = "https://files.pythonhosted.org/packages/2a/72/bfa4e61ab8e7dc1c8adf397e05e6cbdd4239357bd72b248d3de662f23915/rpds_py-2026.5.1-cp314-cp314t-win_amd64.whl", upload-time = 2026-05-28T12:01:05Z, size = 225422, hashes = { sha256 = "c93c629be4636cf54337bd5f06c104d55e42ced54d681f6fe21ae510a65116f6" } }, + { url = "https://files.pythonhosted.org/packages/27/3a/7b5da92b640f67b6717ccafc83cdd06bfa7ff2395c3685c68922bb54d703/rpds_py-2026.5.1-cp315-cp315-macosx_10_12_x86_64.whl", upload-time = 2026-05-28T12:01:06Z, size = 349576, hashes = { sha256 = "3574b55c604b8f75dacb007136508bbc0db406e626301778096a133327e7f2fb" } }, + { url = "https://files.pythonhosted.org/packages/d7/8a/2aafd7ad355a1bd48ca76e2262b74b15e6432b5a1efe150efd4d779cd55d/rpds_py-2026.5.1-cp315-cp315-macosx_11_0_arm64.whl", upload-time = 2026-05-28T12:01:08Z, size = 343640, hashes = { sha256 = "94068eb3ae6d43f5a786b7db96a406a34e6d5c24489feef32fd6e8946ea7b291" } }, + { url = "https://files.pythonhosted.org/packages/f7/7d/6c9523c1abbe840a1b7fba3c516d48e1d3487cc80fea4366c4071cf56784/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-05-28T12:01:09Z, size = 375322, hashes = { sha256 = "f3a5b10e8ce894825f380a8f1b6444cf73c294dfea62afbb2d13e3a9e630cec1" } }, + { url = "https://files.pythonhosted.org/packages/5a/5d/0b7b03fb1dc509321f01de3149784ab773e34c8573022029af8076afcb9c/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2026-05-28T12:01:11Z, size = 379066, hashes = { sha256 = "fc09f82e63d4bcd58149572f857a431bae851dc747e313c3b5bdf7abb907fda8" } }, + { url = "https://files.pythonhosted.org/packages/d7/e2/8ef6012999ebf1cb1c22f876d9ce5e63d960fd4631d2af3202d3f480aa25/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2026-05-28T12:01:13Z, size = 494586, hashes = { sha256 = "e10464d17df3b582745c25cec695cb9558bca2cb6ddb631aee1787fc72c767b2" } }, + { url = "https://files.pythonhosted.org/packages/80/af/1eeb029bec67582c226b7809172207cd005073af4ebd906e65ff494f4983/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2026-05-28T12:01:14Z, size = 388415, hashes = { sha256 = "ba05adbf15d994c38ec0b7ab32e858e5110c21e9009a00a86545fd220f84e038" } }, + { url = "https://files.pythonhosted.org/packages/18/23/ffbe10711c4d766c1cab0557d6906c074f795814863c67b351355d29354a/rpds_py-2026.5.1-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-05-28T12:01:16Z, size = 372427, hashes = { sha256 = "77c004fdc7b891967106f78ddfd7b076bfe6813c6139c6fff6aed3bcaa960b26" } }, + { url = "https://files.pythonhosted.org/packages/bd/3a/30ba4a6ad457e5b070c18d742a33fb77d8d922b565cc881f8a5313d63bfe/rpds_py-2026.5.1-cp315-cp315-manylinux_2_31_riscv64.whl", upload-time = 2026-05-28T12:01:17Z, size = 383615, hashes = { sha256 = "83bcf894486c9d78dd290d3c0124ff6dd8875d3025e2090a8ec49fcc37c55fdd" } }, + { url = "https://files.pythonhosted.org/packages/d3/69/62e242b53ce39c0814bd24e1a6e6eba6c92be716277745f317f9540a2e7b/rpds_py-2026.5.1-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2026-05-28T12:01:19Z, size = 402786, hashes = { sha256 = "c3df104083952a0e0c6f10de33e440eabe98fb6317d23e1a58c68f6df08d01b9" } }, + { url = "https://files.pythonhosted.org/packages/38/c1/a770b9c186928a1ed0f7e6d7ae50e7f3950ed23e3f9e366dbc8e38cb55de/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", upload-time = 2026-05-28T12:01:21Z, size = 551583, hashes = { sha256 = "980450826cf22e133c57e0835070bdd0dd3f73b9b708c3ce223def2cb9469e14" } }, + { url = "https://files.pythonhosted.org/packages/21/7c/68e8579b95375b70d2a963103c42e705856cdb98569258bd807f4423891c/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_i686.whl", upload-time = 2026-05-28T12:01:22Z, size = 616941, hashes = { sha256 = "205dde846f24332ab0c1188699a043b8d165b79bb84529ce272c45048ff6be01" } }, + { url = "https://files.pythonhosted.org/packages/70/a1/a6135aed5730ff03ab957182259987ac11e55fb392a28dc6f0592048a280/rpds_py-2026.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", upload-time = 2026-05-28T12:01:24Z, size = 578349, hashes = { sha256 = "3966b82dd563176396df030f3dd52a6e54cb69b718e95e78bd555ed3d1e0185d" } }, + { url = "https://files.pythonhosted.org/packages/09/6e/f24201a76a84e6c49d0bdfdfcb735210e21701e9b21c5bfc0ba497dd62f6/rpds_py-2026.5.1-cp315-cp315-win32.whl", upload-time = 2026-05-28T12:01:25Z, size = 209922, hashes = { sha256 = "7818f8d0a415be74d2be3590b0a1c1f463a642f4d0217e7d10602dceef5b79aa" } }, + { url = "https://files.pythonhosted.org/packages/9e/e4/966bc240bb0485fc265278f6de44d05834bf0b3618886e0b22e33d54c49a/rpds_py-2026.5.1-cp315-cp315-win_amd64.whl", upload-time = 2026-05-28T12:01:27Z, size = 226003, hashes = { sha256 = "b3cc20c0d800af78fd0fac68086e28c1856cec51ea528bb81ea851aa40d39325" } }, + { url = "https://files.pythonhosted.org/packages/5c/5c/a15a59269cd5e74472734516c73795c15eccfc841b3d4b0228c3f53f19d0/rpds_py-2026.5.1-cp315-cp315-win_arm64.whl", upload-time = 2026-05-28T12:01:28Z, size = 221245, hashes = { sha256 = "3609e9939a8a76cd904cf98a3f1f13b5dc7e150adeaee89e0ea09652ea213e16" } }, + { url = "https://files.pythonhosted.org/packages/e0/22/135ce03804e179a71ceb13be095deda4a279bc88f7a6b8fa161c5ad44e12/rpds_py-2026.5.1-cp315-cp315t-macosx_10_12_x86_64.whl", upload-time = 2026-05-28T12:01:30Z, size = 352015, hashes = { sha256 = "5d333a7127d4b307601ac37792bee01bb95c867cbfacf21b6375b804d6bbd723" } }, + { url = "https://files.pythonhosted.org/packages/3b/5f/f1f6d2652eb9d848f6eb369d8db83a2da6249bb49ad2c2a48f45d54538d3/rpds_py-2026.5.1-cp315-cp315t-macosx_11_0_arm64.whl", upload-time = 2026-05-28T12:01:31Z, size = 345016, hashes = { sha256 = "b5f077b44a4f7808520f66dae234988d867deb9aed9be5da057ce9ba831b2a41" } }, + { url = "https://files.pythonhosted.org/packages/88/66/b74182775691ea2290c99e52ac8d5db844e56fbec90ce421f107658c8314/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-05-28T12:01:33Z, size = 374775, hashes = { sha256 = "55d8f9b7b78c9538fc9e04e82ec0e888ff0c3cffcfad152c77e57cd09351a98a" } }, + { url = "https://files.pythonhosted.org/packages/ff/8f/15e5a61d9f0a43902d36561d4f07cae6ae9f4716be825159fd72717f33af/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2026-05-28T12:01:34Z, size = 380270, hashes = { sha256 = "e3a8ae58895ac107ed934a6bf51e5846f95c53b9b940c2c6d310838fd5846358" } }, + { url = "https://files.pythonhosted.org/packages/02/c3/f859b12763a80540cdf2af0f15b19904cf756a71d7bdd3f82ff3e5b1bbf9/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2026-05-28T12:01:36Z, size = 495285, hashes = { sha256 = "0957cf3c2b8632ec7aaebffebea8005b353cc2a237b6e2ae3c2cac0820704cfb" } }, + { url = "https://files.pythonhosted.org/packages/1c/c7/ff27c2ac8411d30b03b1829fd88cae8dad1a4d0da48dd25e57c4038042e6/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2026-05-28T12:01:37Z, size = 389581, hashes = { sha256 = "c396c1304de421050b3681ea70f371874b54d41b0151e96109758144c231e30b" } }, + { url = "https://files.pythonhosted.org/packages/6e/67/fe92ee32a6cc05c77228a2f8b1762e7124f386ec20ff83d0757b762d58d0/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-05-28T12:01:39Z, size = 376041, hashes = { sha256 = "aad1bff7f666b9598e573815affd666aac6a13a585dde336f843e33350c7fadc" } }, + { url = "https://files.pythonhosted.org/packages/f8/91/b4d6685c27aba55bd82f25b278be8237038117d05f9659a6213ad3408130/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_31_riscv64.whl", upload-time = 2026-05-28T12:01:41Z, size = 383946, hashes = { sha256 = "656a042550878f12d45752452d47094b7cfe5ad1e9d7b87b5a22ad3ae5ff8015" } }, + { url = "https://files.pythonhosted.org/packages/bd/79/2c1d832a53c8e0f8e98fc970ec257b950fecd4f62be2ab7182b500a0cbc8/rpds_py-2026.5.1-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2026-05-28T12:01:43Z, size = 405526, hashes = { sha256 = "73c4bd4f70294737b5206a3e8e30ccadbf8a60301831c8ea23eec5dbeea1ecfa" } }, + { url = "https://files.pythonhosted.org/packages/78/c4/c98117b03c6a8581ab2c2dfccfe9a5ad82bd8128a3c28b46a6ad2d97c393/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", upload-time = 2026-05-28T12:01:44Z, size = 551165, hashes = { sha256 = "43bca78665423cabae77146f2fe7ce55272b6c8d55d82cca83effd42c7e13972" } }, + { url = "https://files.pythonhosted.org/packages/3b/c1/bc479ca069200af730881b1bd525e3114b2b391a351509fcb1b772f28086/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_i686.whl", upload-time = 2026-05-28T12:01:46Z, size = 618778, hashes = { sha256 = "42d0f20e85e549c870749d0e247f0c10d318a45b7e9676d575d2dcb04a1b2e66" } }, + { url = "https://files.pythonhosted.org/packages/77/65/38ab2f90df44c2febfb63cc10ced40763d9b4bc94d173e734528663fe7f5/rpds_py-2026.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", upload-time = 2026-05-28T12:01:48Z, size = 581839, hashes = { sha256 = "b1be5c35683684d5331b93600c210e8367c254683d8a6df6bd21bd2da3a334fb" } }, + { url = "https://files.pythonhosted.org/packages/15/2d/ce1f605fe036aadd460e5822e578c6c7ec3a860936cca37d6e0f299daa77/rpds_py-2026.5.1-cp315-cp315t-win32.whl", upload-time = 2026-05-28T12:01:49Z, size = 207866, hashes = { sha256 = "75808f6c38ce7749bb68cc2770161aae5045e6c6f6781a9782e74b93304399df" } }, + { url = "https://files.pythonhosted.org/packages/79/cb/966040123eb102371559746908ef2c9471f4d43e17ec9a645a2258dab64b/rpds_py-2026.5.1-cp315-cp315t-win_amd64.whl", upload-time = 2026-05-28T12:01:51Z, size = 225441, hashes = { sha256 = "90bd6630002a1c7f09e7843dd79f0d24f3d2897cc25a753480917865d14f15b3" } }, + { url = "https://files.pythonhosted.org/packages/42/56/3fe0fb34820ff667be791b3a3c22b85e8bcba54e9c832f47438c191fa7be/rpds_py-2026.5.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", upload-time = 2026-05-28T12:01:53Z, size = 357151, hashes = { sha256 = "edf2765d84e42447f112ad877af8fe1db0089aaec5b28e88d6eab45e7fe99cea" } }, + { url = "https://files.pythonhosted.org/packages/8b/f2/3eb9ccdb9f143b8c9b003978898cb497f942a324c077401e6b8834238e63/rpds_py-2026.5.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", upload-time = 2026-05-28T12:01:54Z, size = 350195, hashes = { sha256 = "ad3773236e95f7f33991eb125224b7da66f206504d032a253a02da7e134519fb" } }, + { url = "https://files.pythonhosted.org/packages/a7/24/dbda232bc4f3ed732120692ab0d2c8402cb020516556d8bee622dcef2413/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", upload-time = 2026-05-28T12:01:56Z, size = 381850, hashes = { sha256 = "a04df86b3f0fade39ec8fd0e0aab089b1da9fbd2b48df778a57ef96f5e7d38df" } }, + { url = "https://files.pythonhosted.org/packages/40/30/32e769839a358f78810c234f160f2cc21d1e4e47e1c0e0e0d535be5a0219/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", upload-time = 2026-05-28T12:01:58Z, size = 387899, hashes = { sha256 = "6142dbd80c4df62a5d899f0d616d417f84e0bc8d32526c8e5589019d75d028a7" } }, + { url = "https://files.pythonhosted.org/packages/ab/86/ec84d243aadb3b34b71dd26a010d0930b2d284ff5fc9a69fec53810ee6fd/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", upload-time = 2026-05-28T12:01:59Z, size = 501618, hashes = { sha256 = "0b35217adefe87f2fe4db7e9766cabe84744bfe9616d9667be18988928c7f2dc" } }, + { url = "https://files.pythonhosted.org/packages/74/25/b60e52686bbff777a64f9e4f4d3dd57980dc846913777177a2c92e4937aa/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", upload-time = 2026-05-28T12:02:01Z, size = 394003, hashes = { sha256 = "b95d5e11fc712b752081183a55a244c03cd00570489edd7014d8899f8ceb8162" } }, + { url = "https://files.pythonhosted.org/packages/9b/c7/b3a6a588cc2219510ef3f42e207483a93950bedd1e3a0fd4015c95cff9e5/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", upload-time = 2026-05-28T12:02:03Z, size = 379778, hashes = { sha256 = "141c9498daf2ace9eda35d2b0e376f9ea8b058d84f2aef4f96fccfd449a2f251" } }, + { url = "https://files.pythonhosted.org/packages/31/00/c7dba3fc8a3da8cb3f6db1eb3386be4d79c2e97c6890d20eb9ac66ae8c43/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", upload-time = 2026-05-28T12:02:04Z, size = 392359, hashes = { sha256 = "6f249f8b860a200ad35193af961183ebe9132710484e6f6ce0cf89fd83c63a9a" } }, + { url = "https://files.pythonhosted.org/packages/93/dd/472ba494c70753f93745992c99855bee0636daf74e6984e5e003f150316f/rpds_py-2026.5.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", upload-time = 2026-05-28T12:02:06Z, size = 412820, hashes = { sha256 = "e4abbf391a70be864920858bf360f4fb380577c9a0f732438a1996726e2c195b" } }, + { url = "https://files.pythonhosted.org/packages/1d/6f/93831a3bfe789542ed0c1d0d74b78b440f055d6dc3ea4640eba2d95e6e23/rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", upload-time = 2026-05-28T12:02:08Z, size = 557243, hashes = { sha256 = "c74005a7bb87752acf351c93897ec63ad77a07a0da7ecad9c050e32e7286ba34" } }, + { url = "https://files.pythonhosted.org/packages/1f/ff/0b3d604614ffc77522c6b288fdbce68957eb583da1002aa65ba38ac0ee40/rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_i686.whl", upload-time = 2026-05-28T12:02:09Z, size = 623541, hashes = { sha256 = "8213afbe8a3a906fb9acb2014423fe3359ee783d0bf90995f70623a3217bfa6c" } }, + { url = "https://files.pythonhosted.org/packages/ea/ea/e7b0251441da9adfeaebcf29601d10f2a1455fcf0772fae9e7e19032bd96/rpds_py-2026.5.1-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", upload-time = 2026-05-28T12:02:11Z, size = 586326, hashes = { sha256 = "8c43a8a973270fd173bf48cdf80bbe66312421cba68d40845034f174f2389049" } }, +] + [[packages]] name = "ruff" version = "0.15.15" diff --git a/pyproject.toml b/pyproject.toml index 3772c80ff..e7d61a730 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -31,6 +31,7 @@ classifiers = [ ] dependencies = [ + "ada-url>=4,<5", # The CA bundle every https call verifies against (comfy_cli.http.trust_store). # Declared rather than inherited from `requests`: a distribution can ship a # Python whose OpenSSL has no compiled-in trust path at all. Floored at the @@ -40,6 +41,7 @@ dependencies = [ "cookiecutter", "gitpython>=3.1.50", "httpx", + "jsonschema>=4.18", # mixpanel 5.x pulls in pydantic/pydantic-core; the compiled pydantic_core DLL # gets loaded by `comfy install` and then cannot be replaced when ComfyUI's # requirements resolve a different version on Windows (os error 5). 4.x has no @@ -70,7 +72,7 @@ dependencies = [ "blake3>=1.0.9", ] -optional-dependencies.dev = [ "jsonschema", "pre-commit", "pytest", "pytest-cov", "ruff==0.15.15", "typer>=0.24" ] +optional-dependencies.dev = [ "pre-commit", "pytest", "pytest-cov", "ruff==0.15.15", "typer>=0.24" ] optional-dependencies.preview = [ "term-image>=0.7,<0.8" ] urls.Repository = "https://github.com/Comfy-Org/comfy-cli.git" scripts.comfy = "comfy_cli.__main__:main" @@ -85,7 +87,7 @@ include = [ "comfy_cli*" ] # Bundled skills: subdirs of comfy_cli.skills named after each skill (kept in # sync with BUNDLED_SKILLS). Hyphenated dirs aren't importable packages, so # they're plain data dirs matched by glob from the parent package. -"comfy_cli.skills" = [ "*/SKILL.md" ] +"comfy_cli.skills" = [ "*/SKILL.md", "*/PROMPT-TEMPLATE.md" ] "comfy_cli.schemas" = [ "*.json", "*.md" ] "comfy_cli.cql.data" = [ "*.yaml", "*.json" ] diff --git a/scripts/export_cloud_workflow_schemas.mjs b/scripts/export_cloud_workflow_schemas.mjs new file mode 100644 index 000000000..34d5f37aa --- /dev/null +++ b/scripts/export_cloud_workflow_schemas.mjs @@ -0,0 +1,17 @@ +// Run from the matching frontend checkout with its locked dependencies: +// FRONTEND_ROOT="$PWD" node --import tsx /path/to/cli/scripts/export_cloud_workflow_schemas.mjs /output/schema-dir +import fs from 'node:fs/promises' +import path from 'node:path' +import { createRequire } from 'node:module' +import { pathToFileURL } from 'node:url' + +const frontend = process.env.FRONTEND_ROOT +if (!frontend || !process.argv[2]) throw new Error('FRONTEND_ROOT and output directory are required') +const require = createRequire(path.join(frontend, 'package.json')) +const { z } = require('zod') +const source = await import(pathToFileURL(path.join(frontend, 'src/platform/workflow/validation/schemas/workflowSchema.ts'))) +await fs.mkdir(process.argv[2], { recursive: true }) +for (const [version, schema] of [['0_4', source.zComfyWorkflow], ['1_0', source.zComfyWorkflow1]]) { + const generated = z.toJSONSchema(schema, { io: 'input', unrepresentable: 'any' }) + await fs.writeFile(path.join(process.argv[2], `cloud_workflow_${version}.json`), JSON.stringify(generated, null, 2)) +} diff --git a/tests/comfy_cli/agent/test_command.py b/tests/comfy_cli/agent/test_command.py index e5b44757c..83f32306e 100644 --- a/tests/comfy_cli/agent/test_command.py +++ b/tests/comfy_cli/agent/test_command.py @@ -1131,3 +1131,11 @@ def test_permissions_offers_no_cli_grant_it_would_then_refuse(tmp_path: Path, mo assert data["grant"] == {}, "`allow` would refuse, so no command is offered" assert "agent panel" in data["answer_in"] _validate(data) + + +@pytest.mark.parametrize("runner", ["/site-packages/pytest/__main__.py", "/tools/other/__main__.py"]) +def test_embedding_main_module_does_not_change_user_cli_permission_hints(monkeypatch, runner): + from comfy_cli.agent.command import _cli_invocation + + monkeypatch.setattr(sys, "argv", [runner]) + assert _cli_invocation() == "comfy" diff --git a/tests/comfy_cli/auth/test_oauth.py b/tests/comfy_cli/auth/test_oauth.py index c7064763b..bfdb821fb 100644 --- a/tests/comfy_cli/auth/test_oauth.py +++ b/tests/comfy_cli/auth/test_oauth.py @@ -703,7 +703,8 @@ def worker(): # (b) Double-check: if a peer already rotated the token between our pre-lock # read and the post-lock re-read, we adopt it and do NOT refresh again. - def test_double_check_skips_refresh_when_peer_already_rotated(self, persisted, monkeypatch): + @pytest.mark.parametrize("peer_expiry", [None, 1, 4102444800], ids=["unknown-expiry", "expired", "known-unexpired"]) + def test_double_check_skips_refresh_when_peer_already_rotated(self, persisted, monkeypatch, peer_expiry): self._persist_expired(refresh_token="RT0") # Simulate a peer that rotated RT0 → RT1 while we waited for the lock: @@ -716,7 +717,7 @@ def test_double_check_skips_refresh_when_peer_already_rotated(self, persisted, m access_token="PEER_NEW", refresh_token="RT1", token_type="Bearer", - expires_at=int(time.time()) + 3600, + expires_at=peer_expiry, saved_at="2026-01-01T00:00:02+00:00", ) reads = [self._stale(), fresh_peer] @@ -727,6 +728,65 @@ def test_double_check_skips_refresh_when_peer_already_rotated(self, persisted, m assert result.refresh_token == "RT1" assert result.access_token == "PEER_NEW" + def test_a_rejected_older_token_does_not_adopt_an_already_expired_peer_token(self, persisted, monkeypatch): + from comfy_cli.credentials import refreshed_access_token + + self._persist_expired() + monkeypatch.setattr(oauth, "refresh_tokens", lambda **_: self._token_set(access="NEW", refresh="RT1")) + + assert refreshed_access_token("BEFORE_OLD") == "NEW" + assert auth_store.get_cloud_session().refresh_token == "RT1" + + @pytest.mark.parametrize( + ("peer_access", "peer_expiry"), + [("PEER_UNUSABLE", None), ("PEER_UNUSABLE", 1), ("REJECTED_OLDER", 4102444800)], + ids=["unknown-expiry", "expired", "same-rejected-token"], + ) + @pytest.mark.parametrize("peer_timing", ["already-stored", "after-first-read"]) + def test_a_peer_token_that_cannot_be_retried_uses_its_available_refresh( + self, persisted, monkeypatch, peer_timing, peer_access, peer_expiry + ): + from comfy_cli.credentials import refreshed_access_token + + def save(access, refresh, expiry): + return auth_store.save_cloud_session( + base_url="https://c", + resource="https://c/api", + client_id="cid", + scope="s", + access_token=access, + refresh_token=refresh, + token_type="Bearer", + expires_at=expiry, + ) + + save("REJECTED_OLDER", "RT0", 4102444800) + if peer_timing == "already-stored": + save(peer_access, "RT1", peer_expiry) + else: + real_read = auth_store.get_cloud_session + + def read_then_peer_rotates(): + session = real_read() + if session.refresh_token == "RT0": + save(peer_access, "RT1", peer_expiry) + return session + + monkeypatch.setattr(auth_store, "get_cloud_session", read_then_peer_rotates) + refreshes = [] + + def refresh(**kwargs): + refreshes.append(kwargs["refresh_token"]) + return self._token_set(access="NEW", refresh="RT2") + + monkeypatch.setattr(oauth, "refresh_tokens", refresh) + + assert refreshed_access_token("REJECTED_OLDER") == "NEW" + stored = auth_store.get_cloud_session() + assert stored.access_token == "NEW" + assert stored.refresh_token == "RT2" + assert refreshes == ["RT1"] + def _stale(self) -> auth_store.CloudSession: return auth_store.CloudSession( base_url="https://c", diff --git a/tests/comfy_cli/command/build_auth_support.py b/tests/comfy_cli/command/build_auth_support.py index fb4f02706..a726741ae 100644 --- a/tests/comfy_cli/command/build_auth_support.py +++ b/tests/comfy_cli/command/build_auth_support.py @@ -27,7 +27,6 @@ # Keyed on the URL *path* so a route carrying query parameters (`?cursor=`, # `?os=&gpu=`) still matches. _ROUTES: dict[tuple[str, str], tuple[int, JsonObject]] = { - ("POST", "/v1/snapshots/resolve"): (200, {"definition": _EMPTY_DEFINITION, "report": {}}), ("POST", "/v1/builds"): (201, {"id": BUILD_ID, "updatedAt": REVISION}), ("GET", "/v1/builds"): (200, {"builds": [{"id": BUILD_ID, "name": "Matrix"}]}), ("GET", f"/v1/builds/{BUILD_ID}"): ( @@ -99,6 +98,8 @@ def __call__( path = urlsplit(url).path if (method, path) == ("POST", "/v1/models/resolve"): return 200, {"results": _resolved_filenames(body)} + if (method, path) == ("POST", "/v1/snapshots/resolve"): + return 200, {"definition": {"models": [], "customNodes": _placed_nodes(body)}, "report": {}} route = _ROUTES.get((method, path)) if route is None: pytest.fail(f"unexpected Builder call: {method} {url}") @@ -113,6 +114,24 @@ def _resolved_filenames(body: JsonObject | None) -> list[JsonValue]: return [{"filename": filename, "candidates": []} for filename in filenames] +def _placed_nodes(body: JsonObject | None) -> list[JsonValue]: + """Every pack the snapshot names, placed as asked: the importer vouches for + each pin, so a push or dry run that sends one gets past its pin check.""" + assert body is not None + snapshot = body["snapshot"] + assert isinstance(snapshot, dict) + placed: list[JsonValue] = [] + for entry in snapshot.get("snapshots") or []: + assert isinstance(entry, dict) + for node in entry.get("customNodes") or []: + assert isinstance(node, dict) + if node["type"] == "cnr": + placed.append({"name": node["dirName"], "id": node["id"], "registryVersion": node["version"]}) + else: + placed.append({"name": node["dirName"], "repository": node["url"]}) + return placed + + def write_snapshot(root: Path) -> Path: path = root / "snapshot.json" path.write_text(json.dumps({"customNodes": [], "pipPackages": {}, "pythonVersion": "3.12"}), encoding="utf-8") diff --git a/tests/comfy_cli/command/deploy_auth_support.py b/tests/comfy_cli/command/deploy_auth_support.py index 818e6923c..1c12711d5 100644 --- a/tests/comfy_cli/command/deploy_auth_support.py +++ b/tests/comfy_cli/command/deploy_auth_support.py @@ -36,6 +36,7 @@ class DeployFixtureKind(Enum): STATUS = "status" LS = "ls" SHOW = "show" + UI = "ui" LOGS = "logs" EVENTS = "events" SCALE = "scale" @@ -165,6 +166,23 @@ def __call__( } +class EditorRecordingTransport: + """Cloud membership/editor reads, separately from the deployment control plane.""" + + def __init__(self) -> None: + self.calls: list[tuple[str, tuple[str, ...]]] = [] + + def request(self, client, method: str, parts: tuple[str, ...], **kwargs): + assert client.target.auth_token == "tok_test" + assert client.target.api_key is None + self.calls.append((method, parts)) + assert method == "GET" + if parts == ("workspaces", "current"): + return {"id": "workspace-matrix"} + assert parts == ("workspaces", "workspace-matrix", "deployments") + return {"items": [{"deployment_id": DEPLOYMENT_ID, "status": "ready", "release_id": RELEASE_ID}]} + + def prepare_deploy(kind: DeployFixtureKind, root: Path) -> list[str]: match kind: case DeployFixtureKind.UP: @@ -185,7 +203,7 @@ def prepare_deploy(kind: DeployFixtureKind, root: Path) -> list[str]: case DeployFixtureKind.LS: write_spec(root, build_id=BUILD_ID, models=[], nodes=[]) return ["deploy", "ls", str(root)] - case DeployFixtureKind.SHOW | DeployFixtureKind.LOGS | DeployFixtureKind.EVENTS: + case DeployFixtureKind.SHOW | DeployFixtureKind.UI | DeployFixtureKind.LOGS | DeployFixtureKind.EVENTS: return ["deploy", kind.value, "--deployment", DEPLOYMENT_ID] case DeployFixtureKind.SCALE: # Both bounds: `scale` refuses one without the other before it looks @@ -243,6 +261,7 @@ def invoke_deploy(args: list[str], token: str | None): "COMFY_DEPLOY_TOKEN": token, "COMFY_BUILDER_URL": "https://builder.test", "COMFY_DEPLOY_URL": "https://control.test", + "COMFY_CLOUD_BASE_URL": "https://api.comfy.org", }, ) diff --git a/tests/comfy_cli/command/test_assets_library.py b/tests/comfy_cli/command/test_assets_library.py index 718655009..cb4fcc5e3 100644 --- a/tests/comfy_cli/command/test_assets_library.py +++ b/tests/comfy_cli/command/test_assets_library.py @@ -48,8 +48,22 @@ def reset_singleton(): reset_renderer_for_testing() +@pytest.fixture(scope="module") +def root_cli_ready(): + """Load the actual CLI before a test's target fake can bind into lazy modules.""" + from click import Context + from typer.main import get_command + + from comfy_cli.cmdline import app as root_app + + root = get_command(root_app) + with Context(root) as context: + for name in root.list_commands(context): + root.get_command(context, name) + + @pytest.fixture -def cloud_target(monkeypatch: pytest.MonkeyPatch): +def cloud_target(monkeypatch: pytest.MonkeyPatch, root_cli_ready): from comfy_cli.target import Target fake = Target( @@ -738,6 +752,16 @@ def test_bare_uppercase_digest_is_sent_unchanged(self, cloud_target, monkeypatch assert json.loads(calls[0]["body"])["hash"] == _HEX.upper() +def test_ls_encodes_multiple_tags_as_the_cloud_nonexploded_parameter(cloud_target, monkeypatch, capsys): + from urllib.parse import parse_qs, urlsplit + + calls = _patch_urlopen(monkeypatch, {"assets": [], "has_more": False, "total": 0}) + result = _run(["ls", "--tags", " models, loras ", "--where", "cloud"], capsys) + assert result["ok"] is True + query = parse_qs(urlsplit(calls[0]["url"]).query) + assert query["include_tags"] == ["models,loras"] + + # --- assets library upload --------------------------------------------------- _SIGNED = "https://storage.example.com/assets/temp/model-uploads/x.safetensors?X-Goog-Signature=SECRETSIG" @@ -1148,7 +1172,7 @@ def signed_in(monkeypatch: pytest.MonkeyPatch): session=SimpleNamespace(access_token="old-token", base_url="https://cloud.example.com"), forced=0 ) - def get_session(*, refresh=True, force=False, allow_clear=True, expect=None): + def get_session(*, refresh=True, force=False, allow_clear=True, expect=None, rejected_access_token=None): if force: state.forced += 1 state.session = SimpleNamespace(access_token="new-token", base_url="https://cloud.example.com") @@ -1261,7 +1285,7 @@ def stored_login(monkeypatch: pytest.MonkeyPatch): monkeypatch.delenv(var, raising=False) state = SimpleNamespace(login=("a", 1), forced=0) - def get_session(*, refresh=True, force=False, allow_clear=True, expect=None): + def get_session(*, refresh=True, force=False, allow_clear=True, expect=None, rejected_access_token=None): if force: state.forced += 1 state.login = (state.login[0], state.login[1] + 1) diff --git a/tests/comfy_cli/command/test_build_auth_matrix.py b/tests/comfy_cli/command/test_build_auth_matrix.py index fca091c29..8313ef001 100644 --- a/tests/comfy_cli/command/test_build_auth_matrix.py +++ b/tests/comfy_cli/command/test_build_auth_matrix.py @@ -23,7 +23,9 @@ from deploy_auth_support import ( DEPLOY_AUTH_CASES, DeployAuthCase, + DeployFixtureKind, DeployRecordingTransport, + EditorRecordingTransport, JobRecordingTransport, deploy_leaf_commands, invoke_deploy, @@ -53,6 +55,7 @@ class FixtureKind(Enum): VALIDATE_REMOTE_LOOKUP = "validate --remote (lookupable)" PUSH = "push" PUSH_DRY_RUN = "push --dry-run" + PUSH_DRY_RUN_PINNED = "push --dry-run (public pins)" PULL = "pull" STATUS = "status" LS = "ls" @@ -69,6 +72,7 @@ class FixtureKind(Enum): REFS_BUILD_TARGETS = "refs build-targets" REFS_MODEL_DIRS = "refs model-dirs" BLOB_LS = "blob ls" + INVENTORY = "inventory" @dataclass(frozen=True, slots=True) @@ -95,7 +99,10 @@ class BuildAuthCase: BuildAuthCase(FixtureKind.VALIDATE_REMOTE_ZERO, "validate", True, _ZERO_PLUS, 1), BuildAuthCase(FixtureKind.VALIDATE_REMOTE_LOOKUP, "validate", True, _ZERO_PLUS, 2), BuildAuthCase(FixtureKind.PUSH, "push", True, _ONE_PLUS), + # A dry run asks the builder only to place the spec's public pins, the read the + # push makes before it saves, so a spec without one stays signed out and silent. BuildAuthCase(FixtureKind.PUSH_DRY_RUN, "push", False, _ZERO), + BuildAuthCase(FixtureKind.PUSH_DRY_RUN_PINNED, "push", True, _ONE_PLUS, 1), BuildAuthCase(FixtureKind.PULL, "pull", True, _ONE_PLUS), BuildAuthCase(FixtureKind.STATUS, "status", True, _ONE_PLUS), BuildAuthCase(FixtureKind.LS, "ls", True, _ONE_PLUS), @@ -112,6 +119,8 @@ class BuildAuthCase: BuildAuthCase(FixtureKind.REFS_BUILD_TARGETS, "refs build-targets", True, _ONE_PLUS), BuildAuthCase(FixtureKind.REFS_MODEL_DIRS, "refs model-dirs", True, _ONE_PLUS), BuildAuthCase(FixtureKind.BLOB_LS, "blob ls", True, _ONE_PLUS), + # Reads only the workflow file; --cloud reads the node catalog, never the Builder. + BuildAuthCase(FixtureKind.INVENTORY, "inventory", False, _ZERO), ) @@ -165,6 +174,15 @@ def _prepare(kind: FixtureKind, root: Path) -> list[str]: case FixtureKind.PUSH_DRY_RUN: write_spec(root, models=[], nodes=[]) return ["build", "push", "--dry-run", str(root)] + case FixtureKind.PUSH_DRY_RUN_PINNED: + write_spec( + root, + models=[], + nodes=[ + {"name": "registry-node", "id": "registry-node", "registryVersion": "1.0.0", "source": "registry"} + ], + ) + return ["build", "push", "--dry-run", str(root)] case FixtureKind.PULL: write_spec(root, models=[], nodes=[]) return ["build", "pull", "-y", "--id", BUILD_ID, str(root)] @@ -199,6 +217,10 @@ def _prepare(kind: FixtureKind, root: Path) -> list[str]: return ["build", "refs", "model-dirs"] case FixtureKind.BLOB_LS: return ["build", "blob", "ls"] + case FixtureKind.INVENTORY: + workflow = root / "workflow.json" + workflow.write_text(json.dumps({"nodes": [{"id": 1, "type": "KSampler", "mode": 0}]}), encoding="utf-8") + return ["build", "inventory", str(workflow)] case unreachable: assert_never(unreachable) @@ -275,11 +297,15 @@ def test_auth_matrix_covers_every_build_command() -> None: def test_deploy_auth_contract(case: DeployAuthCase, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: # Given control = DeployRecordingTransport() + editor = EditorRecordingTransport() jobs = JobRecordingTransport() builder = RecordingTransport() monkeypatch.setattr("comfy_cli.deploy_api.request_json", control) monkeypatch.setattr("comfy_cli.deploy_jobs.request_json", jobs) monkeypatch.setattr("comfy_cli.builder_api.request_json", builder) + monkeypatch.setattr( + "comfy_cli.comfy_client.Client._request", lambda client, *a, **kw: editor.request(client, *a, **kw) + ) monkeypatch.setattr("comfy_cli.credentials.find_api_key", lambda *args, **kwargs: None) monkeypatch.setattr( "comfy_cli.credentials.get_session", @@ -293,6 +319,7 @@ def test_deploy_auth_contract(case: DeployAuthCase, tmp_path: Path, monkeypatch: assert signed_out.exit_code == 1 assert _error_code(signed_out) == "deploy_not_signed_in" assert control.calls == [] + assert editor.calls == [] # When signed_in = invoke_deploy(prepare_deploy(case.fixture, tmp_path / "signed-in"), "tok_test") @@ -300,6 +327,11 @@ def test_deploy_auth_contract(case: DeployAuthCase, tmp_path: Path, monkeypatch: # Then assert signed_in.exit_code == 0, signed_in.stderr assert len(control.calls) >= 1 + assert editor.calls == ( + [("GET", ("workspaces", "current")), ("GET", ("workspaces", "workspace-matrix", "deployments"))] + if case.fixture is DeployFixtureKind.UI + else [] + ) def test_auth_matrix_covers_every_deploy_command() -> None: diff --git a/tests/comfy_cli/command/test_build_inventory.py b/tests/comfy_cli/command/test_build_inventory.py new file mode 100644 index 000000000..0620b79ee --- /dev/null +++ b/tests/comfy_cli/command/test_build_inventory.py @@ -0,0 +1,493 @@ +from __future__ import annotations + +import json +from pathlib import Path + +import jsonschema +import pytest +from typer.testing import CliRunner + +from comfy_cli.cmdline import app as cli_app + +SCHEMA = Path(__file__).resolve().parents[3] / "comfy_cli" / "schemas" / "build_inventory.json" + + +@pytest.fixture(autouse=True) +def quiet_tracking(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setattr("comfy_cli.tracking.prompt_tracking_consent", lambda *args, **kwargs: None) + monkeypatch.setattr("comfy_cli.tracking.track_event", lambda *args, **kwargs: None) + + +def _invoke(*args: str): + result = CliRunner().invoke( + cli_app, + ["build", "inventory", *args], + env={"AI_AGENT": "1", "COMFY_OUTPUT": "json", "NO_COLOR": "1"}, + ) + lines = [line for line in result.stdout.splitlines() if line.strip()] + return result, json.loads(lines[-1]) + + +def _write_workflow(tmp_path: Path) -> Path: + workflow = { + "nodes": [ + {"id": 1, "type": "CheckpointLoaderSimple", "mode": 0, "widgets_values": ["sdxl/base.safetensors"]}, + {"id": 2, "type": "LoraLoaderModelOnly", "mode": 0, "widgets_values": ["private_v1.safetensors", 1.0]}, + {"id": 3, "type": "UpscaleModelLoader", "mode": 2, "widgets_values": ["muted.pth"]}, + ] + } + path = tmp_path / "wf.json" + path.write_text(json.dumps(workflow), encoding="utf-8") + return path + + +def test_inventory_reports_scope_and_local_files(tmp_path: Path): + workflow = _write_workflow(tmp_path) + models = tmp_path / "models" / "loras" + models.mkdir(parents=True) + (models / "private_v1.safetensors").write_bytes(b"LORA") + + result, envelope = _invoke(str(workflow), "--models-root", str(tmp_path / "models"), "--hash") + + assert result.exit_code == 0, result.stdout + assert envelope["ok"] is True + assert envelope["command"] == "build inventory" + data = envelope["data"] + jsonschema.validate(data, json.loads(SCHEMA.read_text(encoding="utf-8"))) + assert [m["path"] for m in data["models"]] == ["sdxl/base.safetensors", "private_v1.safetensors"] + assert data["skipped"][0]["why"] == "muted" + assert data["models_not_on_disk"] == ["sdxl/base.safetensors"] + assert data["models"][1]["local"][0]["type_dir"] == "loras" + assert "sha256" in data["models"][1]["local"][0] + + +def test_inventory_cloud_uses_the_cloud_catalog(tmp_path: Path, monkeypatch: pytest.MonkeyPatch): + workflow = _write_workflow(tmp_path) + catalog = { + "CheckpointLoaderSimple": {"inputs": [{"name": "ckpt_name", "choices": ["base.safetensors"]}]}, + "LoraLoaderModelOnly": {"inputs": [{"name": "lora_name", "choices": ["public.safetensors"]}]}, + } + + class FakeGraph: + def node(self, name): + return name if name in catalog else None + + def morphism_to_dict(self, node): + return catalog[node] + + seen = {} + + def fake_get_graph(input_path, host, port, where=None, on_stale=None): + seen["where"] = where + return FakeGraph() + + monkeypatch.setattr("comfy_cli.command.nodes._get_graph", fake_get_graph) + monkeypatch.setattr("comfy_cli.target.resolve_target", lambda where=None: object()) + + result, envelope = _invoke(str(workflow), "--cloud") + + assert result.exit_code == 0, result.stdout + assert seen["where"] == "cloud" + cloud = envelope["data"]["cloud"] + assert cloud["verdict"] == "needs_build_or_lossy_conversion" + assert cloud["blocking"] == ["private_v1.safetensors"] + assert cloud["models"][0]["set_widget"] == "1.ckpt_name" + jsonschema.validate(envelope["data"], json.loads(SCHEMA.read_text(encoding="utf-8"))) + + +def test_inventory_unreachable_server_is_reported_not_fatal(tmp_path: Path, monkeypatch: pytest.MonkeyPatch): + workflow = _write_workflow(tmp_path) + + def refuse(url, **kwargs): + raise ConnectionRefusedError(61, "Connection refused") + + monkeypatch.setattr("comfy_cli.local_server_identity.fetch_json", refuse) + + result, envelope = _invoke(str(workflow), "--server", "http://127.0.0.1:8000") + + assert result.exit_code == 0, result.stdout + section = envelope["data"]["local_server"] + assert section["server"] == "http://127.0.0.1:8000" + assert "ConnectionRefusedError" in section["error"] + + +@pytest.mark.parametrize("endpoint", ["system_stats", "object_info"]) +def test_inventory_oversized_server_detail_retains_workflow_report(tmp_path, monkeypatch, endpoint): + from comfy_cli.http import ResponseTooLarge + + def fetch(url): + if url.endswith(endpoint): + raise ResponseTooLarge("response exceeds byte cap") + return {} + + monkeypatch.setattr("comfy_cli.command.build._inventory_fetch_json", fetch) + monkeypatch.setattr("comfy_cli.command.build._inventory_fetch_server_stats", lambda url: (fetch(url), True)) + result, envelope = _invoke(str(_write_workflow(tmp_path)), "--server", "127.0.0.1:8000") + + assert result.exit_code == 0, result.stdout + assert envelope["ok"] is True + assert envelope["data"]["models"][0]["path"] == "sdxl/base.safetensors" + assert "ResponseTooLarge" in envelope["data"]["local_server"]["error"] + jsonschema.validate(envelope["data"], json.loads(SCHEMA.read_text())) + + +def test_inventory_oversized_desktop_stats_does_not_discover_another_install(tmp_path, monkeypatch): + from comfy_cli import desktop_install + from comfy_cli.http import ResponseTooLarge + + observed_stats = [] + + def detect(*, server_stats=None, server_filesystem_verified=False): + observed_stats.append(server_stats) + return None + + def fetch(url): + raise ResponseTooLarge("response exceeds byte cap") + + monkeypatch.setattr(desktop_install, "detect", detect) + monkeypatch.setattr("comfy_cli.command.build._inventory_fetch_json", fetch) + monkeypatch.setattr("comfy_cli.command.build._inventory_fetch_server_stats", lambda url: (fetch(url), True)) + result, envelope = _invoke(str(_write_workflow(tmp_path)), "--desktop", "--server", "127.0.0.1:8000") + + assert result.exit_code == 0, result.stdout + assert envelope["ok"] is True + data = envelope["data"] + assert observed_stats and all(stats == {} for stats in observed_stats) + assert "models_roots" not in data + assert any("cannot verify running server" in warning for warning in data["warnings"]) + assert "ResponseTooLarge" in data["local_server"]["error"] + + +def test_inventory_oversized_cloud_size_stays_unknown(tmp_path, monkeypatch): + from comfy_cli.http import ResponseTooLarge + + workflow = tmp_path / "workflow.json" + workflow.write_text( + json.dumps({"1": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "model.safetensors"}}}) + ) + models = tmp_path / "models" + models.mkdir() + (models / "model.safetensors").write_bytes(b"local") + + class Graph: + def node(self, name): + return name + + def morphism_to_dict(self, node): + return {"inputs": [{"name": "ckpt_name", "choices": ["model.safetensors"]}]} + + class Target: + def url(self, path): + return "https://cloud.example.test/api/" + path + + def oversized(*args, **kwargs): + raise ResponseTooLarge("response exceeds byte cap") + + monkeypatch.setattr("comfy_cli.command.nodes._get_graph", lambda *args, **kwargs: Graph()) + monkeypatch.setattr("comfy_cli.target.resolve_target", lambda **kwargs: Target()) + monkeypatch.setattr("comfy_cli.command.models.search._http_get_json", oversized) + result, envelope = _invoke(str(workflow), "--cloud", "--models-root", str(models)) + + assert result.exit_code == 0, result.stdout + assert envelope["ok"] is True + assert envelope["data"]["cloud"]["models"][0]["weights"] == "unknown" + assert envelope["data"]["cloud"]["unverified"] + + +def test_inventory_rejects_a_missing_or_malformed_workflow(tmp_path: Path): + result, envelope = _invoke(str(tmp_path / "nope.json")) + assert result.exit_code == 1 + assert envelope["error"]["code"] == "workflow_not_found" + + bad = tmp_path / "bad.json" + bad.write_text("", encoding="utf-8") + result, envelope = _invoke(str(bad)) + assert result.exit_code == 1 + assert envelope["error"]["code"] == "workflow_invalid_json" + + listed = tmp_path / "list.json" + listed.write_text("[]", encoding="utf-8") + result, envelope = _invoke(str(listed)) + assert envelope["error"]["code"] == "workflow_invalid_json" + + +def test_inventory_cloud_compares_local_weights_and_hashes_inputs(tmp_path: Path, monkeypatch: pytest.MonkeyPatch): + workflow = tmp_path / "wf.json" + workflow.write_text( + json.dumps( + { + "nodes": [ + {"id": 1, "type": "UpscaleModelLoader", "mode": 0, "widgets_values": ["4x-UltraSharp.pth"]}, + {"id": 2, "type": "LoadImage", "mode": 0, "widgets_values": ["face.png", "image"]}, + ] + } + ), + encoding="utf-8", + ) + models = tmp_path / "models" / "upscale_models" + models.mkdir(parents=True) + (models / "4x-UltraSharp.pth").write_bytes(b"x" * 10) + inputs = tmp_path / "input" + inputs.mkdir() + (inputs / "face.png").write_bytes(b"PNG") + from comfy_cli.hashing import blake3_file + + uploaded = blake3_file(inputs / "face.png").split(":", 1)[1] + ".png" + catalog = { + "UpscaleModelLoader": {"inputs": [{"name": "model_name", "choices": ["4x-UltraSharp.pth"]}]}, + "LoadImage": {"inputs": [{"name": "image", "choices": [uploaded]}]}, + } + + class FakeGraph: + def node(self, name): + return name if name in catalog else None + + def morphism_to_dict(self, node): + return catalog[node] + + monkeypatch.setattr("comfy_cli.command.nodes._get_graph", lambda *args, **kwargs: FakeGraph()) + monkeypatch.setattr("comfy_cli.target.resolve_target", lambda where=None: object()) + monkeypatch.setattr("comfy_cli.command.build._inventory_cloud_model_size", lambda target, name: 66_961_958) + + result, envelope = _invoke( + str(workflow), "--cloud", "--models-root", str(tmp_path / "models"), "--input-root", str(inputs) + ) + + assert result.exit_code == 0, result.stdout + data = envelope["data"] + assert data["cloud"]["models"][0]["weights"] == "different_size" + assert data["cloud"]["verdict"] == "needs_build_or_lossy_conversion" + assert data["inputs"][0]["cloud_name"] == uploaded + assert data["inputs"][0]["on_cloud"] is True + jsonschema.validate(data, json.loads(SCHEMA.read_text(encoding="utf-8"))) + + +@pytest.mark.parametrize("payload", [{}, {"nodes": "not-a-list"}, {"nodes": [None]}, {"not": "a workflow"}]) +def test_inventory_rejects_objects_that_are_not_workflows(tmp_path: Path, payload): + path = tmp_path / "bad.json" + path.write_text(json.dumps(payload), encoding="utf-8") + + result, envelope = _invoke(str(path)) + + assert result.exit_code == 1 + assert envelope["error"]["code"] == "workflow_invalid_json" + + +def test_api_inventory_lists_the_deployment_scanners_complete_upload_plan(tmp_path: Path, monkeypatch): + from comfy_cli.command.deploy_workflow import scan_workflow_inputs + + private = tmp_path / "private-face.png" + private.write_bytes(b"PRIVATE") + graph = {"1": {"class_type": "FaceReference", "inputs": {"reference": private.name}}} + workflow = tmp_path / "api.json" + workflow.write_text(json.dumps(graph), encoding="utf-8") + monkeypatch.setattr("comfy_cli.command.deploy_workflow.resolve_asset_roots", lambda *a, **kw: (tmp_path,)) + + result, envelope = _invoke(str(workflow), "--input-root", str(tmp_path)) + + assert result.exit_code == 0 + expected = scan_workflow_inputs(graph, asset_roots=(tmp_path,)) + assert envelope["data"]["deployment_assets"] == [ + {"local_path": str(asset.local_path), "file_path": asset.file_path, "bytes": asset.local_path.stat().st_size} + for asset in expected.assets + ] + assert envelope["data"]["deployment_asset_roots"] == [str(tmp_path)] + + +@pytest.mark.parametrize("root_option", ["--models-root", "--input-root"]) +def test_inventory_reports_nonexistent_explicit_roots(tmp_path, root_option): + workflow = _write_workflow(tmp_path) + missing = tmp_path / "does-not-exist" + result, envelope = _invoke(str(workflow), root_option, str(missing)) + assert result.exit_code == 0 + assert any("root_not_found" in warning and str(missing) in warning for warning in envelope["data"]["warnings"]) + + +def test_desktop_inventory_uses_only_running_instance_models_and_input(tmp_path, monkeypatch): + from comfy_cli import desktop_install + + app = tmp_path / "Comfy Desktop" + app.mkdir() + records = [] + for name in ("running", "other"): + code = tmp_path / name / "ComfyUI" + code.mkdir(parents=True) + (code / "main.py").write_text("") + (code / "models").mkdir() + (code / "input").mkdir() + records.append({"id": name, "installPath": str(code.parent)}) + (app / "installations.json").write_text(json.dumps(records)) + monkeypatch.setattr(desktop_install, "desktop_app_data_dir", lambda: app) + + def fetch(url): + return ( + {"system": {"argv": [str(tmp_path / "running" / "ComfyUI" / "main.py")]}} + if url.endswith("system_stats") + else {} + ) + + monkeypatch.setattr("comfy_cli.command.build._inventory_fetch_json", fetch) + monkeypatch.setattr("comfy_cli.command.build._inventory_fetch_server_stats", lambda url: (fetch(url), True)) + result, envelope = _invoke(str(_write_workflow(tmp_path)), "--desktop", "--server", "127.0.0.1:8000") + assert result.exit_code == 0 + data = envelope["data"] + assert data["models_roots"] == [str(tmp_path / "running" / "ComfyUI" / "models")] + assert data["desktop"]["install_id"] == "running" + assert data["input_roots"] == [str(tmp_path / "running" / "ComfyUI" / "input")] + + +def test_desktop_inventory_settings_only_modern_registry_is_supported(tmp_path, monkeypatch): + from comfy_cli import desktop_install + + app = tmp_path / "comfyui-desktop-2" + app.mkdir() + models = tmp_path / "models" + models.mkdir() + (app / "settings.json").write_text(json.dumps({"modelsDirs": [str(models)]})) + monkeypatch.setattr(desktop_install, "desktop_app_data_dir", lambda: app) + roots, warning = __import__("comfy_cli.command.build", fromlist=["_desktop_model_roots"])._desktop_model_roots() + assert roots == [str(models)] + assert warning is None + + +@pytest.mark.parametrize("value", ["/not-a-model-root", {"/": "models"}, True, False, 1, 0, {}]) +def test_desktop_inventory_settings_only_rejects_non_list_model_roots(tmp_path, monkeypatch, value): + from comfy_cli import desktop_install + from comfy_cli.command.build import _desktop_model_roots + + app = tmp_path / "desktop-settings" + app.mkdir() + (app / "settings.json").write_text(json.dumps({"modelsDirs": value})) + monkeypatch.setattr(desktop_install, "app_data_dirs", lambda: (app,)) + + roots, warning = _desktop_model_roots() + + assert roots == [] + assert "modelsDirs must be a list" in warning + assert "--models-root" in warning + + +def test_desktop_inventory_settings_only_ignores_empty_and_non_string_roots(tmp_path, monkeypatch): + from comfy_cli import desktop_install + from comfy_cli.command.build import _desktop_model_roots + + app = tmp_path / "desktop-settings" + app.mkdir() + models = tmp_path / "models" + models.mkdir() + (app / "settings.json").write_text(json.dumps({"modelsDirs": ["", None, 7, str(models)]})) + monkeypatch.setattr(desktop_install, "app_data_dirs", lambda: (app,)) + + roots, warning = _desktop_model_roots() + + assert roots == [str(models)] + assert warning is None + + +def test_desktop_inventory_plans_only_referenced_file_from_effective_output_root(tmp_path, monkeypatch): + from comfy_cli import desktop_install + + code = tmp_path / "ComfyUI" + for directory in (code, code / "models", code / "input"): + directory.mkdir(exist_ok=True) + (code / "main.py").write_text("") + app = tmp_path / "Comfy Desktop" + app.mkdir() + (app / "installations.json").write_text(json.dumps([{"id": "live", "installPath": str(code)}])) + output = tmp_path / "actual-output" + output.mkdir() + required = output / "generated.png" + required.write_bytes(b"one required synthetic input") + (output / "unrelated-private.png").write_bytes(b"do not plan this file") + workflow = tmp_path / "api.json" + workflow.write_text(json.dumps({"1": {"class_type": "FaceReference", "inputs": {"reference": "generated.png"}}})) + monkeypatch.setattr(desktop_install, "desktop_app_data_dir", lambda: app) + + def fetch(url): + return ( + { + "system": { + "argv": [str(code / "main.py"), "--output-directory", str(output), "--api-token", "secret-not-path"] + } + } + if url.endswith("system_stats") + else {} + ) + + monkeypatch.setattr("comfy_cli.command.build._inventory_fetch_json", fetch) + monkeypatch.setattr("comfy_cli.command.build._inventory_fetch_server_stats", lambda url: (fetch(url), True)) + result, envelope = _invoke(str(workflow), "--desktop", "--server", "127.0.0.1:8000") + assert result.exit_code == 0, result.output + data = envelope["data"] + assert data["desktop"]["output_dir"] == str(output) + assert str(output) in data["deployment_asset_roots"] + assert [entry["local_path"] for entry in data["deployment_assets"]] == [str(required)] + assert data["local_server"]["launch_paths"]["output_directory"] == [str(output)] + assert "secret-not-path" not in result.output + + +@pytest.mark.parametrize("server", ["192.0.2.77:8188", "127.0.0.1:8000"]) +def test_unverified_desktop_server_keeps_metadata_and_explicit_roots_only(tmp_path, monkeypatch, server): + from comfy_cli import desktop_install + + app = tmp_path / "registry" + app.mkdir() + code = tmp_path / "unrelated" / "ComfyUI" + code.mkdir(parents=True) + (code / "main.py").write_text("") + (code / "models").mkdir() + (app / "installations.json").write_text(json.dumps([{"id": "collision", "installPath": str(code.parent)}])) + explicit = tmp_path / "explicit-models" + explicit.mkdir() + (explicit / "private_v1.safetensors").write_bytes(b"explicit") + stats = {"system": {"argv": [str(code / "main.py")], "python": "/unrelated/python", "comfyui_version": "remote"}} + monkeypatch.setattr(desktop_install, "app_data_dirs", lambda: (app,)) + monkeypatch.setattr("comfy_cli.command.build._inventory_fetch_server_stats", lambda url: (stats, False)) + monkeypatch.setattr("comfy_cli.command.build._inventory_fetch_json", lambda url: {}) + + result, envelope = _invoke( + str(_write_workflow(tmp_path)), "--desktop", "--server", server, "--models-root", str(explicit) + ) + + assert result.exit_code == 0, result.stdout + data = envelope["data"] + assert data["desktop"]["install_id"] is None + assert data["desktop"]["python"] is None + assert data["desktop"]["model_roots"] == [] + assert data["models_roots"] == [str(explicit)] + assert data["models"][1]["local"][0]["bytes"] == 8 + assert "input_roots" not in data and "output_dir" not in data["desktop"] + assert data["local_server"]["comfyui_version"] == "remote" + assert any("filesystem" in warning for warning in data["warnings"]) + jsonschema.validate(data, json.loads(SCHEMA.read_text())) + + +@pytest.mark.parametrize("invalid", ["stats-array", "system-string", "object-info-array"]) +def test_malformed_optional_server_shape_keeps_workflow_and_explicit_roots(tmp_path, monkeypatch, invalid): + stats = ( + [] + if invalid == "stats-array" + else {"system": "not-an-object"} + if invalid == "system-string" + else {"system": {}} + ) + object_info = [] if invalid == "object-info-array" else {} + explicit = tmp_path / "explicit-models" + explicit.mkdir() + (explicit / "private_v1.safetensors").write_bytes(b"explicit") + monkeypatch.setattr( + "comfy_cli.command.build._inventory_fetch_json", + lambda url: stats if url.endswith("system_stats") else object_info, + ) + + result, envelope = _invoke( + str(_write_workflow(tmp_path)), "--server", "127.0.0.1:8000", "--models-root", str(explicit) + ) + + assert result.exit_code == 0, result.stdout + data = envelope["data"] + assert envelope["ok"] is True + assert data["models_roots"] == [str(explicit)] + assert data["models"][1]["local"][0]["bytes"] == 8 + assert "ValueError" in data["local_server"]["error"] + jsonschema.validate(data, json.loads(SCHEMA.read_text())) diff --git a/tests/comfy_cli/command/test_build_push.py b/tests/comfy_cli/command/test_build_push.py index 29d065995..fd52305d7 100644 --- a/tests/comfy_cli/command/test_build_push.py +++ b/tests/comfy_cli/command/test_build_push.py @@ -61,6 +61,7 @@ def _schema(name: str) -> JsonObject: def test_dry_run_is_signed_out_and_zero_http(workspace: Path, monkeypatch: pytest.MonkeyPatch) -> None: + """Only a public pin needs the builder, so a spec without one asks it nothing.""" # Given path = write_spec(workspace) before = path.read_bytes() @@ -294,6 +295,125 @@ def test_pin_gate_normalizes_equivalent_repository_identities(workspace: Path, m assert len(client.snapshots) == 1 +#: A pin to a version the registry has Flagged. The builder's importer cannot +#: place it, so the push refuses it. +_FLAGGED_PIN: JsonObject = { + "name": "ComfyUI-DepthAnythingV3", + "id": "ComfyUI-DepthAnythingV3", + "registryVersion": "0.1.19", + "source": "registry", +} + +_REGISTRY_PIN: JsonObject = { + "name": "registry-node", + "id": "registry-node", + "registryVersion": "1.0.0", + "source": "registry", +} + + +class _FlaggedImporter(RecordingBuilder): + """The importer's answer for a Flagged version, in the shape the live builder + sends: the pack is left out of the definition and named in the report.""" + + def resolve_snapshot(self, snapshot: JsonObject) -> JsonObject: + super().resolve_snapshot(snapshot) + return { + "definition": {}, + "report": {"notInRegistry": [_FLAGGED_PIN["id"]], "unresolvedNodes": [_FLAGGED_PIN["id"]]}, + } + + +def test_a_dry_run_refuses_a_flagged_pin_with_the_push_s_own_error( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + """A dry run is the free check before disclosing and spending, so it must + refuse a pin the builder cannot place the way the push does, not pass it.""" + # Given + pushed_root = make_workspace(tmp_path / "push") + write_spec(pushed_root, models=[], nodes=[_FLAGGED_PIN]) + pushed = _FlaggedImporter() + _install_client(monkeypatch, pushed) + push = invoke_push(pushed_root) + + dry_root = make_workspace(tmp_path / "dry-run") + spec = write_spec(dry_root, models=[], nodes=[_FLAGGED_PIN]) + before = spec.read_bytes() + dry = _FlaggedImporter() + _install_client(monkeypatch, dry) + + # When + result = invoke_push(dry_root, "--dry-run") + + # Then + assert (push.exit_code, result.exit_code) == (1, 1) + error = envelope(result)["error"] + assert error == envelope(push)["error"] + assert error["code"] == "build_registry_pin_missing" + assert "registry:ComfyUI-DepthAnythingV3@0.1.19" in error["message"] + assert [call["method"] for call in dry.calls] == ["resolve_snapshot"] + assert spec.read_bytes() == before + + +def test_a_dry_run_asks_the_builder_only_to_place_its_public_pins( + workspace: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + # Given + path = write_spec(workspace, nodes=[local_node(), _REGISTRY_PIN]) + before = path.read_bytes() + client = RecordingBuilder() + _install_client(monkeypatch, client) + + # When + result = invoke_push(workspace, "--dry-run") + + # Then + assert result.exit_code == 0, result.stderr + assert [call["method"] for call in client.calls] == ["resolve_snapshot"] + sent = client.snapshots[0]["snapshots"][0]["customNodes"] + assert [(node["id"], node["version"]) for node in sent] == [("registry-node", "1.0.0")] + data = envelope(result)["data"] + assert (data["dry_run"], data["upload_count"], data["uploaded"]) == (True, 2, 0) + assert path.read_bytes() == before + + +def test_a_dry_run_whose_pin_lookup_fails_exits_rather_than_passing( + workspace: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + # Given + write_spec(workspace, models=[], nodes=[_REGISTRY_PIN]) + client = RecordingBuilder() + + def unreachable(snapshot: JsonObject) -> JsonObject: + raise urllib.error.URLError("connection refused") + + monkeypatch.setattr(client, "resolve_snapshot", unreachable) + _install_client(monkeypatch, client) + + # When + result = invoke_push(workspace, "--dry-run") + + # Then + assert result.exit_code == 1 + assert envelope(result)["error"]["code"] == "build_builder_error" + + +def test_a_dry_run_tells_a_person_it_checked_the_public_pins(workspace: Path, monkeypatch: pytest.MonkeyPatch) -> None: + # Given + write_spec(workspace, nodes=[local_node(), _REGISTRY_PIN]) + _install_client(monkeypatch, RecordingBuilder()) + + # When + result = invoke_push(workspace, "--dry-run", agentic=False) + + # Then + assert result.exit_code == 0, result.output + text = " ".join(result.stdout.split()) + assert "The builder resolved 1 public custom node pin." in text + assert "nothing was uploaded or saved" in text + assert "nothing was sent" not in text + + def test_a_skipped_symlink_is_named_on_stderr_and_carried_in_the_payload( workspace: Path, monkeypatch: pytest.MonkeyPatch ) -> None: diff --git a/tests/comfy_cli/command/test_build_validate.py b/tests/comfy_cli/command/test_build_validate.py index 42e7fa5e5..39217a1f2 100644 --- a/tests/comfy_cli/command/test_build_validate.py +++ b/tests/comfy_cli/command/test_build_validate.py @@ -934,3 +934,22 @@ def request_json(url, target, *, method="GET", body=None, timeout=30.0, max_byte assert said.count(_FOLDER_CASE_UNCHECKED) == 1, pretty.output assert agent.exit_code == 0, agent.output assert _envelope(agent)["data"]["folder_case_checked"] is False + + +@pytest.mark.parametrize("kind", ["model", "node"]) +@pytest.mark.parametrize("override", [False, True], ids=["default-base", "explicit-base"]) +def test_missing_local_path_names_effective_asset_base(workspace, kind, override): + models = [local_model(localPath="checkpoints/missing.safetensors")] if kind == "model" else [] + nodes = [local_node(localPath="missing-node")] if kind == "node" else [] + write_spec(workspace, models=models, nodes=nodes) + base = workspace / ("models" if kind == "model" else "custom_nodes") + options = [] + if override: + base = workspace.parent / "separate-assets" + base.mkdir() + options = ["--models-dir" if kind == "model" else "--custom-nodes-dir", str(base)] + result = _invoke(workspace, *options) + assert result.exit_code == 1 + error = _envelope(result)["error"] + assert error["code"] == "build_spec_invalid" + assert str(base) in error["message"] diff --git a/tests/comfy_cli/command/test_deploy_progress.py b/tests/comfy_cli/command/test_deploy_progress.py index 5aaaf1927..5acf0278b 100644 --- a/tests/comfy_cli/command/test_deploy_progress.py +++ b/tests/comfy_cli/command/test_deploy_progress.py @@ -581,7 +581,7 @@ def interrupt(_: float) -> None: # Then assert result.exit_code == 130 assert "keeps coming up on our side" in result.stderr - assert "comfy deploy status --deployment dep-status --watch" in result.stderr + assert "comfy deploy show --deployment dep-status" in result.stderr data = _envelope(result)["data"] assert data["deployment"]["status"] == "provisioning" assert data["progress"]["step"] == "staging_models" @@ -655,7 +655,7 @@ def interrupt(_: float) -> None: assert result.exit_code == 130 events = [json.loads(line) for line in result.stderr.splitlines() if line.startswith("{")] assert [event["type"] for event in events] == [EVENT_PROGRESS] - assert "comfy deploy status --deployment dep-1 --watch" in result.stderr + assert "comfy deploy show --deployment dep-1" in result.stderr data = _envelope(result)["data"] assert data["deployment"]["status"] == "provisioning" assert data["progress"]["bytesDone"] == 3 * GB @@ -683,7 +683,14 @@ class _TerminalRenderer: def __init__(self, width: int) -> None: from rich.console import Console - self._console = Console(file=io.StringIO(), width=width, force_terminal=True, color_system=None) + # Emulate the promised terminal even when the caller exports TERM=dumb. + self._console = Console( + file=io.StringIO(), + width=width, + force_terminal=True, + color_system=None, + _environ={"TERM": "xterm-256color"}, + ) def is_pretty(self) -> bool: return True diff --git a/tests/comfy_cli/command/test_deploy_read.py b/tests/comfy_cli/command/test_deploy_read.py index 84062410b..3195d1242 100644 --- a/tests/comfy_cli/command/test_deploy_read.py +++ b/tests/comfy_cli/command/test_deploy_read.py @@ -481,3 +481,25 @@ def test_an_event_with_an_invalid_release_is_refused(release_id, monkeypatch) -> # Then assert result.exit_code == 1 assert _envelope(result)["error"]["code"] == "deploy_server_error" + + +def test_watch_recovery_command_is_read_only_and_runs_outside_a_spec(monkeypatch, tmp_path): + import shlex + + from comfy_cli.command.deploy_progress import reattach_hint + + builder = FakeBuilder() + client = ReadDeploy() + _install_clients(monkeypatch, builder, client) + status_module = importlib.import_module("comfy_cli.command.deploy_status") + monkeypatch.setattr(status_module, "_command_clients", lambda: (builder, client)) + runner = CliRunner() + monkeypatch.chdir(tmp_path) + assert not Path("comfy-build.yaml").exists() + args = shlex.split(reattach_hint("dep-read")) + assert args[0] == "comfy" + result = runner.invoke(app, ["--json", *args[1:]]) + assert result.exit_code == 0, result.output + assert _envelope(result)["data"]["id"] == "dep-read" + assert builder.calls == [] + assert client.calls == [("show", "dep-read")] diff --git a/tests/comfy_cli/command/test_deploy_rollback.py b/tests/comfy_cli/command/test_deploy_rollback.py index 042580278..b00385902 100644 --- a/tests/comfy_cli/command/test_deploy_rollback.py +++ b/tests/comfy_cli/command/test_deploy_rollback.py @@ -233,7 +233,7 @@ def rollback_deployment(self, deployment_id: str, base_revision: int, to_revisio ( "PENDING_UPDATE_EXISTS", "is waiting on an update, so the rollback was refused", - "wait until `comfy deploy status --deployment dep-prod` shows no update", + "wait until `comfy deploy show --deployment dep-prod` shows no update", ), ( "RELEASE_DELETED", diff --git a/tests/comfy_cli/command/test_deploy_run.py b/tests/comfy_cli/command/test_deploy_run.py index f2629f77f..59e731966 100644 --- a/tests/comfy_cli/command/test_deploy_run.py +++ b/tests/comfy_cli/command/test_deploy_run.py @@ -192,7 +192,7 @@ def test_deploy_run_is_registered_with_the_complete_option_surface() -> None: } <= option_names("run") -def test_deploy_tree_is_exactly_the_seventeen_designed_commands() -> None: +def test_deploy_tree_is_exactly_the_eighteen_designed_commands() -> None: # Given / When command = typer.main.get_command(deploy.app) assert hasattr(command, "commands"), command @@ -209,6 +209,7 @@ def test_deploy_tree_is_exactly_the_seventeen_designed_commands() -> None: "status", "ls", "show", + "ui", "logs", "events", "scale", @@ -613,7 +614,7 @@ class _RotatingSignIn: def __init__(self) -> None: self.token = "token-at-start" - def __call__(self, *, refresh=True, force=False, allow_clear=True): + def __call__(self, *, refresh=True, force=False, allow_clear=True, rejected_access_token=None): return SimpleNamespace(access_token=self.token, base_url="https://cloud.comfy.org") @@ -673,7 +674,7 @@ def test_an_unreadable_sign_in_at_cancel_still_cancels_with_the_token_the_run_ho monkeypatch.setattr(deploy_run, "resolve_partner_credential", lambda: None) store = {"readable": True} - def get_session(*, refresh=True, force=False, allow_clear=True): + def get_session(*, refresh=True, force=False, allow_clear=True, rejected_access_token=None): if not store["readable"]: raise OSError("auth store lock unavailable") return SimpleNamespace(access_token="cloud-secret", base_url="https://cloud.comfy.org") diff --git a/tests/comfy_cli/command/test_deploy_status.py b/tests/comfy_cli/command/test_deploy_status.py index 0076d559d..09c942d4d 100644 --- a/tests/comfy_cli/command/test_deploy_status.py +++ b/tests/comfy_cli/command/test_deploy_status.py @@ -4,6 +4,7 @@ import json from datetime import datetime, timedelta, timezone from pathlib import Path +from types import SimpleNamespace import jsonschema import pytest @@ -797,10 +798,38 @@ def get_deployment(self, deployment_id: str) -> JsonObject: assert result.exit_code == 75, result.stderr error = _json_envelope(result)["error"] assert error["code"] == "deploy_watch_lost" - assert "comfy deploy status --deployment dep-status --watch" in error["hint"] + assert "comfy deploy show --deployment dep-status" in error["hint"] assert len(client.get_calls) == 7 +def test_a_watch_refused_with_the_sign_in_still_stored_ends_as_watch_auth_lost(tmp_path, monkeypatch) -> None: + # Given a watch whose read is refused after the client's refresh and retry + class Refused(RecordingDeploy): + sign_in_base_url = "https://cloud.comfy.org" + + def get_deployment(self, deployment_id: str) -> JsonObject: + self.get_calls.append(deployment_id) + raise DeployAPIError("deploy_not_signed_in", "invalid auth token", status=401) + + client = Refused([_status_deployment(status="provisioning")]) + sleeps: list[float] = [] + _install_clients(monkeypatch, FakeBuilder(), client, sleeps) + stored = SimpleNamespace(access_token="token", refresh_token="rt", base_url="https://cloud.comfy.org") + monkeypatch.setattr("comfy_cli.credentials.get_session", lambda **_: stored) + + # When + result = _invoke_json(write_spec(tmp_path), "--watch") + + # Then + assert result.exit_code == 75, result.stderr + error = _json_envelope(result)["error"] + assert error["code"] == "watch_auth_lost" + assert "comfy deploy show --deployment dep-status" in error["hint"] + assert "comfy cloud login" not in error["hint"] + assert client.get_calls == ["dep-status"] + assert sleeps == [] + + def test_a_watch_that_gives_up_takes_the_live_line_down_before_the_error_prints(tmp_path, monkeypatch) -> None: """An error printed while the live line is up lands under a spinner that is still turning.""" # Given a watch that draws its line, then never hears back. CliRunner's diff --git a/tests/comfy_cli/command/test_deploy_ui.py b/tests/comfy_cli/command/test_deploy_ui.py new file mode 100644 index 000000000..5a719de4f --- /dev/null +++ b/tests/comfy_cli/command/test_deploy_ui.py @@ -0,0 +1,210 @@ +from __future__ import annotations + +import importlib +import json +from pathlib import Path + +import jsonschema +import pytest +from typer.testing import CliRunner + +from comfy_cli.cmdline import app +from comfy_cli.comfy_client import Client, HTTPError +from comfy_cli.target import Target + +DEPLOYMENT_ID = "dep-12345678-1234-1234-1234-123456789abc" + + +@pytest.fixture +def editor(monkeypatch): + ui = importlib.import_module("comfy_cli.command.deploy_ui") + deployment = {"id": DEPLOYMENT_ID, "status": "ready", "releaseId": "release-1"} + listing = {"items": [{"deployment_id": DEPLOYMENT_ID, "release_id": "release-1", "status": "ready"}]} + state = {"workspace": {"id": "ws-1"}, "listing": listing, "deployment": deployment, "failure": None} + calls = [] + + class Deploy: + def get_deployment(self, deployment_id): + calls.append(("deploy", deployment_id)) + return state["deployment"] + + def list_all_deployments(self): + pytest.fail("explicit id must not list deployments") + + def get_deployment_logs(self, deployment_id): + pytest.fail("UI discovery must not fetch logs") + + def get_deployment_events(self, deployment_id): + pytest.fail("UI discovery must not fetch events") + + monkeypatch.setattr("comfy_cli.command.deploy_read._command_clients", lambda: (object(), Deploy())) + target = Target(kind="cloud", base_url="https://cloud.test/api", path_prefix="/api", auth_token="secret-token") + monkeypatch.setattr(ui, "resolve_target", lambda **kwargs: state.get("target", target)) + + def request(self, method, parts, **kwargs): + assert method == "GET" + calls.append((method, parts)) + if state["failure"] is not None: + raise state["failure"] + return state["workspace"] if parts == ("workspaces", "current") else state["listing"] + + monkeypatch.setattr(Client, "_request", request) + return state, calls + + +def invoke(): + result = CliRunner().invoke(app, ["--json", "deploy", "ui", "--deployment", DEPLOYMENT_ID]) + lines = [line for line in result.stdout.splitlines() if line.strip()] + return result, json.loads(lines[-1]) + + +def test_deploy_ui_returns_verified_workspace_target_release_link(editor): + state, calls = editor + result, envelope = invoke() + assert result.exit_code == 0, result.output + data = envelope["data"] + assert data == { + "workspaceId": "ws-1", + "deploymentId": DEPLOYMENT_ID, + "releaseId": "release-1", + "url": f"https://cloud.test/?workspace=ws-1&deployment={DEPLOYMENT_ID}", + } + assert envelope["changed"] is False + schema = Path(__file__).resolve().parents[3] / "comfy_cli/schemas/deploy_ui.json" + jsonschema.validate(data, json.loads(schema.read_text())) + assert calls == [ + ("deploy", DEPLOYMENT_ID), + ("GET", ("workspaces", "current")), + ("GET", ("workspaces", "ws-1", "deployments")), + ] + assert "secret-token" not in result.output + + +def test_deploy_ui_accepts_explicitly_enabled_editor(editor): + state, _ = editor + state["deployment"]["editor"] = True + result, envelope = invoke() + assert result.exit_code == 0, result.output + assert envelope["data"]["deploymentId"] == DEPLOYMENT_ID + assert envelope["changed"] is False + + +@pytest.mark.parametrize("enabled", [False, None, 0, "true", {}, []]) +def test_deploy_ui_refuses_explicitly_disabled_or_invalid_editor(editor, enabled): + state, calls = editor + state["deployment"]["editor"] = enabled + result, envelope = invoke() + assert result.exit_code == 1 + assert envelope["data"] is None + assert envelope["error"]["code"] == "deploy_ui_unavailable" + assert calls == [("deploy", DEPLOYMENT_ID)] + + +@pytest.mark.parametrize("status", ["stopped", "provisioning", "unhealthy", "failed"]) +def test_deploy_ui_refuses_nonready_control_record(editor, status): + state, calls = editor + state["deployment"]["status"] = status + result, envelope = invoke() + assert result.exit_code == 1 + assert envelope["data"] is None + assert envelope["error"]["code"] == "deploy_ui_unavailable" + assert calls == [("deploy", DEPLOYMENT_ID)] + + +@pytest.mark.parametrize( + "listing", + [ + None, + {}, + {"items": []}, + {"items": [None]}, + {"items": [{"deployment_id": DEPLOYMENT_ID, "release_id": "release-other", "status": "ready"}]}, + {"items": [{"deployment_id": DEPLOYMENT_ID, "release_id": "release-1", "status": "stopped"}]}, + ], +) +def test_deploy_ui_refuses_unverified_listing(editor, listing): + state, _ = editor + state["listing"] = listing + result, envelope = invoke() + assert result.exit_code == 1 + assert envelope["data"] is None + assert envelope["error"]["code"] == "deploy_ui_unavailable" + + +@pytest.mark.parametrize("status", [401, 403, 404, 503]) +def test_deploy_ui_reports_cloud_refusal_without_guessing_a_url(editor, status): + state, _ = editor + state["failure"] = HTTPError(status, "refused", "Bearer secret-token") + result, envelope = invoke() + assert result.exit_code == 1 + assert envelope["data"] is None + assert envelope["error"]["code"] == "deploy_ui_unavailable" + assert envelope["error"]["details"]["status"] == status + assert "secret-token" not in result.output + + +def test_deploy_ui_requires_session_instead_of_api_key(editor): + state, calls = editor + state["target"] = Target(kind="cloud", base_url="https://cloud.test", api_key="comfyui-secret") + result, envelope = invoke() + assert result.exit_code == 1 + assert envelope["error"]["code"] == "deploy_ui_unavailable" + assert "comfy cloud login" in envelope["error"]["hint"] + assert not any(method == "GET" for method, _ in calls) + + +def test_deploy_ui_refuses_mismatching_control_id(editor): + state, _ = editor + state["deployment"]["id"] = "dep-other" + result, envelope = invoke() + assert result.exit_code == 1 + assert envelope["data"] is None + + +def test_deploy_ui_refuses_workspace_path_injection(editor): + state, _ = editor + state["workspace"] = {"id": "ws-1/../other"} + result, envelope = invoke() + assert result.exit_code == 1 + assert envelope["data"] is None + + +def test_deploy_ui_is_registered_as_a_read_only_command(): + result = CliRunner().invoke(app, ["deploy", "ui", "--help"]) + assert result.exit_code == 0, result.output + assert "read-only" in result.output.lower() + + +def test_editor_reads_use_authenticated_bounded_cloud_transport(monkeypatch): + import io + + from comfy_cli import comfy_client + + requests = [] + + class Response(io.BytesIO): + status = 200 + + def open_request(request, timeout): + requests.append(request) + return Response(b'{"id":"ws-1","items":[]}') + + monkeypatch.setattr(comfy_client._OPENER, "open", open_request) + client = Client(Target(kind="cloud", base_url="https://cloud.test", path_prefix="/api", auth_token="test-token")) + assert client.get_current_workspace()["id"] == "ws-1" + assert client.list_workspace_deployments("ws/one")["items"] == [] + assert [request.full_url for request in requests] == [ + "https://cloud.test/api/workspaces/current", + "https://cloud.test/api/workspaces/ws%2Fone/deployments", + ] + assert all(request.get_method() == "GET" for request in requests) + assert all(request.get_header("Authorization") == "Bearer test-token" for request in requests) + + +def test_deploy_ui_reports_recognized_backend_session_refusal(editor): + state, _ = editor + reason = "listing deployments needs a signed-in session, not an API key" + state["failure"] = HTTPError(403, "refused", json.dumps({"code": "FORBIDDEN", "message": reason})) + result, envelope = invoke() + assert result.exit_code == 1 + assert reason in envelope["error"]["message"] diff --git a/tests/comfy_cli/command/test_deploy_up.py b/tests/comfy_cli/command/test_deploy_up.py index d10e6927d..55a29aa2e 100644 --- a/tests/comfy_cli/command/test_deploy_up.py +++ b/tests/comfy_cli/command/test_deploy_up.py @@ -10,7 +10,7 @@ from concurrent.futures import ThreadPoolExecutor from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from pathlib import Path -from types import ModuleType +from types import ModuleType, SimpleNamespace import jsonschema import pytest @@ -788,7 +788,10 @@ def test_a_deploy_api_that_stays_down_ends_the_watch_with_its_own_exit_code(tmp_ error = _json_envelope(result)["error"] assert error["code"] == "deploy_watch_lost" assert "may still be coming up" in error["message"] - assert error["hint"] == "run `comfy deploy status --deployment dep-1 --watch` to watch it again" + assert error["hint"] == ( + "run `comfy deploy show --deployment dep-1` to inspect it; watching requires " + "`comfy deploy status --deployment dep-1 --watch` with this Build's spec" + ) assert error["details"]["deployment_id"] == "dep-1" assert result.stderr.count("deploy API is not answering") == 1 assert sleeps == [2.0, 4.0, 8.0, 15.0, 15.0, 15.0] @@ -814,6 +817,94 @@ def test_a_4xx_on_the_follow_read_still_fails_at_once(tmp_path, monkeypatch) -> assert client.get_calls == 2 +_CLOUD = "https://cloud.comfy.org" + + +def _refused() -> DeployAPIError: + # What the client raises once a 401 outlives its forced refresh and its one retry. + return DeployAPIError( + "deploy_not_signed_in", + "invalid auth token", + status=401, + details={"operation": "get", "status": 401, "server_code": "UNAUTHORIZED"}, + ) + + +def _stored_sign_in(monkeypatch, base_url: str | None) -> None: + session = ( + SimpleNamespace(access_token="token", refresh_token="rt", base_url=base_url) if base_url is not None else None + ) + monkeypatch.setattr("comfy_cli.credentials.get_session", lambda **_: session) + + +def test_a_401_on_the_follow_read_with_the_sign_in_still_stored_ends_the_watch_not_the_deployment( + tmp_path, monkeypatch +) -> None: + """Parallel watches can each be refused after the shared refresh. The deployment + was accepted with that same sign-in and keeps coming up, so the envelope must + not send an agent to sign in, nor report a failure that did not happen.""" + # Given a deployment the service accepted, then a follow read it refuses + client = FlakyFollow([_refused()], get_statuses=["queued", "ready"]) + client.sign_in_base_url = _CLOUD # type: ignore[attr-defined] + _stored_sign_in(monkeypatch, _CLOUD) + sleeps: list[float] = [] + + # When + result = _invoke_watched_up(tmp_path, monkeypatch, client, sleeps) + + # Then + assert result.exit_code == 75, result.stderr + error = _json_envelope(result)["error"] + assert error["code"] == "watch_auth_lost" + assert "may still be coming up" in error["message"] + assert error["hint"].startswith("run `comfy deploy show --deployment dep-1` to inspect it") + assert "deploy status --deployment dep-1 --watch" in error["hint"] + assert "comfy cloud login" not in error["hint"] + assert error["details"] == {"deployment_id": "dep-1"} + assert sleeps == [] + assert len(client.create_keys) == 1 + + +@pytest.mark.parametrize( + ("client_sign_in", "stored_sign_in"), + [(_CLOUD, None), (_CLOUD, "https://staging.comfy.test"), (None, _CLOUD)], + ids=["refresh_signed_the_user_out", "signed_in_to_another_environment", "workspace_key"], +) +def test_a_401_on_the_follow_read_with_no_sign_in_to_keep_still_says_to_sign_in( + tmp_path, monkeypatch, client_sign_in, stored_sign_in +) -> None: + # Given a follow read refused, and no sign-in this watch's client could keep using + client = FlakyFollow([_refused()], get_statuses=["queued", "ready"]) + client.sign_in_base_url = client_sign_in # type: ignore[attr-defined] + _stored_sign_in(monkeypatch, stored_sign_in) + + # When + result = _invoke_watched_up(tmp_path, monkeypatch, client, []) + + # Then + assert result.exit_code == 1 + assert _json_envelope(result)["error"]["code"] == "deploy_not_signed_in" + + +class _RefusesTheCreate(FakeDeploy): + def create_deployment(self, release_id: str, compute_config: JsonObject, **kwargs) -> JsonObject: + raise _refused() + + +def test_a_401_on_the_create_keeps_the_sign_in_code(tmp_path, monkeypatch) -> None: + # Given a sign-in still stored, and a service that refuses the create itself + client = _RefusesTheCreate() + client.sign_in_base_url = _CLOUD # type: ignore[attr-defined] + _stored_sign_in(monkeypatch, _CLOUD) + + # When + result = _invoke_watched_up(tmp_path, monkeypatch, client, []) + + # Then nothing was accepted, so nothing runs on, and the refusal is the sign-in's + assert result.exit_code == 1 + assert _json_envelope(result)["error"]["code"] == "deploy_not_signed_in" + + def test_a_second_outage_in_one_watch_is_announced_and_backed_off_afresh(tmp_path, monkeypatch) -> None: """A read that is answered ends the outage, so the next one is new: it is announced again and gets the whole retry schedule, not what was left of the first.""" diff --git a/tests/comfy_cli/command/test_deploy_up_move.py b/tests/comfy_cli/command/test_deploy_up_move.py index c07ec1a97..6ffdce38b 100644 --- a/tests/comfy_cli/command/test_deploy_up_move.py +++ b/tests/comfy_cli/command/test_deploy_up_move.py @@ -292,7 +292,7 @@ def test_up_will_not_move_a_deployment_that_is_stopping_or_failed_to_stop(tmp_pa error = _envelope(result)["error"] assert result.exit_code == 1 assert error["code"] == "deploy_conflict" - assert "comfy deploy status --deployment dep-1" in error["hint"] + assert "comfy deploy show --deployment dep-1" in error["hint"] assert client.move_calls == [] and client.start_calls == [] @@ -667,7 +667,7 @@ def test_a_newer_update_while_one_waits_exits_1_as_replaced(tmp_path, monkeypatc "replacing_release_id": "release-3", } assert error["message"] == "the update of deployment dep-1 to release v5 was replaced by an update to release v3" - assert "comfy deploy status --deployment dep-1" in error["hint"] + assert "comfy deploy show --deployment dep-1" in error["hint"] @pytest.mark.parametrize( diff --git a/tests/comfy_cli/command/test_manager_gui.py b/tests/comfy_cli/command/test_manager_gui.py index a84532090..1ed8e2403 100644 --- a/tests/comfy_cli/command/test_manager_gui.py +++ b/tests/comfy_cli/command/test_manager_gui.py @@ -834,11 +834,12 @@ def test_fill_print_table_disable_mode(self, mock_resolve, mock_workspace_config result = ws.fill_print_table() - assert len(result) == 3 + assert len(result) == 4 assert result[0][0] == "Current selected workspace" assert result[1][0] == "Manager" assert "Disabled" in result[1][1] assert result[2][0] == "UV Compile Default" + assert result[3] == ("Warning", "Workspace directory does not exist: /fake/workspace") @patch("comfy_cli.command.custom_nodes.cm_cli_util.resolve_manager_gui_mode", return_value="enable-gui") def test_fill_print_table_enable_gui_mode(self, mock_resolve, mock_workspace_config_manager): @@ -1056,9 +1057,19 @@ def test_fill_data_keeps_existing_fields(self): with self._env(configured_mode=None, has_cm_cli=True, has_legacy_clone=False) as ws: data = ws.fill_data() - assert set(data) == {"path", "type", "manager_mode", "manager_detected", "uv_compile_default"} + assert set(data) == { + "path", + "type", + "manager_mode", + "manager_detected", + "uv_compile_default", + "exists", + "warnings", + } assert data["path"] == "/fake/workspace" assert data["uv_compile_default"] is False + assert data["exists"] is False + assert data["warnings"][0]["code"] == "workspace_not_found" def test_fill_print_table_reports_legacy_clone(self): """The table view matches the JSON view for the legacy-clone case.""" diff --git a/tests/comfy_cli/command/test_model_download_background.py b/tests/comfy_cli/command/test_model_download_background.py index 91294f678..f51684482 100644 --- a/tests/comfy_cli/command/test_model_download_background.py +++ b/tests/comfy_cli/command/test_model_download_background.py @@ -4336,8 +4336,12 @@ def test_cancel_reclaims_the_part_of_an_already_failed_record(self, workspace, j ) download_state.write(workspace, state) - with patch.object(download_state, "is_worker_process", return_value=False): + # This legacy record has no creation time, so worker_alive first asks + # the OS whether its PID exists. Model the killed worker explicitly; + # an unrelated real process may currently hold this fixed test PID. + with patch("comfy_cli.utils.is_running", return_value=False) as pid_alive: models.download_cancel(None, download_id=state.id) + pid_alive.assert_called_once_with(5150) assert not part.exists(), "a terminal record's orphaned partial is still the user's disk" env = json_renderer() diff --git a/tests/comfy_cli/command/test_model_upload.py b/tests/comfy_cli/command/test_model_upload.py new file mode 100644 index 000000000..3463da017 --- /dev/null +++ b/tests/comfy_cli/command/test_model_upload.py @@ -0,0 +1,436 @@ +"""Cloud model uploads enforce target, bytes and explicit named-file approval.""" + +import hashlib +import inspect +import json +import urllib.error +import urllib.parse +from unittest.mock import Mock + +import blake3 +import pytest +import typer +from click import unstyle +from typer.testing import CliRunner + +from comfy_cli.target import Target + + +def test_model_upload_is_a_discoverable_command(): + from comfy_cli.command.models.models import app + + result = CliRunner().invoke(app, ["upload", "--help"]) + assert result.exit_code == 0, result.output + help_text = unstyle(result.output) + assert "--dry-run" in help_text + assert "--expected-sha256" in help_text + + +def setup_upload(tmp_path, monkeypatch, *, flags=None, current="ws-approved", rows=None): + from comfy_cli.command.models import upload + + path = tmp_path / "private.safetensors" + path.write_bytes(b"synthetic-approved-model") + renderer = Mock() + renderer.is_pretty.return_value = False + target = Target("cloud", "https://cloud.example.test", "/api", auth_token="test-secret") + reads = [] + + def read(url, target, *, max_bytes, **kwargs): + reads.append(url) + if url.endswith("/workspaces/current"): + return 200, {"id": current, "name": "Test Workspace"} + if url.endswith("/features"): + return 200, flags if flags is not None else {"private_models_enabled": True} + if url.endswith("/experiment/models"): + return 200, [{"name": "loras"}, {"name": "checkpoints"}] + return 200, {"assets": rows or [], "has_more": False} + + sent = [] + + def send(request, **kwargs): + chunks = b"".join(request.data) + sent.append(chunks) + body = { + "id": "asset-test", + "name": path.name, + "tags": ["models", "loras"], + "hash": "blake3:" + blake3.blake3(path.read_bytes()).hexdigest(), + "loader_path": path.name, + "created_new": True, + } + result = Mock() + result.status = 201 + result.read.side_effect = [json.dumps(body).encode(), b""] + result.__enter__ = Mock(return_value=result) + result.__exit__ = Mock(return_value=False) + return result + + monkeypatch.setattr(upload, "get_renderer", lambda: renderer) + monkeypatch.setattr(upload, "cloud_target_or_local_error", lambda *a: target) + monkeypatch.setattr(upload, "request_json", read) + monkeypatch.setattr(upload, "no_redirect_urlopen", send) + return upload, path, renderer, reads, sent + + +def run_case(module, path, **changes): + options = dict( + model_type="loras", + workspace="ws-approved", + dry_run=False, + yes=True, + expected_sha256=hashlib.sha256(path.read_bytes()).hexdigest(), + name=None, + where="cloud", + ) + options.update(changes) + return inspect.unwrap(module.upload_cmd)(path, **options) + + +def test_plan_never_uploads_and_names_exact_bytes_and_target(tmp_path, monkeypatch): + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch) + run_case(m, p, dry_run=True, yes=False, expected_sha256=None) + assert sent == [] + plan = r.emit.call_args.args[0] + assert plan["sha256"] == hashlib.sha256(p.read_bytes()).hexdigest() + assert plan["workspace_id"] == "ws-approved" + assert plan["destination"].endswith("/api/assets") + assert plan["size_bytes"] == p.stat().st_size + assert plan["uploaded"] is False + + +@pytest.mark.parametrize( + "changes", + [ + {"yes": False}, + {"expected_sha256": None}, + {"expected_sha256": "0" * 64}, + {"workspace": "ws-other"}, + {"model_type": "unsupported"}, + ], +) +def test_missing_or_changed_approval_cannot_upload(tmp_path, monkeypatch, changes): + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch) + with pytest.raises(typer.Exit): + run_case(m, p, **changes) + assert sent == [] + r.error.assert_called_once() + + +@pytest.mark.parametrize("flags", [{}, {"private_models_enabled": False}, {"private_models_enabled": "true"}]) +def test_capability_must_be_explicitly_enabled(tmp_path, monkeypatch, flags): + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch, flags=flags) + with pytest.raises(typer.Exit): + run_case(m, p) + assert sent == [] + + +def test_approved_upload_streams_exact_file_and_model_tags(tmp_path, monkeypatch): + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch) + run_case(m, p) + assert len(sent) == 1 + assert p.read_bytes() in sent[0] + assert b'["models", "loras"]' in sent[0] + assert r.emit.call_args.args[0]["loader_path"] == p.name + assert r.emit.call_args.args[0]["uploaded"] is True + + +@pytest.mark.parametrize("hash_value", ["blake3:" + "0" * 64, None, "unverified"]) +def test_same_name_different_or_unverified_cloud_bytes_requires_new_name(tmp_path, monkeypatch, hash_value): + m, p, r, reads, sent = setup_upload( + tmp_path, monkeypatch, rows=[{"name": "private.safetensors", "hash": hash_value}] + ) + with pytest.raises(typer.Exit): + run_case(m, p) + assert sent == [] + + +def test_mutation_after_snapshot_cannot_change_uploaded_bytes(tmp_path, monkeypatch): + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch) + original = p.read_bytes() + original_send = m.no_redirect_urlopen + + def mutate_then_send(request, **kwargs): + p.write_bytes(b"UNAPPROVED CHANGED CONTENT") + # The mock response must describe the bytes actually sent, not the changed source. + result = original_send(request, **kwargs) + body = { + "id": "asset-test", + "name": p.name, + "tags": ["models", "loras"], + "hash": "blake3:" + blake3.blake3(original).hexdigest(), + "loader_path": p.name, + "created_new": True, + } + result.read.side_effect = [json.dumps(body).encode(), b""] + return result + + monkeypatch.setattr(m, "no_redirect_urlopen", mutate_then_send) + run_case(m, p, expected_sha256=hashlib.sha256(original).hexdigest()) + assert original in sent[0] + assert p.read_bytes() not in sent[0] + + +def test_legacy_cloud_hash_filename_and_loader_name_are_verified(tmp_path, monkeypatch): + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch) + send = m.no_redirect_urlopen + + def legacy_response(request, **kwargs): + response = send(request, **kwargs) + body = json.loads(response.read()) + body["hash"] = body["hash"].removeprefix("blake3:") + ".safetensors" + body.pop("loader_path") + response.read.side_effect = [json.dumps(body).encode(), b""] + return response + + monkeypatch.setattr(m, "no_redirect_urlopen", legacy_response) + run_case(m, p) + assert r.emit.call_args.args[0]["loader_path"] == p.name + r.error.assert_not_called() + + +def test_different_model_folder_cannot_be_reported_as_requested_import(tmp_path, monkeypatch): + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch) + send = m.no_redirect_urlopen + + def wrong_folder(request, **kwargs): + response = send(request, **kwargs) + body = json.loads(response.read()) + body["tags"] = ["models", "checkpoints"] + response.read.side_effect = [json.dumps(body).encode(), b""] + return response + + monkeypatch.setattr(m, "no_redirect_urlopen", wrong_folder) + with pytest.raises(typer.Exit): + run_case(m, p) + assert r.error.call_args.kwargs["details"]["uploaded"] is True + + +def test_identical_workspace_owned_asset_is_reused_without_uploading_bytes(tmp_path, monkeypatch): + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch) + digest = "blake3:" + blake3.blake3(p.read_bytes()).hexdigest() + read = m.request_json + operations = [] + + def existing_asset(url, target, **kwargs): + operations.append((url, kwargs.get("method", "GET"))) + if "/assets?" in url: + return 200, {"assets": [{"id": "asset-existing", "name": p.name, "hash": digest}], "has_more": False} + if url.endswith("/assets/from-hash"): + assert kwargs["body"] == {"hash": digest, "tags": ["models", "loras"]} + return 200, { + "id": "asset-existing", + "name": p.name, + "hash": digest, + "tags": ["models", "loras"], + "loader_path": p.name, + "created_new": False, + } + return read(url, target, **kwargs) + + monkeypatch.setattr(m, "request_json", existing_asset) + run_case(m, p) + assert sent == [] + assert r.emit.call_args.args[0]["deduped"] is True + assert r.emit.call_args.args[0]["uploaded"] is False + assert any(url.endswith("/assets/from-hash") and method == "POST" for url, method in operations) + assert any("include_public=false" in url for url, _ in operations) + + +def test_public_only_identical_asset_uploads_approved_snapshot(tmp_path, monkeypatch): + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch) + approved = p.read_bytes() + digest = "blake3:" + blake3.blake3(approved).hexdigest() + read = m.request_json + operations = [] + + def public_only_asset(url, target, **kwargs): + operations.append((url, kwargs.get("method", "GET"))) + if "/assets?" in url: + query = urllib.parse.parse_qs(urllib.parse.urlsplit(url).query) + rows = [{"id": "public-asset", "name": p.name, "hash": digest}] + return 200, {"assets": rows if query["include_public"] == ["true"] else [], "has_more": False} + if url.endswith("/assets/from-hash"): + # Cloud's ownership preflight excludes public assets and refuses + # an unowned digest even though the bytes are publicly accessible. + raise urllib.error.HTTPError(url, 404, "ASSET_NOT_FOUND", {}, None) + return read(url, target, **kwargs) + + monkeypatch.setattr(m, "request_json", public_only_asset) + run_case(m, p) + assert len(sent) == 1 + assert approved in sent[0] + assert b'["models", "loras"]' in sent[0] + result = r.emit.call_args.args[0] + assert result["uploaded"] is True + assert result["deduped"] is False + assert result["sha256"] == hashlib.sha256(approved).hexdigest() + assert result["workspace_id"] == "ws-approved" + assert result["loader_path"] == p.name + assert not any(url.endswith("/assets/from-hash") for url, _ in operations) + r.error.assert_not_called() + + +@pytest.mark.parametrize( + "owned_listing", + [{}, {"assets": [], "has_more": True}, {"assets": [], "has_more": None}, {"assets": [None], "has_more": False}], +) +def test_unverified_workspace_ownership_cannot_dedup_or_upload(tmp_path, monkeypatch, owned_listing): + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch) + digest = "blake3:" + blake3.blake3(p.read_bytes()).hexdigest() + read = m.request_json + operations = [] + + def unverified_ownership(url, target, **kwargs): + operations.append((url, kwargs.get("method", "GET"))) + if "/assets?" in url: + query = urllib.parse.parse_qs(urllib.parse.urlsplit(url).query) + if query["include_public"] == ["false"]: + return 200, owned_listing + return 200, {"assets": [{"id": "visible-asset", "name": p.name, "hash": digest}], "has_more": False} + if url.endswith("/assets/from-hash"): + return 200, {"id": "unexpected-dedup", "hash": digest, "tags": ["models", "loras"], "loader_path": p.name} + return read(url, target, **kwargs) + + monkeypatch.setattr(m, "request_json", unverified_ownership) + with pytest.raises(typer.Exit): + run_case(m, p) + assert sent == [] + assert not any(method == "POST" for _, method in operations) + r.emit.assert_not_called() + assert r.error.call_args.kwargs["details"]["reason"] == "ownership_unverified" + + +@pytest.mark.parametrize("mode", ["bad_json", "oversize", "wrong_hash"]) +def test_unverifiable_upload_response_never_reports_success(tmp_path, monkeypatch, mode): + from comfy_cli.http import ResponseTooLarge + + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch) + send = m.no_redirect_urlopen + + def bad_response(request, **kwargs): + response = send(request, **kwargs) + if mode == "bad_json": + response.read.side_effect = [b"error", b""] + elif mode == "oversize": + response.read.side_effect = ResponseTooLarge("response too large") + else: + body = json.loads(response.read()) + body["hash"] = "blake3:" + "0" * 64 + response.read.side_effect = [json.dumps(body).encode(), b""] + return response + + monkeypatch.setattr(m, "no_redirect_urlopen", bad_response) + with pytest.raises(typer.Exit): + run_case(m, p) + r.emit.assert_not_called() + r.error.assert_called_once() + + +@pytest.mark.parametrize("public_match", [False, True]) +def test_actual_http_transport_streams_approved_snapshot_with_exact_length(tmp_path, monkeypatch, public_match): + import http.server + import threading + + from comfy_cli.command.models import upload + + source = tmp_path / "transport-model.safetensors" + source.write_bytes(b"APPROVED-MODEL-BYTES" * 65536) + approved = source.read_bytes() + observed = [] + + class Handler(http.server.BaseHTTPRequestHandler): + def log_message(self, *args): + pass + + def answer(self, payload): + encoded = json.dumps(payload).encode() + self.send_response(200) + self.send_header("Content-Type", "application/json") + self.send_header("Content-Length", str(len(encoded))) + self.end_headers() + self.wfile.write(encoded) + + def do_GET(self): + if self.path.endswith("/workspaces/current"): + self.answer({"id": "ws-approved", "name": "Test"}) + elif self.path.endswith("/features"): + self.answer({"private_models_enabled": True}) + elif self.path.endswith("/experiment/models"): + self.answer([{"name": "loras"}]) + else: + query = urllib.parse.parse_qs(urllib.parse.urlsplit(self.path).query) + rows = [] + if public_match and query.get("include_public") == ["true"]: + rows = [ + { + "id": "public-only", + "name": source.name, + "hash": "blake3:" + blake3.blake3(approved).hexdigest(), + } + ] + self.answer({"assets": rows, "has_more": False}) + + def do_POST(self): + assert self.path == "/api/assets" + source.write_bytes(b"CHANGED-AFTER-CLIENT-SNAPSHOT") + body = self.rfile.read(int(self.headers["Content-Length"])) + observed.append((body, self.headers["Authorization"], self.headers["Content-Length"])) + self.answer( + { + "id": "asset-transport", + "name": source.name, + "tags": ["models", "loras"], + "hash": "blake3:" + blake3.blake3(approved).hexdigest(), + "loader_path": source.name, + "created_new": True, + } + ) + + server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler) + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + renderer = Mock() + renderer.is_pretty.return_value = False + target = Target("cloud", f"http://127.0.0.1:{server.server_port}", "/api", auth_token="test-token") + monkeypatch.setattr(upload, "cloud_target_or_local_error", lambda *args: target) + monkeypatch.setattr(upload, "get_renderer", lambda: renderer) + try: + run_case(upload, source, expected_sha256=hashlib.sha256(approved).hexdigest()) + finally: + server.shutdown() + server.server_close() + thread.join(timeout=5) + assert len(observed) == 1 + body, credential, length = observed[0] + assert credential == "Bearer test-token" + assert len(body) == int(length) + assert approved in body + assert source.read_bytes() not in body + renderer.error.assert_not_called() + + +@pytest.mark.parametrize("dry_run", [False, True], ids=["upload", "plan"]) +@pytest.mark.parametrize( + ("status", "rows"), + [(200, [None]), (200, ["malformed"]), (201, []), (503, [])], + ids=["null-row", "string-row", "non-ok-success", "non-ok-error"], +) +def test_unverified_public_collision_listing_never_plans_or_uploads(tmp_path, monkeypatch, dry_run, status, rows): + m, p, r, reads, sent = setup_upload(tmp_path, monkeypatch) + read = m.request_json + operations = [] + + def malformed_public_listing(url, target, **kwargs): + operations.append((url, kwargs.get("method", "GET"))) + if "/assets?" in url: + return status, {"assets": rows, "has_more": False} + return read(url, target, **kwargs) + + monkeypatch.setattr(m, "request_json", malformed_public_listing) + with pytest.raises(typer.Exit): + run_case(m, p, dry_run=dry_run) + assert sent == [] + assert not any(method == "POST" for _, method in operations) + r.emit.assert_not_called() + assert r.error.call_args.kwargs["details"]["reason"] == "collision_unverified" diff --git a/tests/comfy_cli/command/test_pretty_print_sanitize.py b/tests/comfy_cli/command/test_pretty_print_sanitize.py index ed8f70792..5baba29a4 100644 --- a/tests/comfy_cli/command/test_pretty_print_sanitize.py +++ b/tests/comfy_cli/command/test_pretty_print_sanitize.py @@ -708,7 +708,8 @@ def test_status_glyph_keeps_its_own_tags_live(pretty): from comfy_cli.output.glyphs import status_glyph - console = Console(file=pretty, force_terminal=True, width=80) + # This tests authored styling, independently of the caller's terminal type. + console = Console(file=pretty, force_terminal=True, width=80, _environ={"TERM": "xterm-256color"}) console.print(status_glyph("success")) out = pretty.getvalue() @@ -764,6 +765,34 @@ def test_local_workflow_list_table_is_inert(pretty): assert "boom" in assert_inert(pretty) +def test_cloud_workflow_save_receipt_names_the_sidebar_and_is_inert(pretty, tmp_path): + """`comfy workflow save --where cloud` prints the sidebar entry it wrote and + the record id Cloud returned, which is server-supplied; a warning is printed + too, since pretty mode drops `data.warnings`.""" + from comfy_cli.command import workflow + + src = tmp_path / "wf.json" + src.write_text(json.dumps({"nodes": [], "links": []})) + record = {"id": EVIL, "name": "flux", "latest_version": 1} + target = MagicMock() + target.url.side_effect = lambda *parts: "https://cloud.example/api/" + "/".join(parts) + + def _fake_http(url, _target, *, method="GET", body=None): + if method == "POST": + return (200, {"size": 2}) + if url.endswith("/content"): + return (200, {"workflow_json": {"nodes": [], "links": []}}) + return (200, {"data": [record]}) + + with patch.object(workflow, "_http_request", side_effect=_fake_http): + workflow._cloud_save(get_renderer(), target, str(src), "flux", "a note") + out = assert_inert(pretty) + assert "Cloud Workflows sidebar" in out + assert "workflows/flux.json" in out + assert "boom" in out + assert "--description is ignored" in out + + def test_cloud_workflow_list_table_is_inert(pretty): """The cloud saved-workflow catalog reaches the same sink.""" from comfy_cli.command import workflow diff --git a/tests/comfy_cli/command/test_preview_bundled_regression.py b/tests/comfy_cli/command/test_preview_bundled_regression.py new file mode 100644 index 000000000..dd2d8c95c --- /dev/null +++ b/tests/comfy_cli/command/test_preview_bundled_regression.py @@ -0,0 +1,32 @@ +"""Successful bundled rendering must emit one successful result, without an error.""" + +import inspect +import subprocess +from unittest.mock import Mock + +from comfy_cli._safe_exec import BinaryNotFoundError, BinaryRefusal +from comfy_cli.command import preview + + +def test_bundled_ffmpeg_without_ffprobe_does_not_emit_false_untrusted_error(tmp_path, monkeypatch): + source = tmp_path / "clip.mp4" + source.write_bytes(b"fixture") + output = tmp_path / "contact-sheet.png" + renderer = Mock() + renderer.is_pretty.return_value = False + + def unavailable(name): + raise BinaryNotFoundError(f"{name} absent", binary=name, reason=BinaryRefusal.ABSENT) + + def render(argv, **kwargs): + output.write_bytes(b"PNG") + return subprocess.CompletedProcess(argv, 0, stdout="", stderr="") + + monkeypatch.setattr(preview, "get_renderer", lambda: renderer) + monkeypatch.setattr(preview, "resolve_required_binary", unavailable) + monkeypatch.setattr(preview, "_bundled_ffmpeg", lambda: "/trusted/bundled/ffmpeg") + monkeypatch.setattr(preview.subprocess, "run", render) + inspect.unwrap(preview.preview_cmd)(source, out=output) + assert output.is_file() + assert renderer.emit.call_args.args[0]["preview"] == str(output) + renderer.error.assert_not_called() diff --git a/tests/comfy_cli/command/test_run.py b/tests/comfy_cli/command/test_run.py index 9731c0233..3af335823 100644 --- a/tests/comfy_cli/command/test_run.py +++ b/tests/comfy_cli/command/test_run.py @@ -2363,14 +2363,29 @@ def test_markup_in_node_name_does_not_crash_confirm(self, monkeypatch): class TestExecuteUiWorkflow: + @pytest.fixture(autouse=True) + def local_preflight_catalog(self, monkeypatch): + """Validate against the complete conversion fixture without a live server.""" + from copy import deepcopy + + monkeypatch.setattr("comfy_cli.command.run._fetch_object_info", lambda *a, **k: deepcopy(self.OBJECT_INFO)) + + def unexpected_catalog_request(*args, **kwargs): + pytest.fail("unexpected real catalog request; mock the specific object_info transport") + + monkeypatch.setattr("comfy_cli.http._PLAIN_OPENER.open", unexpected_catalog_request) + monkeypatch.setattr("comfy_cli.cql.engine._load_from_target", unexpected_catalog_request) + + # The conversion success fixture must also be an executable graph: + # PreviewImage consumes IMAGE, not an EmptyLatentImage's LATENT output. UI = { "nodes": [ { "id": 1, - "type": "EmptyLatentImage", + "type": "EmptyImage", "inputs": [], - "outputs": [{"name": "LATENT", "type": "LATENT", "links": [10]}], - "widgets_values": [512, 512, 1], + "outputs": [{"name": "IMAGE", "type": "IMAGE", "links": [10]}], + "widgets_values": [512, 512, 1, 0], "mode": 0, }, { @@ -2384,19 +2399,20 @@ class TestExecuteUiWorkflow: "links": [[10, 1, 0, 2, 0, "IMAGE"]], } OBJECT_INFO = { - "EmptyLatentImage": { + "EmptyImage": { "input": { "required": { "width": ["INT", {"default": 512}], "height": ["INT", {"default": 512}], "batch_size": ["INT", {"default": 1}], + "color": ["INT", {"default": 0}], } }, - "input_order": {"required": ["width", "height", "batch_size"]}, - "output": ["LATENT"], - "output_name": ["LATENT"], + "input_order": {"required": ["width", "height", "batch_size", "color"]}, + "output": ["IMAGE"], + "output_name": ["IMAGE"], "output_node": False, - "display_name": "Empty Latent Image", + "display_name": "Empty Image", }, "PreviewImage": { "input": {"required": {"images": ["IMAGE"]}}, @@ -2435,7 +2451,7 @@ def test_ui_workflow_is_converted_then_executed(self, ui_workflow_file): assert mock_fetch.call_args.args == ("127.0.0.1", 8188, 30) api_workflow = MockExec.call_args.args[0] assert set(api_workflow) == {"1", "2"} - assert api_workflow["1"]["class_type"] == "EmptyLatentImage" + assert api_workflow["1"]["class_type"] == "EmptyImage" assert api_workflow["2"]["inputs"]["images"] == ["1", 0] mock_exec.queue.assert_called_once() diff --git a/tests/comfy_cli/command/test_run_json.py b/tests/comfy_cli/command/test_run_json.py index a6ba3f478..41655cd51 100644 --- a/tests/comfy_cli/command/test_run_json.py +++ b/tests/comfy_cli/command/test_run_json.py @@ -52,13 +52,30 @@ def ndjson_renderer(): reset_renderer_for_testing() +@pytest.fixture(autouse=True) +def local_preflight_catalog(monkeypatch): + """Keep event/queue tests independent of any real server on localhost. + + Validation still runs against complete schemas. Tests for conversion HTTP + and deliberately invalid catalogs override their specific boundary below. + """ + from copy import deepcopy + + monkeypatch.setattr("comfy_cli.command.run._fetch_object_info", lambda *a, **k: deepcopy(OBJECT_INFO)) + + def unexpected_catalog_request(*args, **kwargs): + pytest.fail("unexpected real catalog request; mock the specific object_info transport") + + monkeypatch.setattr("comfy_cli.http._PLAIN_OPENER.open", unexpected_catalog_request) + + @pytest.fixture def simple_workflow(): return { "1": { - "class_type": "EmptyLatentImage", - "inputs": {"width": 64, "height": 64, "batch_size": 1}, - "_meta": {"title": "Latent"}, + "class_type": "EmptyImage", + "inputs": {"width": 64, "height": 64, "batch_size": 1, "color": 0}, + "_meta": {"title": "Image"}, }, "2": { "class_type": "SaveImage", @@ -524,8 +541,8 @@ def test_queued_nodes_manifest_from_workflow(self, workflow_file, capsys, simple nodes = queued["nodes"] assert len(nodes) == 2 by_id = {n["node_id"]: n for n in nodes} - assert by_id["1"]["class_type"] == "EmptyLatentImage" - assert by_id["1"]["title"] == "Latent" # _meta.title wins + assert by_id["1"]["class_type"] == "EmptyImage" + assert by_id["1"]["title"] == "Image" # _meta.title wins assert by_id["2"]["class_type"] == "SaveImage" assert by_id["2"]["title"] == "Save" @@ -621,7 +638,7 @@ def test_execution_error(self, workflow_file, capsys): "data": { "prompt_id": "p", "node_id": "1", - "node_type": "EmptyLatentImage", + "node_type": "EmptyImage", "exception_type": "RuntimeError", "exception_message": "boom", "traceback": [' File "x.py"\n', " raise RuntimeError\n"], @@ -635,12 +652,12 @@ def test_execution_error(self, workflow_file, capsys): assert any(e["type"] == "execution_error" for e in _events(lines)) env = _envelope(lines) assert env["error"]["code"] == "execution_error" - assert env["error"]["message"] == "EmptyLatentImage (node 1): boom" + assert env["error"]["message"] == "EmptyImage (node 1): boom" details = env["error"]["details"] assert details["node_id"] == "1" - assert details["class_type"] == "EmptyLatentImage" + assert details["class_type"] == "EmptyImage" assert details["exception_type"] == "RuntimeError" - assert details["title"] == "Latent" # from _meta.title + assert details["title"] == "Image" # from _meta.title # The envelope carries only the traceback tail; the full traceback # stays on the execution_error event. assert isinstance(details["traceback_tail"], list) @@ -658,7 +675,7 @@ def test_execution_error_node_id_coerced_to_str(self, workflow_file, capsys): "data": { "prompt_id": "p", "node_id": 7, - "node_type": "EmptyLatentImage", + "node_type": "EmptyImage", "exception_type": "RuntimeError", "exception_message": "boom", "traceback": [], @@ -797,8 +814,8 @@ def test_node_ids_coerced_to_str(self, simple_workflow, capsys): assert isinstance(ev["node"], str), f"{ev['type']} node is {type(ev['node']).__name__}" def test_title_falls_back_to_class_type(self): - ex = _make_workflow_execution({"1": {"class_type": "EmptyLatentImage", "inputs": {}}}) - assert ex.get_node_title("1") == "EmptyLatentImage" + ex = _make_workflow_execution({"1": {"class_type": "EmptyImage", "inputs": {}}}) + assert ex.get_node_title("1") == "EmptyImage" def test_title_falls_back_to_node_id_for_unknown(self): ex = _make_workflow_execution({}) @@ -809,10 +826,10 @@ def test_title_falls_back_to_node_id_for_unknown(self): "nodes": [ { "id": 1, - "type": "EmptyLatentImage", + "type": "EmptyImage", "inputs": [], - "outputs": [{"name": "LATENT", "type": "LATENT", "links": [10]}], - "widgets_values": [64, 64, 1], + "outputs": [{"name": "IMAGE", "type": "IMAGE", "links": [10]}], + "widgets_values": [64, 64, 1, 0], "mode": 0, }, { @@ -827,17 +844,26 @@ def test_title_falls_back_to_node_id_for_unknown(self): } OBJECT_INFO = { - "EmptyLatentImage": { + "EmptyImage": { "input": { "required": { "width": ["INT", {"default": 512}], "height": ["INT", {"default": 512}], "batch_size": ["INT", {"default": 1}], + "color": ["INT", {"default": 0}], } }, - "input_order": {"required": ["width", "height", "batch_size"]}, + "input_order": {"required": ["width", "height", "batch_size", "color"]}, + "output": ["IMAGE"], + "output_name": ["IMAGE"], "output_node": False, - "display_name": "Empty Latent Image", + "display_name": "Empty Image", + }, + "SaveImage": { + "input": {"required": {"filename_prefix": ["STRING", {"default": "ComfyUI"}], "images": ["IMAGE"]}}, + "input_order": {"required": ["filename_prefix", "images"]}, + "output": [], + "output_node": True, }, "PreviewImage": { "input": {"required": {"images": ["IMAGE"]}}, @@ -970,7 +996,7 @@ def test_api_input_emits_prompt_preview_before_queued(self, workflow_file, capsy assert types[0] == "prompt_preview" assert "queued" in types assert types.index("prompt_preview") < types.index("queued") - assert _events(lines)[0]["prompt"]["1"]["class_type"] == "EmptyLatentImage" + assert _events(lines)[0]["prompt"]["1"]["class_type"] == "EmptyImage" def test_ui_input_emits_converted_then_prompt_preview_then_queued(self, ui_workflow_file, capsys): with ( @@ -1035,7 +1061,7 @@ def test_api_input_emits_prompt_preview_and_envelope_only(self, workflow_file, c assert [e["type"] for e in _events(lines)] == ["prompt_preview"] preview = _events(lines)[0] assert preview["schema"] == "event/1" - assert preview["prompt"]["1"]["class_type"] == "EmptyLatentImage" + assert preview["prompt"]["1"]["class_type"] == "EmptyImage" env = _envelope(lines) assert env["ok"] is True assert env["data"]["status"] == "preview" @@ -1092,7 +1118,7 @@ def test_print_prompt_text_mode_pretty_prints_json(self, workflow_file, capsys): out, _err = capsys.readouterr() parsed = json.loads(out) assert "1" in parsed - assert parsed["1"]["class_type"] == "EmptyLatentImage" + assert parsed["1"]["class_type"] == "EmptyImage" def test_print_prompt_does_not_post_when_workflow_invalid(self, capsys): # Pre-flight failures (workflow_not_found, workflow_not_api_format) @@ -1240,10 +1266,10 @@ def test_execution_cached_event_shape(self, workflow_file, capsys): cached_events = [e for e in _events(lines) if e["type"] == "execution_cached"] assert len(cached_events) == 2 - # Node 1 has _meta.title="Latent"; class_type=EmptyLatentImage + # Node 1 has _meta.title="Image"; class_type=EmptyImage n1 = next(e for e in cached_events if e["node"] == "1") - assert n1["class_type"] == "EmptyLatentImage" - assert n1["title"] == "Latent" + assert n1["class_type"] == "EmptyImage" + assert n1["title"] == "Image" # Node 2 has _meta.title="Save"; class_type=SaveImage n2 = next(e for e in cached_events if e["node"] == "2") assert n2["class_type"] == "SaveImage" @@ -1380,9 +1406,9 @@ class TestErrorPathCoverage: def _make_workflow(self): return { "1": { - "class_type": "EmptyLatentImage", - "inputs": {"width": 64, "height": 64, "batch_size": 1}, - "_meta": {"title": "Latent"}, + "class_type": "EmptyImage", + "inputs": {"width": 64, "height": 64, "batch_size": 1, "color": 0}, + "_meta": {"title": "Image"}, }, "2": { "class_type": "SaveImage", @@ -1399,10 +1425,10 @@ def test_object_info_timeout_routes_to_connection_error(self, capsys): "nodes": [ { "id": 1, - "type": "EmptyLatentImage", + "type": "EmptyImage", "inputs": [], "outputs": [], - "widgets_values": [64, 64, 1], + "widgets_values": [64, 64, 1, 0], "mode": 0, } ], @@ -1414,7 +1440,7 @@ def test_object_info_timeout_routes_to_connection_error(self, capsys): try: with ( patch("comfy_cli.command.run.check_comfy_server_running", return_value=True), - patch("comfy_cli.http._AUTHED_OPENER.open", side_effect=TimeoutError("timed out")), + patch("comfy_cli.http._PLAIN_OPENER.open", side_effect=TimeoutError("timed out")), ): lines, exit_code = _run_execute_capture(path, capsys) assert _envelope(lines)["error"]["code"] == "connection_error" @@ -1427,10 +1453,10 @@ def test_object_info_non_json_body_routes_to_object_info_unavailable(self, capsy "nodes": [ { "id": 1, - "type": "EmptyLatentImage", + "type": "EmptyImage", "inputs": [], "outputs": [], - "widgets_values": [64, 64, 1], + "widgets_values": [64, 64, 1, 0], "mode": 0, } ], @@ -1876,7 +1902,7 @@ def test_api_workflow_async_stream_matches_documented_archetype( assert isinstance(queued["client_id"], str) and queued["client_id"] assert queued["validation_warnings"] == [] assert queued["nodes"] == [ - {"node_id": "1", "class_type": "EmptyLatentImage", "title": "Latent"}, + {"node_id": "1", "class_type": "EmptyImage", "title": "Image"}, {"node_id": "2", "class_type": "SaveImage", "title": "Save"}, ] assert queued["base_url"] == "https://api.comfy.org" @@ -3423,3 +3449,69 @@ def test_input_errors_in_skipped_branch_still_do_not_block(self, monkeypatch, tm ) assert exit_code == 0 assert len(client.submitted) == 1 + + +@pytest.mark.parametrize("skipped_kind", ["unknown-class", "unexecuted-model"]) +def test_targeted_private_model_resolution_preserves_full_graph_pre_submit_checks( + monkeypatch, tmp_path, capsys, skipped_kind +): + from comfy_cli import cloud_model_validation as cv + from comfy_cli.target import Target + + catalog = { + "Source": {"input": {"required": {}}, "output": ["MODEL"]}, + "LoraLoaderModelOnly": { + "input": { + "required": {"model": ["MODEL"], "lora_name": [["public.safetensors"]], "strength_model": ["FLOAT"]} + }, + "output": ["MODEL"], + }, + "Capture": {"input": {"required": {"model": ["MODEL"]}}, "output": [], "output_node": True}, + } + wf = { + "1": {"class_type": "Source", "inputs": {}}, + "2": { + "class_type": "LoraLoaderModelOnly", + "inputs": {"model": ["1", 0], "lora_name": "private.safetensors", "strength_model": 1.0}, + }, + "3": {"class_type": "Capture", "inputs": {"model": ["2", 0]}}, + "9": {"class_type": "NotInstalled", "inputs": {}} + if skipped_kind == "unknown-class" + else { + "class_type": "LoraLoaderModelOnly", + "inputs": {"model": ["1", 0], "lora_name": "unexecuted-private.safetensors", "strength_model": 1.0}, + }, + } + path = tmp_path / "targeted_private.json" + path.write_text(json.dumps(wf)) + client = _recording_client() + _install_cloud_stubs(monkeypatch, client_cls=client, object_info=catalog) + monkeypatch.delenv("COMFY_OBJECT_INFO_FILE", raising=False) + monkeypatch.setattr( + cv, + "resolve_target", + lambda **kwargs: Target(kind="cloud", base_url="https://cloud.test", auth_token="test-token"), + ) + reads = [] + + def assets(url, *args, **kwargs): + reads.append(url) + return 200, { + "has_more": False, + "assets": [{"id": "private", "name": "private.safetensors", "hash": "a" * 64, "tags": ["models", "loras"]}], + } + + monkeypatch.setattr(cv, "request_json", assets) + lines, exit_code = _cloud_capture(capsys, str(path), wait=False, timeout=5, output_node_ids=["3"]) + assert len(reads) == 1 and "name_contains=private.safetensors" in reads[0] + if skipped_kind == "unknown-class": + assert exit_code == 1 + assert client.submitted == [] + error = _envelope(lines)["error"] + assert error["code"] == "workflow_unknown_nodes" + assert [(item["node_id"], item["code"]) for item in error["details"]["errors"]] == [("9", "unknown_class_type")] + assert any(item["code"] == "cloud_model_asset_verified" for item in error["details"]["warnings"]) + else: + assert exit_code == 0 + assert len(client.submitted) == 1 + assert client.submitted[0][0] == wf diff --git a/tests/comfy_cli/command/test_run_prompt.py b/tests/comfy_cli/command/test_run_prompt.py index c67139558..da6f3c557 100644 --- a/tests/comfy_cli/command/test_run_prompt.py +++ b/tests/comfy_cli/command/test_run_prompt.py @@ -9,6 +9,8 @@ from __future__ import annotations +import json +from pathlib import Path from unittest.mock import MagicMock, patch import pytest @@ -32,11 +34,15 @@ class TestExecuteSubmitsPreloadedGraph: """`preloaded` short-circuits file loading; the in-memory graph is what reaches the submit path (WorkflowExecution).""" + @pytest.fixture(autouse=True) + def preloaded_catalog(self): + """Validate the injected graph against a frozen catalog, without a server.""" + catalog = json.loads((Path(__file__).resolve().parents[1] / "fixtures/sd15_object_info.json").read_text()) + with patch("comfy_cli.command.run._fetch_object_info", return_value=catalog): + yield + def test_preloaded_graph_is_submitted(self): - injected = { - "6": {"class_type": "CLIPTextEncode", "inputs": {"text": "a red fox in snow"}}, - "9": {"class_type": "SaveImage", "inputs": {"images": ["8", 0]}}, - } + injected = build_default_workflow(prompt="a red fox in snow") with ( patch("comfy_cli.command.run.check_comfy_server_running", return_value=True), patch("comfy_cli.command.run.ExecutionProgress"), @@ -63,7 +69,7 @@ def test_preloaded_graph_is_submitted(self): def test_preloaded_skips_file_loading(self): """A non-existent path never triggers workflow_not_found when preloaded.""" - injected = {"9": {"class_type": "SaveImage", "inputs": {}}} + injected = build_default_workflow(prompt="fox") with ( patch("comfy_cli.command.run.check_comfy_server_running", return_value=True), patch("comfy_cli.command.run.ExecutionProgress"), diff --git a/tests/comfy_cli/command/test_saved_file_links.py b/tests/comfy_cli/command/test_saved_file_links.py new file mode 100644 index 000000000..31a8ea44c --- /dev/null +++ b/tests/comfy_cli/command/test_saved_file_links.py @@ -0,0 +1,288 @@ +"""Stable file UUID verification cannot be inferred from workflow-record data.""" + +from __future__ import annotations + +import copy +import json +from pathlib import Path +from urllib.parse import parse_qs, urlsplit + +import pytest +from typer.testing import CliRunner + +from comfy_cli.command import workflow as cmd +from comfy_cli.command import workflow_ui as ui +from comfy_cli.target import Target + +FILE_ID = "978e5f58-49dc-4a81-8235-a0b91c204a1c" +WORKSPACE = "w-12345678-abcd-4abc-abcd-123456789abc" +GRAPH = {"version": 0.4, "nodes": [], "links": [], "last_node_id": 0, "last_link_id": 0} +SNAPSHOT_PATH = f"/api/userdata-files/{FILE_ID}" +SNAPSHOT = { + "id": FILE_ID, + "path": "workflows/sub/My saved workflow.json", + "content": json.dumps(GRAPH), + "modified": 1793320000000, + "size": len(json.dumps(GRAPH).encode()), +} + + +@pytest.fixture +def saved_server(monkeypatch): + from comfy_cli.output.renderer import reset_renderer_for_testing + + reset_renderer_for_testing() + target = Target(kind="cloud", base_url="https://cloud.test", path_prefix="/api", auth_token="oauth-test") + monkeypatch.setattr(ui, "resolve_target", lambda **kwargs: target) + bodies = { + "/api/workspaces/current": {"id": WORKSPACE}, + "/api/features": {"private_saved_file_links_enabled": True}, + SNAPSHOT_PATH: copy.deepcopy(SNAPSHOT), + } + calls = [] + + def request(url, request_target, **kwargs): + assert kwargs.get("method", "GET") == "GET" + assert request_target is target + calls.append(urlsplit(url).path) + value = bodies[urlsplit(url).path] + return value if isinstance(value, tuple) else (200, copy.deepcopy(value)) + + monkeypatch.setattr(ui, "request_json", request) + yield bodies, calls + reset_renderer_for_testing() + + +def test_one_uuid_snapshot_without_name_or_content_association(saved_server): + bodies, calls = saved_server + bodies[f"/api/workflows/{FILE_ID}"] = {"id": FILE_ID, "name": "sub/My saved workflow"} + result = ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard") + assert result["savedFileId"] == FILE_ID + assert "workflowId" not in result + assert result["filename"] == SNAPSHOT["path"] + assert parse_qs(urlsplit(result["url"]).query) == { + "savedFile": [FILE_ID], + "workspace": [WORKSPACE], + "environment": ["standard"], + } + assert calls == ["/api/workspaces/current", "/api/features", SNAPSHOT_PATH] + assert "content" not in result and "workflow_json" not in result + + +@pytest.mark.parametrize("flag", [None, False, 1, "true", {}, []]) +def test_only_literal_new_capability_can_publish(saved_server, flag): + bodies, calls = saved_server + bodies["/api/features"] = {"private_workflow_links_enabled": True} + if flag is not None: + bodies["/api/features"]["private_saved_file_links_enabled"] = flag + with pytest.raises(ui.WorkflowUiUnavailable) as failure: + ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard") + assert failure.value.reason == "capability_unavailable" + assert SNAPSHOT_PATH not in calls + + +@pytest.mark.parametrize( + "field,value", + [ + ("id", None), + ("id", "other"), + ("id", FILE_ID.upper()), + ("path", None), + ("path", "workflows/../file.json"), + ("path", "other/file.json"), + ("path", "workflows/other.txt"), + ("path", "workflows/sub//file.json"), + ("modified", True), + ("modified", -1), + ("size", True), + ("size", -1), + ("size", 999), + ("content", GRAPH), + ("content", "not JSON"), + ("content", "NaN"), + ], +) +def test_snapshot_fields_are_validated_without_fallback(saved_server, field, value): + bodies, calls = saved_server + bodies[SNAPSHOT_PATH][field] = value + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard") + assert calls[-1] == SNAPSHOT_PATH + assert not any("/workflows/" in call or "/userdata/" in call for call in calls) + + +@pytest.mark.parametrize("field", ["id", "path", "content", "modified", "size"]) +def test_missing_snapshot_fields_are_refused(saved_server, field): + bodies, _ = saved_server + bodies[SNAPSHOT_PATH].pop(field) + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard") + + +@pytest.mark.parametrize("status", [401, 403, 404, 412, 422, 500]) +def test_endpoint_errors_never_fall_back_to_same_name_equal_content(saved_server, status): + bodies, calls = saved_server + bodies[f"/api/workflows/{FILE_ID}"] = {"id": FILE_ID, "name": "sub/My saved workflow"} + bodies[f"/api/workflows/{FILE_ID}/content"] = {"workflow_json": GRAPH} + bodies["/api/userdata/workflows%2Fsub%2FMy%20saved%20workflow.json"] = GRAPH + bodies[SNAPSHOT_PATH] = (status, {"SECRET": "private prompt"}) + with pytest.raises(ui.WorkflowUiUnavailable) as failure: + ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard") + assert failure.value.status == status + assert "SECRET" not in str(failure.value) + assert calls[-1] == SNAPSHOT_PATH + + +@pytest.mark.parametrize("legacy,mixed", [(True, False), (True, True), (False, False)]) +def test_legacy_record_missing_or_mixed_invocation_refuses_before_network(saved_server, legacy, mixed): + _, calls = saved_server + args = ["ui"] + ([FILE_ID] if legacy else []) + (["--saved-file", FILE_ID] if mixed else []) + result = CliRunner().invoke(cmd.app, args + ["--workspace", WORKSPACE, "--environment", "standard"]) + assert result.exit_code == 1, result.output + assert "saved_file" in result.output or "saved-file" in result.output + assert calls == [] + + +@pytest.mark.parametrize("mode", ["json", "ndjson"]) +def test_explicit_saved_file_cli_machine_output(saved_server, mode): + from comfy_cli.caller import Caller + from comfy_cli.output.renderer import OutputMode, Renderer, set_renderer + + renderer = Renderer.resolve( + is_stdout_tty=False, env={}, caller=Caller(kind="user", agentic=False, source_env=None), json_flag=True + ) + renderer.mode = OutputMode.JSON if mode == "json" else OutputMode.NDJSON + set_renderer(renderer) + result = CliRunner().invoke( + cmd.app, ["ui", "--saved-file", FILE_ID, "--workspace", WORKSPACE, "--environment", "standard"] + ) + assert result.exit_code == 0, result.output + envelope = json.loads(result.stdout.strip().splitlines()[-1]) + assert envelope["ok"] is True + assert envelope["data"]["savedFileId"] == FILE_ID + assert "savedFile=" in envelope["data"]["url"] + + +def test_renamed_unicode_path_comes_from_same_snapshot(saved_server): + bodies, calls = saved_server + bodies[SNAPSHOT_PATH]["path"] = "workflows/新しい folder/雪 workflow.json" + result = ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard") + assert result["filename"] == bodies[SNAPSHOT_PATH]["path"] + assert calls[-1] == SNAPSHOT_PATH + + +# Replay the actual consumer corpus through the new raw-text snapshot route too. +# This retains both canvas versions and legacy Unicode/space model-URL behavior. + +_CORPUS = json.loads((Path(__file__).parents[1] / "fixtures/cloud_workflow_consumer/corpus.json").read_text()) + + +@pytest.mark.parametrize("case", _CORPUS["cases"], ids=lambda case: case["id"]) +def test_saved_snapshot_matches_existing_consumer_compatibility(saved_server, case): + bodies, _ = saved_server + text = json.dumps(case["input"]) + bodies[SNAPSHOT_PATH].update(content=text, size=len(text.encode())) + if case["accepted"]: + assert ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard")["verified"] is True + else: + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard") + + +def test_original_utf8_text_size_and_opaque_unicode_are_accepted(saved_server): + bodies, _ = saved_server + graph = {**GRAPH, "extra": {"title": "雪の workflow"}} + text = " \n" + json.dumps(graph, ensure_ascii=False) + "\n" + bodies[SNAPSHOT_PATH].update(content=text, size=len(text.encode("utf-8"))) + assert ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard")["verified"] is True + + +@pytest.mark.parametrize("mode", ["json", "ndjson"]) +def test_legacy_invocation_machine_error_has_regeneration_hint(saved_server, mode): + from comfy_cli.caller import Caller + from comfy_cli.output.renderer import OutputMode, Renderer, set_renderer + + renderer = Renderer.resolve( + is_stdout_tty=False, env={}, caller=Caller(kind="user", agentic=False, source_env=None), json_flag=True + ) + renderer.mode = OutputMode.JSON if mode == "json" else OutputMode.NDJSON + set_renderer(renderer) + result = CliRunner().invoke(cmd.app, ["ui", FILE_ID, "--workspace", WORKSPACE, "--environment", "standard"]) + assert result.exit_code == 1 + envelope = json.loads(result.stdout.strip().splitlines()[-1]) + assert envelope["ok"] is False + assert envelope["error"]["details"]["reason"] == "legacy_identity_unsupported" + assert "--saved-file" in envelope["error"]["message"] + assert "Workflows" in envelope["error"]["hint"] + + +@pytest.mark.parametrize("status", [401, 403, 404, 422, 500]) +def test_transport_http_error_retains_status_and_sanitizes_body(saved_server, monkeypatch, status): + import urllib.error + from unittest.mock import Mock + + monkeypatch.setattr( + ui, + "request_json", + Mock( + side_effect=urllib.error.HTTPError( + "https://cloud.test/api/userdata-files/private", status, "SECRET PROMPT", {}, None + ) + ), + ) + with pytest.raises(ui.WorkflowUiUnavailable) as failure: + ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard") + assert failure.value.status == status + assert "SECRET" not in str(failure.value) + + +@pytest.mark.parametrize("path", ["workflows/.index.json", "workflows/sub/.json", "workflows/sub/.index.json"]) +def test_snapshot_metadata_files_cannot_be_published(saved_server, path): + bodies, _ = saved_server + bodies[SNAPSHOT_PATH]["path"] = path + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard") + + +@pytest.mark.parametrize( + "field,value", [("modified", 9007199254740992), ("size", 9007199254740992), ("modified", 1.5), ("size", 1.5)] +) +def test_snapshot_metadata_requires_frontend_safe_integers(saved_server, field, value): + bodies, _ = saved_server + bodies[SNAPSHOT_PATH][field] = value + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard") + + +def test_snapshot_modified_accepts_frontend_safe_integer_boundary(saved_server): + bodies, _ = saved_server + bodies[SNAPSHOT_PATH]["modified"] = 9007199254740991 + assert ui.verify_workflow_link(FILE_ID, workspace=WORKSPACE, environment="standard")["verified"] is True + + +@pytest.mark.parametrize("identity", ["11111111-1111-1111-1111-111111111111", "11111111-1111-9111-8111-111111111111"]) +def test_id_requires_frontend_uuid_variant_and_version(saved_server, identity): + bodies, calls = saved_server + bodies[f"/api/userdata-files/{identity}"] = {**SNAPSHOT, "id": identity} + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(identity, workspace=WORKSPACE, environment="standard") + assert calls == [] + + +@pytest.mark.parametrize( + "identity", + [ + "00000000-0000-0000-0000-000000000000", + "ffffffff-ffff-ffff-ffff-ffffffffffff", + "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF", + FILE_ID.upper(), + "11111111-1111-8111-b111-111111111111", + ], +) +def test_publication_accepts_supported_boundary_ids_and_emits_lowercase(saved_server, identity): + bodies, _ = saved_server + canonical = identity.lower() + bodies[f"/api/userdata-files/{canonical}"] = {**SNAPSHOT, "id": canonical} + result = ui.verify_workflow_link(identity, workspace=WORKSPACE, environment="standard") + assert result["savedFileId"] == canonical + assert parse_qs(urlsplit(result["url"]).query)["savedFile"] == [canonical] diff --git a/tests/comfy_cli/command/test_transfer_download.py b/tests/comfy_cli/command/test_transfer_download.py index 889515bf5..0dc887921 100644 --- a/tests/comfy_cli/command/test_transfer_download.py +++ b/tests/comfy_cli/command/test_transfer_download.py @@ -1428,7 +1428,7 @@ def __init__(self, base_url: str, first: str) -> None: self.token = first self.refreshing_reads: list[bool] = [] - def __call__(self, *, refresh=True, force=False, allow_clear=True): + def __call__(self, *, refresh=True, force=False, allow_clear=True, rejected_access_token=None): from types import SimpleNamespace if refresh: diff --git a/tests/comfy_cli/command/test_workflow_saved.py b/tests/comfy_cli/command/test_workflow_saved.py index 8b28da40e..41fc3f3b8 100644 --- a/tests/comfy_cli/command/test_workflow_saved.py +++ b/tests/comfy_cli/command/test_workflow_saved.py @@ -1,7 +1,8 @@ """Tests for `comfy workflow list/get/save/delete` — saved workflows. The cloud path wraps the `/api/workflows` surface documented at -docs.comfy.org/api-reference/cloud/workflow. The local path (`--where local`) +docs.comfy.org/api-reference/cloud/workflow, except `save`, which writes the +`/api/userdata` file the Cloud Workflows sidebar lists. The local path (`--where local`) wraps the running ComfyUI's `/userdata` file store under `workflows/`, mirroring the ComfyUI frontend's layout. All HTTP is mocked; the live round-trip is verified manually. @@ -125,6 +126,8 @@ def _fake(req, timeout=None): calls.append({"url": url, "method": method, "body": body, "headers": dict(req.headers)}) for needle, payload in routes.items(): if needle in url: + if callable(payload): + payload = payload(req) if isinstance(payload, Exception): raise payload if isinstance(payload, tuple): @@ -444,6 +447,34 @@ def test_server_not_running_envelope(self, local_target, tmp_path, monkeypatch, assert env["ok"] is False assert env["error"]["code"] == "server_not_running" + def test_no_overwrite_sends_overwrite_false(self, local_target, tmp_path, monkeypatch, capsys): + wf = tmp_path / "src.json" + wf.write_text(json.dumps(_LOCAL_WORKFLOW)) + calls = _patch_urlopen(monkeypatch, {"/userdata/": {"path": "workflows/flux.json"}}) + env = _run(["save", str(wf), "--name", "flux", "--no-overwrite", "--where", "local"], capsys) + assert env["ok"] is True + assert "overwrite=false" in calls[0]["url"] + + def test_no_overwrite_collision_is_workflow_exists(self, local_target, tmp_path, monkeypatch, capsys): + # ComfyUI answers 409 when `overwrite=false` meets an existing file. + wf = tmp_path / "src.json" + wf.write_text(json.dumps(_LOCAL_WORKFLOW)) + _patch_urlopen(monkeypatch, {"/userdata/": _http_error(409)}) + env = _run(["save", str(wf), "--name", "flux", "--no-overwrite", "--where", "local"], capsys) + assert env["ok"] is False + assert env["where"] == "local" + assert env["error"]["code"] == "workflow_exists" + assert env["error"]["details"]["filename"] == "flux.json" + + def test_refuses_the_favorites_index(self, local_target, tmp_path, monkeypatch, capsys): + wf = tmp_path / "src.json" + wf.write_text(json.dumps(_LOCAL_WORKFLOW)) + calls = _patch_urlopen(monkeypatch, {}) + env = _run(["save", str(wf), "--name", ".index.json", "--where", "local"], capsys) + assert env["ok"] is False + assert env["error"]["code"] == "invalid_argument" + assert calls == [] + class TestLocalDelete: def test_sends_delete(self, local_target, monkeypatch, capsys): @@ -688,7 +719,8 @@ def test_every_call_site_routes_oversize_to_envelope(self, verb, cloud_target, t # Each of the four _http_request call sites must catch _ResponseTooLarge; # an uncaught one would surface as a traceback rather than an envelope. monkeypatch.setattr(workflow_cmd, "_HTTP_MAX_BYTES", 4) - _patch_urlopen(monkeypatch, {"/api/workflows": (b'{"data": []}', 200)}) + # `save` writes through `/api/userdata/`; the other three read `/api/workflows`. + _patch_urlopen(monkeypatch, {"/api/workflows": (b'{"data": []}', 200), "/api/userdata/": (b'{"a": 1}', 200)}) args = { "list": ["list"], "get": ["get", "wf-uuid"], @@ -719,29 +751,349 @@ def test_mutating_verbs_do_not_claim_the_write_was_rejected(self, verb): # --------------------------------------------------------------------------- +_MIRRORED_RECORD = { + "id": "33333333-3333-3333-3333-333333333333", + "name": "my workflow", + "default_view": "workflow", + "latest_version": 2, + "created_by": "user-uuid", + "created_at": "2026-05-23T00:00:00Z", + "updated_at": "2026-05-23T00:00:00Z", +} + +# Cloud's `POST /api/userdata/{file}?full_info=true` receipt: a FileInfo dict. +_SAVED_FILE_ID = "978e5f58-49dc-4a81-8235-a0b91c204a1c" +_USERDATA_SAVE_RESPONSE = { + "id": _SAVED_FILE_ID, + "path": "workflows/my workflow.json", + "size": 64, + "modified": 1700000003000, +} + + +_BOOL_NUMBER_MISMATCHES = [ + pytest.param(1, True, id="one-vs-true"), + pytest.param(0, False, id="zero-vs-false"), + pytest.param(True, 1, id="true-vs-one"), + pytest.param(False, 0, id="false-vs-zero"), + pytest.param({"nested": [1]}, {"nested": [True]}, id="nested-one-vs-true"), + pytest.param({"nested": [False]}, {"nested": [0]}, id="nested-false-vs-zero"), +] + + +def _record_listing(*rows: dict) -> dict: + return {"data": list(rows), "pagination": {"total": len(rows), "limit": 100, "offset": 0}} + + +def _cloud_wf(tmp_path: Path) -> tuple[Path, dict]: + wf_path = tmp_path / "wf.json" + wf_path.write_text(json.dumps(_LOCAL_WORKFLOW)) + return wf_path, _LOCAL_WORKFLOW + + +def _http_409(url: str = "https://cloud.example.com/api/userdata/x"): + return urllib.error.HTTPError(url, 409, "Conflict", {}, io.BytesIO(b"File already exists")) + + class TestSave: - def test_posts_workflow_payload(self, cloud_target, tmp_path, monkeypatch, capsys): + """Cloud `workflow save` writes the file the Cloud Workflows sidebar lists. + + The sidebar lists `userdata/workflows/*.json`; a record created only through + `POST /api/workflows` has no file behind it and never shows there. So the save + is the frontend's own write, `POST /api/userdata/`, + which Cloud mirrors into its `/api/workflows` record store. The record id is + then read back by exact name. + """ + + def test_writes_the_sidebar_userdata_file(self, cloud_target, tmp_path, monkeypatch, capsys): + wf_path, wf_data = _cloud_wf(tmp_path) + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": _USERDATA_SAVE_RESPONSE, + "/content": {"workflow_json": _LOCAL_WORKFLOW}, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + }, + ) + env = _run(["save", str(wf_path), "--name", "my workflow", "--where", "cloud"], capsys) + assert env["ok"] is True, env + assert env["where"] == "cloud" + + write = calls[0] + assert write["method"] == "POST" + # The whole `workflows/.json` path is one percent-encoded segment, + # exactly as the frontend's `encodeURIComponent(file)` sends it. + assert write["url"].startswith("https://cloud.example.com/api/userdata/workflows%2Fmy%20workflow.json?") + assert "overwrite=true" in write["url"] + assert "full_info=true" in write["url"] + # The body is the graph itself, not the `/api/workflows` {name, workflow_json} envelope. + assert json.loads(write["body"]) == wf_data + + # No bare `/api/workflows` record write: Cloud creates the record from the file. + assert not [c for c in calls if c["method"] == "POST" and "/api/workflows" in c["url"]] + + data = env["data"] + assert data["filename"] == "my workflow.json" + assert data["name"] == "my workflow" + assert data["workflow_id"] == _MIRRORED_RECORD["id"] + assert data["latest_version"] == 2 + assert data["size"] == 64 + assert data["source"] == str(wf_path) + assert "warnings" not in data + + def test_record_is_read_back_by_exact_name(self, cloud_target, tmp_path, monkeypatch, capsys): + # Cloud's `name` filter is a case-insensitive substring match, so the + # listing can carry near-misses. Only the exact name is the mirror. + wf_path, _ = _cloud_wf(tmp_path) + near_miss = {**_MIRRORED_RECORD, "id": "44444444-4444-4444-4444-444444444444", "name": "my workflow (copy)"} + cased = {**_MIRRORED_RECORD, "id": "55555555-5555-5555-5555-555555555555", "name": "My Workflow"} + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": _USERDATA_SAVE_RESPONSE, + "/content": {"workflow_json": _LOCAL_WORKFLOW}, + "/api/workflows?": _record_listing(near_miss, cased, _MIRRORED_RECORD), + }, + ) + env = _run(["save", str(wf_path), "--name", "my workflow", "--where", "cloud"], capsys) + assert env["data"]["workflow_id"] == _MIRRORED_RECORD["id"] + lookup = calls[1] + assert lookup["method"] == "GET" + assert "name=my+workflow" in lookup["url"] + + def test_subdir_name_is_a_single_encoded_segment(self, cloud_target, tmp_path, monkeypatch, capsys): + wf_path, _ = _cloud_wf(tmp_path) + record = {**_MIRRORED_RECORD, "name": "team/flux"} + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": {"path": "team/flux.json"}, + "/content": {"workflow_json": _LOCAL_WORKFLOW}, + "/api/workflows?": _record_listing(record), + }, + ) + env = _run(["save", str(wf_path), "--name", "team/flux", "--where", "cloud"], capsys) + assert env["ok"] is True + assert "/api/userdata/workflows%2Fteam%2Fflux.json?" in calls[0]["url"] + assert env["data"]["filename"] == "team/flux.json" + assert env["data"]["workflow_id"] == record["id"] + + def test_json_ext_is_not_doubled(self, cloud_target, tmp_path, monkeypatch, capsys): + wf_path, _ = _cloud_wf(tmp_path) + record = {**_MIRRORED_RECORD, "name": "flux"} + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": {}, + "/content": {"workflow_json": _LOCAL_WORKFLOW}, + "/api/workflows?": _record_listing(record), + }, + ) + env = _run(["save", str(wf_path), "--name", "flux.json", "--where", "cloud"], capsys) + assert "workflows%2Fflux.json?" in calls[0]["url"] + # The record name Cloud derives drops the `.json`. + assert env["data"]["name"] == "flux" + assert env["data"]["workflow_id"] == record["id"] + + def test_uppercase_ext_still_gets_json_appended_on_cloud(self, cloud_target, tmp_path, monkeypatch, capsys): + # Cloud mirrors only names ending in a lowercase `.json` into a record, + # so `flux.JSON` is a stem, not an extension, on this route. + wf_path, _ = _cloud_wf(tmp_path) + calls = _patch_urlopen(monkeypatch, {"/api/userdata/": {}, "/api/workflows?": _record_listing()}) + env = _run(["save", str(wf_path), "--name", "flux.JSON", "--where", "cloud"], capsys) + assert "workflows%2Fflux.JSON.json?" in calls[0]["url"] + assert env["data"]["filename"] == "flux.JSON.json" + + def test_no_overwrite_sends_overwrite_false(self, cloud_target, tmp_path, monkeypatch, capsys): + wf_path, _ = _cloud_wf(tmp_path) + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": _USERDATA_SAVE_RESPONSE, + "/content": {"workflow_json": _LOCAL_WORKFLOW}, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + }, + ) + env = _run(["save", str(wf_path), "--name", "my workflow", "--no-overwrite", "--where", "cloud"], capsys) + assert env["ok"] is True + assert "overwrite=false" in calls[0]["url"] + + def test_no_overwrite_collision_is_workflow_exists(self, cloud_target, tmp_path, monkeypatch, capsys): + wf_path, _ = _cloud_wf(tmp_path) + calls = _patch_urlopen(monkeypatch, {"/api/userdata/": _http_409()}) + env = _run(["save", str(wf_path), "--name", "my workflow", "--no-overwrite", "--where", "cloud"], capsys) + assert env["ok"] is False + assert env["where"] == "cloud" + assert env["error"]["code"] == "workflow_exists" + assert env["error"]["details"]["filename"] == "my workflow.json" + assert "--no-overwrite" in env["error"]["hint"] + # Nothing was written, so there is no record to look up. + assert len(calls) == 1 + + def test_unauthorized_write_is_cloud_unauthorized(self, cloud_target, tmp_path, monkeypatch, capsys): + wf_path, _ = _cloud_wf(tmp_path) + denied = urllib.error.HTTPError( + "https://cloud.example.com/api/userdata/x", 401, "Unauthorized", {}, io.BytesIO(b"") + ) + _patch_urlopen(monkeypatch, {"/api/userdata/": denied}) + env = _run(["save", str(wf_path), "--name", "my workflow", "--where", "cloud"], capsys) + assert env["ok"] is False + assert env["error"]["code"] == "cloud_unauthorized" + assert env["error"]["details"]["operation"] == "save" + + def test_unreachable_write_is_an_error(self, cloud_target, tmp_path, monkeypatch, capsys): + wf_path, _ = _cloud_wf(tmp_path) + _patch_urlopen(monkeypatch, {"/api/userdata/": urllib.error.URLError("refused")}) + env = _run(["save", str(wf_path), "--name", "my workflow", "--where", "cloud"], capsys) + assert env["ok"] is False + assert env["error"]["code"] == "cloud_http_error" + + @pytest.mark.parametrize( + "listing", + [ + pytest.param(_record_listing(), id="no-record"), + pytest.param( + _record_listing(_MIRRORED_RECORD, {**_MIRRORED_RECORD, "id": "66666666-6666-6666-6666-666666666666"}), + id="two-records-one-name", + ), + pytest.param(urllib.error.URLError("reset"), id="lookup-unreachable"), + pytest.param((b"502", 200), id="lookup-unparseable"), + pytest.param( + # A full page may be truncated: the exact match it holds may not be the only one. + _record_listing( + _MIRRORED_RECORD, + *[{**_MIRRORED_RECORD, "id": f"id-{i}", "name": f"my workflow {i}"} for i in range(99)], + ), + id="full-page", + ), + ], + ) + def test_unresolved_record_keeps_the_save_and_warns(self, listing, cloud_target, tmp_path, monkeypatch, capsys): + # The file write has already landed when the record lookup runs, so a + # lookup that cannot name exactly one record must not fail the save (an + # agent would re-issue a save that already succeeded). It reports a null + # id and says why. + wf_path, _ = _cloud_wf(tmp_path) + _patch_urlopen(monkeypatch, {"/api/userdata/": _USERDATA_SAVE_RESPONSE, "/api/workflows?": listing}) + env = _run(["save", str(wf_path), "--name", "my workflow", "--where", "cloud"], capsys) + assert env["ok"] is True + assert env["data"]["filename"] == "my workflow.json" + assert env["data"]["workflow_id"] is None + assert env["data"]["latest_version"] is None + assert [w["code"] for w in env["data"]["warnings"]] == ["workflow_record_unresolved"] + + @pytest.mark.parametrize( + "content", + [ + {"workflow_json": {"nodes": [], "links": []}}, + urllib.error.URLError("mirror content unavailable"), + ], + ) + def test_stale_or_unreadable_mirror_does_not_return_record_id( + self, content, cloud_target, tmp_path, monkeypatch, capsys + ): + # The best-effort mirror may fail while an older same-name record remains. + wf_path, _ = _cloud_wf(tmp_path) + _patch_urlopen( + monkeypatch, + { + "/api/userdata/": _USERDATA_SAVE_RESPONSE, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + "/content": content, + }, + ) + env = _run(["save", str(wf_path), "--name", "my workflow", "--where", "cloud"], capsys) + assert env["ok"] is True + assert env["data"]["workflow_id"] is None + assert env["data"]["warnings"][0]["code"] == "workflow_record_unresolved" + + @pytest.mark.parametrize(("file_value", "record_value"), _BOOL_NUMBER_MISMATCHES) + def test_bool_number_mirror_mismatch_withholds_record_id( + self, file_value, record_value, cloud_target, tmp_path, monkeypatch, capsys + ): wf_path = tmp_path / "wf.json" - wf_data = {"1": {"class_type": "KSampler", "inputs": {"steps": 20}}} - wf_path.write_text(json.dumps(wf_data)) + wf_path.write_text(json.dumps({"nodes": [{"id": 1, "widgets_values": [file_value]}]})) + _patch_urlopen( + monkeypatch, + { + "/api/userdata/": _USERDATA_SAVE_RESPONSE, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + "/content": {"workflow_json": {"nodes": [{"id": 1, "widgets_values": [record_value]}]}}, + }, + ) + env = _run(["save", str(wf_path), "--name", "my workflow", "--where", "cloud"], capsys) + assert env["ok"] is True + assert env["data"]["workflow_id"] is None + assert env["data"]["latest_version"] is None + assert env["data"]["warnings"][0]["code"] == "workflow_record_unresolved" - created = { - "id": "new-uuid", - "name": "my workflow", - "latest_version": 1, - "created_by": "user", - "created_at": "2026-05-23T00:00:00Z", - "updated_at": "2026-05-23T00:00:00Z", - } - calls = _patch_urlopen(monkeypatch, {"/api/workflows": created}) + def test_equivalent_json_numbers_resolve_mirrored_record(self, cloud_target, tmp_path, monkeypatch, capsys): + wf_path = tmp_path / "wf.json" + wf_path.write_text('{"nodes": [{"id": 1, "widgets_values": [{"nested": [1, true, null]}]}]}') + _patch_urlopen( + monkeypatch, + { + "/api/userdata/": _USERDATA_SAVE_RESPONSE, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + "/content": { + "workflow_json": {"nodes": [{"widgets_values": [{"nested": [1.0, True, None]}], "id": 1.0}]} + }, + }, + ) env = _run(["save", str(wf_path), "--name", "my workflow", "--where", "cloud"], capsys) assert env["ok"] is True - assert env["data"]["workflow_id"] == "new-uuid" - # POSTed JSON carries the workflow_json + name. - assert calls[0]["method"] == "POST" - sent = json.loads(calls[0]["body"]) - assert sent["name"] == "my workflow" - assert sent["workflow_json"] == wf_data + assert env["data"]["workflow_id"] == _MIRRORED_RECORD["id"] + assert "warnings" not in env["data"] + + @pytest.mark.parametrize("name", [".hidden", "team/.hidden/flow", ".json", "team/.json"]) + def test_hidden_names_are_refused_before_cloud_write(self, name, cloud_target, tmp_path, monkeypatch, capsys): + # Cloud's userdata listing excludes every dot-prefixed component. + wf_path, _ = _cloud_wf(tmp_path) + calls = _patch_urlopen(monkeypatch, {"/api/userdata/": {}, "/api/workflows?": _record_listing()}) + env = _run(["save", str(wf_path), "--name", name, "--where", "cloud"], capsys) + assert env["ok"] is False + assert env["error"]["code"] == "invalid_argument" + assert calls == [] + + def test_description_is_ignored_with_a_warning(self, cloud_target, tmp_path, monkeypatch, capsys): + # The sidebar file has no description field; say so rather than drop it silently. + wf_path, wf_data = _cloud_wf(tmp_path) + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": _USERDATA_SAVE_RESPONSE, + "/content": {"workflow_json": _LOCAL_WORKFLOW}, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + }, + ) + env = _run( + ["save", str(wf_path), "--name", "my workflow", "--description", "hi", "--where", "cloud"], + capsys, + ) + assert env["ok"] is True + assert [w["code"] for w in env["data"]["warnings"]] == ["description_ignored"] + assert json.loads(calls[0]["body"]) == wf_data + + @pytest.mark.parametrize("name", ["../escape", "/abs", "a\\b", ".index", "sub/.index.json"]) + def test_unsafe_or_reserved_names_are_refused_before_any_call( + self, name, cloud_target, tmp_path, monkeypatch, capsys + ): + # `.index.json` is the frontend's favorites file in the same folder; a + # save under that name would replace the user's bookmarks. + wf_path, _ = _cloud_wf(tmp_path) + calls = _patch_urlopen(monkeypatch, {}) + env = _run(["save", str(wf_path), "--name", name, "--where", "cloud"], capsys) + assert env["ok"] is False + assert env["error"]["code"] == "invalid_argument" + assert calls == [] + + def test_non_utf8_file_surfaces_read_error(self, cloud_target, tmp_path, monkeypatch, capsys): + wf = tmp_path / "bin.json" + wf.write_bytes(b"\xff\xfe\x00") + _patch_urlopen(monkeypatch, {}) + env = _run(["save", str(wf), "--name", "x", "--where", "cloud"], capsys) + assert env["ok"] is False + assert env["error"]["code"] == "workflow_read_error" def test_invalid_json_file_surfaces_workflow_invalid_json(self, cloud_target, tmp_path, monkeypatch, capsys): wf_path = tmp_path / "bad.json" @@ -764,13 +1116,239 @@ def test_missing_file_surfaces_workflow_not_found(self, cloud_target, tmp_path, # --------------------------------------------------------------------------- +def test_cloud_save_list_get_delete_round_trip(cloud_target, tmp_path, monkeypatch, capsys): + # Mirror the verified Cloud handler boundaries: file POST mirrors a record, + # file DELETE mirrors record removal, record DELETE alone removes only a record. + state = {"file": None, "record": False} + + def file(req): + if req.get_method() == "POST": + state["file"] = json.loads(req.data) + state["record"] = True + return _USERDATA_SAVE_RESPONSE + if req.get_method() == "DELETE": + state["file"] = None + state["record"] = False + return (b"", 204) + return state["file"] + + def record(req): + if not state["record"]: + return urllib.error.HTTPError(req.full_url, 404, "Not found", {}, io.BytesIO()) + if req.full_url.endswith("/content"): + return {"id": "v2", "version": 2, "workflow_json": state["file"]} + if req.get_method() == "DELETE": + state["record"] = False + return (b"", 204) + return _MIRRORED_RECORD + + def listing(req): + return _record_listing(_MIRRORED_RECORD) if state["record"] else _record_listing() + + _patch_urlopen( + monkeypatch, + { + "/api/userdata/": file, + "/api/workflows?": listing, + "/api/workflows/": record, + "/api/user": {"id": "user-uuid"}, + }, + ) + src, workflow_json = _cloud_wf(tmp_path) + saved = _run(["save", str(src), "--name", "my workflow", "--where", "cloud"], capsys) + workflow_id = saved["data"]["workflow_id"] + listed = _run(["list", "--where", "cloud"], capsys) + assert listed["data"]["workflows"][0]["id"] == workflow_id + out = tmp_path / "downloaded.json" + fetched = _run(["get", workflow_id, "--out", str(out), "--where", "cloud"], capsys) + assert fetched["ok"] is True + assert json.loads(out.read_text()) == workflow_json + deleted = _run(["delete", workflow_id, "--where", "cloud"], capsys) + assert deleted["ok"] is True + assert state == {"file": None, "record": False} + listed = _run(["list", "--where", "cloud"], capsys) + assert listed["data"]["count"] == 0 + + +class TestCloudDeleteFile: + @pytest.mark.parametrize(("file_value", "record_value"), _BOOL_NUMBER_MISMATCHES) + def test_bool_number_mirror_mismatch_refuses_both_deletes( + self, file_value, record_value, cloud_target, monkeypatch, capsys + ): + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": {"nodes": [{"id": 1, "widgets_values": [file_value]}]}, + "/content": {"workflow_json": {"nodes": [{"id": 1, "widgets_values": [record_value]}]}}, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + "/api/workflows/": _MIRRORED_RECORD, + "/api/user": {"id": "user-uuid"}, + }, + ) + env = _run(["delete", _MIRRORED_RECORD["id"], "--where", "cloud"], capsys) + assert not [call for call in calls if call["method"] == "DELETE"] + assert env["ok"] is False + assert env["error"]["code"] == "workflow_filename_ambiguous" + + def test_equivalent_json_numbers_allow_both_deletes(self, cloud_target, monkeypatch, capsys): + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": {"nodes": [{"id": 1, "widgets_values": [{"nested": [1, True, None]}]}]}, + "/content": { + "workflow_json": {"nodes": [{"widgets_values": [{"nested": [1.0, True, None]}], "id": 1.0}]} + }, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + "/api/workflows/": _MIRRORED_RECORD, + "/api/user": {"id": "user-uuid"}, + }, + ) + env = _run(["delete", _MIRRORED_RECORD["id"], "--where", "cloud"], capsys) + assert env["ok"] is True + assert [call["url"] for call in calls if call["method"] == "DELETE"] == [ + "https://cloud.example.com/api/userdata/workflows%2Fmy%20workflow.json", + "https://cloud.example.com/api/workflows/33333333-3333-3333-3333-333333333333", + ] + + @pytest.mark.parametrize( + ("content", "creator", "user"), + [ + pytest.param({"nodes": []}, "user-uuid", {"id": "user-uuid"}, id="unrelated-file"), + pytest.param(_LOCAL_WORKFLOW, "other-user", {"id": "user-uuid"}, id="other-members-record"), + pytest.param(_LOCAL_WORKFLOW, None, {"id": "user-uuid"}, id="unknown-record-owner"), + pytest.param(_LOCAL_WORKFLOW, "user-uuid", {}, id="unknown-current-user"), + ], + ) + def test_unverified_file_association_leaves_file_and_record_untouched( + self, content, creator, user, cloud_target, monkeypatch, capsys + ): + # A same-name record can be stale after a best-effort sync failure, or + # belong to a different workspace member. Neither authorizes file deletion. + record = {**_MIRRORED_RECORD, "created_by": creator} + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": _LOCAL_WORKFLOW, + "/content": {"workflow_json": content}, + "/api/workflows?": _record_listing(record), + "/api/workflows/": record, + "/api/user": user, + }, + ) + env = _run(["delete", record["id"], "--where", "cloud"], capsys) + assert env["ok"] is False + assert env["error"]["code"] == "workflow_filename_ambiguous" + assert all(call["method"] == "GET" for call in calls) + + @pytest.mark.parametrize("dual_delete", [True, False]) + def test_delete_removes_sidebar_file_and_record(self, dual_delete, cloud_target, monkeypatch, capsys): + # Cloud's userdata delete mirrors best-effort; record DELETE alone leaves the file behind. + state = {"file": True, "record": True} + + def record(req): + if req.full_url.endswith("/content"): + return {"workflow_json": _LOCAL_WORKFLOW} + if req.get_method() == "GET": + return _MIRRORED_RECORD + if not state["record"]: + return urllib.error.HTTPError(req.full_url, 404, "Not found", {}, io.BytesIO()) + state["record"] = False + return (b"", 204) + + def file(req): + if req.get_method() == "DELETE": + state["file"] = False + if dual_delete: + state["record"] = False + return (b"", 204) + return _LOCAL_WORKFLOW + + _patch_urlopen( + monkeypatch, + { + "/api/userdata/": file, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + "/api/workflows/": record, + "/api/user": {"id": "user-uuid"}, + }, + ) + env = _run(["delete", _MIRRORED_RECORD["id"], "--where", "cloud"], capsys) + assert env["ok"] is True, env + assert state == {"file": False, "record": False} + assert env["data"]["filename"] == "my workflow.json" + + def test_duplicate_names_leave_file_and_records_untouched(self, cloud_target, monkeypatch, capsys): + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": _LOCAL_WORKFLOW, + "/api/workflows?": _record_listing(_MIRRORED_RECORD, {**_MIRRORED_RECORD, "id": "other-id"}), + "/api/workflows/": _MIRRORED_RECORD, + }, + ) + env = _run(["delete", _MIRRORED_RECORD["id"], "--where", "cloud"], capsys) + assert env["ok"] is False + assert env["error"]["code"] == "workflow_filename_ambiguous" + assert all(c["method"] == "GET" for c in calls) + + @pytest.mark.parametrize("name", [" leading space", ".index", "../outside"]) + def test_unsafe_record_name_cannot_delete_another_file(self, name, cloud_target, monkeypatch, capsys): + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": _LOCAL_WORKFLOW, + "/api/workflows?": _record_listing({**_MIRRORED_RECORD, "name": name}), + "/api/workflows/": {**_MIRRORED_RECORD, "name": name}, + }, + ) + env = _run(["delete", _MIRRORED_RECORD["id"], "--where", "cloud"], capsys) + assert env["ok"] is False + assert all(c["method"] == "GET" for c in calls) + + def test_partial_failure_reports_file_already_deleted(self, cloud_target, monkeypatch, capsys): + def record(req): + if req.full_url.endswith("/content"): + return {"workflow_json": _LOCAL_WORKFLOW} + if req.get_method() == "GET": + return _MIRRORED_RECORD + return urllib.error.HTTPError(req.full_url, 503, "Unavailable", {}, io.BytesIO()) + + def file(req): + return (b"", 204) if req.get_method() == "DELETE" else _LOCAL_WORKFLOW + + _patch_urlopen( + monkeypatch, + { + "/api/userdata/": file, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + "/api/workflows/": record, + "/api/user": {"id": "user-uuid"}, + }, + ) + env = _run(["delete", _MIRRORED_RECORD["id"], "--where", "cloud"], capsys) + assert env["ok"] is False + assert env["error"]["code"] == "workflow_delete_incomplete" + assert env["error"]["details"]["file_deleted"] is True + assert env["error"]["details"]["workflow_id"] == _MIRRORED_RECORD["id"] + + def test_record_only_workflow_still_deletes(self, cloud_target, monkeypatch, capsys): + def record(req): + return _MIRRORED_RECORD if req.get_method() == "GET" else (b"", 204) + + missing = urllib.error.HTTPError("https://x/userdata/x", 404, "Not Found", {}, io.BytesIO()) + calls = _patch_urlopen(monkeypatch, {"/api/userdata/": missing, "/api/workflows/": record}) + env = _run(["delete", _MIRRORED_RECORD["id"], "--where", "cloud"], capsys) + assert env["ok"] is True + assert [c["method"] for c in calls] == ["GET", "GET", "DELETE"] + + class TestDelete: def test_sends_delete_request(self, cloud_target, monkeypatch, capsys): - calls = _patch_urlopen(monkeypatch, {"/api/workflows/wf-uuid": (b"", 204)}) + calls = _patch_urlopen(monkeypatch, {"/api/workflows/wf-uuid": {"id": "wf-uuid"}}) env = _run(["delete", "wf-uuid", "--where", "cloud"], capsys) assert env["ok"] is True assert env["data"]["deleted"] is True - assert calls[0]["method"] == "DELETE" + assert [c["method"] for c in calls] == ["GET", "DELETE"] def test_404_surfaces_workflow_not_found(self, cloud_target, monkeypatch, capsys): err = urllib.error.HTTPError("https://x/workflows/g", 404, "Not Found", {}, io.BytesIO(b"{}")) @@ -817,9 +1395,12 @@ def test_list_surfaces_error_not_empty(self, cloud_target, monkeypatch, capsys, def test_save_surfaces_error_not_null_id(self, cloud_target, tmp_path, monkeypatch, capsys, raw): wf_path = tmp_path / "wf.json" wf_path.write_text(json.dumps({"1": {"class_type": "KSampler", "inputs": {}}})) - _patch_urlopen(monkeypatch, {"/api/workflows": (raw, 200)}) + calls = _patch_urlopen(monkeypatch, {"/api/userdata/": (raw, 200)}) env = _run(["save", str(wf_path), "--name", "x", "--where", "cloud"], capsys) - # Must NOT claim success with a null workflow_id. + # The save's write is the userdata POST; its receipt is what came back malformed. + assert "/api/userdata/workflows%2Fx.json" in calls[0]["url"] + # Must NOT claim success off a body it could not read (an HTML 200 can be a + # proxy page that never reached Cloud). assert env["ok"] is False assert env["error"]["code"] == "workflow_unparseable" assert env["error"]["details"]["operation"] == "save" @@ -877,3 +1458,77 @@ def test_list_missing_data_is_empty(self, cloud_target, monkeypatch, capsys): env = _run(["list", "--where", "cloud"], capsys) assert env["ok"] is True assert env["data"]["count"] == 0 + + +@pytest.mark.parametrize( + "identity", + [ + None, + "", + 12, + True, + "not-a-uuid", + "a" * 32, + "978E5F58-49DC-4A81-8235-A0B91C204A1C", + "11111111-1111-1111-1111-111111111111", + "11111111-1111-9111-8111-111111111111", + ], +) +def test_cloud_save_without_canonical_file_id_keeps_success_and_record_separate( + cloud_target, tmp_path, monkeypatch, capsys, identity +): + wf_path, _ = _cloud_wf(tmp_path) + receipt = {**_USERDATA_SAVE_RESPONSE, "id": identity} + if identity is None: + receipt.pop("id") + calls = _patch_urlopen( + monkeypatch, + { + "/api/userdata/": receipt, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + "/content": {"workflow_json": _LOCAL_WORKFLOW}, + }, + ) + env = _run(["save", str(wf_path), "--name", "my workflow", "--where", "cloud"], capsys) + assert env["ok"] is True + assert env["data"]["saved_file_id"] is None + assert env["data"]["workflow_id"] == _MIRRORED_RECORD["id"] + warning = next(w for w in env["data"]["warnings"] if w["code"] == "saved_file_identity_unavailable") + assert "do not repeat" in warning["message"] + assert len([c for c in calls if c["method"] == "POST"]) == 1 + + +def test_cloud_save_exposes_received_file_uuid_distinct_from_equal_content_record( + cloud_target, tmp_path, monkeypatch, capsys +): + wf_path, _ = _cloud_wf(tmp_path) + _patch_urlopen( + monkeypatch, + { + "/api/userdata/": _USERDATA_SAVE_RESPONSE, + "/api/workflows?": _record_listing(_MIRRORED_RECORD), + "/content": {"workflow_json": _LOCAL_WORKFLOW}, + }, + ) + env = _run(["save", str(wf_path), "--name", "my workflow", "--where", "cloud"], capsys) + assert env["ok"] is True + assert env["data"]["saved_file_id"] == _SAVED_FILE_ID + assert env["data"]["workflow_id"] == _MIRRORED_RECORD["id"] + assert env["data"]["saved_file_id"] != env["data"]["workflow_id"] + + +@pytest.mark.parametrize("path", [None, "workflows/other.json", "my workflow.json"]) +def test_cloud_save_other_receipt_path_does_not_certify_requested_file( + cloud_target, tmp_path, monkeypatch, capsys, path +): + wf_path, _ = _cloud_wf(tmp_path) + _patch_urlopen( + monkeypatch, + { + "/api/userdata/": {**_USERDATA_SAVE_RESPONSE, "path": path}, + "/api/workflows?": _record_listing(), + }, + ) + env = _run(["save", str(wf_path), "--name", "my workflow", "--where", "cloud"], capsys) + assert env["ok"] is True + assert env["data"]["saved_file_id"] is None diff --git a/tests/comfy_cli/command/test_workflow_ui.py b/tests/comfy_cli/command/test_workflow_ui.py new file mode 100644 index 000000000..aae9d3090 --- /dev/null +++ b/tests/comfy_cli/command/test_workflow_ui.py @@ -0,0 +1,394 @@ +"""Read-only capability-gated links preserve normal private workflow identity.""" + +from __future__ import annotations + +import copy +import json +import urllib.error +from unittest.mock import Mock +from urllib.parse import parse_qs, urlsplit + +import pytest +from click import unstyle +from typer.testing import CliRunner + +from comfy_cli.command import workflow as cmd +from comfy_cli.target import Target + +WID = "c327cae8-2acf-4bfa-bb88-97948a3c008b" +WORKSPACE = "w-12345678-abcd-4abc-abcd-123456789abc" +DEPLOYMENT = "dep-12345678-abcd-4abc-abcd-123456789abc" +GRAPH = {"version": 0.4, "nodes": [], "links": [], "last_node_id": 0, "last_link_id": 0} +META = { + "id": WID, + "name": "sub/My saved workflow", + "latest_version": 1, + "created_by": "user-1", + "created_at": "2026-10-24T00:00:00Z", + "updated_at": "2026-10-24T00:00:00Z", +} + + +def test_cli_ui_command_exists(): + result = CliRunner().invoke(cmd.app, ["ui", "--help"]) + assert result.exit_code == 0, result.output + help_text = unstyle(result.output) + assert "--saved-file" in help_text + assert "--workspace" in help_text + assert "--environment" in help_text + assert "--deployment" in help_text + + +@pytest.fixture +def server(monkeypatch): + from comfy_cli.command import workflow_ui as ui + + target = Target(kind="cloud", base_url="https://cloud.test", path_prefix="/api", auth_token="oauth-test") + monkeypatch.setattr(ui, "resolve_target", lambda **kwargs: target) + bodies = { + "/api/workspaces/current": {"id": WORKSPACE, "name": "Test workspace"}, + "/api/features": {"private_saved_file_links_enabled": True}, + f"/api/workflows/{WID}": copy.deepcopy(META), + f"/api/workflows/{WID}/content": { + "id": "version-1", + "version": 1, + "created_by": "user-1", + "created_at": META["created_at"], + "workflow_json": copy.deepcopy(GRAPH), + }, + "/api/userdata/workflows%2Fsub%2FMy%20saved%20workflow.json": copy.deepcopy(GRAPH), + f"/api/userdata-files/{WID}": { + "id": WID, + "path": "workflows/sub/My saved workflow.json", + "content": json.dumps(GRAPH), + "modified": 1793320000000, + "size": len(json.dumps(GRAPH).encode()), + }, + } + calls = [] + + def request(url, request_target, **kwargs): + assert kwargs.get("method", "GET") == "GET" + assert kwargs["max_bytes"] > 0 + assert request_target is target + calls.append(urlsplit(url).path) + value = bodies[urlsplit(url).path] + if isinstance(value, Exception): + raise value + return 200, copy.deepcopy(value) + + monkeypatch.setattr(ui, "request_json", request) + return ui, bodies, calls, target + + +def test_standard_link_verifies_exact_userdata_snapshot(server): + ui, _, calls, _ = server + result = ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + assert result["savedFileId"] == WID + assert result["filename"] == "workflows/sub/My saved workflow.json" + assert result["verified"] is True + query = parse_qs(urlsplit(result["url"]).query) + assert query == {"savedFile": [WID], "workspace": [WORKSPACE], "environment": ["standard"]} + assert f"/api/userdata-files/{WID}" in calls + assert not any("/workflows/" in call or "/userdata/" in call for call in calls) + assert not urlsplit(result["url"]).fragment + assert "workflow_json" not in result + + +@pytest.mark.parametrize("flag", [None, False, 1, "true", {}, []]) +def test_missing_or_nonboolean_capability_cannot_produce_url(server, flag): + ui, bodies, calls, _ = server + bodies["/api/features"] = {} if flag is None else {"private_saved_file_links_enabled": flag} + with pytest.raises(ui.WorkflowUiUnavailable) as failure: + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + assert failure.value.reason == "capability_unavailable" + assert f"/api/workflows/{WID}" not in calls + + +@pytest.mark.parametrize("workspace", ["other-workspace", "", "../x", "bad&deployment=other"]) +def test_wrong_or_unsafe_workspace_is_refused(server, workspace): + ui, _, _, _ = server + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(WID, workspace=workspace, environment="standard") + + +@pytest.mark.parametrize( + "name", + [ + None, + "", + "../private", + "sub/../private", + "/rooted", + "sub//empty", + "sub/./file", + "sub\\file", + "bad\nfile", + "~hidden", + "sub/.. /file", + ], +) +def test_missing_or_unsafe_snapshot_path_is_refused(server, name): + ui, bodies, calls, _ = server + bodies[f"/api/userdata-files/{WID}"]["path"] = ( + ("~hidden.json" if name == "~hidden" else f"workflows/{name}.json") if isinstance(name, str) else name + ) + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + assert not any("/userdata/" in path for path in calls) + + +@pytest.mark.parametrize("bad_id", ["not-a-uuid", "../secret", WID + "?x=1", "", "a" * 32]) +def test_bad_workflow_identity_rejected_before_network(server, bad_id): + ui, _, calls, _ = server + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(bad_id, workspace=WORKSPACE, environment="standard") + assert calls == [] + + +def test_metadata_other_id_is_refused(server): + ui, bodies, _, _ = server + bodies[f"/api/userdata-files/{WID}"]["id"] = "other-id" + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + + +@pytest.mark.parametrize("field", ["id", "path", "modified", "size"]) +def test_malformed_metadata_is_refused(server, field): + ui, bodies, _, _ = server + bodies[f"/api/userdata-files/{WID}"].pop(field) + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + + +def test_inconsistent_snapshot_size_or_invalid_content_is_refused(server): + ui, bodies, _, _ = server + bodies[f"/api/userdata-files/{WID}"]["size"] += 1 + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + bodies[f"/api/userdata-files/{WID}"]["size"] -= 1 + bodies[f"/api/userdata-files/{WID}"]["content"] = "{bad json" + with pytest.raises(ui.WorkflowUiUnavailable) as failure: + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + assert failure.value.reason == "content_unverified" + + +def test_record_file_boolean_number_comparison_is_not_identity_evidence(server): + ui, bodies, calls, _ = server + bodies[f"/api/workflows/{WID}/content"]["workflow_json"]["extra"] = {"flag": True} + bodies["/api/userdata/workflows%2Fsub%2FMy%20saved%20workflow.json"]["extra"] = {"flag": 1} + # These legacy surfaces cannot affect the UUID-bound snapshot in either direction. + assert ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard")["savedFileId"] == WID + assert not any("/workflows/" in call or "/userdata/" in call for call in calls) + + +@pytest.mark.parametrize("point", ["metadata", "content", "file"]) +def test_legacy_record_surfaces_do_not_affect_actual_id_snapshot(server, point): + ui, bodies, calls, _ = server + paths = { + "metadata": f"/api/workflows/{WID}", + "content": f"/api/workflows/{WID}/content", + "file": "/api/userdata/workflows%2Fsub%2FMy%20saved%20workflow.json", + } + bodies[paths[point]] = urllib.error.HTTPError("https://cloud.test", 404, "missing", {}, None) + assert ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard")["savedFileId"] == WID + assert paths[point] not in calls + + +@pytest.mark.parametrize( + "environment,deployment", [("standard", DEPLOYMENT), ("custom", None), ("invalid", None), ("custom", "../escape")] +) +def test_environment_deployment_conflicts_refused_before_network(server, environment, deployment): + ui, _, calls, _ = server + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment=environment, deployment_id=deployment) + assert calls == [] + + +def test_oauth_session_required(server, monkeypatch): + ui, _, calls, _ = server + monkeypatch.setattr( + ui, "resolve_target", lambda **kw: Target(kind="cloud", base_url="https://cloud.test", api_key="test-key") + ) + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + assert calls == [] + + +def test_custom_link_reuses_exact_verified_deployment_target(server, monkeypatch): + ui, _, _, _ = server + control = Mock() + control.get_deployment.return_value = {"id": DEPLOYMENT, "releaseId": "release-1", "status": "ready"} + monkeypatch.setattr(ui, "_deployment_client", lambda: control) + verified = Mock( + return_value={ + "workspaceId": WORKSPACE, + "deploymentId": DEPLOYMENT, + "releaseId": "release-1", + "url": "https://cloud.test/?workspace=" + WORKSPACE + "&deployment=" + DEPLOYMENT, + } + ) + monkeypatch.setattr(ui, "verify_deployment_editor_target", verified) + result = ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="custom", deployment_id=DEPLOYMENT) + assert parse_qs(urlsplit(result["url"]).query) == { + "savedFile": [WID], + "workspace": [WORKSPACE], + "deployment": [DEPLOYMENT], + } + assert result["releaseId"] == "release-1" + control.get_deployment.assert_called_once_with(DEPLOYMENT) + assert verified.call_args.kwargs["workspace_id"] == WORKSPACE + + +def test_error_response_never_leaks_private_prompts_or_credentials(server, monkeypatch): + ui, _, _, _ = server + renderer = Mock() + monkeypatch.setattr(ui, "get_renderer", lambda: renderer) + monkeypatch.setattr(ui, "request_json", Mock(side_effect=ValueError("SECRET PRIVATE PROMPT oauth-token"))) + with pytest.raises(Exception): + ui.run_ui(saved_file_id=WID, workspace=WORKSPACE, environment="standard") + error = renderer.error.call_args.kwargs + assert error["code"] == "workflow_ui_unavailable" + assert "SECRET" not in json.dumps(error) + assert "oauth-token" not in json.dumps(error) + + +def test_cli_environment_is_a_real_parser_choice(monkeypatch): + from comfy_cli.command import workflow_ui as ui + + action = Mock() + monkeypatch.setattr(ui, "run_ui", action) + result = CliRunner().invoke(cmd.app, ["ui", WID, "--workspace", WORKSPACE, "--environment", "bogus"]) + assert result.exit_code == 2 + action.assert_not_called() + + +@pytest.mark.parametrize("change", ["stopped", "wrong-release", "missing", "duplicate", "editor-disabled"]) +def test_custom_link_uses_real_shared_deployment_verification(server, monkeypatch, change): + ui, _, _, target = server + control = Mock() + control.get_deployment.return_value = { + "id": DEPLOYMENT, + "releaseId": "release-1", + "status": "stopped" if change == "stopped" else "ready", + } + if change == "editor-disabled": + control.get_deployment.return_value["editor"] = False + monkeypatch.setattr(ui, "_deployment_client", lambda: control) + row = { + "deployment_id": DEPLOYMENT, + "release_id": "other" if change == "wrong-release" else "release-1", + "status": "ready", + } + rows = [] if change == "missing" else [row, row] if change == "duplicate" else [row] + cloud = Mock() + cloud.target = target + cloud.list_workspace_deployments.return_value = {"items": rows} + monkeypatch.setattr(ui, "Client", lambda selected: cloud) + with pytest.raises(ui.WorkflowUiUnavailable) as failure: + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="custom", deployment_id=DEPLOYMENT) + assert failure.value.reason == "deployment_unverified" + + +def test_custom_link_real_shared_verifier_passes_and_schema_matches(server, monkeypatch): + from pathlib import Path + + import jsonschema + + ui, _, _, target = server + control = Mock() + control.get_deployment.return_value = {"id": DEPLOYMENT, "releaseId": "release-1", "status": "ready"} + monkeypatch.setattr(ui, "_deployment_client", lambda: control) + cloud = Mock() + cloud.target = target + cloud.list_workspace_deployments.return_value = { + "items": [{"deployment_id": DEPLOYMENT, "release_id": "release-1", "status": "ready"}] + } + monkeypatch.setattr(ui, "Client", lambda selected: cloud) + schema = json.loads((Path(cmd.__file__).parent.parent / "schemas/workflow_ui.json").read_text()) + custom = ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="custom", deployment_id=DEPLOYMENT) + standard = ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + for result in [custom, standard]: + jsonschema.Draft202012Validator(schema).validate(result) + cloud.list_workspace_deployments.assert_called_once_with(WORKSPACE) + + +@pytest.mark.parametrize("location", ["metadata", "content", "userdata", "features"]) +def test_malformed_bodies_are_refused_without_content_in_errors(server, location): + ui, bodies, _, _ = server + malformed = { + "metadata": None, + "content": ["SECRET PRIVATE PROMPT"], + "userdata": {"id": WID, "content": ["SECRET PRIVATE PROMPT"]}, + "features": ["SECRET PRIVATE PROMPT"], + } + bodies["/api/features" if location == "features" else f"/api/userdata-files/{WID}"] = malformed[location] + with pytest.raises(ui.WorkflowUiUnavailable) as failure: + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + assert "SECRET" not in str(failure.value) + + +def test_actual_read_only_http_transport_and_single_segment_userdata_encoding(server, monkeypatch): + import io + + from comfy_cli import http + + ui, bodies, _, _ = server + observed = [] + + class Response(io.BytesIO): + status = 200 + + def open_request(request, *, timeout): + assert request.get_method() == "GET" + assert request.get_header("Authorization") == "Bearer oauth-test" + assert timeout == 15 + observed.append(urlsplit(request.full_url).path) + return Response(json.dumps(bodies[observed[-1]]).encode()) + + monkeypatch.setattr(http._AUTHED_OPENER, "open", open_request) + monkeypatch.setattr(ui, "request_json", http.request_json) + assert ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard")["verified"] is True + assert observed[-1] == f"/api/userdata-files/{WID}" + + +@pytest.mark.parametrize("field", ["content", "path"]) +def test_content_requires_the_frontend_response_contract(server, field): + ui, bodies, _, _ = server + bodies[f"/api/userdata-files/{WID}"].pop(field) + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + + +@pytest.mark.parametrize("field", ["modified", "size"]) +def test_snapshot_numeric_metadata_must_be_valid(server, field): + ui, bodies, _, _ = server + bodies[f"/api/userdata-files/{WID}"][field] = "not-a-number" + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") + + +@pytest.mark.parametrize( + "field,value", [("default_view", "unknown"), ("description", 12), ("forked_from", {"workflow_id": 12})] +) +def test_optional_record_metadata_is_not_file_identity_evidence(server, field, value): + ui, bodies, _, _ = server + bodies[f"/api/workflows/{WID}"][field] = value + assert ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard")["savedFileId"] == WID + + +def test_record_asset_references_are_not_file_identity_evidence(server): + ui, bodies, _, _ = server + bodies[f"/api/workflows/{WID}/content"]["dependency_asset_ids"] = [42] + assert ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard")["savedFileId"] == WID + + +@pytest.mark.parametrize( + "graph", [{"nodes": []}, {"version": 0.4, "last_node_id": 1, "last_link_id": 0, "nodes": [{}], "links": []}] +) +def test_actual_consumer_invalid_graph_is_not_a_verified_normal_link(server, graph): + ui, bodies, _, _ = server + text = json.dumps(graph) + bodies[f"/api/userdata-files/{WID}"].update(content=text, size=len(text.encode())) + with pytest.raises(ui.WorkflowUiUnavailable): + ui.verify_workflow_link(WID, workspace=WORKSPACE, environment="standard") diff --git a/tests/comfy_cli/conftest.py b/tests/comfy_cli/conftest.py index 522edcf38..3277591f7 100644 --- a/tests/comfy_cli/conftest.py +++ b/tests/comfy_cli/conftest.py @@ -72,6 +72,10 @@ def _isolate_config_path(tmp_path, monkeypatch): # whichever ``get_os()`` resolves to lands in our tmp dir. for k in list(constants.DEFAULT_CONFIG.keys()): monkeypatch.setitem(constants.DEFAULT_CONFIG, k, str(fake_root)) + # Constants patched in this process do not reach CLI subprocesses. Give + # each test its own supported store override, also replacing any ambient + # override so credential writes cannot leak between tests or reach a user. + monkeypatch.setenv("COMFY_SECRETS_PATH", str(fake_root / "secrets.json")) # ConfigManager is a @singleton that reads the config dir once, at # construction — so repointing the dir alone leaves the FIRST test's # in-memory config serving every later one. Any test that runs the CLI @@ -169,3 +173,83 @@ def test_my_pretty_thing(pretty_no_stdout): "that to be empty (all output goes to stderr in pretty mode):\n" f" stdout = {captured.out!r}\n" ) + + +@pytest.fixture(autouse=True) +def _isolate_comfy_desktop(tmp_path, monkeypatch): + """Point Comfy Desktop detection at an empty per-test dir. + + ``comfy which`` / ``comfy env`` (and ``comfy build init``) read Desktop's + ``installations.json`` and ``settings.json`` from the real app-data dir. + On a developer machine with Desktop installed, every test touching those + commands would otherwise see that machine's installs. A test that wants a + Desktop install builds one with the ``comfy_desktop`` fixture. + """ + from comfy_cli import desktop_install + + monkeypatch.setattr(desktop_install, "desktop_app_data_dir", lambda: tmp_path / "no-comfy-desktop") + monkeypatch.setattr(desktop_install, "legacy_config_dir", lambda: None) + yield + + +@pytest.fixture +def comfy_desktop(tmp_path, monkeypatch): + """A Comfy Desktop 2 install laid out the way the bug report found it. + + An install adopted from Desktop 1: the ComfyUI checkout under + ``/ComfyUI``, the data (models, custom_nodes, venv) in the + Desktop 1 base path (``config.json`` → ``basePath``, copied into the + record as ``adoptedBaseDir``), and a shared model library listed in + ``settings.json`` → ``modelsDirs`` alongside the data dir's own + ``models/``. Detection is pointed at it; the returned dict names each part. + """ + import json + + from comfy_cli import desktop_install + + install_path = tmp_path / "ComfyUI-Installs" / "ComfyUI" + code = install_path / "ComfyUI" + code.mkdir(parents=True) + (code / "main.py").write_text("") + data = tmp_path / "Documents" / "ComfyUI" + for sub in ("models/checkpoints", "custom_nodes", "user"): + (data / sub).mkdir(parents=True) + python = data / ".venv" / "bin" / "python3" + python.parent.mkdir(parents=True) + python.write_text("") + shared = tmp_path / "ComfyUI-Shared" / "models" + shared.mkdir(parents=True) + legacy = tmp_path / "Application Support" / "ComfyUI" + legacy.mkdir(parents=True) + (legacy / "config.json").write_text(json.dumps({"basePath": str(data)})) + record = { + "id": "inst-adopted", + "name": "ComfyUI", + "sourceId": "standalone", + "installPath": str(install_path), + "adopted": True, + "adoptedBaseDir": str(data), + "adoptedPythonPath": str(python), + "comfyVersion": {"commit": "b53f77a7", "baseTag": "v0.34.2", "commitsAhead": 0}, + "useSharedModels": True, + "status": "installed", + "lastLaunchedAt": 1792188627164, + } + cloud = {"id": "inst-cloud", "name": "Comfy Cloud", "sourceId": "cloud", "remoteUrl": "https://cloud.comfy.org/"} + app = tmp_path / "Application Support" / "Comfy Desktop" + app.mkdir(parents=True) + (app / "installations.json").write_text(json.dumps([record, cloud])) + (app / "settings.json").write_text(json.dumps({"modelsDirs": [str(shared), str(data / "models")]})) + + monkeypatch.setattr(desktop_install, "desktop_app_data_dir", lambda: app) + monkeypatch.setattr(desktop_install, "legacy_config_dir", lambda: legacy) + return { + "app": app, + "legacy": legacy, + "install_path": install_path, + "code": code, + "data": data, + "python": python, + "shared": shared, + "record": record, + } diff --git a/tests/comfy_cli/fixtures/cloud_workflow_consumer/README.md b/tests/comfy_cli/fixtures/cloud_workflow_consumer/README.md new file mode 100644 index 000000000..81a22d8e3 --- /dev/null +++ b/tests/comfy_cli/fixtures/cloud_workflow_consumer/README.md @@ -0,0 +1,44 @@ +# Frontend saved-canvas acceptance oracle + +`corpus.json` contains 826 JSON inputs, with verdicts and normalized outputs produced by actual frontend `validateComfyWorkflow`. No Python implementation supplied expected results. The checked-in generator documents/repeats the oracle call; provenance identifies frontend commit, Node26.8.2, Zod4.6.5, frontend lockfile SHA256 and SHA256s of all runtime sources used. No authentication, remote APIs or workflow execution is involved. + +Run from the frontend checkout with its locked dependencies and supported Node: + +```sh +FRONTEND_ROOT="$PWD" node --import tsx /absolute/canonical-cli/tests/comfy_cli/fixtures/cloud_workflow_consumer/generate.mjs +``` + +Each case contains `id`, `input`, `accepted`, and (when accepted) `normalized`. Nonfinite numbers in normalized output use `{"$number":"Infinity"}` tags; inputs remain plain JSON. The validator can produce Infinity from a long slot string, despite rejecting a nonfinite JSON number. Corpus covers both 0.4 and 1, node/graph required fields, recursive subgraph definitions, numeric string slots, model URLs, registry metadata, widgets, presentation ID keys, preserved opaque metadata and vector normalization. + +## Acceptance semantics omitted by the generated JSON Schema + +Use source-aware keywords on known schema positions. Do not recursively interpret arbitrary fields by name: opaque widget objects and unknown graph metadata can legitimately contain `ver`, `origin_slot`, or `nodes` keys. + +- Slot string conversion is JavaScript `parseInt(value)` with no radix, accepted whenever the result is not NaN. Trim ECMAScript whitespace, optional sign, infer hexadecimal only for `0x`/`0X`, then consume the longest valid digit prefix. Examples: `12tail`→12, `1.9`→1, `1e3`→1, `0b10`→0, `-0xF`→-15. Empty/whitespace-only, `NaN`, `Infinity` and lone `0x` reject. String-derived unsafe integers and Infinity are accepted; number-derived slots must be safe integers. NBSP and BOM are whitespace, U+0085 and U+200B are not. +- `cnr_id` additional refine rejects start/end `[_\-.]`; its already-exported regex is stronger and contains this condition: `^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$`, length1–100. Python JSON Schema uses Python regex semantics: its `$` can match before final LF, unlike the frontend regex. Therefore apply explicit full-match validation even though the generated pattern looks complete. +- `aux_id` splits exactly one slash and validates username length1–39 with `^(?!-)(?!.*--)[a-zA-Z0-9-]+(? {})", + "node_version": "26.8.2", + "zod_version": "4.6.5", + "frontend_lockfile_sha256": "4297df076b7fb8b4b0328aa2f2d5ed7ec1fa1e7d2c48b80c97442c5abc0fcc37", + "generated_at": "2026-10-24", + "sources": { + "src/platform/workflow/validation/schemas/workflowSchema.ts": "9485268f5cd12305ffb03d4ffc711588846a59fb603bb4311add0a16063e4a49", + "src/types/linkId.ts": "ebcec86190f31e0e3a5738659cdf00d8b07850388b7ac7d663cbe9beaf0546e0", + "src/lib/litegraph/src/types/widgets.ts": "31af22f25acb97b868b7006b9b6ca9fb4f5d401608019040f774fdde8243ca85" + }, + "export_command": "FRONTEND_ROOT= node --import tsx /tests/comfy_cli/fixtures/cloud_workflow_consumer/generate.mjs (cwd frontend)" + }, + "nonfinite_normalized_encoding": "Infinity/-Infinity/NaN emitted as {$number: } only in normalized output; inputs are plain JSON", + "cases": [ + { + "id": "0.4/minimal", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/empty-canvas", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/incomplete-node", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + {} + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-node-id", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-node-type", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-node-pos", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-node-size", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-node-flags", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-node-order", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-node-mode", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-node-properties", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0 + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-graph-version", + "input": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-graph-nodes", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-graph-last_node_id", + "input": { + "version": 0.4, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-graph-last_link_id", + "input": { + "version": 0.4, + "last_node_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/missing-graph-links", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-0", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "0", + 1, + "0", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 0, + 1, + 0, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-0", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-1", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "1", + 1, + "1", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 1, + 1, + 1, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-1", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "1" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 1 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-2", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "-1", + 1, + "-1", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + -1, + 1, + -1, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-2", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "-1" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": -1 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-3", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "+12", + 1, + "+12", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 12, + 1, + 12, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-3", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "+12" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 12 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-4", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + " 3 ", + 1, + " 3 ", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 3, + 1, + 3, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-4", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": " 3 " + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 3 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-5", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "\t4", + 1, + "\t4", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 4, + 1, + 4, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-5", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "\t4" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 4 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-6", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "12tail", + 1, + "12tail", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 12, + 1, + 12, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-6", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "12tail" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 12 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-7", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "1.9", + 1, + "1.9", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 1, + 1, + 1, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-7", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "1.9" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 1 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-8", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "0x10", + 1, + "0x10", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 16, + 1, + 16, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-8", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0x10" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 16 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-9", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "-0xF", + 1, + "-0xF", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + -15, + 1, + -15, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-9", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "-0xF" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": -15 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-10", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "0b10", + 1, + "0b10", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 0, + 1, + 0, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-10", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0b10" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-11", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "0o10", + 1, + "0o10", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 0, + 1, + 0, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-11", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0o10" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-12", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "1e3", + 1, + "1e3", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 1, + 1, + 1, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-12", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "1e3" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 1 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-13", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "1_000", + 1, + "1_000", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 1, + 1, + 1, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-13", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "1_000" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 1 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-14", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "", + 1, + "", + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-14", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-15", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + " ", + 1, + " ", + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-15", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": " " + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-16", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "junk", + 1, + "junk", + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-16", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "junk" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-17", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "NaN", + 1, + "NaN", + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-17", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "NaN" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-18", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "Infinity", + 1, + "Infinity", + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-18", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "Infinity" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-19", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "0x", + 1, + "0x", + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-19", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0x" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-20", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "9007199254740992", + 1, + "9007199254740992", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 9007199254740992, + 1, + 9007199254740992, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-20", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "9007199254740992" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 9007199254740992 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-21", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", + 1, + "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + { + "$number": "Infinity" + }, + 1, + { + "$number": "Infinity" + }, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-21", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": { + "$number": "Infinity" + } + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-22", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + " 12tail", + 1, + " 12tail", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 12, + 1, + 12, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-22", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": " 12tail" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 12 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-23", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "-0x10", + 1, + "-0x10", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + -16, + 1, + -16, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-23", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "-0x10" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": -16 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-24", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "…12", + 1, + "…12", + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-24", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "…12" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-25", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "​1", + 1, + "​1", + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-25", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "​1" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-26", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "-0", + 1, + "-0", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 0, + 1, + 0, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-26", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "-0" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-27", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "+0xF", + 1, + "+0xF", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 15, + 1, + 15, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-27", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "+0xF" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 15 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-28", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "0Xff", + 1, + "0Xff", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 255, + 1, + 255, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-28", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0Xff" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 255 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-29", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "
12", + 1, + "
12", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 12, + 1, + 12, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-29", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "
12" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 12 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-30", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "١", + 1, + "١", + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-30", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "١" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-31", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + "12١", + 1, + "12١", + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 12, + 1, + 12, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-31", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "12١" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 12 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-32", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 0, + 1, + 0, + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 0, + 1, + 0, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-32", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-33", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + -1, + 1, + -1, + "IMAGE" + ] + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + -1, + 1, + -1, + "IMAGE" + ] + ], + "version": 0.4 + } + }, + { + "id": "0.4/input-slot-33", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": -1 + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": -1 + } + ], + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/link-slot-34", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 0.5, + 1, + 0.5, + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-34", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0.5 + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-35", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + 9007199254740992, + 1, + 9007199254740992, + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-35", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 9007199254740992 + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-36", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + null, + 1, + null, + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-36", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": null + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-slot-37", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + [ + 1, + 1, + true, + 1, + true, + "IMAGE" + ] + ] + }, + "accepted": false + }, + { + "id": "0.4/input-slot-37", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": true + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-cnr_id-0", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-aux_id-0", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-ver-0", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-cnr_id-1", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc\r" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-aux_id-1", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo\r" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-ver-1", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3\r" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-cnr_id-2", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc\r\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-aux_id-2", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo\r\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-ver-2", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3\r\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-cnr_id-3", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-aux_id-3", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-ver-3", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-cnr_id-4", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-aux_id-4", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/metadata-line-ending-ver-4", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/cnr-0", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "valid-id" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "valid-id" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/cnr-1", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "a" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "a" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/cnr-2", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc.def_12-foo" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc.def_12-foo" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/cnr-3", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/cnr-4", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "_bad" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/cnr-5", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "bad-" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/cnr-6", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "éx" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/cnr-7", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "a/b" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/cnr-8", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/aux-0", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/bar" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/bar" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/aux-1", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "Foo-1/repo.name" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "Foo-1/repo.name" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/aux-2", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "-foo/repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/aux-3", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo-/repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/aux-4", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo--bar/repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/aux-5", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/_repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/aux-6", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo_" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/aux-7", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/aux-8", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/bar/baz" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/aux-9", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "é/repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/aux-10", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "a/b" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "a/b" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/aux-11", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "a/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/r" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-0", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "unknown" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "unknown" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/ver-1", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/ver-2", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "v1.2.3" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/ver-3", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3-beta.1+build.4" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3-beta.1+build.4" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/ver-4", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3-01" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3-01" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/ver-5", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "01.2.3" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-6", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-7", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "bad" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-8", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "abcd" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "abcd" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/ver-9", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "ABCD" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "ABCD" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/ver-10", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "vABCD" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "ABCD" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/ver-11", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "abc" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-12", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/ver-13", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-14", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "V1.2.3" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-15", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "vunknown" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-16", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3-Beta" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-17", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1२.2.3" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-18", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-19", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": 1 + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/ver-20", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": null + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/widget-0", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [ + null, + 1, + true, + "x", + {}, + [ + 1, + { + "x": "y" + } + ] + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [ + null, + 1, + true, + "x", + {}, + [ + 1, + { + "x": "y" + } + ] + ] + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/widget-1", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": { + "positive": "hello", + "nested": { + "x": [] + }, + "length": 10001 + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": { + "positive": "hello", + "nested": { + "x": [] + }, + "length": 10001 + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/widget-2", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [] + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/widget-3", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": {} + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/widget-4", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": "text" + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/widget-5", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": null + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/widget-6", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": 1 + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/widget-7", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": true + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/link-presentation-key-0", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "0": { + "hidden": true + } + } + } + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "0": { + "hidden": true + } + } + }, + "version": 0.4 + } + }, + { + "id": "0.4/link-presentation-key-1", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "-1": { + "hidden": true + } + } + } + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "-1": { + "hidden": true + } + } + }, + "version": 0.4 + } + }, + { + "id": "0.4/link-presentation-key-2", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "1": { + "hidden": true + } + } + } + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "1": { + "hidden": true + } + } + }, + "version": 0.4 + } + }, + { + "id": "0.4/link-presentation-key-3", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "01": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "0.4/link-presentation-key-4", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "+1": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "0.4/link-presentation-key-5", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "-0": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "0.4/link-presentation-key-6", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "1.0": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "0.4/link-presentation-key-7", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "1e3": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "0.4/link-presentation-key-8", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + " 1": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "0.4/link-presentation-key-9", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "0.4/link-presentation-key-10", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "9007199254740991": { + "hidden": true + } + } + } + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "9007199254740991": { + "hidden": true + } + } + }, + "version": 0.4 + } + }, + { + "id": "0.4/link-presentation-key-11", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "9007199254740992": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "0.4/vector-object-normalization", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": { + "0": 7, + "1": -2, + "extra": "removed" + }, + "size": { + "0": 200, + "1": 100 + }, + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 7, + -2 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/bad-vector-object", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": { + "0": 7 + }, + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "0.4/arbitrary-property-kept", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "custom": { + "fn": "opaque", + "list": [] + } + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "custom": { + "fn": "opaque", + "list": [] + } + } + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/recursive-subgraphs", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + } + ] + } + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "definitions": { + "subgraphs": [ + { + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + }, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + } + }, + { + "id": "0.4/recursive-subgraph-invalid-slot", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "outputs": [ + { + "name": "x", + "type": "IMAGE", + "slot_index": "NaN" + } + ] + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + } + ] + } + }, + "accepted": false + }, + { + "id": "0.4/recursive-subgraph-invalid-pack", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "nonsense" + } + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + } + ] + } + }, + "accepted": false + }, + { + "id": "0.4/recursive-subgraph-vector-normalization", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": { + "0": 1, + "1": 2 + }, + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "definitions": { + "subgraphs": [ + { + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 1, + 2 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + } + }, + { + "id": "0.4/recursive-subgraph-missing-state", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "version": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + }, + "accepted": false + }, + { + "id": "0.4/root-unknown-field-kept", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "customMetadata": { + "x": 1, + "ver": "invalid", + "origin_slot": "NaN", + "nodes": [ + { + "properties": { + "ver": "invalid" + } + } + ] + } + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "customMetadata": { + "x": 1, + "ver": "invalid", + "origin_slot": "NaN", + "nodes": [ + { + "properties": { + "ver": "invalid" + } + } + ] + } + } + }, + { + "id": "0.4/opaque-widget-metadata-kept", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [ + { + "ver": "invalid", + "origin_slot": "NaN", + "nodes": [ + {} + ] + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [ + { + "ver": "invalid", + "origin_slot": "NaN", + "nodes": [ + {} + ] + } + ] + } + ], + "links": [], + "version": 0.4 + } + }, + { + "id": "0.4/url-boundary-empty", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-relative-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "models/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-relative-root", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "/models/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-relative-parent", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "../foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-relative-query", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "?model=foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-relative-fragment", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "#foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-relative-protocol", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "//example.com/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-https-no-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-https-missing-host-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:///foo", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https:///foo", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-https-one-slash", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https:/foo", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-https-no-slash", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:foo", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https:foo", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-https-empty-port", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:/foo", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-https-negative-port", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:-1/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-https-max-port", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:65535/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:65535/foo", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-https-overflow-port", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:65536/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-file-empty", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "file:", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-file-local", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:///tmp/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "file:///tmp/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-file-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file://localhost/tmp/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "file://localhost/tmp/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-file-relative", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:relative", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "file:relative", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-file-drive", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:///C:/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "file:///C:/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-opaque-custom", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:opaque", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "custom:opaque", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-opaque-empty", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "custom:", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-custom-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom://example.com/path", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "custom://example.com/path", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-custom-no-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:///path", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "custom:///path", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-opaque-space", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:hello world", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "custom:hello world", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-opaque-unicode", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:é🙂", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "custom:é🙂", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-data", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "data:text/plain,model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "data:text/plain,model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-about", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "about:blank", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "about:blank", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-mailto-empty", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "mailto:", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "mailto:", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-javascript-empty", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "javascript:", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "javascript:", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-invalid-scheme", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "1custom:path", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-scheme-space", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom :path", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-percent-lone", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-percent-short", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%2", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%2", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-percent-invalid", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%GG", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%GG", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-percent-host-invalid", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa%mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-percent-host-invalid-hex", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://%GG/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-percent-host-unicode", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://%C3%A9xample.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://%C3%A9xample.com/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-percent-host-bad-utf8", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://%FF/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-percent-encoded-surrogate", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%ED%A0%80", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%ED%A0%80", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-percent-null-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%00", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%00", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-percent-null-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://%00/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-idn-unicode", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://例え.テスト/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://例え.テスト/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-idn-punycode", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://xn--r8jz45g.xn--zckzah/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://xn--r8jz45g.xn--zckzah/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-idn-fullwidth", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-idn-bad-punycode", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://xn--/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://xn--/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-idn-joiner", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://a‍b.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-ipv6-loopback", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://[::1]/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://[::1]/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-ipv6-full", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://[2001:db8::1]:443/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://[2001:db8::1]:443/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-ipv6-unclosed", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://[::1/model", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-ipv6-zone", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://[fe80::1%25en0]/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-ipv6-unbracketed", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://::1/model", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-ipv4-hex", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://0x7f000001/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://0x7f000001/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-ipv4-short", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://127.1/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://127.1/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-ipv4-bad", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://256.1.1.1/model", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-credentials", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://user:pass@example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://user:pass@example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-backslashes", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:\\example.commodel", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https:\\example.commodel", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-space-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa mple.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-newline-scheme", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "ht\ntps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-tab-scheme", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "ht\ttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-path-high-surrogate", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-query-high-surrogate", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-fragment-high-surrogate", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-host-high-surrogate", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://\ud800.example/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-opaque-high-surrogate", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "custom:\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-path-low-surrogate", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\udfff", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\udfff", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-query-low-surrogate", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\udfff", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\udfff", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-fragment-low-surrogate", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\udfff", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\udfff", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-host-low-surrogate", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://\udfff.example/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-opaque-low-surrogate", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:\udfff", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "custom:\udfff", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-path-pair", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/🙂", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/🙂", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-query-pair", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=🙂", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=🙂", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-fragment-pair", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#🙂", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#🙂", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-host-pair", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://🙂.example/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://🙂.example/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-opaque-pair", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:🙂", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "custom:🙂", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-path-replacement", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/�", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/�", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-query-replacement", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=�", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=�", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-fragment-replacement", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#�", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#�", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-host-replacement", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://�.example/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-opaque-replacement", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:�", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "custom:�", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-path-reversed-pair", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\udfff\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\udfff\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-query-reversed-pair", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\udfff\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\udfff\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-fragment-reversed-pair", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\udfff\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\udfff\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-host-reversed-pair", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://\udfff\ud800.example/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-opaque-reversed-pair", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:\udfff\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "custom:\udfff\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-00-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0000https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0000https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-00-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0000", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0000", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-00-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0000b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0000b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-00-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0000mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-01-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0001https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0001https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-01-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0001", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0001", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-01-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0001b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0001b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-01-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0001mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-02-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0002https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0002https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-02-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0002", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0002", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-02-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0002b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0002b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-02-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0002mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-03-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0003https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0003https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-03-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0003", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0003", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-03-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0003b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0003b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-03-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0003mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-04-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0004https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0004https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-04-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0004", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0004", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-04-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0004b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0004b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-04-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0004mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-05-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0005https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0005https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-05-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0005", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0005", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-05-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0005b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0005b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-05-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0005mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-06-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0006https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0006https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-06-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0006", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0006", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-06-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0006b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0006b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-06-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0006mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-07-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0007https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0007https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-07-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0007", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0007", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-07-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0007b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0007b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-07-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0007mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-08-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\bhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\bhttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-08-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-08-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\bb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\bb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-08-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\bmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-09-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\thttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-09-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\t", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-09-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\tb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/ab", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-09-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\tmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0a-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\nhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0a-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\n", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0a-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\nb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/ab", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0a-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\nmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0b-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u000bhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0b-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u000b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0b-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000bb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000bb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0b-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u000bmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-0c-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\fhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0c-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\f", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0c-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\fb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\fb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0c-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\fmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-0d-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\rhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0d-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\r", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0d-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\rb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/ab", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0d-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\rmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0e-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u000ehttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u000ehttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0e-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u000e", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u000e", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0e-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000eb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000eb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0e-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u000emple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-0f-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u000fhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u000fhttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0f-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u000f", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u000f", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0f-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000fb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000fb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-0f-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u000fmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-10-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0010https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0010https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-10-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0010", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0010", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-10-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0010b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0010b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-10-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0010mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-11-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0011https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0011https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-11-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0011", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0011", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-11-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0011b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0011b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-11-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0011mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-12-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0012https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0012https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-12-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0012", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0012", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-12-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0012b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0012b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-12-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0012mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-13-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0013https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0013https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-13-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0013", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0013", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-13-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0013b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0013b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-13-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0013mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-14-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0014https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0014https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-14-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0014", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0014", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-14-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0014b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0014b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-14-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0014mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-15-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0015https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0015https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-15-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0015", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0015", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-15-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0015b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0015b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-15-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0015mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-16-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0016https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0016https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-16-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0016", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0016", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-16-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0016b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0016b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-16-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0016mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-17-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0017https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0017https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-17-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0017", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0017", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-17-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0017b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0017b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-17-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0017mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-18-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0018https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0018https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-18-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0018", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0018", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-18-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0018b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0018b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-18-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0018mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-19-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0019https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u0019https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-19-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0019", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0019", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-19-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0019b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0019b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-19-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0019mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-1a-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001ahttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u001ahttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1a-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001a", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001a", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1a-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001ab", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001ab", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1a-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001ample.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-1b-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001bhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u001bhttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1b-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1b-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001bb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001bb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1b-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001bmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-1c-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001chttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u001chttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1c-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001c", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001c", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1c-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001cb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001cb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1c-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001cmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-1d-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001dhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u001dhttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1d-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001d", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001d", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1d-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001db", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001db", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1d-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001dmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-1e-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001ehttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u001ehttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1e-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001e", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001e", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1e-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001eb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001eb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1e-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001emple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-1f-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001fhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "\u001fhttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1f-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001f", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001f", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1f-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001fb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001fb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-1f-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001fmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-20-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": " https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-20-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model ", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-20-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-20-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-7f-leading", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/url-boundary-c0-7f-trailing", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-7f-path", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/ab", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/ab", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/url-boundary-c0-7f-host", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/model-url-0", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model.safetensors", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model.safetensors", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/model-url-1", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "ftp://example.com/file", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "ftp://example.com/file", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/model-url-2", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "mailto:a@example.com", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "mailto:a@example.com", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/model-url-3", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "not-a-url", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/model-url-4", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/model-url-5", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "javascript:alert(1)", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "javascript:alert(1)", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/model-url-6", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://a b.com/file", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/model-url-7", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/model-url-8", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": " https://example.com/model ", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/model-url-9", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://éxample.com/file", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https://éxample.com/file", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "0.4/model-url-10", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:99999/file", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "0.4/model-url-11", + "input": { + "version": 0.4, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:example.com/file", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 0.4, + "models": [ + { + "name": "test.safetensors", + "url": "https:example.com/file", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/minimal", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/empty-canvas", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [], + "links": [] + } + }, + { + "id": "1/incomplete-node", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + {} + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/missing-node-id", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/missing-node-type", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/missing-node-pos", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/missing-node-size", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/missing-node-flags", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/missing-node-order", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/missing-node-mode", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/missing-node-properties", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0 + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/missing-graph-version", + "input": { + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/missing-graph-nodes", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "links": [] + }, + "accepted": false + }, + { + "id": "1/missing-graph-state", + "input": { + "version": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-0", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "0", + "target_id": 1, + "target_slot": "0", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 0, + "target_id": 1, + "target_slot": 0, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-0", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-1", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "1", + "target_id": 1, + "target_slot": "1", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 1, + "target_id": 1, + "target_slot": 1, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-1", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "1" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 1 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-2", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "-1", + "target_id": 1, + "target_slot": "-1", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": -1, + "target_id": 1, + "target_slot": -1, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-2", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "-1" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": -1 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-3", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "+12", + "target_id": 1, + "target_slot": "+12", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 12, + "target_id": 1, + "target_slot": 12, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-3", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "+12" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 12 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-4", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": " 3 ", + "target_id": 1, + "target_slot": " 3 ", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 3, + "target_id": 1, + "target_slot": 3, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-4", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": " 3 " + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 3 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-5", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "\t4", + "target_id": 1, + "target_slot": "\t4", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 4, + "target_id": 1, + "target_slot": 4, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-5", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "\t4" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 4 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-6", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "12tail", + "target_id": 1, + "target_slot": "12tail", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 12, + "target_id": 1, + "target_slot": 12, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-6", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "12tail" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 12 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-7", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "1.9", + "target_id": 1, + "target_slot": "1.9", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 1, + "target_id": 1, + "target_slot": 1, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-7", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "1.9" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 1 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-8", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "0x10", + "target_id": 1, + "target_slot": "0x10", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 16, + "target_id": 1, + "target_slot": 16, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-8", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0x10" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 16 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-9", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "-0xF", + "target_id": 1, + "target_slot": "-0xF", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": -15, + "target_id": 1, + "target_slot": -15, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-9", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "-0xF" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": -15 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-10", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "0b10", + "target_id": 1, + "target_slot": "0b10", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 0, + "target_id": 1, + "target_slot": 0, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-10", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0b10" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-11", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "0o10", + "target_id": 1, + "target_slot": "0o10", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 0, + "target_id": 1, + "target_slot": 0, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-11", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0o10" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-12", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "1e3", + "target_id": 1, + "target_slot": "1e3", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 1, + "target_id": 1, + "target_slot": 1, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-12", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "1e3" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 1 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-13", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "1_000", + "target_id": 1, + "target_slot": "1_000", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 1, + "target_id": 1, + "target_slot": 1, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-13", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "1_000" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 1 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-14", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "", + "target_id": 1, + "target_slot": "", + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-14", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-15", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": " ", + "target_id": 1, + "target_slot": " ", + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-15", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": " " + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-16", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "junk", + "target_id": 1, + "target_slot": "junk", + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-16", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "junk" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-17", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "NaN", + "target_id": 1, + "target_slot": "NaN", + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-17", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "NaN" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-18", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "Infinity", + "target_id": 1, + "target_slot": "Infinity", + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-18", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "Infinity" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-19", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "0x", + "target_id": 1, + "target_slot": "0x", + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-19", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0x" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-20", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "9007199254740992", + "target_id": 1, + "target_slot": "9007199254740992", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 9007199254740992, + "target_id": 1, + "target_slot": 9007199254740992, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-20", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "9007199254740992" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 9007199254740992 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-21", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", + "target_id": 1, + "target_slot": "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": { + "$number": "Infinity" + }, + "target_id": 1, + "target_slot": { + "$number": "Infinity" + }, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-21", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": { + "$number": "Infinity" + } + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-22", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": " 12tail", + "target_id": 1, + "target_slot": " 12tail", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 12, + "target_id": 1, + "target_slot": 12, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-22", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": " 12tail" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 12 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-23", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "-0x10", + "target_id": 1, + "target_slot": "-0x10", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": -16, + "target_id": 1, + "target_slot": -16, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-23", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "-0x10" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": -16 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-24", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "…12", + "target_id": 1, + "target_slot": "…12", + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-24", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "…12" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-25", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "​1", + "target_id": 1, + "target_slot": "​1", + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-25", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "​1" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-26", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "-0", + "target_id": 1, + "target_slot": "-0", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 0, + "target_id": 1, + "target_slot": 0, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-26", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "-0" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-27", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "+0xF", + "target_id": 1, + "target_slot": "+0xF", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 15, + "target_id": 1, + "target_slot": 15, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-27", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "+0xF" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 15 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-28", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "0Xff", + "target_id": 1, + "target_slot": "0Xff", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 255, + "target_id": 1, + "target_slot": 255, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-28", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "0Xff" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 255 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-29", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "
12", + "target_id": 1, + "target_slot": "
12", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 12, + "target_id": 1, + "target_slot": 12, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-29", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "
12" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 12 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-30", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "١", + "target_id": 1, + "target_slot": "١", + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-30", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "١" + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-31", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": "12١", + "target_id": 1, + "target_slot": "12١", + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 12, + "target_id": 1, + "target_slot": 12, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-31", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": "12١" + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 12 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-32", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 0, + "target_id": 1, + "target_slot": 0, + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 0, + "target_id": 1, + "target_slot": 0, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-32", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-33", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": -1, + "target_id": 1, + "target_slot": -1, + "type": "IMAGE" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": -1, + "target_id": 1, + "target_slot": -1, + "type": "IMAGE" + } + ] + } + }, + { + "id": "1/input-slot-33", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": -1 + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": -1 + } + ], + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/link-slot-34", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 0.5, + "target_id": 1, + "target_slot": 0.5, + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-34", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 0.5 + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-35", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": 9007199254740992, + "target_id": 1, + "target_slot": 9007199254740992, + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-35", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": 9007199254740992 + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-36", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": null, + "target_id": 1, + "target_slot": null, + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-36", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": null + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-slot-37", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [ + { + "id": 1, + "origin_id": 1, + "origin_slot": true, + "target_id": 1, + "target_slot": true, + "type": "IMAGE" + } + ] + }, + "accepted": false + }, + { + "id": "1/input-slot-37", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "inputs": [ + { + "name": "in", + "type": "IMAGE", + "slot_index": true + } + ] + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-cnr_id-0", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-aux_id-0", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-ver-0", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-cnr_id-1", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc\r" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-aux_id-1", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo\r" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-ver-1", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3\r" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-cnr_id-2", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc\r\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-aux_id-2", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo\r\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-ver-2", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3\r\n" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-cnr_id-3", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-aux_id-3", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-ver-3", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-cnr_id-4", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-aux_id-4", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/metadata-line-ending-ver-4", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3
" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/cnr-0", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "valid-id" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "valid-id" + } + } + ], + "links": [] + } + }, + { + "id": "1/cnr-1", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "a" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "a" + } + } + ], + "links": [] + } + }, + { + "id": "1/cnr-2", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc.def_12-foo" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "abc.def_12-foo" + } + } + ], + "links": [] + } + }, + { + "id": "1/cnr-3", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/cnr-4", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "_bad" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/cnr-5", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "bad-" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/cnr-6", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "éx" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/cnr-7", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "a/b" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/cnr-8", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "cnr_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/aux-0", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/bar" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/bar" + } + } + ], + "links": [] + } + }, + { + "id": "1/aux-1", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "Foo-1/repo.name" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "Foo-1/repo.name" + } + } + ], + "links": [] + } + }, + { + "id": "1/aux-2", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "-foo/repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/aux-3", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo-/repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/aux-4", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo--bar/repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/aux-5", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/_repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/aux-6", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/repo_" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/aux-7", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/aux-8", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "foo/bar/baz" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/aux-9", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "é/repo" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/aux-10", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "a/b" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "a/b" + } + } + ], + "links": [] + } + }, + { + "id": "1/aux-11", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "aux_id": "a/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/ra/r" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-0", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "unknown" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "unknown" + } + } + ], + "links": [] + } + }, + { + "id": "1/ver-1", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3" + } + } + ], + "links": [] + } + }, + { + "id": "1/ver-2", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "v1.2.3" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3" + } + } + ], + "links": [] + } + }, + { + "id": "1/ver-3", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3-beta.1+build.4" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3-beta.1+build.4" + } + } + ], + "links": [] + } + }, + { + "id": "1/ver-4", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3-01" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3-01" + } + } + ], + "links": [] + } + }, + { + "id": "1/ver-5", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "01.2.3" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-6", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-7", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "bad" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-8", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "abcd" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "abcd" + } + } + ], + "links": [] + } + }, + { + "id": "1/ver-9", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "ABCD" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "ABCD" + } + } + ], + "links": [] + } + }, + { + "id": "1/ver-10", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "vABCD" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "ABCD" + } + } + ], + "links": [] + } + }, + { + "id": "1/ver-11", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "abc" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-12", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + } + ], + "links": [] + } + }, + { + "id": "1/ver-13", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-14", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "V1.2.3" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-15", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "vunknown" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-16", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1.2.3-Beta" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-17", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "1२.2.3" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-18", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "" + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-19", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": 1 + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/ver-20", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": null + } + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/widget-0", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [ + null, + 1, + true, + "x", + {}, + [ + 1, + { + "x": "y" + } + ] + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [ + null, + 1, + true, + "x", + {}, + [ + 1, + { + "x": "y" + } + ] + ] + } + ], + "links": [] + } + }, + { + "id": "1/widget-1", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": { + "positive": "hello", + "nested": { + "x": [] + }, + "length": 10001 + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": { + "positive": "hello", + "nested": { + "x": [] + }, + "length": 10001 + } + } + ], + "links": [] + } + }, + { + "id": "1/widget-2", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [] + } + ], + "links": [] + } + }, + { + "id": "1/widget-3", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": {} + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": {} + } + ], + "links": [] + } + }, + { + "id": "1/widget-4", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": "text" + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/widget-5", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": null + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/widget-6", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": 1 + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/widget-7", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": true + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/link-presentation-key-0", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "0": { + "hidden": true + } + } + } + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "0": { + "hidden": true + } + } + } + } + }, + { + "id": "1/link-presentation-key-1", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "-1": { + "hidden": true + } + } + } + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "-1": { + "hidden": true + } + } + } + } + }, + { + "id": "1/link-presentation-key-2", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "1": { + "hidden": true + } + } + } + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "1": { + "hidden": true + } + } + } + } + }, + { + "id": "1/link-presentation-key-3", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "01": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "1/link-presentation-key-4", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "+1": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "1/link-presentation-key-5", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "-0": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "1/link-presentation-key-6", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "1.0": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "1/link-presentation-key-7", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "1e3": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "1/link-presentation-key-8", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + " 1": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "1/link-presentation-key-9", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "1/link-presentation-key-10", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "9007199254740991": { + "hidden": true + } + } + } + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "9007199254740991": { + "hidden": true + } + } + } + } + }, + { + "id": "1/link-presentation-key-11", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "extra": { + "linkPresentation": { + "9007199254740992": { + "hidden": true + } + } + } + }, + "accepted": false + }, + { + "id": "1/vector-object-normalization", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": { + "0": 7, + "1": -2, + "extra": "removed" + }, + "size": { + "0": 200, + "1": 100 + }, + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 7, + -2 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + } + }, + { + "id": "1/bad-vector-object", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": { + "0": 7 + }, + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "1/arbitrary-property-kept", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "custom": { + "fn": "opaque", + "list": [] + } + } + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "custom": { + "fn": "opaque", + "list": [] + } + } + } + ], + "links": [] + } + }, + { + "id": "1/recursive-subgraphs", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + } + ] + } + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + }, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + } + }, + { + "id": "1/recursive-subgraph-invalid-slot", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "outputs": [ + { + "name": "x", + "type": "IMAGE", + "slot_index": "NaN" + } + ] + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + } + ] + } + }, + "accepted": false + }, + { + "id": "1/recursive-subgraph-invalid-pack", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": { + "ver": "nonsense" + } + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + } + ] + } + }, + "accepted": false + }, + { + "id": "1/recursive-subgraph-vector-normalization", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": { + "0": 1, + "1": 2 + }, + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 1, + 2 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + } + }, + { + "id": "1/recursive-subgraph-missing-state", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "definitions": { + "subgraphs": [ + { + "version": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "id": "c327cae8-2acf-4bfa-bb88-97948a3c008b", + "revision": 1, + "name": "Nested", + "inputNode": { + "id": -10, + "bounding": [ + 0, + 0, + 100, + 100 + ] + }, + "outputNode": { + "id": -20, + "bounding": [ + 0, + 0, + 100, + 100 + ] + } + } + ] + } + }, + "accepted": false + }, + { + "id": "1/root-unknown-field-kept", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "customMetadata": { + "x": 1, + "ver": "invalid", + "origin_slot": "NaN", + "nodes": [ + { + "properties": { + "ver": "invalid" + } + } + ] + } + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "customMetadata": { + "x": 1, + "ver": "invalid", + "origin_slot": "NaN", + "nodes": [ + { + "properties": { + "ver": "invalid" + } + } + ] + } + } + }, + { + "id": "1/opaque-widget-metadata-kept", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [ + { + "ver": "invalid", + "origin_slot": "NaN", + "nodes": [ + {} + ] + } + ] + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {}, + "widgets_values": [ + { + "ver": "invalid", + "origin_slot": "NaN", + "nodes": [ + {} + ] + } + ] + } + ], + "links": [] + } + }, + { + "id": "1/url-boundary-empty", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-relative-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "models/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-relative-root", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "/models/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-relative-parent", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "../foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-relative-query", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "?model=foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-relative-fragment", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "#foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-relative-protocol", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "//example.com/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-https-no-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-https-missing-host-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:///foo", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:///foo", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-https-one-slash", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:/foo", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-https-no-slash", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:foo", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:foo", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-https-empty-port", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:/foo", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-https-negative-port", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:-1/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-https-max-port", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:65535/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:65535/foo", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-https-overflow-port", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:65536/foo", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-file-empty", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-file-local", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:///tmp/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:///tmp/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-file-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file://localhost/tmp/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file://localhost/tmp/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-file-relative", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:relative", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:relative", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-file-drive", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:///C:/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "file:///C:/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-opaque-custom", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:opaque", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:opaque", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-opaque-empty", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-custom-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom://example.com/path", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom://example.com/path", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-custom-no-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:///path", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:///path", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-opaque-space", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:hello world", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:hello world", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-opaque-unicode", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:é🙂", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:é🙂", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-data", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "data:text/plain,model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "data:text/plain,model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-about", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "about:blank", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "about:blank", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-mailto-empty", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "mailto:", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "mailto:", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-javascript-empty", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "javascript:", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "javascript:", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-invalid-scheme", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "1custom:path", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-scheme-space", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom :path", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-percent-lone", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-percent-short", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%2", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%2", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-percent-invalid", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%GG", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%GG", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-percent-host-invalid", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa%mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-percent-host-invalid-hex", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://%GG/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-percent-host-unicode", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://%C3%A9xample.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://%C3%A9xample.com/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-percent-host-bad-utf8", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://%FF/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-percent-encoded-surrogate", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%ED%A0%80", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%ED%A0%80", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-percent-null-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%00", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/%00", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-percent-null-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://%00/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-idn-unicode", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://例え.テスト/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://例え.テスト/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-idn-punycode", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://xn--r8jz45g.xn--zckzah/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://xn--r8jz45g.xn--zckzah/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-idn-fullwidth", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-idn-bad-punycode", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://xn--/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://xn--/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-idn-joiner", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://a‍b.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-ipv6-loopback", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://[::1]/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://[::1]/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-ipv6-full", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://[2001:db8::1]:443/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://[2001:db8::1]:443/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-ipv6-unclosed", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://[::1/model", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-ipv6-zone", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://[fe80::1%25en0]/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-ipv6-unbracketed", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://::1/model", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-ipv4-hex", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://0x7f000001/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://0x7f000001/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-ipv4-short", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://127.1/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://127.1/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-ipv4-bad", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://256.1.1.1/model", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-credentials", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://user:pass@example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://user:pass@example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-backslashes", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:\\example.commodel", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:\\example.commodel", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-space-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa mple.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-newline-scheme", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "ht\ntps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-tab-scheme", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "ht\ttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-path-high-surrogate", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-query-high-surrogate", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-fragment-high-surrogate", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-host-high-surrogate", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://\ud800.example/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-opaque-high-surrogate", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-path-low-surrogate", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\udfff", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\udfff", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-query-low-surrogate", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\udfff", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\udfff", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-fragment-low-surrogate", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\udfff", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\udfff", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-host-low-surrogate", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://\udfff.example/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-opaque-low-surrogate", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:\udfff", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:\udfff", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-path-pair", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/🙂", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/🙂", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-query-pair", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=🙂", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=🙂", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-fragment-pair", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#🙂", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#🙂", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-host-pair", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://🙂.example/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://🙂.example/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-opaque-pair", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:🙂", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:🙂", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-path-replacement", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/�", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/�", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-query-replacement", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=�", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=�", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-fragment-replacement", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#�", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#�", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-host-replacement", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://�.example/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-opaque-replacement", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:�", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:�", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-path-reversed-pair", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\udfff\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/\udfff\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-query-reversed-pair", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\udfff\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/?q=\udfff\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-fragment-reversed-pair", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\udfff\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/#\udfff\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-host-reversed-pair", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://\udfff\ud800.example/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-opaque-reversed-pair", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:\udfff\ud800", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "custom:\udfff\ud800", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-00-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0000https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0000https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-00-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0000", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0000", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-00-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0000b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0000b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-00-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0000mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-01-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0001https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0001https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-01-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0001", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0001", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-01-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0001b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0001b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-01-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0001mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-02-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0002https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0002https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-02-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0002", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0002", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-02-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0002b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0002b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-02-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0002mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-03-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0003https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0003https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-03-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0003", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0003", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-03-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0003b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0003b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-03-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0003mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-04-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0004https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0004https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-04-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0004", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0004", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-04-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0004b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0004b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-04-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0004mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-05-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0005https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0005https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-05-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0005", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0005", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-05-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0005b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0005b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-05-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0005mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-06-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0006https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0006https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-06-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0006", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0006", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-06-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0006b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0006b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-06-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0006mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-07-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0007https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0007https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-07-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0007", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0007", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-07-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0007b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0007b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-07-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0007mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-08-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\bhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\bhttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-08-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-08-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\bb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\bb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-08-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\bmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-09-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\thttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-09-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\t", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-09-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\tb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/ab", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-09-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\tmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0a-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\nhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0a-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\n", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0a-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\nb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/ab", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0a-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\nmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0b-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u000bhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0b-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u000b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0b-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000bb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000bb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0b-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u000bmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-0c-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\fhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0c-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\f", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0c-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\fb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\fb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0c-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\fmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-0d-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\rhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0d-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\r", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0d-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\rb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/ab", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0d-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\rmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0e-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u000ehttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u000ehttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0e-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u000e", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u000e", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0e-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000eb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000eb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0e-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u000emple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-0f-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u000fhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u000fhttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0f-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u000f", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u000f", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0f-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000fb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u000fb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-0f-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u000fmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-10-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0010https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0010https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-10-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0010", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0010", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-10-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0010b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0010b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-10-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0010mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-11-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0011https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0011https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-11-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0011", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0011", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-11-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0011b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0011b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-11-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0011mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-12-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0012https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0012https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-12-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0012", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0012", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-12-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0012b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0012b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-12-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0012mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-13-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0013https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0013https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-13-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0013", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0013", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-13-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0013b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0013b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-13-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0013mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-14-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0014https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0014https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-14-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0014", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0014", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-14-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0014b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0014b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-14-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0014mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-15-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0015https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0015https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-15-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0015", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0015", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-15-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0015b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0015b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-15-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0015mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-16-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0016https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0016https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-16-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0016", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0016", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-16-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0016b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0016b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-16-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0016mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-17-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0017https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0017https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-17-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0017", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0017", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-17-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0017b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0017b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-17-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0017mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-18-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0018https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0018https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-18-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0018", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0018", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-18-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0018b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0018b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-18-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0018mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-19-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0019https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u0019https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-19-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0019", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u0019", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-19-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0019b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u0019b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-19-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u0019mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-1a-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001ahttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001ahttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1a-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001a", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001a", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1a-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001ab", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001ab", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1a-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001ample.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-1b-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001bhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001bhttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1b-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1b-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001bb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001bb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1b-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001bmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-1c-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001chttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001chttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1c-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001c", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001c", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1c-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001cb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001cb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1c-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001cmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-1d-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001dhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001dhttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1d-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001d", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001d", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1d-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001db", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001db", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1d-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001dmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-1e-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001ehttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001ehttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1e-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001e", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001e", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1e-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001eb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001eb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1e-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001emple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-1f-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001fhttps://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "\u001fhttps://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1f-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001f", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model\u001f", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1f-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001fb", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a\u001fb", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-1f-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa\u001fmple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-20-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": " https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-20-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model ", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-20-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-20-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://exa mple.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-7f-leading", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/url-boundary-c0-7f-trailing", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-7f-path", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/ab", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/ab", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/url-boundary-c0-7f-host", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/model-url-0", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model.safetensors", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model.safetensors", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/model-url-1", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "ftp://example.com/file", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "ftp://example.com/file", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/model-url-2", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "mailto:a@example.com", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "mailto:a@example.com", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/model-url-3", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "not-a-url", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/model-url-4", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/model-url-5", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "javascript:alert(1)", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "javascript:alert(1)", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/model-url-6", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://a b.com/file", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/model-url-7", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a b", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/a b", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/model-url-8", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": " https://example.com/model ", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com/model", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/model-url-9", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://éxample.com/file", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://éxample.com/file", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "1/model-url-10", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https://example.com:99999/file", + "directory": "checkpoints" + } + ] + }, + "accepted": false + }, + { + "id": "1/model-url-11", + "input": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:example.com/file", + "directory": "checkpoints" + } + ] + }, + "accepted": true, + "normalized": { + "version": 1, + "state": { + "lastGroupId": 0, + "lastNodeId": 1, + "lastLinkId": 1, + "lastRerouteId": 0 + }, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "models": [ + { + "name": "test.safetensors", + "url": "https:example.com/file", + "directory": "checkpoints" + } + ] + } + }, + { + "id": "root/not-an-object", + "input": [], + "accepted": false + }, + { + "id": "root/no-version", + "input": { + "nodes": [] + }, + "accepted": false + }, + { + "id": "root/string-version", + "input": { + "version": "0.4", + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": false + }, + { + "id": "root/unknown-numeric-version-uses-04", + "input": { + "version": 99, + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [] + }, + "accepted": true, + "normalized": { + "last_node_id": 1, + "last_link_id": 1, + "nodes": [ + { + "id": 1, + "type": "Note", + "pos": [ + 0, + 0 + ], + "size": [ + 200, + 100 + ], + "flags": {}, + "order": 0, + "mode": 0, + "properties": {} + } + ], + "links": [], + "version": 99 + } + } + ] +} diff --git a/tests/comfy_cli/fixtures/cloud_workflow_consumer/generate.mjs b/tests/comfy_cli/fixtures/cloud_workflow_consumer/generate.mjs new file mode 100644 index 000000000..45089a373 --- /dev/null +++ b/tests/comfy_cli/fixtures/cloud_workflow_consumer/generate.mjs @@ -0,0 +1,88 @@ +import { readFileSync, writeFileSync } from 'node:fs' +import { createHash } from 'node:crypto' +import { execFileSync } from 'node:child_process' +import { dirname, join } from 'node:path' +import { fileURLToPath, pathToFileURL } from 'node:url' + +const root = process.env.FRONTEND_ROOT +if (!root) throw new Error('FRONTEND_ROOT must identify the authoritative frontend checkout') +const schemaPath = 'src/platform/workflow/validation/schemas/workflowSchema.ts' +const { validateComfyWorkflow } = await import(pathToFileURL(join(root, schemaPath)).href) +const node = () => ({ id: 1, type: 'Note', pos: [0, 0], size: [200, 100], flags: {}, order: 0, mode: 0, properties: {} }) +const state = () => ({ lastGroupId: 0, lastNodeId: 1, lastLinkId: 1, lastRerouteId: 0 }) +const graph = (version) => version === 1 + ? { version: 1, state: state(), nodes: [node()], links: [] } + : { version, last_node_id: 1, last_link_id: 1, nodes: [node()], links: [] } +const subgraph = () => ({ ...graph(1), id: 'c327cae8-2acf-4bfa-bb88-97948a3c008b', revision: 1, name: 'Nested', inputNode: { id: -10, bounding: [0, 0, 100, 100] }, outputNode: { id: -20, bounding: [0, 0, 100, 100] } }) +const cases = [] +const add = (id, input) => cases.push({ id, input }) +const mutate = (version, label, edit) => { + const input = graph(version) + edit(input) + add(`${version}/${label}`, input) +} +const slotValues = ['0', '1', '-1', '+12', ' 3 ', '\t4', '12tail', '1.9', '0x10', '-0xF', '0b10', '0o10', '1e3', '1_000', '', ' ', 'junk', 'NaN', 'Infinity', '0x', '9007199254740992', '9'.repeat(400), '\u00a012tail', '\ufeff-0x10', '\u008512', '\u200b1', '-0', '+0xF', '0Xff', '\u202812', '١', '12١', 0, -1, 0.5, 9007199254740992, null, true] +const urlVectors = [ + ['empty',''], ['relative-path','models/foo'], ['relative-root','/models/foo'], ['relative-parent','../foo'], ['relative-query','?model=foo'], ['relative-fragment','#foo'], ['relative-protocol','//example.com/foo'], + ['https-no-host','https://'], ['https-missing-host-path','https:///foo'], ['https-one-slash','https:/foo'], ['https-no-slash','https:foo'], ['https-empty-port','https://example.com:/foo'], ['https-negative-port','https://example.com:-1/foo'], ['https-max-port','https://example.com:65535/foo'], ['https-overflow-port','https://example.com:65536/foo'], + ['file-empty','file:'], ['file-local','file:///tmp/model'], ['file-host','file://localhost/tmp/model'], ['file-relative','file:relative'], ['file-drive','file:///C:/model'], + ['opaque-custom','custom:opaque'], ['opaque-empty','custom:'], ['custom-host','custom://example.com/path'], ['custom-no-host','custom:///path'], ['opaque-space','custom:hello world'], ['opaque-unicode','custom:é🙂'], ['data','data:text/plain,model'], ['about','about:blank'], ['mailto-empty','mailto:'], ['javascript-empty','javascript:'], ['invalid-scheme','1custom:path'], ['scheme-space','custom :path'], + ['percent-lone','https://example.com/%'], ['percent-short','https://example.com/%2'], ['percent-invalid','https://example.com/%GG'], ['percent-host-invalid','https://exa%mple.com/'], ['percent-host-invalid-hex','https://%GG/'], ['percent-host-unicode','https://%C3%A9xample.com/'], ['percent-host-bad-utf8','https://%FF/'], ['percent-encoded-surrogate','https://example.com/%ED%A0%80'], ['percent-null-path','https://example.com/%00'], ['percent-null-host','https://%00/'], + ['idn-unicode','https://例え.テスト/model'], ['idn-punycode','https://xn--r8jz45g.xn--zckzah/model'], ['idn-fullwidth','https://example.com/'], ['idn-bad-punycode','https://xn--/'], ['idn-joiner','https://a\u200db.com/'], + ['ipv6-loopback','https://[::1]/model'], ['ipv6-full','https://[2001:db8::1]:443/model'], ['ipv6-unclosed','https://[::1/model'], ['ipv6-zone','https://[fe80::1%25en0]/'], ['ipv6-unbracketed','https://::1/model'], ['ipv4-hex','https://0x7f000001/model'], ['ipv4-short','https://127.1/model'], ['ipv4-bad','https://256.1.1.1/model'], + ['credentials','https://user:pass@example.com/model'], ['backslashes','https:\\example.com\model'], ['space-host','https://exa mple.com/model'], ['newline-scheme','ht\ntps://example.com/model'], ['tab-scheme','ht\ttps://example.com/model'] +] +for (const [label, scalar] of [['high-surrogate','\ud800'],['low-surrogate','\udfff'],['pair','\ud83d\ude42'],['replacement','\ufffd'],['reversed-pair','\udfff\ud800']]) { + urlVectors.push([`path-${label}`,`https://example.com/${scalar}`], [`query-${label}`,`https://example.com/?q=${scalar}`], [`fragment-${label}`,`https://example.com/#${scalar}`], [`host-${label}`,`https://${scalar}.example/`], [`opaque-${label}`,`custom:${scalar}`]) +} +for (const code of [...Array.from({length:33},(_,i)=>i),127]) { + const scalar=String.fromCharCode(code) + const label=code.toString(16).padStart(2,'0') + urlVectors.push([`c0-${label}-leading`,`${scalar}https://example.com/model`], [`c0-${label}-trailing`,`https://example.com/model${scalar}`], [`c0-${label}-path`,`https://example.com/a${scalar}b`], [`c0-${label}-host`,`https://exa${scalar}mple.com/`]) +} +for (const version of [0.4, 1]) { + add(`${version}/minimal`, graph(version)) + mutate(version, 'empty-canvas', g => { g.nodes = [] }) + mutate(version, 'incomplete-node', g => { g.nodes = [{}] }) + for (const field of ['id', 'type', 'pos', 'size', 'flags', 'order', 'mode', 'properties']) mutate(version, `missing-node-${field}`, g => { delete g.nodes[0][field] }) + for (const field of ['version', 'nodes', ...(version === 1 ? ['state'] : ['last_node_id', 'last_link_id', 'links'])]) mutate(version, `missing-graph-${field}`, g => { delete g[field] }) + for (const [index, slot] of slotValues.entries()) { + mutate(version, `link-slot-${index}`, g => { g.links = version === 1 ? [{ id: 1, origin_id: 1, origin_slot: slot, target_id: 1, target_slot: slot, type: 'IMAGE' }] : [[1, 1, slot, 1, slot, 'IMAGE']] }) + mutate(version, `input-slot-${index}`, g => { g.nodes[0].inputs = [{ name: 'in', type: 'IMAGE', slot_index: slot }] }) + } + for (const [index, tail] of ['\n', '\r', '\r\n', '\u2028', '\u2029'].entries()) { + for (const [field,value] of [['cnr_id','abc'],['aux_id','foo/repo'],['ver','1.2.3']]) mutate(version, `metadata-line-ending-${field}-${index}`, g => { g.nodes[0].properties[field]=value+tail }) + } + for (const [index, value] of ['valid-id', 'a', 'abc.def_12-foo', '', '_bad', 'bad-', 'éx', 'a/b', 'a'.repeat(101)].entries()) mutate(version, `cnr-${index}`, g => { g.nodes[0].properties.cnr_id = value }) + for (const [index, value] of ['foo/bar', 'Foo-1/repo.name', '-foo/repo', 'foo-/repo', 'foo--bar/repo', 'foo/_repo', 'foo/repo_', 'a'.repeat(40)+'/repo', 'foo/bar/baz', 'é/repo', 'a/b', 'a/r'.repeat(52)].entries()) mutate(version, `aux-${index}`, g => { g.nodes[0].properties.aux_id = value }) + for (const [index, value] of ['unknown', '1.2.3', 'v1.2.3', '1.2.3-beta.1+build.4', '1.2.3-01', '01.2.3', '1.2', 'bad', 'abcd', 'ABCD', 'vABCD', 'abc', 'a'.repeat(40), 'a'.repeat(41), 'V1.2.3', 'vunknown', '1.2.3-Beta', '1२.2.3', '', 1, null].entries()) mutate(version, `ver-${index}`, g => { g.nodes[0].properties.ver = value }) + for (const [index, value] of [[null, 1, true, 'x', {}, [1, {'x':'y'}]], { positive: 'hello', nested: { x: [] }, length: 10001 }, [], {}, 'text', null, 1, true].entries()) mutate(version, `widget-${index}`, g => { g.nodes[0].widgets_values = value }) + for (const [index, key] of ['0', '-1', '1', '01', '+1', '-0', '1.0', '1e3', ' 1', '', '9007199254740991', '9007199254740992'].entries()) mutate(version, `link-presentation-key-${index}`, g => { g.extra = { linkPresentation: { [key]: { hidden: true } } } }) + mutate(version, 'vector-object-normalization', g => { g.nodes[0].pos = {0: 7, 1: -2, extra: 'removed'}; g.nodes[0].size = {0: 200, 1: 100} }) + mutate(version, 'bad-vector-object', g => { g.nodes[0].pos = {0: 7} }) + mutate(version, 'arbitrary-property-kept', g => { g.nodes[0].properties.custom = { fn: 'opaque', list: [] } }) + mutate(version, 'recursive-subgraphs', g => { const sub = subgraph(); sub.definitions = { subgraphs: [subgraph()] }; g.definitions = {subgraphs:[sub]} }) + mutate(version, 'recursive-subgraph-invalid-slot', g => { const sub = subgraph(); const nested=subgraph(); nested.nodes[0].outputs=[{name:'x',type:'IMAGE',slot_index:'NaN'}]; sub.definitions={subgraphs:[nested]};g.definitions={subgraphs:[sub]} }) + mutate(version, 'recursive-subgraph-invalid-pack', g => { const sub = subgraph(); const nested=subgraph(); nested.nodes[0].properties.ver='nonsense'; sub.definitions={subgraphs:[nested]};g.definitions={subgraphs:[sub]} }) + mutate(version, 'recursive-subgraph-vector-normalization', g => { const sub = subgraph(); sub.nodes[0].pos={0:1,1:2}; g.definitions={subgraphs:[sub]} }) + mutate(version, 'recursive-subgraph-missing-state', g => { const sub = subgraph(); delete sub.state; g.definitions={subgraphs:[sub]} }) + mutate(version, 'root-unknown-field-kept', g => { g.customMetadata={x:1,ver:'invalid',origin_slot:'NaN',nodes:[{properties:{ver:'invalid'}}]} }) + mutate(version, 'opaque-widget-metadata-kept', g => { g.nodes[0].widgets_values=[{ver:'invalid',origin_slot:'NaN',nodes:[{}]}] }) + for (const [label,url] of urlVectors) mutate(version, `url-boundary-${label}`, g => { g.models=[{name:'test.safetensors',url,directory:'checkpoints'}] }) + for (const [index,url] of ['https://example.com/model.safetensors','ftp://example.com/file','mailto:a@example.com','not-a-url','https://','javascript:alert(1)','https://a b.com/file','https://example.com/a b',' https://example.com/model ','https://éxample.com/file','https://example.com:99999/file','https:example.com/file'].entries()) mutate(version, `model-url-${index}`, g => {g.models=[{name:'test.safetensors',url,directory:'checkpoints'}]}) +} +add('root/not-an-object', []) +add('root/no-version', {nodes:[]}) +add('root/string-version', {...graph(0.4),version:'0.4'}) +add('root/unknown-numeric-version-uses-04', graph(99)) +for (const test of cases) { + const normalized=await validateComfyWorkflow(test.input,()=>{}) + test.accepted=normalized!==null + if (normalized!==null) test.normalized=normalized +} +const sources=[schemaPath,'src/types/linkId.ts','src/lib/litegraph/src/types/widgets.ts'] +const provenance={ frontend_commit:execFileSync('git',['rev-parse','HEAD'],{cwd:root,encoding:'utf8'}).trim(), oracle:'validateComfyWorkflow(input, () => {})', node_version:process.versions.node, zod_version:JSON.parse(readFileSync(join(root,'node_modules/zod/package.json'),'utf8')).version, frontend_lockfile_sha256:createHash('sha256').update(readFileSync(join(root,'pnpm-lock.yaml'))).digest('hex'), generated_at:'2026-10-24', sources:Object.fromEntries(sources.map(p=>[p,createHash('sha256').update(readFileSync(join(root,p))).digest('hex')])), export_command:'FRONTEND_ROOT= node --import tsx /tests/comfy_cli/fixtures/cloud_workflow_consumer/generate.mjs (cwd frontend)' } +const destination=join(dirname(fileURLToPath(import.meta.url)),'corpus.json') +const json=JSON.stringify({provenance,nonfinite_normalized_encoding:'Infinity/-Infinity/NaN emitted as {$number: } only in normalized output; inputs are plain JSON',cases},(key,value)=>typeof value==='number'&&!Number.isFinite(value)?{$number:String(value)}:value,2) +writeFileSync(destination,json+'\n') +console.log(destination,`${cases.length} cases`,`${cases.filter(c=>c.accepted).length} accepted`) diff --git a/tests/comfy_cli/fixtures/saved_file_uuid_consumer.json b/tests/comfy_cli/fixtures/saved_file_uuid_consumer.json new file mode 100644 index 000000000..f41bd1388 --- /dev/null +++ b/tests/comfy_cli/fixtures/saved_file_uuid_consumer.json @@ -0,0 +1,1355 @@ +{ + "provenance": { + "package": "uuid", + "version": "11.1.1", + "consumer": "savedWorkflowService.ts and savedWorkflowLink.ts: uuid.validate(id) && id === id.toLowerCase()", + "regex_sha256": "774bc4bc767a58458dfdd252430d96b71b3d380ac241b50df6cb757aaa1b4783" + }, + "cases": [ + { + "id": "version-0-variant-0", + "input": "11111111-1111-0111-0111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-1", + "input": "11111111-1111-0111-1111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-2", + "input": "11111111-1111-0111-2111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-3", + "input": "11111111-1111-0111-3111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-4", + "input": "11111111-1111-0111-4111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-5", + "input": "11111111-1111-0111-5111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-6", + "input": "11111111-1111-0111-6111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-7", + "input": "11111111-1111-0111-7111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-8", + "input": "11111111-1111-0111-8111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-9", + "input": "11111111-1111-0111-9111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-a", + "input": "11111111-1111-0111-a111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-b", + "input": "11111111-1111-0111-b111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-c", + "input": "11111111-1111-0111-c111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-d", + "input": "11111111-1111-0111-d111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-e", + "input": "11111111-1111-0111-e111-111111111111", + "accepted": false + }, + { + "id": "version-0-variant-f", + "input": "11111111-1111-0111-f111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-0", + "input": "11111111-1111-1111-0111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-1", + "input": "11111111-1111-1111-1111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-2", + "input": "11111111-1111-1111-2111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-3", + "input": "11111111-1111-1111-3111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-4", + "input": "11111111-1111-1111-4111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-5", + "input": "11111111-1111-1111-5111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-6", + "input": "11111111-1111-1111-6111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-7", + "input": "11111111-1111-1111-7111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-8", + "input": "11111111-1111-1111-8111-111111111111", + "accepted": true + }, + { + "id": "version-1-variant-9", + "input": "11111111-1111-1111-9111-111111111111", + "accepted": true + }, + { + "id": "version-1-variant-a", + "input": "11111111-1111-1111-a111-111111111111", + "accepted": true + }, + { + "id": "version-1-variant-b", + "input": "11111111-1111-1111-b111-111111111111", + "accepted": true + }, + { + "id": "version-1-variant-c", + "input": "11111111-1111-1111-c111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-d", + "input": "11111111-1111-1111-d111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-e", + "input": "11111111-1111-1111-e111-111111111111", + "accepted": false + }, + { + "id": "version-1-variant-f", + "input": "11111111-1111-1111-f111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-0", + "input": "11111111-1111-2111-0111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-1", + "input": "11111111-1111-2111-1111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-2", + "input": "11111111-1111-2111-2111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-3", + "input": "11111111-1111-2111-3111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-4", + "input": "11111111-1111-2111-4111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-5", + "input": "11111111-1111-2111-5111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-6", + "input": "11111111-1111-2111-6111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-7", + "input": "11111111-1111-2111-7111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-8", + "input": "11111111-1111-2111-8111-111111111111", + "accepted": true + }, + { + "id": "version-2-variant-9", + "input": "11111111-1111-2111-9111-111111111111", + "accepted": true + }, + { + "id": "version-2-variant-a", + "input": "11111111-1111-2111-a111-111111111111", + "accepted": true + }, + { + "id": "version-2-variant-b", + "input": "11111111-1111-2111-b111-111111111111", + "accepted": true + }, + { + "id": "version-2-variant-c", + "input": "11111111-1111-2111-c111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-d", + "input": "11111111-1111-2111-d111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-e", + "input": "11111111-1111-2111-e111-111111111111", + "accepted": false + }, + { + "id": "version-2-variant-f", + "input": "11111111-1111-2111-f111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-0", + "input": "11111111-1111-3111-0111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-1", + "input": "11111111-1111-3111-1111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-2", + "input": "11111111-1111-3111-2111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-3", + "input": "11111111-1111-3111-3111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-4", + "input": "11111111-1111-3111-4111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-5", + "input": "11111111-1111-3111-5111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-6", + "input": "11111111-1111-3111-6111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-7", + "input": "11111111-1111-3111-7111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-8", + "input": "11111111-1111-3111-8111-111111111111", + "accepted": true + }, + { + "id": "version-3-variant-9", + "input": "11111111-1111-3111-9111-111111111111", + "accepted": true + }, + { + "id": "version-3-variant-a", + "input": "11111111-1111-3111-a111-111111111111", + "accepted": true + }, + { + "id": "version-3-variant-b", + "input": "11111111-1111-3111-b111-111111111111", + "accepted": true + }, + { + "id": "version-3-variant-c", + "input": "11111111-1111-3111-c111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-d", + "input": "11111111-1111-3111-d111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-e", + "input": "11111111-1111-3111-e111-111111111111", + "accepted": false + }, + { + "id": "version-3-variant-f", + "input": "11111111-1111-3111-f111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-0", + "input": "11111111-1111-4111-0111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-1", + "input": "11111111-1111-4111-1111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-2", + "input": "11111111-1111-4111-2111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-3", + "input": "11111111-1111-4111-3111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-4", + "input": "11111111-1111-4111-4111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-5", + "input": "11111111-1111-4111-5111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-6", + "input": "11111111-1111-4111-6111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-7", + "input": "11111111-1111-4111-7111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-8", + "input": "11111111-1111-4111-8111-111111111111", + "accepted": true + }, + { + "id": "version-4-variant-9", + "input": "11111111-1111-4111-9111-111111111111", + "accepted": true + }, + { + "id": "version-4-variant-a", + "input": "11111111-1111-4111-a111-111111111111", + "accepted": true + }, + { + "id": "version-4-variant-b", + "input": "11111111-1111-4111-b111-111111111111", + "accepted": true + }, + { + "id": "version-4-variant-c", + "input": "11111111-1111-4111-c111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-d", + "input": "11111111-1111-4111-d111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-e", + "input": "11111111-1111-4111-e111-111111111111", + "accepted": false + }, + { + "id": "version-4-variant-f", + "input": "11111111-1111-4111-f111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-0", + "input": "11111111-1111-5111-0111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-1", + "input": "11111111-1111-5111-1111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-2", + "input": "11111111-1111-5111-2111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-3", + "input": "11111111-1111-5111-3111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-4", + "input": "11111111-1111-5111-4111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-5", + "input": "11111111-1111-5111-5111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-6", + "input": "11111111-1111-5111-6111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-7", + "input": "11111111-1111-5111-7111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-8", + "input": "11111111-1111-5111-8111-111111111111", + "accepted": true + }, + { + "id": "version-5-variant-9", + "input": "11111111-1111-5111-9111-111111111111", + "accepted": true + }, + { + "id": "version-5-variant-a", + "input": "11111111-1111-5111-a111-111111111111", + "accepted": true + }, + { + "id": "version-5-variant-b", + "input": "11111111-1111-5111-b111-111111111111", + "accepted": true + }, + { + "id": "version-5-variant-c", + "input": "11111111-1111-5111-c111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-d", + "input": "11111111-1111-5111-d111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-e", + "input": "11111111-1111-5111-e111-111111111111", + "accepted": false + }, + { + "id": "version-5-variant-f", + "input": "11111111-1111-5111-f111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-0", + "input": "11111111-1111-6111-0111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-1", + "input": "11111111-1111-6111-1111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-2", + "input": "11111111-1111-6111-2111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-3", + "input": "11111111-1111-6111-3111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-4", + "input": "11111111-1111-6111-4111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-5", + "input": "11111111-1111-6111-5111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-6", + "input": "11111111-1111-6111-6111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-7", + "input": "11111111-1111-6111-7111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-8", + "input": "11111111-1111-6111-8111-111111111111", + "accepted": true + }, + { + "id": "version-6-variant-9", + "input": "11111111-1111-6111-9111-111111111111", + "accepted": true + }, + { + "id": "version-6-variant-a", + "input": "11111111-1111-6111-a111-111111111111", + "accepted": true + }, + { + "id": "version-6-variant-b", + "input": "11111111-1111-6111-b111-111111111111", + "accepted": true + }, + { + "id": "version-6-variant-c", + "input": "11111111-1111-6111-c111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-d", + "input": "11111111-1111-6111-d111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-e", + "input": "11111111-1111-6111-e111-111111111111", + "accepted": false + }, + { + "id": "version-6-variant-f", + "input": "11111111-1111-6111-f111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-0", + "input": "11111111-1111-7111-0111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-1", + "input": "11111111-1111-7111-1111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-2", + "input": "11111111-1111-7111-2111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-3", + "input": "11111111-1111-7111-3111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-4", + "input": "11111111-1111-7111-4111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-5", + "input": "11111111-1111-7111-5111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-6", + "input": "11111111-1111-7111-6111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-7", + "input": "11111111-1111-7111-7111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-8", + "input": "11111111-1111-7111-8111-111111111111", + "accepted": true + }, + { + "id": "version-7-variant-9", + "input": "11111111-1111-7111-9111-111111111111", + "accepted": true + }, + { + "id": "version-7-variant-a", + "input": "11111111-1111-7111-a111-111111111111", + "accepted": true + }, + { + "id": "version-7-variant-b", + "input": "11111111-1111-7111-b111-111111111111", + "accepted": true + }, + { + "id": "version-7-variant-c", + "input": "11111111-1111-7111-c111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-d", + "input": "11111111-1111-7111-d111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-e", + "input": "11111111-1111-7111-e111-111111111111", + "accepted": false + }, + { + "id": "version-7-variant-f", + "input": "11111111-1111-7111-f111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-0", + "input": "11111111-1111-8111-0111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-1", + "input": "11111111-1111-8111-1111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-2", + "input": "11111111-1111-8111-2111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-3", + "input": "11111111-1111-8111-3111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-4", + "input": "11111111-1111-8111-4111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-5", + "input": "11111111-1111-8111-5111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-6", + "input": "11111111-1111-8111-6111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-7", + "input": "11111111-1111-8111-7111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-8", + "input": "11111111-1111-8111-8111-111111111111", + "accepted": true + }, + { + "id": "version-8-variant-9", + "input": "11111111-1111-8111-9111-111111111111", + "accepted": true + }, + { + "id": "version-8-variant-a", + "input": "11111111-1111-8111-a111-111111111111", + "accepted": true + }, + { + "id": "version-8-variant-b", + "input": "11111111-1111-8111-b111-111111111111", + "accepted": true + }, + { + "id": "version-8-variant-c", + "input": "11111111-1111-8111-c111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-d", + "input": "11111111-1111-8111-d111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-e", + "input": "11111111-1111-8111-e111-111111111111", + "accepted": false + }, + { + "id": "version-8-variant-f", + "input": "11111111-1111-8111-f111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-0", + "input": "11111111-1111-9111-0111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-1", + "input": "11111111-1111-9111-1111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-2", + "input": "11111111-1111-9111-2111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-3", + "input": "11111111-1111-9111-3111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-4", + "input": "11111111-1111-9111-4111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-5", + "input": "11111111-1111-9111-5111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-6", + "input": "11111111-1111-9111-6111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-7", + "input": "11111111-1111-9111-7111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-8", + "input": "11111111-1111-9111-8111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-9", + "input": "11111111-1111-9111-9111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-a", + "input": "11111111-1111-9111-a111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-b", + "input": "11111111-1111-9111-b111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-c", + "input": "11111111-1111-9111-c111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-d", + "input": "11111111-1111-9111-d111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-e", + "input": "11111111-1111-9111-e111-111111111111", + "accepted": false + }, + { + "id": "version-9-variant-f", + "input": "11111111-1111-9111-f111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-0", + "input": "11111111-1111-a111-0111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-1", + "input": "11111111-1111-a111-1111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-2", + "input": "11111111-1111-a111-2111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-3", + "input": "11111111-1111-a111-3111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-4", + "input": "11111111-1111-a111-4111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-5", + "input": "11111111-1111-a111-5111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-6", + "input": "11111111-1111-a111-6111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-7", + "input": "11111111-1111-a111-7111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-8", + "input": "11111111-1111-a111-8111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-9", + "input": "11111111-1111-a111-9111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-a", + "input": "11111111-1111-a111-a111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-b", + "input": "11111111-1111-a111-b111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-c", + "input": "11111111-1111-a111-c111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-d", + "input": "11111111-1111-a111-d111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-e", + "input": "11111111-1111-a111-e111-111111111111", + "accepted": false + }, + { + "id": "version-a-variant-f", + "input": "11111111-1111-a111-f111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-0", + "input": "11111111-1111-b111-0111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-1", + "input": "11111111-1111-b111-1111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-2", + "input": "11111111-1111-b111-2111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-3", + "input": "11111111-1111-b111-3111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-4", + "input": "11111111-1111-b111-4111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-5", + "input": "11111111-1111-b111-5111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-6", + "input": "11111111-1111-b111-6111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-7", + "input": "11111111-1111-b111-7111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-8", + "input": "11111111-1111-b111-8111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-9", + "input": "11111111-1111-b111-9111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-a", + "input": "11111111-1111-b111-a111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-b", + "input": "11111111-1111-b111-b111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-c", + "input": "11111111-1111-b111-c111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-d", + "input": "11111111-1111-b111-d111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-e", + "input": "11111111-1111-b111-e111-111111111111", + "accepted": false + }, + { + "id": "version-b-variant-f", + "input": "11111111-1111-b111-f111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-0", + "input": "11111111-1111-c111-0111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-1", + "input": "11111111-1111-c111-1111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-2", + "input": "11111111-1111-c111-2111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-3", + "input": "11111111-1111-c111-3111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-4", + "input": "11111111-1111-c111-4111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-5", + "input": "11111111-1111-c111-5111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-6", + "input": "11111111-1111-c111-6111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-7", + "input": "11111111-1111-c111-7111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-8", + "input": "11111111-1111-c111-8111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-9", + "input": "11111111-1111-c111-9111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-a", + "input": "11111111-1111-c111-a111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-b", + "input": "11111111-1111-c111-b111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-c", + "input": "11111111-1111-c111-c111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-d", + "input": "11111111-1111-c111-d111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-e", + "input": "11111111-1111-c111-e111-111111111111", + "accepted": false + }, + { + "id": "version-c-variant-f", + "input": "11111111-1111-c111-f111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-0", + "input": "11111111-1111-d111-0111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-1", + "input": "11111111-1111-d111-1111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-2", + "input": "11111111-1111-d111-2111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-3", + "input": "11111111-1111-d111-3111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-4", + "input": "11111111-1111-d111-4111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-5", + "input": "11111111-1111-d111-5111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-6", + "input": "11111111-1111-d111-6111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-7", + "input": "11111111-1111-d111-7111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-8", + "input": "11111111-1111-d111-8111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-9", + "input": "11111111-1111-d111-9111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-a", + "input": "11111111-1111-d111-a111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-b", + "input": "11111111-1111-d111-b111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-c", + "input": "11111111-1111-d111-c111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-d", + "input": "11111111-1111-d111-d111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-e", + "input": "11111111-1111-d111-e111-111111111111", + "accepted": false + }, + { + "id": "version-d-variant-f", + "input": "11111111-1111-d111-f111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-0", + "input": "11111111-1111-e111-0111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-1", + "input": "11111111-1111-e111-1111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-2", + "input": "11111111-1111-e111-2111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-3", + "input": "11111111-1111-e111-3111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-4", + "input": "11111111-1111-e111-4111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-5", + "input": "11111111-1111-e111-5111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-6", + "input": "11111111-1111-e111-6111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-7", + "input": "11111111-1111-e111-7111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-8", + "input": "11111111-1111-e111-8111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-9", + "input": "11111111-1111-e111-9111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-a", + "input": "11111111-1111-e111-a111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-b", + "input": "11111111-1111-e111-b111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-c", + "input": "11111111-1111-e111-c111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-d", + "input": "11111111-1111-e111-d111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-e", + "input": "11111111-1111-e111-e111-111111111111", + "accepted": false + }, + { + "id": "version-e-variant-f", + "input": "11111111-1111-e111-f111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-0", + "input": "11111111-1111-f111-0111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-1", + "input": "11111111-1111-f111-1111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-2", + "input": "11111111-1111-f111-2111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-3", + "input": "11111111-1111-f111-3111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-4", + "input": "11111111-1111-f111-4111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-5", + "input": "11111111-1111-f111-5111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-6", + "input": "11111111-1111-f111-6111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-7", + "input": "11111111-1111-f111-7111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-8", + "input": "11111111-1111-f111-8111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-9", + "input": "11111111-1111-f111-9111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-a", + "input": "11111111-1111-f111-a111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-b", + "input": "11111111-1111-f111-b111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-c", + "input": "11111111-1111-f111-c111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-d", + "input": "11111111-1111-f111-d111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-e", + "input": "11111111-1111-f111-e111-111111111111", + "accepted": false + }, + { + "id": "version-f-variant-f", + "input": "11111111-1111-f111-f111-111111111111", + "accepted": false + }, + { + "id": "boundary-256", + "input": "00000000-0000-0000-0000-000000000000", + "accepted": true + }, + { + "id": "boundary-257", + "input": "ffffffff-ffff-ffff-ffff-ffffffffffff", + "accepted": true + }, + { + "id": "boundary-258", + "input": "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF", + "accepted": false + }, + { + "id": "boundary-259", + "input": "978E5F58-49DC-4A81-8235-A0B91C204A1C", + "accepted": false + }, + { + "id": "boundary-260", + "input": "978e5f58-49dc-4a81-8235-a0b91c204a1c", + "accepted": true + }, + { + "id": "boundary-261", + "input": "978e5f5849dc4a818235a0b91c204a1c", + "accepted": false + }, + { + "id": "boundary-262", + "input": " 978e5f58-49dc-4a81-8235-a0b91c204a1c", + "accepted": false + }, + { + "id": "boundary-263", + "input": "978e5f58-49dc-4a81-8235-a0b91c204a1c\n", + "accepted": false + }, + { + "id": "boundary-264", + "input": "", + "accepted": false + }, + { + "id": "boundary-265", + "input": null, + "accepted": false + }, + { + "id": "boundary-266", + "input": true, + "accepted": false + }, + { + "id": "boundary-267", + "input": 123, + "accepted": false + }, + { + "id": "boundary-268", + "input": {}, + "accepted": false + } + ] +} diff --git a/tests/comfy_cli/output/test_envelope_schemas.py b/tests/comfy_cli/output/test_envelope_schemas.py index bcd387916..ae22891d8 100644 --- a/tests/comfy_cli/output/test_envelope_schemas.py +++ b/tests/comfy_cli/output/test_envelope_schemas.py @@ -119,10 +119,16 @@ def test_env_json_validates(): assert envelope["ok"] is True -def test_which_json_validates(): - envelope = _run_cli(["--json", "which"]) +def test_which_json_validates(tmp_path): + workspace = tmp_path / "ComfyUI" + workspace.mkdir() + (workspace / "main.py").write_text("") + envelope = _run_cli(["--json", "--workspace", str(workspace), "which"]) _validator_for("envelope.json").validate(envelope) + assert envelope["ok"] is True _validator_for("which.json").validate(envelope["data"]) + assert envelope["data"]["workspace_path"] == str(workspace) + assert envelope["data"]["exists"] is True def test_help_json_validates(): diff --git a/tests/comfy_cli/output/test_error_code_registry.py b/tests/comfy_cli/output/test_error_code_registry.py index bba81920c..6109be76c 100644 --- a/tests/comfy_cli/output/test_error_code_registry.py +++ b/tests/comfy_cli/output/test_error_code_registry.py @@ -280,14 +280,14 @@ def test_deploy_error_codes_are_the_exact_final_set() -> None: deploy_workflow_not_api_format deploy_status_terminal deploy_workflow_too_large deploy_watch_lost deploy_update_failed deploy_update_replaced deploy_updates_unavailable deploy_name_not_found deploy_invalid_name deploy_name_taken deploy_names_unavailable deploy_editor_unchanged - deploy_build_not_found deploy_ambiguous_build""".split() + deploy_build_not_found deploy_ambiguous_build deploy_ui_unavailable""".split() ) # When actual = {code for code in error_codes.all_codes() if code.startswith("deploy_")} # Then - assert len(actual) == 46 + assert len(actual) == 47 assert actual == expected diff --git a/tests/comfy_cli/output/test_error_envelope_where.py b/tests/comfy_cli/output/test_error_envelope_where.py index e84ae3a06..ed0ae837f 100644 --- a/tests/comfy_cli/output/test_error_envelope_where.py +++ b/tests/comfy_cli/output/test_error_envelope_where.py @@ -324,15 +324,19 @@ def _workflow(tmp_path): def test_cloud(self, tmp_path): err = LoadError("no object_info", details={"hint": "sign in"}) - with patch("comfy_cli.cql.engine.Graph.load", side_effect=err): + with patch("comfy_cli.cql.loader.resilient_load_object_info", side_effect=err) as load: env = _run(["--json", "validate", "--workflow", self._workflow(tmp_path), "--where", "cloud"]) + load.assert_called_once() + assert load.call_args.kwargs["mode"] == "cloud" assert env["error"]["code"] == "cql_no_graph" assert env["where"] == "cloud" def test_local(self, tmp_path): err = LoadError("no object_info", details={"hint": "comfy launch"}) - with patch("comfy_cli.cql.engine.Graph.load", side_effect=err): + with patch("comfy_cli.cql.loader.resilient_load_object_info", side_effect=err) as load: env = _run(["--json", "validate", "--workflow", self._workflow(tmp_path), "--where", "local"]) + load.assert_called_once() + assert load.call_args.kwargs["mode"] == "local" assert env["error"]["code"] == "cql_no_graph" assert env["where"] == "local" diff --git a/tests/comfy_cli/test_cloud_model_validation.py b/tests/comfy_cli/test_cloud_model_validation.py new file mode 100644 index 000000000..7eda2a540 --- /dev/null +++ b/tests/comfy_cli/test_cloud_model_validation.py @@ -0,0 +1,361 @@ +"""Uploaded model assets may be absent from Cloud's static enum snapshot.""" + +from __future__ import annotations + +import copy +import json +import urllib.error +from unittest.mock import Mock +from urllib.parse import parse_qs, urlsplit + +import pytest + +from comfy_cli.cql.engine import Graph +from comfy_cli.target import Target + +DIGEST = "a" * 64 +NAME = "private.safetensors" + + +def object_info(): + return { + "Source": {"input": {"required": {}}, "output": ["MODEL"]}, + "LoraLoaderModelOnly": { + "input": { + "required": {"model": ["MODEL"], "lora_name": [["public.safetensors"]], "strength_model": ["FLOAT"]} + }, + "output": ["MODEL"], + }, + "Capture": {"input": {"required": {"model": ["MODEL"]}}, "output": [], "output_node": True}, + } + + +def workflow(): + return { + "1": {"class_type": "Source", "inputs": {}}, + "2": { + "class_type": "LoraLoaderModelOnly", + "inputs": {"model": ["1", 0], "lora_name": NAME, "strength_model": 1.0}, + }, + "3": {"class_type": "Capture", "inputs": {"model": ["2", 0]}}, + } + + +def validation(wf=None): + return Graph.from_object_info(object_info()).validate_workflow(wf or workflow()) + + +def asset(**changes): + return { + "id": "asset-private", + "name": NAME, + "hash": DIGEST + ".safetensors", + "tags": ["models", "loras"], + **changes, + } + + +@pytest.fixture +def service(monkeypatch): + from comfy_cli import cloud_model_validation as cv + + monkeypatch.delenv("COMFY_OBJECT_INFO_FILE", raising=False) + monkeypatch.setattr( + cv, + "resolve_target", + lambda **kw: Target(kind="cloud", base_url="https://cloud.test", path_prefix="/api", auth_token="test-token"), + ) + request = Mock(return_value=(200, {"assets": [asset()], "has_more": False})) + monkeypatch.setattr(cv, "request_json", request) + return cv, request + + +def test_authenticated_exact_model_asset_resolves_real_graph_error(service): + cv, request = service + result = validation() + before = copy.deepcopy(result) + assert [e["code"] for e in result["errors"]] == ["unknown_enum_value"] + resolved = cv.resolve_cloud_model_errors(result, workflow(), where="cloud") + assert resolved["valid"] is True + assert resolved["errors"] == [] + assert resolved["warnings"][-1]["code"] == "cloud_model_asset_verified" + assert resolved["warnings"][-1]["asset_id"] == "asset-private" + assert result == before + query = parse_qs(urlsplit(request.call_args.args[0]).query) + assert query["include_public"] == ["false"] + assert query["include_tags"] == ["models"] + assert query["name_contains"] == [NAME] + assert request.call_args.kwargs["max_bytes"] <= 4 * 1024 * 1024 + + +@pytest.mark.parametrize( + "row", + [ + asset(name="prefix-" + NAME), + asset(tags=["models", "vae"]), + asset(tags=["loras"]), + asset(hash="unknown"), + asset(hash=None), + asset(id=None), + asset(name="other", loader_path="other"), + asset(tags="models,loras"), + ], +) +def test_fuzzy_wrong_folder_or_unverifiable_asset_retains_error(service, row): + cv, request = service + request.return_value = (200, {"assets": [row], "has_more": False}) + result = validation() + assert cv.resolve_cloud_model_errors(result, workflow(), where="cloud") == result + + +def test_exact_server_loader_path_is_accepted(service): + cv, request = service + request.return_value = (200, {"assets": [asset(name="display name", loader_path=NAME)], "has_more": False}) + assert cv.resolve_cloud_model_errors(validation(), workflow(), where="cloud")["valid"] is True + + +@pytest.mark.parametrize( + "body", + [ + None, + {}, + {"assets": None, "has_more": False}, + {"assets": [asset()]}, + {"assets": [asset()], "has_more": True}, + {"assets": [asset(), "malformed"], "has_more": False}, + ], +) +def test_incomplete_or_malformed_result_retains_original_diagnostics(service, body): + cv, request = service + request.return_value = (200, body) + result = validation() + assert cv.resolve_cloud_model_errors(result, workflow(), where="cloud") == result + + +@pytest.mark.parametrize( + "error", + [ + OSError("offline"), + ValueError("bad response"), + TimeoutError("timeout"), + urllib.error.HTTPError("https://cloud.test", 403, "forbidden", {}, None), + ], +) +def test_unavailable_lookup_retains_original_diagnostics(service, error): + cv, request = service + request.side_effect = error + result = validation() + assert cv.resolve_cloud_model_errors(result, workflow(), where="cloud") == result + + +@pytest.mark.parametrize( + "where,offline,env", [("local", False, None), ("cloud", True, None), ("cloud", False, "/offline/catalog.json")] +) +def test_offline_or_local_validation_does_not_resolve_target_or_network(service, monkeypatch, where, offline, env): + cv, request = service + target = Mock(side_effect=AssertionError("must stay offline")) + monkeypatch.setattr(cv, "resolve_target", target) + if env: + monkeypatch.setenv("COMFY_OBJECT_INFO_FILE", env) + result = validation() + assert cv.resolve_cloud_model_errors(result, workflow(), where=where, offline=offline) == result + target.assert_not_called() + request.assert_not_called() + + +@pytest.mark.parametrize("change", ["nonmodel", "otherfield", "othercode", "valid"]) +def test_arbitrary_enums_and_other_errors_do_not_start_network(service, monkeypatch, change): + cv, request = service + wf = workflow() + result = validation() + if change == "nonmodel": + wf["2"]["class_type"] = "KSampler" + elif change == "otherfield": + result["errors"][0]["field"] = "strength_model" + elif change == "othercode": + result["errors"][0]["code"] = "no_options_available" + else: + result = {"valid": True, "errors": [], "warnings": []} + target = Mock(side_effect=AssertionError("unrelated error must not start network")) + monkeypatch.setattr(cv, "resolve_target", target) + assert cv.resolve_cloud_model_errors(result, wf, where="cloud") == result + request.assert_not_called() + target.assert_not_called() + + +def test_unauthenticated_target_keeps_error_without_assets_read(service, monkeypatch): + cv, request = service + monkeypatch.setattr(cv, "resolve_target", lambda **kw: Target(kind="cloud", base_url="https://cloud.test")) + result = validation() + assert cv.resolve_cloud_model_errors(result, workflow(), where="cloud") == result + request.assert_not_called() + + +def test_conflicting_exact_asset_hashes_are_ambiguous(service): + cv, request = service + request.return_value = (200, {"assets": [asset(), asset(id="asset-other", hash="b" * 64)], "has_more": False}) + result = validation() + assert cv.resolve_cloud_model_errors(result, workflow(), where="cloud") == result + + +def test_only_resolved_error_removed_other_diagnostics_unchanged(service): + cv, _ = service + result = validation() + unrelated = {"node_id": "2", "field": "model", "code": "shape_mismatch", "message": "test invalid shape"} + result["errors"].append(unrelated) + resolved = cv.resolve_cloud_model_errors(result, workflow(), where="cloud") + assert resolved["valid"] is False + assert resolved["errors"] == [unrelated] + + +def test_repeated_same_model_uses_one_bounded_lookup(service): + cv, request = service + wf = workflow() + wf["4"] = copy.deepcopy(wf["2"]) + result = validation(wf) + assert len(result["errors"]) == 2 + assert cv.resolve_cloud_model_errors(result, wf, where="cloud")["valid"] is True + assert request.call_count == 1 + + +def test_run_preflight_uses_authenticated_asset_verification(service): + from comfy_cli.command.run.preflight import _preflight_validate + + _, request = service + renderer = Mock() + renderer.is_pretty.return_value = False + _preflight_validate(renderer, workflow(), object_info(), where="cloud", target_label="cloud") + renderer.error.assert_not_called() + assert request.call_count == 1 + + +def test_workflow_validate_uses_same_asset_check_and_offline_override(service, monkeypatch, tmp_path): + from comfy_cli.command import workflow as cmd + from comfy_cli.cql import loader + + _, request = service + renderer = Mock() + renderer.is_pretty.return_value = False + monkeypatch.setattr(cmd, "get_renderer", lambda: renderer) + monkeypatch.setattr(loader, "resilient_load_object_info", lambda **kw: object_info()) + path = tmp_path / "workflow.json" + path.write_text(json.dumps(workflow())) + cmd.validate_api_workflow(str(path), where="cloud") + assert renderer.emit.call_args.args[0]["valid"] is True + request.assert_called_once() + request.reset_mock() + with pytest.raises(Exception): + cmd.validate_api_workflow(str(path), where="cloud", input_path="offline-catalog.json") + request.assert_not_called() + + +def test_actual_authenticated_http_transport_uses_supported_models_filter(service, monkeypatch): + import io + + from comfy_cli import http + + cv, _ = service + seen = [] + + class Response(io.BytesIO): + status = 200 + + def open_request(request, *, timeout): + query = parse_qs(urlsplit(request.full_url).query) + assert query["include_tags"] == ["models"] + assert query["include_public"] == ["false"] + assert query["name_contains"] == [NAME] + assert request.get_method() == "GET" + assert request.get_header("Authorization") == "Bearer test-token" + assert timeout == 10 + seen.append(request.full_url) + return Response(json.dumps({"assets": [asset()], "has_more": False}).encode()) + + monkeypatch.setattr(http._AUTHED_OPENER, "open", open_request) + monkeypatch.setattr(cv, "request_json", http.request_json) + assert cv.resolve_cloud_model_errors(validation(), workflow(), where="cloud")["valid"] is True + assert len(seen) == 1 + + +def test_bounded_http_body_preserves_original_error(service, monkeypatch): + import io + + from comfy_cli import http + + cv, _ = service + + class Response(io.BytesIO): + status = 200 + + monkeypatch.setattr(http._AUTHED_OPENER, "open", lambda *args, **kw: Response(b"x" * (2 * 1024 * 1024 + 1))) + monkeypatch.setattr(cv, "request_json", http.request_json) + result = validation() + assert cv.resolve_cloud_model_errors(result, workflow(), where="cloud") == result + + +@pytest.mark.parametrize("hash_value", [DIGEST, DIGEST + ".safetensors", "blake3:" + DIGEST]) +def test_supported_server_hash_forms(service, hash_value): + cv, request = service + request.return_value = (200, {"assets": [asset(hash=hash_value)], "has_more": False}) + resolved = cv.resolve_cloud_model_errors(validation(), workflow(), where="cloud") + assert resolved["valid"] is True + assert resolved["warnings"][-1]["content_hash"] == "blake3:" + DIGEST + + +def test_unique_lookups_are_bounded_and_unchecked_errors_remain(service): + cv, request = service + wf = {} + errors = [] + for i in range(17): + wf[str(i)] = {"class_type": "LoraLoaderModelOnly", "inputs": {"lora_name": f"{i}.safetensors"}} + errors.append({"node_id": str(i), "field": "lora_name", "code": "unknown_enum_value"}) + + def lookup(url, *args, **kwargs): + name = parse_qs(urlsplit(url).query)["name_contains"][0] + return 200, {"assets": [asset(name=name)], "has_more": False} + + request.side_effect = lookup + result = cv.resolve_cloud_model_errors({"valid": False, "errors": errors, "warnings": []}, wf, where="cloud") + assert request.call_count == 16 + assert result["valid"] is False + assert result["errors"] == [errors[-1]] + + +@pytest.mark.parametrize("skipped_kind", ["unknown-class", "missing-class", "unexecuted-model"]) +def test_targeted_run_keeps_verified_model_resolution_and_full_graph_class_checks(service, skipped_kind): + import typer + + from comfy_cli.command.run.preflight import _preflight_validate + + _, request = service + runnable = workflow() + if skipped_kind == "unknown-class": + skipped = {"class_type": "NotInstalled", "inputs": {}} + expected = "unknown_class_type" + elif skipped_kind == "missing-class": + skipped = {"inputs": {}} + expected = "missing_class_type" + else: + skipped = copy.deepcopy(runnable["2"]) + skipped["inputs"]["lora_name"] = "unexecuted-private.safetensors" + expected = None + submitted = {**runnable, "9": skipped} + renderer = Mock() + renderer.is_pretty.return_value = False + + def validate(): + _preflight_validate( + renderer, runnable, object_info(), where="cloud", target_label="cloud", submitted_workflow=submitted + ) + + if expected: + with pytest.raises(typer.Exit): + validate() + details = renderer.error.call_args.kwargs["details"] + assert [(error["node_id"], error["code"]) for error in details["errors"]] == [("9", expected)] + assert any(warning["code"] == "cloud_model_asset_verified" for warning in details["warnings"]) + else: + validate() + renderer.error.assert_not_called() + request.assert_called_once() + assert parse_qs(urlsplit(request.call_args.args[0]).query)["name_contains"] == [NAME] diff --git a/tests/comfy_cli/test_cloud_workflow_schema.py b/tests/comfy_cli/test_cloud_workflow_schema.py new file mode 100644 index 000000000..274b8ac0b --- /dev/null +++ b/tests/comfy_cli/test_cloud_workflow_schema.py @@ -0,0 +1,54 @@ +"""Acceptance parity with the actual matching frontend saved-canvas consumer.""" + +from __future__ import annotations + +import json +from pathlib import Path + +import pytest + +CORPUS = json.loads((Path(__file__).parent / "fixtures/cloud_workflow_consumer/corpus.json").read_text()) + + +@pytest.mark.parametrize("case", CORPUS["cases"], ids=lambda case: case["id"]) +def test_saved_canvas_matches_frontend_consumer(case): + from comfy_cli.cloud_workflow_schema import is_supported_canvas + + assert is_supported_canvas(case["input"]) is case["accepted"] + + +def test_url_validation_does_not_resolve_or_contact_the_host(monkeypatch): + import socket + + from comfy_cli.cloud_workflow_schema import _uri + + def network_forbidden(*args, **kwargs): + pytest.fail("URL syntax validation must not perform network I/O") + + monkeypatch.setattr(socket, "getaddrinfo", network_forbidden) + monkeypatch.setattr(socket, "create_connection", network_forbidden) + assert _uri("https://never-resolve-this-name.invalid/path?q=1#fragment") is True + + +def test_configured_cloud_origin_is_not_an_implicit_url_base(monkeypatch): + from comfy_cli.cloud_workflow_schema import _uri + + monkeypatch.setenv("COMFY_CLOUD_BASE_URL", "https://cloud.test") + assert _uri("/relative/model.safetensors") is False + assert _uri("//example.com/model.safetensors") is False + + +def test_missing_native_parser_cannot_verify_a_url(monkeypatch): + import builtins + + from comfy_cli.cloud_workflow_schema import _uri + + original = builtins.__import__ + + def without_parser(name, *args, **kwargs): + if name == "ada_url": + raise ImportError("simulated unavailable native parser") + return original(name, *args, **kwargs) + + monkeypatch.setattr(builtins, "__import__", without_parser) + assert _uri("https://example.com/model.safetensors") is False diff --git a/tests/comfy_cli/test_data_plane_token.py b/tests/comfy_cli/test_data_plane_token.py index 9f138686c..07553aa3e 100644 --- a/tests/comfy_cli/test_data_plane_token.py +++ b/tests/comfy_cli/test_data_plane_token.py @@ -27,7 +27,7 @@ def __init__(self, proactive: str, forced: str | None) -> None: self.forced = forced self.forced_calls = 0 - def __call__(self, *, refresh=True, force=False, allow_clear=True, expect=None): + def __call__(self, *, refresh=True, force=False, allow_clear=True, rejected_access_token=None, expect=None): if force: self.forced_calls += 1 if not self.forced: @@ -181,7 +181,7 @@ def test_a_sign_in_to_another_environment_mid_run_is_never_sent_or_refreshed(mon refreshing: list[bool] = [] - def get_session(*, refresh=True, force=False, allow_clear=True): + def get_session(*, refresh=True, force=False, allow_clear=True, rejected_access_token=None): if refresh or force: refreshing.append(allow_clear) return stored @@ -382,3 +382,28 @@ def get_session(**kwargs): # Then: the refresh is asked exactly as before, with no expectation attached assert calls and all("expect" not in kwargs for kwargs in calls) + + +def test_an_account_bound_holder_adopts_the_same_accounts_peer_refresh(login_race) -> None: + held = _save_login("a", expires_at=_LATER).access_token + token = DataPlaneToken(held, refreshes=True, base_url=_CLOUD, same_account=True) + peer = _jwt("a", 2) + from comfy_cli.auth import store + + stored = store.get_cloud_session() + store.save_cloud_session( + base_url=stored.base_url, + resource=stored.resource, + client_id=stored.client_id, + scope=stored.scope, + access_token=peer, + refresh_token="refresh-a-peer", + token_type="Bearer", + expires_at=_LATER, + ) + + assert token.after_rejection() is True + assert token.current() == peer + assert login_race.refreshed == [] + assert store.get_cloud_session().refresh_token == "refresh-a-peer" + assert token.account_replaced is False diff --git a/tests/comfy_cli/test_desktop_install.py b/tests/comfy_cli/test_desktop_install.py new file mode 100644 index 000000000..3d069bd29 --- /dev/null +++ b/tests/comfy_cli/test_desktop_install.py @@ -0,0 +1,615 @@ +"""Comfy Desktop 2 detection from the records Desktop keeps on disk. + +Every test builds its own fixture layout under ``tmp_path``; none reads the +machine's real Desktop files (the autouse ``_isolate_comfy_desktop`` fixture +points detection at an empty dir unless a test passes its own). +""" + +from __future__ import annotations + +import json +from pathlib import Path + +import pytest + +from comfy_cli import desktop_install +from comfy_cli.constants import OS + +# Bound at import, before the autouse isolation fixture replaces the module +# attributes, so the per-OS resolution itself can still be tested. +_real_app_data_dir = desktop_install.desktop_app_data_dir +_real_legacy_config_dir = desktop_install.legacy_config_dir + + +def _checkout(code_dir: Path, version: str | None = None) -> Path: + code_dir.mkdir(parents=True, exist_ok=True) + (code_dir / "main.py").write_text("") + if version: + (code_dir / "comfyui_version.py").write_text(f'__version__ = "{version}"\n') + return code_dir + + +def _venv(root: Path) -> Path: + py = root / ".venv" / "bin" / "python3" + py.parent.mkdir(parents=True, exist_ok=True) + py.write_text("") + return py + + +def _write_desktop(app_dir: Path, installs: list, *, models_dirs: list[str] | None = None) -> Path: + app_dir.mkdir(parents=True, exist_ok=True) + (app_dir / "installations.json").write_text(json.dumps(installs)) + (app_dir / "settings.json").write_text(json.dumps({"modelsDirs": models_dirs or []})) + return app_dir + + +def test_no_installations_file_means_no_desktop(tmp_path): + assert desktop_install.detect(tmp_path / "Comfy Desktop", tmp_path / "legacy") is None + + +def test_adopted_install_reports_its_split_layout(comfy_desktop): + layout = comfy_desktop + + found = desktop_install.detect(layout["app"], layout["legacy"]) + + assert found is not None + install = found.selected + assert install is not None + assert install.install_id == "inst-adopted" + assert install.code_dir == str(layout["code"]) + assert install.data_dir == str(layout["data"]) + assert install.python == str(layout["python"]) + assert install.comfyui_version == "v0.34.2" + assert install.comfyui_commit == "b53f77a7" + # The data dir's own models/ is listed once even though settings.json also + # names it; the shared root follows. + assert [(r.path, r.source) for r in install.model_roots] == [ + (str(layout["data"] / "models"), "data"), + (str(layout["shared"]), "shared"), + ] + assert all(r.exists for r in install.model_roots) + # The Comfy Cloud entry has no local files and is not an install here. + assert [i.install_id for i in found.installs] == ["inst-adopted"] + assert found.selected_reason == "the only Comfy Desktop install with a ComfyUI checkout on disk" + assert found.problems == () + + +def test_to_dict_puts_the_selected_install_at_the_top(comfy_desktop): + layout = comfy_desktop + + block = desktop_install.detect(layout["app"], layout["legacy"]).to_dict() + + assert block["code_dir"] == str(layout["code"]) + assert block["data_dir"] == str(layout["data"]) + assert block["custom_nodes_dir"] == str(layout["data"] / "custom_nodes") + assert block["python"] == str(layout["python"]) + assert block["comfyui_version"] == "v0.34.2" + assert [r["path"] for r in block["model_roots"]] == [str(layout["data"] / "models"), str(layout["shared"])] + assert block["installs"] == [ + { + "install_id": "inst-adopted", + "name": "ComfyUI", + "code_dir": str(layout["code"]), + "data_dir": str(layout["data"]), + "comfyui_version": "v0.34.2", + "last_launched_at": "2026-10-16T22:10:27Z", + "status": "installed", + "exists": True, + "selected": True, + } + ] + assert block["app_data_dir"] == str(layout["app"]) + + +def test_standalone_install_keeps_data_beside_the_code(tmp_path): + install_path = tmp_path / "ComfyUI-Installs" / "Fresh" + code = _checkout(install_path / "ComfyUI") + python = _venv(code) + app = _write_desktop( + tmp_path / "Comfy Desktop", + [{"id": "inst-fresh", "installPath": str(install_path), "comfyVersion": {"baseTag": "v0.41.1"}}], + ) + + install = desktop_install.detect(app, tmp_path / "legacy").selected + + assert install.code_dir == str(code) + assert install.data_dir == str(code) + assert install.python == str(python) + assert [r.path for r in install.model_roots] == [str(code / "models")] + + +def test_most_recently_launched_install_is_selected_and_the_reason_says_so(tmp_path): + older = tmp_path / "Installs" / "Old" + newer = tmp_path / "Installs" / "New" + _checkout(older / "ComfyUI") + _checkout(newer / "ComfyUI") + app = _write_desktop( + tmp_path / "Comfy Desktop", + [ + {"id": "old", "installPath": str(older), "lastLaunchedAt": 1_700_000_000_000}, + {"id": "new", "installPath": str(newer), "lastLaunchedAt": 1_790_000_000_000}, + {"id": "never", "installPath": str(tmp_path / "Installs" / "Gone")}, + ], + ) + + found = desktop_install.detect(app, tmp_path / "legacy") + + assert found.selected.install_id == "new" + assert "most recently launched of 2 Comfy Desktop installs" in found.selected_reason + assert [i.install_id for i in found.installs] == ["old", "new", "never"] + rows = {row["install_id"]: row for row in found.to_dict()["installs"]} + assert rows["new"]["selected"] is True + assert rows["old"]["selected"] is False + # An install whose checkout is gone is listed but never selected. + assert rows["never"]["exists"] is False + assert rows["never"]["selected"] is False + + +def test_no_launch_history_picks_the_first_listed_install(tmp_path): + first = tmp_path / "Installs" / "A" + second = tmp_path / "Installs" / "B" + _checkout(first / "ComfyUI") + _checkout(second / "ComfyUI") + app = _write_desktop( + tmp_path / "Comfy Desktop", + [{"id": "a", "installPath": str(first)}, {"id": "b", "installPath": str(second)}], + ) + + found = desktop_install.detect(app, tmp_path / "legacy") + + assert found.selected.install_id == "a" + assert "none has been launched" in found.selected_reason + + +def test_no_install_with_a_checkout_selects_nothing(tmp_path): + app = _write_desktop(tmp_path / "Comfy Desktop", [{"id": "gone", "installPath": str(tmp_path / "missing")}]) + + found = desktop_install.detect(app, tmp_path / "legacy") + + assert found.selected is None + assert found.selected_reason is None + assert [i.install_id for i in found.installs] == ["gone"] + + +def test_opting_out_of_shared_models_drops_the_shared_roots(tmp_path): + install_path = tmp_path / "Installs" / "Isolated" + code = _checkout(install_path / "ComfyUI") + extra = tmp_path / "extra-models" + app = _write_desktop( + tmp_path / "Comfy Desktop", + [{"id": "iso", "installPath": str(install_path), "useSharedModels": False, "modelDirs": [str(extra)]}], + models_dirs=[str(tmp_path / "shared")], + ) + + install = desktop_install.detect(app, tmp_path / "legacy").selected + + assert [(r.path, r.source, r.exists) for r in install.model_roots] == [ + (str(code / "models"), "data", False), + (str(extra), "install", False), + ] + + +def test_adopted_record_without_a_base_dir_falls_back_to_desktop_1_config(comfy_desktop): + layout = comfy_desktop + record = dict(layout["record"]) + del record["adoptedBaseDir"] + del record["adoptedPythonPath"] + _write_desktop(layout["app"], [record]) + + install = desktop_install.detect(layout["app"], layout["legacy"]).selected + + assert install.data_dir == str(layout["data"]) + assert install.python == str(layout["python"]) + + +def test_version_falls_back_to_the_checkout_marker(tmp_path): + install_path = tmp_path / "Installs" / "Marker" + _checkout(install_path / "ComfyUI", version="0.41.2") + app = _write_desktop(tmp_path / "Comfy Desktop", [{"id": "m", "installPath": str(install_path)}]) + + install = desktop_install.detect(app, tmp_path / "legacy").selected + + assert install.comfyui_version == "v0.41.2" + + +def test_unreadable_installations_file_is_a_problem_not_a_crash(tmp_path): + app = tmp_path / "Comfy Desktop" + app.mkdir() + (app / "installations.json").write_text("{not json") + + found = desktop_install.detect(app, tmp_path / "legacy") + + assert found is not None + assert found.selected is None + assert len(found.problems) == 1 + assert "installations.json" in found.problems[0] + + +def test_unreadable_settings_file_still_detects_the_install(comfy_desktop): + layout = comfy_desktop + (layout["app"] / "settings.json").write_text("[broken") + + found = desktop_install.detect(layout["app"], layout["legacy"]) + + assert found.selected.install_id == "inst-adopted" + assert [r.source for r in found.selected.model_roots] == ["data"] + assert len(found.problems) == 1 + assert "settings.json" in found.problems[0] + + +def test_install_for_dir_matches_the_code_dir_and_the_data_dir(comfy_desktop, tmp_path): + layout = comfy_desktop + found = desktop_install.detect(layout["app"], layout["legacy"]) + + assert desktop_install.install_for_dir(layout["data"], found).install_id == "inst-adopted" + assert desktop_install.install_for_dir(layout["code"], found).install_id == "inst-adopted" + assert desktop_install.install_for_dir(tmp_path, found) is None + + +@pytest.mark.parametrize( + ("os_value", "env", "expected"), + [ + (OS.MACOS, {}, Path.home() / "Library" / "Application Support" / "Comfy Desktop"), + (OS.WINDOWS, {"APPDATA": "/appdata"}, Path("/appdata") / "Comfy Desktop"), + (OS.LINUX, {"XDG_DATA_HOME": "/xdg"}, Path("/xdg") / "Comfy Desktop"), + ], +) +def test_app_data_dir_per_os(monkeypatch, os_value, env, expected): + monkeypatch.setattr(desktop_install, "get_os", lambda: os_value) + for key in ("APPDATA", "XDG_DATA_HOME"): + monkeypatch.delenv(key, raising=False) + for key, value in env.items(): + monkeypatch.setenv(key, value) + + assert _real_app_data_dir() == expected + + +def test_legacy_config_dir_per_os(monkeypatch): + monkeypatch.setattr(desktop_install, "get_os", lambda: OS.MACOS) + assert _real_legacy_config_dir() == Path.home() / "Library" / "Application Support" / "ComfyUI" + monkeypatch.setattr(desktop_install, "get_os", lambda: OS.LINUX) + assert _real_legacy_config_dir() is None + + +@pytest.mark.parametrize("timestamp", [1e30, float("inf")]) +def test_invalid_launch_timestamp_does_not_break_discovery(tmp_path, timestamp): + install_path = tmp_path / "Installs" / "Valid" + _checkout(install_path / "ComfyUI") + app = _write_desktop( + tmp_path / "Comfy Desktop", + [{"id": "valid", "installPath": str(install_path), "lastLaunchedAt": timestamp}], + ) + + found = desktop_install.detect(app, tmp_path / "legacy") + + assert found.to_dict()["installs"][0]["last_launched_at"] is None + assert found.selected.install_id == "valid" + + +def test_adopted_install_with_unreadable_legacy_config_marks_data_root_uncertain(tmp_path): + code = _checkout(tmp_path / "checkout") + app = _write_desktop(tmp_path / "Comfy Desktop", [{"id": "adopted", "installPath": str(code), "adopted": True}]) + legacy = tmp_path / "legacy" + legacy.mkdir() + (legacy / "config.json").write_text("{broken") + + found = desktop_install.detect(app, legacy) + + assert any("config.json" in problem for problem in found.problems) + assert any("unverified" in problem and "data" in problem for problem in found.problems) + + +def test_detect_scans_modern_userdata_and_keeps_each_registry_roots(tmp_path, monkeypatch): + old = tmp_path / "Comfy Desktop" + modern = tmp_path / "comfyui-desktop-2" + for app, name in ((old, "old"), (modern, "modern")): + code = _checkout(tmp_path / name / "ComfyUI") + _write_desktop( + app, [{"id": name, "installPath": str(code.parent)}], models_dirs=[str(tmp_path / name / "shared")] + ) + monkeypatch.setattr(desktop_install, "desktop_app_data_dir", lambda: old) + found = desktop_install.detect() + assert {install.install_id for install in found.installs} == {"old", "modern"} + modern_install = next(install for install in found.installs if install.install_id == "modern") + assert str(tmp_path / "modern" / "shared") in [root.path for root in modern_install.model_roots] + assert str(tmp_path / "old" / "shared") not in [root.path for root in modern_install.model_roots] + + +def test_running_server_selects_matching_instance_instead_of_latest(tmp_path): + records = [] + for name, launched in (("running", 1), ("latest", 2)): + code = _checkout(tmp_path / name / "ComfyUI") + records.append({"id": name, "installPath": str(code.parent), "lastLaunchedAt": launched}) + app = _write_desktop(tmp_path / "Comfy Desktop", records) + found = desktop_install.detect( + app, + server_stats={"system": {"argv": [str(tmp_path / "running" / "ComfyUI" / "main.py")]}}, + server_filesystem_verified=True, + ) + assert found.selected.install_id == "running" + assert "running server" in found.selected_reason + + +def test_server_instance_config_matches_install_and_applies_effective_paths(tmp_path): + code = _checkout(tmp_path / "install" / "ComfyUI") + app = _write_desktop(tmp_path / "Comfy Desktop", [{"id": "inst-live", "installPath": str(code.parent)}]) + config = app / "instance-model-paths" / "inst-live.yaml" + config.parent.mkdir() + root = tmp_path / "effective-models" + config.write_text(f"live:\n base_path: {root}\n checkpoints: checkpoints\n") + data = tmp_path / "effective-data" + inputs = tmp_path / "private-inputs" + stats = { + "system": { + "argv": [ + "main.py", + "--extra-model-paths-config", + str(config), + "--base-directory", + str(data), + "--input-directory", + str(inputs), + ] + } + } + found = desktop_install.detect(app, server_stats=stats, server_filesystem_verified=True) + assert found.selected.install_id == "inst-live" + assert found.selected.data_dir == str(data) + assert str(root) in [root.path for root in found.selected.model_roots] + assert found.to_dict()["input_dir"] == str(inputs) + + +def test_server_that_does_not_match_records_is_not_silently_assumed(tmp_path): + code = _checkout(tmp_path / "install" / "ComfyUI") + app = _write_desktop(tmp_path / "Comfy Desktop", [{"id": "candidate", "installPath": str(code.parent)}]) + found = desktop_install.detect( + app, + server_stats={"system": {"argv": [str(tmp_path / "different" / "main.py")]}}, + server_filesystem_verified=True, + ) + assert found.selected is None + assert any("running server" in problem for problem in found.problems) + + +def test_server_model_configs_replace_stale_shared_settings(tmp_path): + code = _checkout(tmp_path / "install" / "ComfyUI") + app = _write_desktop( + tmp_path / "Comfy Desktop", + [{"id": "live", "installPath": str(code.parent)}], + models_dirs=[str(tmp_path / "stale")], + ) + first, second = tmp_path / "one.yaml", tmp_path / "two.yaml" + first.write_text(f"one:\n base_path: {tmp_path / 'models-one'}\n checkpoints: checkpoints\n") + second.write_text(f"two:\n base_path: {tmp_path / 'models-two'}\n loras: loras\n") + stats = { + "system": { + "argv": [str(code / "main.py"), "--extra-model-paths-config", str(first), str(second)], + "comfyui_version": "0.99.0", + } + } + found = desktop_install.detect(app, server_stats=stats, server_filesystem_verified=True) + paths = [root.path for root in found.selected.model_roots] + assert str(tmp_path / "stale") not in paths + assert str(tmp_path / "models-one") in paths + assert str(tmp_path / "models-two") in paths + assert found.selected.comfyui_version == "v0.99.0" + + +def test_relative_server_data_paths_are_unverified(tmp_path): + code = _checkout(tmp_path / "install" / "ComfyUI") + app = _write_desktop(tmp_path / "Comfy Desktop", [{"id": "live", "installPath": str(code.parent)}]) + found = desktop_install.detect( + app, + server_stats={"system": {"argv": [str(code / "main.py"), "--base-directory", "relative-data"]}}, + server_filesystem_verified=True, + ) + assert found.selected is None + assert any("relative" in problem for problem in found.problems) + + +def test_server_config_includes_absolute_paths_outside_base_and_no_base_sections(tmp_path): + code = _checkout(tmp_path / "install" / "ComfyUI") + app = _write_desktop(tmp_path / "Comfy Desktop", [{"id": "live", "installPath": str(code.parent)}]) + config = tmp_path / "models.yaml" + outside = tmp_path / "private-loras" + config.write_text( + f"one:\n base_path: {tmp_path / 'models'}\n loras: {outside}\ntwo:\n checkpoints: relative-checkpoints\n" + ) + found = desktop_install.detect( + app, + server_stats={"system": {"argv": [str(code / "main.py"), "--extra-model-paths-config", str(config)]}}, + server_filesystem_verified=True, + ) + paths = [root.path for root in found.selected.model_roots] + assert str(outside) in paths + assert str(tmp_path / "relative-checkpoints") in paths + assert not found.problems + + +@pytest.mark.parametrize("explicit", [True, False]) +def test_running_server_output_directory_is_reported_with_source(tmp_path, explicit): + code = _checkout(tmp_path / "install" / "ComfyUI") + app = _write_desktop(tmp_path / "Comfy Desktop", [{"id": "live", "installPath": str(code.parent)}]) + output = tmp_path / "actual-output" if explicit else code / "output" + argv = [str(code / "main.py")] + if explicit: + argv += ["--output-directory", str(output)] + found = desktop_install.detect(app, server_stats={"system": {"argv": argv}}, server_filesystem_verified=True) + assert found.to_dict()["output_dir"] == str(output) + assert found.to_dict()["output_dir_source"] == ("server_argv" if explicit else "server_default") + + +def test_relative_output_directory_requires_process_cwd_verification(tmp_path): + code = _checkout(tmp_path / "install" / "ComfyUI") + app = _write_desktop(tmp_path / "Comfy Desktop", [{"id": "live", "installPath": str(code.parent)}]) + found = desktop_install.detect( + app, + server_stats={"system": {"argv": [str(code / "main.py"), "--output-directory", "relative-output"]}}, + server_filesystem_verified=True, + ) + assert found.selected is None + assert "output_dir" not in found.to_dict() + + +@pytest.mark.parametrize("override_data", [False, True], ids=["registry-data", "process-data"]) +@pytest.mark.parametrize( + "process_python", ["missing", "none", "empty", "wrong-type", "missing-file", "directory", "valid-file"] +) +def test_server_interpreter_uses_only_a_verified_process_path(tmp_path, override_data, process_python): + code = _checkout(tmp_path / "install" / "ComfyUI") + registry_python = _venv(code) + app = _write_desktop(tmp_path / "Comfy Desktop", [{"id": "live", "installPath": str(code.parent)}]) + legacy = tmp_path / "legacy" + assert desktop_install.detect(app, legacy).selected.python == str(registry_python) + + data = tmp_path / "process-data" if override_data else code + if override_data: + _venv(data) # Even an existing data-directory interpreter is not process evidence. + runtime_python = tmp_path / "process-python" + runtime_python.write_text("") + system = {"argv": [str(code / "main.py"), "--base-directory", str(data)]} + if process_python != "missing": + system["python"] = { + "none": None, + "empty": "", + "wrong-type": 42, + "missing-file": str(tmp_path / "missing-python"), + "directory": str(data), + "valid-file": str(runtime_python), + }[process_python] + + found = desktop_install.detect(app, legacy, server_stats={"system": system}, server_filesystem_verified=True) + + expected_python = str(runtime_python) if process_python == "valid-file" else None + assert found.selected.data_dir == str(data) + assert found.selected.python == expected_python + assert found.to_dict()["python"] == expected_python + + +@pytest.mark.parametrize("match", ["code-path", "config-stem"]) +def test_server_paths_without_filesystem_provenance_do_not_select_local_install(tmp_path, monkeypatch, match): + code = _checkout(tmp_path / "unrelated-local" / "ComfyUI") + _venv(code) + app = _write_desktop(tmp_path / "registry", [{"id": "collision", "installPath": str(code.parent)}]) + config = app / "collision.yaml" + config.write_text("private:\n base_path: /unrelated-local-models\n checkpoints: checkpoints\n") + argv = [str(code / "main.py")] if match == "code-path" else ["/remote/main.py"] + argv += ["--extra-model-paths-config", str(config)] + original = Path.read_text + + def read(path, *args, **kwargs): + assert path != config, "unverified server metadata must not read a local model config" + return original(path, *args, **kwargs) + + monkeypatch.setattr(Path, "read_text", read) + found = desktop_install.detect(app, server_stats={"system": {"argv": argv}}) + + assert found.selected is None + block = found.to_dict() + assert block["python"] is None + assert block["model_roots"] == [] + assert "input_dir" not in block and "output_dir" not in block + assert any("filesystem" in problem for problem in found.problems) + + +def test_verified_local_server_cannot_select_desktop_by_copied_config_stem(tmp_path, monkeypatch): + code = _checkout(tmp_path / "unrelated-desktop" / "ComfyUI") + app = _write_desktop(tmp_path / "registry", [{"id": "collision", "installPath": str(code.parent)}]) + copied = tmp_path / "outside-registry" / "collision.yaml" + copied.parent.mkdir() + copied.write_text("private:\n base_path: /unrelated-private\n loras: loras\n") + original = Path.read_text + + def read(path, *args, **kwargs): + assert path != copied, "a copied config name is not Desktop launch identity" + return original(path, *args, **kwargs) + + monkeypatch.setattr(Path, "read_text", read) + found = desktop_install.detect( + app, + server_stats={"system": {"argv": ["/other/main.py", "--extra-model-paths-config", str(copied)]}}, + server_filesystem_verified=True, + ) + assert found.selected is None + assert found.to_dict()["model_roots"] == [] + + +@pytest.mark.parametrize("selected_registry", [0, 1]) +def test_generated_config_identity_keeps_owning_registry_with_duplicate_ids(tmp_path, monkeypatch, selected_registry): + apps = [] + codes = [] + for name in ("comfyui-desktop-2", "Comfy Desktop"): + code = _checkout(tmp_path / name / "install" / "ComfyUI") + app = _write_desktop(tmp_path / name / "registry", [{"id": "same-id", "installPath": str(code.parent)}]) + config = app / "instance-model-paths" / "same-id.yaml" + config.parent.mkdir() + config.write_text("{}") + apps.append(app) + codes.append(code) + monkeypatch.setattr(desktop_install, "app_data_dirs", lambda: tuple(apps)) + config = apps[selected_registry] / "instance-model-paths" / "same-id.yaml" + found = desktop_install.detect( + server_stats={"system": {"argv": ["/shared/bundled/main.py", "--extra-model-paths-config", str(config)]}}, + server_filesystem_verified=True, + ) + assert found.selected.code_dir == str(codes[selected_registry]) + assert [i.summary(selected=i is found.selected)["selected"] for i in found.installs] == [ + selected_registry == 0, + selected_registry == 1, + ] + block = found.to_dict() + assert "registry_dir" not in block + assert all("registry_dir" not in item for item in block["installs"]) + + +@pytest.mark.parametrize( + "install_id", ["../collision", "nested/id", "nested\\id", "/absolute", "C:collision", "null\x00id"] +) +def test_config_identity_rejects_path_separators_in_record_id(tmp_path, install_id): + if ":" in install_id: + from pathlib import PureWindowsPath + + # A drive-relative component discards the owning registry on Windows. + expected = PureWindowsPath("D:/registry/instance-model-paths") / f"{install_id}.yaml" + assert expected.drive == "C:" and not expected.is_absolute() + code = _checkout(tmp_path / "install" / "ComfyUI") + app = _write_desktop(tmp_path / "registry", [{"id": install_id, "installPath": str(code.parent)}]) + config = app / "instance-model-paths" / f"{install_id}.yaml" + found = desktop_install.detect( + app, + server_stats={"system": {"argv": ["/other/main.py", "--extra-model-paths-config", str(config)]}}, + server_filesystem_verified=True, + ) + assert found.selected is None + + +def test_unknown_server_provenance_clears_previously_derived_directories(tmp_path): + from dataclasses import replace + + code = _checkout(tmp_path / "install" / "ComfyUI") + app = _write_desktop(tmp_path / "registry", [{"id": "live", "installPath": str(code.parent)}]) + found = replace( + desktop_install.detect(app), + input_dir="/previous/input", + output_dir="/previous/output", + output_dir_source="server_argv", + ) + unresolved = desktop_install._for_server(found, {"system": {"argv": [str(code / "main.py")]}}) + assert unresolved.selected is None + assert unresolved.input_dir is None and unresolved.output_dir is None and unresolved.output_dir_source is None + + +def test_generated_config_identity_accepts_verified_file_alias(tmp_path): + code = _checkout(tmp_path / "install" / "ComfyUI") + app = _write_desktop(tmp_path / "registry", [{"id": "live", "installPath": str(code.parent)}]) + config = app / "instance-model-paths" / "live.yaml" + config.parent.mkdir() + config.write_text("{}") + alias = tmp_path / "verified-config-alias.yaml" + alias.symlink_to(config) + found = desktop_install.detect( + app, + server_stats={"system": {"argv": ["/shared/main.py", "--extra-model-paths-config", str(alias)]}}, + server_filesystem_verified=True, + ) + assert found.selected.install_id == "live" diff --git a/tests/comfy_cli/test_http.py b/tests/comfy_cli/test_http.py index 703199d85..20adb7027 100644 --- a/tests/comfy_cli/test_http.py +++ b/tests/comfy_cli/test_http.py @@ -819,7 +819,6 @@ def test_an_unloadable_supplement_falls_through_to_the_platform_roots(tmp_path, monkeypatch.setitem(sys.modules, "certifi", types.SimpleNamespace(where=lambda: str(broken))) real = ssl.create_default_context - populated = len(pathlib.Path(certifi.where()).read_text().split("-----BEGIN CERTIFICATE-----")) - 1 def platform_with_roots(*args, **kwargs): context = real(*args, **kwargs) @@ -827,13 +826,15 @@ def platform_with_roots(*args, **kwargs): context.load_verify_locations(cafile=certifi.where()) return context + expected_roots = set(platform_with_roots().get_ca_certs(binary_form=True)) + assert expected_roots, "the platform fixture must contain trust roots" monkeypatch.setattr(ssl, "create_default_context", platform_with_roots) # When context = http_mod.ssl_context() # Then - assert context.cert_store_stats()["x509_ca"] == populated, ( + assert set(context.get_ca_certs(binary_form=True)) == expected_roots, ( "the platform roots must survive a supplement that would not load" ) diff --git a/tests/comfy_cli/test_local_server_identity.py b/tests/comfy_cli/test_local_server_identity.py new file mode 100644 index 000000000..f17006b44 --- /dev/null +++ b/tests/comfy_cli/test_local_server_identity.py @@ -0,0 +1,377 @@ +"""Read-only provenance: network-reported paths are not local filesystem proof.""" + +import json +import socket +import subprocess +import sys +import time +import urllib.error +from dataclasses import replace +from pathlib import Path +from types import SimpleNamespace +from unittest.mock import Mock + +import psutil +import pytest + +from comfy_cli import local_server_identity as identity +from comfy_cli.command.stop_port import Listener + + +@pytest.fixture +def process(tmp_path): + script = tmp_path / "main.py" + script.write_text("") + return Listener( + 123, [sys.executable, str(script), "--listen", "127.0.0.1"], str(tmp_path), "python", "127.0.0.1", 10.0 + ) + + +def _stats(process): + return {"system": {"argv": process.cmdline[1:], "comfyui_version": "test", "python": sys.executable}} + + +@pytest.mark.parametrize("change", ["missing", "pid", "start", "argv", "cwd", "no-start"]) +def test_process_identity_must_survive_the_request(process, monkeypatch, change): + after = { + "missing": None, + "pid": replace(process, pid=456), + "start": replace(process, create_time=11.0), + "argv": replace(process, cmdline=["ssh", "-L", "8188:remote:8188"]), + "cwd": replace(process, cwd="/elsewhere"), + "no-start": replace(process, create_time=None), + }[change] + monkeypatch.setattr(identity, "_same_filesystem_namespace", lambda pid: True) + assert not identity._verified(_stats(process), process, after) + + +@pytest.mark.parametrize( + "change", ["missing-argv", "wrong-argv", "wrong-script", "missing-version", "forwarder", "unknown-cwd", "container"] +) +def test_reported_paths_do_not_replace_os_evidence(process, monkeypatch, change): + stats = _stats(process) + if change == "missing-argv": + del stats["system"]["argv"] + elif change == "wrong-argv": + stats["system"]["argv"] = [str(Path(process.cwd) / "main.py"), "--base-directory", "/private"] + elif change == "wrong-script": + stats["system"]["argv"][0] = "/remote/main.py" + elif change == "missing-version": + del stats["system"]["comfyui_version"] + elif change == "forwarder": + process = replace(process, cmdline=["ssh", "-L", "8188:remote:8188"]) + elif change == "unknown-cwd": + process = replace(process, cmdline=[sys.executable, "main.py"], cwd=None) + stats["system"]["argv"] = ["main.py"] + monkeypatch.setattr(identity, "_same_filesystem_namespace", lambda pid: change != "container") + assert not identity._verified(stats, process, process) + + +def test_relative_script_uses_verified_process_cwd(process, monkeypatch): + process = replace(process, cmdline=[sys.executable, "main.py", *process.cmdline[2:]]) + monkeypatch.setattr(identity, "_same_filesystem_namespace", lambda pid: True) + assert identity._verified(_stats(process), process, process) + + +@pytest.mark.parametrize("failure", [None, "mount", "root", "unreadable"]) +def test_linux_requires_same_mount_namespace_and_process_root(monkeypatch, failure): + monkeypatch.setattr(identity, "sys", SimpleNamespace(platform="linux")) + seen = [] + + def samefile(path, other): + seen.append((str(path), str(other))) + if failure == "unreadable": + raise PermissionError("restricted /proc") + return not ( + (failure == "mount" and "ns/mnt" in str(path)) or (failure == "root" and str(path).endswith("root")) + ) + + monkeypatch.setattr(Path, "samefile", samefile) + assert identity._same_filesystem_namespace(123) == (failure is None) + if failure is None: + assert len(seen) == 2 + + +def _conn(ip): + return SimpleNamespace(status=psutil.CONN_LISTEN, laddr=SimpleNamespace(ip=ip, port=8188)) + + +@pytest.mark.parametrize( + "bound,accepted", [("127.0.0.2", False), ("127.0.0.1", True), ("0.0.0.0", True), ("::", False)] +) +def test_listener_must_bind_the_actual_address(process, monkeypatch, bound, accepted): + fake = SimpleNamespace( + pid=123, + info={"name": "python", "cmdline": process.cmdline}, + net_connections=lambda **kw: [_conn(bound)], + cwd=lambda: process.cwd, + create_time=lambda: 10.0, + ) + fake.cmdline = lambda: process.cmdline + fake.name = lambda: "python" + monkeypatch.setattr(psutil, "process_iter", lambda attrs: [fake]) + monkeypatch.setattr(psutil, "Process", lambda pid: fake) + monkeypatch.setattr(identity, "_is_local_address", lambda ip: True) + assert (identity._listener("127.0.0.1", 8188) is not None) == accepted + + +def test_remote_address_never_borrows_a_local_wildcard_listener(monkeypatch): + monkeypatch.setattr(psutil, "net_if_addrs", lambda: {}) + scan = Mock(side_effect=AssertionError("remote endpoint must not scan listeners")) + monkeypatch.setattr(psutil, "process_iter", scan) + assert identity._listener("192.0.2.77", 8188) is None + scan.assert_not_called() + + +def test_reused_port_with_multiple_owners_is_ambiguous(process, monkeypatch): + def fake(pid): + return SimpleNamespace( + pid=pid, + info={"name": "python", "cmdline": process.cmdline}, + net_connections=lambda **kw: [_conn("127.0.0.1")], + cwd=lambda: process.cwd, + create_time=lambda: 10.0, + ) + + owners = {pid: fake(pid) for pid in (123, 456)} + for owner in owners.values(): + owner.cmdline = lambda: process.cmdline + owner.name = lambda: "python" + monkeypatch.setattr(psutil, "process_iter", lambda attrs: list(owners.values())) + monkeypatch.setattr(psutil, "Process", lambda pid: owners[pid]) + assert identity._listener("127.0.0.1", 8188) is None + + +@pytest.fixture +def live_server(tmp_path, request): + """Own a real Python main.py listener; terminate only this fixture's child.""" + script = tmp_path / "ComfyUI" / getattr(request, "param", "main.py") + script.parent.mkdir() + port_file = tmp_path / "port" + script.write_text("""import json,sys +from http.server import BaseHTTPRequestHandler, HTTPServer +class Handler(BaseHTTPRequestHandler): + def do_GET(self): + if self.path == "/redirect": + self.send_response(302); self.send_header("Location", "/system_stats"); self.end_headers(); return + body=json.dumps({"system":{"argv":sys.argv,"comfyui_version":"test","python":sys.executable},"host":self.headers.get("Host")}).encode() + self.send_response(200); self.send_header("Content-Length",str(len(body))); self.end_headers(); self.wfile.write(body) + def log_message(self,*args): pass +server=HTTPServer(("127.0.0.1",0),Handler) +open(sys.argv[1],"w").write(str(server.server_port)) +server.serve_forever() +""") + child = subprocess.Popen( + [sys.executable, str(script), str(port_file)], cwd=tmp_path, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE + ) + try: + deadline = time.monotonic() + 10 + while not port_file.exists(): + assert child.poll() is None, child.stderr.read().decode() + assert time.monotonic() < deadline, "fixture listener did not start" + time.sleep(0.01) + yield int(port_file.read_text()), script, child + finally: + child.terminate() + child.communicate(timeout=5) + + +def test_actual_local_process_is_proven_and_host_header_preserved(live_server, monkeypatch): + port, _, child = live_server + # An HTTP proxy must not reroute the proof-bearing fetch. + monkeypatch.setenv("http_proxy", "http://127.0.0.1:1") + monkeypatch.setenv("HTTP_PROXY", "http://127.0.0.1:1") + monkeypatch.setenv("no_proxy", "") + monkeypatch.setenv("NO_PROXY", "") + document = identity.fetch_json(f"http://localhost:{port}/system_stats", verify_filesystem=True) + assert document.filesystem_verified + assert document.data["host"] == f"localhost:{port}" + assert child.poll() is None + + +def test_actual_redirect_does_not_supply_identity(live_server): + port, _, _ = live_server + with pytest.raises(urllib.error.HTTPError, match="redirect refused"): + identity.fetch_json(f"http://127.0.0.1:{port}/redirect", verify_filesystem=True) + + +def test_ipv6_then_ipv4_connection_fallback_remains_supported(live_server, monkeypatch): + port, _, _ = live_server + original = socket.getaddrinfo + + def resolve(host, *args, **kwargs): + if host == "localhost": + return [ + (socket.AF_INET6, socket.SOCK_STREAM, 6, "", ("::1", port, 0, 0)), + (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("127.0.0.1", port)), + ] + return original(host, *args, **kwargs) + + monkeypatch.setattr(socket, "getaddrinfo", resolve) + document = identity.fetch_json(f"http://localhost:{port}/system_stats", verify_filesystem=True) + assert document.filesystem_verified + assert document.data["host"] == f"localhost:{port}" + + +@pytest.mark.parametrize("live_server", ["forwarder.py"], indirect=True) +def test_real_python_forwarder_cannot_supply_filesystem_proof(live_server): + port, _, child = live_server + document = identity.fetch_json(f"http://127.0.0.1:{port}/system_stats", verify_filesystem=True) + assert document.data["system"]["comfyui_version"] == "test" + assert not document.filesystem_verified + assert child.poll() is None + + +@pytest.mark.parametrize("prefix", [["worker.py"], ["-c", "pass"], ["-m", "http.server"]]) +def test_later_main_py_token_is_not_the_executed_script(process, monkeypatch, prefix): + decoy = process.cmdline[1:] + process = replace(process, cmdline=[sys.executable, *prefix, *decoy]) + stats = {"system": {"argv": decoy, "comfyui_version": "test"}} + monkeypatch.setattr(identity, "_same_filesystem_namespace", lambda pid: True) + assert not identity._verified(stats, process, process) + + +@pytest.mark.parametrize("flags", [["-u"], ["-s", "-B"], ["-X", "dev"], ["-Wignore"], ["--"]]) +def test_python_interpreter_flags_before_actual_main_py_are_supported(process, monkeypatch, flags): + stats = _stats(process) + process = replace(process, cmdline=[sys.executable, *flags, *process.cmdline[1:]]) + monkeypatch.setattr(identity, "_same_filesystem_namespace", lambda pid: True) + assert identity._verified(stats, process, process) + + +def test_unreadable_process_table_preserves_server_metadata(live_server, monkeypatch): + port, _, _ = live_server + + def denied(*args, **kwargs): + raise psutil.AccessDenied() + + monkeypatch.setattr(psutil, "process_iter", denied) + document = identity.fetch_json(f"http://127.0.0.1:{port}/system_stats", verify_filesystem=True) + assert document.data["system"]["comfyui_version"] == "test" + assert not document.filesystem_verified + + +def test_real_listener_proof_selects_desktop_inventory(live_server, tmp_path, monkeypatch): + from typer.testing import CliRunner + + from comfy_cli import desktop_install + from comfy_cli.cmdline import app + + port, script, child = live_server + registry = tmp_path / "registry" + registry.mkdir() + (registry / "installations.json").write_text(json.dumps([{"id": "live", "installPath": str(script.parent.parent)}])) + models = script.parent / "models" / "loras" + models.mkdir(parents=True) + (models / "private_v1.safetensors").write_bytes(b"actual-local") + (script.parent / "input").mkdir() + (script.parent / "output").mkdir() + workflow = tmp_path / "workflow.json" + workflow.write_text( + json.dumps( + { + "nodes": [ + { + "id": 1, + "type": "LoraLoaderModelOnly", + "mode": 0, + "widgets_values": ["private_v1.safetensors", 1.0], + } + ] + } + ) + ) + monkeypatch.setattr(desktop_install, "app_data_dirs", lambda: (registry,)) + monkeypatch.setattr("comfy_cli.tracking.prompt_tracking_consent", lambda *a, **kw: None) + monkeypatch.setattr("comfy_cli.tracking.track_event", lambda *a, **kw: None) + result = CliRunner().invoke( + app, + ["build", "inventory", str(workflow), "--desktop", "--server", f"http://localhost:{port}"], + env={"AI_AGENT": "1", "COMFY_OUTPUT": "json", "NO_COLOR": "1"}, + ) + assert result.exit_code == 0, result.stdout + data = json.loads(result.stdout.splitlines()[-1])["data"] + assert data["desktop"]["install_id"] == "live" + assert data["desktop"]["python"] == sys.executable + assert data["models"][0]["local"][0]["bytes"] == 12 + assert data["input_roots"] == [str(script.parent / "input")] + assert data["desktop"]["output_dir"] == str(script.parent / "output") + assert data["local_server"]["server"] == f"http://localhost:{port}" + assert child.poll() is None + + +def test_body_read_failure_does_not_fall_back_to_another_server(monkeypatch): + class BrokenBody: + def __enter__(self): + return self + + def __exit__(self, *args): + pass + + def read(self, size): + raise TimeoutError("body stalled after HTTP response") + + class OtherServer(BrokenBody): + def read(self, size): + return b"{}" + + monkeypatch.setattr( + socket, + "getaddrinfo", + lambda *a, **kw: [ + (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("127.0.0.1", 8188)), + (socket.AF_INET, socket.SOCK_STREAM, 6, "", ("127.0.0.2", 8188)), + ], + ) + opened = Mock(side_effect=[BrokenBody(), OtherServer()]) + monkeypatch.setattr(identity, "build_http_only_opener", lambda *args: SimpleNamespace(open=opened)) + with pytest.raises(TimeoutError, match="body stalled"): + identity.fetch_json("http://localhost:8188/system_stats") + opened.assert_called_once() + + +def test_listener_reads_fresh_create_time_instead_of_iterator_cache(process, monkeypatch): + cached = SimpleNamespace(pid=123, create_time=lambda: 10.0) + fresh = SimpleNamespace( + pid=123, + cmdline=lambda: process.cmdline, + name=lambda: "python", + net_connections=lambda **kw: [_conn("127.0.0.1")], + cwd=lambda: process.cwd, + create_time=lambda: 20.0, + ) + monkeypatch.setattr(psutil, "process_iter", lambda attrs: [cached]) + constructor = Mock(return_value=fresh) + monkeypatch.setattr(psutil, "Process", constructor) + listener = identity._listener("127.0.0.1", 8188) + assert listener.create_time == 20.0 + constructor.assert_called_once_with(123) + + +@pytest.mark.parametrize( + "cwd,script,reported,expected", + [ + ("D:\\work", "C:main.py", "C:main.py", False), + ("D:\\work", "C:\\work\\main.py", "C:main.py", False), + ("C:\\work", "C:main.py", "C:main.py", True), + ], +) +def test_windows_drive_relative_script_needs_absolute_process_resolution(monkeypatch, cwd, script, reported, expected): + import ntpath + + # Model Windows paths without modifying the host's os.path or touching a + # per-drive filesystem. Cross-drive joins remain relative on Windows. + assert ntpath.isabs(ntpath.join(cwd, script)) == (expected or ntpath.isabs(script)) + monkeypatch.setattr(identity, "os", SimpleNamespace(path=ntpath)) + monkeypatch.setattr(identity, "_is_python_ish", lambda arg: True) + monkeypatch.setattr(identity, "_same_filesystem_namespace", lambda pid: True) + files = Mock(return_value=SimpleNamespace(is_file=lambda: True, samefile=lambda other: True)) + monkeypatch.setattr(identity, "Path", files) + process = Listener(123, ["C:\\Python\\python.exe", script], cwd, "python", "127.0.0.1", 10.0) + stats = {"system": {"argv": [reported], "comfyui_version": "test"}} + + assert identity._verified(stats, process, process) == expected + if expected: + files.assert_called_with("C:\\work\\main.py") + else: + files.assert_not_called() diff --git a/tests/comfy_cli/test_platform_api_key.py b/tests/comfy_cli/test_platform_api_key.py index 64a14f17d..3c6c2b1d8 100644 --- a/tests/comfy_cli/test_platform_api_key.py +++ b/tests/comfy_cli/test_platform_api_key.py @@ -41,7 +41,7 @@ def __call__(self, url, target, **kwargs): def _install(monkeypatch, server: _Server, key: Credential | None, sign_in: str | None = "signed-in-token") -> list: refreshes: list = [] - def sessions(*, refresh=True, force=False, allow_clear=True): + def sessions(*, refresh=True, force=False, allow_clear=True, rejected_access_token=None): if force: refreshes.append(force) return SimpleNamespace(access_token=sign_in, base_url="https://cloud.comfy.org") if sign_in else None @@ -187,7 +187,7 @@ def test_a_refreshed_sign_in_the_builder_still_refuses_names_the_login(monkeypat server = _Server(status=401) refreshed = iter(["refreshed-token"]) - def sessions(*, refresh=True, force=False, allow_clear=True): + def sessions(*, refresh=True, force=False, allow_clear=True, rejected_access_token=None): return SimpleNamespace( access_token=next(refreshed) if force else "signed-in-token", base_url="https://cloud.comfy.org" ) diff --git a/tests/comfy_cli/test_saved_file_identity.py b/tests/comfy_cli/test_saved_file_identity.py new file mode 100644 index 000000000..a40bccc65 --- /dev/null +++ b/tests/comfy_cli/test_saved_file_identity.py @@ -0,0 +1,51 @@ +"""Parity with the frontend's pinned uuid11.1.1 validator and lowercase wire ID.""" + +import json +from pathlib import Path + +import pytest + +from comfy_cli.saved_file_identity import canonical_saved_file_id + + +@pytest.mark.parametrize("version", range(1, 9)) +@pytest.mark.parametrize("variant", "89ab") +def test_rfc_versions_and_variants(version, variant): + identity = f"11111111-1111-{version}111-{variant}111-111111111111" + assert canonical_saved_file_id(identity) == identity + + +@pytest.mark.parametrize("identity", ["00000000-0000-0000-0000-000000000000", "ffffffff-ffff-ffff-ffff-ffffffffffff"]) +def test_frontend_nil_and_max_special_cases(identity): + assert canonical_saved_file_id(identity) == identity + + +@pytest.mark.parametrize( + "identity", + [ + None, + True, + 123, + "", + "a" * 32, + "11111111-1111-0111-8111-111111111111", + "11111111-1111-9111-8111-111111111111", + "11111111-1111-f111-8111-111111111111", + "11111111-1111-4111-7111-111111111111", + "11111111-1111-4111-c111-111111111111", + "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF", + "978E5F58-49DC-4A81-8235-A0B91C204A1C", + " 978e5f58-49dc-4a81-8235-a0b91c204a1c", + "978e5f58-49dc-4a81-8235-a0b91c204a1c\n", + ], +) +def test_malformed_or_noncanonical_received_ids_are_not_advertised(identity): + assert canonical_saved_file_id(identity) is None + + +_CONSUMER = json.loads((Path(__file__).parent / "fixtures/saved_file_uuid_consumer.json").read_text()) + + +@pytest.mark.parametrize("case", _CONSUMER["cases"], ids=lambda case: case["id"]) +def test_matches_actual_pinned_frontend_uuid_consumer(case): + assert (canonical_saved_file_id(case["input"]) is not None) is case["accepted"] diff --git a/tests/comfy_cli/test_session_refresh.py b/tests/comfy_cli/test_session_refresh.py index a0db03ba4..027d285bd 100644 --- a/tests/comfy_cli/test_session_refresh.py +++ b/tests/comfy_cli/test_session_refresh.py @@ -10,12 +10,16 @@ import http.client import io +import os +import threading +import time import urllib.error from types import SimpleNamespace import pytest from comfy_cli.builder_api import BuilderClient +from comfy_cli.credentials import Credential from comfy_cli.deploy_api import DeployAPIError, DeployClient _DEPLOY_URL = "https://deploy.test/deploy" @@ -38,18 +42,27 @@ def __call__(self, url, target, **kwargs): class _Sessions: - """Stands in for the stored sign-in: hands out ``first`` until forced, then ``after``.""" + """Stands in for the stored sign-in: hands out ``first`` until forced, then ``after``. + + A forced refresh that yields no token clears the store, as a fatal refresh does. + """ def __init__(self, first: str, after: str | None) -> None: self.first = first self.after = after self.forced = 0 + self.cleared = False - def __call__(self, *, refresh=True, force=False, allow_clear=True): + def __call__(self, *, refresh=True, force=False, allow_clear=True, rejected_access_token=None): if force: self.forced += 1 - return SimpleNamespace(access_token=self.after, base_url="https://cloud.comfy.org") if self.after else None - return SimpleNamespace(access_token=self.first, base_url="https://cloud.comfy.org") + if self.after is None: + self.cleared = allow_clear + return None + return SimpleNamespace(access_token=self.after, refresh_token="rt", base_url="https://cloud.comfy.org") + if self.cleared: + return None + return SimpleNamespace(access_token=self.first, refresh_token="rt", base_url="https://cloud.comfy.org") def _install(monkeypatch, server: _Server, sessions: _Sessions) -> None: @@ -75,6 +88,63 @@ def _install(monkeypatch, server: _Server, sessions: _Sessions) -> None: } +@pytest.mark.parametrize("lagging", ["builder", "deploy"]) +def test_overlapping_clients_reuse_the_peer_refresh_before_retrying(monkeypatch, tmp_path, lagging) -> None: + """A late 401 for OLD must not rotate the NEW token a peer just obtained.""" + from comfy_cli.auth import store + from comfy_cli.cloud import oauth + + monkeypatch.setattr(store, "secrets_path", lambda: tmp_path / "secrets.json") + store.save_cloud_session( + base_url="https://cloud.comfy.org", + resource="https://cloud.comfy.org/api", + client_id="cli", + scope="s", + access_token="OLD", + refresh_token="RT0", + token_type="Bearer", + expires_at=int(time.time()) + 3600, + ) + refreshes = [] + + def refresh(**kwargs): + refreshes.append(kwargs["refresh_token"]) + generation = len(refreshes) + return oauth.TokenSet( + access_token=f"NEW{generation}", + refresh_token=f"RT{generation}", + token_type="Bearer", + expires_in=3600, + expires_at=int(time.time()) + 3600, + scope="s", + ) + + monkeypatch.setattr(oauth, "refresh_tokens", refresh) + clients = {"builder": BuilderClient.from_session(_BUILDER_URL), "deploy": DeployClient.from_session(_DEPLOY_URL)} + peer = "deploy" if lagging == "builder" else "builder" + calls = { + "builder": lambda: clients["builder"].get_release("r1"), + "deploy": lambda: clients["deploy"].get_deployment("dep-1"), + } + requests = [] + + def send(url, target, **kwargs): + name = "builder" if url.startswith(_BUILDER_URL) else "deploy" + requests.append((name, target.auth_token)) + if target.auth_token == "OLD": + if name == lagging: + calls[peer]() # Peer finishes its refresh while this stale request is in flight. + raise urllib.error.HTTPError(url, 401, "expired", http.client.HTTPMessage(), io.BytesIO(b"{}")) + return 200, dict(_ANSWER) + + monkeypatch.setattr("comfy_cli.builder_api.request_json", send) + monkeypatch.setattr("comfy_cli.deploy_api.request_json", send) + + assert calls[lagging]()["status"] == "ready" + assert refreshes == ["RT0"] + assert requests == [(lagging, "OLD"), (peer, "OLD"), (peer, "NEW1"), (lagging, "NEW1")] + + @pytest.mark.parametrize("call", _DEPLOY_CALLS.values(), ids=_DEPLOY_CALLS.keys()) def test_deploy_client_retries_once_with_a_refreshed_token_after_a_401(monkeypatch, call) -> None: # Given @@ -260,3 +330,348 @@ def test_a_refused_injected_token_says_to_replace_it_not_to_sign_in(monkeypatch) assert "COMFY_BUILDER_TOKEN" in envelope["error"]["hint"] assert "comfy cloud login" not in envelope["error"]["hint"] assert server.tokens == ["injected"] + + +# --- A 401 that outlives the refresh during a watch ----------------------------- +# +# Several commands polling at once can each be refused after the shared refresh: +# a peer can hold the refresh lock past this process's timeout, and then this one +# retries nothing. The build or deployment was accepted with the same sign-in a +# moment earlier and runs on, so while that sign-in is still stored, signing in +# again is not the fix. A 401 before anything was submitted keeps its sign-in code. + + +class _AnswersTheCut(_Server): + """Answers the cut whatever token it carries, then refuses every read the watch makes.""" + + def __call__(self, url, target, **kwargs): + if kwargs.get("method") == "POST": + self.tokens.append(target.auth_token) + return 200, dict(_ANSWER) + return super().__call__(url, target, **kwargs) + + +def _watched_cut(monkeypatch, server: _Server, sessions: _Sessions): + import json + + from typer.testing import CliRunner + + from comfy_cli.cmdline import app + + _install(monkeypatch, server, sessions) + monkeypatch.delenv("COMFY_BUILDER_TOKEN", raising=False) + monkeypatch.delenv("COMFY_CLOUD_API_KEY", raising=False) + result = CliRunner().invoke( + app, + ["--json", "build", "release", "create", "--id", "b1", "--target", "linux/nvidia", "--watch"], + env={"COMFY_BUILDER_URL": _BUILDER_URL}, + ) + envelope = json.loads([line for line in result.stdout.splitlines() if line.strip()][-1]) + return result, envelope["error"] + + +def test_a_release_watch_refused_after_the_refresh_says_the_release_keeps_building(monkeypatch) -> None: + # Given a cut the builder accepts, then a watch it refuses even after the refresh + server = _AnswersTheCut(valid=set()) + sessions = _Sessions(first="signed-in", after="refreshed") + + # When + result, error = _watched_cut(monkeypatch, server, sessions) + + # Then only the watch ended: its own code and exit status, and no sign-in prompt + assert result.exit_code == 75 + assert error["code"] == "watch_auth_lost" + assert "may still be building" in error["message"] + assert "comfy build release show r1" in error["hint"] + assert "comfy cloud login" not in error["hint"] + assert error["details"] == {"releaseId": "r1"} + assert server.tokens == ["signed-in", "signed-in", "refreshed"] + assert sessions.forced == 1 + + +@pytest.mark.parametrize("misses", [1, 4]) +@pytest.mark.parametrize("refreshed", ["refreshed", None], ids=["sign-in-retained", "signed-out"]) +@pytest.mark.parametrize("later_poll", [False, True], ids=["initial-poll", "later-poll"]) +def test_a_release_watch_transport_retry_preserves_the_following_auth_refusal( + monkeypatch, misses, refreshed, later_poll +) -> None: + from comfy_cli.command import build + + class TimeoutThenRefuse(_AnswersTheCut): + remaining = misses + pending_building = later_poll + + def __call__(self, url, target, **kwargs): + if kwargs.get("method") != "POST" and self.pending_building: + self.pending_building = False + return 200, {"id": "r1", "status": "building"} + if kwargs.get("method") != "POST" and self.remaining: + self.remaining -= 1 + raise TimeoutError("timed out") + return super().__call__(url, target, **kwargs) + + server = TimeoutThenRefuse(valid=set()) + sessions = _Sessions(first="signed-in", after=refreshed) + sleeps = [] + monkeypatch.setattr(build.time, "sleep", sleeps.append) + + result, error = _watched_cut(monkeypatch, server, sessions) + + assert result.exit_code == (75 if refreshed else 1), result.output + assert error["code"] == ("watch_auth_lost" if refreshed else "build_not_signed_in") + assert sleeps == ([build._RELEASE_POLL_SECONDS] if later_poll else []) + [4.0, 8.0, 16.0, 30.0][:misses] + assert server.tokens == (["signed-in", "signed-in", "refreshed"] if refreshed else ["signed-in", "signed-in"]) + assert sessions.forced == 1 + assert sessions.cleared is (refreshed is None) + assert server.remaining == 0 + if refreshed: + assert error["details"] == {"releaseId": "r1"} + assert "may still be building" in error["message"] + assert "comfy build release show r1" in error["hint"] + assert "comfy cloud login" not in error["hint"] + + +def test_a_release_watch_whose_refresh_signed_the_user_out_still_says_to_sign_in(monkeypatch) -> None: + # Given a watch refused, and a refresh that cleared the sign-in + server = _AnswersTheCut(valid=set()) + sessions = _Sessions(first="signed-in", after=None) + + # When + result, error = _watched_cut(monkeypatch, server, sessions) + + # Then nobody is signed in any more, so signing in is the move + assert result.exit_code == 1 + assert error["code"] == "build_not_signed_in" + assert "comfy cloud login" in error["hint"] + + +def test_a_cut_refused_before_anything_was_made_keeps_the_sign_in_code(monkeypatch) -> None: + # Given a builder that refuses the cut itself, with the sign-in still stored + server = _Server(valid=set()) + sessions = _Sessions(first="signed-in", after="refreshed") + + # When + result, error = _watched_cut(monkeypatch, server, sessions) + + # Then nothing is running, so the refusal is the sign-in's + assert result.exit_code == 1 + assert error["code"] == "build_not_signed_in" + assert server.tokens == ["signed-in", "refreshed"] + + +def test_a_deploy_watch_refused_after_the_refresh_ends_the_watch_not_the_deployment(monkeypatch) -> None: + # Given + from comfy_cli.command.deploy_runtime import DeployWatchAuthLostError, poll_deployment + + server = _Server(valid=set()) + sessions = _Sessions(first="signed-in", after="refreshed") + _install(monkeypatch, server, sessions) + sleeps: list[float] = [] + + # When + with pytest.raises(DeployWatchAuthLostError) as exc_info: + poll_deployment(DeployClient.from_session(_DEPLOY_URL), "dep-1", sleeps.append) + + # Then the read was refused after one refresh and one retry, and never retried again + assert exc_info.value.deployment_id == "dep-1" + assert exc_info.value.code == "watch_auth_lost" + assert server.tokens == ["signed-in", "refreshed"] + assert sleeps == [] + + +def test_a_watch_with_an_unrefreshable_stored_token_requires_sign_in(monkeypatch) -> None: + from comfy_cli.command.deploy_runtime import poll_deployment + + # A token without a refresh token can remain on disk after its lifetime ends. + session = SimpleNamespace(access_token="expired", refresh_token=None, base_url="https://cloud.comfy.org") + monkeypatch.setattr("comfy_cli.credentials.get_session", lambda **_: session) + monkeypatch.setattr("comfy_cli.deploy_api.request_json", _Server(valid=set())) + + with pytest.raises(DeployAPIError) as exc_info: + poll_deployment(DeployClient.from_session(_DEPLOY_URL), "dep-1", lambda _: None) + + assert exc_info.value.code == "deploy_not_signed_in" + + +class _SignedInElsewhere(_Sessions): + """A sign-in to another environment, stored while the watch ran.""" + + def __call__(self, *, refresh=True, force=False, allow_clear=True, rejected_access_token=None): + session = super().__call__(refresh=refresh, force=force, allow_clear=allow_clear) + if self.forced and not force: + return SimpleNamespace(access_token=self.after, refresh_token="rt", base_url="https://staging.comfy.test") + return session + + +@pytest.mark.parametrize( + "sessions", + [_Sessions(first="signed-in", after=None), _SignedInElsewhere(first="signed-in", after="staging")], + ids=["refresh_signed_the_user_out", "signed_in_to_another_environment"], +) +def test_a_deploy_watch_with_no_sign_in_left_to_keep_says_to_sign_in(monkeypatch, sessions) -> None: + # Given + from comfy_cli.command.deploy_runtime import poll_deployment + + _install(monkeypatch, _Server(valid=set()), sessions) + + # When + with pytest.raises(DeployAPIError) as exc_info: + poll_deployment(DeployClient.from_session(_DEPLOY_URL), "dep-1", lambda _: None) + + # Then + assert exc_info.value.code == "deploy_not_signed_in" + + +@pytest.mark.parametrize( + "build", + [ + lambda: DeployClient(_DEPLOY_URL, "injected"), + lambda: DeployClient( + _DEPLOY_URL, api_key=Credential(kind="api_key", value="k", source="env:COMFY_CLOUD_API_KEY") + ), + ], + ids=["handed_token", "workspace_key"], +) +def test_a_deploy_watch_on_a_credential_it_cannot_refresh_keeps_the_sign_in_code(monkeypatch, build) -> None: + # Given a sign-in stored beside a client that was never built from it + from comfy_cli.command.deploy_runtime import poll_deployment + + server = _Server(valid=set()) + _install(monkeypatch, server, _Sessions(first="signed-in", after="refreshed")) + + # When + with pytest.raises(DeployAPIError) as exc_info: + poll_deployment(build(), "dep-1", lambda _: None) + + # Then the credential the client sent is the one to replace + assert exc_info.value.code == "deploy_not_signed_in" + + +@pytest.fixture +def peer_takes_refresh_lock_after_first_read(monkeypatch, tmp_path): + """Own a real secrets lock; compress only its contended acquisition attempts.""" + from comfy_cli import locking + from comfy_cli.auth import store + from comfy_cli.cloud import oauth + + monkeypatch.setenv("COMFY_SECRETS_PATH", str(tmp_path / "secrets.json")) + store.save_cloud_session( + base_url="https://cloud.comfy.org", + resource="https://cloud.comfy.org/api", + client_id="cli", + scope="s", + access_token="signed-in", + refresh_token="RT0", + token_type="Bearer", + expires_at=4102444800, + ) + initial = store.secrets_path().read_bytes() + state = SimpleNamespace(armed=False, started=False, contended=False, timeouts=[], errors=[]) + held, release = threading.Event(), threading.Event() + real_acquire, real_read = locking._acquire, store.get_cloud_session + lock_stat = store.lock_path().stat() + + def peer(): + try: + with locking.file_lock(store.lock_path(), timeout=0): + state.contended = True + held.set() + if not release.wait(5): + raise AssertionError("test did not release its owned secrets lock") + state.contended = False + except BaseException as error: + state.errors.append(error) + held.set() + + owner = threading.Thread(target=peer) + + def acquire(fd, *, timeout): + info = os.fstat(fd) + owns_path = (info.st_dev, info.st_ino) == (lock_stat.st_dev, lock_stat.st_ino) + if owns_path and state.contended: + state.timeouts.append(timeout) + if timeout is None: + pytest.fail("unbounded secrets read after the refresh lock timed out") + # Exercise the actual contended OS lock without waiting out the + # production refresh budget. Classification already requests zero. + return real_acquire(fd, timeout=0) + return real_acquire(fd, timeout=timeout) + + def read(): + session = real_read() + if state.armed and not state.started: + state.started = True + owner.start() + assert held.wait(5), "test peer never acquired its secrets lock" + assert not state.errors + return session + + monkeypatch.setattr(locking, "_acquire", acquire) + monkeypatch.setattr(store, "get_cloud_session", read) + monkeypatch.setattr(oauth, "refresh_tokens", lambda **_: pytest.fail("must not refresh outside the held lock")) + + def release_peer(): + release.set() + if owner.ident is not None: + # Acquisition was nonblocking; the only possible wait is our own + # event, released above even when a regression assertion fails. + owner.join() + assert not state.errors + + state.release_peer = release_peer + try: + yield state + finally: + release_peer() + assert store.secrets_path().read_bytes() == initial + + +@pytest.mark.parametrize("kind", ["builder", "deploy"]) +def test_a_watch_does_not_wait_again_when_a_peer_outlives_the_refresh_lock( + monkeypatch, capsys, peer_takes_refresh_lock_after_first_read, kind +): + import json + + import typer + + from comfy_cli import credentials + from comfy_cli.caller import Caller + from comfy_cli.command.build import _watched_release + from comfy_cli.command.deploy_runtime import DeployWatchAuthLostError, exit_watch_lost, poll_deployment + from comfy_cli.output.renderer import Renderer + + state = peer_takes_refresh_lock_after_first_read + client = BuilderClient.from_session(_BUILDER_URL) if kind == "builder" else DeployClient.from_session(_DEPLOY_URL) + requests = [] + + def refused(url, target, **kwargs): + requests.append(target.auth_token) + state.armed = True + raise urllib.error.HTTPError(url, 401, "refused", http.client.HTTPMessage(), io.BytesIO(b"{}")) + + monkeypatch.setattr("comfy_cli.builder_api.request_json", refused) + monkeypatch.setattr("comfy_cli.deploy_api.request_json", refused) + renderer = Renderer.resolve( + is_stdout_tty=False, env={}, caller=Caller(kind="user", agentic=False, source_env=None), json_flag=True + ) + with pytest.raises(typer.Exit) as stopped: + if kind == "builder": + _watched_release(renderer, client, "r1") + else: + try: + poll_deployment(client, "dep-1", lambda _: pytest.fail("must not sleep after the refused read")) + except DeployWatchAuthLostError as error: + exit_watch_lost(renderer, error) + + envelope = json.loads(capsys.readouterr().out.strip().splitlines()[-1]) + assert stopped.value.exit_code == 75 + assert envelope["error"]["code"] == "watch_auth_lost" + assert "comfy cloud login" not in envelope["error"]["hint"] + assert requests == ["signed-in"] + assert state.timeouts == [90.0, 0] + assert state.started is True + + # With the same real store readable again, the nested lock is reentrant. + state.release_peer() + assert credentials.sign_in_still_stored("https://cloud.comfy.org") is True + assert credentials.sign_in_still_stored(None) is False diff --git a/tests/comfy_cli/test_subprocess_credential_isolation.py b/tests/comfy_cli/test_subprocess_credential_isolation.py new file mode 100644 index 000000000..92f462e6f --- /dev/null +++ b/tests/comfy_cli/test_subprocess_credential_isolation.py @@ -0,0 +1,19 @@ +"""CLI subprocess tests must inherit their own test store, never a user's store.""" + +import os +import subprocess +import sys + +from comfy_cli.auth.store import secrets_path + + +def test_cli_subprocess_inherits_the_per_test_credential_destination(): + expected = str(secrets_path()) + child = subprocess.run( + [sys.executable, "-c", "from comfy_cli.auth.store import secrets_path; print(secrets_path())"], + env=dict(os.environ), + text=True, + capture_output=True, + check=True, + ) + assert child.stdout.strip() == expected diff --git a/tests/comfy_cli/test_which_desktop.py b/tests/comfy_cli/test_which_desktop.py new file mode 100644 index 000000000..24a24ee59 --- /dev/null +++ b/tests/comfy_cli/test_which_desktop.py @@ -0,0 +1,304 @@ +"""`comfy which` / `comfy env` on a machine where the workspace is missing or is Comfy Desktop's. + +The default workspace comfy-cli falls back to (``~/Documents/comfy/ComfyUI``) +does not exist on a Desktop-only machine. These commands used to report it with +``ok: true``; now a missing path is an error (`which`) or a flagged warning +(`env`), and a Desktop 2 install is reported with its real split layout. +""" + +from __future__ import annotations + +import json +from dataclasses import replace +from pathlib import Path + +import jsonschema +import pytest +from typer.testing import CliRunner + +from comfy_cli import desktop_install, utils +from comfy_cli.cmdline import app, workspace_manager +from comfy_cli.env_checker import EnvChecker + +SCHEMAS_DIR = Path(__file__).resolve().parents[2] / "comfy_cli" / "schemas" + + +def _schema(name: str) -> dict: + return json.loads((SCHEMAS_DIR / name).read_text()) + + +@pytest.fixture +def fallback_workspace(tmp_path, monkeypatch) -> Path: + """comfy-cli's own default workspace, pointed into tmp and not created. + + The cwd is moved to an empty dir so the cwd auto-detect step finds nothing. + """ + fallback = tmp_path / "Documents" / "comfy" / "ComfyUI" + monkeypatch.setattr(utils, "get_not_user_set_default_workspace", lambda: str(fallback)) + elsewhere = tmp_path / "elsewhere" + elsewhere.mkdir() + monkeypatch.chdir(elsewhere) + return fallback + + +def _invoke(*args: str): + result = CliRunner().invoke(app, list(args)) + lines = [line for line in result.stdout.splitlines() if line.strip()] + envelope = json.loads(lines[-1]) if lines and lines[-1].startswith("{") else None + return result, envelope + + +def test_which_keeps_missing_selected_workspace_separate_from_desktop_candidate(comfy_desktop, fallback_workspace): + result, envelope = _invoke("--json", "which") + + assert result.exit_code == 1, result.output + assert envelope["ok"] is False + assert envelope["error"]["code"] == "workspace_not_found" + details = envelope["error"]["details"] + assert details["workspace_type"] == workspace_manager.workspace_type.value == "default" + assert details["path"] == workspace_manager.workspace_path == str(fallback_workspace) + assert not Path(workspace_manager.workspace_path).is_dir() + desktop = details["desktop"] + assert desktop["code_dir"] == str(comfy_desktop["code"]) + assert desktop["data_dir"] == str(comfy_desktop["data"]) + assert desktop["python"] == str(comfy_desktop["python"]) + assert desktop["comfyui_version"] == "v0.34.2" + assert [root["path"] for root in desktop["model_roots"]] == [ + str(comfy_desktop["data"] / "models"), + str(comfy_desktop["shared"]), + ] + assert desktop["selected_reason"] + assert [row["install_id"] for row in desktop["installs"]] == ["inst-adopted"] + + +def test_which_lists_every_desktop_install_and_says_which_it_picked(comfy_desktop, fallback_workspace, tmp_path): + other = tmp_path / "ComfyUI-Installs" / "Test" + (other / "ComfyUI").mkdir(parents=True) + (other / "ComfyUI" / "main.py").write_text("") + records = [ + {"id": "inst-test", "name": "Test", "installPath": str(other), "lastLaunchedAt": 1_700_000_000_000}, + comfy_desktop["record"], + ] + (comfy_desktop["app"] / "installations.json").write_text(json.dumps(records)) + + _, envelope = _invoke("--json", "which") + + desktop = envelope["error"]["details"]["desktop"] + assert desktop["install_id"] == "inst-adopted" + assert "most recently launched of 2" in desktop["selected_reason"] + assert {row["install_id"]: row["selected"] for row in desktop["installs"]} == { + "inst-test": False, + "inst-adopted": True, + } + + +def test_which_errors_when_the_default_workspace_does_not_exist(fallback_workspace): + result, envelope = _invoke("--json", "which") + + assert result.exit_code == 1 + assert envelope["ok"] is False + assert envelope["error"]["code"] == "workspace_not_found" + assert envelope["error"]["details"]["path"] == str(fallback_workspace) + assert envelope["error"]["details"]["workspace_type"] == "default" + assert envelope["error"]["hint"] + + +def test_which_errors_for_a_missing_specified_workspace_even_with_desktop_installed( + comfy_desktop, fallback_workspace, tmp_path +): + missing = tmp_path / "typo" / "ComfyUI" + + result, envelope = _invoke("--json", "--workspace", str(missing), "which") + + assert result.exit_code == 1 + assert envelope["error"]["code"] == "workspace_not_found" + assert envelope["error"]["details"]["path"] == str(missing) + assert envelope["error"]["details"]["workspace_type"] == "specified" + + +def test_which_keeps_an_installed_default_workspace_over_desktop(comfy_desktop, fallback_workspace): + fallback_workspace.mkdir(parents=True) + + result, envelope = _invoke("--json", "which") + + assert result.exit_code == 0, result.output + assert envelope["data"]["workspace_path"] == str(fallback_workspace) + assert envelope["data"]["workspace_type"] == "default" + assert envelope["data"]["exists"] is True + assert "desktop" not in envelope["data"] + + +def test_which_names_unreadable_desktop_records_in_the_error(comfy_desktop, fallback_workspace): + (comfy_desktop["app"] / "installations.json").write_text("{not json") + + result, envelope = _invoke("--json", "which") + + assert result.exit_code == 1 + assert envelope["error"]["code"] == "workspace_not_found" + problems = envelope["error"]["details"]["desktop"]["problems"] + assert len(problems) == 1 + assert "installations.json" in problems[0] + + +def test_which_warns_when_desktop_settings_are_unreadable(comfy_desktop, fallback_workspace): + (comfy_desktop["app"] / "settings.json").write_text("[broken") + + result, envelope = _invoke("--json", "which") + + assert result.exit_code == 1, result.output + assert envelope["error"]["code"] == "workspace_not_found" + desktop = envelope["error"]["details"]["desktop"] + assert any("settings.json" in problem for problem in desktop["problems"]) + + +def test_pretty_which_shows_the_desktop_data_dir(comfy_desktop, fallback_workspace): + result = CliRunner().invoke( + app, + ["--workspace", str(comfy_desktop["code"]), "which"], + env={"COMFY_OUTPUT": "pretty", "COLUMNS": "400"}, + ) + + assert result.exit_code == 0, result.output + assert str(comfy_desktop["data"]) in result.output + assert "Desktop data" in result.output + assert "specified" in result.output + + +def test_env_reports_the_desktop_install(comfy_desktop, fallback_workspace): + result, envelope = _invoke("--json", "env") + + assert result.exit_code == 0, result.output + data = envelope["data"] + jsonschema.validate(data, _schema("env.json")) + workspace = data["workspace"] + assert workspace["type"] == workspace_manager.workspace_type.value == "default" + assert workspace["path"] == workspace_manager.workspace_path == str(fallback_workspace) + assert workspace["exists"] is False + assert workspace["desktop"]["data_dir"] == str(comfy_desktop["data"]) + assert [w["code"] for w in data["warnings"]] == ["workspace_not_found"] + + +def test_env_flags_a_missing_workspace_instead_of_a_silent_default(fallback_workspace): + result, envelope = _invoke("--json", "env") + + assert result.exit_code == 0, result.output + data = envelope["data"] + jsonschema.validate(data, _schema("env.json")) + assert data["workspace"]["path"] == str(fallback_workspace) + assert data["workspace"]["exists"] is False + assert [w["code"] for w in data["warnings"]] == ["workspace_not_found"] + assert str(fallback_workspace) in data["warnings"][0]["message"] + + +@pytest.mark.parametrize("part", ["code", "data"]) +def test_which_enriches_an_explicit_desktop_workspace(comfy_desktop, fallback_workspace, part): + result, envelope = _invoke("--json", "--workspace", str(comfy_desktop[part]), "which") + + assert result.exit_code == 0, result.output + jsonschema.validate(envelope["data"], _schema("which.json")) + assert envelope["data"]["workspace_type"] == "specified" + assert envelope["data"]["workspace_path"] == str(comfy_desktop[part]) + assert envelope["data"]["desktop"]["data_dir"] == str(comfy_desktop["data"]) + assert envelope["data"]["desktop"]["code_dir"] == str(comfy_desktop["code"]) + + +def test_env_warns_when_desktop_settings_are_unreadable(comfy_desktop, fallback_workspace): + (comfy_desktop["app"] / "settings.json").write_text("[broken") + + result, envelope = _invoke("--json", "env") + + assert result.exit_code == 0, result.output + assert [w["code"] for w in envelope["data"]["warnings"]] == ["workspace_not_found", "desktop_config_unreadable"] + + +def test_env_renders_hostile_discovery_values_literally_without_changing_json( + comfy_desktop, fallback_workspace, monkeypatch +): + raw = "[/]literal[red]x[/red]\x1b[2J\x1b]0;osc-title\x07\x9b2J\r\u202e世界" + visible = "[/]literal[red]x[/red]\u202e世界" + selected_path = str(fallback_workspace.parent / raw) + monkeypatch.setattr(utils, "get_not_user_set_default_workspace", lambda: selected_path) + found = desktop_install.detect() + candidate = replace( + found.selected, + code_dir=f"code:{raw}", + data_dir=f"data:{raw}", + model_roots=(desktop_install.ModelRoot(f"model:{raw}", "data", True),), + ) + found = replace(found, installs=(candidate,), selected=candidate, problems=(f"warning:{raw}",)) + monkeypatch.setattr(desktop_install, "detect", lambda: found) + monkeypatch.setattr(EnvChecker(), "fill_print_table", lambda: []) + + json_result, envelope = _invoke("--json", "env") + assert json_result.exit_code == 0, json_result.output + workspace = envelope["data"]["workspace"] + assert workspace["path"] == selected_path + assert workspace["desktop"]["code_dir"] == f"code:{raw}" + assert workspace["desktop"]["data_dir"] == f"data:{raw}" + assert workspace["desktop"]["model_roots"][0]["path"] == f"model:{raw}" + assert any(warning["message"] == f"warning:{raw}" for warning in envelope["data"]["warnings"]) + + result = CliRunner().invoke(app, ["env"], env={"COMFY_OUTPUT": "pretty", "COLUMNS": "600", "NO_COLOR": "1"}) + + assert result.exit_code == 0, result.output + assert str(fallback_workspace.parent / visible) in result.output + assert f"code:{visible}" in result.output + assert f"data:{visible}" in result.output + assert f"model:{visible}" in result.output + assert f"warning:{visible}" in result.output + assert "\x1b" not in result.output and "\x9b" not in result.output + assert "\x07" not in result.output and "\r" not in result.output + assert "osc-title" not in result.output + assert "\u202e世界" in result.output + + +def test_which_renders_hostile_desktop_fields_literally_without_changing_json( + comfy_desktop, fallback_workspace, monkeypatch +): + raw = "[/]literal[red]x[/red]\x1b[2J\x1b]0;osc-title\x07\x9b2J\r\u202e世界" + visible = "[/]literal[red]x[/red]\u202e世界" + code = fallback_workspace.parent / "selected-comfy" + desktop_code = fallback_workspace.parent / f"code:{raw}" + code.mkdir(parents=True) + (code / "main.py").write_text("") + found = desktop_install.detect() + candidate = replace( + found.selected, + code_dir=str(desktop_code), + data_dir=f"data:{raw}", + python=f"python:{raw}", + model_roots=(desktop_install.ModelRoot(f"model:{raw}", "data", True),), + ) + found = replace( + found, installs=(candidate,), selected=candidate, selected_reason=f"reason:{raw}", problems=(f"warning:{raw}",) + ) + monkeypatch.setattr(desktop_install, "detect", lambda: found) + monkeypatch.setattr(desktop_install, "install_for_dir", lambda path, detected: {str(code): candidate}.get(path)) + monkeypatch.setattr("comfy_cli.cmdline.env_checker.check_comfy_server_running", lambda **kwargs: False) + + json_result, envelope = _invoke("--json", "--workspace", str(code), "which") + assert json_result.exit_code == 0, json_result.output + data = envelope["data"] + assert data["workspace_path"] == str(code) + assert data["desktop"]["code_dir"] == str(desktop_code) + assert data["desktop"]["data_dir"] == f"data:{raw}" + assert data["desktop"]["python"] == f"python:{raw}" + assert data["desktop"]["model_roots"][0]["path"] == f"model:{raw}" + assert data["desktop"]["selected_reason"] == f"reason:{raw}" + assert data["warnings"][0]["message"] == f"warning:{raw}" + + result = CliRunner().invoke( + app, ["--workspace", str(code), "which"], env={"COMFY_OUTPUT": "pretty", "COLUMNS": "600", "NO_COLOR": "1"} + ) + + assert result.exit_code == 0, result.output + assert str(fallback_workspace.parent / f"code:{visible}") in result.output + assert f"data:{visible}" in result.output + assert f"python:{visible}" in result.output + assert f"model:{visible}" in result.output + assert f"reason:{visible}" in result.output + assert f"warning:{visible}" in result.output + assert "\x1b" not in result.output and "\x9b" not in result.output + assert "\x07" not in result.output and "\r" not in result.output + assert "osc-title" not in result.output + assert "\u202e世界" in result.output diff --git a/tests/comfy_cli/test_workflow_inventory.py b/tests/comfy_cli/test_workflow_inventory.py new file mode 100644 index 000000000..24fbb79dc --- /dev/null +++ b/tests/comfy_cli/test_workflow_inventory.py @@ -0,0 +1,315 @@ +from __future__ import annotations + +import hashlib +from pathlib import Path + +from comfy_cli.workflow_inventory import inventory, join_cloud, join_inputs, join_local, join_server + + +def _node(node_id, class_type, widgets=(), *, mode=0, **properties): + return {"id": node_id, "type": class_type, "mode": mode, "widgets_values": list(widgets), "properties": properties} + + +def _workflow(): + return { + "nodes": [ + _node(1, "CheckpointLoaderSimple", ["sdxl\\base_v1.safetensors"], cnr_id="comfy-core", ver="0.3.60"), + _node(2, "LoraLoaderModelOnly", ["studio/hero_v5.safetensors", 0.8], cnr_id="comfy-core"), + _node(3, "CLIPTextEncode", ["a portrait, embedding:EasyNegative, sharp"], cnr_id="comfy-core"), + _node(4, "LoadImage", ["face.png", "image"], cnr_id="comfy-core"), + _node(5, "UpscaleModelLoader", ["4x_unused.pth"], mode=4, cnr_id="comfy-core"), + _node(6, "IPAdapterUnifiedLoader", ["PLUS (high strength)"], cnr_id="comfyui_ipadapter_plus", ver="2.0.0"), + _node(7, "Note", ["remember to swap the LoRA"]), + _node(8, "aaaaaaaa-0000-0000-0000-000000000001", []), + _node( + 9, + "VAELoader", + ["sdxl_vae.safetensors"], + cnr_id="comfy-core", + models=[{"name": "sdxl_vae.safetensors", "directory": "vae", "url": "https://example.test/vae"}], + ), + ], + "definitions": { + "subgraphs": [ + { + "id": "aaaaaaaa-0000-0000-0000-000000000001", + "nodes": [_node(20, "UltimateSDUpscale", [2, 42], cnr_id="comfyui_ultimatesdupscale", ver="1.6.0")], + } + ] + }, + "extra": {"node_versions": {"comfy-core": "0.3.60"}}, + } + + +def test_inventory_scopes_to_active_nodes_and_keeps_subfolders(): + report = inventory(_workflow()) + + assert report["format"] == "ui" + assert set(report["classes"]) == { + "CheckpointLoaderSimple", + "LoraLoaderModelOnly", + "CLIPTextEncode", + "LoadImage", + "IPAdapterUnifiedLoader", + "VAELoader", + "UltimateSDUpscale", + } + assert report["classes"]["IPAdapterUnifiedLoader"] == { + "count": 1, + "pack": "comfyui_ipadapter_plus", + "ver": ["2.0.0"], + } + paths = [m["path"] for m in report["models"]] + assert paths == ["sdxl/base_v1.safetensors", "studio/hero_v5.safetensors", "sdxl_vae.safetensors"] + assert report["models"][0]["subfolder"] == "sdxl" + assert any("Windows path" in w for w in report["warnings"]) + assert report["embeddings"] == [{"name": "EasyNegative", "node": "CLIPTextEncode", "node_id": 3}] + assert report["inputs"] == [{"file": "face.png", "node": "LoadImage", "node_id": 4}] + assert report["skipped"] == [ + {"id": 5, "class": "UpscaleModelLoader", "why": "bypassed", "models": ["4x_unused.pth"]} + ] + assert [i["class"] for i in report["implicit"]] == ["IPAdapterUnifiedLoader"] + assert report["node_versions"] == {"comfy-core": "0.3.60"} + assert report["packs"]["comfyui_ultimatesdupscale"] == ["UltimateSDUpscale"] + + +def test_inventory_reads_api_exports(): + api = { + "1": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "base.safetensors"}}, + "2": {"class_type": "KSampler", "inputs": {"model": ["1", 0], "seed": 1}}, + } + report = inventory(api) + + assert report["format"] == "api" + assert set(report["classes"]) == {"CheckpointLoaderSimple", "KSampler"} + assert [m["path"] for m in report["models"]] == ["base.safetensors"] + + +def test_join_local_matches_by_basename_across_roots(tmp_path: Path): + first = tmp_path / "models" + shared = tmp_path / "shared" + (first / "checkpoints" / "sdxl").mkdir(parents=True) + (shared / "loras").mkdir(parents=True) + (first / "checkpoints" / "sdxl" / "base_v1.safetensors").write_bytes(b"BASE") + (shared / "loras" / "hero_v5.safetensors").write_bytes(b"HERO") + report = inventory(_workflow()) + + join_local(report, [str(first), str(shared)], hash_files=True) + + base, lora, vae = report["models"] + assert base["local"][0]["rel"] == "checkpoints/sdxl/base_v1.safetensors" + assert base["local"][0]["type_dir"] == "checkpoints" + assert base["local"][0]["sha256"] == hashlib.sha256(b"BASE").hexdigest() + assert lora["local"][0]["root"] == str(shared) + assert vae["local"] == [] + assert report["models_not_on_disk"] == ["sdxl_vae.safetensors"] + + +def test_join_server_maps_classes_to_local_pack_dirs(): + report = inventory(_workflow()) + object_info = { + "CheckpointLoaderSimple": {"python_module": "nodes"}, + "UltimateSDUpscale": {"python_module": "custom_nodes.ComfyUI_UltimateSDUpscale"}, + } + + section = join_server(report, object_info, {"system": {"comfyui_version": "0.3.60"}}) + + assert section["comfyui_version"] == "0.3.60" + assert section["classes_by_local_pack_dir"] == { + "core": ["CheckpointLoaderSimple"], + "ComfyUI_UltimateSDUpscale": ["UltimateSDUpscale"], + } + assert "IPAdapterUnifiedLoader" in section["classes_missing_locally"] + + +def _catalog(**nodes): + return lambda class_type: nodes.get(class_type) + + +def _combo(name, *choices, cloud_disabled=False): + return {"inputs": [{"name": name, "choices": list(choices)}], "cloud_disabled": cloud_disabled} + + +def test_join_cloud_finds_remaps_and_blockers(): + report = inventory(_workflow()) + lookup = _catalog( + CheckpointLoaderSimple=_combo("ckpt_name", "base_v1.safetensors", "other.safetensors"), + LoraLoaderModelOnly=_combo("lora_name", "public.safetensors"), + CLIPTextEncode={"inputs": []}, + LoadImage=_combo("image", "example.png"), + VAELoader=_combo("vae_name", "sdxl_vae.safetensors"), + UltimateSDUpscale={"inputs": []}, + IPAdapterUnifiedLoader=_combo("preset", "PLUS (high strength)", cloud_disabled=True), + ) + + cloud = join_cloud(report, lookup) + + statuses = {m["path"]: m for m in cloud["models"]} + remap = statuses["sdxl/base_v1.safetensors"] + assert remap["status"] == "remap" + assert remap["set_widget"] == "1.ckpt_name" + assert remap["to"] == "base_v1.safetensors" + assert statuses["studio/hero_v5.safetensors"]["status"] == "absent" + assert statuses["sdxl_vae.safetensors"]["status"] == "present" + assert cloud["cloud_disabled"] == ["IPAdapterUnifiedLoader"] + assert cloud["verdict"] == "needs_build_or_lossy_conversion" + assert cloud["blocking"] == ["IPAdapterUnifiedLoader", "studio/hero_v5.safetensors"] + assert any(u.startswith("embedding:EasyNegative") for u in cloud["unverified"]) + + +def test_join_cloud_verdicts_without_blockers(): + plain = inventory({"nodes": [_node(1, "CheckpointLoaderSimple", ["base.safetensors"])]}) + nested = inventory({"nodes": [_node(1, "CheckpointLoaderSimple", ["sdxl/base.safetensors"])]}) + lookup = _catalog(CheckpointLoaderSimple=_combo("ckpt_name", "base.safetensors")) + + assert join_cloud(plain, lookup)["verdict"] == "covered_needs_check" + assert join_cloud(nested, lookup)["verdict"] == "covered_needs_check" + assert join_cloud(nested, lookup)["models"][0]["status"] == "remap" + assert join_cloud(plain, _catalog())["missing_classes"] == ["CheckpointLoaderSimple"] + + +def test_join_cloud_treats_missing_perf_only_nodes_as_lossless(): + workflow = { + "nodes": [ + _node(1, "WanVideoModelLoader", ["wan.safetensors"]), + _node(2, "WanVideoBlockSwap", [10, False]), + _node(3, "WanVideoSetBlockSwap"), + ] + } + cloud = join_cloud(inventory(workflow), _catalog(WanVideoModelLoader=_combo("model", "wan.safetensors"))) + + assert cloud["missing_classes"] == [] + assert [x["class"] for x in cloud["lossless_removable"]] == ["WanVideoBlockSwap", "WanVideoSetBlockSwap"] + assert cloud["verdict"] == "covered_needs_check" # Original model identity still needs verification. + + +def test_join_cloud_flags_a_same_named_file_with_different_weights(tmp_path: Path): + (tmp_path / "upscale_models").mkdir() + (tmp_path / "upscale_models" / "4x-UltraSharp.pth").write_bytes(b"x" * 10) + report = inventory({"nodes": [_node(1, "UpscaleModelLoader", ["4x-UltraSharp.pth"])]}) + join_local(report, [str(tmp_path)]) + lookup = _catalog(UpscaleModelLoader=_combo("model_name", "4x-UltraSharp.pth")) + + differs = join_cloud(report, lookup, size_of=lambda name: 66_961_958) + same = join_cloud(report, lookup, size_of=lambda name: 10) + + assert differs["models"][0]["weights"] == "different_size" + assert differs["verdict"] == "needs_build_or_lossy_conversion" + assert same["models"][0]["weights"] == "same_size" + assert same["verdict"] == "covered_needs_check" + + +def test_join_inputs_names_the_cloud_upload_and_finds_it(tmp_path: Path): + (tmp_path / "face.png").write_bytes(b"PNG") + report = inventory({"nodes": [_node(4, "LoadImage", ["face.png", "image"])]}) + + join_inputs(report, [str(tmp_path)], lambda path: "blake3:abc123") + cloud = join_cloud(report, _catalog(LoadImage=_combo("image", "abc123.png"))) + + item = report["inputs"][0] + assert item["local_path"] == str(tmp_path / "face.png") + assert item["cloud_name"] == "abc123.png" + assert item["on_cloud"] is True + assert cloud["verdict"] == "covered" + + +def test_inventory_only_expands_active_subgraph_instances(): + workflow = { + "nodes": [_node(1, "active"), _node(2, "muted", mode=2), _node(3, "bypassed", mode=4)], + "definitions": { + "subgraphs": [ + {"id": "active", "nodes": [_node(10, "VAELoader", ["used.safetensors"])]}, + {"id": "muted", "nodes": [_node(10, "LoraLoader", ["private.safetensors"])]}, + {"id": "bypassed", "nodes": [_node(10, "LoraLoader", ["bypassed.safetensors"])]}, + {"id": "unused", "nodes": [_node(10, "LoraLoader", ["unrelated.safetensors"])]}, + ] + }, + } + + report = inventory(workflow) + + assert list(report["classes"]) == ["VAELoader"] + assert [m["path"] for m in report["models"]] == ["used.safetensors"] + assert report["models"][0]["node_id"] == "1/10" + + +def test_inventory_checks_each_use_of_a_model_on_cloud(): + report = inventory( + {"nodes": [_node(1, "UNETLoader", ["same.safetensors"]), _node(2, "LoraLoader", ["same.safetensors"])]} + ) + + cloud = join_cloud( + report, + _catalog( + UNETLoader=_combo("unet_name", "same.safetensors"), LoraLoader=_combo("lora_name", "other.safetensors") + ), + ) + + assert cloud["verdict"] == "needs_build_or_lossy_conversion" + assert [m["status"] for m in cloud["models"]] == ["present", "absent"] + + +def test_join_inputs_respects_subfolders_and_rejects_ambiguous_basenames(tmp_path: Path): + for directory, data in [("first", b"WRONG"), ("second", b"RIGHT")]: + (tmp_path / directory).mkdir() + (tmp_path / directory / "face.png").write_bytes(data) + report = inventory({"nodes": [_node(1, "LoadImage", ["second/face.png", "image"])]}) + join_inputs(report, [str(tmp_path)], lambda path: hashlib.sha256(Path(path).read_bytes()).hexdigest()) + assert report["inputs"][0]["local_path"] == str(tmp_path / "second" / "face.png") + + ambiguous = inventory({"nodes": [_node(1, "LoadImage", ["face.png", "image"])]}) + join_inputs(ambiguous, [str(tmp_path)], lambda path: "should-not-hash-an-ambiguous-file") + assert ambiguous["inputs"][0]["local_path"] is None + assert "cloud_name" not in ambiguous["inputs"][0] + assert any("ambiguous" in warning for warning in ambiguous["warnings"]) + + +def test_same_size_is_not_proof_of_identical_weights(tmp_path: Path): + (tmp_path / "same.safetensors").write_bytes(b"SAME LENGTH") + report = inventory({"nodes": [_node(1, "UNETLoader", ["same.safetensors"])]}) + join_local(report, [str(tmp_path)]) + cloud = join_cloud(report, _catalog(UNETLoader=_combo("unet_name", "same.safetensors")), lambda name: 11) + + assert cloud["models"][0]["weights"] == "same_size" + assert cloud["verdict"] == "covered_needs_check" + assert any("identity" in note for note in cloud["unverified"]) + + +def test_api_input_files_are_selected_by_input_name_not_dict_order(): + report = inventory( + {"1": {"class_type": "LoadImageMask", "inputs": {"channel": "red", "image": "private-mask.png"}}} + ) + assert report["inputs"][0]["file"] == "private-mask.png" + + +def test_dynamic_ui_bindings_cannot_be_reported_as_covered(): + workflow = { + "nodes": [_node(1, "PrimitiveNode", ["private.png"]), _node(2, "LoadImage")], + "links": [[1, 1, 0, 2, 0, "STRING"]], + } + cloud = join_cloud(inventory(workflow), _catalog(LoadImage=_combo("image", "public.png"))) + assert cloud["verdict"] == "covered_needs_check" + assert any("API" in note for note in cloud["unverified"]) + + +def test_download_hints_do_not_add_unselected_template_models_to_scope(): + report = inventory( + { + "nodes": [ + _node( + 1, + "CheckpointLoaderSimple", + ["active.safetensors"], + models=[ + { + "name": "template-default.safetensors", + "directory": "checkpoints", + "url": "https://example.test/old", + } + ], + ) + ] + } + ) + assert [model["path"] for model in report["models"]] == ["active.safetensors"] + assert report["model_hints"][0]["path"] == "template-default.safetensors" diff --git a/tests/comfy_cli/test_workflow_inventory_regressions.py b/tests/comfy_cli/test_workflow_inventory_regressions.py new file mode 100644 index 000000000..3bec5e109 --- /dev/null +++ b/tests/comfy_cli/test_workflow_inventory_regressions.py @@ -0,0 +1,250 @@ +"""Dependency-scope and identity regressions from Run-on-Cloud validation.""" + +import pytest + +from comfy_cli.workflow_inventory import inventory, join_cloud, join_inputs, join_local + + +def _node(identifier, kind, values=(), **extra): + return {"id": identifier, "type": kind, "widgets_values": list(values), **extra} + + +def _catalog(kind): + return {"inputs": [{"name": "ckpt_name", "choices": ["base.safetensors"]}]} + + +@pytest.mark.parametrize("api", [False, True]) +def test_prompt_model_suffix_is_text_while_real_spaced_filename_is_retained(api): + text = "portrait, sharp focus, embedding:EasyNegative.pt" + workflow = ( + { + "1": {"class_type": "CLIPTextEncode", "inputs": {"text": text}}, + "2": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "My Model.safetensors"}}, + } + if api + else { + "nodes": [_node(1, "CLIPTextEncode", [text]), _node(2, "CheckpointLoaderSimple", ["My Model.safetensors"])] + } + ) + report = inventory(workflow) + assert report["embeddings"][0]["name"] == "EasyNegative.pt" + assert [model["path"] for model in report["models"]] == ["My Model.safetensors"] + + +@pytest.mark.parametrize( + "text,name", [("(embedding:BadDream:1.2)", "BadDream"), ("(embedding:BadDream.pt:0.75)", "BadDream.pt")] +) +def test_embedding_weight_is_not_part_of_filename(text, name): + report = inventory({"nodes": [_node(1, "CLIPTextEncode", [text])]}) + assert report["embeddings"][0]["name"] == name + + +@pytest.mark.parametrize("mode,why", [(2, "muted"), (4, "bypassed")]) +def test_inactive_subgraph_is_reported_without_expanding(mode, why): + report = inventory( + { + "nodes": [_node(1, "sg", mode=mode)], + "definitions": {"subgraphs": [{"id": "sg", "nodes": [_node(2, "PrivateLoader")]}]}, + } + ) + assert report["classes"] == {} + assert report["skipped"] == [{"id": 1, "class": "sg", "why": why, "models": []}] + + +@pytest.mark.parametrize("checked", [False, True]) +def test_absent_local_identity_is_not_verified_coverage(tmp_path, checked): + report = inventory({"nodes": [_node(1, "CheckpointLoaderSimple", ["base.safetensors"])]}) + if checked: + join_local(report, [str(tmp_path)]) + cloud = join_cloud(report, _catalog) + assert cloud["models"][0]["weights"] == ("no_local_copy" if checked else "not_checked") + assert cloud["verdict"] == "covered_needs_check" + assert cloud["unverified"] + + +@pytest.mark.parametrize("same_size,hash_files", [(False, False), (True, False), (True, True)]) +def test_different_local_copies_are_ambiguous(tmp_path, same_size, hash_files): + for name, payload in [("first", b"first"), ("second", b"other" if same_size else b"cloud-size")]: + root = tmp_path / name + root.mkdir() + (root / "base.safetensors").write_bytes(payload) + report = inventory({"nodes": [_node(1, "CheckpointLoaderSimple", ["base.safetensors"])]}) + join_local(report, [str(tmp_path / "first"), str(tmp_path / "second")], hash_files=hash_files) + cloud = join_cloud(report, _catalog, lambda _: 5) + assert cloud["models"][0]["weights"] == "ambiguous_local_copies" + assert cloud["verdict"] == "covered_needs_check" + + +def test_verified_identical_local_copies_keep_size_evidence(tmp_path): + for name in ("first", "second"): + root = tmp_path / name + root.mkdir() + (root / "base.safetensors").write_bytes(b"same") + report = inventory({"nodes": [_node(1, "CheckpointLoaderSimple", ["base.safetensors"])]}) + join_local(report, [str(tmp_path / "first"), str(tmp_path / "second")], hash_files=True) + assert join_cloud(report, _catalog, lambda _: 4)["models"][0]["weights"] == "same_size" + + +@pytest.mark.parametrize("api", [False, True]) +def test_unused_known_loader_is_excluded_but_unknown_output_is_preserved(api): + workflow = ( + { + "1": {"class_type": "LoadImage", "inputs": {"image": "input.png"}}, + "2": {"class_type": "SaveImage", "inputs": {"images": ["1", 0]}}, + "3": {"class_type": "LoraLoader", "inputs": {"lora_name": "unused.safetensors"}}, + "4": {"class_type": "PrivateOutput", "inputs": {"model": ["5", 0]}}, + "5": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "needed.safetensors"}}, + } + if api + else { + "nodes": [ + _node(1, "LoadImage", ["input.png"]), + _node(2, "SaveImage"), + _node(3, "LoraLoader", ["unused.safetensors"]), + _node(4, "PrivateOutput"), + _node(5, "CheckpointLoaderSimple", ["needed.safetensors"]), + ], + "links": [[1, 1, 0, 2, 0, "IMAGE"], [2, 5, 0, 4, 0, "MODEL"]], + } + ) + report = inventory(workflow) + assert "LoraLoader" not in report["classes"] + assert "PrivateOutput" in report["classes"] + assert [model["path"] for model in report["models"]] == ["needed.safetensors"] + assert any(str(node["id"]) == "3" and node["why"] == "disconnected" for node in report["skipped"]) + + +def test_no_known_output_does_not_guess_which_nodes_execute(): + report = inventory({"nodes": [_node(1, "LoraLoader", ["keep.safetensors"])]}) + assert report["models"][0]["path"] == "keep.safetensors" + + +def test_known_text_widget_ending_with_model_suffix_is_not_a_path(): + report = inventory({"nodes": [_node(1, "CLIPTextEncode", ["a portrait titled model.pt"])]}) + assert report["models"] == [] + + +def test_cli_preview_envelope_has_actionable_graph_extraction_error(): + with pytest.raises(ValueError, match=r"data\.prompt.*API graph"): + inventory( + {"schema": "envelope/1", "ok": True, "data": {"prompt": {"1": {"class_type": "SaveImage", "inputs": {}}}}} + ) + + +def test_literal_numeric_api_array_does_not_create_dependency_edge(): + report = inventory( + { + "1": {"class_type": "LoraLoader", "inputs": {"lora_name": "unused.safetensors"}}, + "2": {"class_type": "LoadImage", "inputs": {"image": "input.png"}}, + "3": {"class_type": "SaveImage", "inputs": {"images": ["2", 0], "range": [1, 0]}}, + } + ) + assert "LoraLoader" not in report["classes"] + + +def test_bypass_dependencies_are_retained_for_reachable_output(): + report = inventory( + { + "nodes": [ + _node(1, "CheckpointLoaderSimple", ["keep.safetensors"]), + _node(2, "LoraLoader", ["skip.safetensors"], mode=4), + _node(3, "SaveImage"), + ], + "links": [[1, 1, 0, 2, 0, "MODEL"], [2, 2, 0, 3, 0, "IMAGE"]], + } + ) + assert [model["path"] for model in report["models"]] == ["keep.safetensors"] + assert report["skipped"][0]["why"] == "bypassed" + + +def test_incomplete_graph_does_not_hide_dependencies(): + report = inventory( + { + "nodes": [_node(1, "CheckpointLoaderSimple", ["keep.safetensors"]), _node(2, "SaveImage")], + "links": [[1, 99, 0, 2, 0, "IMAGE"]], + } + ) + assert report["models"][0]["path"] == "keep.safetensors" + + +def test_broken_api_link_disables_pruning(): + report = inventory( + { + "1": {"class_type": "LoadImage", "inputs": {"image": "input.png"}}, + "2": {"class_type": "SaveImage", "inputs": {"images": ["1", 0], "other": ["missing-id", 0]}}, + "3": {"class_type": "LoraLoader", "inputs": {"lora_name": "keep.safetensors"}}, + } + ) + assert report["models"][0]["path"] == "keep.safetensors" + + +def test_unknown_loader_model_paths_are_not_hidden_by_text_like_input_names(): + report = inventory( + { + "1": { + "class_type": "CustomLoader", + "inputs": {"positive": "positive.safetensors", "text": "text.safetensors"}, + } + } + ) + assert [model["path"] for model in report["models"]] == ["positive.safetensors", "text.safetensors"] + + +def test_subgraph_object_links_are_supported(): + report = inventory( + { + "nodes": [_node(1, "sg")], + "definitions": { + "subgraphs": [ + { + "id": "sg", + "nodes": [ + _node(2, "LoadImage", ["input.png"]), + _node(3, "SaveImage"), + _node(4, "LoraLoader", ["unused.safetensors"]), + ], + "links": [ + { + "id": 1, + "origin_id": 2, + "origin_slot": 0, + "target_id": 3, + "target_slot": 0, + "type": "IMAGE", + } + ], + } + ] + }, + } + ) + assert report["models"] == [] + assert any(node["id"] == "1/4" and node["why"] == "disconnected" for node in report["skipped"]) + + +def test_missing_input_is_separate_from_dependency_coverage(tmp_path): + report = inventory({"nodes": [_node(1, "LoadImage", ["missing.png"])]}) + join_inputs(report, [str(tmp_path)], lambda _: pytest.fail("missing file cannot be hashed")) + cloud = join_cloud(report, lambda _: {"inputs": [{"name": "image", "choices": []}]}) + assert cloud["verdict"] == "covered" + assert cloud["readiness"] == { + "status": "needs_inputs", + "unresolved_inputs": [ + {"node_id": 1, "file": "missing.png", "reason": "local file not found and target availability unverified"} + ], + } + + +@pytest.mark.parametrize("output_class", ["SaveImage", "PrivateOutputNode"]) +def test_untrusted_output_false_metadata_cannot_hide_an_executed_save_branch(output_class): + from comfy_cli.workflow_inventory import inventory + + graph = { + "1": {"class_type": "CheckpointLoaderSimple", "inputs": {"ckpt_name": "used.safetensors"}}, + "2": {"class_type": "SaveImage", "inputs": {"images": ["1", 0]}}, + "3": {"class_type": "LoraLoader", "inputs": {"lora_name": "also-used.safetensors"}}, + "4": {"class_type": output_class, "output_node": False, "inputs": {"images": ["3", 0]}}, + } + report = inventory(graph) + assert {row["path"] for row in report["models"]} == {"used.safetensors", "also-used.safetensors"} + assert not any(row["why"] == "disconnected" for row in report["skipped"]) diff --git a/tests/comfy_cli/test_workspace_manager.py b/tests/comfy_cli/test_workspace_manager.py index b5bd3aa67..49a615089 100644 --- a/tests/comfy_cli/test_workspace_manager.py +++ b/tests/comfy_cli/test_workspace_manager.py @@ -721,17 +721,19 @@ def test_no_workspace_probe(self, command): result = self._invoke(["--json", *command]) assert not isinstance(result.exception, AssertionError), result.exception - def test_which_still_resolves_the_workspace(self): + def test_which_still_resolves_the_workspace(self, tmp_path): from typer.testing import CliRunner import comfy_cli.workspace_manager as workspace_manager_module from comfy_cli.cmdline import app - with patch.object(workspace_manager_module, "check_comfy_repo", return_value=(True, "/sentinel/ComfyUI")): + workspace = tmp_path / "ComfyUI" + workspace.mkdir() + with patch.object(workspace_manager_module, "check_comfy_repo", return_value=(True, str(workspace))): result = CliRunner().invoke(app, ["--json", "which"]) assert result.exit_code == 0, result.output - assert "/sentinel/ComfyUI" in result.output + assert str(workspace) in result.output def test_gitpython_is_not_imported(self): import subprocess diff --git a/uv.lock b/uv.lock index 2fc3a76bb..57587f87a 100644 --- a/uv.lock +++ b/uv.lock @@ -6,6 +6,57 @@ resolution-markers = [ "python_full_version < '3.11'", ] +[[package]] +name = "ada-url" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/4e/f62ef579f693298f62a4657a0429823444025f342161d53f5c1f7bd629c6/ada_url-4.0.0.tar.gz", hash = "sha256:9f399ec867349800a4c2d3aa8df8c533c340494b04d34b1f082b97d9a8b76a07", size = 265328, upload-time = "2026-07-28T19:29:53.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/0d/fcd5baaf23238abeb34e0cfc7e5be3100dfddcc71e6b91e4d57a2d55b6e8/ada_url-4.0.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:28a1d13716d127afe59bb46d91e19c4e02de103eabf965394d7944dccf7540fa", size = 701622, upload-time = "2026-07-28T19:28:52.855Z" }, + { url = "https://files.pythonhosted.org/packages/7b/fe/80b2c37bc58579e17e9d95f21573f126ba2e29944411c659e07d24bdd614/ada_url-4.0.0-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:19a73177721fa710cd336be18cfbd8c7de1d81201f895fb1df00b3a15b06c9f3", size = 486263, upload-time = "2026-07-28T19:28:54.544Z" }, + { url = "https://files.pythonhosted.org/packages/5b/d9/8195d44667f89697b279c7441e81af63d607d6e357c8a2e7f3c9d6cee0ff/ada_url-4.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e8ae79506463092bc01c3f430fb8784720ab6f3fe49ce65427ad7dd838cb1b4a", size = 481514, upload-time = "2026-07-28T19:28:56.106Z" }, + { url = "https://files.pythonhosted.org/packages/27/b4/b304d6b74961888f2f0756542848025f5c03a7709d124aac0b0c3c9405bb/ada_url-4.0.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2094db65d134d3d87c65d28fb7ab5ce4b7c16480e02c3a5da4da0756bcab5025", size = 1829883, upload-time = "2026-07-28T19:28:57.696Z" }, + { url = "https://files.pythonhosted.org/packages/07/67/0179da20490a258922071cf87d8d5558ec24c83e23831ddb304b44002442/ada_url-4.0.0-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e18557b30431aa1e19fb570416d4a0186a470202d113c47283c311757f08cf1f", size = 1861219, upload-time = "2026-07-28T19:28:59.445Z" }, + { url = "https://files.pythonhosted.org/packages/99/c0/eb5c9fb3e6478213e376b78d75bf1d44cf3e098c7568f74db0069630fa62/ada_url-4.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a0e0464aff6800b21d22f9f9683fd5625d1e9539967032291c88305361d2f6da", size = 2767525, upload-time = "2026-07-28T19:29:00.932Z" }, + { url = "https://files.pythonhosted.org/packages/da/a4/0e0469f7d2fe343fdfcfa353c8886a3d8a99e21441a3ec59cdaa5d43ee4e/ada_url-4.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0d8081fd0e939823162afa6d69cfeb5815c0035b56227cda2aa66357ba63917d", size = 2876126, upload-time = "2026-07-28T19:29:02.447Z" }, + { url = "https://files.pythonhosted.org/packages/77/53/a3052700fca22443defe1d856654a9db94f1a61a5fc731439c07a31071dc/ada_url-4.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:9ec145a74027c7be028c5558813302d27d9bdcc848947b9c00ff5e0e92c6aed1", size = 434044, upload-time = "2026-07-28T19:29:04.025Z" }, + { url = "https://files.pythonhosted.org/packages/06/25/4b6407fd8584debd46cde4775c8593bb1173d523de51bf2912db3b32a511/ada_url-4.0.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:6b49f6bb47c3252f673eeafed5f24a10449829a16ca02852cc19b2d1fa39c2d2", size = 701619, upload-time = "2026-07-28T19:29:05.323Z" }, + { url = "https://files.pythonhosted.org/packages/17/61/8932be53b468a4f3cdf70fee7089624d532883e0e1ba72c934646e2741d1/ada_url-4.0.0-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:39b4223ef9a226a3d673c8905f551308051f7c10781a25383f806bd7e33cf681", size = 486262, upload-time = "2026-07-28T19:29:06.757Z" }, + { url = "https://files.pythonhosted.org/packages/b7/49/aa3c27d40b6eee2cdb74781bd4d1ec4dce654a922475a07331f757400e31/ada_url-4.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8c0a10891bb775ebf9b5eac2a7a14150a208a43d94ff5c5e98829fa7770b7d99", size = 481514, upload-time = "2026-07-28T19:29:08.225Z" }, + { url = "https://files.pythonhosted.org/packages/9e/2f/0203f4d74dfd718e0f117c28906c0b9d90ac89dd90766efe61ce944e0a8a/ada_url-4.0.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:74e7aff0596381d35a2db6a473beb38bc9ca5e16f64a97e20c0ae3206059dfa2", size = 1829834, upload-time = "2026-07-28T19:29:09.671Z" }, + { url = "https://files.pythonhosted.org/packages/96/5f/3b3f5a17f75f690fd757183f31cc27f39101a14e664dfb0c5c6f71bf30f3/ada_url-4.0.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e86c86ffe4d310095ed50701afe5c1e76c2efd1c268ecdc91bfcd8a4609d80b4", size = 1861233, upload-time = "2026-07-28T19:29:11.181Z" }, + { url = "https://files.pythonhosted.org/packages/7d/8f/8f76f385fb47b50148d81bc215295cc9b61cd2969df3f1ba5041fd6767cc/ada_url-4.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d25ad705c3e720661b5defac4af046087a048330d6afe80b892053d1c47c23ac", size = 2767523, upload-time = "2026-07-28T19:29:12.601Z" }, + { url = "https://files.pythonhosted.org/packages/d3/56/1ec2bb5240810e53998eef2b8fb540fe25c0fefd5c26ff2bd25a1f9c3871/ada_url-4.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3f5efa01409553d15b8b27b4640cb43427a53c2995d2e2c5de505bd1faa9fb55", size = 2876096, upload-time = "2026-07-28T19:29:14.107Z" }, + { url = "https://files.pythonhosted.org/packages/f3/61/34e2575622c6db1f30d1bd20f709c1cf16359a7a1d1dee5add01ac2dc07e/ada_url-4.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:0641ecdeb6b226967077f52404af455a11e2957bcbb31b5921d6eb405859f831", size = 434042, upload-time = "2026-07-28T19:29:15.538Z" }, + { url = "https://files.pythonhosted.org/packages/49/6e/13bd71c47fa7096a3c74ae6536a8b465c2defedca43135e2881e3c590ccd/ada_url-4.0.0-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:909658402abad0c35422b3306d1464131c25b926cd203399b18bc1667f0778d4", size = 706191, upload-time = "2026-07-28T19:29:16.919Z" }, + { url = "https://files.pythonhosted.org/packages/9a/aa/6718ba57b57090db0b2f675d78a3762318e0f2c477ba718f76c6d8ec7e30/ada_url-4.0.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:75785fb7242411d1d0ada6e6abbe5cedcb87bee7d38272a1fd8beb5fc512bc2d", size = 488395, upload-time = "2026-07-28T19:29:18.284Z" }, + { url = "https://files.pythonhosted.org/packages/3f/8e/65fac4fa8846bffdc3d8c4e17294ee435385fcc8980ba141ed3b6f03b224/ada_url-4.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b3c6fd8148c1efde18f71a7c241d3e0ea98de36091a12940656cfa545a84da14", size = 483727, upload-time = "2026-07-28T19:29:19.929Z" }, + { url = "https://files.pythonhosted.org/packages/26/3e/5d931d6eba90657470f0ee9d4049685f177e34a452a1805aad5fe1c8885e/ada_url-4.0.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d85ab449fe23d2ac612d34a869dd6a0b5968b45819ebcae40d6307c7f951db69", size = 1830343, upload-time = "2026-07-28T19:29:21.514Z" }, + { url = "https://files.pythonhosted.org/packages/23/7c/144b315890c7c6bc6367bcd9101bd29f4343bc2a93a944bc5815dafbf48a/ada_url-4.0.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da1510328ffbb5a505815f322061137527946a3698bbb70dc53ec086b8086e21", size = 1861921, upload-time = "2026-07-28T19:29:23.129Z" }, + { url = "https://files.pythonhosted.org/packages/f6/f3/ed5f9b121dc460c2cc555393394e0d14a660bb1ed753abc0f1d60de04297/ada_url-4.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8e975816ec664690d78f26b479f41098f6cb1e3142b42821eef9eb9ee199f287", size = 2768370, upload-time = "2026-07-28T19:29:24.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/22/6a5d890f541266f5b7c345947c633bdb686a856c734502131161c52e3ccc/ada_url-4.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4608f6aa98fc736a4edd751dd017c9f146b8d3d86e08d86bfc0df5cb7f3eae8b", size = 2877324, upload-time = "2026-07-28T19:29:26.276Z" }, + { url = "https://files.pythonhosted.org/packages/b2/fe/13e01dbdc2ab9d7b9d150c386437d68ce0db9f3c3d2028130613cc10949b/ada_url-4.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:d5ab0c75e227d46dca70376193eb70387c605eb43866cf425a03df9655e02303", size = 434129, upload-time = "2026-07-28T19:29:28.129Z" }, + { url = "https://files.pythonhosted.org/packages/d5/74/426e9a200d80dbc368c26441e5978e8b2ebc7e3d9af08726d36439ef584e/ada_url-4.0.0-cp313-cp313-macosx_10_15_universal2.whl", hash = "sha256:da4040f51e6c17cf827f38031d3546e4a940c1440523ec0d0319048da21de174", size = 706191, upload-time = "2026-07-28T19:29:29.622Z" }, + { url = "https://files.pythonhosted.org/packages/4d/6b/4357e137aa0c894671ddbe975d4056dc2855626f0d1e09398c4e4a81fbea/ada_url-4.0.0-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:e1abb7c8bf5acbee94a5bb0b2e3100dcaf0aa3b4294e31e17c5645c85f473595", size = 488396, upload-time = "2026-07-28T19:29:30.948Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/6f881a4c36ac84f7ab12426594a12fc2155e82976bf2ff7ea1d080779ad7/ada_url-4.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:be53094f4cf0d435b51cf738486de8decaeafdc465d0b24a1462ecf88fbb2f58", size = 483727, upload-time = "2026-07-28T19:29:32.306Z" }, + { url = "https://files.pythonhosted.org/packages/88/ac/d02f27798ed2b15067d25e62cec97b6d1626cf9cc9ac8b3d3a45877a830c/ada_url-4.0.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f691beab142575e6546a37cac142e3abfe3bb7d0b586b648fc56917b5b88ec3", size = 1830312, upload-time = "2026-07-28T19:29:33.605Z" }, + { url = "https://files.pythonhosted.org/packages/5d/67/525a42ce8f4de030423c497b1a70261921f0347070cb3b22f9ae6ce6a14a/ada_url-4.0.0-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bdb9e57c9f2d2c4c29dc2b49eeb7c370a8c9550fcd95a44d8434444e236537a2", size = 1861928, upload-time = "2026-07-28T19:29:35.193Z" }, + { url = "https://files.pythonhosted.org/packages/91/0c/4e7d2ae2c72c963d1c0ee004a88a088ee8c0c669c9910947ea722e144eaa/ada_url-4.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4bc8c4f6cdc816379c14d49ae987a9e35bb5e8ee35517735a49afed08fd16e9e", size = 2768337, upload-time = "2026-07-28T19:29:36.868Z" }, + { url = "https://files.pythonhosted.org/packages/02/66/a673c258d4aa76b888758d5a468f231bb12686dc3c10ee51c2e5c2dffd7e/ada_url-4.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6f13b0cff78ad3ff48c4179f2eafaa0231be1ca1a4f52d841565a69dd3c7ceeb", size = 2877325, upload-time = "2026-07-28T19:29:38.637Z" }, + { url = "https://files.pythonhosted.org/packages/25/39/498e9e2a848a8fc0744c2d3fd36436de837bc0bd58a99041ddee832e37ea/ada_url-4.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:5563001339c7f19586df57d832238c45ab065c012c7d884cfd5ed73db8be46d6", size = 434130, upload-time = "2026-07-28T19:29:40.087Z" }, + { url = "https://files.pythonhosted.org/packages/87/78/74c5cd93ca51841cbd78af1cb4b1b3cd2c09a9d7915138c402491f25219c/ada_url-4.0.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:39f4bd73f700a69c5b8a90e961ef941a6a746a0702267626d1c963d375bb9262", size = 706351, upload-time = "2026-07-28T19:29:41.525Z" }, + { url = "https://files.pythonhosted.org/packages/f2/d2/5085234207eba6988714b1baa39f9ec02f2547d30f013fe99ee0689705e4/ada_url-4.0.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:528476f914bcc0f0f0d61edfaaad74762bb250577ba7a057fe498a01da74d0dd", size = 488412, upload-time = "2026-07-28T19:29:43.334Z" }, + { url = "https://files.pythonhosted.org/packages/e0/d9/b961166186fb879207606061c53c5f99ee541d932f9d8138ec6094ee321d/ada_url-4.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:21fb572120df103bc5596ae7e1989aa9653ad67876ee1f0c0479c0b7dc1987b7", size = 483816, upload-time = "2026-07-28T19:29:44.699Z" }, + { url = "https://files.pythonhosted.org/packages/e8/af/52a41bd417d738bdf9f02c13dd4f9df14bcf632a780fe3bbd2d41942eb38/ada_url-4.0.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23992e6adf1ee199cda3f740dc4b180f766f2221b664e867822bcd769b4319e7", size = 1830000, upload-time = "2026-07-28T19:29:46.404Z" }, + { url = "https://files.pythonhosted.org/packages/7b/11/d09f9563c844ca03a57000fd186ab4c478dd5e8c47f3ca968ac589edc9b9/ada_url-4.0.0-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ae36e49770036978ae9a3c31f24b69a1020d83dcc53b9a134a1ba5cafb85bd28", size = 1861736, upload-time = "2026-07-28T19:29:47.915Z" }, + { url = "https://files.pythonhosted.org/packages/12/a5/51e2c2da49fb0e2f82ee8df154fb37e2e32222a7cea85cec33919cdda404/ada_url-4.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:cc2c47eb1fc2e3fa164c8c64be6a3c63b5d30f72d5ceb3698d31c738bdbe953c", size = 2767953, upload-time = "2026-07-28T19:29:49.343Z" }, + { url = "https://files.pythonhosted.org/packages/12/4e/daa6b344240c9ea7776d211f2875731638d607c32a7f6b66cd3fdec7f2b6/ada_url-4.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f24ac26a6e1c8cb00abfa84426e5419cbe619439d55ba1266db4c67b5af066ad", size = 2877652, upload-time = "2026-07-28T19:29:50.926Z" }, + { url = "https://files.pythonhosted.org/packages/97/f0/3a6bf91fc2e6a0ee808e7fbf0981f7b6bb44b466dbfad19f2d229d32185c/ada_url-4.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:8ad116df43579c0c49dd1807e182137c38a3784927181a26ea4f5d051da155f0", size = 438477, upload-time = "2026-07-28T19:29:52.591Z" }, +] + [[package]] name = "annotated-doc" version = "0.0.5" @@ -171,6 +222,117 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e5/48/1549795ba7742c948d2ad169c1c8cdbae65bc450d6cd753d124b17c8cd32/certifi-2025.8.3-py3-none-any.whl", hash = "sha256:f6c12493cfb1b06ba2ff328595af9350c65d6644968e5d3a2ffd78699af217a5", size = 161216, upload-time = "2025-08-03T03:07:45.777Z" }, ] +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", version = "3.11", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and implementation_name != 'PyPy'" }, + { name = "pycparser", version = "3.12", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/d2/2cde336b375f55c76ca670f0be3978cc048e31e24f3b4d7ce8473150a388/cffi-2.1.1-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:baed1e86cc735622097354b9d1281406caf42ff42a886d29faa8e8d1630333be", size = 183779, upload-time = "2026-08-03T21:19:15.602Z" }, + { url = "https://files.pythonhosted.org/packages/94/1a/4b2f7c92293ba05cbd4a9a1b28faaf0326272d9488e6354657571c48a7aa/cffi-2.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ca82be1a1d406ecfe1d25dc16cb33488e5a16bf4438c9fb590484ea29d92478b", size = 184178, upload-time = "2026-08-03T21:19:16.67Z" }, + { url = "https://files.pythonhosted.org/packages/17/0b/ba385d8ccedf926c3cd06e8e2f327027da5afe5f0eb30f1f7bc43ac55125/cffi-2.1.1-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:42e2f76b9455f5a9a844f770bf3e200ed3da0e15f5df3db9c31fe80b04b3d004", size = 211037, upload-time = "2026-08-03T21:19:17.705Z" }, + { url = "https://files.pythonhosted.org/packages/a3/b9/0f2e58b2cefa33255bff36935d42b13180fe559bba82596540eb404bde7d/cffi-2.1.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5a59cc1c4442bc3d5c703bf720b51138d0bfc173618807c9ee2490a7541dd3d9", size = 218652, upload-time = "2026-08-03T21:19:18.735Z" }, + { url = "https://files.pythonhosted.org/packages/37/15/180e0dab27b9312c7479003d14c9e547634b7dcb934e2cc4650e1b131a7a/cffi-2.1.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:9f8d177621de5cb38ee3e731eda45d421db093ec0739f46a5594babda7987a98", size = 205422, upload-time = "2026-08-03T21:19:19.96Z" }, + { url = "https://files.pythonhosted.org/packages/18/d4/03026f0c850cbbaa9030750490225b4a7f4d524ea4df72c3cc740a90f4ef/cffi-2.1.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:75f80557d1389eddbd0de2681f6a390a0c5338c31ddaa821381c203fc3fd50d9", size = 205444, upload-time = "2026-08-03T21:19:21.246Z" }, + { url = "https://files.pythonhosted.org/packages/75/77/60bebf6f818bec84210ac5b6979ce4eeadce6fbbaabc9c7ab23e506d1ce5/cffi-2.1.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:194cffa889098ced9976c3fc6340305e43f6303657d298da55366907c05c22d6", size = 218742, upload-time = "2026-08-03T21:19:22.523Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ae/679bf47e73fd77b352171727f07de559a003f14de5d02b904a6ec1fa73ca/cffi-2.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5bb4e7ea95dcd6a014a6fef62e62467d67d8e582326443f3d68e71d6320a9fcf", size = 221054, upload-time = "2026-08-03T21:19:23.694Z" }, + { url = "https://files.pythonhosted.org/packages/09/b8/eefc0e06913b70aa153bf74c946094a18f58fd4aff11b7f372bfdfdca050/cffi-2.1.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3d22a20b1fb1632cc72c22f95f7b0d2961c3e1c235f245ba4c606c4771035659", size = 213489, upload-time = "2026-08-03T21:19:24.922Z" }, + { url = "https://files.pythonhosted.org/packages/6f/13/4e56852824a03cdf68523a35686f1c28eacd4bd30a7b0a78e682e6e6e1d3/cffi-2.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:1dea0e4d7d4f11f619fe8c1d76caf49e24405b4b5743c0e3be16a500ecd930c9", size = 220241, upload-time = "2026-08-03T21:19:26.214Z" }, + { url = "https://files.pythonhosted.org/packages/99/7f/040f9e163e4acac3ee3d85b02d00b2576e7ca980d8785f0a3a5f1a9bf7f5/cffi-2.1.1-cp310-cp310-win32.whl", hash = "sha256:7ce713ace7c0e4520535b42b77eaa742c16dab813978064913e5a3cf82973b41", size = 174578, upload-time = "2026-08-03T21:19:27.338Z" }, + { url = "https://files.pythonhosted.org/packages/ba/0b/644a2ec1a4eaba49c2939410bb1eb1d25b09d6d0582f5d2f95c537043725/cffi-2.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:a48d62ab9d6f4f98c983223a547af44be6ca3691074c31cecced6facd3ba2dc1", size = 185082, upload-time = "2026-08-03T21:19:28.409Z" }, + { url = "https://files.pythonhosted.org/packages/70/d2/16d99a0c4948febc0ebd133a13b2f688ff7f8cb04da971e1128872ce0c03/cffi-2.1.1-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:c8d2c9fd1f2d16f780d15127abb050d13d1a76c03a4bd87d7e4980e45e511e12", size = 183838, upload-time = "2026-08-03T21:19:29.637Z" }, + { url = "https://files.pythonhosted.org/packages/cd/95/31b535a9f0220ae9f357de4a08d57ce89cb417653c2fd9f075f50822a388/cffi-2.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:398aff33cee2767e3e781d2554c54bd0dff386bb437581e0d8011fde1a942ec1", size = 184168, upload-time = "2026-08-03T21:19:30.764Z" }, + { url = "https://files.pythonhosted.org/packages/ad/5a/4707a0dc1f203f5dde5a907b0d4e3c25d71120241048bd5bc6f1bb9d4e71/cffi-2.1.1-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0", size = 211805, upload-time = "2026-08-03T21:19:31.867Z" }, + { url = "https://files.pythonhosted.org/packages/ad/66/c19feabb28485b6e0bbaaafa90837a1ef5d302e90f2178bd33f17a49879b/cffi-2.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813", size = 218716, upload-time = "2026-08-03T21:19:32.896Z" }, + { url = "https://files.pythonhosted.org/packages/a7/92/500760486c8baab49a7a8a58ba7fc3355ec3974b454b8a09e528efde9e1d/cffi-2.1.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6e192623c49c94421616a5778fba35cf0d5a8d000650c1967ef4448ee5cdd990", size = 205569, upload-time = "2026-08-03T21:19:34.142Z" }, + { url = "https://files.pythonhosted.org/packages/a5/a7/a67c733254d6e7373f7822f8082d8d6beade791e0cf12a7611f376fa61c7/cffi-2.1.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a6e721d4b0e45d5b65e87534470e67b18dcd092c83f68fba09f152b9cbc061af", size = 204907, upload-time = "2026-08-03T21:19:35.174Z" }, + { url = "https://files.pythonhosted.org/packages/f7/a4/4399daaf8f7dfee9d7c3327fdb0426ee041cc63edc358b93911ceb2bfc7a/cffi-2.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632", size = 217807, upload-time = "2026-08-03T21:19:36.286Z" }, + { url = "https://files.pythonhosted.org/packages/28/f7/dabe6da2466ecbd82dc62e7342dc6b1065dad990c06f00f0ede9ebf2a0ed/cffi-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd", size = 221252, upload-time = "2026-08-03T21:19:37.416Z" }, + { url = "https://files.pythonhosted.org/packages/ce/87/616202d8e51342c07d2534c510111c4cc37201775ce8f60802c9335d1edd/cffi-2.1.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a", size = 214214, upload-time = "2026-08-03T21:19:38.507Z" }, + { url = "https://files.pythonhosted.org/packages/b4/c6/ab025d75d2c26c19b087c0124e75ee31cb65032f4fe345d356d8c507ab97/cffi-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa", size = 219408, upload-time = "2026-08-03T21:19:39.809Z" }, + { url = "https://files.pythonhosted.org/packages/db/e2/7e8109f65445bdc673a7b54f02c677de462db75674220fd1335efc8eb598/cffi-2.1.1-cp311-cp311-win32.whl", hash = "sha256:f8ec5e643a9a937f64e1999eb9f75d072263751912dc5cd06d3c85f8f44be7c3", size = 174470, upload-time = "2026-08-03T21:19:41.246Z" }, + { url = "https://files.pythonhosted.org/packages/73/c0/77ba02423c2f7d7091143c45cd49e0e6575c4c1967394bb542bd923a9b74/cffi-2.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:42f6930c31dc7f50732c9ae793c2786c7b6b044195967bbdde40bb9be81c4cc0", size = 185096, upload-time = "2026-08-03T21:19:42.615Z" }, + { url = "https://files.pythonhosted.org/packages/7c/47/9f1f85f9672ceda4984dc6c4f8824e8558992a2972c3d3c81fb8eb28d4ba/cffi-2.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:c7659f22557c5a0bc4855cd635f55edec690cc008a40768527762cb9fb263455", size = 179941, upload-time = "2026-08-03T21:19:43.747Z" }, + { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", size = 184821, upload-time = "2026-08-03T21:19:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", size = 184719, upload-time = "2026-08-03T21:19:46.129Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", size = 210249, upload-time = "2026-08-03T21:19:49.543Z" }, + { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", size = 208775, upload-time = "2026-08-03T21:19:50.918Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", hash = "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", size = 175292, upload-time = "2026-08-03T21:19:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", size = 185919, upload-time = "2026-08-03T21:19:56.89Z" }, + { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", size = 180093, upload-time = "2026-08-03T21:19:58.155Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/a7/46/2e5fdde8555706dd98139a910ca11be02809f3f605ce956f655d0214e100/cffi-2.1.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6", size = 184805, upload-time = "2026-08-03T21:20:02.02Z" }, + { url = "https://files.pythonhosted.org/packages/55/41/4c7042f317b9217502988f0873af87e16ad606dc20f84e546e3e6ce9764c/cffi-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971", size = 184764, upload-time = "2026-08-03T21:20:03.141Z" }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" }, + { url = "https://files.pythonhosted.org/packages/02/10/4b3c75dde3d9663c9e02ba05c2668b954f671d4bbe346413ca8c696b295a/cffi-2.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264", size = 210175, upload-time = "2026-08-03T21:20:06.75Z" }, + { url = "https://files.pythonhosted.org/packages/df/62/14f74b9543e605d17701dc797b815958b8bb70b7624ce1b832ddad48ed6c/cffi-2.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3", size = 208670, upload-time = "2026-08-03T21:20:08.04Z" }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/839b50531021a647fb5e929f72cf97bc1ff702b5472166164b5b6e76b851/cffi-2.1.1-cp313-cp313-win32.whl", hash = "sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac", size = 175263, upload-time = "2026-08-03T21:20:13.559Z" }, + { url = "https://files.pythonhosted.org/packages/60/a6/8b149b2c3f2e11aaa1618ef64500b45f50f22c57a977a4dff1aff1f91042/cffi-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d", size = 185688, upload-time = "2026-08-03T21:20:14.69Z" }, + { url = "https://files.pythonhosted.org/packages/01/9a/11f687cb39d6a3504060d5242f04f48c735afb4d3d533958a20594890cb2/cffi-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973", size = 180078, upload-time = "2026-08-03T21:20:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/d9/99/c4b0c17cacdc9c3b8f280026286a9826d6a208c0f047591a3c3ce99b91fd/cffi-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54", size = 184964, upload-time = "2026-08-03T21:20:19.708Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a9/9db617d05d7367c1ad0ab00b3aa6e6f9281edd689b4ee9ea0e5a84e89c97/cffi-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72", size = 184962, upload-time = "2026-08-03T21:20:20.833Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/80/10/c5c0cbf0a657aecf59ef511409734230bf556f05a0d6c9eed7aa5c0a0166/cffi-2.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062", size = 209985, upload-time = "2026-08-03T21:20:23.401Z" }, + { url = "https://files.pythonhosted.org/packages/d5/6c/bfa0b87b03b9238148beca990292843c9396ba069b54496596594173de7b/cffi-2.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03", size = 208530, upload-time = "2026-08-03T21:20:24.628Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e9/d0061c364cde06ee43168a0d076ac1da512cbc380d44767b844ba34fe2b6/cffi-2.1.1-cp314-cp314-win32.whl", hash = "sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c", size = 177682, upload-time = "2026-08-03T21:20:44.288Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1c3e01e3ba14c39f6d10bfbac52753b7e22259e38088e5cfe1d704918690/cffi-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48", size = 187949, upload-time = "2026-08-03T21:20:45.623Z" }, + { url = "https://files.pythonhosted.org/packages/87/5b/da4e39efe18eeb89cf580ea9cfc66b6a7c3eadb808fc0cc1d3a295cb5a5d/cffi-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836", size = 182947, upload-time = "2026-08-03T21:20:46.955Z" }, + { url = "https://files.pythonhosted.org/packages/23/59/40338bf421c5accea1d45158170c87006ef1cd371b05c077e76476949728/cffi-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3", size = 188504, upload-time = "2026-08-03T21:20:29.495Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/5ecf1023850036e674c77ec4de86182d309ae344e39e7cba984b7df5d647/cffi-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2", size = 188259, upload-time = "2026-08-03T21:20:31.291Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/4d/45/ba4c93527bc38616a8bd36488acb69a2212d60486794f0c1f318949bbb76/cffi-2.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc", size = 211538, upload-time = "2026-08-03T21:20:33.808Z" }, + { url = "https://files.pythonhosted.org/packages/80/e9/b6ef565e452acb932fb0cb5443f44a78efbd1233e566f02b5a83855e9115/cffi-2.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29", size = 210688, upload-time = "2026-08-03T21:20:34.974Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d2/3b7176cb570a1d3e27faf67b72f591af508036e0d8b2be2ef9af9e8c84bb/cffi-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4", size = 182868, upload-time = "2026-08-03T21:20:40.388Z" }, + { url = "https://files.pythonhosted.org/packages/56/78/31f00c1bcd97c9bbf55f1bfdf5bc809a5de8887473e90bb9960dca825e80/cffi-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e", size = 194104, upload-time = "2026-08-03T21:20:41.725Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1b/58496f2ed0a35de575250c02a43ab3cc2c04d494a88fed31c1cabc0fd176/cffi-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5", size = 186402, upload-time = "2026-08-03T21:20:43.042Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8a/af668013284634733f02d683458a0728739c7d6ddb5e14cb0c20832266fe/cffi-2.1.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4", size = 184933, upload-time = "2026-08-03T21:20:50.639Z" }, + { url = "https://files.pythonhosted.org/packages/0c/75/2f5207ff6d1a613133b23a5203cc0c2a628313b5eb3974d7956ae3c57950/cffi-2.1.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8", size = 185002, upload-time = "2026-08-03T21:20:52.173Z" }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" }, + { url = "https://files.pythonhosted.org/packages/50/e3/f6234a833e6e08c7007003074723c406559eecf9b48dfc97471e5a8eb7a0/cffi-2.1.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80", size = 209919, upload-time = "2026-08-03T21:20:54.783Z" }, + { url = "https://files.pythonhosted.org/packages/0d/fc/5f74e293fced6edb51af3a46c4ccf6c23c9943774ecb375ddbd522c76add/cffi-2.1.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779", size = 208529, upload-time = "2026-08-03T21:20:56.066Z" }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" }, + { url = "https://files.pythonhosted.org/packages/f8/7e/8debeb04f1ab9fe2a6963964cd6f1aaf7192627b83926586a6a4e089c9fa/cffi-2.1.1-cp315-cp315-win32.whl", hash = "sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac", size = 177683, upload-time = "2026-08-03T21:21:14.901Z" }, + { url = "https://files.pythonhosted.org/packages/e0/31/5158704cc474ab65c1647932e88be78dc0873f47130e253be38bcaf13d01/cffi-2.1.1-cp315-cp315-win_amd64.whl", hash = "sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960", size = 187897, upload-time = "2026-08-03T21:21:16.108Z" }, + { url = "https://files.pythonhosted.org/packages/cc/4b/b3a2da8570c704ffc0f9762cdc3ec0f02c8573798e0b5cf7f11c82bbb70f/cffi-2.1.1-cp315-cp315-win_arm64.whl", hash = "sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1", size = 182935, upload-time = "2026-08-03T21:21:17.271Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ef/5443574510a1207e6f6bc38ba6e1f1de36cb48fef07b2728bb896a21f430/cffi-2.1.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc", size = 188464, upload-time = "2026-08-03T21:21:01.163Z" }, + { url = "https://files.pythonhosted.org/packages/7e/ae/a56fa8c4686ad50e148fcbc8d3ae0d03915ff5c30d795058988c24118cef/cffi-2.1.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab", size = 188262, upload-time = "2026-08-03T21:21:02.382Z" }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f6/c3ad28bd19f77047a03084424fbd4cbe997303267c14423737324be0385d/cffi-2.1.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358", size = 211520, upload-time = "2026-08-03T21:21:04.863Z" }, + { url = "https://files.pythonhosted.org/packages/a0/cd/ccac9013a5bd9fd764de118674ab9c805b5ca10c19270d90ee273f8b2240/cffi-2.1.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231", size = 210673, upload-time = "2026-08-03T21:21:06.223Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" }, + { url = "https://files.pythonhosted.org/packages/6d/cd/a361394c94b2129d604bb846f624a8e88255a3ee33129c434a00d715e64f/cffi-2.1.1-cp315-cp315t-win32.whl", hash = "sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66", size = 182707, upload-time = "2026-08-03T21:21:11.226Z" }, + { url = "https://files.pythonhosted.org/packages/9b/b5/ba2b299993c26577d529b6ae29841f9e15b9fcf004d65f423f4fcf94ade9/cffi-2.1.1-cp315-cp315t-win_amd64.whl", hash = "sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3", size = 193772, upload-time = "2026-08-03T21:21:12.39Z" }, + { url = "https://files.pythonhosted.org/packages/aa/29/35e016098c814cd93de9cd320c66b5bfba14dc6ecedd3cb518fa7c408c69/cffi-2.1.1-cp315-cp315t-win_arm64.whl", hash = "sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692", size = 186360, upload-time = "2026-08-03T21:21:13.636Z" }, +] + [[package]] name = "cfgv" version = "3.4.0" @@ -273,6 +435,7 @@ name = "comfy-cli" version = "0.0.0" source = { editable = "." } dependencies = [ + { name = "ada-url" }, { name = "blake3" }, { name = "certifi" }, { name = "charset-normalizer" }, @@ -280,6 +443,7 @@ dependencies = [ { name = "gitpython" }, { name = "httpx" }, { name = "imageio-ffmpeg" }, + { name = "jsonschema" }, { name = "mixpanel" }, { name = "packaging" }, { name = "pathspec" }, @@ -300,7 +464,6 @@ dependencies = [ [package.optional-dependencies] dev = [ - { name = "jsonschema" }, { name = "pre-commit" }, { name = "pytest" }, { name = "pytest-cov" }, @@ -313,6 +476,7 @@ preview = [ [package.metadata] requires-dist = [ + { name = "ada-url", specifier = ">=4,<5" }, { name = "blake3", specifier = ">=1.0.9" }, { name = "certifi", specifier = ">=2024.7.4" }, { name = "charset-normalizer", specifier = ">=3" }, @@ -320,7 +484,7 @@ requires-dist = [ { name = "gitpython", specifier = ">=3.1.50" }, { name = "httpx" }, { name = "imageio-ffmpeg" }, - { name = "jsonschema", marker = "extra == 'dev'" }, + { name = "jsonschema", specifier = ">=4.18" }, { name = "mixpanel", specifier = "<5" }, { name = "packaging" }, { name = "pathspec" }, @@ -478,7 +642,7 @@ name = "exceptiongroup" version = "1.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749, upload-time = "2025-05-10T17:42:51.123Z" } wheels = [ @@ -891,6 +1055,30 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885, upload-time = "2025-02-13T21:54:37.486Z" }, ] +[[package]] +name = "pycparser" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/da/a8/c5fdbeee588bb8ada9458774f43adf1bdd30bd59157055142183e769a024/pycparser-3.11.tar.gz", hash = "sha256:d875f09c3507d00e1aba0eecc6dcadc1352f30fff09dc6bff2f1c2935e97c2bc", size = 113796, upload-time = "2026-10-09T12:56:59.539Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/11/0e6f11117525ff0eec40ebac3d313376f102df93ca44ad9e893ee85e4f89/pycparser-3.11-py3-none-any.whl", hash = "sha256:51d5a8ba2be0bbe440b99d2112604c95bbbc3c2748a64260186c541e1729cd80", size = 51178, upload-time = "2026-10-09T12:56:58.131Z" }, +] + +[[package]] +name = "pycparser" +version = "3.12" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/27/eeb9f307bf07060f3d9f9aa0fb8c15b01bdfded0a941e4b2719c7f94cacd/pycparser-3.12.tar.gz", hash = "sha256:f03387877eab82ce01bbdfd0ba7252ee55a90b1c708d5129e2ce915475cf1db6", size = 158785, upload-time = "2026-10-22T13:40:03.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/ae/315bbeee126a769cbde43cf4908acb4b40408d8bf8bbf334dd7368d8dadf/pycparser-3.12-py3-none-any.whl", hash = "sha256:a076f3f489b39b43ed13563a1dafe42447445bec2e294154ec5c57fcdda4c85e", size = 62600, upload-time = "2026-10-22T13:40:02.021Z" }, +] + [[package]] name = "pygments" version = "2.19.2"