fix: release v0.3.84 — ernie_t2i.json実行時のPrompt outputs failed validationエラーを修正

サブグラフ境界のwidget値(width/height等)が複数の内部ノードへfan-outする場合
(EmptyFlux2LatentImage.widthへの実ウィジェット注入 + PreviewAny.sourceという
ウィジェット表現を持たないワイルドカード必須入力への中継)、_flattenSubgraphs
のinputPortTargetsが最後の1ターゲットで上書きされ、片方が未接続のまま
Required input is missing: sourceで検証エラーになっていた。全fan-outターゲット
を追跡し、非ウィジェット入力にはリテラル値を直接注入するよう修正。
実サーバーへの/promptバリデーションおよび実ブラウザでのGenerate実行で確認。

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

DEVLOG.md

@@ -2,6 +2,84 @@
 
 ---
 
+## v0.3.84
+
+### バグ修正: ernie_t2i.jsonをGenerateUIタブで実行すると "Prompt outputs failed validation" エラー
+
+v0.3.83でプロンプト表示は修正できたが、ユーザーが実際にGenerateを実行すると`Required input is missing: source`で失敗する不具合が新たに見つかった。ComfyUIサーバーへ直接`/prompt`をPOSTして検証エラーの詳細を取得したところ、原因は`PreviewAny`（"Preview as Text"、テキストデバッグ表示用）ノードの必須入力`source`（型`*`のワイルドカード、ウィジェット表現を持たない）が空になっていたこと。
+
+Ernie Imageのサブグラフでは、外側の折りたたみノードが持つ`width`/`height`ウィジェット値が、内部で**2方向に分岐**していた: 一方は`EmptyFlux2LatentImage.width`（ウィジェット値として注入・解決済み）、もう一方は`PreviewAny.source`（幅の値をプロンプトテンプレート文字列 `{width}` に埋め込むために使われる中継ノード）。既存の`_flattenSubgraphs`の境界値注入ロジックは「1つの境界ポート→1つの内部ターゲット」を前提にしており、`inputPortTargets`が複数ターゲットのうち最後の1つで上書きされていたため、fan-out先の一方（多くの場合ウィジェットではない方）が完全に未接続のまま残っていた。
+
+- `inputPortTargets`をポートごとに配列で保持するよう変更し、全fan-outターゲットを追跡できるようにした
+- ウィジェット注入ループをポート単位で回すよう再構成: ウィジェット型ターゲットには従来通り`widgets_values`へ注入しつつ、非ウィジェット型（`PreviewAny.source`のようなワイルドカード必須入力）には`_wfmLiteralInputs`という新しい経路でリテラル値をそのまま`inputs`に注入するようにした（`convertUiToApi`側で`_wfmLiteralInputs`をマージ）
+- 外側ノードの`widgets_values`が空（＝ユーザーが未設定のテンプレートそのまま）の場合でも、fan-out先の別ターゲット（例: `EmptyFlux2LatentImage`）が保持する内部デフォルト値を読み取ってフォールバックとして使うようにし、`image_ernie_image.json`（未設定テンプレート）でも同様に動作するようにした
+
+**検証**: `/object_info`を提供する実際のComfyUIサーバーに対しNode.jsから直接`/prompt`をPOSTして修正前後の検証結果を比較（修正前: `node_errors`に`Required input is missing: source`、修正後: `node_errors: {}`）。さらに実ブラウザのGenerateUIタブから`ernie_t2i.json`を読み込みGenerateボタンを実行し、実際に画像が生成され「Done (1 image)」になることを確認。
+
+**How to apply**: サブグラフの境界ウィジェット値は1つのポートから複数の内部ノードへ分岐しうる（今回のような「実際に使う値」と「表示・テンプレート埋め込み用の値」の二重利用パターン）。`_flattenSubgraphs`の境界値解決ロジックを触る際は、常に「1ポート=1ターゲット」ではなく「1ポート=Nターゲット」であることを前提にすること。またウィジェット表現を持たない必須入力（型`*`など）はwidgets_valuesに書けないため、`_wfmLiteralInputs`のような別経路でリテラル値を注入する。
+
+## v0.3.83
+
+### 追加機能: Ernie Image（ernie-image / ernie-image-turbo）ワークフロー対応 + プロンプトがリンク経由のノードから供給されるパターンの修正
+
+Flux2 Klein（`Flux2-Klein_00025.json`）とErnie Image系2ワークフロー（`image_ernie_image.json` / `ernie_t2i.json`）で、GenerateUIタブ・Metadataタブ・サイドパネルIタブのいずれもプロンプトが表示されない不具合を修正した。
+
+いずれも「プロンプトの実体が`CLIPTextEncode`自身のウィジェット値ではなく、リンク経由で外部の別ノードから供給される」という、v0.3.81/v0.3.82で対応した構成とは異なる新しいパターンが原因だった。
+
+- **Flux2 Klein**: `CLIPTextEncode.text`が`PrimitiveStringMultiline`ノードへのリンク参照になっている。GenerateUIタブ側（`comfyui-workflow.js`）は既存のrole伝播ロジックで対応済みだったが、Metadataタブ側（`metadata-tab.js`の`resolveLinkedText()`、API形式のリンク解決用）が`text`/`text_g`/`prompt`等のキーしか見ておらず、`PrimitiveStringMultiline`が使う`value`キーを見ていなかったため未検出だった。
+- **Ernie Image**: プロンプト強化トグル（`prompt_enhancement`）用に`ComfySwitchNode`（if/else switch）を使い、生プロンプトを保持する`PrimitiveStringMultiline`と、LLMで書き換える`TextGenerate`ノードのどちらかへ実行時に切り替える構成。`TextGenerate`の出力は実行時まで内容が決まらず静的解析では取得不能なため、3タブとも`ComfySwitchNode`の両分岐（`on_false`/`on_true`）を辿った上で、リテラルな文字列へ解決できる方（＝ユーザーが入力した元のプロンプト）を採用するようにした。
+
+`comfyui-workflow.js`（GenerateUIタブの`analyzeWorkflow()`のPass 1bロール伝播に`ComfySwitchNode`対応を追加）、`metadata-tab.js`（`resolveLinkedText()`と`extractPromptsFromNodeSet()`を再帰的な解決ロジックに書き直し、`ComfySwitchNode`と`value`キーに対応）、`node_sets_menu.js`（サイドパネルIタブのローカル複製、同様の修正）の3ファイルを修正。
+
+**検証**: 実際に稼働中のComfyUIサーバー（`/object_info`）を使い、`convertUiToApi()`によるサブグラフ展開を経た上でGenerateUIタブ・Metadataタブ・サイドパネルIタブの3箇所すべてで実ブラウザ上からプロンプトが正しく表示されることを確認。
+
+**あわせてヘルプを更新**: GenerateUIタブ（`helpGen2`）・Metadataタブ（`helpMetadata5`）のヘルプ本文、およびMetadataタブ内の対応フォーマット補足（`metaFormatTodo`）に記載している対応サブグラフワークフローの例にErnie Imageを追加（EN/JA/ZH）。
+
+**How to apply**: [[v0.3.82]]で整理した「GenerateUIタブとMetadataタブ（およびIタブの複製）は別実装で自動同期しない」という注意点に加え、プロンプトが`CLIPTextEncode`自身の値ではなくリンク経由で別ノードから来るパターン（`PrimitiveStringMultiline`直結、`ComfySwitchNode`等の中継ノード経由）は今後も現れうる。中継ノードがLLM呼び出しなど実行時にしか値が決まらないノードへ分岐している場合は、無理に実際の出力値を再現しようとせず、静的に解決できる（＝ユーザーが直接入力した）分岐を優先して表示する方針でよい。
+
+## v0.3.82
+
+### バグ修正: MetadataタブとサイドパネルIタブでLongCat/Boogu/HiDream E1/FireRed等のプロンプトが表示されない不具合
+
+v0.3.81でFlux.2 Klein/LongCat/Boogu/HiDream E1/FireRedをGenerateUIタブに対応させた後、ユーザーがAI TOOL Chatで実際に5系統すべてを生成しMetadataタブで確認したところ、`qwen_image_edit2509`/`2511`・LongCat・Boogu・FireRedの画像でプロンプトが一切表示されない不具合が見つかった。同じ画像をGenerateUIタブへ読み込むと正しく表示されたことから、GenerateUIタブの解析（`comfyui-workflow.js`の`analyzeWorkflow()`）とは別に実装されているMetadataタブ独自のプロンプト抽出ロジック（`extractPromptsAPI()`/`extractPromptsFromNodeSet()`）が、v0.3.81で対応した新しいノードパターンに追従していなかったことが原因と判明した。
+
+- **`prompt`キーの欠落**: PNG画像は`workflow`チャンク（UI形式）より`prompt`チャンク（ComfyUIが実行時に生成した、既にAPI形式のペイロードそのもの）が優先的に読まれるため、常に`extractPromptsAPI()`のtextMap構築ロジックが使われる。ここが`text`/`text_g`キーのみを見ており、`TextEncodeQwenImageEdit`(Plus含む)や`TextEncodeBooguEdit`が使う`prompt`キーを見ていなかった（LongCat/Boogu/FireRed、および同種のQwen-Image-Edit系公式テンプレートすべてに影響）。
+- **Guider経由のrole判定漏れ**: `SamplerCustomAdvanced`はpositive/negativeを直接持たず、`guider`入力の先にある`CFGGuider`/`DualCFGGuider`/`BasicGuider`ノードが持つため、サンプラーノードのinputsを直接見るだけの既存ロジックでは見つけられなかった（Flux.2 Klein/HiDream E1）。GenerateUIタブ側で先に実装した「guiderノードを辿る」対応と同じロジックをMetadataタブ側にも追加。
+- **`TextEncodeBooguEdit`の1ノード2ロール対応**: `prompt`/`negative_prompt`を1ノードに両方持つ構造は`TextEncodeMageFlowEdit`と同じパターンのため、既存の専用分岐にBooguも合流させた。
+- **`InstructPixToPixConditioning`の追加ホップ解決**: HiDream E1のこのノードはpositive/negativeを中継するだけで自身はテキストを持たないため、guiderの`cond1`/`negative`から一段先まで辿るようにした。
+
+`extractPromptsAPI()`（API形式JSON・PNGの`prompt`チャンク用）と`extractPromptsFromNodeSet()`（UI形式・サブグラフ内共用）の両方を修正。さらに`node_sets_menu.js`（ComfyUIサイドパネルのIタブ、`web/comfyui/`はESモジュールをimportできない制約から`comfyui-workflow.js`/`metadata-tab.js`相当のロジックを`_wfm`接頭辞でローカル複製している）にも同じ修正を適用した。
+
+**あわせてヘルプを更新**: GenerateUIタブ（`helpGen2`）・Metadataタブ（`helpMetadata5`）のヘルプ本文、およびMetadataタブ内の対応フォーマット補足（`metaFormatTodo`）に記載している対応サブグラフワークフローの例に、LongCat/Boogu/HiDream E1/FireRedを追加（EN/JA/ZH）。あわせて`metaFormatTodo`にMage-Flowが記載漏れだった既存の抜けも修正した。
+
+**検証**: ユーザーがAI TOOL Chatで実際に5系統のワークフローを生成し、Metadataタブでプロンプトが正しく表示されることを確認。サイドパネルIタブでも同様に確認。
+
+**How to apply**: GenerateUIタブとMetadataタブ（および複製先のIタブ）は、ワークフロー解析ロジックを別々に実装しており自動的には同期しない。新しいノードパターン（プロンプトの格納キー名、guider経由のconditioning構造など）へ対応する際は、`comfyui-workflow.js`の`analyzeWorkflow()`だけでなく`metadata-tab.js`の`extractPromptsAPI()`/`extractPromptsFromNodeSet()`、および`node_sets_menu.js`のローカル複製版も合わせて確認・修正すること。特にPNG画像のメタデータは`prompt`（API形式）チャンクが`workflow`（UI形式）チャンクより優先されるため、実機検証はワークフローJSONの直接ドロップだけでなく、実際に生成したPNG画像でも行うこと（今回はまさにこの違いで問題が後から発覚した）。
+
+## v0.3.81
+
+### 追加機能: GenerateUIタブでFlux.2 Klein / LongCat / Boogu / HiDream E1 / FireRedのImage Editワークフローに対応
+
+「Flux2.Klein4b_comic.json / Flux2.Klein9b_comic.jsonをGenerateUIタブで動作させたい」という依頼を皮切りに、続けて`longcat_comic` / `boogu_image_comic` / `hidream_comic` / `Firered_comic`の4ワークフローにも対応してほしいという依頼が続いた。いずれも公式・サードパーティのImage Edit系ワークフローで、`KSampler`を使わない「Advanced Sampling」構成（`RandomNoise`＋何らかのGuiderノード＋`KSamplerSelect`＋`*Scheduler`＋`SamplerCustom`系ノードに分散した seed/steps/cfg/sampler/scheduler）や、独自のプロンプト/サンプラーノードを使っており、既存の`analyzeWorkflow()`（`comfyui-workflow.js`）が前提とするKSampler中心の設計では検出できず、GenerateUIタブのSettings/Latentパネルが「ノードが見つかりません」表示のまま操作不能だった。
+
+- **Flux.2 Klein（4b/9b）**: `CFGGuider`＋`RandomNoise`＋`SamplerCustomAdvanced`＋`KSamplerSelect`＋`Flux2Scheduler`という構成。`SamplerCustomAdvanced`を起点にguider/noise/sampler/schedulerの4ノードをたどり、Settingsパネルに複合サンプラーとして集約表示・編集できるようにした。`EmptyFlux2LatentImage`もLatentパネルに対応させ、`GetImageSize`へリンクされたwidth/heightは編集不可の代わりに空欄＋説明表示にして誤上書きを防止。`CFGGuider`/`BasicGuider`をpositive/negative判定の起点にも追加。
+- **LongCat**: 標準`KSampler`だが独自プロンプトノード`TextEncodeQwenImageEdit`（Plus無し版）を使用。`FluxGuidance`/`FluxKontextMultiReferenceLatentMethod`をrole伝播のパススルーノード集合(`COND_PASSTHROUGH`)に追加。
+- **Boogu**: `SamplerCustom`（`SamplerCustomAdvanced`とは入力構成が別物で、`CFGGuider`/`RandomNoise`を介さず自身が`positive`/`negative`/`cfg`/`noise_seed`を直接持つ）を誤って同一視していた既存実装を分離し、それぞれ専用ロジックで検出。独自プロンプトノード`TextEncodeBooguEdit`（1ノードに`prompt`/`negative_prompt`を両方保持）にも対応。
+- **HiDream E1**: `cond1`/`cond2`/`negative`という3つのconditioning入力を持つ特殊ガイダンスノード`DualCFGGuider`（`cfg`の代わりに`cfg_conds`/`cfg_cond2_negative`を持つ）と、画像編集用の中継ノード`InstructPixToPixConditioning`（positive/negative別々の入力・出力を持つため、通常の`COND_PASSTHROUGH`一括処理では役割を取り違える）のrole伝播に個別対応。
+- **FireRed**: `KSampler`のseed/steps/cfgがPrimitiveノード経由でリンクされる構成（値が数値ではなくリンク参照配列になる）で、既存の直接値前提のコードがリンク配列をそのままSettingsパネルに表示しようとしていた不具合を修正（数値でない場合は`undefined`扱いにし、リンク接続時は空欄＋「linked」表示、Apply時は未入力なら書き込みをスキップ）。
+
+**実機検証で発見・修正した既存バグ（今回の対応範囲拡大で初めて表面化）**
+
+- サブグラフ内部で完結するリンク（`GetImageSize`→`EmptyFlux2LatentImage`など）の扱いが誤っており、`widgets_values`変換で`batch_size`が`1024`になったり`CLIPTextEncode`の`text`が消えたりする不具合。
+- 同じロール（positive/negative）のプロンプトノードが複数存在する場合、ドロップダウンの選択とテキストエリアの表示内容が食い違う不具合（全`<option>`に無条件で`selected`を付けていたため）。
+- ミュート/バイパスしたサブグラフの内部ノードにmode情報が伝播せず、無効なパイプラインのノードがModelタブ等のデフォルト表示に紛れ込む不具合。
+- サブグラフ展開処理（`_flattenSubgraphs`）の`widgets_values`ノーマライズが「配列長とwidget数が完全一致する場合のみ」動作する設計だったため、seed直後に`control_after_generate`拡張値（`'fixed'`等）が挟まるノード（`KSampler`等）では条件が不成立となり、リンクされたwidget（steps/cfg等）のエントリが除去されないまま後続処理に渡り、cfg/denoiseなど後続フィールドの値が1つずつズレて上書きされる不具合（Firered_comicの実機検証で発覚）。`_simulateWidgetValues`/`_stripLegacyLinkedWidgetValues`/`_findInjectedWidgetIndex`という共通ロジックに全面書き直し、legacy-full/modern形式の自動判定と`control_after_generate`込みの正確な位置計算・注入に統一した。
+- `Reroute`ノード（配線整理用のUI専用パススルーノードで、ComfyUIバックエンドにノードクラスが存在しない）がそのままAPIペイロードに含まれ、`missing_node_type`の400エラーで生成が失敗する不具合（hidream_comicを実際にGenerateして初めて発覚）。既存のBypass(mode:4)ノード解決ロジック(`_resolveBypassSource`)をReroute対応に拡張し、常に配線を透過解決するようにした。Rerouteの入力型は`"*"`（汎用型）のまま保存されることが多く、Bypass用の型一致検索では見つからないため、Reroute（常に1入力1出力）は型チェックを省略する専用分岐を追加。
+
+**検証**: 実際にComfyUI上で6ワークフロー（Flux2.Klein4b_comic/Flux2.Klein9b_comic/longcat_comic/boogu_image_comic/hidream_comic/Firered_comic）をGenerateUIタブへ読み込み、Prompt/Settings/Model/Imageタブの表示とRaw JSON変換結果を1つずつ突き合わせて確認。hidream_comicは実際にGenerateを実行し、画像生成成功（Eagle保存ログ）まで確認。
+
+**How to apply**: KSamplerを使わない「Advanced Sampling」構成（`CFGGuider`/`DualCFGGuider`/`BasicGuider` + `RandomNoise` + `SamplerCustom`(`Advanced`) + `KSamplerSelect` + `*Scheduler`）に新しく遭遇したら、`SamplerCustomAdvanced`/`SamplerCustom`自体を起点にguider/scheduler/samplerノードをたどるのが基本形だが、guiderノードのconditioning入力名（`positive`/`negative` vs `cond1`/`cond2`/`negative`等）やSamplerCustom系のwidget有無はノードごとに異なるため、実際のノード定義を確認してから個別対応を追加すること。サブグラフの`widgets_values`関連の不具合は、`_simulateWidgetValues`系の共通ロジックが「legacy-full/modern形式の自動判定」「`control_after_generate`込みの正確な位置計算」まで一括して担うようになったため、今後同種の問題が出たら個別対応ではなくこの共通関数を確認・拡張するのが筋。`Reroute`のようなComfyコア標準の「UI専用でバックエンドに実体がないノード」は他にも存在しうるため、同様のエラー（`missing_node_type`）に遭遇したら`_resolveBypassSource`の仕組みを拡張する方針で対応する。
+
 ## v0.3.80
 
 ### 追加機能: Comic Creator「半自動マンガ作成」向けブリッジ（LLMプロンプト下書き・バッチ画像生成）

README.md

@@ -21,7 +21,7 @@ A comprehensive workflow, asset management, and generation UI plugin for [ComfyU
 - Built-in AI tools (translation and more)
 
 ![Workflow Studio](https://img.shields.io/badge/ComfyUI-Custom_Node-blue)
-![Version](https://img.shields.io/badge/version-0.3.79-green)
+![Version](https://img.shields.io/badge/version-0.3.84-green)
 
 ## Screenshots
 
@@ -99,7 +99,7 @@ A comprehensive workflow, asset management, and generation UI plugin for [ComfyU
   - **Center pane** — group-based selection with inner tabs (Checkpoint | Lora | Prompt | Workflow); Checkpoint/Lora groups come from the Models tab, Prompt groups from the Prompt tab, Workflow groups from the Workflow tab — check a group to add all its members, expand ▶ to select individually
   - **Right pane (Batch Queue)** — 7 columns: Checkpoint / Lora / Prompt / Workflow / Sampler / Scheduler / **Style**; each column header has an enable checkbox (radio behavior: only one at a time); count shown per column; Style batch applies each selected style sequentially to a workflow copy
   - **Lora batch prompt sync** (v0.3.69) — for each selected LoRA, its syntax (`<lora:name:strength_model:strength_clip>`) and CivitAI trained words are automatically appended to the Positive prompt (rebuilt from the original prompt each time, not accumulated), then restored to the pre-batch state when the batch completes or is stopped; if a selected LoRA is not yet recognized by ComfyUI's model list, a warning toast suggests a Refresh or restart
-- **UI-to-API conversion** — automatic conversion supporting subgraphs (nested workflows), COMBO types, and display-only node exclusion; improved analysis covers SDXL multi-hop CONDITIONING chains, CLIPTextEncodeSDXL, SDXLPromptStyler, KSamplerAdvanced, and more
+- **UI-to-API conversion** — automatic conversion supporting subgraphs (nested workflows), COMBO types, and display-only node exclusion; improved analysis covers SDXL multi-hop CONDITIONING chains, CLIPTextEncodeSDXL, SDXLPromptStyler, KSamplerAdvanced, and Guider-based "Advanced Sampling" workflows (`SamplerCustomAdvanced`/`SamplerCustom` + `CFGGuider`/`DualCFGGuider`/`BasicGuider` + `RandomNoise` + `KSamplerSelect` + `*Scheduler` — Flux.2 Klein, LongCat, Boogu, HiDream E1, etc.)
 - **Eagle integration** — auto-save generated images to [Eagle](https://eagle.cool/) with metadata
 
 ### Feeder subtab (v0.3.5 / v0.3.42)
@@ -145,11 +145,11 @@ Two independent modes selectable via **[Image Loop] / [Gallery]** toggle buttons
 
 - **3-column layout** — Drop zone (left) | Model info (center) | LoRA + Prompt (right)
 - **File drop** — drop a ComfyUI-generated PNG / WebP or workflow JSON onto the drop zone (or click to open a file picker); PNG/WebP images are shown as a preview
-- **Model extraction** — automatically extracts Checkpoint, VAE, Diffusion Model, and Text Encoder names from the workflow; supports both standard and subgraph-based workflows (Flux.2 Dev/Klein, Qwen-Image-Edit/2511/Layered, Z-Image Base/Turbo, Ernie Image, WAN2.2); node types covered: UNETLoader, UnetLoaderGGUF, UNETLoaderGGUF (e.g. HiDream GGUF), CLIPLoader, DualCLIPLoader, TripleCLIPLoader, QuadrupleCLIPLoader (e.g. HiDream 4-CLIP)
+- **Model extraction** — automatically extracts Checkpoint, VAE, Diffusion Model, and Text Encoder names from the workflow; supports both standard and subgraph-based workflows (Flux.2 Dev/Klein, Qwen-Image-Edit/2511/Layered, Z-Image Base/Turbo, Ernie Image, WAN2.2, Mage-Flow, LongCat, Boogu, HiDream E1, FireRed); node types covered: UNETLoader, UnetLoaderGGUF, UNETLoaderGGUF (e.g. HiDream GGUF), CLIPLoader, DualCLIPLoader, TripleCLIPLoader, QuadrupleCLIPLoader (e.g. HiDream 4-CLIP)
 - **LoRA extraction** — lists all LoRA models with `strength_model / strength_clip` values
 - **Prompt extraction** — lists prompts with POS / NEG badges when positive/negative can be determined; when distinction is not possible (e.g. `SamplerCustomAdvanced`, intermediate nodes, cross-level connections), prompts are shown without a badge as plain **Text**; click any entry to view the full text below
 - **Prompt actions** — Copy to clipboard, **GenUI:P/N** (set GenerateUI positive/negative prompt), **Prompt:P/N** (set Prompt tab preset positive/negative)
-- **Format support** — ComfyUI PNG/WebP/JSON (standard + Flux.2 / Qwen-Image / Z-Image / Ernie Image / WAN2.2 subgraph workflows), SD WebUI, SD Forge, Fooocus
+- **Format support** — ComfyUI PNG/WebP/JSON (standard + Flux.2 / Qwen-Image / Z-Image / Ernie Image / WAN2.2 / Mage-Flow / LongCat / Boogu / HiDream E1 / FireRed subgraph workflows), SD WebUI, SD Forge, Fooocus
 - **Format note** — supported formats and covered model types are always shown in the left column
 
 ### Settings Tab
@@ -410,6 +410,24 @@ Click the **camera icon** (next to the W button) in ComfyUI's top bar to capture
 
 ## Changelog
 
+### v0.3.84
+
+- **Bug fix: `ernie_t2i.json` failed to Generate with "Prompt outputs failed validation"** — the actual failure was `Required input is missing: source` on a `PreviewAny` ("Preview as Text") node. Ernie Image's subgraph fans a single boundary widget value (e.g. `width`) out to *two* internal targets — `EmptyFlux2LatentImage.width` (a real widget) and a `PreviewAny.source` (a required wildcard `*` input with no widget representation, used to render the value into a prompt-template string). The subgraph-flattening logic only ever tracked the last of several fan-out targets per boundary port, so one of the two was always left completely unconnected. Now every fan-out target is tracked and resolved: widget-type targets get the value written into `widgets_values` as before, and non-widget targets get it injected as a plain literal input value. Also handles unfilled templates (outer `widgets_values` empty) by falling back to the sibling widget target's own template-authored default.
+- Verified against a live ComfyUI server: `/prompt` validation passes with `node_errors: {}`, and an actual Generate run from the GenerateUI tab completes successfully.
+
+### v0.3.83
+
+- **Bug fix: prompts not shown for Flux.2 Klein / Ernie Image workflows** — fixed in the GenerateUI tab, Metadata tab, and sidebar Info tab. Two related patterns weren't detected: (1) `CLIPTextEncode.text` linked to a `PrimitiveStringMultiline` node instead of holding the text directly — the Metadata/Info tab's link resolver only recognized `text`/`text_g`/`prompt` input keys, not `PrimitiveStringMultiline`'s `value` key (GenerateUI's own analysis already handled this). (2) Ernie Image's prompt-enhancement toggle routes the prompt through a `ComfySwitchNode` ("If/Else Switch") that picks between the raw `PrimitiveStringMultiline` text and an LLM-rewritten version from a `TextGenerate` node — since the LLM output can't be known statically, all three tabs now follow both switch branches and use whichever resolves to a literal string (i.e. the user's original prompt).
+- **Help & format notes updated** — GenerateUI/Metadata tab help text and the Metadata tab's "supported formats" note now include Ernie Image alongside the existing subgraph-workflow entries (EN/JA/ZH).
+
+### v0.3.82
+
+- **GenerateUI tab — Flux.2 Klein / LongCat / Boogu / HiDream E1 / FireRed Image Edit workflow support** — these use ComfyUI's Guider-based "Advanced Sampling" pattern (`SamplerCustomAdvanced`/`SamplerCustom` + `CFGGuider`/`DualCFGGuider`/`BasicGuider` + `RandomNoise` + `KSamplerSelect` + `*Scheduler`, spreading seed/steps/cfg/sampler/scheduler across several nodes instead of one `KSampler`) plus model-specific text-encoder nodes (`TextEncodeQwenImageEdit`, `TextEncodeBooguEdit`), none of which the previous KSampler-centric analysis could detect — the Settings/Latent panels showed "no node found" and were unusable. `SamplerCustomAdvanced`/`SamplerCustom` are now resolved back to their driving Guider/Scheduler/KSamplerSelect nodes for editing; `EmptyFlux2LatentImage` is supported in the Latent panel (linked width/height shown blank instead of a stale default).
+- **Bug fix: subgraph `widgets_values` normalization** — rewrote the subgraph-flattening logic that strips linked-widget entries from a template node's `widgets_values`; the previous length-based detection didn't account for the `control_after_generate` extra value that follows `seed`, so on nodes where a linked widget (e.g. `steps`) sits right after `seed` (e.g. `KSampler`), every subsequent widget value ended up shifted by one slot — `cfg`/`denoise` silently got the wrong value. Also fixed a related bug where `EmptyFlux2LatentImage.batch_size` came out as `1024` instead of `1` on Flux.2 Klein workflows.
+- **Bug fix: `Reroute` node caused a 400 error** — `Reroute` is a UI-only passthrough node with no backend node class; including it in the API payload (as happened with HiDream E1's UNETLoader→BasicScheduler/DualCFGGuider fan-out) made ComfyUI reject the prompt with `missing_node_type`. Now resolved through transparently, the same way Bypass-mode nodes already were.
+- **Bug fix: Metadata tab / sidebar Info tab prompt extraction** — these have their own prompt-extraction logic separate from GenerateUI's analysis, and it hadn't kept up: PNG metadata is read from the `prompt` chunk (already API-format) before `workflow`, so the text-encoder scan needed to recognize the `prompt` input key (used by `TextEncodeQwenImageEdit`/`TextEncodeBooguEdit`, not just `text`/`text_g`), resolve `SamplerCustomAdvanced` through its Guider node to find positive/negative, handle `TextEncodeBooguEdit`'s single-node prompt+negative_prompt layout, and follow one extra hop through `InstructPixToPixConditioning`. Without these, prompts from LongCat/Boogu/FireRed/Qwen-Image-Edit-2509/2511 images showed up empty even though the same image loaded correctly into GenerateUI.
+- **Help & format notes updated** — GenerateUI/Metadata tab help text and the Metadata tab's "supported formats" note now list LongCat/Boogu/HiDream E1/FireRed alongside the existing Flux.2/Qwen-Image/Z-Image/Mage-Flow entries (EN/JA/ZH).
+
 ### v0.3.80
 
 - **Comic Creator — Semi-Automatic Manga bridges** — added `window._wfmReceiveLLMPromptRequest(context)` and `window._wfmReceiveGenerateRequest(prompt, width, height)` (`gallery-tab.js`), following the same "assign to `window`, called across the iframe boundary" pattern as the existing I2I/Inpaint bridges. The LLM bridge drafts an image-generation prompt from scene/character/dialogue context using the AI tab's existing Ollama/LM Studio connection logic (`callLLM`/`loadAiSettings`/`isValidBackendUrl`, now exported from `ai-tab.js`); the generate bridge runs a txt2img generation with the workflow currently loaded in the GenerateUI tab, writing the requested width/height into the detected `EmptyLatentImage`/`EmptySD3LatentImage` node the same way the Settings tab's Latent Image panel does, and returns the result image URL.

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-workflow-studio"
 description = "A comprehensive workflow, asset management, and generation UI plugin for ComfyUI. Manage workflows, models, images, and prompts; batch generation and Image Feeder in the GenerateUI tab; library side panel with canvas drag & drop and AI tools."
-version = "0.3.80"
+version = "0.3.84"
 license = "MIT"
 requires-python = ">= 3.10"
 dependencies = ["jinja2"]

static/js/comfyui-editor.js

@@ -367,7 +367,7 @@ export const comfyEditor = {
                 <label>Positive Prompt</label>
                 <div style="display:flex;gap:8px;margin-bottom:6px;">
                     <select id="wfm-prompt-pos-target" class="wfm-select" style="width:auto;flex:1;min-width:0;">
-                        ${positiveNodes.map((n) => `<option value="${n.id}" data-text-key="${n.textKey || "text"}" selected>ID:${n.id} (${n.title})</option>`).join("")}
+                        ${positiveNodes.map((n, i) => `<option value="${n.id}" data-text-key="${n.textKey || "text"}" ${i === 0 ? "selected" : ""}>ID:${n.id} (${n.title})</option>`).join("")}
                         ${nodeOpts}
                     </select>
                     <button class="wfm-btn wfm-btn-sm" id="wfm-prompt-pos-revert" title="${t("revertPromptTitle")}">↺</button>
@@ -379,7 +379,7 @@ export const comfyEditor = {
                 <label>Negative Prompt</label>
                 <div style="display:flex;gap:8px;margin-bottom:6px;">
                     <select id="wfm-prompt-neg-target" class="wfm-select" style="width:auto;flex:1;min-width:0;">
-                        ${negativeNodes.map((n) => `<option value="${n.id}" data-text-key="${n.textKey || "text"}" selected>ID:${n.id} (${n.title})</option>`).join("")}
+                        ${negativeNodes.map((n, i) => `<option value="${n.id}" data-text-key="${n.textKey || "text"}" ${i === 0 ? "selected" : ""}>ID:${n.id} (${n.title})</option>`).join("")}
                         ${nodeOpts}
                     </select>
                     <button class="wfm-btn wfm-btn-sm" id="wfm-prompt-neg-revert" title="${t("revertPromptTitle")}">↺</button>
@@ -1030,23 +1030,39 @@ export const comfyEditor = {
         const sampler = analysis.sampler_nodes?.[0];
         const latent = analysis.latent_nodes?.[0];
 
+        // "Advanced Sampling" workflows (Flux.1/Flux.2, SD3.5, Chroma...) spread seed/steps/cfg/
+        // sampler/scheduler/denoise across RandomNoise + CFGGuider + KSamplerSelect + a *Scheduler
+        // node instead of one KSampler. sampler.*NodeId (set in analyzeWorkflow) says which real
+        // node each field writes back to; null/"" means that workflow has no such control at all
+        // (e.g. Flux2Scheduler has no named "scheduler" combo) so the field is disabled here.
+        const schedulerAvailable = !!sampler && sampler.schedulerNodeId != null;
+        const denoiseAvailable = !!sampler && sampler.denoiseNodeId != null;
+
         el.innerHTML = `
             <div style="display:flex;flex-direction:row;gap:0;align-items:flex-start;">
                 <div style="flex:1;min-width:0;padding-right:14px;border-right:1px solid var(--wfm-border);">
-                    <h3 style="font-size:13px;font-weight:600;text-transform:uppercase;letter-spacing:0.5px;color:var(--wfm-text-secondary);margin:0 0 12px;">KSampler</h3>
+                    <h3 style="font-size:13px;font-weight:600;text-transform:uppercase;letter-spacing:0.5px;color:var(--wfm-text-secondary);margin:0 0 12px;">${sampler?.advanced ? "Sampler (Advanced)" : "KSampler"}</h3>
                     ${sampler ? `
-                    <input type="hidden" id="wfm-settings-sampler-id" value="${sampler.id}" data-seed-key="${sampler.seedKey || "seed"}">
+                    <input type="hidden" id="wfm-settings-sampler-id"
+                        data-seed-key="${sampler.seedKey || "seed"}"
+                        data-seed-node-id="${sampler.seedNodeId ?? sampler.id}"
+                        data-steps-node-id="${sampler.stepsNodeId ?? sampler.id}"
+                        data-cfg-key="${sampler.cfgKey || "cfg"}"
+                        data-cfg-node-id="${sampler.cfgNodeId ?? sampler.id}"
+                        data-sampler-node-id="${sampler.samplerNodeId ?? sampler.id}"
+                        data-scheduler-node-id="${sampler.schedulerNodeId ?? ""}"
+                        data-denoise-node-id="${sampler.denoiseNodeId ?? ""}">
                     <div class="wfm-form-group">
                         <label>Seed</label>
-                        <input type="number" class="wfm-input" id="wfm-settings-seed" value="${sampler.seed ?? -1}">
+                        <input type="number" class="wfm-input" id="wfm-settings-seed" value="${sampler.seed ?? ""}" placeholder="${sampler.seed === undefined ? "linked" : ""}">
                     </div>
                     <div class="wfm-form-group">
                         <label>Steps</label>
-                        <input type="number" class="wfm-input" id="wfm-settings-steps" value="${sampler.steps ?? 20}" min="1" max="200">
+                        <input type="number" class="wfm-input" id="wfm-settings-steps" value="${sampler.steps ?? ""}" placeholder="${sampler.steps === undefined ? "linked" : ""}" min="1" max="200">
                     </div>
                     <div class="wfm-form-group">
                         <label>CFG</label>
-                        <input type="number" class="wfm-input" id="wfm-settings-cfg" value="${sampler.cfg ?? 7}" step="0.5" min="0">
+                        <input type="number" class="wfm-input" id="wfm-settings-cfg" value="${sampler.cfg ?? ""}" placeholder="${sampler.cfg === undefined ? "linked" : ""}" step="0.5" min="0">
                     </div>
                     <div class="wfm-form-group">
                         <label>Sampler</label>
@@ -1056,13 +1072,15 @@ export const comfyEditor = {
                     </div>
                     <div class="wfm-form-group">
                         <label>Scheduler</label>
-                        <select class="wfm-select" id="wfm-settings-scheduler">
-                            ${this.models.schedulers.map((s) => `<option value="${s}" ${s === sampler.scheduler ? "selected" : ""}>${s}</option>`).join("")}
+                        <select class="wfm-select" id="wfm-settings-scheduler" ${schedulerAvailable ? "" : "disabled"}>
+                            ${schedulerAvailable
+                                ? this.models.schedulers.map((s) => `<option value="${s}" ${s === sampler.scheduler ? "selected" : ""}>${s}</option>`).join("")
+                                : `<option value="">N/A</option>`}
                         </select>
                     </div>
                     <div class="wfm-form-group">
                         <label>Denoise</label>
-                        <input type="number" class="wfm-input" id="wfm-settings-denoise" value="${sampler.denoise ?? 1.0}" step="0.05" min="0" max="1">
+                        <input type="number" class="wfm-input" id="wfm-settings-denoise" value="${sampler.denoise ?? ""}" placeholder="${denoiseAvailable && sampler.denoise === undefined ? "linked" : ""}" step="0.05" min="0" max="1" ${denoiseAvailable ? "" : "disabled"}>
                     </div>
                     <button class="wfm-btn wfm-btn-sm" id="wfm-settings-sampler-apply" title="Apply (Alt+Click: Apply &amp; Generate)">Apply</button>
                     ` : "<p class='wfm-placeholder'>No KSampler node found</p>"}
@@ -1073,17 +1091,18 @@ export const comfyEditor = {
                     <input type="hidden" id="wfm-settings-latent-id" value="${latent.id}">
                     <div class="wfm-form-group">
                         <label>Width</label>
-                        <input type="number" class="wfm-input" id="wfm-settings-width" value="${latent.width ?? 512}" step="8" min="64">
+                        <input type="number" class="wfm-input" id="wfm-settings-width" value="${latent.width ?? ""}" placeholder="${latent.width === undefined ? "linked" : ""}" step="8" min="64">
                     </div>
                     <div class="wfm-form-group">
                         <label>Height</label>
-                        <input type="number" class="wfm-input" id="wfm-settings-height" value="${latent.height ?? 512}" step="8" min="64">
+                        <input type="number" class="wfm-input" id="wfm-settings-height" value="${latent.height ?? ""}" placeholder="${latent.height === undefined ? "linked" : ""}" step="8" min="64">
                     </div>
                     <div class="wfm-form-group">
                         <label>Batch Size</label>
                         <input type="number" class="wfm-input" id="wfm-settings-batch" value="${latent.batch_size ?? 1}" min="1" max="64">
                     </div>
                     <button class="wfm-btn wfm-btn-sm" id="wfm-settings-latent-apply">Apply</button>
+                    ${latent.width === undefined || latent.height === undefined ? `<p class="wfm-placeholder" style="margin-top:6px;">Width/Height is linked to another node (e.g. auto-follows the input image) — leave blank to keep it linked.</p>` : ""}
                     <div style="margin-top:10px;border-top:1px solid var(--wfm-border);padding-top:10px;">
                         <div style="display:flex;flex-wrap:wrap;gap:4px;margin-bottom:8px;">
                             ${[512, 768, 1024, 2048].map((s) => `<button class="wfm-btn wfm-btn-sm wfm-latent-sq-btn" data-size="${s}">${s}</button>`).join("")}
@@ -1109,17 +1128,21 @@ export const comfyEditor = {
         `;
 
         document.getElementById("wfm-settings-sampler-apply")?.addEventListener("click", (e) => {
-            const nodeId = document.getElementById("wfm-settings-sampler-id")?.value;
-            if (!nodeId || !comfyUI.currentWorkflow?.[nodeId]) return;
-            const inputs = comfyUI.currentWorkflow[nodeId].inputs;
-            // KSamplerAdvanced uses noise_seed; fall back to seed
-            const seedKey = document.getElementById("wfm-settings-sampler-id")?.dataset?.seedKey || "seed";
-            inputs[seedKey] = parseInt(document.getElementById("wfm-settings-seed")?.value) || -1;
-            inputs.steps = parseInt(document.getElementById("wfm-settings-steps")?.value) || 20;
-            inputs.cfg = parseFloat(document.getElementById("wfm-settings-cfg")?.value) || 7;
-            inputs.sampler_name = document.getElementById("wfm-settings-sampler-name")?.value;
-            inputs.scheduler = document.getElementById("wfm-settings-scheduler")?.value;
-            inputs.denoise = parseFloat(document.getElementById("wfm-settings-denoise")?.value) || 1.0;
+            const ds = document.getElementById("wfm-settings-sampler-id")?.dataset || {};
+            const write = (nodeId, key, value) => {
+                if (!nodeId || !comfyUI.currentWorkflow?.[nodeId]) return;
+                comfyUI.currentWorkflow[nodeId].inputs[key] = value;
+            };
+            const seedEl = document.getElementById("wfm-settings-seed");
+            if (seedEl?.value !== "") write(ds.seedNodeId, ds.seedKey || "seed", parseInt(seedEl.value) || -1);
+            const stepsEl = document.getElementById("wfm-settings-steps");
+            if (stepsEl?.value !== "") write(ds.stepsNodeId, "steps", parseInt(stepsEl.value) || 20);
+            const cfgEl = document.getElementById("wfm-settings-cfg");
+            if (cfgEl?.value !== "") write(ds.cfgNodeId, ds.cfgKey || "cfg", parseFloat(cfgEl.value) || 7);
+            write(ds.samplerNodeId, "sampler_name", document.getElementById("wfm-settings-sampler-name")?.value);
+            if (ds.schedulerNodeId) write(ds.schedulerNodeId, "scheduler", document.getElementById("wfm-settings-scheduler")?.value);
+            const denoiseEl = document.getElementById("wfm-settings-denoise");
+            if (ds.denoiseNodeId && denoiseEl?.value !== "") write(ds.denoiseNodeId, "denoise", parseFloat(denoiseEl.value) || 1.0);
             _syncRawJson();
             if (e.altKey) document.dispatchEvent(new CustomEvent("wfm:apply-and-generate"));
         });
@@ -1128,8 +1151,11 @@ export const comfyEditor = {
             const nodeId = document.getElementById("wfm-settings-latent-id")?.value;
             if (!nodeId || !comfyUI.currentWorkflow?.[nodeId]) return;
             const inputs = comfyUI.currentWorkflow[nodeId].inputs;
-            inputs.width = parseInt(document.getElementById("wfm-settings-width")?.value) || 512;
-            inputs.height = parseInt(document.getElementById("wfm-settings-height")?.value) || 512;
+            const wEl = document.getElementById("wfm-settings-width");
+            const hEl = document.getElementById("wfm-settings-height");
+            // Blank = leave the (linked) width/height alone instead of clobbering it with a default
+            if (wEl?.value !== "") inputs.width = parseInt(wEl.value) || 512;
+            if (hEl?.value !== "") inputs.height = parseInt(hEl.value) || 512;
             inputs.batch_size = parseInt(document.getElementById("wfm-settings-batch")?.value) || 1;
             _syncRawJson();
         });

static/js/comfyui-workflow.js

@@ -18,31 +18,42 @@ let _lastBypassedNodes = [];
 let _lastMutedNodes = [];
 
 /**
- * Trace a link's source through any Bypass-mode (mode 4) nodes, matching each bypassed
- * node's output slot to an input slot of the same type and following the connection
- * upstream (recursively, for chained bypasses). Mirrors ComfyUI's own Bypass behavior,
- * where a bypassed node is removed but its wires are reconnected end-to-end.
+ * Trace a link's source through any Bypass-mode (mode 4) nodes AND Reroute nodes, matching each
+ * one's output slot to an input slot of the same type and following the connection upstream
+ * (recursively, for chains of either/both). Mirrors ComfyUI's own Bypass behavior, where a
+ * bypassed node is removed but its wires are reconnected end-to-end — Reroute needs the identical
+ * treatment because it's a UI-only passthrough node with no backend node class at all: leaving it
+ * in the API payload makes ComfyUI reject the whole prompt with "missing_node_type" (Reroute
+ * always has to be resolved through, regardless of its mode).
  * Returns null when no pass-through source exists (the matching input is unconnected),
  * in which case the caller should treat the input as unlinked.
  */
 function _resolveBypassSource(nodeById, linkMap, nodeId, slot, visited) {
     const idStr = String(nodeId);
     const node = nodeById[idStr];
-    if (!node || node.mode !== 4) return [idStr, slot];
-    if (visited.has(idStr)) return null; // circular bypass chain guard
+    if (!node || (node.mode !== 4 && node.type !== "Reroute")) return [idStr, slot];
+    if (visited.has(idStr)) return null; // circular bypass/reroute chain guard
 
     visited.add(idStr);
     const outputs = node.outputs || [];
     const inputs = node.inputs || [];
-    const outType = outputs[slot]?.type;
 
-    let inIdx = -1;
-    if (inputs[slot]?.type === outType && linkMap[idStr]?.[slot]) {
-        inIdx = slot;
+    let inIdx;
+    if (node.type === "Reroute") {
+        // Reroute is always exactly one input -> one output. Its stored input type is commonly
+        // the generic "*" even when the output shows the propagated concrete type (e.g. MODEL),
+        // so the type-match search used for Bypass below would fail to find it — just take the
+        // sole input.
+        inIdx = 0;
     } else {
-        inIdx = inputs.findIndex((inp, i) => inp.type === outType && linkMap[idStr]?.[i]);
+        const outType = outputs[slot]?.type;
+        if (inputs[slot]?.type === outType && linkMap[idStr]?.[slot]) {
+            inIdx = slot;
+        } else {
+            inIdx = inputs.findIndex((inp, i) => inp.type === outType && linkMap[idStr]?.[i]);
+        }
     }
-    if (inIdx === -1) return null;
+    if (inIdx === -1 || inIdx === undefined) return null;
 
     const upstream = linkMap[idStr][inIdx];
     if (!upstream) return null;
@@ -170,6 +181,124 @@ function _isExtraWidgetValue(val, expectedType) {
     return false;
 }
 
+/**
+ * True when a subgraph-template node's widget input (by name) is actually wired end-to-end —
+ * either redirected from an outer parent-graph link, or wired to another internal node within the
+ * same subgraph template (boundary links from the subgraph's own input ports, origin_id === -10,
+ * don't count: those resolve to a plain injected widget value instead, handled separately).
+ */
+function _isLinkedWidgetName(remappedNode, sgDef, origInternalId, redirectedTargets, name) {
+    const inputDef = (remappedNode.inputs || []).find((i) => i.widget && i.name === name);
+    if (!inputDef) return false;
+    const slotIdx = remappedNode.inputs.indexOf(inputDef);
+    if (redirectedTargets.has(`${remappedNode.id}:${slotIdx}`)) return true;
+    return inputDef.link != null && (sgDef.links || []).some(
+        (l) => l.id === inputDef.link && String(l.target_id) === origInternalId && l.target_slot === slotIdx && l.origin_id !== -10
+    );
+}
+
+/**
+ * Simulate consuming widgets_values against object_info's widget name/type order, accounting for
+ * frontend-only "control_after_generate" extras (e.g. "fixed" after a seed) that occupy one extra
+ * slot and shift every later index by one. When skipLinked is true, widgets the caller's
+ * isLinkedName() flags as linked are treated as consuming zero widgets_values entries (the
+ * "modern" ComfyUI format); with it false, every widget is assumed present (the "legacy full"
+ * format some subgraph templates store). Returns each widget's actual widgets_values index
+ * (or -1 if the array ran out), plus consumedIndices — every index a widget's own turn advanced
+ * past (normally just its value, but two when a control_after_generate extra was skipped) — and
+ * how many entries were consumed in total (the latter is how callers detect which of the two
+ * formats a given widgets_values array actually follows).
+ *
+ * consumedIndices matters because convertUiToApi's own widget-mapping loop only skips a
+ * control_after_generate extra while advancing past the *next* widget's turn (see its
+ * `!linkedSlotNames.has(name)` branch) — if that next widget turns out to be linked, the loop
+ * `continue`s before ever looking at the extra, leaving it unconsumed and silently misread as the
+ * value of whatever non-linked widget comes after. Stripping a linked widget's position alone
+ * (without its swallowed extra) reproduces exactly that bug one level up, in the injection step.
+ */
+function _simulateWidgetValues(widgetNames, widgetTypes, widgetsValues, isLinkedName, skipLinked) {
+    let idx = 0;
+    const positions = {};
+    const consumedIndices = {};
+    for (let nIdx = 0; nIdx < widgetNames.length; nIdx++) {
+        const name = widgetNames[nIdx];
+        if (skipLinked && isLinkedName(name)) {
+            positions[name] = -1;
+            consumedIndices[name] = [];
+            continue;
+        }
+        if (idx >= widgetsValues.length) {
+            positions[name] = -1;
+            consumedIndices[name] = [];
+            continue;
+        }
+        const consumed = [idx];
+        let p = idx;
+        idx++;
+        if (_isExtraWidgetValue(widgetsValues[p], widgetTypes[nIdx]) && idx < widgetsValues.length) {
+            consumed.push(idx);
+            p = idx;
+            idx++;
+        }
+        positions[name] = p;
+        consumedIndices[name] = consumed;
+    }
+    return { positions, consumedIndices, consumed: idx };
+}
+
+/**
+ * Strip a subgraph-template node's widgets_values entries belonging to widget slots that are
+ * actually linked (see _isLinkedWidgetName), so convertUiToApi's own widget-mapping loop — which
+ * assumes the "modern" format where linked widgets contribute zero widgets_values entries — maps
+ * every remaining widget to the right value instead of drifting by however many linked entries
+ * were left in place. No-op when widgets_values already follows the modern format (nothing to
+ * strip) or the node has no widget inputs at all.
+ */
+function _stripLegacyLinkedWidgetValues(objectInfo, remappedNode, sgDef, origInternalId, redirectedTargets) {
+    const widgetsValues = remappedNode.widgets_values;
+    const allWidgetInputs = (remappedNode.inputs || []).filter((i) => i.widget);
+    if (!widgetsValues || allWidgetInputs.length === 0) return;
+
+    const widgetNames = _getWidgetInputNames(objectInfo, remappedNode.type);
+    const widgetTypes = _getWidgetInputTypes(objectInfo, remappedNode.type);
+    const isLinkedName = (name) => _isLinkedWidgetName(remappedNode, sgDef, origInternalId, redirectedTargets, name);
+
+    // If skipping linked widgets already accounts for every entry, widgets_values is already in
+    // the modern (no dangling linked entries) format — nothing to strip.
+    const skipSim = _simulateWidgetValues(widgetNames, widgetTypes, widgetsValues, isLinkedName, true);
+    if (skipSim.consumed === widgetsValues.length) return;
+
+    // Otherwise it's "legacy full": recompute with every widget present to find exactly which
+    // indices the linked ones occupy — including any control_after_generate extra a linked
+    // widget's own turn would have consumed, which must be dropped too (see _simulateWidgetValues).
+    const fullSim = _simulateWidgetValues(widgetNames, widgetTypes, widgetsValues, isLinkedName, false);
+    const linkedIdx = new Set();
+    for (const name of widgetNames) {
+        if (isLinkedName(name)) {
+            for (const i of fullSim.consumedIndices[name] || []) linkedIdx.add(i);
+        }
+    }
+    if (linkedIdx.size > 0) {
+        remappedNode.widgets_values = widgetsValues.filter((_, i) => !linkedIdx.has(i));
+    }
+}
+
+/**
+ * Find the widgets_values array index that corresponds to a given widget input name on a
+ * subgraph-template node, for injecting an outer subgraph-node's un-linked widget value into it.
+ * Assumes _stripLegacyLinkedWidgetValues has already normalized widgets_values to the modern
+ * format (linked widgets contribute zero entries), matching what convertUiToApi's own
+ * widget-mapping loop expects.
+ */
+function _findInjectedWidgetIndex(objectInfo, remappedNode, sgDef, origInternalId, redirectedTargets, targetName) {
+    const widgetNames = _getWidgetInputNames(objectInfo, remappedNode.type);
+    const widgetTypes = _getWidgetInputTypes(objectInfo, remappedNode.type);
+    const widgetsValues = remappedNode.widgets_values || [];
+    const isLinkedName = (name) => _isLinkedWidgetName(remappedNode, sgDef, origInternalId, redirectedTargets, name);
+    const sim = _simulateWidgetValues(widgetNames, widgetTypes, widgetsValues, isLinkedName, true);
+    return sim.positions[targetName] ?? -1;
+}
+
 /**
  * Flatten a subgraph-containing UI workflow into a plain UI workflow.
  *
@@ -226,16 +355,20 @@ function _flattenSubgraphs(workflow, objectInfo) {
         }
 
         // === Map subgraph input ports → internal target {nodeId, slot} ===
+        // A single boundary port can fan out to MULTIPLE internal targets (e.g. a "width" pin
+        // feeding both EmptyFlux2LatentImage.width as a widget AND a PreviewAny.source wildcard
+        // link purely for canvas display) — collect all of them, not just the last one seen.
         const inputPortTargets = {};
         for (let portIdx = 0; portIdx < (sgDef.inputs || []).length; portIdx++) {
             const port = sgDef.inputs[portIdx];
             for (const linkId of (port.linkIds || [])) {
                 const iLink = (sgDef.links || []).find(l => l.id === linkId);
                 if (iLink && iLink.origin_id === -10) {
-                    inputPortTargets[portIdx] = {
+                    if (!inputPortTargets[portIdx]) inputPortTargets[portIdx] = [];
+                    inputPortTargets[portIdx].push({
                         targetNodeId: nodeIdRemap[iLink.target_id],
                         targetSlot: iLink.target_slot,
-                    };
+                    });
                 }
             }
         }
@@ -270,7 +403,11 @@ function _flattenSubgraphs(workflow, objectInfo) {
                     ? (sgDef.inputs || []).findIndex(p => p.name === inputName)
                     : -1;
                 if (portIdx === -1) portIdx = dstSlot;
-                const target = inputPortTargets[portIdx];
+                // Only the port's first fanned-out target is redirected here (a real outer link
+                // feeding a fanned-out port is rare — not seen in any known template so far).
+                // The far more common case (an outer *widget value*, no real link, fanning out to
+                // multiple internal targets) is handled fully below, for every target.
+                const target = inputPortTargets[portIdx]?.[0];
                 if (target) {
                     link[3] = target.targetNodeId;
                     link[4] = target.targetSlot;
@@ -289,80 +426,102 @@ function _flattenSubgraphs(workflow, objectInfo) {
 
         // === Add internal nodes (remapped IDs) ===
         const remappedByOrigId = {};
-        const normalizedNodeIds = new Set();
         for (const iNode of sgDef.nodes) {
             const remapped = JSON.parse(JSON.stringify(iNode));
             remapped.id = nodeIdRemap[iNode.id];
 
-            // Some subgraph-template nodes store widgets_values in the "legacy full" format
-            // (one entry per widget input, including linked ones), while convertUiToApi's
-            // widget-mapping loop assumes the "modern" format (linked widget inputs have no
-            // entry at all). Detect the full format by comparing lengths and strip the
-            // entries belonging to inputs that are *actually* linked end-to-end (per
-            // redirectedTargets above) so downstream mapping stays index-aligned. Boundary
-            // links that terminate in a plain widget value (e.g. prompt text) are NOT
-            // stripped — their value lives in the outer node's widgets_values instead and
-            // is injected below.
-            const allWidgetInputs = (remapped.inputs || []).filter((i) => i.widget);
-            if (remapped.widgets_values && remapped.widgets_values.length === allWidgetInputs.length) {
-                const linkedIdx = new Set();
-                allWidgetInputs.forEach((inp, i) => {
-                    const slotIdx = remapped.inputs.indexOf(inp);
-                    if (redirectedTargets.has(`${remapped.id}:${slotIdx}`)) linkedIdx.add(i);
-                });
-                if (linkedIdx.size > 0) {
-                    remapped.widgets_values = remapped.widgets_values.filter((_, i) => !linkedIdx.has(i));
-                    normalizedNodeIds.add(remapped.id);
-                }
+            // Propagate the outer subgraph-node's Mute/Bypass mode onto every internal node.
+            // Without this, muting or bypassing a whole subgraph instance (e.g. disabling one of
+            // several parallel Flux.2 sampling pipelines via Ctrl-B) leaves its internal nodes at
+            // their template-authored mode (normally 0/enabled), so convertUiToApi's mode check
+            // below never excludes them — they end up in the API payload and can be picked up by
+            // node-existence-based UI logic (e.g. "first matching node found") ahead of the nodes
+            // actually driving the enabled pipeline.
+            if (node.mode === 2 || node.mode === 4) {
+                remapped.mode = node.mode;
             }
 
+            // Some subgraph-template nodes store widgets_values in the "legacy full" format (one
+            // entry per widget input, including ones that are actually linked — either redirected
+            // from an outer parent-graph link, or wired to another internal node within the same
+            // subgraph template, e.g. EmptyFlux2LatentImage.width <- GetImageSize). Strip those
+            // entries so convertUiToApi's widget-mapping loop (which assumes the "modern" format:
+            // linked widgets contribute zero entries) doesn't drift every subsequent widget by
+            // however many linked entries were left in place — see _stripLegacyLinkedWidgetValues.
+            // Boundary links that terminate in a plain widget value (e.g. prompt text) are NOT
+            // treated as linked here — those resolve via the outer-value injection step below.
+            _stripLegacyLinkedWidgetValues(objectInfo, remapped, sgDef, String(iNode.id), redirectedTargets);
+
             addedNodes.push(remapped);
             remappedByOrigId[iNode.id] = remapped;
         }
 
         // === Inject outer subgraph-node widget values into internal nodes ===
-        // Only un-linked widget inputs — linked ones are already redirected above.
+        // Only un-linked widget inputs — linked ones are already redirected above. A port can fan
+        // out to several internal targets (see inputPortTargets collection above) — apply the same
+        // value to every one of them, not just the first. Iterating per PORT (rather than per
+        // outer widget) matters for unfilled templates whose outer widgets_values is empty ([]) —
+        // there is then no outer override to apply, but the fan-out's widget-type target (e.g.
+        // EmptyFlux2LatentImage.width) still holds its own template-authored default, and that
+        // same value is what a sibling non-widget target (e.g. a PreviewAny used to render the
+        // value into a text template) needs too.
         const outerWidgetInputs = (node.inputs || []).filter((inp) => inp.widget);
-        outerWidgetInputs.forEach((inp, widgetIdx) => {
-            if (inp.link != null) return;
-            if (widgetIdx >= (node.widgets_values || []).length) return;
-            const outerValue = node.widgets_values[widgetIdx];
+        for (let portIdx = 0; portIdx < (sgDef.inputs || []).length; portIdx++) {
+            const targets = inputPortTargets[portIdx];
+            if (!targets || targets.length === 0) continue;
 
-            const portIdx = (sgDef.inputs || []).findIndex((p) => p.name === inp.name);
-            if (portIdx === -1) return;
-            const target = inputPortTargets[portIdx];
-            if (!target) return;
+            const port = sgDef.inputs[portIdx];
+            const outerInp = outerWidgetInputs.find((inp) => inp.name === port.name);
+            const outerWidgetIdx = outerInp ? outerWidgetInputs.indexOf(outerInp) : -1;
+            const hasOuterOverride = !!outerInp && outerInp.link == null && outerWidgetIdx !== -1
+                && outerWidgetIdx < (node.widgets_values || []).length;
+            const outerValue = hasOuterOverride ? node.widgets_values[outerWidgetIdx] : undefined;
 
-            const origInternalId = String(target.targetNodeId).split(":").pop();
-            const remappedNode = remappedByOrigId[origInternalId];
-            if (!remappedNode) return;
+            // Value to apply to non-widget (wildcard) fan-out targets: the outer override if
+            // present, otherwise whatever a sibling widget-type target ends up holding (its own
+            // unmodified template default, when there is no outer override).
+            let fallbackLiteral = outerValue;
 
-            const targetInputDef = (remappedNode.inputs || [])[target.targetSlot];
-            if (!targetInputDef?.widget) return;
+            for (const target of targets) {
+                const origInternalId = String(target.targetNodeId).split(":").pop();
+                const remappedNode = remappedByOrigId[origInternalId];
+                if (!remappedNode) continue;
+                const targetInputDef = (remappedNode.inputs || [])[target.targetSlot];
+                if (!targetInputDef?.widget) continue;
 
-            // When the internal node's widgets_values was normalized above (stripped of
-            // linked-slot entries), the index must be computed against that same reduced
-            // set of widget names — object_info's full name order (which still includes
-            // e.g. width/height) would be off by however many entries were stripped.
-            let iWidgetIdx;
-            if (normalizedNodeIds.has(remappedNode.id)) {
-                const remainingNames = (remappedNode.inputs || [])
-                    .filter((i) => i.widget)
-                    .filter((i) => {
-                        const slotIdx = remappedNode.inputs.indexOf(i);
-                        return !redirectedTargets.has(`${remappedNode.id}:${slotIdx}`);
-                    })
-                    .map((i) => i.name);
-                iWidgetIdx = remainingNames.indexOf(targetInputDef.name);
-            } else {
-                const widgetNames = _getWidgetInputNames(objectInfo, remappedNode.type);
-                iWidgetIdx = widgetNames.indexOf(targetInputDef.name);
+                // Compute where in widgets_values this widget's value actually lives — accounting
+                // for linked slots (which consume no entry) and control_after_generate-style
+                // extras (which shift later indices by one). See _findInjectedWidgetIndex for why
+                // a plain name-index lookup silently corrupts sibling widgets here.
+                const iWidgetIdx = _findInjectedWidgetIndex(
+                    objectInfo, remappedNode, sgDef, origInternalId, redirectedTargets, targetInputDef.name
+                );
+                if (iWidgetIdx === -1) continue;
+
+                if (!remappedNode.widgets_values) remappedNode.widgets_values = [];
+                if (hasOuterOverride) remappedNode.widgets_values[iWidgetIdx] = outerValue;
+                if (fallbackLiteral === undefined) fallbackLiteral = remappedNode.widgets_values[iWidgetIdx];
             }
-            if (iWidgetIdx === -1) return;
 
-            if (!remappedNode.widgets_values) remappedNode.widgets_values = [];
-            remappedNode.widgets_values[iWidgetIdx] = outerValue;
-        });
+            if (fallbackLiteral === undefined) continue;
+
+            for (const target of targets) {
+                const origInternalId = String(target.targetNodeId).split(":").pop();
+                const remappedNode = remappedByOrigId[origInternalId];
+                if (!remappedNode) continue;
+                const targetInputDef = (remappedNode.inputs || [])[target.targetSlot];
+                if (!targetInputDef || targetInputDef.widget) continue;
+
+                // Not a widget-representable input — typically a required wildcard ("*") link slot
+                // with no widget UI (e.g. a "Preview as Text" node used to render a width/height
+                // value into a prompt template string). There is no upstream node to link it to
+                // once flattened (the value only ever existed as this outer widget or a sibling
+                // target's own default), so stash it for convertUiToApi() to inject as a plain
+                // literal value instead of a link.
+                if (!remappedNode._wfmLiteralInputs) remappedNode._wfmLiteralInputs = {};
+                remappedNode._wfmLiteralInputs[targetInputDef.name] = fallbackLiteral;
+            }
+        }
 
         // === Add internal links (object format → array format) ===
         for (const iLink of (sgDef.links || [])) {
@@ -459,6 +618,10 @@ export const comfyWorkflow = {
                 _lastBypassedNodes.push({ nodeId: String(node.id), title: node.title || node.type });
                 continue;
             }
+            // Reroute: UI-only passthrough node, no backend node class — including it in the API
+            // payload triggers a "missing_node_type" 400 from ComfyUI. Its wires are already
+            // resolved through via _resolveBypassSource() below, same as a Bypassed node's.
+            if (node.type === "Reroute") continue;
             // Skip note/display-only nodes that are unknown to ComfyUI backend
             if (!objectInfo[node.type] && _isDisplayOnlyNode(node)) continue;
             const nodeId = String(node.id);
@@ -606,6 +769,15 @@ export const comfyWorkflow = {
                 inputs["wildcard_text"] = widgets[0];
             }
 
+            // Literal values for non-widget (e.g. wildcard "*") inputs that a subgraph boundary
+            // widget fanned out to — see the injection step in _flattenSubgraphs for why these
+            // can't be represented as widgets_values entries or resolved as a link.
+            if (node._wfmLiteralInputs) {
+                for (const [k, v] of Object.entries(node._wfmLiteralInputs)) {
+                    if (!(k in inputs)) inputs[k] = v;
+                }
+            }
+
             api[nodeId] = {
                 class_type: node.type,
                 inputs,
@@ -715,15 +887,48 @@ export const comfyWorkflow = {
 
                 // KSamplerAdvanced uses noise_seed instead of seed
                 const seedKey = "seed" in inputs ? "seed" : "noise_seed";
+                const seedVal = inputs.seed ?? inputs.noise_seed;
+                // seed/steps/cfg/denoise are sometimes wired to Primitive nodes (e.g. a shared
+                // "steps" value switched between two LoRA presets) instead of holding a direct
+                // number — leave those undefined so the settings-tab UI shows "linked" instead of
+                // a link-reference array, and Apply doesn't clobber the link with a literal value.
                 result.sampler_nodes.push({
                     id, type: ct, title,
-                    seed: inputs.seed ?? inputs.noise_seed,
-                    seedKey,
-                    steps: inputs.steps, cfg: inputs.cfg,
-                    sampler_name: inputs.sampler_name, scheduler: inputs.scheduler,
-                    denoise: inputs.denoise,
+                    seed: typeof seedVal === "number" ? seedVal : undefined,
+                    seedKey, seedNodeId: id,
+                    steps: typeof inputs.steps === "number" ? inputs.steps : undefined, stepsNodeId: id,
+                    cfg: typeof inputs.cfg === "number" ? inputs.cfg : undefined, cfgNodeId: id,
+                    sampler_name: inputs.sampler_name, samplerNodeId: id,
+                    scheduler: inputs.scheduler, schedulerNodeId: id,
+                    denoise: typeof inputs.denoise === "number" ? inputs.denoise : undefined, denoiseNodeId: id,
                 });
             }
+
+            // CFGGuider / BasicGuider / DualCFGGuider — used by "Advanced Sampling" workflows
+            // (Flux.1/Flux.2, SD3.5, Chroma, HiDream E1, etc.) in place of KSampler's
+            // positive/negative inputs. These feed SamplerCustomAdvanced rather than driving a
+            // sampler themselves, so role propagation must start here too, or CLIPTextEncode
+            // nodes downstream stay "unknown" role.
+            if (ct === "CFGGuider") {
+                if (Array.isArray(inputs.positive)) samplerPositiveRef[inputs.positive[0]] = true;
+                if (Array.isArray(inputs.negative)) samplerNegativeRef[inputs.negative[0]] = true;
+            }
+            if (ct === "BasicGuider") {
+                if (Array.isArray(inputs.conditioning)) samplerPositiveRef[inputs.conditioning[0]] = true;
+            }
+            // DualCFGGuider (HiDream E1 instruct-pix2pix style edit): cond1/cond2 both derive from
+            // the positive text (often via InstructPixToPixConditioning), negative is separate —
+            // cond2 is left unmarked since it doesn't cleanly map to either role.
+            if (ct === "DualCFGGuider") {
+                if (Array.isArray(inputs.cond1)) samplerPositiveRef[inputs.cond1[0]] = true;
+                if (Array.isArray(inputs.negative)) samplerNegativeRef[inputs.negative[0]] = true;
+            }
+            // SamplerCustom (older/simpler counterpart to SamplerCustomAdvanced): holds
+            // positive/negative directly instead of going through a separate Guider node.
+            if (ct === "SamplerCustom") {
+                if (Array.isArray(inputs.positive)) samplerPositiveRef[inputs.positive[0]] = true;
+                if (Array.isArray(inputs.negative)) samplerNegativeRef[inputs.negative[0]] = true;
+            }
         }
 
         // === Pass 1b: Expand refs through CONDITIONING graph (BFS, 5 iterations) ===
@@ -737,6 +942,7 @@ export const comfyWorkflow = {
             "ControlNetApply", "ControlNetApplyAdvanced",
             "IPAdapterApply", "IPAdapterApplyFaceID",
             "StyleModelApply",
+            "FluxGuidance", "FluxKontextMultiReferenceLatentMethod",
         ]);
 
         for (let iter = 0; iter < 5; iter++) {
@@ -791,6 +997,29 @@ export const comfyWorkflow = {
                         }
                     }
                 }
+                // InstructPixToPixConditioning (HiDream E1 edit) — unlike COND_PASSTHROUGH nodes,
+                // this has *separate* positive/negative inputs feeding separate outputs, so each
+                // role must route only to its own input (not both) or the negative CLIPTextEncode
+                // would incorrectly get marked positive too via the positive-output branch.
+                if (ct === "InstructPixToPixConditioning") {
+                    if (isPos && Array.isArray(inputs.positive)) samplerPositiveRef[inputs.positive[0]] = true;
+                    if (isNeg && Array.isArray(inputs.negative)) samplerNegativeRef[inputs.negative[0]] = true;
+                }
+                // ComfySwitchNode ("If/Else Switch", on_false/on_true/switch) — used by Ernie
+                // Image's prompt-enhancement toggle to pick between the raw PrimitiveStringMultiline
+                // text and an LLM-generated (TextGenerate) rewrite. The rewrite can't be known
+                // statically, so propagate the role through both branches — only the branch that
+                // resolves to a literal string source (e.g. PrimitiveStringMultiline) will end up
+                // producing a prompt_nodes entry in Pass 2.
+                if (ct === "ComfySwitchNode") {
+                    for (const key of ["on_false", "on_true"]) {
+                        const tv = inputs[key];
+                        if (Array.isArray(tv)) {
+                            if (isPos) samplerPositiveRef[tv[0]] = true;
+                            if (isNeg) samplerNegativeRef[tv[0]] = true;
+                        }
+                    }
+                }
             }
         }
 
@@ -812,6 +1041,72 @@ export const comfyWorkflow = {
                 return "unknown";
             };
 
+            // --- Advanced Sampler: SamplerCustomAdvanced ---
+            // "Advanced Sampling" pattern used by Flux.1/Flux.2, SD3.5, Chroma, HiDream E1, etc.:
+            // instead of one KSampler node holding seed/steps/cfg/sampler/scheduler, those values
+            // are spread across RandomNoise (noise_seed) → a Guider node (cfg) → KSamplerSelect
+            // (sampler_name) → a *Scheduler node (steps/denoise), all feeding SamplerCustomAdvanced.
+            // Collect them into one composite entry so Settings-tab editing still works; each
+            // value's *NodeId tracks which real node to write back to (null = no such control
+            // exists on this workflow, e.g. Flux2Scheduler has no named "scheduler" combo).
+            if (ct === "SamplerCustomAdvanced") {
+                const noiseId = Array.isArray(inputs.noise) ? String(inputs.noise[0]) : null;
+                const guiderId = Array.isArray(inputs.guider) ? String(inputs.guider[0]) : null;
+                const samplerSelId = Array.isArray(inputs.sampler) ? String(inputs.sampler[0]) : null;
+                const schedulerId = Array.isArray(inputs.sigmas) ? String(inputs.sigmas[0]) : null;
+
+                const noiseInputs = (noiseId && workflow[noiseId]?.inputs) || {};
+                const guiderNode = guiderId ? workflow[guiderId] : null;
+                const guiderInputs = guiderNode?.inputs || {};
+                // DualCFGGuider (HiDream E1 instruct-pix2pix edit) has no plain "cfg" input — its
+                // two CFG knobs are cfg_conds/cfg_cond2_negative. Use cfg_conds as the
+                // representative value so Settings still shows/edits *something* meaningful.
+                const guiderCfgKey = guiderNode?.class_type === "DualCFGGuider" ? "cfg_conds" : "cfg";
+                const samplerSelInputs = (samplerSelId && workflow[samplerSelId]?.inputs) || {};
+                const schedulerInputs = (schedulerId && workflow[schedulerId]?.inputs) || {};
+
+                result.sampler_nodes.push({
+                    id, type: ct, title, advanced: true,
+                    seed: typeof noiseInputs.noise_seed === "number" ? noiseInputs.noise_seed : undefined,
+                    seedKey: "noise_seed", seedNodeId: noiseId,
+                    steps: typeof schedulerInputs.steps === "number" ? schedulerInputs.steps : undefined,
+                    stepsNodeId: schedulerId,
+                    cfg: typeof guiderInputs[guiderCfgKey] === "number" ? guiderInputs[guiderCfgKey] : undefined,
+                    cfgNodeId: guiderCfgKey in guiderInputs ? guiderId : null,
+                    cfgKey: guiderCfgKey,
+                    sampler_name: samplerSelInputs.sampler_name, samplerNodeId: samplerSelId,
+                    scheduler: undefined, schedulerNodeId: "scheduler" in schedulerInputs ? schedulerId : null,
+                    denoise: typeof schedulerInputs.denoise === "number" ? schedulerInputs.denoise : undefined,
+                    denoiseNodeId: "denoise" in schedulerInputs ? schedulerId : null,
+                });
+            }
+
+            // --- Advanced Sampler: SamplerCustom ---
+            // Older/simpler counterpart to SamplerCustomAdvanced: no RandomNoise/Guider
+            // indirection — noise_seed and cfg are its own widgets, and positive/negative feed it
+            // directly. sampler_name/steps/scheduler/denoise still come from separate
+            // KSamplerSelect/*Scheduler nodes via its sampler/sigmas inputs.
+            if (ct === "SamplerCustom") {
+                const samplerSelId = Array.isArray(inputs.sampler) ? String(inputs.sampler[0]) : null;
+                const schedulerId = Array.isArray(inputs.sigmas) ? String(inputs.sigmas[0]) : null;
+                const samplerSelInputs = (samplerSelId && workflow[samplerSelId]?.inputs) || {};
+                const schedulerInputs = (schedulerId && workflow[schedulerId]?.inputs) || {};
+
+                result.sampler_nodes.push({
+                    id, type: ct, title, advanced: true,
+                    seed: typeof inputs.noise_seed === "number" ? inputs.noise_seed : undefined,
+                    seedKey: "noise_seed", seedNodeId: id,
+                    steps: typeof schedulerInputs.steps === "number" ? schedulerInputs.steps : undefined,
+                    stepsNodeId: schedulerId,
+                    cfg: typeof inputs.cfg === "number" ? inputs.cfg : undefined,
+                    cfgNodeId: id,
+                    sampler_name: samplerSelInputs.sampler_name, samplerNodeId: samplerSelId,
+                    scheduler: schedulerInputs.scheduler, schedulerNodeId: "scheduler" in schedulerInputs ? schedulerId : null,
+                    denoise: typeof schedulerInputs.denoise === "number" ? schedulerInputs.denoise : undefined,
+                    denoiseNodeId: "denoise" in schedulerInputs ? schedulerId : null,
+                });
+            }
+
             // --- Checkpoint nodes ---
             // Matches: CheckpointLoaderSimple, CheckpointLoader, "Checkpoint Loader" (WAS), etc.
             if (ct.includes("CheckpointLoader") || ct === "Checkpoint Loader") {
@@ -878,8 +1173,9 @@ export const comfyWorkflow = {
                 }
             }
 
-            // Qwen-based image+text encoder
-            if (ct === "TextEncodeQwenImageEditPlus") {
+            // Qwen-based image+text encoder (Plus variant takes up to 3 reference images;
+            // the base variant takes one — both share the same "prompt" widget)
+            if (ct === "TextEncodeQwenImageEditPlus" || ct === "TextEncodeQwenImageEdit") {
                 result.prompt_nodes.push({
                     id, type: ct, title, role: getRole(),
                     text: inputs.prompt || "",
@@ -887,6 +1183,22 @@ export const comfyWorkflow = {
                 });
             }
 
+            // TextEncodeBooguEdit (Boogu image-edit model) — prompt + negative_prompt in one node
+            if (ct === "TextEncodeBooguEdit") {
+                if (typeof inputs.prompt === "string") {
+                    result.prompt_nodes.push({
+                        id, type: ct, title: `${title} [positive]`, role: "positive",
+                        text: inputs.prompt, textKey: "prompt",
+                    });
+                }
+                if (typeof inputs.negative_prompt === "string") {
+                    result.prompt_nodes.push({
+                        id, type: ct, title: `${title} [negative]`, role: "negative",
+                        text: inputs.negative_prompt, textKey: "negative_prompt",
+                    });
+                }
+            }
+
             // Mage-Flow text encoder — prompt + negative_prompt in one node (fixed roles,
             // unlike KSampler-derived getRole() since both wires originate from this node)
             if (ct === "TextEncodeMageFlowEdit") {
@@ -957,10 +1269,15 @@ export const comfyWorkflow = {
             }
 
             // --- Latent nodes ---
-            if (ct === "EmptyLatentImage" || ct === "EmptySD3LatentImage") {
+            // EmptyFlux2LatentImage (Flux.2 templates) often has width/height wired to a
+            // GetImageSize node (auto-follows the reference image) rather than a direct number —
+            // leave those as undefined, same treatment as TextEncodeMageFlowEdit below, so the
+            // settings-tab UI shows "linked" instead of a stale default and Apply doesn't clobber it.
+            if (ct === "EmptyLatentImage" || ct === "EmptySD3LatentImage" || ct === "EmptyFlux2LatentImage") {
                 result.latent_nodes.push({
                     id, type: ct, title,
-                    width: inputs.width, height: inputs.height,
+                    width: typeof inputs.width === "number" ? inputs.width : undefined,
+                    height: typeof inputs.height === "number" ? inputs.height : undefined,
                     batch_size: inputs.batch_size,
                 });
             }

static/js/i18n.js

@@ -645,7 +645,7 @@ const LANGUAGES = {
         helpWf6: "Detail modal: rename, favorite, thumbnail change, badge assignment, tags, memo, AI summary, send to canvas, load in GenerateUI, set as default, delete",
         helpWf7: "Badge management: add, rename, delete badges with custom colors shared with the Models tab (⚙ Badge button)",
         helpGen1: "Connect/disconnect ComfyUI and check connection status",
-        helpGen2: "Load workflows from Workflow tab (subgraph-containing workflows are supported, e.g. Flux.2 / Qwen-Image / Z-Image / Mage-Flow templates; only ComfyUI's simplified App format [.app.json / Linear Mode] is not); Reset Workflow button re-reads the current workflow file from disk and reloads the editor; Save button (right end of the tab bar) saves the current workflow — including any edits made in the editor — as a new .json file to the Workflow tab; a filename dialog appears with the current workflow name as the default",
+        helpGen2: "Load workflows from Workflow tab (subgraph-containing workflows are supported, e.g. Flux.2 / Qwen-Image / Z-Image / Mage-Flow / LongCat / Boogu / HiDream E1 / FireRed / Ernie Image templates; only ComfyUI's simplified App format [.app.json / Linear Mode] is not); Reset Workflow button re-reads the current workflow file from disk and reloads the editor; Save button (right end of the tab bar) saves the current workflow — including any edits made in the editor — as a new .json file to the Workflow tab; a filename dialog appears with the current workflow name as the default",
         helpGen3: "5-tab layout — Input (Prompt + Image), Model, Settings, Feeder, Batch — Input/Model/Settings each include a Raw JSON column for instant preview and direct editing",
         helpGen4: "Input tab: inner tabs — Prompt and Image (drag-and-drop upload); Prompt tab has Positive Prompt, Negative Prompt, and an Embeddings selector at the bottom — select a model, set Weight (default 1.0), then click Paste to insert (embedding:Name:weight) at the cursor position of the last focused textarea (defaults to Positive if neither is focused); a ↺ button next to each Apply button reverts the textarea to the node's currently applied value; select text (or just place the cursor on a word/parenthesis block) and press Ctrl+↑/↓ to adjust its emphasis weight in (text:weight) syntax by ±0.05 — the parentheses are removed automatically when the weight returns to 1.0",
         helpGen5: "Model tab: Checkpoint, VAE, LoRA (Single/Stack tabs), ControlNet, Diffusion Model (UNETLoader / UnetLoaderGGUF / LoaderGGUF), Text Encoder (CLIPLoader / DualCLIPLoader / ClipLoaderGGUF / DualClipLoaderGGUF — type and device selectors; DualCLIP shows two clip selectors), Hypernetwork (with Strength field) selectors with filter",
@@ -1078,14 +1078,14 @@ const LANGUAGES = {
         metaFmtComfyui: "ComfyUI — PNG / WebP / JSON",
         metaFmtSdwebui: "SD WebUI / SD Forge — PNG (parameters)",
         metaFmtFooocus: "Fooocus — PNG (fooocus_scheme)",
-        metaFormatTodo: "Flux.2 / Qwen-Image / Z-Image subgraph workflows supported",
+        metaFormatTodo: "Flux.2 / Qwen-Image / Z-Image / Mage-Flow / LongCat / Boogu / HiDream E1 / FireRed / Ernie Image subgraph workflows supported",
         helpMetadataTitle: "Metadata Tab",
         helpMetadataDesc: "Drop a ComfyUI-generated PNG/WebP or workflow JSON to instantly extract and view the embedded model and prompt information.",
         helpMetadata1: "Left column: drop zone (image preview for PNG/WebP) and file info; click or drop to load",
         helpMetadata2: "Center column: Checkpoint, VAE, Diffusion Model, and Text Encoder lists extracted from the workflow",
         helpMetadata3: "Right column: LoRA list (with strength values) and Prompt list (click to view full text below)",
         helpMetadata4: "Prompt actions — Copy: copy to clipboard; GenUI:P/N: set GenerateUI positive/negative prompt; Prompt:P/N: set Prompt tab preset positive/negative",
-        helpMetadata5: "Supported: ComfyUI PNG/WebP/JSON (standard + Flux.2 / Qwen-Image / Z-Image / Mage-Flow subgraph workflows), SD WebUI, SD Forge, Fooocus.",
+        helpMetadata5: "Supported: ComfyUI PNG/WebP/JSON (standard + Flux.2 / Qwen-Image / Z-Image / Mage-Flow / LongCat / Boogu / HiDream E1 / FireRed / Ernie Image subgraph workflows), SD WebUI, SD Forge, Fooocus.",
     },
 
     ja: {
@@ -1727,7 +1727,7 @@ const LANGUAGES = {
         helpWf6: "詳細モーダル：名前変更、お気に入り、サムネイル変更、バッジ付与、タグ、メモ、AI要約、キャンバスへ送る、生成UIに読み込み、デフォルト設定、削除",
         helpWf7: "バッジ管理：バッジの追加・名前変更・削除、カスタム色設定（Modelsタブと共有）— ⚙ Badgeボタン",
         helpGen1: "ComfyUIの接続・切断、接続状態の確認",
-        helpGen2: "Workflowタブからワークフローを読み込み（サブグラフを含むワークフローにも対応 — Flux.2 / Qwen-Image / Z-Image / Mage-Flow 等のテンプレート含む；ComfyUIの簡略化App形式 [.app.json / Linear Mode] のみ非対応）。Reset Workflowボタンは現在のワークフローファイルをディスクから再読込してエディタをリロード。Saveボタン（タブバー右端）はエディタでの編集を含む現在のワークフローを新しい.jsonファイルとしてWorkflowタブに保存（現在のワークフロー名を初期値としたファイル名ダイアログを表示）",
+        helpGen2: "Workflowタブからワークフローを読み込み（サブグラフを含むワークフローにも対応 — Flux.2 / Qwen-Image / Z-Image / Mage-Flow / LongCat / Boogu / HiDream E1 / FireRed / Ernie Image 等のテンプレート含む；ComfyUIの簡略化App形式 [.app.json / Linear Mode] のみ非対応）。Reset Workflowボタンは現在のワークフローファイルをディスクから再読込してエディタをリロード。Saveボタン（タブバー右端）はエディタでの編集を含む現在のワークフローを新しい.jsonファイルとしてWorkflowタブに保存（現在のワークフロー名を初期値としたファイル名ダイアログを表示）",
         helpGen3: "5タブ構成 — Input（プロンプト＋画像）、Model、Settings、Feeder、Batch — Input/Model/SettingsタブにはRaw JSON列を常時表示",
         helpGen4: "Inputタブ：Prompt・Imageの内部タブ切り替え；PromptタブにはPositive Prompt・Negative Promptに加え最下部にEmbeddingsセレクタを表示（Filter＋セレクト＋Weight入力＋Pasteボタン）— Pasteは最後にフォーカスしたテキストエリアのカーソル位置に(embedding:Name:weight)を挿入（未フォーカス時はPositiveに追加）；各Applyボタンの左隣の↺ボタンはテキストエリアをノードの現在の適用値に戻す；テキストを選択（または単語・括弧内にカーソルを置くだけでも可）してCtrl+↑/↓を押すと(text:weight)形式で強調weightを±0.05単位で調整（weightが1.0に戻ると括弧を自動解除）",
         helpGen5: "Modelタブ：Checkpoint/VAE/LoRA（Single/Stackタブ）/ControlNet/Diffusion Model（UNETLoader / UnetLoaderGGUF / LoaderGGUF対応）/Text Encoder（CLIPLoader / DualCLIPLoader / ClipLoaderGGUF / DualClipLoaderGGUF対応 — typeおよびdevice選択付き、DualCLIPは2段モデル選択）/Hypernetwork（Strength入力付き）のセレクタ（フィルタ検索付き）",
@@ -2159,14 +2159,14 @@ const LANGUAGES = {
         metaFmtComfyui: "ComfyUI — PNG / WebP / JSON",
         metaFmtSdwebui: "SD WebUI / SD Forge — PNG（parameters チャンク）",
         metaFmtFooocus: "Fooocus — PNG（fooocus_scheme チャンク）",
-        metaFormatTodo: "Flux.2 / Qwen-Image / Z-Image サブグラフ形式に対応済み",
+        metaFormatTodo: "Flux.2 / Qwen-Image / Z-Image / Mage-Flow / LongCat / Boogu / HiDream E1 / FireRed / Ernie Image サブグラフ形式に対応済み",
         helpMetadataTitle: "Metadata タブ",
         helpMetadataDesc: "ComfyUI で生成した PNG / WebP または ワークフロー JSON をドロップすると、埋め込まれたモデル・プロンプト情報を即座に抽出・表示します。",
         helpMetadata1: "左列: ドロップゾーン（PNG/WebP は画像プレビュー表示）＋ファイル情報・対応フォーマット説明",
         helpMetadata2: "中列: ワークフローから抽出した Checkpoint・VAE・Diffusion Model・Text Encoder の一覧",
         helpMetadata3: "右列: LoRA 一覧（強度値付き）＋プロンプト一覧（クリックで下部に全文表示）",
         helpMetadata4: "プロンプトアクション — Copy: クリップボードにコピー; GenUI:P/N: GenerateUI のポジティブ/ネガティブプロンプトにセット; Prompt:P/N: Prompt タブ Presets のポジティブ/ネガティブにセット",
-        helpMetadata5: "対応フォーマット: ComfyUI PNG/WebP/JSON（標準形式 ＋ Flux.2 / Qwen-Image / Z-Image / Mage-Flow サブグラフ形式）・SD WebUI・SD Forge・Fooocus。",
+        helpMetadata5: "対応フォーマット: ComfyUI PNG/WebP/JSON（標準形式 ＋ Flux.2 / Qwen-Image / Z-Image / Mage-Flow / LongCat / Boogu / HiDream E1 / FireRed / Ernie Image サブグラフ形式）・SD WebUI・SD Forge・Fooocus。",
     },
 
     zh: {
@@ -2808,7 +2808,7 @@ const LANGUAGES = {
         helpWf6: "详情弹窗：重命名、收藏、缩略图更换、徽章分配、标签、备注、AI摘要、发送到画布、加载到生成UI、设为默认、删除",
         helpWf7: "徽章管理：添加、重命名、删除徽章并自定义颜色（与Models标签共享）— ⚙ Badge按钮",
         helpGen1: "连接/断开ComfyUI，检查连接状态",
-        helpGen2: "从工作流标签页加载工作流（支持含子图的工作流，例如 Flux.2 / Qwen-Image / Z-Image / Mage-Flow 等模板；仅不支持ComfyUI的简化App格式 [.app.json / Linear Mode]）。Reset Workflow按钮从磁盘重新读取当前工作流文件并重新加载编辑器。Save按钮（标签栏右端）将当前工作流（包括在编辑器中所做的编辑）保存为新的.json文件到工作流标签页；会显示以当前工作流名称为默认值的文件名对话框",
+        helpGen2: "从工作流标签页加载工作流（支持含子图的工作流，例如 Flux.2 / Qwen-Image / Z-Image / Mage-Flow / LongCat / Boogu / HiDream E1 / FireRed / Ernie Image 等模板；仅不支持ComfyUI的简化App格式 [.app.json / Linear Mode]）。Reset Workflow按钮从磁盘重新读取当前工作流文件并重新加载编辑器。Save按钮（标签栏右端）将当前工作流（包括在编辑器中所做的编辑）保存为新的.json文件到工作流标签页；会显示以当前工作流名称为默认值的文件名对话框",
         helpGen3: "5标签布局 — Input（提示词＋图像）、Model、Settings、Feeder、Batch — Input/Model/Settings各含实时预览和直接编辑的Raw JSON列",
         helpGen4: "Input标签：含Prompt和Image子标签（拖放上传）；Prompt标签显示Positive Prompt、Negative Prompt，以及底部的Embeddings选择器（过滤＋下拉＋权重＋Paste按钮）— Paste将(embedding:Name:weight)插入最后聚焦文本框的光标位置（未聚焦时默认追加到Positive）；每个Apply按钮左侧的↺按钮可将文本框恢复为节点当前已应用的值；选中文字（或将光标置于单词/括号内也可）后按Ctrl+↑/↓，即可以(text:weight)语法以±0.05为单位调整强调权重（权重恢复为1.0时自动去除括号）",
         helpGen5: "Model标签：Checkpoint/VAE/LoRA（Single/Stack标签）/ControlNet/Diffusion Model（支持UNETLoader / UnetLoaderGGUF / LoaderGGUF）/Text Encoder（支持CLIPLoader / DualCLIPLoader / ClipLoaderGGUF / DualClipLoaderGGUF — 含type和device选择器，DualCLIP显示两段模型选择）/Hypernetwork（带Strength输入）选择器（含筛选）",
@@ -3240,14 +3240,14 @@ const LANGUAGES = {
         metaFmtComfyui: "ComfyUI — PNG / WebP / JSON",
         metaFmtSdwebui: "SD WebUI / SD Forge — PNG（parameters）",
         metaFmtFooocus: "Fooocus — PNG（fooocus_scheme）",
-        metaFormatTodo: "已支持 Flux.2 / Qwen-Image / Z-Image 子图工作流",
+        metaFormatTodo: "已支持 Flux.2 / Qwen-Image / Z-Image / Mage-Flow / LongCat / Boogu / HiDream E1 / FireRed / Ernie Image 子图工作流",
         helpMetadataTitle: "Metadata 标签页",
         helpMetadataDesc: "拖放 ComfyUI 生成的 PNG/WebP 或工作流 JSON，即可提取并显示其中的模型和提示词信息。",
         helpMetadata1: "左列：拖放区（PNG/WebP 显示图片预览）及文件信息与支持格式说明",
         helpMetadata2: "中列：从工作流中提取的 Checkpoint、VAE、扩散模型、文本编码器列表",
         helpMetadata3: "右列：LoRA 列表（含强度值）和提示词列表（点击在下方显示全文）",
         helpMetadata4: "提示词操作 — Copy：复制到剪贴板；GenUI:P/N：设置 GenerateUI 正/负向提示；Prompt:P/N：设置 Prompt 标签页预设正/负向提示",
-        helpMetadata5: "支持格式：ComfyUI PNG/WebP/JSON（标准格式 + Flux.2 / Qwen-Image / Z-Image / Mage-Flow 子图工作流）、SD WebUI、SD Forge、Fooocus。",
+        helpMetadata5: "支持格式：ComfyUI PNG/WebP/JSON（标准格式 + Flux.2 / Qwen-Image / Z-Image / Mage-Flow / LongCat / Boogu / HiDream E1 / FireRed / Ernie Image 子图工作流）、SD WebUI、SD Forge、Fooocus。",
     },
 };
 

static/js/metadata-tab.js

@@ -193,6 +193,45 @@ function extractPrompts(wf) {
     return Array.isArray(wf.nodes) ? extractPromptsLiteGraph(wf) : extractPromptsAPI(wf);
 }
 
+// LiteGraph形式: リンクを辿ってテキストを解決（ComfySwitchNode等の中継ノードにも対応）
+function resolveLinkedTextInNodeSet(nodeMap, linkOrigin, linkSlot, srcId, slot, depth = 0) {
+    if (depth > 6) return null;
+    const srcNode = nodeMap.get(srcId);
+    if (!srcNode) return null;
+    const srcType = srcNode.type ?? "";
+    if (isPromptStylerNode(srcType)) {
+        const v = srcNode.widgets_values?.[slot];
+        return (v && typeof v === "string") ? v : null;
+    }
+    // ComfySwitchNode ("If/Else Switch") — 片方(TextGenerateなどLLMノード)は静的解決不能なため
+    // on_false/on_true の両方を試し、リテラルへ解決できた方を採用する。
+    if (srcType === "ComfySwitchNode" && Array.isArray(srcNode.inputs)) {
+        for (const name of ["on_false", "on_true"]) {
+            const inp = srcNode.inputs.find(i => i.name === name);
+            if (inp?.link == null) continue;
+            const originId = linkOrigin.get(inp.link);
+            const originSlot = linkSlot.get(inp.link) ?? 0;
+            if (originId == null) continue;
+            const text = resolveLinkedTextInNodeSet(nodeMap, linkOrigin, linkSlot, originId, originSlot, depth + 1);
+            if (text) return text;
+        }
+        return null;
+    }
+    // WFS_PromptText, PrimitiveStringMultiline 等、任意の STRING 出力ノード
+    const v = srcNode.widgets_values?.[slot] ?? srcNode.widgets_values?.[0];
+    if (v && typeof v === "string") return v;
+    // さらにリンクされている場合（StringReplace等の中継ノード）は追跡する
+    if (Array.isArray(srcNode.inputs)) {
+        const nextInput = srcNode.inputs.find(i => ["text", "value", "prompt", "string"].includes(i.name));
+        if (nextInput?.link != null) {
+            const originId = linkOrigin.get(nextInput.link);
+            const originSlot = linkSlot.get(nextInput.link) ?? 0;
+            if (originId != null) return resolveLinkedTextInNodeSet(nodeMap, linkOrigin, linkSlot, originId, originSlot, depth + 1);
+        }
+    }
+    return null;
+}
+
 // CLIPTextEncode + KSampler でプロンプト抽出（トップレベル・サブグラフ共用）
 // サンプラーが見つかりテキストが取れた場合のみ非null を返す
 function extractPromptsFromNodeSet(nodes, links) {
@@ -221,18 +260,8 @@ function extractPromptsFromNodeSet(nodes, links) {
             if (textInput?.link != null) {
                 const originId = linkOrigin.get(textInput.link);
                 const originSlot = linkSlot.get(textInput.link) ?? 0;
-                const srcNode = originId != null ? nodeMap.get(originId) : null;
-                if (srcNode) {
-                    const srcType = srcNode.type ?? "";
-                    if (isPromptStylerNode(srcType)) {
-                        const v = srcNode.widgets_values?.[originSlot];
-                        if (v && typeof v === "string") textMap.set(n.id, v);
-                    } else {
-                        // WFS_PromptText, PrimitiveStringMultiline, ComfySwitchNode 等、任意の STRING 出力ノード
-                        const v = srcNode.widgets_values?.[originSlot] ?? srcNode.widgets_values?.[0];
-                        if (v && typeof v === "string") textMap.set(n.id, v);
-                    }
-                }
+                const text2 = resolveLinkedTextInNodeSet(nodeMap, linkOrigin, linkSlot, originId, originSlot);
+                if (text2) textMap.set(n.id, text2);
             }
         }
     }
@@ -241,24 +270,46 @@ function extractPromptsFromNodeSet(nodes, links) {
     for (const n of nodes) {
         if (!isSamplerNode(n.type ?? "") || !Array.isArray(n.inputs)) continue;
         foundSampler = true;
-        for (const inp of n.inputs) {
+        // SamplerCustomAdvanced doesn't hold positive/negative directly — it drives a separate
+        // Guider node (CFGGuider/DualCFGGuider/BasicGuider) via its "guider" input. Scan that
+        // node's inputs instead so the loop below can find the positive/negative-role slots.
+        let inputsToScan = n.inputs;
+        const guiderInput = n.inputs.find(inp => inp.name === "guider");
+        if (guiderInput?.link != null) {
+            const guiderId = linkOrigin.get(guiderInput.link);
+            const guiderNode = guiderId != null ? nodeMap.get(guiderId) : null;
+            if (Array.isArray(guiderNode?.inputs)) inputsToScan = guiderNode.inputs;
+        }
+        for (const inp of inputsToScan) {
             if (!inp || inp.link == null) continue;
             const originId = linkOrigin.get(inp.link);
             if (originId == null) continue;
             const name = inp.name ?? "";
-            const isPos = name === "positive" || name.startsWith("positive");
+            // DualCFGGuider (HiDream E1): cond1 carries the positive-derived conditioning.
+            const isPos = name === "positive" || name === "cond1" || name.startsWith("positive");
             const isNeg = name === "negative" || name.startsWith("negative");
             if (!isPos && !isNeg) continue;
-            // TextEncodeMageFlowEdit — one node carries both prompt & negative_prompt
-            // directly, so textMap (single text per node) can't represent both roles.
+            // TextEncodeMageFlowEdit / TextEncodeBooguEdit — one node carries both prompt &
+            // negative_prompt directly, so textMap (single text per node) can't represent both
+            // roles.
             const srcNode = nodeMap.get(originId);
-            if (srcNode?.type === "TextEncodeMageFlowEdit") {
+            if (srcNode?.type === "TextEncodeMageFlowEdit" || srcNode?.type === "TextEncodeBooguEdit") {
                 const widgetIdx = isPos ? 0 : 1; // widgets_values: [prompt, negative_prompt, ...]
                 const text = srcNode.widgets_values?.[widgetIdx];
                 if (text && typeof text === "string") { if (isPos) pos.add(text); else neg.add(text); }
                 continue;
             }
-            const text = textMap.get(originId);
+            // InstructPixToPixConditioning (HiDream E1): forwards the actual text-encoder
+            // conditioning through its own positive/negative inputs — follow one more hop.
+            let resolvedOriginId = originId;
+            if (srcNode?.type === "InstructPixToPixConditioning" && Array.isArray(srcNode.inputs)) {
+                const innerInput = srcNode.inputs.find(i => i.name === (isPos ? "positive" : "negative"));
+                if (innerInput?.link != null) {
+                    const innerId = linkOrigin.get(innerInput.link);
+                    if (innerId != null) resolvedOriginId = innerId;
+                }
+            }
+            const text = textMap.get(resolvedOriginId);
             if (!text) continue;
             if (isPos) pos.add(text); else neg.add(text);
         }
@@ -312,7 +363,8 @@ function extractMarkdownNoteModels(wf) {
 }
 
 // API形式: リンク参照 [srcNodeId, slot] からテキストを解決
-function resolveLinkedText(wf, srcId, slot) {
+function resolveLinkedText(wf, srcId, slot, depth = 0) {
+    if (depth > 6) return null;
     const src = wf[String(srcId)];
     if (!src || typeof src !== "object") return null;
     const ct = src.class_type ?? "";
@@ -321,13 +373,32 @@ function resolveLinkedText(wf, srcId, slot) {
         const v = slot === 0 ? src.inputs?.text_positive : src.inputs?.text_negative;
         return (v && typeof v === "string") ? v : null;
     }
-    // 汎用テキストキー
+    // ComfySwitchNode ("If/Else Switch", on_false/on_true/switch) — Ernie Imageのプロンプト強化
+    // トグルなどで使われる。片方(TextGenerateなどLLMノード)は静的解決不能なため両方試し、
+    // リテラルへ解決できた方を採用する。
+    if (ct === "ComfySwitchNode") {
+        for (const key of ["on_false", "on_true"]) {
+            const v = src.inputs?.[key];
+            if (Array.isArray(v)) {
+                const text = resolveLinkedText(wf, v[0], v[1] ?? 0, depth + 1);
+                if (text) return text;
+            } else if (typeof v === "string" && v) {
+                return v;
+            }
+        }
+        return null;
+    }
+    // 汎用テキストキー（"value" は PrimitiveString/PrimitiveStringMultiline）
     const keys = slot === 0
-        ? ["text_positive", "text", "text_g", "prompt"]
+        ? ["text_positive", "text", "text_g", "prompt", "value"]
         : ["text_negative", "text_l"];
     for (const k of keys) {
         const v = src.inputs?.[k];
-        if (v && typeof v === "string") return v;
+        if (typeof v === "string" && v) return v;
+        if (Array.isArray(v)) {
+            const text = resolveLinkedText(wf, v[0], v[1] ?? 0, depth + 1);
+            if (text) return text;
+        }
     }
     return null;
 }
@@ -342,7 +413,9 @@ function extractPromptsAPI(wf) {
     const textMap = new Map();
     for (const [id, n] of Object.entries(wf)) {
         if (!n || !isTextEncoderNode(n.class_type ?? "")) continue;
-        const raw = n.inputs?.text ?? n.inputs?.text_g ?? null;
+        // "prompt" — TextEncodeQwenImageEdit(Plus)/TextEncodeBooguEdit and similar Image Edit
+        // model text encoders use this key instead of "text"/"text_g".
+        const raw = n.inputs?.text ?? n.inputs?.text_g ?? n.inputs?.prompt ?? null;
         if (raw && typeof raw === "string") {
             textMap.set(id, raw);
         } else if (Array.isArray(raw)) {
@@ -356,20 +429,35 @@ function extractPromptsAPI(wf) {
     for (const n of Object.values(wf)) {
         if (!n || !isSamplerNode(n.class_type ?? "")) continue;
         foundSampler = true;
-        for (const [key, val] of Object.entries(n.inputs ?? {})) {
+        // SamplerCustomAdvanced doesn't hold positive/negative directly — it drives a separate
+        // Guider node (CFGGuider/DualCFGGuider/BasicGuider) via its "guider" input. Scan that
+        // node's inputs instead so the loop below can find the positive/negative-role keys.
+        let inputsToScan = n.inputs ?? {};
+        if (Array.isArray(n.inputs?.guider)) {
+            const guiderNode = wf[String(n.inputs.guider[0])];
+            if (guiderNode?.inputs) inputsToScan = guiderNode.inputs;
+        }
+        for (const [key, val] of Object.entries(inputsToScan)) {
             if (!Array.isArray(val)) continue;
-            const isPos = key === "positive" || key.startsWith("positive");
+            // DualCFGGuider (HiDream E1): cond1 carries the positive-derived conditioning.
+            const isPos = key === "positive" || key === "cond1" || key.startsWith("positive");
             const isNeg = key === "negative" || key.startsWith("negative");
             if (!isPos && !isNeg) continue;
-            // TextEncodeMageFlowEdit — one node carries both prompt & negative_prompt
-            // directly, so textMap (single text per node) can't represent both roles.
+            // TextEncodeMageFlowEdit / TextEncodeBooguEdit — one node carries both prompt &
+            // negative_prompt directly, so textMap (single text per node) can't represent both
+            // roles.
             const srcNode = wf[String(val[0])];
-            if (srcNode?.class_type === "TextEncodeMageFlowEdit") {
+            if (srcNode?.class_type === "TextEncodeMageFlowEdit" || srcNode?.class_type === "TextEncodeBooguEdit") {
                 const text = isPos ? srcNode.inputs?.prompt : srcNode.inputs?.negative_prompt;
                 if (text && typeof text === "string") { if (isPos) pos.add(text); else neg.add(text); }
                 continue;
             }
-            const text = textMap.get(String(val[0]));
+            // InstructPixToPixConditioning (HiDream E1): forwards the actual text-encoder
+            // conditioning through its own positive/negative inputs — follow one more hop.
+            const resolvedId = srcNode?.class_type === "InstructPixToPixConditioning" && Array.isArray(srcNode.inputs?.[isPos ? "positive" : "negative"])
+                ? String(srcNode.inputs[isPos ? "positive" : "negative"][0])
+                : String(val[0]);
+            const text = textMap.get(resolvedId);
             if (!text) continue;
             if (isPos) pos.add(text); else neg.add(text);
         }

web/comfyui/node_sets_menu.js

@@ -2939,6 +2939,41 @@ function _isTextEncoderNode(ct) { return ct === "CLIPTextEncode" || ct.includes(
 function _isSamplerNode(ct) { return ct === "KSampler" || ct === "KSamplerAdvanced" || ct.includes("KSampler") || ct.includes("Sampler"); }
 function _isPromptStylerNode(ct) { return ct.includes("PromptStyler"); }
 
+// LiteGraph形式: リンクを辿ってテキストを解決（ComfySwitchNode等の中継ノードにも対応）
+function _resolveLinkedTextInNodeSet(nodeMap, linkOrigin, linkSlot, srcId, slot, depth = 0) {
+    if (depth > 6) return null;
+    const srcNode = nodeMap.get(srcId);
+    if (!srcNode) return null;
+    const srcType = srcNode.type ?? "";
+    if (_isPromptStylerNode(srcType)) {
+        const v = srcNode.widgets_values?.[slot];
+        return (v && typeof v === "string") ? v : null;
+    }
+    if (srcType === "ComfySwitchNode" && Array.isArray(srcNode.inputs)) {
+        for (const name of ["on_false", "on_true"]) {
+            const inp = srcNode.inputs.find(i => i.name === name);
+            if (inp?.link == null) continue;
+            const originId = linkOrigin.get(inp.link);
+            const originSlot = linkSlot.get(inp.link) ?? 0;
+            if (originId == null) continue;
+            const text = _resolveLinkedTextInNodeSet(nodeMap, linkOrigin, linkSlot, originId, originSlot, depth + 1);
+            if (text) return text;
+        }
+        return null;
+    }
+    const v = srcNode.widgets_values?.[slot] ?? srcNode.widgets_values?.[0];
+    if (v && typeof v === "string") return v;
+    if (Array.isArray(srcNode.inputs)) {
+        const nextInput = srcNode.inputs.find(i => ["text", "value", "prompt", "string"].includes(i.name));
+        if (nextInput?.link != null) {
+            const originId = linkOrigin.get(nextInput.link);
+            const originSlot = linkSlot.get(nextInput.link) ?? 0;
+            if (originId != null) return _resolveLinkedTextInNodeSet(nodeMap, linkOrigin, linkSlot, originId, originSlot, depth + 1);
+        }
+    }
+    return null;
+}
+
 function _extractPromptsFromNodeSet(nodes, links) {
     const nodeMap = new Map();
     for (const n of nodes) nodeMap.set(n.id, n);
@@ -2959,12 +2994,8 @@ function _extractPromptsFromNodeSet(nodes, links) {
             if (textInput?.link != null) {
                 const originId = linkOrigin.get(textInput.link);
                 const originSlot = linkSlot.get(textInput.link) ?? 0;
-                const srcNode = originId != null ? nodeMap.get(originId) : null;
-                if (srcNode) {
-                    const srcType = srcNode.type ?? "";
-                    if (_isPromptStylerNode(srcType)) { const v = srcNode.widgets_values?.[originSlot]; if (v && typeof v === "string") textMap.set(n.id, v); }
-                    else { const v = srcNode.widgets_values?.[originSlot] ?? srcNode.widgets_values?.[0]; if (v && typeof v === "string") textMap.set(n.id, v); }
-                }
+                const text2 = _resolveLinkedTextInNodeSet(nodeMap, linkOrigin, linkSlot, originId, originSlot);
+                if (text2) textMap.set(n.id, text2);
             }
         }
     }
@@ -2973,24 +3004,44 @@ function _extractPromptsFromNodeSet(nodes, links) {
     for (const n of nodes) {
         if (!_isSamplerNode(n.type ?? "") || !Array.isArray(n.inputs)) continue;
         foundSampler = true;
-        for (const inp of n.inputs) {
+        // SamplerCustomAdvanced doesn't hold positive/negative directly — resolve through its
+        // "guider" input (CFGGuider/DualCFGGuider/BasicGuider) instead.
+        let inputsToScan = n.inputs;
+        const guiderInput = n.inputs.find(inp => inp.name === "guider");
+        if (guiderInput?.link != null) {
+            const guiderId = linkOrigin.get(guiderInput.link);
+            const guiderNode = guiderId != null ? nodeMap.get(guiderId) : null;
+            if (Array.isArray(guiderNode?.inputs)) inputsToScan = guiderNode.inputs;
+        }
+        for (const inp of inputsToScan) {
             if (!inp || inp.link == null) continue;
             const originId = linkOrigin.get(inp.link);
             if (originId == null) continue;
             const name = inp.name ?? "";
-            const isPos = name === "positive" || name.startsWith("positive");
+            // DualCFGGuider (HiDream E1): cond1 carries the positive-derived conditioning.
+            const isPos = name === "positive" || name === "cond1" || name.startsWith("positive");
             const isNeg = name === "negative" || name.startsWith("negative");
             if (!isPos && !isNeg) continue;
-            // TextEncodeMageFlowEdit — 1ノードでprompt/negative_prompt両方を直接持つため、
-            // textMap(1ノード1テキスト)では両ロールを表現できない
+            // TextEncodeMageFlowEdit / TextEncodeBooguEdit — 1ノードでprompt/negative_prompt両方を
+            // 直接持つため、textMap(1ノード1テキスト)では両ロールを表現できない
             const srcNode = nodeMap.get(originId);
-            if (srcNode?.type === "TextEncodeMageFlowEdit") {
+            if (srcNode?.type === "TextEncodeMageFlowEdit" || srcNode?.type === "TextEncodeBooguEdit") {
                 const widgetIdx = isPos ? 0 : 1; // widgets_values: [prompt, negative_prompt, ...]
                 const txt = srcNode.widgets_values?.[widgetIdx];
                 if (txt && typeof txt === "string") { if (isPos) pos.add(txt); else neg.add(txt); }
                 continue;
             }
-            const txt = textMap.get(originId);
+            // InstructPixToPixConditioning (HiDream E1): forwards the actual text-encoder
+            // conditioning through its own positive/negative inputs — follow one more hop.
+            let resolvedOriginId = originId;
+            if (srcNode?.type === "InstructPixToPixConditioning" && Array.isArray(srcNode.inputs)) {
+                const innerInput = srcNode.inputs.find(i => i.name === (isPos ? "positive" : "negative"));
+                if (innerInput?.link != null) {
+                    const innerId = linkOrigin.get(innerInput.link);
+                    if (innerId != null) resolvedOriginId = innerId;
+                }
+            }
+            const txt = textMap.get(resolvedOriginId);
             if (!txt) continue;
             if (isPos) pos.add(txt); else neg.add(txt);
         }
@@ -3040,13 +3091,28 @@ function _extractMarkdownNoteModels(wf) {
     return hasAny ? result : null;
 }
 
-function _resolveLinkedText(wf, srcId, slot) {
+function _resolveLinkedText(wf, srcId, slot, depth = 0) {
+    if (depth > 6) return null;
     const src = wf[String(srcId)];
     if (!src || typeof src !== "object") return null;
     const ct = src.class_type ?? "";
     if (_isPromptStylerNode(ct)) { const v = slot === 0 ? src.inputs?.text_positive : src.inputs?.text_negative; return (v && typeof v === "string") ? v : null; }
-    const keys = slot === 0 ? ["text_positive", "text", "text_g", "prompt"] : ["text_negative", "text_l"];
-    for (const k of keys) { const v = src.inputs?.[k]; if (v && typeof v === "string") return v; }
+    // ComfySwitchNode ("If/Else Switch") — 片方(TextGenerateなどLLMノード)は静的解決不能なため
+    // on_false/on_true の両方を試し、リテラルへ解決できた方を採用する。
+    if (ct === "ComfySwitchNode") {
+        for (const key of ["on_false", "on_true"]) {
+            const v = src.inputs?.[key];
+            if (Array.isArray(v)) { const text = _resolveLinkedText(wf, v[0], v[1] ?? 0, depth + 1); if (text) return text; }
+            else if (typeof v === "string" && v) return v;
+        }
+        return null;
+    }
+    const keys = slot === 0 ? ["text_positive", "text", "text_g", "prompt", "value"] : ["text_negative", "text_l"];
+    for (const k of keys) {
+        const v = src.inputs?.[k];
+        if (typeof v === "string" && v) return v;
+        if (Array.isArray(v)) { const text = _resolveLinkedText(wf, v[0], v[1] ?? 0, depth + 1); if (text) return text; }
+    }
     return null;
 }
 
@@ -3060,7 +3126,9 @@ function _extractPromptsAPI(wf) {
     const textMap = new Map();
     for (const [id, n] of Object.entries(wf)) {
         if (!n || !_isTextEncoderNode(n.class_type ?? "")) continue;
-        const raw = n.inputs?.text ?? n.inputs?.text_g ?? null;
+        // "prompt" — TextEncodeQwenImageEdit(Plus)/TextEncodeBooguEdit and similar Image Edit
+        // model text encoders use this key instead of "text"/"text_g".
+        const raw = n.inputs?.text ?? n.inputs?.text_g ?? n.inputs?.prompt ?? null;
         if (raw && typeof raw === "string") { textMap.set(id, raw); }
         else if (Array.isArray(raw)) { const txt = _resolveLinkedText(wf, raw[0], raw[1] ?? 0); if (txt) textMap.set(id, txt); }
     }
@@ -3069,20 +3137,34 @@ function _extractPromptsAPI(wf) {
     for (const n of Object.values(wf)) {
         if (!n || !_isSamplerNode(n.class_type ?? "")) continue;
         foundSampler = true;
-        for (const [key, val] of Object.entries(n.inputs ?? {})) {
+        // SamplerCustomAdvanced doesn't hold positive/negative directly — it drives a separate
+        // Guider node (CFGGuider/DualCFGGuider/BasicGuider) via its "guider" input. Scan that
+        // node's inputs instead so the loop below can find the positive/negative-role keys.
+        let inputsToScan = n.inputs ?? {};
+        if (Array.isArray(n.inputs?.guider)) {
+            const guiderNode = wf[String(n.inputs.guider[0])];
+            if (guiderNode?.inputs) inputsToScan = guiderNode.inputs;
+        }
+        for (const [key, val] of Object.entries(inputsToScan)) {
             if (!Array.isArray(val)) continue;
-            const isPos = key === "positive" || key.startsWith("positive");
+            // DualCFGGuider (HiDream E1): cond1 carries the positive-derived conditioning.
+            const isPos = key === "positive" || key === "cond1" || key.startsWith("positive");
             const isNeg = key === "negative" || key.startsWith("negative");
             if (!isPos && !isNeg) continue;
-            // TextEncodeMageFlowEdit — 1ノードでprompt/negative_prompt両方を直接持つため、
-            // textMap(1ノード1テキスト)では両ロールを表現できない
+            // TextEncodeMageFlowEdit / TextEncodeBooguEdit — 1ノードでprompt/negative_prompt両方を
+            // 直接持つため、textMap(1ノード1テキスト)では両ロールを表現できない
             const srcNode = wf[String(val[0])];
-            if (srcNode?.class_type === "TextEncodeMageFlowEdit") {
+            if (srcNode?.class_type === "TextEncodeMageFlowEdit" || srcNode?.class_type === "TextEncodeBooguEdit") {
                 const txt = isPos ? srcNode.inputs?.prompt : srcNode.inputs?.negative_prompt;
                 if (txt && typeof txt === "string") { if (isPos) pos.add(txt); else neg.add(txt); }
                 continue;
             }
-            const txt = textMap.get(String(val[0]));
+            // InstructPixToPixConditioning (HiDream E1): forwards the actual text-encoder
+            // conditioning through its own positive/negative inputs — follow one more hop.
+            const resolvedId = srcNode?.class_type === "InstructPixToPixConditioning" && Array.isArray(srcNode.inputs?.[isPos ? "positive" : "negative"])
+                ? String(srcNode.inputs[isPos ? "positive" : "negative"][0])
+                : String(val[0]);
+            const txt = textMap.get(resolvedId);
             if (!txt) continue;
             if (isPos) pos.add(txt); else neg.add(txt);
         }