From 53cfed5ce6c7e0257236132b1fb3890de8bb0d98 Mon Sep 17 00:00:00 2001 From: "claude[bot]" <209825114+claude[bot]@users.noreply.github.com> Date: Thu, 24 Sep 2026 00:01:57 +0000 Subject: [PATCH 1/3] fix: subgraph-interior widgets don't render in Vue mode after insert_workflow (#18634) ## Summary Fixes missing Vue widgets on nodes inside a subgraph inserted through `insert_workflow`. Multiplayer assigns inserted nodes colon-bearing local IDs. Those IDs cannot be represented safely as colon-delimited locator or execution paths, so widget rendering now resolves live nodes from the existing `(graphId, nodeId)` state instead. ## Changes - Resolve widget hosts directly within their owning graph without parsing the local node ID. - Continue rendering and updating stored widgets when no valid execution ID exists, while skipping execution-keyed error operations. - Prevent `LGraph.getNodeById` from returning inherited object properties. - Cover the real insert/projection/widget-model path, the pre-graph-ready fallback, scope collisions, and inherited registry keys. ## Verification - `pnpm exec vitest run src/lib/litegraph/src/LGraph.test.ts src/utils/graphTraversalUtil.test.ts src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts` (280 passed) - `pnpm typecheck:app` - ESLint, type-aware oxlint, formatting, and Knip passed on the changed files. --------- --- src/lib/litegraph/src/LGraph.test.ts | 7 + src/lib/litegraph/src/LGraph.ts | 4 +- ...SubgraphInteriorWidgets.regression.test.ts | 170 ++++++++++++++++++ .../composables/processedWidgetRenderModel.ts | 54 +++--- .../composables/useProcessedWidgets.test.ts | 31 ++++ .../composables/useProcessedWidgets.ts | 8 +- src/utils/graphTraversalUtil.test.ts | 22 +++ src/utils/graphTraversalUtil.ts | 11 ++ 8 files changed, 273 insertions(+), 34 deletions(-) create mode 100644 src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts diff --git a/src/lib/litegraph/src/LGraph.test.ts b/src/lib/litegraph/src/LGraph.test.ts index e4e31f5e846..d5a29e8c355 100644 --- a/src/lib/litegraph/src/LGraph.test.ts +++ b/src/lib/litegraph/src/LGraph.test.ts @@ -331,6 +331,13 @@ describe('LGraph', () => { expect(graph.last_node_id).toBe(7) }) + it.for(['constructor', 'toString', '__proto__'])( + 'does not return inherited property %s as a node', + (id) => { + expect(new LGraph().getNodeById(toNodeId(id))).toBeNull() + } + ) + describe('duplicate node-instance invariants', () => { function createGraphsSharingANodeId() { const ownerGraph = new LGraph() diff --git a/src/lib/litegraph/src/LGraph.ts b/src/lib/litegraph/src/LGraph.ts index 4a3fac5292d..884f6c6a147 100644 --- a/src/lib/litegraph/src/LGraph.ts +++ b/src/lib/litegraph/src/LGraph.ts @@ -1627,7 +1627,9 @@ export class LGraph * Returns a node by its id. */ getNodeById(id: NodeId | null | undefined): LGraphNode | null { - return id != null && id !== UNASSIGNED_NODE_ID + return id != null && + id !== UNASSIGNED_NODE_ID && + Object.hasOwn(this._nodes_by_id, id) ? (this._nodes_by_id[id] ?? null) : null } diff --git a/src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts b/src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts new file mode 100644 index 00000000000..d63675d5ce1 --- /dev/null +++ b/src/renderer/extensions/vueNodes/composables/insertWorkflowSubgraphInteriorWidgets.regression.test.ts @@ -0,0 +1,170 @@ +import { applyOps, mint } from '@comfyorg/comfy-multi-player' +import type { + InsertWorkflowOp, + WidgetCatalog +} from '@comfyorg/comfy-multi-player' +import { assert, beforeEach, expect, it, onTestFinished } from 'vitest' +import * as Y from 'yjs' + +import { + LGraph, + LGraphNode, + LiteGraph, + SubgraphNode +} from '@/lib/litegraph/src/litegraph' +import { + createTestSubgraph, + createTestSubgraphNode, + enableSubgraphNodeCreation +} from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers' +import { + stripGraphPrefix, + useWidgetValueStore +} from '@/stores/widgetValueStore' +import { graphScopeOf } from '@/types/graphScopeId' +import { toNodeId } from '@/types/nodeId' +import { inertPlacementPort } from '@/workbench/extensions/agent/crdt/__fixtures__/inertPlacementPort' +import { AgentCrdtProjection } from '@/workbench/extensions/agent/crdt/agentCrdtProjection' +import { FollowerDoc } from '@/workbench/extensions/agent/crdt/followerDoc' +import { createGraphMutations } from '@/workbench/extensions/agent/crdt/graphMutations' + +import type { WidgetUiCallbacks } from './processedWidgetRenderModel' +import { computeProcessedWidgets } from './useProcessedWidgets' + +class InteriorWidgetNode extends LGraphNode { + constructor() { + super('interior-widget') + this.serialize_widgets = true + this.addWidget('text', 'prompt', 'before insert', () => {}) + } +} + +const catalog: WidgetCatalog = { + types: { + 'interior-widget': { widget_order: ['prompt'] } + } +} + +const noopUi: WidgetUiCallbacks = { + getTooltipConfig: () => ({}), + handleNodeRightClick: () => {} +} + +beforeEach(() => { + LiteGraph.registerNodeType('interior-widget', InteriorWidgetNode) +}) + +function bindProjection(workflowId: string, graph: LGraph) { + const follower = new FollowerDoc() + const projection = new AgentCrdtProjection( + createGraphMutations({ + getScope: () => graphScopeOf(graph), + layout: { createNode: () => {}, deleteNodes: () => {} }, + placement: inertPlacementPort + }), + () => graph, + () => follower.doc + ) + projection.bind(workflowId, follower) + onTestFinished(() => { + projection.destroy() + follower.destroy() + }) + + let sequence = 0 + return (update: Uint8Array, opIds: string[]) => { + follower.applyRemoteUpdate(update) + const committed = projection.applyFrame({ + workflowId, + seq: ++sequence, + update, + actor: 'agent:test', + opIds + }) + projection.reconcileLiveGraph(workflowId) + return committed + } +} + +function serializeWorkflow(graph: LGraph): InsertWorkflowOp['workflow'] { + return JSON.parse( + JSON.stringify(graph.serialize()) + ) as InsertWorkflowOp['workflow'] +} + +it('produces a live Vue widget model for an inserted subgraph-interior node', () => { + const graph = new LGraph() + onTestFinished(enableSubgraphNodeCreation(graph)) + + const blueprint = new LGraph() + const subgraph = createTestSubgraph({ rootGraph: blueprint }) + blueprint.subgraphs.set(subgraph.id, subgraph) + + const interior = LiteGraph.createNode('interior-widget') + assert(interior) + interior.id = toNodeId(42) + subgraph.add(interior) + assert(interior.widgets?.[0]) + interior.widgets[0].value = 'after insert' + blueprint.add(createTestSubgraphNode(subgraph, { id: 1 })) + + const hostDoc = mint({ nodes: [], links: [] }, catalog) + onTestFinished(() => hostDoc.destroy()) + const deliver = bindProjection('inserted-subgraph-widget', graph) + deliver(Y.encodeStateAsUpdate(hostDoc), []) + + const operation: InsertWorkflowOp = { + op_id: 'inserted-subgraph-widget-test-0001', + actor: 'agent:test', + base_version: 1, + stamp: [1, 'agent:test'], + op: 'insert_workflow', + workflow: serializeWorkflow(blueprint) + } + const vector = Y.encodeStateVector(hostDoc) + expect(applyOps(hostDoc, [operation], catalog).outcomes).toEqual([ + { op_id: operation.op_id, outcome: 'applied' } + ]) + expect( + deliver(Y.encodeStateAsUpdate(hostDoc, vector), [operation.op_id]) + ).toBe(true) + + const instance = graph._nodes.find( + (node): node is SubgraphNode => node instanceof SubgraphNode + ) + assert(instance) + const materialized = instance.subgraph._nodes.find( + (node) => node.type === 'interior-widget' + ) + assert(materialized) + expect(String(materialized.id)).toContain(':') + + const rootGraphId = graph.rootGraph.id + const localNodeId = stripGraphPrefix(String(materialized.id)) + assert(localNodeId) + const widgetIds = useWidgetValueStore().getNodeWidgetIds( + rootGraphId, + localNodeId + ) + const processed = computeProcessedWidgets({ + nodeData: materialized._state, + widgetIds, + graphId: rootGraphId, + showAdvanced: false, + isGraphReady: true, + rootGraph: graph, + ui: noopUi + }) + + expect( + processed.map(({ visible, simplified }) => ({ + name: simplified.name, + value: simplified.value, + visible + })) + ).toEqual([{ name: 'prompt', value: 'after insert', visible: true }]) + + assert(processed[0]) + processed[0].updateHandler('updated through Vue') + expect(materialized.widgets?.[0]?.value).toBe('updated through Vue') +}) diff --git a/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts b/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts index c23fc68e16f..0b5361dd4f6 100644 --- a/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts +++ b/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts @@ -27,8 +27,8 @@ import { useWidgetValueStore } from '@/stores/widgetValueStore' import { - createLeafNodeExecutionId, - createLeafNodeLocatorId + createNodeExecutionId, + createNodeLocatorId } from '@/types/nodeIdentification' import type { NodeExecutionId, NodeLocatorId } from '@/types/nodeIdentification' import type { NodeId } from '@/types/nodeId' @@ -47,8 +47,7 @@ import type { WidgetId } from '@/types/widgetId' import { executionIdFromState, executionIdToNodeLocatorId, - getNodeByLocatorId, - locatorIdFromState, + getNodeByState, subgraphIdFromState } from '@/utils/graphTraversalUtil' import { mapLiveWidgetsById } from '@/utils/litegraphUtil' @@ -166,8 +165,7 @@ function getHostNode( nodeData: NodeState ): LGraphNode | null { if (!rootGraph) return null - const locatorId = locatorIdFromState(nodeData, rootGraph.id) - return locatorId ? getNodeByLocatorId(rootGraph, locatorId) : null + return getNodeByState(rootGraph, nodeData) } function isWidgetVisible( @@ -183,7 +181,7 @@ function isWidgetVisible( function hasWidgetError( widget: { name: string; errorTarget?: WidgetErrorTarget }, - nodeExecId: NodeExecutionId, + nodeExecId: NodeExecutionId | null, nodeErrors: | { errors: { extra_info?: { input_name?: string } }[] } | undefined, @@ -195,8 +193,9 @@ function hasWidgetError( !!nodeErrors?.errors.some( (e) => e.extra_info?.input_name === widget.name ) || - missingModelStore.isWidgetMissingModel(nodeExecId, widget.name) || - missingMediaStore.isWidgetMissingMedia(nodeExecId, widget.name) + (nodeExecId !== null && + (missingModelStore.isWidgetMissingModel(nodeExecId, widget.name) || + missingMediaStore.isWidgetMissingMedia(nodeExecId, widget.name))) const target = widget.errorTarget if (!target) return hasHostError @@ -226,7 +225,7 @@ function createWidgetUpdateHandler({ id: WidgetId live?: { node: LGraphNode; widget: IBaseWidget } errorTarget?: WidgetErrorTarget - nodeExecId: NodeExecutionId + nodeExecId: NodeExecutionId | null widgetName: string widgetOptions: IWidgetOptions executionErrorStore: ReturnType @@ -251,13 +250,15 @@ function createWidgetUpdateHandler({ options ) } - executionErrorStore.clearWidgetRelatedErrors( - nodeExecId, - widgetName, - widgetName, - newValue, - options - ) + if (nodeExecId) { + executionErrorStore.clearWidgetRelatedErrors( + nodeExecId, + widgetName, + widgetName, + newValue, + options + ) + } } } @@ -335,12 +336,10 @@ function widgetNodeLocatorId( ) if (sourceLocator) return sourceLocator } - if (!bareWidgetId) return undefined - return ( - createLeafNodeLocatorId( - subgraphIdFromState(ctx.nodeData, ctx.rootGraphId), - bareWidgetId - ) ?? undefined + if (!bareWidgetId || bareWidgetId.includes(':')) return undefined + return createNodeLocatorId( + subgraphIdFromState(ctx.nodeData, ctx.rootGraphId), + bareWidgetId ) } @@ -353,7 +352,7 @@ interface WidgetProcessingContext { hostNode: LGraphNode | null liveWidgets: Map slotMetadata: Map - nodeExecId: NodeExecutionId + nodeExecId: NodeExecutionId | null nodeErrors: Parameters[2] widgetValueStore: ReturnType executionErrorStore: ReturnType @@ -492,8 +491,7 @@ export function computeProcessedWidgets({ const nodeExecId = isGraphReady && rootGraph ? executionIdFromState(rootGraph, nodeData) - : createLeafNodeExecutionId(nodeData.id) - if (!nodeExecId) return [] + : createNodeExecutionId([nodeData.id]) const hostNode = getHostNode(rootGraph, nodeData) const liveWidgets = hostNode @@ -525,7 +523,9 @@ export function computeProcessedWidgets({ liveWidgets, slotMetadata, nodeExecId, - nodeErrors: executionErrorStore.lastNodeErrors?.[nodeExecId], + nodeErrors: nodeExecId + ? executionErrorStore.lastNodeErrors?.[nodeExecId] + : undefined, widgetValueStore, executionErrorStore, missingModelStore, diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts index 9f57a96119e..e1f4e4b1b3c 100644 --- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts +++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts @@ -10,6 +10,7 @@ import { } from '@/lib/litegraph/src/subgraph/__fixtures__/subgraphHelpers' import type { SubgraphNode } from '@/lib/litegraph/src/subgraph/SubgraphNode' import type { IBaseWidget } from '@/lib/litegraph/src/types/widgets' +import { useMissingMediaStore } from '@/platform/missingMedia/missingMediaStore' import { useMissingModelStore } from '@/platform/missingModel/missingModelStore' import { computeProcessedWidgets } from '@/renderer/extensions/vueNodes/composables/useProcessedWidgets' import WidgetDOM from '@/renderer/extensions/vueNodes/widgets/components/WidgetDOM.vue' @@ -517,6 +518,36 @@ describe('promoted subgraph widgets', () => { }) describe('computeProcessedWidgets', () => { + it('renders an opaque-ID widget before its graph is ready', () => { + const nodeId = toNodeId('insert:abc123:root:node:5') + const id = widgetId(GRAPH_ID, nodeId, 'text') + registerWidgetState(id, { type: 'text', value: 'before' }) + const missingModelSpy = vi.spyOn( + useMissingModelStore(), + 'isWidgetMissingModel' + ) + const missingMediaSpy = vi.spyOn( + useMissingMediaStore(), + 'isWidgetMissingMedia' + ) + const clearErrorSpy = vi.spyOn( + useExecutionErrorStore(), + 'clearWidgetRelatedErrors' + ) + + const [processed] = processWidgets({ widgetIds: [id], nodeId }) + + expect(processed.simplified.value).toBe('before') + expect(processed.hasError).toBe(false) + expect(missingModelSpy).not.toHaveBeenCalled() + expect(missingMediaSpy).not.toHaveBeenCalled() + + processed.updateHandler('after') + + expect(useWidgetValueStore().getWidget(id)?.value).toBe('after') + expect(clearErrorSpy).not.toHaveBeenCalled() + }) + it('applies advanced border styling to advanced widgets', () => { const id = widgetId(GRAPH_ID, toNodeId(1), 'text') registerWidgetState(id, { type: 'text', options: { advanced: true } }) diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts index 8a50c9c8a4a..b519bad54a8 100644 --- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts +++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.ts @@ -17,18 +17,14 @@ import { app } from '@/scripts/app' import { nodeTypeValidForApp } from '@/stores/appModeStore' import type { NodeState } from '@/types/nodeState' import type { WidgetId } from '@/types/widgetId' -import { - getNodeByLocatorId, - locatorIdFromState -} from '@/utils/graphTraversalUtil' +import { getNodeByState } from '@/utils/graphTraversalUtil' export { computeProcessedWidgets } export type { ProcessedWidget } function getHostNode(nodeData: NodeState): LGraphNode | null { if (!app.isGraphReady) return null - const locatorId = locatorIdFromState(nodeData, app.rootGraph.id) - return locatorId ? getNodeByLocatorId(app.rootGraph, locatorId) : null + return getNodeByState(app.rootGraph, nodeData) } export function useProcessedWidgets( diff --git a/src/utils/graphTraversalUtil.test.ts b/src/utils/graphTraversalUtil.test.ts index d9111785110..dbe5cf2f7e4 100644 --- a/src/utils/graphTraversalUtil.test.ts +++ b/src/utils/graphTraversalUtil.test.ts @@ -18,6 +18,7 @@ import { getLocalNodeIdFromExecutionId, getNodeByExecutionId, getNodeByLocatorId, + getNodeByState, getRootGraph, getSubgraphPathFromExecutionId, executionIdFromState, @@ -1100,6 +1101,27 @@ describe('graphTraversalUtil', () => { }) }) + describe('getNodeByState', () => { + it('uses graph identity to disambiguate colon-bearing node IDs', () => { + const subgraphUuid = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890' + const nodeId = toNodeId(`${subgraphUuid}:node:5`) + const rootNode = createMockNode(nodeId) + const interiorNode = createMockNode(nodeId) + const subgraph = createMockSubgraph(subgraphUuid, [interiorNode]) + const graph = createMockGraph([ + rootNode, + createMockNode('456', { isSubgraph: true, subgraph }) + ]) + + expect( + getNodeByState(graph, { id: nodeId, graphId: ROOT_GRAPH_ID }) + ).toBe(rootNode) + expect( + getNodeByState(graph, { id: nodeId, graphId: subgraphUuid }) + ).toBe(interiorNode) + }) + }) + describe('getNodeByLocatorId', () => { it('should find node in root graph', () => { const nodes = [createMockNode('123'), createMockNode('456')] diff --git a/src/utils/graphTraversalUtil.ts b/src/utils/graphTraversalUtil.ts index 169c045053f..69dc3d5c78a 100644 --- a/src/utils/graphTraversalUtil.ts +++ b/src/utils/graphTraversalUtil.ts @@ -641,6 +641,17 @@ export function executionIdFromState( return getExecutionIdByNode(rootGraph, node) ?? fallback } +export function getNodeByState( + rootGraph: LGraph, + state: Pick +): LGraphNode | null { + const graph = + state.graphId === rootGraph.id + ? rootGraph + : findSubgraphByUuid(rootGraph, state.graphId) + return graph?.getNodeById(state.id) ?? null +} + /** * Get a node by its locator ID from anywhere in the graph hierarchy. * For subgraph nodes, the format is `:` where From 3dc8c6a4169c7325ec52b0313cd28d76d7ad3a69 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 24 Sep 2026 09:31:15 +0000 Subject: [PATCH 2/3] fix: harden node-id registry and restore opaque-id locator tolerance Cursor review follow-ups on #18679 (backport of #18634): - LGraph._nodes_by_id was a plain object literal, so a node id of "__proto__" (accepted by parseNodeId) would repoint the object's prototype on add() instead of creating an own key, permanently hiding that node from getNodeById's new Object.hasOwn guard. Use Object.create(null) so every node id, including "__proto__", is a normal own property. - widgetNodeLocatorId rejected every colon-bearing bareWidgetId, but createLeafNodeLocatorId already tolerates a colon for root-owned ids (no subgraph to disambiguate from) while rejecting it for subgraph-owned ones. Restore that tolerant constructor plus its `?? undefined` normalization so root-owned opaque ids (comfy-multi- player's insert_workflow remapped ids) keep a working nodeLocatorId instead of losing it, and no null return value leaks past this function's NodeLocatorId | undefined contract. --- src/lib/litegraph/src/LGraph.test.ts | 18 ++++++++++++++++++ src/lib/litegraph/src/LGraph.ts | 4 ++-- .../composables/processedWidgetRenderModel.ts | 14 ++++++++------ .../composables/useProcessedWidgets.test.ts | 13 +++++++++++++ 4 files changed, 41 insertions(+), 8 deletions(-) diff --git a/src/lib/litegraph/src/LGraph.test.ts b/src/lib/litegraph/src/LGraph.test.ts index d5a29e8c355..7cc9406d661 100644 --- a/src/lib/litegraph/src/LGraph.test.ts +++ b/src/lib/litegraph/src/LGraph.test.ts @@ -338,6 +338,24 @@ describe('LGraph', () => { } ) + it('registers and retrieves a node whose id is __proto__ without polluting the registry', () => { + const graph = new LGraph() + const node = new LGraphNode('proto-id') + Reflect.set(node, 'id', '__proto__') + + graph.add(node, true) + + expect(graph.getNodeById(toNodeId('__proto__'))).toBe(node) + expect(Object.getPrototypeOf(graph._nodes_by_id)).toBeNull() + + const otherNode = new LGraphNode('other') + graph.add(otherNode, true) + expect(graph.getNodeById(otherNode.id)).toBe(otherNode) + + graph.remove(node) + expect(graph.getNodeById(toNodeId('__proto__'))).toBeNull() + }) + describe('duplicate node-instance invariants', () => { function createGraphsSharingANodeId() { const ownerGraph = new LGraph() diff --git a/src/lib/litegraph/src/LGraph.ts b/src/lib/litegraph/src/LGraph.ts index 884f6c6a147..6e7d5a8e988 100644 --- a/src/lib/litegraph/src/LGraph.ts +++ b/src/lib/litegraph/src/LGraph.ts @@ -623,7 +623,7 @@ export class LGraph readonly events = new CustomEventTarget() readonly _subgraphs: Map = new Map() _nodes: (LGraphNode | SubgraphNode)[] = [] - _nodes_by_id: Partial> = {} + _nodes_by_id: Partial> = Object.create(null) _nodes_in_order: LGraphNode[] = [] _nodes_executable: LGraphNode[] | null = null _groups: LGraphGroup[] = [] @@ -833,7 +833,7 @@ export class LGraph this._subgraphs.clear() this._nodes = [] - this._nodes_by_id = {} + this._nodes_by_id = Object.create(null) this._nodes_in_order = [] this._nodes_executable = null this._groups = [] diff --git a/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts b/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts index 0b5361dd4f6..280fe1adb30 100644 --- a/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts +++ b/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts @@ -27,8 +27,8 @@ import { useWidgetValueStore } from '@/stores/widgetValueStore' import { - createNodeExecutionId, - createNodeLocatorId + createLeafNodeLocatorId, + createNodeExecutionId } from '@/types/nodeIdentification' import type { NodeExecutionId, NodeLocatorId } from '@/types/nodeIdentification' import type { NodeId } from '@/types/nodeId' @@ -336,10 +336,12 @@ function widgetNodeLocatorId( ) if (sourceLocator) return sourceLocator } - if (!bareWidgetId || bareWidgetId.includes(':')) return undefined - return createNodeLocatorId( - subgraphIdFromState(ctx.nodeData, ctx.rootGraphId), - bareWidgetId + if (!bareWidgetId) return undefined + return ( + createLeafNodeLocatorId( + subgraphIdFromState(ctx.nodeData, ctx.rootGraphId), + bareWidgetId + ) ?? undefined ) } diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts index e1f4e4b1b3c..e237c057413 100644 --- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts +++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts @@ -20,6 +20,7 @@ import { useLinkStore } from '@/stores/linkStore' import { useWidgetValueStore } from '@/stores/widgetValueStore' import type { WidgetRenderState } from '@/stores/widgetValueStore' import { + createLeafNodeLocatorId, createNodeExecutionId, createNodeLocatorId } from '@/types/nodeIdentification' @@ -548,6 +549,18 @@ describe('computeProcessedWidgets', () => { expect(clearErrorSpy).not.toHaveBeenCalled() }) + it('resolves the widget locator for a root-owned opaque id whole', () => { + const nodeId = toNodeId('insert:abc123:root:node:5') + const id = widgetId(GRAPH_ID, nodeId, 'text') + registerWidgetState(id, { type: 'text', value: 'before' }) + + const [processed] = processWidgets({ widgetIds: [id], nodeId }) + + expect(processed.simplified.nodeLocatorId).toBe( + createLeafNodeLocatorId(null, nodeId) + ) + }) + it('applies advanced border styling to advanced widgets', () => { const id = widgetId(GRAPH_ID, toNodeId(1), 'text') registerWidgetState(id, { type: 'text', options: { advanced: true } }) From 7d1a9c87ef2ae022b72f98431aff6bf4ca980fe1 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 24 Sep 2026 09:35:32 +0000 Subject: [PATCH 3/3] fix: guard lastNodeErrors lookups against inherited Object.prototype keys A node whose id is exactly constructor/toString/valueOf resolves lastNodeErrors[id] to the inherited Object.prototype member instead of undefined when it has no recorded error, which crashed hasWidgetError's .errors.some(...) call. Add getOwnNodeErrors (Object.hasOwn-guarded, mirroring the LGraph.getNodeById fix) and use it at both lastNodeErrors read sites in processedWidgetRenderModel.ts. --- .../composables/processedWidgetRenderModel.ts | 22 ++++++++++++++-- .../composables/useProcessedWidgets.test.ts | 26 +++++++++++++++++++ 2 files changed, 46 insertions(+), 2 deletions(-) diff --git a/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts b/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts index 280fe1adb30..de2c3ab0291 100644 --- a/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts +++ b/src/renderer/extensions/vueNodes/composables/processedWidgetRenderModel.ts @@ -179,6 +179,21 @@ function isWidgetVisible( }) } +/** + * `lastNodeErrors` is a plain record keyed by execution id; a node whose id + * is `constructor`/`toString`/`valueOf` (accepted by `parseNodeId`) would + * otherwise resolve to the inherited `Object.prototype` member instead of + * `undefined` when it has no recorded error. + */ +function getOwnNodeErrors( + nodeErrors: Record | null | undefined, + id: string +): T | undefined { + return nodeErrors && Object.hasOwn(nodeErrors, id) + ? nodeErrors[id] + : undefined +} + function hasWidgetError( widget: { name: string; errorTarget?: WidgetErrorTarget }, nodeExecId: NodeExecutionId | null, @@ -199,7 +214,10 @@ function hasWidgetError( const target = widget.errorTarget if (!target) return hasHostError - const sourceErrors = executionErrorStore.lastNodeErrors?.[target.executionId] + const sourceErrors = getOwnNodeErrors( + executionErrorStore.lastNodeErrors, + target.executionId + ) return ( hasHostError || !!sourceErrors?.errors.some( @@ -526,7 +544,7 @@ export function computeProcessedWidgets({ slotMetadata, nodeExecId, nodeErrors: nodeExecId - ? executionErrorStore.lastNodeErrors?.[nodeExecId] + ? getOwnNodeErrors(executionErrorStore.lastNodeErrors, nodeExecId) : undefined, widgetValueStore, executionErrorStore, diff --git a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts index e237c057413..329881abf20 100644 --- a/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts +++ b/src/renderer/extensions/vueNodes/composables/useProcessedWidgets.test.ts @@ -405,6 +405,32 @@ describe('widget error state', () => { ) expect(processWidgetNamed('ckpt_name').hasError).toBe(true) }) + + it('does not crash on an inherited Object.prototype member id', () => { + useExecutionErrorStore().recordNodeErrors({ + [createNodeExecutionId([toNodeId(2)])]: { + errors: [ + { + type: 'required_input_missing', + message: 'seed is required', + details: '', + extra_info: { input_name: 'seed' } + } + ], + class_type: 'TestNode', + dependent_outputs: [] + } + }) + const id = widgetId(GRAPH_ID, toNodeId('constructor'), 'seed') + registerWidgetState(id, { type: 'combo' }) + + const [processed] = processWidgets({ + widgetIds: [id], + nodeId: toNodeId('constructor') + }) + + expect(processed.hasError).toBe(false) + }) }) describe('promoted subgraph widgets', () => {