Which ipcRenderer.invoke promise settles when the matched ipcMain.handle never replies?

Answer to the Core Question

When an ipcMain.handle never sends a reply, the ipcRenderer.invoke promise stays pending forever. Electron’s IPC layer does not impose a timeout or automatic rejection; the promise only settles when the main process calls event.reply() or returns a value from the handler.

Why the Promise Remains Pending

• IPC messages are matched by a unique ID. The renderer keeps a table of pending callbacks keyed by that ID.
• Without a reply, the entry is never removed, so the associated Promise object remains in memory.
• Electron treats a missing reply the same as a delayed one—no distinction is made between a slow handler and a crashed one.
• Only if the channel has no registered handler at all will the renderer reject the promise immediately.

Detecting a Stalled invoke

Because the renderer cannot detect a silent main‑process handler, you must add a client‑side timeout wrapper:

function safeInvoke(channel, ...args) {
  const timeoutMs = 5000; // adjust as needed
  return Promise.race([
    ipcRenderer.invoke(channel, ...args),
    new Promise((_, reject) => setTimeout(() => reject(new Error('invoke timed out')), timeoutMs))
  ]);
}

Note that rejecting the wrapper does not cancel the main‑process handler; it may continue running and eventually send a reply that will be ignored by the renderer.

Effect on Garbage Collection

While the promise is pending, the renderer’s IPC layer holds a reference to the callback closure. Any objects captured by that closure—such as DOM nodes or large buffers—remain reachable, potentially delaying garbage collection of the entire renderer context until the page is navigated, reloaded, or the renderer process is killed.

Practical Verification Steps

1. In main.js, register a handler that never replies:

   ipcMain.handle('slow', () => {/* intentionally no reply */});
   

2. From the renderer, call:

   ipcRenderer.invoke('slow').then(console.log).catch(console.error);
   

3. Open Chrome DevTools, go to the Console tab, and observe that the promise stays in the Pending state for as long as the app runs.
4. Wrap the call with safeInvoke above and confirm that it rejects after the timeout while the raw promise remains pending.
5. Use the Memory panel to take a heap snapshot before and after the timeout to see that the pending IPC entry is still retained.

What to Ask Next

The behavior can vary slightly across Electron major releases. If you notice a different outcome, please share the exact Electron version you’re using.