From 48dd78842b56898a9bb0c8015ab9d3e35edf4c84 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 8 Oct 2026 07:00:24 +0000 Subject: [PATCH 1/7] fix: only create async work for extensions that define the hook invokeExtensionsAsync created an async wrapper and promise for every enabled extension on every call, even for extensions without the hook. It runs once per node def, so large installs created millions of promises at startup. Now only extensions that define the hook start async work. Result array length and indices are unchanged, and the `in` check is now inside a per-extension guard so a throwing Proxy `has` trap is logged instead of rejecting the whole call. --- src/services/extensionService.test.ts | 274 ++++++++++++++++++++++++++ src/services/extensionService.ts | 87 +++++--- 2 files changed, 330 insertions(+), 31 deletions(-) diff --git a/src/services/extensionService.test.ts b/src/services/extensionService.test.ts index 6669ff64b31..71bbd97274f 100644 --- a/src/services/extensionService.test.ts +++ b/src/services/extensionService.test.ts @@ -1,7 +1,10 @@ import { assert, describe, expect, it, vi } from 'vitest' +import { legacyMenuCompat } from '@/lib/litegraph/src/contextMenuCompat' import { reportError } from '@/platform/telemetry/reportError' import { api } from '@/scripts/api' +import { useExtensionStore } from '@/stores/extensionStore' +import type { ComfyExtension } from '@/types/comfy' import type { ExtensionLoadFailure } from './extensionService' import { @@ -165,3 +168,274 @@ describe('extension loading', () => { }) }) }) + +describe('invokeExtensionsAsync', () => { + const HOOK = 'addCustomNodeDefs' + const noop = () => {} + + // Hooks here return arbitrary values, which the real hook types disallow + type TestExtension = { name: string; [key: string]: unknown } + + function register(...extensions: TestExtension[]) { + const store = useExtensionStore() + for (const ext of extensions) store.registerExtension(ext) + } + + const invoke = () => useExtensionService().invokeExtensionsAsync(HOOK, {}) + + it('only calls extensions that define the hook, in registration order', async () => { + const calls: string[] = [] + register( + { name: 'a', [HOOK]: () => void calls.push('a') }, + { name: 'none' }, + { name: 'b', [HOOK]: () => void calls.push('b') } + ) + + await invoke() + + expect(calls).toEqual(['a', 'b']) + }) + + it('starts hooks concurrently rather than sequentially', async () => { + const events: string[] = [] + let releaseFirst = noop + register( + { + name: 'slow', + [HOOK]: async () => { + events.push('slow:start') + await new Promise((resolve) => (releaseFirst = resolve)) + events.push('slow:end') + } + }, + { name: 'fast', [HOOK]: () => void events.push('fast:start') } + ) + + const done = invoke() + expect(events).toEqual(['slow:start', 'fast:start']) + releaseFirst() + await done + expect(events).toEqual(['slow:start', 'fast:start', 'slow:end']) + }) + + it('keeps one result slot per enabled extension, aligned by index', async () => { + register( + { name: 'none-first' }, + { name: 'a', [HOOK]: () => 'a-result' }, + { name: 'none-middle' }, + { name: 'b', [HOOK]: async () => 'b-result' }, + { name: 'none-last' } + ) + + const results = await invoke() + + expect(results).toHaveLength(5) + expect(results).toEqual([ + undefined, + 'a-result', + undefined, + 'b-result', + undefined + ]) + expect(Array.from(results.keys())).toEqual([0, 1, 2, 3, 4]) + }) + + it('skips disabled extensions without leaving a slot', async () => { + const hook = vi.fn() + register({ name: 'off', [HOOK]: hook }, { name: 'on', [HOOK]: hook }) + useExtensionStore().loadDisabledExtensionNames(['off']) + + const results = await invoke() + + expect(hook).toHaveBeenCalledOnce() + expect(results).toHaveLength(1) + }) + + it('calls hooks inherited from the prototype chain', async () => { + const hook = vi.fn() + register(Object.create({ [HOOK]: hook }, { name: { value: 'inherited' } })) + + await invoke() + + expect(hook).toHaveBeenCalledOnce() + }) + + it('passes the args plus the app and binds this to the extension', async () => { + const hook = vi.fn() + const ext: TestExtension = { name: 'a', [HOOK]: hook } + register(ext) + const defs = {} + + await useExtensionService().invokeExtensionsAsync(HOOK, defs) + + expect(hook).toHaveBeenCalledOnce() + expect(hook.mock.calls[0][0]).toBe(defs) + expect(hook.mock.contexts[0]).toBe(useExtensionStore().extensions[0]) + }) + + it('ignores a non-function property of the same name', async () => { + const after = vi.fn() + register( + { name: 'not-fn', [HOOK]: 'nope' }, + { + name: 'after', + [HOOK]: after + } + ) + + const results = await invoke() + + expect(after).toHaveBeenCalledOnce() + expect(results).toEqual([undefined, undefined]) + expect(console.error).not.toHaveBeenCalled() + }) + + it('logs a throwing or rejecting hook and still runs the others', async () => { + const before = vi.fn() + const after = vi.fn(() => 'ok') + register( + { name: 'before', [HOOK]: before }, + { + name: 'sync-throw', + [HOOK]: () => { + throw new Error('sync boom') + } + }, + { + name: 'async-reject', + [HOOK]: () => Promise.reject(new Error('async')) + }, + { name: 'after', [HOOK]: after } + ) + + const results = await invoke() + + expect(before).toHaveBeenCalledOnce() + expect(after).toHaveBeenCalledOnce() + expect(results).toEqual([undefined, undefined, undefined, 'ok']) + expect(console.error).toHaveBeenCalledTimes(2) + expect(vi.mocked(console.error).mock.calls[0][0]).toBe( + `Error calling extension 'sync-throw' method '${HOOK}'` + ) + }) + + it('isolates a throwing getter', async () => { + const after = vi.fn() + const getterExt: TestExtension = { name: 'getter' } + Object.defineProperty(getterExt, HOOK, { + enumerable: true, + get() { + throw new Error('getter boom') + } + }) + register(getterExt, { name: 'after', [HOOK]: after }) + + await invoke() + + expect(after).toHaveBeenCalledOnce() + expect(console.error).toHaveBeenCalledOnce() + }) + + it('isolates a Proxy whose has trap throws', async () => { + const after = vi.fn() + const proxied = new Proxy( + { name: 'proxy' }, + { + has(target, key) { + if (key === HOOK) throw new Error('has boom') + return key in target + } + } + ) + register(proxied, { name: 'after', [HOOK]: after }) + + const results = await invoke() + + expect(after).toHaveBeenCalledOnce() + expect(results).toEqual([undefined, undefined]) + expect(console.error).toHaveBeenCalledOnce() + expect(vi.mocked(console.error).mock.calls[0][0]).toBe( + `Error calling extension 'proxy' method '${HOOK}'` + ) + }) + + it('picks up a hook added by an earlier extension during the same call', async () => { + const late = vi.fn() + const lateExt: TestExtension = { name: 'late' } + register( + { + name: 'installer', + [HOOK]: () => { + lateExt[HOOK] = late + } + }, + lateExt + ) + + await invoke() + + expect(late).toHaveBeenCalledOnce() + }) + + it('works on a snapshot of the enabled extensions', async () => { + const added = vi.fn() + register({ + name: 'registrar', + [HOOK]: () => + useExtensionStore().registerExtension({ name: 'added', [HOOK]: added }) + }) + + const results = await invoke() + + expect(added).not.toHaveBeenCalled() + expect(results).toHaveLength(1) + }) + + it('creates promise work only for extensions that define the hook', async () => { + const all = Array.from({ length: 1000 }, (_, i): ComfyExtension => { + return i % 300 === 0 + ? { name: `ext-${i}`, [HOOK]: noop } + : { name: `ext-${i}` } + }) + register(...all) + const promiseAll = vi.spyOn(Promise, 'all') + + const results = await invoke() + + expect(results).toHaveLength(1000) + const [pending] = promiseAll.mock.calls[0] + // ext-0, ext-300, ext-600 and ext-900 define the hook + expect([...pending]).toHaveLength(4) + }) + + describe('legacy menu compat tracking for setup', () => { + it('sets the current extension while setup runs and clears it afterwards', async () => { + const events: string[] = [] + vi.spyOn(legacyMenuCompat, 'setCurrentExtension').mockImplementation( + (name) => void events.push(`current:${name}`) + ) + register( + { name: 'a', setup: () => void events.push('setup:a') }, + { name: 'none' } + ) + + await useExtensionService().invokeExtensionsAsync('setup') + + expect(events).toEqual(['current:a', 'setup:a', 'current:null']) + }) + + it('clears the current extension when setup throws', async () => { + const spy = vi.spyOn(legacyMenuCompat, 'setCurrentExtension') + register({ + name: 'bad', + setup: () => { + throw new Error('boom') + } + }) + + await useExtensionService().invokeExtensionsAsync('setup') + + expect(spy.mock.calls).toEqual([['bad'], [null]]) + }) + }) +}) diff --git a/src/services/extensionService.ts b/src/services/extensionService.ts index 5dcee47f02a..61f7898905f 100644 --- a/src/services/extensionService.ts +++ b/src/services/extensionService.ts @@ -279,44 +279,69 @@ export const useExtensionService = () => { method: T, ...args: Parameters> ) => { - return await Promise.all( - extensionStore.enabledExtensions.map(async (ext) => { - if (method in ext) { - try { - const fn = ext[method] - if (typeof fn !== 'function') { - return - } + const logError = (ext: ComfyExtension, error: unknown) => + console.error( + `Error calling extension '${ext.name}' method '${method}'`, + { error }, + { extension: ext }, + { args } + ) - // Set current extension name for legacy compatibility tracking - if (method === 'setup') { - legacyMenuCompat.setCurrentExtension(ext.name) - } + const callHook = async (ext: ComfyExtension) => { + try { + const fn = ext[method] + if (typeof fn !== 'function') { + return + } - const result = await fn.call(ext, ...args, app) + // Set current extension name for legacy compatibility tracking + if (method === 'setup') { + legacyMenuCompat.setCurrentExtension(ext.name) + } - // Clear current extension after setup - if (method === 'setup') { - legacyMenuCompat.setCurrentExtension(null) - } + const result = await fn.call(ext, ...args, app) - return result - } catch (error) { - // Clear current extension on error too - if (method === 'setup') { - legacyMenuCompat.setCurrentExtension(null) - } + // Clear current extension after setup + if (method === 'setup') { + legacyMenuCompat.setCurrentExtension(null) + } - console.error( - `Error calling extension '${ext.name}' method '${method}'`, - { error }, - { extension: ext }, - { args } - ) - } + return result + } catch (error) { + // Clear current extension on error too + if (method === 'setup') { + legacyMenuCompat.setCurrentExtension(null) } - }) + + logError(ext, error) + } + } + + // Called once per node def per extension, so only start async work for + // extensions that define the hook. The `in` check stays synchronous and is + // evaluated in extension order, like the hook calls, and is guarded so a + // throwing Proxy `has` trap only affects its own extension. + const exts = extensionStore.enabledExtensions + const results: Awaited>[] = Array.from( + { length: exts.length }, + () => undefined ) + const pending: Promise[] = [] + exts.forEach((ext, index) => { + try { + if (!(method in ext)) return + } catch (error) { + logError(ext, error) + return + } + pending.push( + callHook(ext).then((result) => { + results[index] = result + }) + ) + }) + await Promise.all(pending) + return results } return { From 7246a01744b36c4c81c6fdc57bda351d29207477 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 8 Oct 2026 07:14:47 +0000 Subject: [PATCH 2/7] perf: register node defs in bounded chunks registerNodesFromDefs started registration for every node def at once, which put thousands of defs (and their extension hooks) in flight together. Process them in chunks of 256 instead. Defs within a chunk still overlap, order is preserved, and a failed def still lets the rest register before the first error is rethrown. --- src/scripts/app.registerNodesFromDefs.test.ts | 82 +++++++++++++++++++ src/scripts/app.ts | 25 ++++-- 2 files changed, 102 insertions(+), 5 deletions(-) create mode 100644 src/scripts/app.registerNodesFromDefs.test.ts diff --git a/src/scripts/app.registerNodesFromDefs.test.ts b/src/scripts/app.registerNodesFromDefs.test.ts new file mode 100644 index 00000000000..fbb4359bf61 --- /dev/null +++ b/src/scripts/app.registerNodesFromDefs.test.ts @@ -0,0 +1,82 @@ +import { fromPartial } from '@total-typescript/shoehorn' +import { describe, expect, it, vi } from 'vitest' + +import type { ComfyNodeDef as ComfyNodeDefV1 } from '@/schemas/nodeDefSchema' +import { app } from '@/scripts/app' +import type { useExtensionService } from '@/services/extensionService' + +const { invokeExtensionsAsync } = vi.hoisted(() => ({ + invokeExtensionsAsync: vi.fn() +})) + +vi.mock(import('@/services/extensionService'), () => ({ + useExtensionService: () => + fromPartial>({ + invokeExtensionsAsync + }) +})) + +function makeDefs(count: number) { + const defs: Record = {} + for (let i = 0; i < count; i++) { + defs[`Node${i}`] = { name: `Node${i}` } as ComfyNodeDefV1 + } + return defs +} + +describe('ComfyApp.registerNodesFromDefs', () => { + it('registers every def in order after the addCustomNodeDefs hook', async () => { + const events: string[] = [] + invokeExtensionsAsync.mockImplementation(async (method) => { + events.push(`hook:${method}`) + return [] + }) + vi.spyOn(app, 'registerNodeDef').mockImplementation(async (nodeId) => { + events.push(nodeId) + }) + const defs = makeDefs(600) + + await app.registerNodesFromDefs(defs) + + expect(events[0]).toBe('hook:addCustomNodeDefs') + expect(events.slice(1)).toEqual(Object.keys(defs)) + }) + + it('never has more than one chunk of defs in flight, but overlaps within it', async () => { + let inFlight = 0 + let maxInFlight = 0 + vi.spyOn(app, 'registerNodeDef').mockImplementation(async () => { + inFlight++ + maxInFlight = Math.max(maxInFlight, inFlight) + await new Promise((resolve) => setTimeout(resolve, 0)) + inFlight-- + }) + + await app.registerNodesFromDefs(makeDefs(1000)) + + expect(maxInFlight).toBeGreaterThan(1) + expect(maxInFlight).toBeLessThanOrEqual(256) + }) + + it('still registers the remaining defs when one rejects, then rethrows the first error', async () => { + const registered: string[] = [] + vi.spyOn(app, 'registerNodeDef').mockImplementation(async (nodeId) => { + registered.push(nodeId) + if (nodeId === 'Node3') throw new Error('first') + if (nodeId === 'Node400') throw new Error('second') + }) + const defs = makeDefs(600) + + await expect(app.registerNodesFromDefs(defs)).rejects.toThrow('first') + + expect(registered).toEqual(Object.keys(defs)) + }) + + it('does nothing for an empty def set', async () => { + const register = vi.spyOn(app, 'registerNodeDef') + + await app.registerNodesFromDefs({}) + + expect(register).not.toHaveBeenCalled() + }) +}) diff --git a/src/scripts/app.ts b/src/scripts/app.ts index 9cc80e6b95e..e27f38d298a 100644 --- a/src/scripts/app.ts +++ b/src/scripts/app.ts @@ -308,6 +308,9 @@ function createNodeOutputsMutationView( }) } +/** Max node defs registered concurrently by `registerNodesFromDefs`. */ +const REGISTER_NODE_DEFS_CHUNK_SIZE = 256 + export class ComfyApp { /** * List of entries to queue @@ -1225,12 +1228,24 @@ export class ComfyApp { async registerNodesFromDefs(defs: Record) { await useExtensionService().invokeExtensionsAsync('addCustomNodeDefs', defs) - // Register a node for each definition - await Promise.all( - Object.keys(defs).map((nodeId) => - this.registerNodeDef(nodeId, defs[nodeId]) + // Register a node for each definition. Chunked so thousands of defs do not + // all have their registration (and extension hooks) in flight at once. + // Like the previous single Promise.all, one failed def does not stop the + // others from registering, and the first rejection is what gets thrown. + const nodeIds = Object.keys(defs) + let firstFailure: PromiseRejectedResult | undefined + for (let i = 0; i < nodeIds.length; i += REGISTER_NODE_DEFS_CHUNK_SIZE) { + const results = await Promise.allSettled( + nodeIds + .slice(i, i + REGISTER_NODE_DEFS_CHUNK_SIZE) + .map((nodeId) => this.registerNodeDef(nodeId, defs[nodeId])) ) - ) + firstFailure ??= results.find( + (result): result is PromiseRejectedResult => + result.status === 'rejected' + ) + } + if (firstFailure) throw firstFailure.reason } loadTemplateData(templateData: { From a83b00b8f56b88a624639b3c32cfd376f0daa223 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 8 Oct 2026 07:19:31 +0000 Subject: [PATCH 3/7] Revert "perf: register node defs in bounded chunks" This reverts commit 7246a01744b36c4c81c6fdc57bda351d29207477. --- src/scripts/app.registerNodesFromDefs.test.ts | 82 ------------------- src/scripts/app.ts | 25 ++---- 2 files changed, 5 insertions(+), 102 deletions(-) delete mode 100644 src/scripts/app.registerNodesFromDefs.test.ts diff --git a/src/scripts/app.registerNodesFromDefs.test.ts b/src/scripts/app.registerNodesFromDefs.test.ts deleted file mode 100644 index fbb4359bf61..00000000000 --- a/src/scripts/app.registerNodesFromDefs.test.ts +++ /dev/null @@ -1,82 +0,0 @@ -import { fromPartial } from '@total-typescript/shoehorn' -import { describe, expect, it, vi } from 'vitest' - -import type { ComfyNodeDef as ComfyNodeDefV1 } from '@/schemas/nodeDefSchema' -import { app } from '@/scripts/app' -import type { useExtensionService } from '@/services/extensionService' - -const { invokeExtensionsAsync } = vi.hoisted(() => ({ - invokeExtensionsAsync: vi.fn() -})) - -vi.mock(import('@/services/extensionService'), () => ({ - useExtensionService: () => - fromPartial>({ - invokeExtensionsAsync - }) -})) - -function makeDefs(count: number) { - const defs: Record = {} - for (let i = 0; i < count; i++) { - defs[`Node${i}`] = { name: `Node${i}` } as ComfyNodeDefV1 - } - return defs -} - -describe('ComfyApp.registerNodesFromDefs', () => { - it('registers every def in order after the addCustomNodeDefs hook', async () => { - const events: string[] = [] - invokeExtensionsAsync.mockImplementation(async (method) => { - events.push(`hook:${method}`) - return [] - }) - vi.spyOn(app, 'registerNodeDef').mockImplementation(async (nodeId) => { - events.push(nodeId) - }) - const defs = makeDefs(600) - - await app.registerNodesFromDefs(defs) - - expect(events[0]).toBe('hook:addCustomNodeDefs') - expect(events.slice(1)).toEqual(Object.keys(defs)) - }) - - it('never has more than one chunk of defs in flight, but overlaps within it', async () => { - let inFlight = 0 - let maxInFlight = 0 - vi.spyOn(app, 'registerNodeDef').mockImplementation(async () => { - inFlight++ - maxInFlight = Math.max(maxInFlight, inFlight) - await new Promise((resolve) => setTimeout(resolve, 0)) - inFlight-- - }) - - await app.registerNodesFromDefs(makeDefs(1000)) - - expect(maxInFlight).toBeGreaterThan(1) - expect(maxInFlight).toBeLessThanOrEqual(256) - }) - - it('still registers the remaining defs when one rejects, then rethrows the first error', async () => { - const registered: string[] = [] - vi.spyOn(app, 'registerNodeDef').mockImplementation(async (nodeId) => { - registered.push(nodeId) - if (nodeId === 'Node3') throw new Error('first') - if (nodeId === 'Node400') throw new Error('second') - }) - const defs = makeDefs(600) - - await expect(app.registerNodesFromDefs(defs)).rejects.toThrow('first') - - expect(registered).toEqual(Object.keys(defs)) - }) - - it('does nothing for an empty def set', async () => { - const register = vi.spyOn(app, 'registerNodeDef') - - await app.registerNodesFromDefs({}) - - expect(register).not.toHaveBeenCalled() - }) -}) diff --git a/src/scripts/app.ts b/src/scripts/app.ts index e27f38d298a..9cc80e6b95e 100644 --- a/src/scripts/app.ts +++ b/src/scripts/app.ts @@ -308,9 +308,6 @@ function createNodeOutputsMutationView( }) } -/** Max node defs registered concurrently by `registerNodesFromDefs`. */ -const REGISTER_NODE_DEFS_CHUNK_SIZE = 256 - export class ComfyApp { /** * List of entries to queue @@ -1228,24 +1225,12 @@ export class ComfyApp { async registerNodesFromDefs(defs: Record) { await useExtensionService().invokeExtensionsAsync('addCustomNodeDefs', defs) - // Register a node for each definition. Chunked so thousands of defs do not - // all have their registration (and extension hooks) in flight at once. - // Like the previous single Promise.all, one failed def does not stop the - // others from registering, and the first rejection is what gets thrown. - const nodeIds = Object.keys(defs) - let firstFailure: PromiseRejectedResult | undefined - for (let i = 0; i < nodeIds.length; i += REGISTER_NODE_DEFS_CHUNK_SIZE) { - const results = await Promise.allSettled( - nodeIds - .slice(i, i + REGISTER_NODE_DEFS_CHUNK_SIZE) - .map((nodeId) => this.registerNodeDef(nodeId, defs[nodeId])) - ) - firstFailure ??= results.find( - (result): result is PromiseRejectedResult => - result.status === 'rejected' + // Register a node for each definition + await Promise.all( + Object.keys(defs).map((nodeId) => + this.registerNodeDef(nodeId, defs[nodeId]) ) - } - if (firstFailure) throw firstFailure.reason + ) } loadTemplateData(templateData: { From 1f7567a092782c86a49cf78d0bd8a93b8eae1043 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 8 Oct 2026 19:54:50 +0000 Subject: [PATCH 4/7] fix: do not wrap sync extension hooks in promises Replace the per-extension async wrapper in invokeExtensionsAsync with a synchronous loop. Hooks that return synchronously are never awaited and only returned promises are collected, so extensions without a hook, and hooks that do not return a promise, allocate no promises. The property read is guarded per extension so a throwing getter or Proxy trap is logged without aborting the call. --- src/services/extensionService.test.ts | 160 +++++++++++++++++--------- src/services/extensionService.ts | 85 +++++++------- 2 files changed, 147 insertions(+), 98 deletions(-) diff --git a/src/services/extensionService.test.ts b/src/services/extensionService.test.ts index 71bbd97274f..2bd9afdc2e9 100644 --- a/src/services/extensionService.test.ts +++ b/src/services/extensionService.test.ts @@ -4,7 +4,6 @@ import { legacyMenuCompat } from '@/lib/litegraph/src/contextMenuCompat' import { reportError } from '@/platform/telemetry/reportError' import { api } from '@/scripts/api' import { useExtensionStore } from '@/stores/extensionStore' -import type { ComfyExtension } from '@/types/comfy' import type { ExtensionLoadFailure } from './extensionService' import { @@ -196,6 +195,19 @@ describe('invokeExtensionsAsync', () => { expect(calls).toEqual(['a', 'b']) }) + it('invokes every hook synchronously, before any await', () => { + const calls: string[] = [] + register( + { name: 'sync', [HOOK]: () => void calls.push('sync') }, + { name: 'async', [HOOK]: async () => void calls.push('async') }, + { name: 'sync2', [HOOK]: () => void calls.push('sync2') } + ) + + void invoke() + + expect(calls).toEqual(['sync', 'async', 'sync2']) + }) + it('starts hooks concurrently rather than sequentially', async () => { const events: string[] = [] let releaseFirst = noop @@ -218,37 +230,48 @@ describe('invokeExtensionsAsync', () => { expect(events).toEqual(['slow:start', 'fast:start', 'slow:end']) }) - it('keeps one result slot per enabled extension, aligned by index', async () => { + it('waits for async hooks and resolves with their results', async () => { register( { name: 'none-first' }, - { name: 'a', [HOOK]: () => 'a-result' }, - { name: 'none-middle' }, - { name: 'b', [HOOK]: async () => 'b-result' }, - { name: 'none-last' } + { name: 'sync', [HOOK]: () => 'sync-result' }, + { name: 'a', [HOOK]: async () => 'a-result' }, + { name: 'none-last' }, + { name: 'b', [HOOK]: () => Promise.resolve('b-result') } ) const results = await invoke() - expect(results).toHaveLength(5) - expect(results).toEqual([ - undefined, - 'a-result', - undefined, - 'b-result', - undefined - ]) - expect(Array.from(results.keys())).toEqual([0, 1, 2, 3, 4]) + expect(results).toEqual(['a-result', 'b-result']) + }) + + it('awaits thenables that are not native promises', async () => { + const order: string[] = [] + register({ + name: 'thenable', + [HOOK]: () => ({ + then: (resolve: (value: string) => void) => { + setTimeout(() => { + order.push('thenable') + resolve('done') + }, 0) + } + }) + }) + + const results = await invoke() + + expect(order).toEqual(['thenable']) + expect(results).toEqual(['done']) }) - it('skips disabled extensions without leaving a slot', async () => { + it('skips disabled extensions', async () => { const hook = vi.fn() register({ name: 'off', [HOOK]: hook }, { name: 'on', [HOOK]: hook }) useExtensionStore().loadDisabledExtensionNames(['off']) - const results = await invoke() + await invoke() expect(hook).toHaveBeenCalledOnce() - expect(results).toHaveLength(1) }) it('calls hooks inherited from the prototype chain', async () => { @@ -262,37 +285,33 @@ describe('invokeExtensionsAsync', () => { it('passes the args plus the app and binds this to the extension', async () => { const hook = vi.fn() - const ext: TestExtension = { name: 'a', [HOOK]: hook } - register(ext) + register({ name: 'a', [HOOK]: hook }) const defs = {} await useExtensionService().invokeExtensionsAsync(HOOK, defs) expect(hook).toHaveBeenCalledOnce() + expect(hook.mock.calls[0]).toHaveLength(2) expect(hook.mock.calls[0][0]).toBe(defs) expect(hook.mock.contexts[0]).toBe(useExtensionStore().extensions[0]) }) - it('ignores a non-function property of the same name', async () => { + it('silently ignores a non-function property of the same name', async () => { const after = vi.fn() register( { name: 'not-fn', [HOOK]: 'nope' }, - { - name: 'after', - [HOOK]: after - } + { name: 'after', [HOOK]: after } ) - const results = await invoke() + await invoke() expect(after).toHaveBeenCalledOnce() - expect(results).toEqual([undefined, undefined]) expect(console.error).not.toHaveBeenCalled() }) - it('logs a throwing or rejecting hook and still runs the others', async () => { + it('logs a throwing sync hook and still runs the others', async () => { const before = vi.fn() - const after = vi.fn(() => 'ok') + const after = vi.fn() register( { name: 'before', [HOOK]: before }, { @@ -301,24 +320,36 @@ describe('invokeExtensionsAsync', () => { throw new Error('sync boom') } }, - { - name: 'async-reject', - [HOOK]: () => Promise.reject(new Error('async')) - }, { name: 'after', [HOOK]: after } ) - const results = await invoke() + await invoke() expect(before).toHaveBeenCalledOnce() expect(after).toHaveBeenCalledOnce() - expect(results).toEqual([undefined, undefined, undefined, 'ok']) - expect(console.error).toHaveBeenCalledTimes(2) + expect(console.error).toHaveBeenCalledOnce() expect(vi.mocked(console.error).mock.calls[0][0]).toBe( `Error calling extension 'sync-throw' method '${HOOK}'` ) }) + it('logs a rejecting async hook without failing the others', async () => { + const after = vi.fn(async () => 'ok') + register( + { name: 'async-reject', [HOOK]: () => Promise.reject(new Error('nope')) }, + { name: 'after', [HOOK]: after } + ) + + const results = await invoke() + + expect(after).toHaveBeenCalledOnce() + expect(results).toEqual([undefined, 'ok']) + expect(console.error).toHaveBeenCalledOnce() + expect(vi.mocked(console.error).mock.calls[0][0]).toBe( + `Error calling extension 'async-reject' method '${HOOK}'` + ) + }) + it('isolates a throwing getter', async () => { const after = vi.fn() const getterExt: TestExtension = { name: 'getter' } @@ -334,29 +365,28 @@ describe('invokeExtensionsAsync', () => { expect(after).toHaveBeenCalledOnce() expect(console.error).toHaveBeenCalledOnce() + expect(vi.mocked(console.error).mock.calls[0][0]).toBe( + `Error calling extension 'getter' method '${HOOK}'` + ) }) - it('isolates a Proxy whose has trap throws', async () => { + it('isolates a Proxy whose get trap throws', async () => { const after = vi.fn() const proxied = new Proxy( { name: 'proxy' }, { - has(target, key) { - if (key === HOOK) throw new Error('has boom') - return key in target + get(target, key) { + if (key === HOOK) throw new Error('get boom') + return Reflect.get(target, key) } } ) register(proxied, { name: 'after', [HOOK]: after }) - const results = await invoke() + await invoke() expect(after).toHaveBeenCalledOnce() - expect(results).toEqual([undefined, undefined]) expect(console.error).toHaveBeenCalledOnce() - expect(vi.mocked(console.error).mock.calls[0][0]).toBe( - `Error calling extension 'proxy' method '${HOOK}'` - ) }) it('picks up a hook added by an earlier extension during the same call', async () => { @@ -385,14 +415,14 @@ describe('invokeExtensionsAsync', () => { useExtensionStore().registerExtension({ name: 'added', [HOOK]: added }) }) - const results = await invoke() + await invoke() expect(added).not.toHaveBeenCalled() - expect(results).toHaveLength(1) }) - it('creates promise work only for extensions that define the hook', async () => { - const all = Array.from({ length: 1000 }, (_, i): ComfyExtension => { + it('only waits on promises that hooks actually return', async () => { + const all = Array.from({ length: 1000 }, (_, i): TestExtension => { + if (i === 0) return { name: `ext-${i}`, [HOOK]: async () => {} } return i % 300 === 0 ? { name: `ext-${i}`, [HOOK]: noop } : { name: `ext-${i}` } @@ -400,12 +430,10 @@ describe('invokeExtensionsAsync', () => { register(...all) const promiseAll = vi.spyOn(Promise, 'all') - const results = await invoke() + await invoke() - expect(results).toHaveLength(1000) const [pending] = promiseAll.mock.calls[0] - // ext-0, ext-300, ext-600 and ext-900 define the hook - expect([...pending]).toHaveLength(4) + expect([...pending]).toHaveLength(1) }) describe('legacy menu compat tracking for setup', () => { @@ -436,6 +464,32 @@ describe('invokeExtensionsAsync', () => { await useExtensionService().invokeExtensionsAsync('setup') expect(spy.mock.calls).toEqual([['bad'], [null]]) + expect(console.error).toHaveBeenCalledOnce() + }) + + it('clears the current extension when setup rejects, without failing others', async () => { + const spy = vi.spyOn(legacyMenuCompat, 'setCurrentExtension') + const after = vi.fn() + register( + { name: 'bad', setup: () => Promise.reject(new Error('nope')) }, + { name: 'after', setup: after } + ) + + await useExtensionService().invokeExtensionsAsync('setup') + + expect(after).toHaveBeenCalledOnce() + expect(spy.mock.calls).toContainEqual([null]) + expect(console.error).toHaveBeenCalledOnce() + }) + + it('passes the app once to setup hooks', async () => { + const setup = vi.fn() + register({ name: 'a', setup }) + + await useExtensionService().invokeExtensionsAsync('setup') + + expect(setup).toHaveBeenCalledOnce() + expect(setup.mock.calls[0]).toHaveLength(1) }) }) }) diff --git a/src/services/extensionService.ts b/src/services/extensionService.ts index 61f7898905f..7318e28d8c9 100644 --- a/src/services/extensionService.ts +++ b/src/services/extensionService.ts @@ -23,6 +23,15 @@ const INLINED_CLOUD_EXTENSIONS = new Set([ '/extensions/cloud/sentry.js' ]) +function isPromiseLike(value: unknown): value is PromiseLike { + return ( + value instanceof Promise || + (typeof value === 'object' && + value !== null && + typeof (value as { then?: unknown }).then === 'function') + ) +} + export function shouldLoadExtension( extension: string, isCloudBuild: boolean @@ -270,7 +279,12 @@ export const useExtensionService = () => { /** * Invoke an async extension callback - * Each callback will be invoked concurrently + * Each callback will be invoked concurrently, in extension order. Only + * extensions that define the callback do any work, and only the promises + * that callbacks actually return are awaited (callbacks that return + * synchronously are never wrapped in a promise). The resolved array holds + * the results of those async callbacks, so it is not index-aligned with the + * extensions. * @param {string} method The extension callback to execute * @param {...unknown} args Any arguments to pass to the callback * @returns @@ -287,61 +301,42 @@ export const useExtensionService = () => { { args } ) - const callHook = async (ext: ComfyExtension) => { + // This runs once per node def per extension, so avoid allocating promises + // or closures for extensions that do not define the hook. + const pending: Promise[] = [] + for (const ext of extensionStore.enabledExtensions) { + // The property read is inside the try so a throwing getter or Proxy trap + // only affects its own extension. try { const fn = ext[method] - if (typeof fn !== 'function') { - return - } + if (typeof fn !== 'function') continue - // Set current extension name for legacy compatibility tracking if (method === 'setup') { - legacyMenuCompat.setCurrentExtension(ext.name) + // Track the current extension for legacy compatibility + pending.push( + (async () => { + legacyMenuCompat.setCurrentExtension(ext.name) + try { + return await fn.call(ext, ...args, app) + } finally { + legacyMenuCompat.setCurrentExtension(null) + } + })().catch((error) => logError(ext, error)) + ) + continue } - const result = await fn.call(ext, ...args, app) - - // Clear current extension after setup - if (method === 'setup') { - legacyMenuCompat.setCurrentExtension(null) + const result: unknown = fn.call(ext, ...args, app) + if (isPromiseLike(result)) { + pending.push( + Promise.resolve(result).catch((error) => logError(ext, error)) + ) } - - return result } catch (error) { - // Clear current extension on error too - if (method === 'setup') { - legacyMenuCompat.setCurrentExtension(null) - } - logError(ext, error) } } - - // Called once per node def per extension, so only start async work for - // extensions that define the hook. The `in` check stays synchronous and is - // evaluated in extension order, like the hook calls, and is guarded so a - // throwing Proxy `has` trap only affects its own extension. - const exts = extensionStore.enabledExtensions - const results: Awaited>[] = Array.from( - { length: exts.length }, - () => undefined - ) - const pending: Promise[] = [] - exts.forEach((ext, index) => { - try { - if (!(method in ext)) return - } catch (error) { - logError(ext, error) - return - } - pending.push( - callHook(ext).then((result) => { - results[index] = result - }) - ) - }) - await Promise.all(pending) - return results + return await Promise.all(pending) } return { From ba333b75aa1280641572e80b7c16936a4b56d2c1 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 8 Oct 2026 20:32:56 +0000 Subject: [PATCH 5/7] fix: keep results of synchronous extension hooks invokeExtensionsAsync dropped the return value of hooks that returned synchronously. Restore the previous result shape: one entry per enabled extension in order, holding the awaited hook result, or undefined for extensions without the hook or whose hook threw or rejected. Only promise-like results are awaited, and extensions without the hook still allocate no promise. --- src/services/extensionService.test.ts | 39 ++++++++++++++++++++----- src/services/extensionService.ts | 41 ++++++++++++++++++--------- 2 files changed, 59 insertions(+), 21 deletions(-) diff --git a/src/services/extensionService.test.ts b/src/services/extensionService.test.ts index 2bd9afdc2e9..f30ac5bf224 100644 --- a/src/services/extensionService.test.ts +++ b/src/services/extensionService.test.ts @@ -230,10 +230,11 @@ describe('invokeExtensionsAsync', () => { expect(events).toEqual(['slow:start', 'fast:start', 'slow:end']) }) - it('waits for async hooks and resolves with their results', async () => { + it('returns one result per extension, in extension order', async () => { + const widgets = { CUSTOM: noop } register( { name: 'none-first' }, - { name: 'sync', [HOOK]: () => 'sync-result' }, + { name: 'sync', [HOOK]: () => widgets }, { name: 'a', [HOOK]: async () => 'a-result' }, { name: 'none-last' }, { name: 'b', [HOOK]: () => Promise.resolve('b-result') } @@ -241,7 +242,27 @@ describe('invokeExtensionsAsync', () => { const results = await invoke() - expect(results).toEqual(['a-result', 'b-result']) + expect(results).toHaveLength(5) + expect(results).toEqual([ + undefined, + widgets, + 'a-result', + undefined, + 'b-result' + ]) + expect(results[1]).toBe(widgets) + }) + + it('keeps falsy but defined sync and async return values', async () => { + register( + { name: 'zero', [HOOK]: () => 0 }, + { name: 'false', [HOOK]: () => false }, + { name: 'empty', [HOOK]: () => '' }, + { name: 'null', [HOOK]: () => null }, + { name: 'async-zero', [HOOK]: async () => 0 } + ) + + expect(await invoke()).toEqual([0, false, '', null, 0]) }) it('awaits thenables that are not native promises', async () => { @@ -264,14 +285,15 @@ describe('invokeExtensionsAsync', () => { expect(results).toEqual(['done']) }) - it('skips disabled extensions', async () => { + it('skips disabled extensions without leaving a slot', async () => { const hook = vi.fn() register({ name: 'off', [HOOK]: hook }, { name: 'on', [HOOK]: hook }) useExtensionStore().loadDisabledExtensionNames(['off']) - await invoke() + const results = await invoke() expect(hook).toHaveBeenCalledOnce() + expect(results).toHaveLength(1) }) it('calls hooks inherited from the prototype chain', async () => { @@ -303,9 +325,10 @@ describe('invokeExtensionsAsync', () => { { name: 'after', [HOOK]: after } ) - await invoke() + const results = await invoke() expect(after).toHaveBeenCalledOnce() + expect(results).toEqual([undefined, undefined]) expect(console.error).not.toHaveBeenCalled() }) @@ -323,10 +346,12 @@ describe('invokeExtensionsAsync', () => { { name: 'after', [HOOK]: after } ) - await invoke() + const results = await invoke() expect(before).toHaveBeenCalledOnce() expect(after).toHaveBeenCalledOnce() + expect(results).toHaveLength(3) + expect(results[1]).toBeUndefined() expect(console.error).toHaveBeenCalledOnce() expect(vi.mocked(console.error).mock.calls[0][0]).toBe( `Error calling extension 'sync-throw' method '${HOOK}'` diff --git a/src/services/extensionService.ts b/src/services/extensionService.ts index 7318e28d8c9..f8cedd7c541 100644 --- a/src/services/extensionService.ts +++ b/src/services/extensionService.ts @@ -280,19 +280,21 @@ export const useExtensionService = () => { /** * Invoke an async extension callback * Each callback will be invoked concurrently, in extension order. Only - * extensions that define the callback do any work, and only the promises - * that callbacks actually return are awaited (callbacks that return - * synchronously are never wrapped in a promise). The resolved array holds - * the results of those async callbacks, so it is not index-aligned with the - * extensions. + * extensions that define the callback do any work, and only promises that + * callbacks actually return are awaited (callbacks that return + * synchronously are never wrapped in a promise). * @param {string} method The extension callback to execute * @param {...unknown} args Any arguments to pass to the callback - * @returns + * @returns One entry per enabled extension, in extension order: the + * (awaited) return value of its callback, or undefined if it has no such + * callback or the callback threw or rejected. */ const invokeExtensionsAsync = async ( method: T, ...args: Parameters> ) => { + type Result = Awaited>> | undefined + const logError = (ext: ComfyExtension, error: unknown) => console.error( `Error calling extension '${ext.name}' method '${method}'`, @@ -303,13 +305,15 @@ export const useExtensionService = () => { // This runs once per node def per extension, so avoid allocating promises // or closures for extensions that do not define the hook. - const pending: Promise[] = [] - for (const ext of extensionStore.enabledExtensions) { + const exts = extensionStore.enabledExtensions + const results: Result[] = Array.from({ length: exts.length }) + const pending: Promise[] = [] + exts.forEach((ext, index) => { // The property read is inside the try so a throwing getter or Proxy trap // only affects its own extension. try { const fn = ext[method] - if (typeof fn !== 'function') continue + if (typeof fn !== 'function') return if (method === 'setup') { // Track the current extension for legacy compatibility @@ -321,22 +325,31 @@ export const useExtensionService = () => { } finally { legacyMenuCompat.setCurrentExtension(null) } - })().catch((error) => logError(ext, error)) + })().then( + (value) => void (results[index] = value as Result), + (error) => logError(ext, error) + ) ) - continue + return } const result: unknown = fn.call(ext, ...args, app) if (isPromiseLike(result)) { pending.push( - Promise.resolve(result).catch((error) => logError(ext, error)) + Promise.resolve(result).then( + (value) => void (results[index] = value as Result), + (error) => logError(ext, error) + ) ) + } else { + results[index] = result as Result } } catch (error) { logError(ext, error) } - } - return await Promise.all(pending) + }) + await Promise.all(pending) + return results } return { From 847b9a1370c8dec3e30a7c8817927d592f29b2c5 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 8 Oct 2026 20:47:10 +0000 Subject: [PATCH 6/7] Revert "fix: keep results of synchronous extension hooks" This reverts commit ba333b75aa1280641572e80b7c16936a4b56d2c1. --- src/services/extensionService.test.ts | 39 +++++-------------------- src/services/extensionService.ts | 41 +++++++++------------------ 2 files changed, 21 insertions(+), 59 deletions(-) diff --git a/src/services/extensionService.test.ts b/src/services/extensionService.test.ts index f30ac5bf224..2bd9afdc2e9 100644 --- a/src/services/extensionService.test.ts +++ b/src/services/extensionService.test.ts @@ -230,11 +230,10 @@ describe('invokeExtensionsAsync', () => { expect(events).toEqual(['slow:start', 'fast:start', 'slow:end']) }) - it('returns one result per extension, in extension order', async () => { - const widgets = { CUSTOM: noop } + it('waits for async hooks and resolves with their results', async () => { register( { name: 'none-first' }, - { name: 'sync', [HOOK]: () => widgets }, + { name: 'sync', [HOOK]: () => 'sync-result' }, { name: 'a', [HOOK]: async () => 'a-result' }, { name: 'none-last' }, { name: 'b', [HOOK]: () => Promise.resolve('b-result') } @@ -242,27 +241,7 @@ describe('invokeExtensionsAsync', () => { const results = await invoke() - expect(results).toHaveLength(5) - expect(results).toEqual([ - undefined, - widgets, - 'a-result', - undefined, - 'b-result' - ]) - expect(results[1]).toBe(widgets) - }) - - it('keeps falsy but defined sync and async return values', async () => { - register( - { name: 'zero', [HOOK]: () => 0 }, - { name: 'false', [HOOK]: () => false }, - { name: 'empty', [HOOK]: () => '' }, - { name: 'null', [HOOK]: () => null }, - { name: 'async-zero', [HOOK]: async () => 0 } - ) - - expect(await invoke()).toEqual([0, false, '', null, 0]) + expect(results).toEqual(['a-result', 'b-result']) }) it('awaits thenables that are not native promises', async () => { @@ -285,15 +264,14 @@ describe('invokeExtensionsAsync', () => { expect(results).toEqual(['done']) }) - it('skips disabled extensions without leaving a slot', async () => { + it('skips disabled extensions', async () => { const hook = vi.fn() register({ name: 'off', [HOOK]: hook }, { name: 'on', [HOOK]: hook }) useExtensionStore().loadDisabledExtensionNames(['off']) - const results = await invoke() + await invoke() expect(hook).toHaveBeenCalledOnce() - expect(results).toHaveLength(1) }) it('calls hooks inherited from the prototype chain', async () => { @@ -325,10 +303,9 @@ describe('invokeExtensionsAsync', () => { { name: 'after', [HOOK]: after } ) - const results = await invoke() + await invoke() expect(after).toHaveBeenCalledOnce() - expect(results).toEqual([undefined, undefined]) expect(console.error).not.toHaveBeenCalled() }) @@ -346,12 +323,10 @@ describe('invokeExtensionsAsync', () => { { name: 'after', [HOOK]: after } ) - const results = await invoke() + await invoke() expect(before).toHaveBeenCalledOnce() expect(after).toHaveBeenCalledOnce() - expect(results).toHaveLength(3) - expect(results[1]).toBeUndefined() expect(console.error).toHaveBeenCalledOnce() expect(vi.mocked(console.error).mock.calls[0][0]).toBe( `Error calling extension 'sync-throw' method '${HOOK}'` diff --git a/src/services/extensionService.ts b/src/services/extensionService.ts index f8cedd7c541..7318e28d8c9 100644 --- a/src/services/extensionService.ts +++ b/src/services/extensionService.ts @@ -280,21 +280,19 @@ export const useExtensionService = () => { /** * Invoke an async extension callback * Each callback will be invoked concurrently, in extension order. Only - * extensions that define the callback do any work, and only promises that - * callbacks actually return are awaited (callbacks that return - * synchronously are never wrapped in a promise). + * extensions that define the callback do any work, and only the promises + * that callbacks actually return are awaited (callbacks that return + * synchronously are never wrapped in a promise). The resolved array holds + * the results of those async callbacks, so it is not index-aligned with the + * extensions. * @param {string} method The extension callback to execute * @param {...unknown} args Any arguments to pass to the callback - * @returns One entry per enabled extension, in extension order: the - * (awaited) return value of its callback, or undefined if it has no such - * callback or the callback threw or rejected. + * @returns */ const invokeExtensionsAsync = async ( method: T, ...args: Parameters> ) => { - type Result = Awaited>> | undefined - const logError = (ext: ComfyExtension, error: unknown) => console.error( `Error calling extension '${ext.name}' method '${method}'`, @@ -305,15 +303,13 @@ export const useExtensionService = () => { // This runs once per node def per extension, so avoid allocating promises // or closures for extensions that do not define the hook. - const exts = extensionStore.enabledExtensions - const results: Result[] = Array.from({ length: exts.length }) - const pending: Promise[] = [] - exts.forEach((ext, index) => { + const pending: Promise[] = [] + for (const ext of extensionStore.enabledExtensions) { // The property read is inside the try so a throwing getter or Proxy trap // only affects its own extension. try { const fn = ext[method] - if (typeof fn !== 'function') return + if (typeof fn !== 'function') continue if (method === 'setup') { // Track the current extension for legacy compatibility @@ -325,31 +321,22 @@ export const useExtensionService = () => { } finally { legacyMenuCompat.setCurrentExtension(null) } - })().then( - (value) => void (results[index] = value as Result), - (error) => logError(ext, error) - ) + })().catch((error) => logError(ext, error)) ) - return + continue } const result: unknown = fn.call(ext, ...args, app) if (isPromiseLike(result)) { pending.push( - Promise.resolve(result).then( - (value) => void (results[index] = value as Result), - (error) => logError(ext, error) - ) + Promise.resolve(result).catch((error) => logError(ext, error)) ) - } else { - results[index] = result as Result } } catch (error) { logError(ext, error) } - }) - await Promise.all(pending) - return results + } + return await Promise.all(pending) } return { From 4263e8a17d28b99ace34acd18b777784f518e6df Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 8 Oct 2026 20:51:03 +0000 Subject: [PATCH 7/7] fix: keep return values of synchronous extension hooks Collect the return value of hooks that return synchronously alongside the promises from async hooks, so invokeExtensionsAsync still resolves with every hook result. Extensions without the hook contribute nothing, and the result array is not index-aligned with the extensions. --- src/services/extensionService.test.ts | 33 ++++++++++++++++++++------- src/services/extensionService.ts | 20 ++++++++-------- 2 files changed, 35 insertions(+), 18 deletions(-) diff --git a/src/services/extensionService.test.ts b/src/services/extensionService.test.ts index 2bd9afdc2e9..a443b40af27 100644 --- a/src/services/extensionService.test.ts +++ b/src/services/extensionService.test.ts @@ -230,10 +230,11 @@ describe('invokeExtensionsAsync', () => { expect(events).toEqual(['slow:start', 'fast:start', 'slow:end']) }) - it('waits for async hooks and resolves with their results', async () => { + it('resolves with the results of the hooks that ran, in order', async () => { + const widgets = { CUSTOM: noop } register( { name: 'none-first' }, - { name: 'sync', [HOOK]: () => 'sync-result' }, + { name: 'sync', [HOOK]: () => widgets }, { name: 'a', [HOOK]: async () => 'a-result' }, { name: 'none-last' }, { name: 'b', [HOOK]: () => Promise.resolve('b-result') } @@ -241,7 +242,20 @@ describe('invokeExtensionsAsync', () => { const results = await invoke() - expect(results).toEqual(['a-result', 'b-result']) + expect(results).toEqual([widgets, 'a-result', 'b-result']) + expect(results[0]).toBe(widgets) + }) + + it('keeps falsy but defined sync and async return values', async () => { + register( + { name: 'zero', [HOOK]: () => 0 }, + { name: 'false', [HOOK]: () => false }, + { name: 'empty', [HOOK]: () => '' }, + { name: 'null', [HOOK]: () => null }, + { name: 'async-zero', [HOOK]: async () => 0 } + ) + + expect(await invoke()).toEqual([0, false, '', null, 0]) }) it('awaits thenables that are not native promises', async () => { @@ -420,20 +434,23 @@ describe('invokeExtensionsAsync', () => { expect(added).not.toHaveBeenCalled() }) - it('only waits on promises that hooks actually return', async () => { + it('does no work for extensions that do not define the hook', async () => { const all = Array.from({ length: 1000 }, (_, i): TestExtension => { - if (i === 0) return { name: `ext-${i}`, [HOOK]: async () => {} } + if (i === 0) return { name: `ext-${i}`, [HOOK]: async () => 'async' } return i % 300 === 0 - ? { name: `ext-${i}`, [HOOK]: noop } + ? { name: `ext-${i}`, [HOOK]: () => 'sync' } : { name: `ext-${i}` } }) register(...all) const promiseAll = vi.spyOn(Promise, 'all') - await invoke() + const results = await invoke() + // ext-0, ext-300, ext-600 and ext-900 define the hook; only ext-0 is async + expect(results).toEqual(['async', 'sync', 'sync', 'sync']) const [pending] = promiseAll.mock.calls[0] - expect([...pending]).toHaveLength(1) + expect([...pending]).toHaveLength(4) + expect([...pending].filter((p) => p instanceof Promise)).toHaveLength(1) }) describe('legacy menu compat tracking for setup', () => { diff --git a/src/services/extensionService.ts b/src/services/extensionService.ts index 7318e28d8c9..9bba8f46c7a 100644 --- a/src/services/extensionService.ts +++ b/src/services/extensionService.ts @@ -280,11 +280,11 @@ export const useExtensionService = () => { /** * Invoke an async extension callback * Each callback will be invoked concurrently, in extension order. Only - * extensions that define the callback do any work, and only the promises - * that callbacks actually return are awaited (callbacks that return + * extensions that define the callback do any work, and only promises that + * callbacks actually return are awaited (callbacks that return * synchronously are never wrapped in a promise). The resolved array holds - * the results of those async callbacks, so it is not index-aligned with the - * extensions. + * the results of the callbacks that ran, so it is not index-aligned with + * the extensions. * @param {string} method The extension callback to execute * @param {...unknown} args Any arguments to pass to the callback * @returns @@ -303,7 +303,7 @@ export const useExtensionService = () => { // This runs once per node def per extension, so avoid allocating promises // or closures for extensions that do not define the hook. - const pending: Promise[] = [] + const pending: unknown[] = [] for (const ext of extensionStore.enabledExtensions) { // The property read is inside the try so a throwing getter or Proxy trap // only affects its own extension. @@ -327,11 +327,11 @@ export const useExtensionService = () => { } const result: unknown = fn.call(ext, ...args, app) - if (isPromiseLike(result)) { - pending.push( - Promise.resolve(result).catch((error) => logError(ext, error)) - ) - } + pending.push( + isPromiseLike(result) + ? Promise.resolve(result).catch((error) => logError(ext, error)) + : result + ) } catch (error) { logError(ext, error) }