morluto/rea

Fork 0

mirror of https://github.com/morluto/rea.git synced 2026-11-05 06:45:22 +00:00

[PR #4915] fix(javascript): attribute call-path unknowns only where the walk can reach Electron #6673

New issue

Open

opened 2026-11-01 21:42:12 +00:00 by bsakaguchi · 0 comments

bsakaguchi commented

2026-11-01 21:42:12 +00:00

Owner

📋 Pull Request Information

Original PR: https://github.com/morluto/rea/pull/4915
Author: @mertkayacs
Created: 10/17/2026
Status: 🔄 Open

Base: main ← Head: fix/javascript-electron-call-paths-reference

📝 Commits (10+)

964da78 test(javascript): cover the isolated-world probe outside Electron identity
74e6b71 fix(javascript): expand Electron call paths only with an Electron reference
05a1b60 test(javascript): cover Electron reach through resolved names, aliases and worker URLs
701bf0e fix(javascript): attribute call-path unknowns only where the walk can reach Electron
9fc7700 test(javascript): cover a hoisted read that precedes a loader alias
6cf5380 fix(javascript): keep call-path unknowns for late-initialized loader aliases
75691e8 test(javascript): drop a duplicate loader-alias case
0d07317 test(javascript): cover loader aliases reached through bindings and calls
fa1c35b fix(javascript): prove a late initializer loader-free before dropping its unknown
6a7b648 test(javascript): cover loaders behind default parameters, wrappers and long alias chains

📊 Changes

12 files changed (+1695 additions, -57 deletions)

View changed files

📝 src/application/javascript/JavaScriptWrappedCallPathCancellation.test.ts (+2 -0)
📝 src/domain/javascript/electronWrappedCallPaths.ts (+49 -20)
➕ src/domain/javascript/electronWrappedCallPaths.unknown_scope.test.ts (+787 -0)
📝 src/domain/javascript/javascriptElectronMemberWrites.ts (+31 -0)
📝 src/domain/javascript/javascriptSemanticAnalysis.ts (+26 -6)
📝 src/domain/javascript/javascriptSemanticState.ts (+11 -0)
📝 src/domain/javascript/javascriptStaticAnalysis.ts (+3 -5)
📝 src/domain/javascript/javascriptSymbolicBindings.test.ts (+77 -3)
📝 src/domain/javascript/javascriptSymbolicBindings.ts (+613 -19)
➕ tests/boundary/cli/javascriptApplicationCoverage.test.ts (+92 -0)
📝 tests/boundary/mcp/agentKnownAnswerMcp.test.ts (+1 -1)
📝 tests/evaluation/model-evals/AgentEvaluationFixtures.ts (+3 -3)

📄 Description

Summary

Fixes #4893.

Since 6.5.0, analyze-javascript-application reports parse_status: "partial" for ordinary production bundles that parse cleanly, and the application graph coverage follows it to partial with no named limit. The file-level unknown comes from the Electron wrapped-call-path expansion: it evaluates calls in every module, including modules that never import or require Electron, and any read the symbolic resolver cannot settle counts as an unknown finding for the whole file. Since b8fab7429 the resolver treats a read that precedes its initializer in source order as unresolved. Every hoisted function that reads a module-level var initialized later (the timer shims in react-dom-client.production.js, for example) now trips it, so a module with no Electron surface at all is reported as partially understood.

This change keeps the expansion running on every module, so no finding is lost, and attributes the unknowns it meets to the file only where the walk could have reached Electron, as judged by the same resolver: a proven Electron callee root in the identity index, a resolver value that reached an Electron module, a require whose module name stayed unresolved, an exhausted budget, or a static import or require that names Electron or leaves its module name unresolved. Where none of that happened the walk could not have hidden a path, so its unresolved reads describe no fact the analysis could have found. Modules that reach Electron keep the current behavior, including the unknown findings their dynamic values produce.

Problem and expected behavior

Smallest trigger, a module without any Electron reference:

function schedule(callback) {
  return scheduleTimeout(callback, 0);
}
var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0;
module.exports = { schedule };

Observed on main (2fb5e204a): parse_status: "partial", parse_error_count: 0, limitation "One or more static keys, expressions, or Electron boundary values were dynamic and remain unknown.", graph coverage partial with omitted_count: null and limits: [].

Expected: parse_status: "complete" and complete graph coverage. The unknown is attributed by a walk that can only ever emit Electron call paths. Every emitted path starts at an Electron exposure or IPC registration (entryKind is only set by bridge and the IPC registration branches), and every Electron value the resolver can reach starts at a require or import of the Electron module (a require("electron") literal, the Electron identity index, or a bundler namespace that resolves to one). Without such a reference the walk cannot hide a finding, so reporting its unresolved reads as unknown findings violates the rule in AGENTS.md that unknowns describe facts the analysis could not establish, and the coverage contract in docs/javascript-application-graph.md ("Graph coverage describes the analyzed artifact scope and resource limits").

Change and scope

src/domain/javascript/javascriptSymbolicBindings.ts: the resolver records reachedElectron when an evaluated require names an Electron module and unresolvedRequire when a require's module name could not be resolved. These are the only places the resolver produces an Electron module value or gives up on one, so the gate is derived from the resolution the walk itself performs.
src/domain/javascript/electronWrappedCallPaths.ts: collectElectronWrappedCallPaths counts the unknowns it meets locally and adds them to the file's unknownFindings only when the walk could have reached Electron (identity bindings, the two resolver flags, an exhausted budget, or a module reference that names Electron or leaves its name unresolved). Paths, bridge findings and IPC registrations are produced exactly as before.
src/domain/javascript/javascriptElectronMemberWrites.ts: referencesElectronModule(references) is the predicate finalizeStaticAnalysis already used inline for the Electron identity limitation, now shared and restricted to module reference kinds (static-import, dynamic-import, require); a worker or service-worker script named electron is a script, not a module. referencesUnresolvedModule is its unresolved-name companion for the gate.
Modules that reach Electron through a variable module name (require(name)), a require alias (const load = require; load("electron")), bundler namespaces or the identity index keep their bridge findings, IPC registrations and call paths; regression tests pin these paths and the worker-URL distinction.
src/domain/javascript/javascriptSymbolicBindings.ts: when a read precedes its initializer, a resolver-backed proof drops the loader uncertainty only after establishing that the initializer cannot expose a module loader. The proof follows safe single-definition aliases and function calls, derives ordinary and rest parameter safety from the actual call arguments, treats unproven parameters, catch bindings and arguments as loader-bearing, memoizes called functions by parameter-safety signature, and fails closed when either binding recursion or AST recursion reaches depth 128.

Not included: the semantics of parse_status for Electron modules with dynamic values, and the omitted_count: null note in the issue. Both are existing, tested behavior and out of scope here.

Follow the contribution scope.
Unresolved scope, authority, side effects, or required verification block
integration. Link the required maintainer scope decision for new providers or
capabilities involving target execution, injection, mutation, or protection
recovery; ordinary fixes within existing boundaries may state "not applicable".

Contract and boundary impact

Semantic owner and earliest changed stage: domain static analysis, collectElectronWrappedCallPaths, which runs after the static traversal of one source. The static reference facts it reads are produced by that traversal.
Contribution scope fit and linked maintainer decision: ordinary fix within existing boundaries; not applicable.
CLI and MCP/tool-catalog contract: no schema change. For modules without an Electron reference, parse_status is complete when the parser completed and the file's limitations no longer carry the dynamic-unknown line; graph coverage and per-observation coverage follow. Modules with an Electron reference report exactly what they did before.
Provider, bridge, target-format, or platform compatibility: none.
Evidence, artifact, provenance, or reconstruction contract: the file-level unknown is only dropped where no Electron path could exist; retained unknowns keep their current text and placement.
Target selection, authority, upstream behavior, and cleanup details (if applicable): not applicable.
Generated metadata (docs/public/product-catalog.json), package, or installation impact (CI generates and validates ignored catalogs and skills/; edit authored instructions in .agents/skills/reverse-engineer-anything/ and never commit build outputs): none.

Expected effects (check known effects; use documentation-only on its own).
Unchecked items do not establish absence; leave uncertainties visible.

Read existing files or captured data.
Launch or attach to a process.
Inject instrumentation or run scripts/code.
Change process memory, registers, files, or configuration.
Contact network services.
Recover protected code or work around protections.
Documentation or usability only; no target interaction.
Not sure yet; investigation or maintainer guidance needed.

Evidence and regression coverage

Tests added or updated:
- src/domain/javascript/electronWrappedCallPaths.unknown_scope.test.ts: 25 cases cover non-Electron hoisted reads, real and unresolved Electron reachability, worker URLs, aliased and late-initialized loaders, default parameters, closed-over loaders, receiver-derived loaders, changed holder objects, invocation parameters, rest parameters, catch bindings, arguments, safe wrappers, a 15,000-binding alias chain, and a 15,000-term nested initializer.
- tests/boundary/cli/javascriptApplicationCoverage.test.ts: the built public CLI reports complete file and graph coverage for the minimal non-Electron trigger.
Base reproduction or other evidence (executed): on 2fb5e204a with only the first test commit applied, the hoisted-read test and the CLI test fail with expected 'partial' to be 'complete' (domain test at parse_status, CLI test at the file observation's parse_status). The Electron-reference case passes on base and after the fix. The three later tests were written against the first version of this change (a skip gated on literal Electron references) and failed there: the resolved-name and alias modules lost their bridge, IPC and call-path findings, and the worker-URL module stayed partial; they pass with the resolver-derived attribution. Instrumenting JavaScriptSymbolicBindings on react-dom-client.production.js (react-dom 19.2.0 from npm) showed every unresolved read came from scheduleTimeout, cancelTimeout, scheduleMicrotask, listener and discreteReplayableEvents reads inside hoisted functions, each initialized later in the file, evaluated by the isolated-world probe and by seeded walks of a module with no Electron reference. With the fix the domain analysis of that file returns parse_status: "complete", parse_error_count: 0, 3 references, and only the "parsed as data" limitation.
User-visible CLI/MCP output (if applicable): on this host the built CLI on a directory holding react-dom-client.production.js reports the file observation parse_status as partial on main and complete with this change. Graph coverage on that file stays partial here for a different, named reason: the semantic pass reports "Owned JavaScript worker exhausted its heap", with both the default heap and --max-heap-mb 5120, so the coverage carries the heap and timeout limits. The reporter's run did not hit that constraint; the CLI test above shows the coverage change on a module the semantic pass completes.
Remaining proof gaps: no end-to-end complete-coverage run on the reporter's exact file on this host, for the heap reason above. No real Electron runtime execution is claimed.

For evidence-bearing changes:

Observed, derived, and inferred claims remain distinguishable.
Artifact identity, source provenance, and failed attempts remain preserved.
Unsupported, incomplete, unavailable, or uncertain outcomes remain visible.

Validation performed

npm run test:focused -- src/domain/javascript/electronWrappedCallPaths.unknown_scope.test.ts tests/boundary/cli/javascriptApplicationCoverage.test.ts on c6bc7bce4: 2 files passed, 26 tests passed.
All src/domain/javascript and src/application/javascript tests via npm run test:local -- <exact test paths> on c6bc7bce4: 105 files passed, 2,765 tests passed.
npm run check:fast on c6bc7bce4: dependency check, typecheck, and lint passed.
npm run format:check on c6bc7bce4: all 4,055 matched files passed.
Historical base and intermediate failure results remain recorded in the evidence section above.

Compatibility, safety, and release

Breaking changes or migration steps: none. Consumers that treated partial on non-Electron bundles as a completeness signal get complete when the parse completed and no limit fired.
Real Hopper/Ghidra, browser, or OS coverage: not applicable; no provider involved. Linux x64, Node 24.18.0.
Package or release metadata impact: none.
Security, privacy, process, or containment review: none; the walk still runs everywhere, only the attribution of its unresolved reads changes.

Author readiness

Human owner: @mertkayacs

I reviewed the final diff and relevant existing code, understand the change and its edge cases, and take responsibility for the complete PR, including AI-assisted work.
I checked the evidence above, confirmed it supports the current change, and recorded meaningful validation gaps.
I declare this PR ready for initial maintainer review.

Before merge

This PR addresses a concrete problem or an agreed enhancement.
Material scope and authority questions are resolved, and any required maintainer scope decision covers the final diff.
The PR has one focused outcome and the title follows type(scope): outcome.
Related issue is linked, or the reason for not linking one is stated above.
Tests cover changed observable behavior and meaningful failure paths.
Owning docs, contracts, and generated metadata are updated where needed.
User-visible CLI/MCP changes include representative output.
I checked the final diff for secrets, unrelated cleanup, and unsupported claims.

_{🔄 This issue represents a GitHub Pull Request. It cannot be merged through Gitea due to API limitations.}

## 📋 Pull Request Information **Original PR:** https://github.com/morluto/rea/pull/4915 **Author:** [@mertkayacs](https://github.com/mertkayacs) **Created:** 10/17/2026 **Status:** 🔄 Open **Base:** `main` ← **Head:** `fix/javascript-electron-call-paths-reference` --- ### 📝 Commits (10+) - [`964da78`](https://github.com/morluto/rea/commit/964da78f9a66926719e2a5f51ebaf9d30bffb20b) test(javascript): cover the isolated-world probe outside Electron identity - [`74e6b71`](https://github.com/morluto/rea/commit/74e6b71f42c53f66aff70a22cfb640c11e676713) fix(javascript): expand Electron call paths only with an Electron reference - [`05a1b60`](https://github.com/morluto/rea/commit/05a1b603f97c7b94c9c125803fad2851e71c1d25) test(javascript): cover Electron reach through resolved names, aliases and worker URLs - [`701bf0e`](https://github.com/morluto/rea/commit/701bf0e0a696e093433521486272f29c8bfe96b0) fix(javascript): attribute call-path unknowns only where the walk can reach Electron - [`9fc7700`](https://github.com/morluto/rea/commit/9fc77002882e775cb13f2a7f738a03f7302669aa) test(javascript): cover a hoisted read that precedes a loader alias - [`6cf5380`](https://github.com/morluto/rea/commit/6cf53805c080b6f9cfde1347189c9d30335859db) fix(javascript): keep call-path unknowns for late-initialized loader aliases - [`75691e8`](https://github.com/morluto/rea/commit/75691e8d5f43ccdd049c43acc685f457bdfe39b8) test(javascript): drop a duplicate loader-alias case - [`0d07317`](https://github.com/morluto/rea/commit/0d073171085857e96fdf311a485242e9e2f15d4f) test(javascript): cover loader aliases reached through bindings and calls - [`fa1c35b`](https://github.com/morluto/rea/commit/fa1c35b55137c8f4601b65804f54c902f86c2c28) fix(javascript): prove a late initializer loader-free before dropping its unknown - [`6a7b648`](https://github.com/morluto/rea/commit/6a7b64835aba293579130d398a5007429a227e7a) test(javascript): cover loaders behind default parameters, wrappers and long alias chains ### 📊 Changes **12 files changed** (+1695 additions, -57 deletions) <details> <summary>View changed files</summary> 📝 `src/application/javascript/JavaScriptWrappedCallPathCancellation.test.ts` (+2 -0) 📝 `src/domain/javascript/electronWrappedCallPaths.ts` (+49 -20) ➕ `src/domain/javascript/electronWrappedCallPaths.unknown_scope.test.ts` (+787 -0) 📝 `src/domain/javascript/javascriptElectronMemberWrites.ts` (+31 -0) 📝 `src/domain/javascript/javascriptSemanticAnalysis.ts` (+26 -6) 📝 `src/domain/javascript/javascriptSemanticState.ts` (+11 -0) 📝 `src/domain/javascript/javascriptStaticAnalysis.ts` (+3 -5) 📝 `src/domain/javascript/javascriptSymbolicBindings.test.ts` (+77 -3) 📝 `src/domain/javascript/javascriptSymbolicBindings.ts` (+613 -19) ➕ `tests/boundary/cli/javascriptApplicationCoverage.test.ts` (+92 -0) 📝 `tests/boundary/mcp/agentKnownAnswerMcp.test.ts` (+1 -1) 📝 `tests/evaluation/model-evals/AgentEvaluationFixtures.ts` (+3 -3) </details> ### 📄 Description ## Summary Fixes #4893. Since 6.5.0, `analyze-javascript-application` reports `parse_status: "partial"` for ordinary production bundles that parse cleanly, and the application graph coverage follows it to `partial` with no named limit. The file-level unknown comes from the Electron wrapped-call-path expansion: it evaluates calls in every module, including modules that never import or require Electron, and any read the symbolic resolver cannot settle counts as an unknown finding for the whole file. Since b8fab7429 the resolver treats a read that precedes its initializer in source order as unresolved. Every hoisted function that reads a module-level `var` initialized later (the timer shims in `react-dom-client.production.js`, for example) now trips it, so a module with no Electron surface at all is reported as partially understood. This change keeps the expansion running on every module, so no finding is lost, and attributes the unknowns it meets to the file only where the walk could have reached Electron, as judged by the same resolver: a proven Electron callee root in the identity index, a resolver value that reached an Electron module, a require whose module name stayed unresolved, an exhausted budget, or a static import or require that names Electron or leaves its module name unresolved. Where none of that happened the walk could not have hidden a path, so its unresolved reads describe no fact the analysis could have found. Modules that reach Electron keep the current behavior, including the unknown findings their dynamic values produce. ## Problem and expected behavior Smallest trigger, a module without any Electron reference: ```js function schedule(callback) { return scheduleTimeout(callback, 0); } var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0; module.exports = { schedule }; ``` Observed on main (2fb5e204a): `parse_status: "partial"`, `parse_error_count: 0`, limitation "One or more static keys, expressions, or Electron boundary values were dynamic and remain unknown.", graph coverage `partial` with `omitted_count: null` and `limits: []`. Expected: `parse_status: "complete"` and complete graph coverage. The unknown is attributed by a walk that can only ever emit Electron call paths. Every emitted path starts at an Electron exposure or IPC registration (`entryKind` is only set by `bridge` and the IPC registration branches), and every Electron value the resolver can reach starts at a require or import of the Electron module (a `require("electron")` literal, the Electron identity index, or a bundler namespace that resolves to one). Without such a reference the walk cannot hide a finding, so reporting its unresolved reads as unknown findings violates the rule in AGENTS.md that unknowns describe facts the analysis could not establish, and the coverage contract in `docs/javascript-application-graph.md` ("Graph coverage describes the analyzed artifact scope and resource limits"). ## Change and scope - `src/domain/javascript/javascriptSymbolicBindings.ts`: the resolver records `reachedElectron` when an evaluated require names an Electron module and `unresolvedRequire` when a require's module name could not be resolved. These are the only places the resolver produces an Electron module value or gives up on one, so the gate is derived from the resolution the walk itself performs. - `src/domain/javascript/electronWrappedCallPaths.ts`: `collectElectronWrappedCallPaths` counts the unknowns it meets locally and adds them to the file's `unknownFindings` only when the walk could have reached Electron (identity bindings, the two resolver flags, an exhausted budget, or a module reference that names Electron or leaves its name unresolved). Paths, bridge findings and IPC registrations are produced exactly as before. - `src/domain/javascript/javascriptElectronMemberWrites.ts`: `referencesElectronModule(references)` is the predicate `finalizeStaticAnalysis` already used inline for the Electron identity limitation, now shared and restricted to module reference kinds (`static-import`, `dynamic-import`, `require`); a worker or service-worker script named `electron` is a script, not a module. `referencesUnresolvedModule` is its unresolved-name companion for the gate. - Modules that reach Electron through a variable module name (`require(name)`), a require alias (`const load = require; load("electron")`), bundler namespaces or the identity index keep their bridge findings, IPC registrations and call paths; regression tests pin these paths and the worker-URL distinction. - `src/domain/javascript/javascriptSymbolicBindings.ts`: when a read precedes its initializer, a resolver-backed proof drops the loader uncertainty only after establishing that the initializer cannot expose a module loader. The proof follows safe single-definition aliases and function calls, derives ordinary and rest parameter safety from the actual call arguments, treats unproven parameters, catch bindings and `arguments` as loader-bearing, memoizes called functions by parameter-safety signature, and fails closed when either binding recursion or AST recursion reaches depth 128. Not included: the semantics of `parse_status` for Electron modules with dynamic values, and the `omitted_count: null` note in the issue. Both are existing, tested behavior and out of scope here. Follow the [contribution scope](https://github.com/morluto/rea/blob/main/CONTRIBUTING.md#contribution-scope). Unresolved scope, authority, side effects, or required verification block integration. Link the required maintainer scope decision for new providers or capabilities involving target execution, injection, mutation, or protection recovery; ordinary fixes within existing boundaries may state "not applicable". ## Contract and boundary impact - Semantic owner and earliest changed stage: domain static analysis, `collectElectronWrappedCallPaths`, which runs after the static traversal of one source. The static reference facts it reads are produced by that traversal. - Contribution scope fit and linked maintainer decision: ordinary fix within existing boundaries; not applicable. - CLI and MCP/tool-catalog contract: no schema change. For modules without an Electron reference, `parse_status` is `complete` when the parser completed and the file's `limitations` no longer carry the dynamic-unknown line; graph coverage and per-observation coverage follow. Modules with an Electron reference report exactly what they did before. - Provider, bridge, target-format, or platform compatibility: none. - Evidence, artifact, provenance, or reconstruction contract: the file-level unknown is only dropped where no Electron path could exist; retained unknowns keep their current text and placement. - Target selection, authority, upstream behavior, and cleanup details (if applicable): not applicable. - Generated metadata (`docs/public/product-catalog.json`), package, or installation impact (CI generates and validates ignored catalogs and `skills/`; edit authored instructions in `.agents/skills/reverse-engineer-anything/` and never commit build outputs): none. Expected effects (check known effects; use documentation-only on its own). Unchecked items do not establish absence; leave uncertainties visible. - [x] Read existing files or captured data. - [ ] Launch or attach to a process. - [ ] Inject instrumentation or run scripts/code. - [ ] Change process memory, registers, files, or configuration. - [ ] Contact network services. - [ ] Recover protected code or work around protections. - [ ] Documentation or usability only; no target interaction. - [ ] Not sure yet; investigation or maintainer guidance needed. ## Evidence and regression coverage - Tests added or updated: - `src/domain/javascript/electronWrappedCallPaths.unknown_scope.test.ts`: 25 cases cover non-Electron hoisted reads, real and unresolved Electron reachability, worker URLs, aliased and late-initialized loaders, default parameters, closed-over loaders, receiver-derived loaders, changed holder objects, invocation parameters, rest parameters, catch bindings, `arguments`, safe wrappers, a 15,000-binding alias chain, and a 15,000-term nested initializer. - `tests/boundary/cli/javascriptApplicationCoverage.test.ts`: the built public CLI reports complete file and graph coverage for the minimal non-Electron trigger. - Base reproduction or other evidence (executed): on 2fb5e204a with only the first test commit applied, the hoisted-read test and the CLI test fail with `expected 'partial' to be 'complete'` (domain test at `parse_status`, CLI test at the file observation's `parse_status`). The Electron-reference case passes on base and after the fix. The three later tests were written against the first version of this change (a skip gated on literal Electron references) and failed there: the resolved-name and alias modules lost their bridge, IPC and call-path findings, and the worker-URL module stayed `partial`; they pass with the resolver-derived attribution. Instrumenting `JavaScriptSymbolicBindings` on `react-dom-client.production.js` (react-dom 19.2.0 from npm) showed every unresolved read came from `scheduleTimeout`, `cancelTimeout`, `scheduleMicrotask`, `listener` and `discreteReplayableEvents` reads inside hoisted functions, each initialized later in the file, evaluated by the isolated-world probe and by seeded walks of a module with no Electron reference. With the fix the domain analysis of that file returns `parse_status: "complete"`, `parse_error_count: 0`, 3 references, and only the "parsed as data" limitation. - User-visible CLI/MCP output (if applicable): on this host the built CLI on a directory holding `react-dom-client.production.js` reports the file observation `parse_status` as `partial` on main and `complete` with this change. Graph coverage on that file stays `partial` here for a different, named reason: the semantic pass reports "Owned JavaScript worker exhausted its heap", with both the default heap and `--max-heap-mb 5120`, so the coverage carries the heap and timeout limits. The reporter's run did not hit that constraint; the CLI test above shows the coverage change on a module the semantic pass completes. - Remaining proof gaps: no end-to-end complete-coverage run on the reporter's exact file on this host, for the heap reason above. No real Electron runtime execution is claimed. For evidence-bearing changes: - [x] Observed, derived, and inferred claims remain distinguishable. - [x] Artifact identity, source provenance, and failed attempts remain preserved. - [x] Unsupported, incomplete, unavailable, or uncertain outcomes remain visible. ## Validation performed - `npm run test:focused -- src/domain/javascript/electronWrappedCallPaths.unknown_scope.test.ts tests/boundary/cli/javascriptApplicationCoverage.test.ts` on `c6bc7bce4`: 2 files passed, 26 tests passed. - All `src/domain/javascript` and `src/application/javascript` tests via `npm run test:local -- <exact test paths>` on `c6bc7bce4`: 105 files passed, 2,765 tests passed. - `npm run check:fast` on `c6bc7bce4`: dependency check, typecheck, and lint passed. - `npm run format:check` on `c6bc7bce4`: all 4,055 matched files passed. - Historical base and intermediate failure results remain recorded in the evidence section above. ## Compatibility, safety, and release - Breaking changes or migration steps: none. Consumers that treated `partial` on non-Electron bundles as a completeness signal get `complete` when the parse completed and no limit fired. - Real Hopper/Ghidra, browser, or OS coverage: not applicable; no provider involved. Linux x64, Node 24.18.0. - Package or release metadata impact: none. - Security, privacy, process, or containment review: none; the walk still runs everywhere, only the attribution of its unresolved reads changes. ## Author readiness Human owner: @mertkayacs - [x] I reviewed the final diff and relevant existing code, understand the change and its edge cases, and take responsibility for the complete PR, including AI-assisted work. - [x] I checked the evidence above, confirmed it supports the current change, and recorded meaningful validation gaps. - [x] I declare this PR ready for initial maintainer review. ## Before merge - [x] This PR addresses a concrete problem or an agreed enhancement. - [x] Material scope and authority questions are resolved, and any required maintainer scope decision covers the final diff. - [x] The PR has one focused outcome and the title follows `type(scope): outcome`. - [x] Related issue is linked, or the reason for not linking one is stated above. - [x] Tests cover changed observable behavior and meaningful failure paths. - [x] Owning docs, contracts, and generated metadata are updated where needed. - [x] User-visible CLI/MCP changes include representative output. - [x] I checked the final diff for secrets, unrelated cleanup, and unsupported claims. --- <sub>🔄 This issue represents a GitHub Pull Request. It cannot be merged through Gitea due to API limitations.</sub>

bsakaguchi added the

pull-request

label

2026-11-01 21:42:12 +00:00

No milestone

No project

No assignees

1 participant

Notifications

Due date

The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference

morluto/rea#6673

No description provided.

Rows
Columns