REA says an Electron message has no handler? Check dynamic channels.

We reproduced incorrect IPC pairing in REA 6.8.0 and tested a source fix for computed channels and wrappers.

Your reading list
The fixed build marks all three unresolved channel cases ambiguous.

A renderer sends app:log. The main process registers a handler using process.env.CHANNEL. Can a static analyzer know whether they match? It cannot, unless that channel value is resolved.

Published REA 6.8.0 nevertheless labeled that send unpaired in our reproduction. With a wrapper that registers both a literal and a computed channel, it went the other way and labeled the send paired. Both answers were too certain.

The source build we tested returns ambiguous for these cases. This is a useful correction when reading an Electron application graph: it tells you which connection still needs investigation, rather than inventing absence or a unique match.

What we tested

We ran the real analyze-javascript-application CLI against six generated CommonJS Electron fixtures. We did not install or launch Electron, execute the fixture JavaScript, or claim a real application was affected. These are static-analysis checks.

The comparison used Node 24.22.1 on macOS 26.6.2 arm64, published rea-agents@6.8.0, and source commit b1ff7cdacc03110d51bcac33da3cbb7850ac27fc. Both manifests say 6.8.0; the version string alone does not identify the fix. We have not established which later npm release first includes it.

Every numbered step includes a real terminal screenshot of the test harness output, with arrows only. The downloadable test kit retains the full CLI responses and executable assertions. The fixtures are deliberately small so the checked behavior is clear.

1. Prepare the six channel fixtures

Extract the kit as rea-ipc-test. With Node 24.22.1 active, build a sibling source checkout and install the pinned comparison package:

git clone https://github.com/morluto/rea.git rea-upstream-test
cd rea-upstream-test
git checkout b1ff7cdacc03110d51bcac33da3cbb7850ac27fc
npx --yes npm@11.16.0 ci
npx --yes npm@11.16.0 run build:cached
cd ../rea-ipc-test
npm ci
node lab.mjs prepare

Set REA_SOURCE to the source checkout path if it is elsewhere.

The kit creates main.js, preload.js and package.json for each case. The renderer sends the same literal channel in every fixture:

require("electron").ipcRenderer.send("app:log", 1);

The simplest ambiguous handler is ipcMain.on(process.env.CHANNEL, () => {}). The environment-variable name is part of the parsed source; this test does not supply a runtime value for it.

Actual preparation output records the channel, six fixtures and the pinned build.

2. Reproduce the misleading pairing

node lab.mjs reproduce

The harness checks published 6.8.0 against three shapes: a direct computed handler, a mixed literal/computed wrapper, and an exported registration wrapper.

The direct and exported cases report one unpaired send. The mixed wrapper reports one paired send. All three report zero ambiguous sends. These are successful commands containing misleading static conclusions, not a CLI crash.

Published REA reports unpaired or paired sends where the handler channel remains unresolved.

3. Run the source fix on the same files

node lab.mjs fix

All three cases must now report one ambiguous transmission and zero paired or unpaired transmissions. The harness checks input-directory hashes before and after each CLI call.

The actionable change is to use this tested analyzer build and retain the ambiguity. Do not rename an application’s channels just to obtain a cleaner graph. For your own input, run:

node ../rea-upstream-test/scripts/rea.mjs   analyze-javascript-application /absolute/path/to/app --format json

Read normalized_result.summary.ipc alongside the source locations and the graph’s remaining limitations.

The fixed build marks all three unresolved channel cases ambiguous.

4. Check that known handlers still pair

node lab.mjs controls

The literal handler and the wrapper whose calls all use literal channels still pair with the send. A fixture with no main handler remains unpaired. These controls matter: changing every transmission to ambiguous would hide useful information.

A static paired result still does not prove that a handler runs. To establish runtime delivery, observe the actual app and its channel values in a separate authorized investigation.

Literal handler controls remain paired while the no-handler control remains unpaired.

For a broader investigation, keep the evidence checklist beside the result and preserve unknowns when following relationships.

Next article

REA cannot find a framework Info.plist that is right there

Intermediate · 5 MIN READ

Related articles

All guides

Open full-resolution image ↗