From ae51e7b320d65f9bd494a0e94123cff1cb6c3fe4 Mon Sep 17 00:00:00 2001 From: bymyself Date: Tue, 24 Mar 2026 16:48:47 -0700 Subject: [PATCH 1/7] test: add perf test for viewport pan sweep GC churn Adds a @perf test that pans aggressively back and forth across a large graph (245 nodes), forcing many nodes to cross the viewport boundary. Measures style recalcs, forced layouts, task duration, heap delta, and DOM node churn. This is PR 1 of 2. The optimization (viewport culling) will follow in a separate PR once this baseline is established on main. --- browser_tests/tests/performance.spec.ts | 39 +++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/browser_tests/tests/performance.spec.ts b/browser_tests/tests/performance.spec.ts index cd6a6afa228..9d86233fdbe 100644 --- a/browser_tests/tests/performance.spec.ts +++ b/browser_tests/tests/performance.spec.ts @@ -154,6 +154,45 @@ test.describe('Performance', { tag: ['@perf'] }, () => { ) }) + test('large graph viewport pan sweep', async ({ comfyPage }) => { + await comfyPage.workflow.loadWorkflow('large-graph-workflow') + + const canvas = comfyPage.canvas + const box = await canvas.boundingBox() + if (!box) throw new Error('Canvas bounding box not available') + + // Pan aggressively across the full graph so many nodes cross the + // viewport boundary, triggering mount/unmount cycles and GC churn. + const centerX = box.x + box.width / 2 + const centerY = box.y + box.height / 2 + await comfyPage.page.mouse.move(centerX, centerY) + await comfyPage.page.mouse.down({ button: 'middle' }) + + await comfyPage.perf.startMeasuring() + + // Sweep right (nodes exit left edge, new nodes enter right edge) + for (let i = 0; i < 120; i++) { + await comfyPage.page.mouse.move(centerX + i * 8, centerY + i * 3) + await comfyPage.nextFrame() + } + // Sweep back left + for (let i = 120; i > 0; i--) { + await comfyPage.page.mouse.move(centerX + i * 8, centerY + i * 3) + await comfyPage.nextFrame() + } + + await comfyPage.page.mouse.up({ button: 'middle' }) + + const m = await comfyPage.perf.stopMeasuring('viewport-pan-sweep') + recordMeasurement(m) + console.log( + `Viewport pan sweep: ${m.styleRecalcs} recalcs, ${m.layouts} layouts, ` + + `${m.taskDurationMs.toFixed(1)}ms task, ` + + `heap Δ${(m.heapDeltaBytes / 1024).toFixed(0)}KB, ` + + `DOM Δ${m.domNodes} nodes` + ) + }) + test('subgraph DOM widget clipping during node selection', async ({ comfyPage }) => { From c5dd55e219bd6a431bd12a16a02f090045d10a8b Mon Sep 17 00:00:00 2001 From: bymyself Date: Tue, 24 Mar 2026 18:35:01 -0700 Subject: [PATCH 2/7] =?UTF-8?q?fix:=20correct=20domNodes=20log=20label=20?= =?UTF-8?q?=E2=80=94=20absolute=20count,=20not=20delta?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit https://github.com/Comfy-Org/ComfyUI_frontend/pull/10479#discussion_r2984981001 --- browser_tests/tests/performance.spec.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/browser_tests/tests/performance.spec.ts b/browser_tests/tests/performance.spec.ts index 9d86233fdbe..e495d3da668 100644 --- a/browser_tests/tests/performance.spec.ts +++ b/browser_tests/tests/performance.spec.ts @@ -189,7 +189,7 @@ test.describe('Performance', { tag: ['@perf'] }, () => { `Viewport pan sweep: ${m.styleRecalcs} recalcs, ${m.layouts} layouts, ` + `${m.taskDurationMs.toFixed(1)}ms task, ` + `heap Δ${(m.heapDeltaBytes / 1024).toFixed(0)}KB, ` + - `DOM Δ${m.domNodes} nodes` + `${m.domNodes} DOM nodes` ) }) From aaa5faf87c13170acdd31ceab4cc8410ea089d89 Mon Sep 17 00:00:00 2001 From: bymyself Date: Tue, 24 Mar 2026 16:35:40 -0700 Subject: [PATCH 3/7] perf: add viewport culling to reduce Vue node mount/unmount GC churn Nodes outside the viewport are no longer rendered as Vue components. This reduces the number of mounted component instances and avoids the costly mount/unmount cycle that was generating excessive GC pressure (~1,273 GC events/sec) during panning. Key design decisions: - Generous viewport margin (0.75x) prevents visible pop-in - Immediate mount when nodes enter viewport - Debounced unmount (250ms) when nodes leave viewport, preventing churn when nodes oscillate at the viewport edge - Throttled visibility recomputation (96ms) during active pan/zoom to avoid making culling itself a per-frame hotspot - Nodes without layout data are always mounted (safe fallback) - Camera state is sampled imperatively via throttle, not bound as a reactive dependency on allNodes, preserving the existing TransformPane optimization that avoids full vdom diffs --- src/components/graph/GraphCanvas.vue | 25 +- .../graph/useViewportCulling.test.ts | 240 ++++++++++++++++++ src/composables/graph/useViewportCulling.ts | 132 ++++++++++ 3 files changed, 396 insertions(+), 1 deletion(-) create mode 100644 src/composables/graph/useViewportCulling.test.ts create mode 100644 src/composables/graph/useViewportCulling.ts diff --git a/src/components/graph/GraphCanvas.vue b/src/components/graph/GraphCanvas.vue index cbc6418f4f7..8166358b8c2 100644 --- a/src/components/graph/GraphCanvas.vue +++ b/src/components/graph/GraphCanvas.vue @@ -147,6 +147,7 @@ import WorkflowTabs from '@/components/topbar/WorkflowTabs.vue' import { useChainCallback } from '@/composables/functional/useChainCallback' import { installErrorClearingHooks } from '@/composables/graph/useErrorClearingHooks' import type { VueNodeData } from '@/composables/graph/useGraphNodeManager' +import { useViewportCulling } from '@/composables/graph/useViewportCulling' import { useVueNodeLifecycle } from '@/composables/graph/useVueNodeLifecycle' import { useNodeBadge } from '@/composables/node/useNodeBadge' import { useCanvasDrop } from '@/composables/useCanvasDrop' @@ -167,6 +168,7 @@ import { useWorkflowPersistenceV2 as useWorkflowPersistence } from '@/platform/w import { useCanvasStore } from '@/renderer/core/canvas/canvasStore' import { useCanvasInteractions } from '@/renderer/core/canvas/useCanvasInteractions' import { layoutStore } from '@/renderer/core/layout/store/layoutStore' +import { useTransformSettling } from '@/renderer/core/layout/transform/useTransformSettling' import TransformPane from '@/renderer/core/layout/transform/TransformPane.vue' import MiniMap from '@/renderer/extensions/minimap/MiniMap.vue' import LGraphNode from '@/renderer/extensions/vueNodes/components/LGraphNode.vue' @@ -282,7 +284,7 @@ watch( } ) -const allNodes = computed((): VueNodeData[] => +const rawNodes = computed((): VueNodeData[] => Array.from(vueNodeLifecycle.nodeManager.value?.vueNodeData?.values() ?? []) ) watch( @@ -302,6 +304,27 @@ watch( } ) +const canvasElement = computed(() => canvasStore.canvas?.canvas) +const { isTransforming } = useTransformSettling(canvasElement, { + settleDelay: 256 +}) + +const nodeLayouts = layoutStore.getAllNodes() + +const { mountedNodeIds } = useViewportCulling({ + rawNodes, + nodeLayouts, + getViewportSize: () => { + const rect = canvasStore.canvas?.canvas?.getBoundingClientRect() + return { width: rect?.width ?? 0, height: rect?.height ?? 0 } + }, + isTransforming +}) + +const allNodes = computed(() => + rawNodes.value.filter((node) => mountedNodeIds.value.has(node.id)) +) + function onLinkOverlayReady(el: HTMLCanvasElement) { if (!canvasStore.canvas) return canvasStore.canvas.overlayCanvas = el diff --git a/src/composables/graph/useViewportCulling.test.ts b/src/composables/graph/useViewportCulling.test.ts new file mode 100644 index 00000000000..3548e0ba23f --- /dev/null +++ b/src/composables/graph/useViewportCulling.test.ts @@ -0,0 +1,240 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { computed, nextTick, ref } from 'vue' + +import type { VueNodeData } from '@/composables/graph/useGraphNodeManager' +import type { NodeId, NodeLayout } from '@/renderer/core/layout/types' + +const mockIsNodeInViewport = vi.fn() + +vi.mock('@/renderer/core/layout/transform/useTransformState', () => ({ + useTransformState: () => ({ + isNodeInViewport: mockIsNodeInViewport, + camera: { x: 0, y: 0, z: 1 } + }) +})) + +// Must import after mock setup +const { useViewportCulling } = + await import('@/composables/graph/useViewportCulling') + +function makeNode(id: string): VueNodeData { + return { + id: id as NodeId, + title: `Node ${id}`, + type: 'test', + mode: 0, + executing: false, + selected: false + } +} + +let layoutCounter = 0 + +function makeLayout(x: number, y: number, w = 200, h = 100): NodeLayout { + return { + id: `layout-${layoutCounter++}`, + position: { x, y }, + size: { width: w, height: h }, + bounds: { x, y, width: w, height: h }, + zIndex: 0, + visible: true + } +} + +describe('useViewportCulling', () => { + const isTransforming = ref(false) + const viewport = { width: 1000, height: 600 } + + beforeEach(() => { + vi.useFakeTimers() + vi.clearAllMocks() + isTransforming.value = false + mockIsNodeInViewport.mockReturnValue(true) + }) + + afterEach(() => { + vi.useRealTimers() + }) + + it('mounts all nodes when all are visible', () => { + const nodes = [makeNode('1'), makeNode('2'), makeNode('3')] + const layouts = new Map([ + ['1', makeLayout(100, 100)], + ['2', makeLayout(300, 100)], + ['3', makeLayout(500, 100)] + ]) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => nodes), + nodeLayouts: computed(() => layouts), + getViewportSize: () => viewport, + isTransforming + }) + + expect(mountedNodeIds.value.size).toBe(3) + expect(mountedNodeIds.value.has('1')).toBe(true) + expect(mountedNodeIds.value.has('2')).toBe(true) + expect(mountedNodeIds.value.has('3')).toBe(true) + }) + + it('culls nodes outside the viewport after debounce', async () => { + const nodes = [makeNode('1'), makeNode('2')] + const layouts = new Map([ + ['1', makeLayout(100, 100)], + ['2', makeLayout(5000, 5000)] + ]) + + mockIsNodeInViewport.mockImplementation( + (pos: [number, number]) => pos[0] < 2000 && pos[1] < 2000 + ) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => nodes), + nodeLayouts: computed(() => layouts), + getViewportSize: () => viewport, + isTransforming + }) + + // Node 2 is outside viewport, but hasn't been pruned yet on + // initial mount since it was never in the set to begin with + // and computeVisibleNodeIds runs immediately + expect(mountedNodeIds.value.has('1')).toBe(true) + expect(mountedNodeIds.value.has('2')).toBe(false) + }) + + it('mounts nodes without layout data', () => { + const nodes = [makeNode('1'), makeNode('2')] + const layouts = new Map([ + ['1', makeLayout(100, 100)] + // Node '2' has no layout + ]) + + mockIsNodeInViewport.mockReturnValue(true) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => nodes), + nodeLayouts: computed(() => layouts), + getViewportSize: () => viewport, + isTransforming + }) + + expect(mountedNodeIds.value.has('1')).toBe(true) + expect(mountedNodeIds.value.has('2')).toBe(true) + }) + + it('mounts all nodes when viewport size is zero', () => { + const nodes = [makeNode('1'), makeNode('2')] + const layouts = new Map([ + ['1', makeLayout(100, 100)], + ['2', makeLayout(5000, 5000)] + ]) + + mockIsNodeInViewport.mockReturnValue(false) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => nodes), + nodeLayouts: computed(() => layouts), + getViewportSize: () => ({ width: 0, height: 0 }), + isTransforming + }) + + expect(mountedNodeIds.value.size).toBe(2) + }) + + it('delays unmounting nodes that leave the viewport', async () => { + const nodes = [makeNode('1'), makeNode('2')] + const layouts = new Map([ + ['1', makeLayout(100, 100)], + ['2', makeLayout(300, 100)] + ]) + + mockIsNodeInViewport.mockReturnValue(true) + + const rawNodes = ref(nodes) + const nodeLayouts = ref(layouts) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => rawNodes.value), + nodeLayouts: computed(() => nodeLayouts.value), + getViewportSize: () => viewport, + isTransforming + }) + + expect(mountedNodeIds.value.size).toBe(2) + + // Node 2 leaves viewport + mockIsNodeInViewport.mockImplementation( + (pos: [number, number]) => pos[0] < 200 + ) + + // Trigger a refresh by updating layouts + nodeLayouts.value = new Map(layouts) + await nextTick() + + // Node 2 should still be mounted (debounce hasn't fired) + expect(mountedNodeIds.value.has('2')).toBe(true) + + // After debounce delay, node 2 should be unmounted + await vi.advanceTimersByTimeAsync(300) + + expect(mountedNodeIds.value.has('1')).toBe(true) + expect(mountedNodeIds.value.has('2')).toBe(false) + }) + + it('immediately mounts nodes entering the viewport', async () => { + const nodes = [makeNode('1'), makeNode('2')] + const layouts = new Map([ + ['1', makeLayout(100, 100)], + ['2', makeLayout(5000, 5000)] + ]) + + mockIsNodeInViewport.mockImplementation( + (pos: [number, number]) => pos[0] < 2000 + ) + + const rawNodes = ref(nodes) + const nodeLayouts = ref(layouts) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => rawNodes.value), + nodeLayouts: computed(() => nodeLayouts.value), + getViewportSize: () => viewport, + isTransforming + }) + + expect(mountedNodeIds.value.has('2')).toBe(false) + + // Node 2 enters viewport + mockIsNodeInViewport.mockReturnValue(true) + nodeLayouts.value = new Map(layouts) + await nextTick() + + // Should be immediately mounted without waiting for debounce + expect(mountedNodeIds.value.has('2')).toBe(true) + }) + + it('handles new nodes being added to the graph', async () => { + const nodes = ref([makeNode('1')]) + const layouts = ref( + new Map([['1', makeLayout(100, 100)]]) + ) + + mockIsNodeInViewport.mockReturnValue(true) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => nodes.value), + nodeLayouts: computed(() => layouts.value), + getViewportSize: () => viewport, + isTransforming + }) + + expect(mountedNodeIds.value.size).toBe(1) + + // Add a new node + nodes.value = [...nodes.value, makeNode('2')] + layouts.value = new Map([...layouts.value, ['2', makeLayout(200, 200)]]) + await nextTick() + + expect(mountedNodeIds.value.has('2')).toBe(true) + }) +}) diff --git a/src/composables/graph/useViewportCulling.ts b/src/composables/graph/useViewportCulling.ts new file mode 100644 index 00000000000..d8b07f52be4 --- /dev/null +++ b/src/composables/graph/useViewportCulling.ts @@ -0,0 +1,132 @@ +/** + * Viewport Culling for Vue Node Components + * + * Controls which nodes are mounted as Vue components based on viewport + * visibility. Nodes entering the viewport are mounted immediately; nodes + * leaving are unmounted after a debounce delay to avoid mount/unmount + * churn when nodes oscillate at the viewport edge during panning. + * + * Visibility checks are throttled during active pan/zoom interactions + * to avoid turning culling into a per-frame reactive hotspot. + */ +import { useDebounceFn, useEventListener, useThrottleFn } from '@vueuse/core' +import { shallowRef, watch } from 'vue' +import type { ComputedRef, Ref } from 'vue' + +import type { VueNodeData } from '@/composables/graph/useGraphNodeManager' +import type { NodeId, NodeLayout } from '@/renderer/core/layout/types' +import { useTransformState } from '@/renderer/core/layout/transform/useTransformState' + +/** Viewport margin as a fraction of viewport dimensions (0.75 = 75% extra) */ +const VIEWPORT_MARGIN = 0.75 + +/** Delay before unmounting nodes that left the viewport */ +const HIDE_DELAY_MS = 250 + +/** Throttle interval for visibility recomputation during pan/zoom */ +const CULL_THROTTLE_MS = 96 + +interface UseViewportCullingOptions { + rawNodes: ComputedRef + nodeLayouts: ComputedRef> + getViewportSize: () => { width: number; height: number } + isTransforming: Ref +} + +export function useViewportCulling({ + rawNodes, + nodeLayouts, + getViewportSize, + isTransforming +}: UseViewportCullingOptions) { + const { isNodeInViewport } = useTransformState() + const mountedNodeIds = shallowRef(new Set()) + + function computeVisibleNodeIds(): Set { + const viewport = getViewportSize() + const layouts = nodeLayouts.value + const visible = new Set() + + if (!viewport.width || !viewport.height) { + for (const node of rawNodes.value) visible.add(node.id) + return visible + } + + for (const node of rawNodes.value) { + const layout = layouts.get(node.id) + + if (!layout) { + visible.add(node.id) + continue + } + + if ( + isNodeInViewport( + [layout.position.x, layout.position.y], + [layout.size.width, layout.size.height], + viewport, + VIEWPORT_MARGIN + ) + ) { + visible.add(node.id) + } + } + + return visible + } + + const pruneMountedNodes = useDebounceFn(() => { + mountedNodeIds.value = computeVisibleNodeIds() + }, HIDE_DELAY_MS) + + function refreshMountedNodes() { + const visibleNow = computeVisibleNodeIds() + const current = mountedNodeIds.value + + let needsPrune = false + const next = new Set(current) + + for (const id of visibleNow) { + next.add(id) + } + + for (const id of next) { + if (!visibleNow.has(id)) { + needsPrune = true + break + } + } + + mountedNodeIds.value = next + + if (needsPrune) { + void pruneMountedNodes() + } + } + + const refreshThrottled = useThrottleFn(refreshMountedNodes, CULL_THROTTLE_MS) + + watch([rawNodes, nodeLayouts], refreshMountedNodes, { immediate: true }) + + const { camera } = useTransformState() + watch( + () => [camera.x, camera.y, camera.z] as const, + () => { + if (isTransforming.value) { + void refreshThrottled() + } + } + ) + + watch(isTransforming, (moving) => { + if (!moving) { + refreshMountedNodes() + } + }) + + useEventListener(window, 'resize', refreshMountedNodes) + + return { + mountedNodeIds + } +} From 08b357ae1892c74161652597b228f6ef4d8ad08e Mon Sep 17 00:00:00 2001 From: bymyself Date: Tue, 24 Mar 2026 18:35:54 -0700 Subject: [PATCH 4/7] perf: skip shallowRef update when mounted node set is unchanged Avoid publishing a new Set to mountedNodeIds when no nodes entered the viewport, preventing unnecessary downstream computed invalidation during pan/zoom ticks. https://github.com/Comfy-Org/ComfyUI_frontend/pull/10481#discussion_r2985002114 --- src/composables/graph/useViewportCulling.ts | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/src/composables/graph/useViewportCulling.ts b/src/composables/graph/useViewportCulling.ts index d8b07f52be4..2cc3e85e4f2 100644 --- a/src/composables/graph/useViewportCulling.ts +++ b/src/composables/graph/useViewportCulling.ts @@ -83,21 +83,28 @@ export function useViewportCulling({ const visibleNow = computeVisibleNodeIds() const current = mountedNodeIds.value + let hasNewNodes = false let needsPrune = false - const next = new Set(current) + let next = current for (const id of visibleNow) { - next.add(id) + if (!current.has(id)) { + if (next === current) next = new Set(current) + next.add(id) + hasNewNodes = true + } } - for (const id of next) { + for (const id of current) { if (!visibleNow.has(id)) { needsPrune = true break } } - mountedNodeIds.value = next + if (hasNewNodes) { + mountedNodeIds.value = next + } if (needsPrune) { void pruneMountedNodes() From ca0e41a786ef8c642ab5f88612e82713b1176a0e Mon Sep 17 00:00:00 2001 From: bymyself Date: Wed, 25 Mar 2026 11:41:58 -0700 Subject: [PATCH 5/7] fix: add ResizeObserver on canvas element for sidebar/splitter resizes --- src/components/graph/GraphCanvas.vue | 3 ++- src/composables/graph/useViewportCulling.ts | 15 +++++++++++++-- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/src/components/graph/GraphCanvas.vue b/src/components/graph/GraphCanvas.vue index 8166358b8c2..194d5a7a82b 100644 --- a/src/components/graph/GraphCanvas.vue +++ b/src/components/graph/GraphCanvas.vue @@ -318,7 +318,8 @@ const { mountedNodeIds } = useViewportCulling({ const rect = canvasStore.canvas?.canvas?.getBoundingClientRect() return { width: rect?.width ?? 0, height: rect?.height ?? 0 } }, - isTransforming + isTransforming, + canvasElement }) const allNodes = computed(() => diff --git a/src/composables/graph/useViewportCulling.ts b/src/composables/graph/useViewportCulling.ts index 2cc3e85e4f2..9184e9a7a55 100644 --- a/src/composables/graph/useViewportCulling.ts +++ b/src/composables/graph/useViewportCulling.ts @@ -9,7 +9,12 @@ * Visibility checks are throttled during active pan/zoom interactions * to avoid turning culling into a per-frame reactive hotspot. */ -import { useDebounceFn, useEventListener, useThrottleFn } from '@vueuse/core' +import { + useDebounceFn, + useEventListener, + useResizeObserver, + useThrottleFn +} from '@vueuse/core' import { shallowRef, watch } from 'vue' import type { ComputedRef, Ref } from 'vue' @@ -31,13 +36,15 @@ interface UseViewportCullingOptions { nodeLayouts: ComputedRef> getViewportSize: () => { width: number; height: number } isTransforming: Ref + canvasElement?: Ref } export function useViewportCulling({ rawNodes, nodeLayouts, getViewportSize, - isTransforming + isTransforming, + canvasElement }: UseViewportCullingOptions) { const { isNodeInViewport } = useTransformState() const mountedNodeIds = shallowRef(new Set()) @@ -133,6 +140,10 @@ export function useViewportCulling({ useEventListener(window, 'resize', refreshMountedNodes) + if (canvasElement) { + useResizeObserver(canvasElement, refreshMountedNodes) + } + return { mountedNodeIds } From 84fad7f507bf32f33b0954429ad8ef4fcf682581 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Fri, 27 Mar 2026 17:04:35 -0700 Subject: [PATCH 6/7] fix: resolve merge conflict with main in performance.spec.ts --- browser_tests/tests/performance.spec.ts | 32 +++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/browser_tests/tests/performance.spec.ts b/browser_tests/tests/performance.spec.ts index e495d3da668..d863a34bb7c 100644 --- a/browser_tests/tests/performance.spec.ts +++ b/browser_tests/tests/performance.spec.ts @@ -193,6 +193,38 @@ test.describe('Performance', { tag: ['@perf'] }, () => { ) }) + test('large graph zoom interaction', async ({ comfyPage }) => { + await comfyPage.workflow.loadWorkflow('large-graph-workflow') + + const canvas = comfyPage.canvas + const box = await canvas.boundingBox() + if (!box) throw new Error('Canvas bounding box not available') + + // Position mouse at center so wheel events hit the canvas + const centerX = box.x + box.width / 2 + const centerY = box.y + box.height / 2 + await comfyPage.page.mouse.move(centerX, centerY) + + await comfyPage.perf.startMeasuring() + + // Zoom in 30 steps then out 30 steps — each step triggers + // ResizeObserver for all ~245 node elements due to CSS scale change. + for (let i = 0; i < 30; i++) { + await comfyPage.page.mouse.wheel(0, -100) + await comfyPage.nextFrame() + } + for (let i = 0; i < 30; i++) { + await comfyPage.page.mouse.wheel(0, 100) + await comfyPage.nextFrame() + } + + const m = await comfyPage.perf.stopMeasuring('large-graph-zoom') + recordMeasurement(m) + console.log( + `Large graph zoom: ${m.layouts} layouts, ${m.layoutDurationMs.toFixed(1)}ms layout, ${m.frameDurationMs.toFixed(1)}ms/frame, TBT=${m.totalBlockingTimeMs.toFixed(0)}ms` + ) + }) + test('subgraph DOM widget clipping during node selection', async ({ comfyPage }) => { From 3517e141243479145a5dce241d68eb8a6ed5c675 Mon Sep 17 00:00:00 2001 From: Christian Byrne Date: Fri, 27 Mar 2026 17:06:02 -0700 Subject: [PATCH 7/7] Revert performance.spec.ts to pre-merge state --- browser_tests/tests/performance.spec.ts | 32 ------------------------- 1 file changed, 32 deletions(-) diff --git a/browser_tests/tests/performance.spec.ts b/browser_tests/tests/performance.spec.ts index d863a34bb7c..e495d3da668 100644 --- a/browser_tests/tests/performance.spec.ts +++ b/browser_tests/tests/performance.spec.ts @@ -193,38 +193,6 @@ test.describe('Performance', { tag: ['@perf'] }, () => { ) }) - test('large graph zoom interaction', async ({ comfyPage }) => { - await comfyPage.workflow.loadWorkflow('large-graph-workflow') - - const canvas = comfyPage.canvas - const box = await canvas.boundingBox() - if (!box) throw new Error('Canvas bounding box not available') - - // Position mouse at center so wheel events hit the canvas - const centerX = box.x + box.width / 2 - const centerY = box.y + box.height / 2 - await comfyPage.page.mouse.move(centerX, centerY) - - await comfyPage.perf.startMeasuring() - - // Zoom in 30 steps then out 30 steps — each step triggers - // ResizeObserver for all ~245 node elements due to CSS scale change. - for (let i = 0; i < 30; i++) { - await comfyPage.page.mouse.wheel(0, -100) - await comfyPage.nextFrame() - } - for (let i = 0; i < 30; i++) { - await comfyPage.page.mouse.wheel(0, 100) - await comfyPage.nextFrame() - } - - const m = await comfyPage.perf.stopMeasuring('large-graph-zoom') - recordMeasurement(m) - console.log( - `Large graph zoom: ${m.layouts} layouts, ${m.layoutDurationMs.toFixed(1)}ms layout, ${m.frameDurationMs.toFixed(1)}ms/frame, TBT=${m.totalBlockingTimeMs.toFixed(0)}ms` - ) - }) - test('subgraph DOM widget clipping during node selection', async ({ comfyPage }) => {