comfyui-mcp 0.48.21 → 0.48.23

package/dist/services/workflow-converter.js

@@ -9,6 +9,32 @@ export function isUiFormat(obj) {
     const record = obj;
     return Array.isArray(record.nodes) && Array.isArray(record.links);
 }
+/** The primitive scalar widget types that occupy a widgets_values slot. */
+const SCALAR_WIDGET_TYPES = new Set(["INT", "FLOAT", "STRING", "BOOLEAN", "COMBO"]);
+/**
+ * Whether a (type, cfg) pair describes a scalar widget input. Beyond the plain
+ * "INT"/"FLOAT"/… types this also recognizes:
+ *  - a `widgetType` config hint (the frontend's authoritative "render this as a
+ *    FLOAT/INT widget" flag), and
+ *  - a COMBINED type string like "FLOAT,INT" (ComfyUI declares widgets whose value
+ *    may be either — e.g. LTXVEmptyLatentAudio.frame_rate is `["FLOAT,INT", …]`).
+ * Without this, a combined-type widget is misread as a LINK input, dropped from
+ * the widget list, and every following widget value shifts by one slot (issue
+ * #193: frame_rate 24 landed on batch_size and frame_rate fell back to default 25).
+ */
+function isScalarWidgetType(type, cfg) {
+    const wt = cfg?.widgetType;
+    if (typeof wt === "string" && SCALAR_WIDGET_TYPES.has(wt))
+        return true;
+    if (typeof type !== "string")
+        return false;
+    if (SCALAR_WIDGET_TYPES.has(type))
+        return true;
+    if (!type.includes(","))
+        return false;
+    const parts = type.split(",").map((s) => s.trim()).filter(Boolean);
+    return parts.length > 0 && parts.every((p) => SCALAR_WIDGET_TYPES.has(p));
+}
 /**
  * Check if an input spec represents a widget (value input) vs a link (connection input).
  * Widget inputs have an array type spec like ["INT", {...}] or ["STRING", {...}].
@@ -27,15 +53,8 @@ function isWidgetInput(inputName, def) {
     const cfg = spec[1];
     if (Array.isArray(cfg?.options))
         return true;
-    // Standard widget types
-    const WIDGET_TYPES = new Set([
-        "INT",
-        "FLOAT",
-        "STRING",
-        "BOOLEAN",
-        "COMBO",
-    ]);
-    return WIDGET_TYPES.has(typeSpec);
+    // Standard + combined + widgetType-hinted scalar widgets.
+    return isScalarWidgetType(typeSpec, cfg);
 }
 /**
  * Whether an input spec is a POSITIONAL widget — one that occupies a slot in the
@@ -52,7 +71,7 @@ function isPositionalWidgetSpec(spec) {
     const cfg = spec[1];
     if (Array.isArray(cfg?.options))
         return true; // dynamic combo (options-carrying)
-    return ["INT", "FLOAT", "STRING", "BOOLEAN", "COMBO"].includes(String(type));
+    return isScalarWidgetType(type, cfg);
 }
 /**
  * Model/asset file extensions that appear in ComfyUI loader combos
@@ -63,16 +82,23 @@ function isPositionalWidgetSpec(spec) {
  * to the first option is harmless.
  */
 const ASSET_FILE_RE = /\.(safetensors|safetensor|sft|ckpt|pt|pt2|pth|bin|gguf|onnx|vae|pkl|npz|yaml)$/i;
-function looksLikeAssetFilename(value) {
+export function looksLikeAssetFilename(value) {
     return typeof value === "string" && ASSET_FILE_RE.test(value.trim());
 }
 /**
- * Widget names that are ALWAYS server-side asset selectors, even when their
+ * Widget names that are ALWAYS server-side MODEL asset selectors, even when their
  * options carry no file extension (e.g. DiffusersLoader.model_path lists
  * extensionless directory names). Substituting a different entry here silently
- * swaps the user's model, so these must never take the comboOpts[0] fallback.
- * Deliberately excludes enum-shaped "_name" widgets (sampler_name, scheduler)
- * whose first-option fallback is legitimate.
+ * swaps the user's model, so these must never take the comboOpts[0] fallback
+ * (issue #407). These "_name"/"model_path" widget names are unambiguous model
+ * selectors on every node that exposes them, so a plain name match is safe.
+ *
+ * Deliberately EXCLUDES generic media names (image/audio/video) and enum-shaped
+ * "_name" widgets (sampler_name, scheduler): those are NOT globally asset
+ * selectors — a combo merely *named* `image` on some non-loader node, or a
+ * `sampler_name`, is a true enum whose first-option fallback is legitimate.
+ * Media/upload selectors are recognized structurally instead (see
+ * LOADER_ASSET_INPUTS and isUploadSelectorSpec).
  */
 const ASSET_WIDGET_NAMES = new Set([
     "ckpt_name",
@@ -94,13 +120,187 @@ const ASSET_WIDGET_NAMES = new Set([
     "diffusion_model",
 ]);
 /**
- * Check if an input has control_after_generate in its spec config.
- * These inputs (like seed, noise_seed) have a phantom "fixed"/"randomize" widget
- * in the UI's widgets_values array that doesn't correspond to any named input.
+ * KNOWN server-side file/upload SELECTORS, keyed by (classType → input name):
+ * real loader nodes whose combo lists media files present on the *connected*
+ * server (uploads or on-disk inputs). For these — and ONLY these, plus the
+ * model-loader widget names in ASSET_WIDGET_NAMES and object_info upload-flag
+ * metadata (isUploadSelectorSpec) — a value absent from a STALE combo is
+ * PRESERVED with a warning rather than silently rewritten to comboOpts[0]
+ * (issue #504). This is deliberately an allowlist, NOT a global name/extension
+ * heuristic: a combo merely *named* `image`/`audio`/`video`/`extension` on some
+ * OTHER node, or a media-looking value (`.bmp`, `.mp4`, …) on a TRUE enum, is
+ * NOT an asset selector and must take the enum fallback (substitute + warn) so
+ * ComfyUI does not hard-reject a "Value not in list".
  */
-function hasControlAfterGenerate(inputName, def) {
-    const spec = def.input.required?.[inputName] ?? def.input.optional?.[inputName];
-    if (!spec)
+const LOADER_ASSET_INPUTS = new Map([
+    ["LoadImage", new Set(["image"])],
+    ["LoadImageMask", new Set(["image"])],
+    ["LoadImageOutput", new Set(["image"])],
+    ["VHS_LoadVideo", new Set(["video"])],
+    ["VHS_LoadVideoPath", new Set(["video"])],
+    ["VHS_LoadVideoFFmpeg", new Set(["video"])],
+    ["VHS_LoadVideoFFmpegPath", new Set(["video"])],
+    ["LoadAudio", new Set(["audio"])],
+    ["VHS_LoadAudio", new Set(["audio"])],
+    ["VHS_LoadAudioUpload", new Set(["audio"])],
+]);
+function isKnownLoaderInput(classType, name) {
+    return LOADER_ASSET_INPUTS.get(classType)?.has(name) ?? false;
+}
+/**
+ * Whether object_info marks this input as an in-browser file/media UPLOAD
+ * selector — the authoritative signal that the combo lists server-side input
+ * files (LoadImage's `image` carries `{image_upload: true}`, audio/video loaders
+ * `{audio_upload|video_upload: true}`). When present this is more reliable than
+ * any name allowlist, so a staged value absent from a stale combo is preserved.
+ */
+function isUploadSelectorSpec(spec) {
+    if (!Array.isArray(spec))
+        return false;
+    const cfg = spec[1];
+    if (!cfg || typeof cfg !== "object")
+        return false;
+    return (cfg.image_upload === true ||
+        cfg.audio_upload === true ||
+        cfg.video_upload === true);
+}
+/**
+ * Extract the selectable option list from a widget spec, covering ALL three
+ * combo shapes so validation never misses one (issue #504 P1-B):
+ *   - inline combo:      [["a","b"], {..}]                 -> spec[0]
+ *   - COMBO w/ options:  ["COMBO", {options:["a","b"]}]    -> spec[1].options
+ *   - V3 dynamic combo:  ["COMFY_DYNAMICCOMBO_V3",         -> the option keys
+ *                          {options:[{key:"K", inputs:{…}}]}]
+ * A plain scalar spec (["INT",{…}]) or a link input carries no enumerable list,
+ * so this returns undefined and the caller passes the value through untouched.
+ * Object-shaped dynamic options are normalized to their `key`.
+ */
+function getComboOptions(spec) {
+    if (!Array.isArray(spec))
+        return undefined;
+    const type = spec[0];
+    if (Array.isArray(type))
+        return type; // inline combo: spec[0] IS the option list
+    const cfg = spec[1];
+    const opts = cfg?.options;
+    if (Array.isArray(opts)) {
+        // Flat value list (["auto","1:1"]) or object-keyed dynamic-combo list
+        // ([{key:"Nano Banana 2", …}]). Normalize both to their selectable values.
+        return opts.map((o) => o &&
+            typeof o === "object" &&
+            !Array.isArray(o) &&
+            "key" in o
+            ? o.key
+            : o);
+    }
+    return undefined;
+}
+/**
+ * Validate one saved combo value against its object_info options (of ANY combo
+ * shape — see getComboOptions) and return the value to store. This is the SINGLE
+ * choke-point every combo-value assignment flows through — direct widget, the
+ * name→value object form, the has_serialized_properties overwrite, a linked
+ * PrimitiveNode literal (P1-A), AND a V3 dynamic-combo nested leaf value (P1-B) —
+ * so no path can emit a value ComfyUI would reject with "Value not in list".
+ *
+ * Non-combo specs and in-list values pass through unchanged. For an out-of-list
+ * value the decision mirrors #407/#504:
+ *
+ *  - genuine ASSET/upload selector (model-loader widget name, (classType,input)
+ *    loader allowlist, or object_info upload flag) → PRESERVE + warn, so a
+ *    staged/absent file surfaces as an honest missing-asset error rather than a
+ *    silent wrong-file swap;
+ *  - true ENUM (sampler_name, scheduler, a stale "Select to add Wildcard"
+ *    helper, a combo merely NAMED image/extension, a media-looking value on a
+ *    non-loader enum, an out-of-list dynamic/nested key) → SUBSTITUTE
+ *    comboOpts[0] + warn, because ComfyUI hard-rejects a "Value not in list".
+ *
+ * `name` is the LEAF input name (nested leaf for dynamic combos) so asset
+ * classification keys off the real selector name, and `spec` is that leaf's
+ * spec, never regressing #504/#407.
+ */
+function validateComboValueForSpec(name, value, spec, classType, nodeId, warnings) {
+    const comboOpts = getComboOptions(spec);
+    // Not an enumerable combo (plain INT/FLOAT/STRING/BOOLEAN or a link input) —
+    // nothing to validate against.
+    if (!Array.isArray(comboOpts))
+        return value;
+    // Already a valid option — pass through untouched.
+    if (comboOpts.includes(value))
+        return value;
+    const isAssetCombo = ASSET_WIDGET_NAMES.has(name) ||
+        isKnownLoaderInput(classType, name) ||
+        isUploadSelectorSpec(spec);
+    // Recognized combo whose option list is EMPTY on the connected server (e.g. no
+    // models/files installed, or a fully-retired enum). There is no valid option to
+    // substitute to, so preserve the declared value and WARN — surfacing an honest
+    // missing-option/asset error rather than SILENTLY emitting an out-of-list
+    // literal. (Previously the length===0 branch returned the value with no warning.)
+    if (comboOpts.length === 0) {
+        warnings.push(isAssetCombo
+            ? `Node ${nodeId} (${classType}): widget "${name}" value "${String(value)}" — the connected server has no installed options for this asset combo; keeping the declared value so it surfaces as a missing-asset error.`
+            : `Node ${nodeId} (${classType}): widget "${name}" value "${String(value)}" — the connected server lists no options for this combo, so it cannot be validated; keeping the declared value so it surfaces as an honest error rather than being silently emitted.`);
+        return value;
+    }
+    if (isAssetCombo) {
+        warnings.push(`Node ${nodeId} (${classType}): widget "${name}" value "${String(value)}" is not installed on the connected server — keeping the declared value so it surfaces as a missing-asset error rather than silently substituting "${String(comboOpts[0])}".`);
+        return value;
+    }
+    warnings.push(`Node ${nodeId} (${classType}): widget "${name}" value "${String(value)}" is not a valid option on the connected server — substituting the first available option "${String(comboOpts[0])}" so the graph stays runnable (ComfyUI rejects unknown enum values).`);
+    return comboOpts[0];
+}
+/**
+ * Def-keyed wrapper for validateComboValueForSpec: resolves the input's spec from
+ * object_info by name (required then optional) and delegates. Used by the direct
+ * widget paths and the linked-PrimitiveNode path.
+ */
+function validateComboWidgetValue(name, value, def, classType, nodeId, warnings) {
+    const spec = def.input?.required?.[name] ??
+        def.input?.optional?.[name];
+    return validateComboValueForSpec(name, value, spec, classType, nodeId, warnings);
+}
+/**
+ * Resolve an input NAME (possibly a V3 dynamic-combo dotted "<combo>.<leaf>"
+ * key) to its LEAF name and object_info spec. A flat name resolves against the
+ * node's top-level required/optional inputs. A dotted name resolves the leaf
+ * against the parent dynamic combo's SELECTED option (looked up from the already
+ * populated `inputs[parent]`), so validation and asset classification key off
+ * the real leaf spec + leaf name — never the dotted name (which no top-level
+ * lookup would find, letting an unvalidated value through). Used by the linked
+ * PrimitiveNode path, where a primitive can feed a nested dotted input directly.
+ */
+function resolveWidgetSpec(def, name, inputs) {
+    const dot = name.indexOf(".");
+    if (dot < 0) {
+        const spec = def.input?.required?.[name] ??
+            def.input?.optional?.[name];
+        return { leafName: name, spec };
+    }
+    const parent = name.slice(0, dot);
+    const leafName = name.slice(dot + 1);
+    const parentSpec = def.input?.required?.[parent] ??
+        def.input?.optional?.[parent];
+    const opts = (Array.isArray(parentSpec)
+        ? parentSpec[1]
+        : undefined)?.options;
+    const selectedKey = inputs[parent];
+    // V3 option inputs may live under required OR optional — search both so an
+    // optional nested leaf isn't left unresolved (which would skip validation).
+    const selected = Array.isArray(opts)
+        ? opts.find((o) => o?.key === selectedKey)?.inputs
+        : undefined;
+    const spec = selected?.required?.[leafName] ?? selected?.optional?.[leafName];
+    return { leafName, spec };
+}
+/**
+ * Whether a widget SPEC carries a control_after_generate phantom slot — either
+ * flagged in its config, or a seed-type INT the ComfyUI frontend auto-augments.
+ * Works for both top-level inputs and V3 dynamic-combo NESTED leaves (which have
+ * no entry in def.input), so nested controlled seeds skip their phantom
+ * "fixed"/"randomize" slot too instead of shifting every following widget.
+ */
+function specHasControlAfterGenerate(name, spec) {
+    if (!Array.isArray(spec))
         return false;
     if (spec[1]?.control_after_generate === true)
         return true;
@@ -108,10 +308,19 @@ function hasControlAfterGenerate(inputName, def) {
     // widgets even when object_info doesn't flag it (e.g. UltimateSDUpscale.seed,
     // KSamplerAdvanced.noise_seed). The saved widgets_values then carry the extra
     // "fixed"/"randomize"/… value that must be skipped during mapping.
-    if (spec[0] === "INT" &&
-        (inputName === "seed" || inputName === "noise_seed" || inputName === "rand_seed"))
-        return true;
-    return false;
+    return (spec[0] === "INT" &&
+        (name === "seed" || name === "noise_seed" || name === "rand_seed"));
+}
+/**
+ * Check if an input has control_after_generate in its spec config.
+ * These inputs (like seed, noise_seed) have a phantom "fixed"/"randomize" widget
+ * in the UI's widgets_values array that doesn't correspond to any named input.
+ */
+function hasControlAfterGenerate(inputName, def) {
+    const spec = def.input.required?.[inputName] ?? def.input.optional?.[inputName];
+    if (!spec)
+        return false;
+    return specHasControlAfterGenerate(inputName, spec);
 }
 /**
  * Get the ordered list of input names from a node definition.
@@ -142,6 +351,22 @@ const WIRING_VIRTUAL_TYPES = new Set([
 const isGetVirtual = (t) => WIRING_VIRTUAL_TYPES.has(t) && /get/i.test(t);
 const isSetVirtual = (t) => WIRING_VIRTUAL_TYPES.has(t) && /set/i.test(t) && !/get/i.test(t);
 const isWiringVirtual = (t) => t != null && (t === "Reroute" || isGetVirtual(t) || isSetVirtual(t));
+/**
+ * The bus name (the "Constant" widget) that keys a Set/Get virtual node. Usually
+ * widgets_values[0] on a serialized graph, but the live-canvas reconstruction
+ * fallback (#384) keys widget values BY NAME, so widgets_values can be an object
+ * ({ Constant: "…" }) instead of a positional array. Read both shapes so Set/Get
+ * resolution survives the fallback path.
+ */
+function busKey(wv) {
+    if (Array.isArray(wv))
+        return wv[0];
+    if (wv && typeof wv === "object") {
+        const o = wv;
+        return o.Constant ?? o.constant ?? Object.values(o)[0];
+    }
+    return undefined;
+}
 /**
  * Pre-pass: strip the pure "wiring" virtual nodes — KJNodes **Get/Set** bus nodes
  * and **Reroute** — by rewriting each consumer's link straight to the real
@@ -176,7 +401,7 @@ function deVirtualizeGraph(nodes, links) {
     const busSet = new Map();
     for (const n of nodes) {
         if (isSetVirtual(n.type)) {
-            const b = n.widgets_values?.[0];
+            const b = busKey(n.widgets_values);
             if (b != null)
                 busSet.set(String(b), n);
         }
@@ -197,19 +422,29 @@ function deVirtualizeGraph(nodes, links) {
             return s ? resolveReal(s.node, s.slot, depth + 1) : null;
         }
         if (isGetVirtual(node.type)) {
-            const b = node.widgets_values?.[0];
+            const b = busKey(node.widgets_values);
             const setN = b != null ? busSet.get(String(b)) : undefined;
             if (!setN)
                 return null;
             const s = incoming(setN);
             return s ? resolveReal(s.node, s.slot, depth + 1) : null;
         }
+        // SetNode passthrough: rgthree/KJNodes Set nodes expose an output that mirrors
+        // their value input, so a consumer can wire straight off the SetNode (not only
+        // via a GetNode). Follow the Set's value input to the real source — otherwise
+        // the link is left pointing at the (removed) virtual and gets dropped, losing
+        // the connection (issue #361: Set/Get-resolved links missing on downstream nodes).
+        if (isSetVirtual(node.type)) {
+            const s = incoming(node);
+            return s ? resolveReal(s.node, s.slot, depth + 1) : null;
+        }
         return { node: nodeId, slot };
     };
     const drop = new Set();
     for (const l of links) {
         const srcType = byId.get(lsrc(l))?.type;
-        if (srcType === "Reroute" || (srcType && isGetVirtual(srcType))) {
+        if (srcType === "Reroute" ||
+            (srcType && (isGetVirtual(srcType) || isSetVirtual(srcType)))) {
             const real = resolveReal(lsrc(l), lsrcSlot(l));
             if (real && !isWiringVirtual(byId.get(real.node)?.type)) {
                 setLsrc(l, real.node, real.slot);
@@ -629,7 +864,15 @@ export function isLinkRef(v, nodeKeys) {
 /** The UI slot `type` string for a widget input spec. */
 function widgetSlotType(spec) {
     const t = spec[0];
-    return Array.isArray(t) ? "COMBO" : t;
+    if (Array.isArray(t))
+        return "COMBO";
+    const wt = spec[1]?.widgetType;
+    if (typeof wt === "string")
+        return wt;
+    // Combined type like "FLOAT,INT" → the first member is the concrete slot type.
+    if (typeof t === "string" && t.includes(","))
+        return t.split(",")[0].trim();
+    return t;
 }
 /**
  * A sensible widgets_values entry for a widget the API graph didn't provide:
@@ -988,7 +1231,7 @@ export function convertUiToApi(ui, objectInfo) {
     for (const n of expanded.nodes) {
         if (!isSetType(n.type))
             continue;
-        const bus = n.widgets_values?.[0];
+        const bus = busKey(n.widgets_values);
         const inp = (n.inputs ?? []).find((i) => i.link != null);
         if (bus != null && inp?.link != null)
             busSource.set(String(bus), inp.link);
@@ -1011,7 +1254,7 @@ export function convertUiToApi(ui, objectInfo) {
         }
         // Virtual GetNode: follow the bus to the SetNode that wrote it.
         if (isGetType(src.type)) {
-            const bus = src.widgets_values?.[0];
+            const bus = busKey(src.widgets_values);
             const setLink = bus != null ? busSource.get(String(bus)) : undefined;
             return setLink != null ? resolveSource(setLink, depth + 1) : null;
         }
@@ -1075,25 +1318,166 @@ export function convertUiToApi(ui, objectInfo) {
                 widgetNames.push(name);
             }
         }
+        // Nested widgets that have been "converted to input" (linked) carry NO
+        // positional widgets_values slot — their value arrives via the link, not the
+        // saved array — so consuming a slot for them would steal the next widget's
+        // value and mis-align the whole tail. Track the linked (dotted) input names
+        // to skip their positional consumption below.
+        const linkedInputNames = new Set((node.inputs ?? [])
+            .filter((i) => i.link != null)
+            .map((i) => i.name));
         // Map widgets_values to named widget inputs.
         // Some INT inputs with "control_after_generate": true (like seed, noise_seed) have
         // a phantom widget value in widgets_values ("fixed"/"randomize"/"increment"/"decrement")
         // that doesn't correspond to any named input — we must skip those.
         const widgetValues = node.widgets_values ?? [];
         // Some nodes (e.g. VHS_VideoCombine) store widgets_values as a name->value
-        // object instead of a positional array. Map those by name directly.
+        // object instead of a positional array — as does the #384 live-canvas
+        // fallback (graph_get_state keys every widget by name). Map those by name
+        // directly; no positional drift means the values are authoritative (no
+        // combo-validity re-resolution or phantom control_after_generate slot needed).
         if (!Array.isArray(widgetValues)) {
             const wv = widgetValues;
+            // Resolve a top-level dynamic combo's SELECTED-option nested inputs (merged
+            // required + optional — an asset selector may live under `optional`, and
+            // reading only `required` would drop it, regressing #504/#407). Mirrors the
+            // positional branch's nested lookup.
+            const nestedFor = (name) => {
+                const spec = def.input?.required?.[name] ??
+                    def.input?.optional?.[name];
+                const opts = (Array.isArray(spec)
+                    ? spec[1]
+                    : undefined)?.options;
+                const selInputs = Array.isArray(opts)
+                    ? opts.find((o) => o?.key === wv[name])?.inputs
+                    : undefined;
+                return selInputs && (selInputs.required || selInputs.optional)
+                    ? { ...selInputs.required, ...selInputs.optional }
+                    : undefined;
+            };
+            // A name-keyed capture (the #384 graph_get_state fallback, or a natively
+            // name-keyed widgets_values) stores EVERY widget in ONE FLAT name→value map.
+            // That is only authoritative when names are GLOBALLY UNIQUE. When more than
+            // one control claims the SAME flat slot — two dynamic-combo parents each with
+            // a nested "strength", OR a nested "strength" shadowing a top-level widget
+            // "strength" — the single stored value can't be attributed to ANY of them, so
+            // reading by leaf name would silently push one control's value onto another
+            // (the #504/#499 wrong-value bug class). A control claims the flat slot L when
+            // it needs L and the capture did NOT parent-qualify it ("first.strength"); a
+            // PARENT-QUALIFIED key is always unambiguous and consumes its own slot, never
+            // the flat one. Count the claimants of each flat slot up front so the emit
+            // loop can FAIL CLOSED — refuse EVERY control competing for an over-subscribed
+            // slot (top-level AND nested), leaving each to its node default — rather than
+            // trust a value that might belong to a different control.
+            const nestedByParent = new Map();
+            for (const name of widgetNames) {
+                const nested = nestedFor(name);
+                if (nested)
+                    nestedByParent.set(name, nested);
+            }
+            // flat-slot claimant count, keyed by leaf name.
+            const flatClaimants = new Map();
+            const claimFlat = (leaf) => flatClaimants.set(leaf, (flatClaimants.get(leaf) ?? 0) + 1);
             for (const name of widgetNames) {
                 if (name in wv)
-                    inputs[name] = wv[name];
+                    claimFlat(name); // top-level widget claims its own flat slot
+            }
+            for (const [parent, nested] of nestedByParent) {
+                for (const [nName, nSpec] of Object.entries(nested)) {
+                    if (!isPositionalWidgetSpec(nSpec))
+                        continue;
+                    // a nested leaf claims the flat slot only when it FALLS BACK to it
+                    // (no parent-qualified key present in the capture).
+                    if (`${parent}.${nName}` in wv)
+                        continue;
+                    if (nName in wv)
+                        claimFlat(nName);
+                }
+            }
+            const flatAmbiguous = (leaf) => (flatClaimants.get(leaf) ?? 0) > 1;
+            const ambiguityWarning = (target, leaf) => `Node ${nodeId} (${classType}): widget "${target}" could not be resolved from the name-keyed capture because the flat slot "${leaf}" is claimed by more than one control (multiple dynamic-combo nested leaves of the same name, or a nested leaf shadowing a top-level widget), so the single stored value can't be attributed to the right control. Left to the node default rather than risk assigning another control's value. Re-capture with a panel that emits parent-qualified widget names, or pass pack/path/graph.`;
+            for (const name of widgetNames) {
+                if (name in wv) {
+                    // A top-level widget whose flat slot is over-subscribed (a nested leaf of
+                    // the same name also falls back to it) is itself ambiguous — the stored
+                    // value might be the nested control's — so refuse it too, don't trust it.
+                    if (flatAmbiguous(name)) {
+                        warnings.push(ambiguityWarning(name, name));
+                    }
+                    else {
+                        inputs[name] = validateComboWidgetValue(name, wv[name], def, classType, nodeId, warnings);
+                    }
+                }
+                // V3 dynamic-combo nested inputs: the selected option adds required
+                // sub-inputs whose live values are ALSO keyed in wv. Emit them as
+                // "<combo>.<nested>" so the prompt matches the array-branch shape (ComfyUI
+                // rebuilds the nested dict from these dotted keys). Each nested leaf is
+                // validated against ITS OWN spec/name (mirrors the array branch — don't
+                // regress #504/#407 asset preservation for nested combos).
+                const nested = nestedByParent.get(name);
+                if (nested) {
+                    for (const [nName, nSpec] of Object.entries(nested)) {
+                        if (!isPositionalWidgetSpec(nSpec))
+                            continue;
+                        const qualified = `${name}.${nName}`;
+                        // Preferred: the capture already parent-qualified the key — unambiguous.
+                        if (qualified in wv) {
+                            inputs[qualified] = validateComboValueForSpec(nName, wv[qualified], nSpec, classType, nodeId, warnings);
+                            continue;
+                        }
+                        if (!(nName in wv))
+                            continue;
+                        // Flat leaf: safe ONLY when it is the SOLE claimant of that flat slot.
+                        if (flatAmbiguous(nName)) {
+                            warnings.push(ambiguityWarning(qualified, nName));
+                            continue;
+                        }
+                        inputs[qualified] = validateComboValueForSpec(nName, wv[nName], nSpec, classType, nodeId, warnings);
+                    }
+                }
             }
         }
         else {
             let widgetIdx = 0;
-            for (const name of widgetNames) {
+            // A still-valid dynamic-combo option whose NESTED arity DRIFTED between save
+            // and load (the option kept its key but added/removed nested inputs) can't be
+            // detected up front — its saved nested slots were serialized against the OLD
+            // arity, but we map using the CURRENT one, so any drift shifts the trailing
+            // top-level widgets (e.g. a since-removed nested "multiplier" leaves its stale
+            // value to land on the seed). The stale-parent guard below only catches a
+            // REMOVED option (key absent). For a still-present option, a LEFTOVER saved
+            // value after the whole positional mapping is the reliable drift signal — a
+            // self-consistent layout consumes exactly. Track whether a still-valid dynamic
+            // combo was processed and which widgets were mapped AFTER it, so on leftover we
+            // can default those (shifted) widgets + warn instead of trusting the shift.
+            let sawDynamicCombo = false;
+            // Set when ANY combo hits a refusal (stale/empty-options parent, or a linked-
+            // nested leaf). A refusal INTENTIONALLY stops mapping and leaves the tail
+            // unconsumed, so the leftover it creates is EXPECTED — it does NOT prove that an
+            // EARLIER combo drifted. Positionally, a valid layout ([first, first.note,
+            // count, second→refuse]) and a drifted one are IDENTICAL once a refusal is
+            // present, so acting on that leftover would DELETE valid earlier values (a real
+            // regression). Therefore a refusal suppresses the leftover drift guard entirely
+            // for this node; the drift guard fires only on a leftover with NO refusal, where
+            // it unambiguously means the arity shrank.
+            let refusalOccurred = false;
+            const widgetsAfterDynamicCombo = [];
+            // Dotted "<combo>.<leaf>" keys assigned positionally from a dynamic combo's
+            // nested layout. On a proven arity drift (leftover) these are ALSO suspect — a
+            // since-removed nested slot shifts every later nested value onto the wrong leaf
+            // (old A=[obsolete, strength], current A=[strength], saved ["A",4,0.75] maps
+            // strength=4, the obsolete value) — so the drift guard defaults them too, not
+            // just the trailing top-level widgets.
+            const nestedKeysFromDynamic = [];
+            for (let nameIdx = 0; nameIdx < widgetNames.length; nameIdx++) {
+                const name = widgetNames[nameIdx];
                 if (widgetIdx >= widgetValues.length)
                     break;
+                // A widget mapped AFTER a still-valid dynamic combo is positionally
+                // downstream of its (unverifiable) nested arity — record it for the
+                // drift-leftover check below.
+                if (sawDynamicCombo)
+                    widgetsAfterDynamicCombo.push(name);
                 const value = widgetValues[widgetIdx];
                 inputs[name] = value;
                 widgetIdx++;
@@ -1108,38 +1492,100 @@ export function convertUiToApi(ui, objectInfo) {
                 // Classic combo widget: if the saved value isn't one of the valid options
                 // (a stale UI-helper combo like Impact's "Select to add Wildcard", or a
                 // value from a node version with different options), fall back to the
-                // default first option. ComfyUI hard-rejects "Value not in list" otherwise,
-                // so defaulting is strictly safer than passing the stale value through.
-                //
-                // EXCEPTION (issue #407): an ASSET-selection combo (unet_name, ckpt_name,
-                // vae_name, lora_name, …) lists the files installed on the *connected*
-                // server. When the declared model isn't installed there, comboOpts[0] is a
-                // completely unrelated model — e.g. Krea 2's "krea2_turbo_fp8.safetensors"
-                // silently became "flux-2-klein-9b.safetensors" (the first installed unet).
-                // Silently swapping one model for another produces a misleading graph that
-                // can't render the advertised workflow. For asset combos we KEEP the
-                // declared value and warn, so it surfaces as an honest missing-asset error
-                // instead of a wrong-model success.
-                const comboOpts = Array.isArray(spec) ? spec[0] : undefined;
-                if (Array.isArray(comboOpts) &&
-                    comboOpts.length > 0 &&
-                    !comboOpts.includes(value)) {
-                    const isAssetCombo = ASSET_WIDGET_NAMES.has(name) ||
-                        looksLikeAssetFilename(value) ||
-                        comboOpts.some((opt) => looksLikeAssetFilename(opt));
-                    if (isAssetCombo) {
-                        warnings.push(`Node ${nodeId} (${classType}): widget "${name}" value "${String(value)}" is not installed on the connected server — keeping the declared value so it surfaces as a missing-asset error rather than silently substituting "${String(comboOpts[0])}".`);
-                        // inputs[name] already holds the declared value; leave it untouched.
-                    }
-                    else {
-                        inputs[name] = comboOpts[0];
-                    }
-                }
+                // default first option — UNLESS it's a genuine asset/upload selector, which
+                // we preserve + warn (#407/#504). See validateComboWidgetValue for the full
+                // classification (model-loader names + (classType,input) loader allowlist +
+                // object_info upload flag — NOT a global name/extension heuristic).
+                inputs[name] = validateComboWidgetValue(name, value, def, classType, nodeId, warnings);
                 const opts = (Array.isArray(spec)
                     ? spec[1]
                     : undefined)?.options;
-                const nested = Array.isArray(opts)
-                    ? opts.find((o) => o?.key === value)?.inputs?.required
+                // A V3 option's nested widgets can live under required OR optional; both
+                // occupy positional widgets_values slots in serialization order (required
+                // then optional). Merging them keeps the positional index aligned AND
+                // ensures every nested leaf is validated — reading only `required` would
+                // skip an optional leaf and mis-position every later widget.
+                //
+                // Look up the option by the RAW saved `value` (the selection the array was
+                // serialized against), NOT the post-validation inputs[name]. If the saved
+                // selection is stale (its option was removed/renamed), its ORIGINAL nested
+                // arity is unrecoverable, so consuming zero nested slots while still
+                // advancing the top-level index would silently misassign a leftover nested
+                // value onto the trailing top-level widgets (e.g. a removed option's nested
+                // strength overwriting the user's seed). The stale-parent guard below REFUSES
+                // that case (warn + stop) instead of guessing.
+                // A V3 dynamic combo must be identified by its EXPLICIT type string
+                // (spec[0] === "COMFY_DYNAMICCOMBO_V3"), NOT by whether its current options
+                // list happens to contain keyed objects. An EMPTY current options list
+                // (["COMFY_DYNAMICCOMBO_V3", {options: []}]) has NO keyed entries, so the
+                // object-key heuristic alone reports false and the stale-parent guard below
+                // never fires — re-opening the exact silent-positional-shift hole: with an
+                // empty options list every saved selection is stale, and consuming zero
+                // nested slots while advancing the top-level index misassigns a leftover
+                // nested value (e.g. a removed option's strength=0.75) onto the next widget
+                // (e.g. a seed). Keying off the type covers the empty-options case too.
+                //
+                // The object-key heuristic is retained as a fallback for any V3 dynamic list
+                // that carries keyed {key, inputs} entries without the literal type marker.
+                // A classic string-option COMBO (spec[0] is the ["a","b"] options array, not
+                // the "COMFY_DYNAMICCOMBO_V3" string) matches NEITHER branch, so it must NOT
+                // trip the stale-parent guard below (which would wrongly refuse a perfectly
+                // valid classic-combo value).
+                const specType = Array.isArray(spec) ? spec[0] : undefined;
+                const isDynamicComboType = specType === "COMFY_DYNAMICCOMBO_V3";
+                const isDynamicOptions = isDynamicComboType ||
+                    (Array.isArray(opts) &&
+                        opts.some((o) => o != null &&
+                            typeof o === "object" &&
+                            !Array.isArray(o) &&
+                            "key" in o));
+                const savedOption = Array.isArray(opts)
+                    ? opts.find((o) => o?.key === value)
+                    : undefined;
+                // P0 (#517): STALE dynamic-combo parent. The saved selection is NOT among
+                // the current dynamic options (the option was removed/renamed, or was
+                // substituted above). The saved array was serialized against the OLD
+                // option's layout: [parent, <OLD option's nested slots>, ...trailing
+                // top-level widgets...]. The OLD nested arity is unknowable from THIS schema,
+                // so the pre-fix code consumed ZERO nested slots while still advancing the
+                // top-level index — silently mapping a leftover stale nested value onto the
+                // next widget (e.g. a removed option's strength=0.75 landing on the user's
+                // seed, discarding the real 42 with no warning).
+                //
+                // The saved array was serialized as
+                //   [parent, <removed option's nested slots>, ...trailing top-level widgets...]
+                // and we CANNOT reconstruct where the orphaned-nested block ends: NEITHER the
+                // removed option's nested arity NOR the trailing widgets' saved-slot count is
+                // recoverable. The trailing count is doubly unknown — a nested seed carries a
+                // variable control_after_generate phantom, a trailing dynamic combo adds a
+                // value-dependent number of slots, AND the current schema may have added or
+                // removed trailing widgets since the graph was saved. A surplus arithmetic
+                // (values-left vs current trailing-widget-count) silently mis-attributes
+                // orphaned slots whenever any of those drift (e.g. a schema-added trailing
+                // widget makes surplus cancel to zero while an orphan still sits before the
+                // seed). Because NO positional reconstruction is provably safe, REFUSE: warn
+                // and stop positional mapping here so an orphaned nested value can NEVER be
+                // silently mapped onto a later top-level widget (such as a seed). The
+                // remaining required inputs then default-fill below. The parent itself was
+                // already substituted + warned via validateComboWidgetValue above.
+                if (isDynamicOptions &&
+                    savedOption === undefined &&
+                    widgetIdx < widgetValues.length) {
+                    warnings.push(`Node ${nodeId} (${classType}): widget "${name}" saved selection "${String(value)}" is no longer an available option, so the removed option's nested-input layout can't be reconstructed. The remaining ${widgetValues.length - widgetIdx} saved widget value(s) are left to their defaults rather than risk silently assigning a stale nested value to a later widget (such as a seed).`);
+                    // A refusal's leftover is expected and can't be attributed to earlier drift,
+                    // so suppress the drift guard for this node (see refusalOccurred note).
+                    refusalOccurred = true;
+                    break;
+                }
+                // Still-valid dynamic combo (option key present): its nested arity is trusted
+                // from the CURRENT schema but can't be verified against the save — flag it so
+                // the post-loop leftover check can detect a drift-induced tail shift.
+                if (isDynamicOptions && savedOption !== undefined)
+                    sawDynamicCombo = true;
+                const selectedInputs = savedOption?.inputs;
+                const nested = selectedInputs &&
+                    (selectedInputs.required || selectedInputs.optional)
+                    ? { ...selectedInputs.required, ...selectedInputs.optional }
                     : undefined;
                 if (nested) {
                     // V3 dynamic-combo nested inputs are keyed with the combo's id as a
@@ -1149,16 +1595,105 @@ export function convertUiToApi(ui, objectInfo) {
                     // non-widget nested inputs (AUTOGROW lists like Nano Banana 2's
                     // "images", or IMAGE/link types) have no saved widget value, so skipping
                     // them keeps the positional mapping aligned.
+                    let refuseTail = false;
                     for (const [nName, nSpec] of Object.entries(nested)) {
-                        if (widgetIdx >= widgetValues.length)
-                            break;
                         if (!isPositionalWidgetSpec(nSpec))
                             continue;
-                        inputs[`${name}.${nName}`] = widgetValues[widgetIdx];
+                        // A linked (converted-to-input) nested leaf's value arrives via the link
+                        // loop below, NOT the saved array. Other/older frontend versions, though,
+                        // RETAIN a serialized placeholder for a converted widget, so the leaf may
+                        // OR may not still occupy a widgets_values slot — and that cannot be told
+                        // apart positionally. If a placeholder IS present and we skip it without
+                        // consuming, the retained value shifts onto the NEXT top-level widget: a
+                        // seed silently becomes the placeholder (e.g. widgets_values
+                        // [parent, 4(linked-nested placeholder), 424242(seed), "fixed"] would map
+                        // seed=4). When trailing saved values remain, the alignment is
+                        // unrecoverable, so REFUSE the tail — the same safe pattern as the
+                        // stale-parent guard above: warn + leave the remaining top-level widgets
+                        // to their defaults rather than risk a silent shift onto a later widget.
+                        // (If NO trailing values remain there is nothing to misassign, so the
+                        // link simply supplies the leaf and the loop ends.)
+                        if (linkedInputNames.has(`${name}.${nName}`)) {
+                            if (widgetIdx < widgetValues.length) {
+                                warnings.push(`Node ${nodeId} (${classType}): widget "${name}" has a converted-to-input (linked) nested widget "${name}.${nName}" whose widgets_values slot can't be positionally resolved (frontend versions differ on whether a converted widget keeps a placeholder slot), so the remaining ${widgetValues.length - widgetIdx} saved widget value(s) are left to their defaults rather than risk silently assigning a stale value to a later widget (such as a seed).`);
+                                refuseTail = true;
+                                break;
+                            }
+                            continue;
+                        }
+                        if (widgetIdx >= widgetValues.length)
+                            break;
+                        // Nested leaf values bypass the top-level widget validation, so validate
+                        // each against ITS OWN leaf spec/name (P1-B). Asset classification keys
+                        // off the leaf name + loader/upload allowlist (don't regress #504/#407);
+                        // an out-of-list nested enum (e.g. aspect_ratio "4:3") substitutes+warns.
+                        inputs[`${name}.${nName}`] = validateComboValueForSpec(nName, widgetValues[widgetIdx], nSpec, classType, nodeId, warnings);
+                        nestedKeysFromDynamic.push(`${name}.${nName}`);
                         widgetIdx++;
+                        // A nested seed-type / control_after_generate leaf carries a phantom
+                        // "fixed"/"randomize" value right after it (same as top-level seeds), so
+                        // skip that slot or every following widget shifts by one.
+                        if (specHasControlAfterGenerate(nName, nSpec) &&
+                            widgetIdx < widgetValues.length) {
+                            widgetIdx++;
+                        }
+                    }
+                    // A linked nested leaf with trailing saved values made the alignment
+                    // ambiguous — stop mapping the remaining top-level widgets (they
+                    // default-fill below) so no retained placeholder can shift onto a seed.
+                    // This refusal's leftover is expected, so suppress the drift guard for this
+                    // node (see refusalOccurred note) — otherwise it would delete valid earlier
+                    // widgets/leaves mapped before this refusing combo.
+                    if (refuseTail) {
+                        refusalOccurred = true;
+                        break;
                     }
                 }
             }
+            // Drift guard: a LEFTOVER saved value after a still-valid dynamic combo means
+            // its nested arity SHRANK since the save (see the sawDynamicCombo note above) —
+            // the current option consumes fewer nested slots than the save held, leaving a
+            // provable leftover. A self-consistent layout consumes exactly; a leftover proves
+            // the positional mapping after (and WITHIN) the drifted combo is shifted: both the
+            // trailing top-level widgets AND the nested dotted leaves may hold a value that
+            // belongs to a since-removed slot (e.g. old A=[obsolete, strength], current
+            // A=[strength], saved ["A",4,0.75] maps strength=4 — the obsolete value). Default
+            // BOTH sets (delete so top-level widgets default-fill below and nested leaves fall
+            // to their runtime option defaults) and warn, rather than trust a silently shifted
+            // value on a later widget (such as a seed) OR a nested leaf. This fires on ANY
+            // leftover — even with no trailing top-level widget — so a shifted nested value
+            // can't survive. (Mirrors the stale-parent + linked-leaf refusals.)
+            //
+            // LIMITATION (accepted, BROAD): only the direction that nets to a LEFTOVER is
+            // catchable. Any nested-arity drift that nets to EXACT consumption is positionally
+            // INDISTINGUISHABLE from a legitimate layout and CANNOT be caught from
+            // widgets_values alone. That covers not just arity-GROWTH (option gained nested
+            // inputs) but ALSO arity-SHRINK masked by a newly-added TOP-LEVEL widget (a
+            // removed nested slot canceled by an added trailing widget → exact), and the
+            // multi-combo variants of both. Catching any of these would require refusing ALL
+            // trailing widgets after every dynamic combo — which regresses the canonical Nano
+            // Banana multi-nested node ([prompt, model, aspect_ratio, resolution,
+            // thinking_level, seed, control, response_modalities], an existing passing test).
+            // So this guard catches only the provable (leftover) direction.
+            //
+            // ALSO ACCEPTED (undecidable when a REFUSAL is present): a refusal (linked-leaf
+            // or stale/empty-options parent) INTENTIONALLY stops mapping, so the leftover it
+            // creates is EXPECTED and cannot be attributed to an earlier combo's drift — a
+            // valid layout ([first, first.note, count, second→refuse]) and a drifted one are
+            // positionally IDENTICAL once a refusal is present. Acting on that leftover would
+            // DELETE valid earlier values, so `refusalOccurred` suppresses this guard for the
+            // whole node. (Any earlier drift then falls to the accepted exact-consumption
+            // class above — a refusal's leftover is not a reliable drift signal.) The guard
+            // therefore fires ONLY on a leftover with NO refusal, where it unambiguously means
+            // the arity shrank.
+            if (sawDynamicCombo && !refusalOccurred && widgetIdx < widgetValues.length) {
+                for (const wn of widgetsAfterDynamicCombo)
+                    delete inputs[wn];
+                for (const nk of nestedKeysFromDynamic)
+                    delete inputs[nk];
+                const defaulted = [...nestedKeysFromDynamic, ...widgetsAfterDynamicCombo];
+                warnings.push(`Node ${nodeId} (${classType}): a dynamic-combo option's nested-input layout appears to have changed since this workflow was saved (${widgetValues.length - widgetIdx} saved widget value(s) remain unmapped), so its nested leaves and the widget(s) positioned after it${defaulted.length ? ` (${defaulted.join(", ")})` : ""} are left to their defaults rather than risk a silently shifted value on a later widget (such as a seed) or nested leaf.`);
+            }
         }
         // Nodes with a CUSTOM serialized-widget layout (properties.has_serialized_properties
         // — WhatDreamsCost's LTXDirector/LTXSequencer, kijai's PromptRelay) pack extra or
@@ -1174,7 +1709,7 @@ export function convertUiToApi(ui, objectInfo) {
         if (serializedProps?.has_serialized_properties === true) {
             for (const name of widgetNames) {
                 if (name in serializedProps)
-                    inputs[name] = serializedProps[name];
+                    inputs[name] = validateComboWidgetValue(name, serializedProps[name], def, classType, nodeId, warnings);
             }
         }
         // Fill any required input not covered by widgets_values or a link with its
@@ -1200,8 +1735,14 @@ export function convertUiToApi(ui, objectInfo) {
             else {
                 dflt = config?.default;
             }
-            if (dflt !== undefined)
-                inputs[name] = dflt;
+            if (dflt !== undefined) {
+                // A schema `default` can itself be out-of-list (custom-node combo drift,
+                // e.g. sampler_name default "removed_sampler" not in its own options).
+                // Route the derived default through the same choke-point so it can't emit
+                // a value ComfyUI rejects — first-option substitution for a true enum,
+                // leaf-name asset preservation for a loader/upload selector.
+                inputs[name] = validateComboValueForSpec(name, dflt, spec, classType, nodeId, warnings);
+            }
         }
         // Map linked inputs from node's inputs array (bypass/mute resolved)
         if (node.inputs) {
@@ -1215,8 +1756,18 @@ export function convertUiToApi(ui, objectInfo) {
                 const srcNode = link ? nodesById.get(link.sourceNodeId) : undefined;
                 if (srcNode?.type === "PrimitiveNode") {
                     const val = srcNode.widgets_values?.[0];
-                    if (val !== undefined)
-                        inputs[input.name] = val;
+                    // A linked PrimitiveNode literal bypasses the widget-value validation
+                    // above (widgets are processed first, links after), so route it through
+                    // the same choke-point (P1-A). A stale LOADER asset is preserved+warned;
+                    // a true out-of-list ENUM (e.g. sampler_name "removed_sampler") is
+                    // substituted+warned rather than reaching the API and being rejected.
+                    // input.name may be a dynamic-combo dotted "<combo>.<leaf>" key, so
+                    // resolve the leaf spec/name first — a top-level lookup would miss it
+                    // and let the value through unvalidated.
+                    if (val !== undefined) {
+                        const { leafName, spec } = resolveWidgetSpec(def, input.name, inputs);
+                        inputs[input.name] = validateComboValueForSpec(leafName, val, spec, classType, nodeId, warnings);
+                    }
                     continue;
                 }
                 const resolved = resolveSource(input.link);
@@ -1224,6 +1775,145 @@ export function convertUiToApi(ui, objectInfo) {
                     inputs[input.name] = [resolved.id, resolved.slot];
             }
         }
+        // Final dependency-aware pass over V3 dynamic-combo dotted "<parent>.<leaf>"
+        // inputs: a link/PrimitiveNode override above can change the PARENT selection
+        // AFTER its nested leaves were validated against the ORIGINAL option (e.g.
+        // positional emits model="A"+model.choice="a1", then a primitive overrides
+        // model="B"). Re-anchor every dotted leaf to the FINAL parent value — drop a
+        // leaf that the selected option no longer defines, and revalidate the rest
+        // against the leaf's real spec — so no leaf reaches the prompt validated
+        // against the wrong option.
+        for (const key of Object.keys(inputs)) {
+            const dot = key.indexOf(".");
+            if (dot < 0)
+                continue;
+            const parent = key.slice(0, dot);
+            // Orphaned dotted leaf: its dynamic parent isn't in the prompt (e.g. an
+            // optional parent left unset while the leaf was linked). There's no option
+            // context to validate against, and the leaf is meaningless without its
+            // parent — ComfyUI has no selected option so "<parent>.<leaf>" is an unknown
+            // input it hard-rejects. Default-DENY: drop the leaf UNCONDITIONALLY,
+            // whether it's an un-parented literal OR a link ref. Keeping a link ref here
+            // (the previous behavior) still emitted an orphan the server would reject.
+            if (!(parent in inputs)) {
+                delete inputs[key];
+                continue;
+            }
+            const leafVal = inputs[key];
+            // A leaf can itself be a LINK REF ([id, slot]) — a nested widget converted to
+            // input and wired to a real node. We can't membership-check its runtime
+            // value, but we CAN check whether the FINAL selected option even DEFINES the
+            // leaf: an array leaf under an option that doesn't define it is just as
+            // orphaned as a literal one, and ComfyUI hard-rejects the unknown input. So
+            // link-ref leaves are re-anchored too (previously they short-circuited here
+            // with an unconditional `continue`, leaking an orphan under an incompatible
+            // parent).
+            const leafIsLink = Array.isArray(leafVal);
+            // Parent fed by a real (non-Primitive) link → the SELECTED option is only
+            // known at runtime, so a leaf saved/linked under one option may be wrong
+            // for the resolved one. Keep it only if it validates under EVERY option
+            // that defines the leaf; otherwise drop it (ComfyUI supplies the runtime
+            // option's default). This prevents a wrong-option literal (e.g. option-A
+            // "a1" left on a parent that resolves to option B) reaching the prompt.
+            if (Array.isArray(inputs[parent])) {
+                const leaf = key.slice(dot + 1);
+                const pSpec = def.input?.required?.[parent] ??
+                    def.input?.optional?.[parent];
+                const pOpts = (Array.isArray(pSpec)
+                    ? pSpec[1]
+                    : undefined)?.options;
+                // The resolved option is unknowable at convert time, so KEEP the leaf only
+                // if it stays valid WHICHEVER option resolves — i.e. it must be defined by
+                // EVERY option (definedEverywhere). If ANY option omits the leaf, that
+                // runtime resolution would orphan it (ComfyUI rejects the unknown nested
+                // input), so default-DENY and drop it — the option's default is supplied at
+                // runtime. This holds for a LINK-REF leaf (whose runtime value we can't
+                // membership-check — definition is all we can verify) AND a LITERAL leaf,
+                // which must ALSO be a strict in-list MEMBER of every option. Membership
+                // uses a strict includes() — NOT validateComboValueForSpec, whose
+                // asset/empty-combo PRESERVE path would keep an out-of-list literal and
+                // swallow its warning.
+                let anyOption = false;
+                let definedEverywhere = true;
+                let definedSomewhere = false;
+                // For a LITERAL leaf: it must be an in-list MEMBER of every option that
+                // DEFINES it as a combo. Options that OMIT the leaf are skipped (not failed)
+                // so a leaf defined by only some options is still assessed on the options
+                // that do define it. A scalar/non-combo defining option (getComboOptions
+                // undefined) can't fail membership — it's a normal required input.
+                let memberWhereDefined = true;
+                if (Array.isArray(pOpts)) {
+                    for (const o of pOpts) {
+                        anyOption = true;
+                        const s = o?.inputs?.required?.[leaf] ?? o?.inputs?.optional?.[leaf];
+                        if (s === undefined) {
+                            // This option omits the leaf entirely (orphan if IT resolves).
+                            definedEverywhere = false;
+                            continue;
+                        }
+                        definedSomewhere = true;
+                        if (leafIsLink)
+                            continue; // link ref: definition is all we can check
+                        const optList = getComboOptions(s);
+                        if (Array.isArray(optList) && !optList.includes(leafVal)) {
+                            memberWhereDefined = false;
+                        }
+                    }
+                }
+                // Decision, split by leaf kind:
+                //  - LINK-REF leaf: its runtime value is unknowable, so the only defense
+                //    against orphaning it under an option that omits the leaf is strict
+                //    default-DENY — keep only if EVERY option defines it. Dropping a link
+                //    ref discards no user-authored scalar (the connection's value is
+                //    runtime), so the strict rule is cheap and safe.
+                //  - LITERAL leaf: it is a concrete USER VALUE. Dropping it just because
+                //    SOME option omits the leaf silently discards the user's input on a
+                //    resolution that may never occur (#517 P0-B: option A defines
+                //    strength=0.75, option B omits it — the strict rule deleted 0.75 even
+                //    though A is the live selection). A deterministic parent never reaches
+                //    this branch (a Primitive/positional parent is a STRING, re-anchored
+                //    against its RESOLVED option in the non-array path above), so here the
+                //    selection is genuinely unknowable — preserve a literal that at least
+                //    one option DEFINES, provided it stays a valid member wherever a
+                //    defining option enumerates options. A wrong-option literal (defined by
+                //    all options but out-of-list for one — the test-1216 case) still fails
+                //    memberWhereDefined and is dropped, so no invalid literal reaches the
+                //    prompt.
+                const drop = !anyOption
+                    ? true
+                    : leafIsLink
+                        ? !definedEverywhere
+                        : !definedSomewhere || !memberWhereDefined;
+                if (drop) {
+                    // A dropped LINK-REF leaf is a real connection the user wired — deleting it
+                    // silently would make the parent's runtime option fall back to its default
+                    // with no trace (FIX 2, #517). Keep the strict default-deny (safest against
+                    // orphaning under an option that omits the leaf), but WARN so the removed
+                    // link + parent are surfaced rather than silently discarded.
+                    if (leafIsLink) {
+                        warnings.push(`Node ${nodeId} (${classType}): the linked nested input "${key}" was dropped — its dynamic parent "${parent}" is fed by a runtime link (resolved option unknown) and not every option defines "${leaf}", so keeping the connection could orphan it under an option that omits the leaf. "${leaf}" will use the resolved option's default instead of the wired link.`);
+                    }
+                    delete inputs[key];
+                }
+                continue;
+            }
+            const { leafName, spec } = resolveWidgetSpec(def, key, inputs);
+            if (spec === undefined) {
+                // The final selected option does not define this leaf — it belongs to the
+                // superseded option and would be an unknown input on the current one. Drop
+                // it whether it's a literal OR a real-link ref (both orphan under the final
+                // option; a link ref is not exempt — the previous `continue` above leaked
+                // exactly this case).
+                delete inputs[key];
+                continue;
+            }
+            // Leaf IS defined by the final selected option. A real-link ref into a defined
+            // leaf is a valid connection whose runtime value ComfyUI validates — keep it
+            // as-is (there's no literal to re-validate here).
+            if (leafIsLink)
+                continue;
+            inputs[key] = validateComboValueForSpec(leafName, leafVal, spec, classType, nodeId, warnings);
+        }
         // rgthree "Power Lora Loader" stores its loras in widgets_values as a list of
         // {on, lora, strength, strengthTwo} objects, NOT as named inputs — its Python
         // reads them from kwargs keyed lora_1, lora_2, …. Translate them here so the
@@ -1324,6 +2014,11 @@ export function convertUiToApi(ui, objectInfo) {
     const nodeCount = Object.keys(workflow).length;
     const skipped = expanded.nodes.length - nodeCount;
     logger.info(`Converted UI workflow: ${nodeCount} nodes (${skipped} skipped)`);
-    return { workflow, warnings };
+    // De-duplicate identical warnings. A value can legitimately be validated twice
+    // (positional pass, then the final dynamic-parent re-anchor pass) and produce
+    // the same message; identical strings already embed node id + input, so exact
+    // duplicates are pure noise. Distinct nodes/inputs keep their own warnings.
+    const dedupedWarnings = [...new Set(warnings)];
+    return { workflow, warnings: dedupedWarnings };
 }
 //# sourceMappingURL=workflow-converter.js.map