comfyui-mcp 0.52.199 → 0.52.200

package/dist/orchestrator/panel-tools.js

@@ -6035,13 +6035,21 @@ function forgetStaleSubgraphIdentity(ctx) {
     ctx.bridge?.clearPromotedSubgraphIdentity?.(ctx.tabId);
 }
 /** Tabs whose promoted-container mapping is unverified after a queue-busy
- * mutation refusal. `graph_get_subgraph` can stay indeterminate for ordinary
- * root nodes until something walks the live graph (#2730). */
+ * mutation refusal or a canvas-replacing load. `graph_get_subgraph` can stay
+ * indeterminate for ordinary root nodes and live subgraphs until something
+ * walks the live graph (#2730, #2886). */
 const staleSubgraphMappingTabs = new Set();
 function noteStaleSubgraphMapping(tabId) {
     if (tabId)
         staleSubgraphMappingTabs.add(tabId);
 }
+/** A successful `graph_load` replaced the canvas. Drop leftover subgraph
+ * identity and force one mapping refresh before the next promoted write so
+ * `panel_set_widget` does not stay refused until a manual current-target rebind. */
+function noteCanvasReplacedForPromotedWrites(ctx) {
+    forgetStaleSubgraphIdentity(ctx);
+    noteStaleSubgraphMapping(ctx.tabId);
+}
 export function __resetStaleSubgraphMappingForTest() {
     staleSubgraphMappingTabs.clear();
 }
@@ -6586,6 +6594,9 @@ function classifyPromotedSubgraphReadError(res) {
     }
     return "permanent";
 }
+function isStaleSubgraphMappingRead(res) {
+    return /subgraph mapping is not loaded/i.test(textOfToolResult(res));
+}
 /**
  * panel#1869 — the panel's `[canvas-root-divergence]` refusal is a DIAGNOSIS,
  * and must not be replaced by the promoted-container wording.
@@ -7442,7 +7453,12 @@ async function preparePromotedWidgetWrite(ctx, nodeId, widget) {
             // ordinary root node. Refresh the mapping once and re-probe. Still
             // unverifiable → refuse. Do not spend the transient subgraph re-read on
             // a permanent application error.
-            if (!mappingRefreshed && rootGraphIdentity !== null) {
+            // #2886 — a live subgraph container has the same stale-registry miss
+            // after graph_load. Re-probing only the ordinary fast path left those
+            // writes refused; retry graph_get_subgraph once the mapping walk ran.
+            // Do not replay other permanent application errors.
+            const mappingUnknown = isStaleSubgraphMappingRead(sub);
+            if (!mappingRefreshed && (rootGraphIdentity !== null || mappingUnknown)) {
                 const refreshError = await refreshSubgraphMapping();
                 if (refreshError)
                     return refreshError;
@@ -7455,61 +7471,89 @@ async function preparePromotedWidgetWrite(ctx, nodeId, widget) {
                         return ordinaryBindingRefusal(widget, driftAfterMapping);
                     return ordinaryWritePlanFromScope(widget, targetScope, tabBefore, identityBefore);
                 }
-            }
-            return promotedSubgraphReadRefusal(widget, sub, "graph_get_subgraph could not determine whether the addressed node is a promoted container");
-        }
-        // A binding/subgraph registration transition can make the first read
-        // indeterminate even though the same live container is readable immediately
-        // afterward. Refresh once, then keep the existing fail-closed classification
-        // and identity checks for the fresh reply.
-        const refreshedSub = await ctx.call({ cmd: "graph_get_subgraph", node_id: nodeId }, undefined, undefined, undefined, PROMOTED_PREFLIGHT_READ_OPTIONS);
-        if (refreshedSub.isError) {
-            const refreshedReadKind = classifyPromotedSubgraphReadError(refreshedSub);
-            if (refreshedReadKind === "definitive-ordinary") {
-                const driftAfterRefresh = panelBindingDriftReason(ctx, "after the subgraph refresh", hasIdentityApi, identityBefore, tabBefore);
-                if (driftAfterRefresh)
-                    return promotedWriteRefusal(widget, driftAfterRefresh);
-                const expectedNodeType = definitiveNonPromotedNodeType(refreshedSub);
-                if (!expectedNodeType) {
-                    return promotedWriteRefusal(widget, "the definitive ordinary refresh did not publish a node type fence");
-                }
-                const expectedNodeIdentity = targetScope?.nodeIdentity;
-                if (!expectedNodeIdentity) {
-                    return promotedWriteRefusal(widget, "the preflight ordinary-node read did not publish a trustworthy node identity fence");
+                if (mappingUnknown) {
+                    sub = await ctx.call({ cmd: "graph_get_subgraph", node_id: nodeId }, undefined, undefined, undefined, PROMOTED_PREFLIGHT_READ_OPTIONS);
                 }
-                if (ctx.tabExpectedNodeTypeFenceCapability?.() !== true) {
-                    return promotedPanelBuildRefusal(ctx, nodeId, widget, "does not advertise the atomic ordinary-node write fence", "enforces_expected_node_type_at_write");
-                }
-                if (ctx.tabExpectedNodeIdentityFenceCapability?.() !== true) {
-                    return promotedPanelBuildRefusal(ctx, nodeId, widget, "does not advertise the atomic ordinary-node identity write fence", "enforces_expected_node_identity_at_write");
-                }
-                const ordinaryScope = targetScope;
-                if (!ordinaryScope?.graphIdentity) {
-                    return ordinaryBindingRefusal(widget, "did not publish the current graph identity needed to fence this ordinary write");
+            }
+            if (sub.isError) {
+                if (classifyPromotedSubgraphReadError(sub) === "definitive-ordinary") {
+                    const driftAfterMappingRead = panelBindingDriftReason(ctx, "after the subgraph mapping refresh", hasIdentityApi, identityBefore, tabBefore);
+                    if (driftAfterMappingRead)
+                        return promotedWriteRefusal(widget, driftAfterMappingRead);
+                    if (targetScope?.activeView === "subgraph" && targetScope.node === "ordinary") {
+                        if (!targetScope.nodeIdentity)
+                            return null;
+                        const expectedNodeType = definitiveNonPromotedNodeType(sub);
+                        if (!sameDefinitiveOrdinaryNodeType(expectedNodeType, targetScope.nodeType)) {
+                            return promotedWriteRefusal(widget, "the ordinary node type changed between the scope and subgraph reads");
+                        }
+                        if (ctx.tabExpectedNodeTypeFenceCapability?.() !== true) {
+                            return promotedPanelBuildRefusal(ctx, nodeId, widget, "does not advertise the atomic ordinary-node write fence", "enforces_expected_node_type_at_write");
+                        }
+                        if (ctx.tabExpectedNodeIdentityFenceCapability?.() !== true) {
+                            return promotedPanelBuildRefusal(ctx, nodeId, widget, "does not advertise the atomic ordinary-node identity write fence", "enforces_expected_node_identity_at_write");
+                        }
+                        return ordinaryWritePlanFromScope(widget, targetScope, tabBefore, identityBefore);
+                    }
+                    return null;
                 }
-                return {
-                    kind: "ordinary-write",
-                    activeView: ordinaryScope.activeView,
-                    ...(ordinaryScope.scopeOwnerNodeId !== undefined
-                        ? { scopeOwnerNodeId: ordinaryScope.scopeOwnerNodeId }
-                        : {}),
-                    graphIdentity: ordinaryScope.graphIdentity,
-                    ...(ordinaryScope.workflowUuid !== undefined
-                        ? { workflowUuid: ordinaryScope.workflowUuid }
-                        : {}),
-                    expectedNodeType,
-                    expectedNodeIdentity,
-                    binding: {
-                        tabId: tabBefore,
-                        ...(isUsablePanelConnectionIdentity(identityBefore)
-                            ? { identity: identityBefore }
+                return promotedSubgraphReadRefusal(widget, sub, "graph_get_subgraph could not determine whether the addressed node is a promoted container");
+            }
+        }
+        else {
+            // A binding/subgraph registration transition can make the first read
+            // indeterminate even though the same live container is readable immediately
+            // afterward. Refresh once, then keep the existing fail-closed classification
+            // and identity checks for the fresh reply.
+            const refreshedSub = await ctx.call({ cmd: "graph_get_subgraph", node_id: nodeId }, undefined, undefined, undefined, PROMOTED_PREFLIGHT_READ_OPTIONS);
+            if (refreshedSub.isError) {
+                const refreshedReadKind = classifyPromotedSubgraphReadError(refreshedSub);
+                if (refreshedReadKind === "definitive-ordinary") {
+                    const driftAfterRefresh = panelBindingDriftReason(ctx, "after the subgraph refresh", hasIdentityApi, identityBefore, tabBefore);
+                    if (driftAfterRefresh)
+                        return promotedWriteRefusal(widget, driftAfterRefresh);
+                    const expectedNodeType = definitiveNonPromotedNodeType(refreshedSub);
+                    if (!expectedNodeType) {
+                        return promotedWriteRefusal(widget, "the definitive ordinary refresh did not publish a node type fence");
+                    }
+                    const expectedNodeIdentity = targetScope?.nodeIdentity;
+                    if (!expectedNodeIdentity) {
+                        return promotedWriteRefusal(widget, "the preflight ordinary-node read did not publish a trustworthy node identity fence");
+                    }
+                    if (ctx.tabExpectedNodeTypeFenceCapability?.() !== true) {
+                        return promotedPanelBuildRefusal(ctx, nodeId, widget, "does not advertise the atomic ordinary-node write fence", "enforces_expected_node_type_at_write");
+                    }
+                    if (ctx.tabExpectedNodeIdentityFenceCapability?.() !== true) {
+                        return promotedPanelBuildRefusal(ctx, nodeId, widget, "does not advertise the atomic ordinary-node identity write fence", "enforces_expected_node_identity_at_write");
+                    }
+                    const ordinaryScope = targetScope;
+                    if (!ordinaryScope?.graphIdentity) {
+                        return ordinaryBindingRefusal(widget, "did not publish the current graph identity needed to fence this ordinary write");
+                    }
+                    return {
+                        kind: "ordinary-write",
+                        activeView: ordinaryScope.activeView,
+                        ...(ordinaryScope.scopeOwnerNodeId !== undefined
+                            ? { scopeOwnerNodeId: ordinaryScope.scopeOwnerNodeId }
                             : {}),
-                    },
-                };
+                        graphIdentity: ordinaryScope.graphIdentity,
+                        ...(ordinaryScope.workflowUuid !== undefined
+                            ? { workflowUuid: ordinaryScope.workflowUuid }
+                            : {}),
+                        expectedNodeType,
+                        expectedNodeIdentity,
+                        binding: {
+                            tabId: tabBefore,
+                            ...(isUsablePanelConnectionIdentity(identityBefore)
+                                ? { identity: identityBefore }
+                                : {}),
+                        },
+                    };
+                }
+                return promotedSubgraphReadRefusal(widget, refreshedSub, "graph_get_subgraph could not determine whether the addressed node is a promoted container");
             }
-            return promotedSubgraphReadRefusal(widget, refreshedSub, "graph_get_subgraph could not determine whether the addressed node is a promoted container");
+            sub = refreshedSub;
         }
-        sub = refreshedSub;
     }
     let payload = parseToolResultJson(sub);
     if (!payload || !promotedEnvelopeCarriesEvidence(payload)) {
@@ -17918,6 +17962,12 @@ export function buildPanelToolDefs() {
                 // `format:"api"`. That field is present only on this branch, which makes it the
                 // signal rather than an inference.
                 const reply = parseToolResultJson(loaded);
+                // #2886 — a successful load replaces the canvas. UI-format keeps the
+                // instance uuid, so the fence is still valid, but leftover subgraph
+                // identity and the subgraph registry still describe the PREVIOUS graph.
+                // Mark mapping stale here; do not re-derive from whatever is active now.
+                if (reply?.loaded === true)
+                    noteCanvasReplacedForPromotedWrites(ctx);
                 const remintedInstance = reply?.loaded === true && reply?.format === "api";
                 if (!remintedInstance)
                     return loaded;