diff --git a/src/lib/litegraph/src/LGraph.test.ts b/src/lib/litegraph/src/LGraph.test.ts index e4e31f5e846..7cc9406d661 100644 --- a/src/lib/litegraph/src/LGraph.test.ts +++ b/src/lib/litegraph/src/LGraph.test.ts @@ -331,6 +331,31 @@ 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() + } + ) + + 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 4a3fac5292d..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 = [] @@ -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..de2c3ab0291 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 + createLeafNodeLocatorId, + createNodeExecutionId } 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( @@ -181,9 +179,24 @@ 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, + nodeExecId: NodeExecutionId | null, nodeErrors: | { errors: { extra_info?: { input_name?: string } }[] } | undefined, @@ -195,12 +208,16 @@ 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 - const sourceErrors = executionErrorStore.lastNodeErrors?.[target.executionId] + const sourceErrors = getOwnNodeErrors( + executionErrorStore.lastNodeErrors, + target.executionId + ) return ( hasHostError || !!sourceErrors?.errors.some( @@ -226,7 +243,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 +268,15 @@ function createWidgetUpdateHandler({ options ) } - executionErrorStore.clearWidgetRelatedErrors( - nodeExecId, - widgetName, - widgetName, - newValue, - options - ) + if (nodeExecId) { + executionErrorStore.clearWidgetRelatedErrors( + nodeExecId, + widgetName, + widgetName, + newValue, + options + ) + } } } @@ -353,7 +372,7 @@ interface WidgetProcessingContext { hostNode: LGraphNode | null liveWidgets: Map slotMetadata: Map - nodeExecId: NodeExecutionId + nodeExecId: NodeExecutionId | null nodeErrors: Parameters[2] widgetValueStore: ReturnType executionErrorStore: ReturnType @@ -492,8 +511,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 +543,9 @@ export function computeProcessedWidgets({ liveWidgets, slotMetadata, nodeExecId, - nodeErrors: executionErrorStore.lastNodeErrors?.[nodeExecId], + nodeErrors: nodeExecId + ? getOwnNodeErrors(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..329881abf20 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' @@ -19,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' @@ -403,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', () => { @@ -517,6 +545,48 @@ 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('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 } }) 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