Commit Graph
9371 Commits
Author SHA1 Message Date
morluto 587cca5c5c fix(capture): keep credential checks independent of body filters (#13215) 2026-11-21 21:27:18 +00:00
morluto 1e89bcc216 test(capture): consolidate Protobuf descriptor identity checks (#13214) 2026-11-21 16:24:24 -05:00
morluto 6152c02f3f fix(capture): retain credential checks across MIME conflicts (#13209) 2026-11-21 21:12:50 +00:00
morluto 62d836a630 test(capture): retain independent Playwright trace coverage checks (#13208) 2026-11-21 21:09:37 +00:00
Prince Kumar 6d92ca438f test: cover Unicode code point ordering 2026-11-21 22:09:16 +01:00
Iain afc040cceb fix(model): recognize F8_E4M3 GGUF tensors from ggml v0.29.0 2026-11-21 22:01:42 +01:00
morluto 339f0ace57 test(capture): consolidate Playwright trace contracts (#13207) 2026-11-21 20:55:20 +00:00
morluto ff3919f3eb fix(capture): distinguish corrupt SAZ metadata bytes (#13204) 2026-11-21 20:51:33 +00:00
morluto a2faf4cc34 test(capture): prove retained summaries survive source deletion (#13206) 2026-11-21 20:48:19 +00:00
morluto 088bc68b1c fix(capture): surface unsupported decoder requirements (#13203) 2026-11-21 20:38:10 +00:00
morluto 204434e087 test(native): isolate Objective-C ivar alignment coverage (#13205) 2026-11-21 15:36:31 -05:00
Afloat 71a7e0d9ff perf(desktop): bound retained text lines while counting full files (#10207) 2026-11-21 21:33:01 +01:00
RRFZ ce3506e298 fix(elf): clear the ARM Thumb bit before naming unwind ranges (#9692)
An ARM STT_FUNC or STT_GNU_IFUNC value for Thumb code is the code
address with bit 0 set (AAELF32 symbol values), while an FDE initial
location is the even code address. inspect_elf_unwind_ranges matched
symbol values to FDE starts exactly, so a Thumb function described by an
.eh_frame FDE lost its name: the range was named by a local label or
mapping symbol from .symtab, or had no name when only .dynsym was left.
On ARM EABI such FDEs come mostly from hand-written assembly with .cfi
directives; compiled code unwinds through .ARM.exidx.

Clear bit 0 of ARM function and IFUNC symbol values before the lookup, as
the ELF initializer and Android JNI readers already do. Mapping symbols
and other machines keep their values.
2026-11-21 21:32:08 +01:00
LexLuthorPrimero 402273dd57 docs(third-party): warn against identically named jar source on npm 2026-11-21 21:28:57 +01:00
Filhao2019 2fbcec84eb fix(mcp): name the HTTP option that requires --http 2026-11-21 21:28:49 +01:00
fengqiaoquandAnankequ 3dcd6b62e8 test(native): retain per-ivar alignment facts in mixed lists (#3424)
fix(apple): decode the ivar WORD_ALIGN sentinel as 8-byte alignment

Co-authored-by: Anankequ <2983852214@qq.com>
2026-11-21 21:24:28 +01:00
Dayan KijegeandClaude Opus 5.5 d955cd0d60 fix(elf): do not count SPARC register declarations as imports
On SPARC, symbol type 13 is STT_SPARC_REGISTER. An undefined entry of
that type declares use of the global register named by st_value and
may have an empty name (SPARC V9 ABI); it is not an import.
inspect-elf-dependencies listed each one as an unnamed import, recorded
a name_unreadable issue for its empty name, and marked coverage
partial. JNA's sunos-sparcv9 libjnidispatch.so (shipped in Eclipse
Installer) declares %g2 and %g3 this way and reported 47 imports, two
of them unnamed, with partial coverage.

parseImports now skips undefined type-13 entries when e_machine is
EM_SPARC, EM_SPARC32PLUS or EM_SPARCV9. Elsewhere type 13 is a
different processor-specific type and keeps today's row.

Validation (macOS arm64, Node 24.22.1):
- New parser regressions for machines 2, 18 and 43 (big-endian, 32-
  and 64-bit) fail before this change; a non-SPARC control keeps the
  unnamed row and partial coverage.
- ElfDependencyParser, ElfDependenciesProvider and ElfDependenciesView:
  79 passed. Format, typecheck, lint and architecture guards pass.
- Real file: libjnidispatch.so now reports 45 imports, complete
  coverage and no issues, matching the 45 named undefined dynamic
  symbols llvm-nm lists.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 21:24:17 +01:00
Deepak Jain 68657d55bb test(mcp): cover wrapped ENOTCONN connection loss
The ENOTCONN classifier and direct-error regression landed in #11490.
Keep that implementation and add coverage for an HTTP listener error whose
parsed system code is ENOTCONN after its native cause is made opaque.

Group the direct and wrapped cases outside the runtime test function to
keep the existing function-size limit while retaining both assertions.

Related: #11362

Signed-off-by: Deepak Jain <deepujain@gmail.com>
2026-11-21 21:24:09 +01:00
Deepak Jain 2337ebe130 fix(frida): keep ptrace seize guidance from overclaiming
The remediation for a refused ptrace seize said injection was unavailable
whatever the target. Frida's reason carries no errno, so REA cannot tell a
host that lacks PTRACE_SEIZE, such as PRoot-Distro, from a ptrace permission
policy that refused only the selected process. Sending the second case to
another host would be wrong.

Word the remediation as two possibilities. If other targets fail the same
way, run REA on a host with native ptrace support or use a remote Frida
server. Otherwise check the ptrace permissions that apply to this target. The
regression test now asserts the conditional wording and that the host-wide
claim is gone.

Refs #9103

Signed-off-by: Deepak Jain <deepujain@gmail.com>
2026-11-21 21:24:01 +01:00
Deepak Jain 317f90e023 fix(frida): explain refused ptrace seize during injection
When Frida cannot start tracing a target because its ptrace seize request
was refused, REA reported the generic "Choose another analysis or target"
remediation. On PRoot-Distro, which does not implement PTRACE_SEIZE, no
target can work, so that advice sent operators in the wrong direction while
device and process discovery kept succeeding.

Recognize Frida's "Unable to perform ptrace seize" reason in the Frida
provider's failure conversion and return a message and remediation that name
the refused request, say injection is unavailable whatever the target, and
point at a host with native ptrace support or a remote Frida server. The
remote-connect remediation moves into the same helper. Other Frida startup
failures keep the generic remediation, and incomplete cleanup still takes
precedence over both.

Refs #9103

Signed-off-by: Deepak Jain <deepujain@gmail.com>
2026-11-21 21:24:01 +01:00
morluto 1c982b82fe test(har): consolidate producer and evidence coverage (#13202) 2026-11-21 20:20:49 +00:00
Jeffandgithub-actions[bot] e773afd9c3 docs(native): explain resource-only bundle admission (#5764)
* docs(native): explain resource-only bundle admission

* docs(native): name supported resource-session commands

* docs: refresh resource-session guide

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
2026-11-21 21:19:57 +01:00
morluto fb691dc98b docs(dev): clarify how to review duplicate ownership 2026-11-21 15:12:26 -05:00
XiaoBinGan d777c3c55f perf(entropy): count bytes through one shared loop
A reviewer read the test and said it would still pass with `Uint32Array` back at
`ByteEntropyService.ts:258`. That was correct, and I verified it: reverting the counter to
`Uint32Array` left all four cases green. The test pinned the counter type but not the loop that
fills it, so nothing tied the service's census to the exact counter.

The two counting loops were copies of each other — `computeBlockEntropy` and the service each had
their own. They are one function now, `countByteValues(bytes, counts)`, whose `counts` parameter is
`Float64Array`. That makes the counter type part of the signature rather than a local decision: a
narrower bin is a compile error at the call site, which is the guarantee the test was pretending to
give.

With `const counts = new Uint32Array(256);` at that line:

    src/application/binaryDiagnostics/ByteEntropyService.ts(282,36): error TS2345:
    Argument of type 'Uint32Array<ArrayBuffer>' is not assignable to parameter of type
    'Float64Array<ArrayBufferLike>'.

The tests changed to match what they can actually prove:

- a census that lands just under 2^32 and then crosses it in one more chunk, asserting the total
  does not wrap;
- two chunks accumulating into one counter, matching how the service counts a stream, compared
  against the same bytes counted as one run.

I did not attempt a 4 GiB fixture: the loop is called per chunk, so crossing the boundary with a
counter set near it exercises the same arithmetic without a quarter-hour of I/O.

`src/domain/native/byteEntropy.test.ts` — 5 cases. `tsc` 0 errors.
2026-11-21 21:12:12 +01:00
XiaoBinGan a3acfcf003 fix(entropy): keep the whole-file census in a counter that cannot wrap
The previous commit moved the whole-file census into a `Uint32Array`. That bin wraps
at 2^32 occurrences of one byte, and the service admits files up to
`Number.MAX_SAFE_INTEGER`, so a 6 GiB zero-filled file reported
`entropyFromCounts(counts, size)` = 0.5283 instead of 0.

Measured on 8 MiB, three interleaved runs against the compiled counter:

| form | time |
| --- | --- |
| `for...of` + `Float64Array` | 79.59ms |
| indexed + `Float64Array` | 9.26ms |
| indexed + `Uint32Array` | 9.28ms |

The 8x comes from the indexed reads, not from the integer bin, so exactness costs
nothing here. The bounded block counter stays bounded by `block_size` (max 65536) and
also uses a `Float64Array` so the two counters read the same.

`wholeFileByteCounts` names the counter the service uses, so the test can assert the
property that matters: a count above 2^32 survives. It fails on the previous commit.

`src/domain/native` + `src/application/binaryDiagnostics`: 443 passing. One test fails
on this Windows host before and after this diff — `reports a changed artifact when its
parent directory moves during streaming` fails with `ENOENT` on a directory rename.
`tsc` 0; `npm run lint` 0 errors; `knip` 0.
2026-11-21 21:12:12 +01:00
XiaoBinGan 5d3276d14c perf(entropy): count bytes by index into an integer table
Both entropy counters walked the payload with `for (const byte of bytes)` and
accumulated into a `Float64Array` through `counts[byte] ?? 0`. Iterating a typed
array that way costs far more than an indexed read, and the nullish fallback is dead
work because a typed-array element is never `undefined`.

Measured on the compiled function with a 4 MiB block, alternating the two bodies so
both run in the same process:

| body | time |
| --- | --- |
| `for...of` + `Float64Array` | 37.15ms |
| indexed + `Uint32Array` | 4.64ms |

That is **8.01x** on the counter. Entropy values are unchanged: 300 randomised and
boundary inputs produce identical results to the previous implementation, and the
4 MiB fixture reports the same entropy from both bodies.

`ByteEntropyService` streams the same accounting over each read buffer, so it gets
the same change; `filled` bounds that loop because the buffer is reused between
reads.

`src/domain/native` and `src/application/binaryDiagnostics`: 442 passing. One test
fails on this Windows host in both the base and this diff — `reports a changed
artifact when its parent directory moves during streaming` fails with `ENOENT` on a
directory rename, so it is environmental, not caused by this change. `tsc` 0;
`npm run lint` 0 errors; `knip` 0.
2026-11-21 21:12:12 +01:00
Saiyam Jain 1d78e6abe6 fix(state-view): preserve partial list status when total count is invalid 2026-11-21 21:12:03 +01:00
Saiyam Jain 00b4082d4c fix(state-view): reject unsafe integers in recorded item counts 2026-11-21 21:12:03 +01:00
XiaoBinGan 62c4c25d19 fix(javascript): include the underscore in the http token class
A review finding, measured on Node 24.22.1. `_` is an RFC 9110 `tchar`, and the class I wrote
omitted it, so a valid method was reported as refused:

| call | outcome |
| --- | --- |
| `http.request({method: "M_SEARCH"})` | request constructed |
| `http.request({method: "X_CUSTOM"})` | request constructed |
| `http.request({method: "_"})` | request constructed |
| `http.request({method: "M-SEARCH"})` | request constructed |
| `http.request({method: "A B"})` | THREW `ERR_INVALID_HTTP_TOKEN` |

The class now matches RFC 9110 exactly. Three cases pin the characters a hand-written class is
most likely to drop: `_`, and the `-` that was already present.

`src/domain/javascript`: 5665 passing.
2026-11-21 21:11:54 +01:00
XiaoBinGan adf186d5ff fix(javascript): reject an http method token Node refuses at the call site
`http`/`https` validate `options.method` with `checkIsHttpToken` before the request exists, so a
literal outside the RFC 9110 token class throws `ERR_INVALID_HTTP_TOKEN` and no request is
created. The analyzer reported one anyway.

Measured on Node 24.22.1:

| call | outcome |
| --- | --- |
| `http.request({method: "BAD METHOD"})` | THREW `ERR_INVALID_HTTP_TOKEN` |
| `http.request({method: "GET"})`, `{method: "POST"}` | request constructed |
| `http.request({method: ""})` | request constructed — empty is a valid token, Node falls back to GET |
| `http.request("http://h/", {method: "BAD METHOD"})` | THREW |
| `http.request(new URL("http://h/"), {method: "BAD METHOD"})` | THREW |

## What this decides, and what it deliberately does not

Only shapes where the copied value is certainly the syntactic one:

- slot 0 is an options literal, or
- slot 0 is a string, a template or a verified `new URL`, so the `(url, options)` overload is proven

Every other shape keeps the request. Each of these was measured and can put something else in the
slot or change the copied value:

| call | outcome | why undecided here |
| --- | --- | --- |
| `http.request(() => {}, {method: "BAD METHOD"})` | request constructed | slot 0 is the callback, slot 1 unread |
| `https.request(null, {method: "BAD METHOD"})` | request constructed | `https` keeps its default options for a falsy input |
| `{get x() { this.method = "GET"; }, method: "BAD METHOD"}` | request constructed | the getter runs before the copy |
| `{method: "BAD METHOD", get x() { this.method = "GET"; }}` | THREW | getter after the copy cannot rescue it, but this reader does not model copy order |
| `{...{host: "h"}, method: "BAD METHOD"}` | THREW | a spread may replace the member |

The last two are the honest gap in this change. Closing them needs `Object.assign`'s enumeration
order — integer keys first, first-insertion position for a redefined key — which is a different
piece of work and belongs in its own change rather than widening this one.

Keeping a request Node never makes is the safer direction, and it is the direction I chose
wherever the copy is not certainly the literal.

## Contract and boundary impact

- Semantic owner and earliest changed stage: request candidate collection in the JavaScript domain.
- CLI and MCP/tool-catalog contract: none.
- Provider, bridge, target-format, or platform compatibility: `fetch` and `WebSocket` keep their
  existing behavior; both use a different member and do not validate a token.
- Evidence, artifact, provenance, or reconstruction contract: a refused call no longer reports a
  request operation or its linked release.
- Generated metadata, package, or installation impact: none.

Expected effects:

- [x] Analysis facts only; no target interaction.

## Validation performed

- 15 cases in `javascriptSemanticAnalysis.http_method_token.test.ts`; reverting the reader fails 5.
- `src/domain/javascript` — 5644 passing.
- `npm run format:check` — exit 0.
- `npm run lint` — 0 errors.

## 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] Tests cover changed observable behavior and meaningful failure paths.
- [x] Owning docs, contracts, and generated metadata are updated where needed.
- [x] I checked the final diff for secrets, unrelated cleanup, and unsupported claims.

## Author readiness

Human owner: @XiaoBinGan

- [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, confirm it supports the current change, and recorded meaningful validation gaps.
- [x] I declare this PR ready for initial maintainer review.
2026-11-21 21:11:54 +01:00
RRFZ d500638d5d fix(javascript): track shared ESM HTTP agent mutations 2026-11-21 21:10:59 +01:00
RRFZ f54cc2f3ac fix(javascript): omit requests rejected by the default agent protocol 2026-11-21 21:10:59 +01:00
RRFZ 9f74043fa6 test(javascript): verify candidate response provenance in the graph 2026-11-21 21:10:51 +01:00
RRFZ a8d714f0e3 fix(javascript): qualify response consumers with uncertain receivers 2026-11-21 21:10:51 +01:00
morluto 286d599e9f test(web): consolidate passive capture comparison coverage (#13200) 2026-11-21 20:10:41 +00:00
XiaoBinGan 1aa394d62d fix(browser): report only grammatical CORP and X-Content-Type-Options values
One regex served both headers — `^[a-z][a-z0-9_.\x2d]*$` after lowercasing — so any token counted as a
declared policy. Measured through `safeResponseMetadata`:

| `Cross-Origin-Resource-Policy` | published | Fetch 3.7 |
| --- | --- | --- |
| `same-origin` | `same-origin` | `same-origin` |
| `SAME-ORIGIN` | `same-origin` | none |
| `Same-Site` | `same-site` | none |
| `same-origin-ish` | `same-origin-ish` | none |
| `same_origin` | `same_origin` | none |
| `unsafe-none` | `unsafe-none` | none |

The value ABNF is `%s"same-origin" / %s"same-site" / %s"cross-origin"`, and `%s` is case-sensitive,
so the internal check nulls every other spelling. Case folding made `SAME-ORIGIN` worse than a bad
echo: it turned a value browsers ignore into the enforced spelling, so an observation claimed
embedding isolation the page did not have.

`X-Content-Type-Options` declares exactly one case-insensitive `nosniff`, and "determine nosniff"
tests `values[0]` of the combined header. The strict whole-value match also dropped valid
declarations — `nosniff` sent on two lines, or `nosniff, sniff`, both published nothing. The reader
takes the first list member now.

| `X-Content-Type-Options` | before | after |
| --- | --- | --- |
| `nosniff` | `nosniff` | `nosniff` |
| `NOSNIFF` | `nosniff` | `nosniff` |
| `nosniff\nnosniff` | none | `nosniff` |
| `nosniff, sniff` | none | `nosniff` |
| `sniff, nosniff` | none | none |
| `nosniff-ish` | `nosniff-ish` | none |

Each header has its own grammar now, and `policyToken` is gone.

`src/browser/CdpSafeMetadata.test.ts` — 133 passing, 17 new cases. Reverting either reader fails
them.
2026-11-21 21:10:02 +01:00
XiaoBinGan 985fa2fac9 fix(pe): keep pefile's unrounded raw offset for a sub-page section
`createPefileReadCompatibility` models pefile's section reads so an import hash is published only
when both readers see the same bytes. Its layout gate rejected any section whose
`PointerToRawData` was not 512-aligned — but pefile 2024.8.26's `get_PointerToRawData_adj()` skips
that rounding when `SectionAlignment < 0x1000` and `PointerToRawData == VirtualAddress`, the
`LdrpWx86FormatVirtualImage` layout ntoskrnl-era drivers use.

The gate already modelled the sub-page case two lines above (`SectionAlignment < 0x1000 ?
FileAlignment : SectionAlignment`), then rejected it against an absolute 512 rule — and
`docs/pe-imports.md` scopes the withhold to an incomplete table or a different row sequence, not to
a file offset.

Measured on a minimal image with `SectionAlignment = FileAlignment = 0x80` and `.idata` at RVA 0x300
== file offset 0x300:

| | before | after |
| --- | --- | --- |
| coverage | `complete` | `complete` |
| issues | `[]` | `[]` |
| `imphash.md5` | `null` | `92cef6cc91a85825f3c8a0516517c66f` |

The withheld hash is the only thing that differed: both readers were already reading the same bytes.

The exception is exact rather than approximate — a section with the same sub-page alignment whose
`PointerToRawData` differs from its `VirtualAddress` still withholds, because pefile does round it
there. That case is the second new test.

pefile's current `master` broadened the condition to every sub-page image; this matches the
2024.8.26 revision the module documents, which is the narrower and safer rule.

`tests/fixtures/binaryDiagnostics/peImports.ts` takes an optional `layout`, so the shared builder
produces the geometry instead of a test hand-encoding a second image. Its default is unchanged —
`SectionAlignment`/`FileAlignment` are written only when supplied, so every existing fixture keeps
its exact bytes.

`src/native/pe` — 265 passing. Restoring the absolute 512 rule fails the sub-page case.
2026-11-21 21:08:49 +01:00
CyberSproutandCursor 360bcb4c6c docs(process): record the capture PTY hangup of same-group children (#10282)
When the target exits, the terminal sends SIGHUP to its foreground process group. The capture guide now says that, and that this signal is not REA cleanup.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-11-21 21:01:14 +01:00
morluto 33d1c6ee44 test(web): control CDP teardown timing and consolidate cleanup proof (#13199) 2026-11-21 20:00:35 +00:00
David Muñoz Rey 559956cf6b refactor(inspector): own the Node discovery path rule in one module (#10680)
Node Inspector discovery reports a target as `file://` plus the pathname,
with quotes and backslashes replaced by underscores. Whether such a
pathname is identifiable was decided twice: inline in
authorizeRuntimeTargetLocation and again as NODE_DISCOVERY_AMBIGUOUS in
the createNodeDiscoveryTempDirectory fixture. The copies could drift, and
the fixture could not import the product rule without loading
JavaScriptRuntimeScope and its Electron file-scope chain.

Move the rule to src/inspector/nodeDiscoveryPath.ts, a module with no
imports, and use it from both places. Behavior is unchanged. A unit test
covers the Windows branch, which Linux CI cannot reach through the
boundary tests.

Validation: nodeDiscoveryPath and cancellation tests 12/12;
javascriptRuntimeTargetLocations and javascriptRuntimeObservation 42/42
with TMPDIR containing an underscore (exercises the /tmp fallback);
check:fast passes.

Refs morluto/rea#9996
2026-11-21 20:59:38 +01:00
morluto 7b856fa5a1 refactor(desktop): validate task pointer syntax at its shared owner 2026-11-21 20:57:32 +01:00
Nianze Wu 361be4cb63 fix(desktop): reject invalid task pointer escapes 2026-11-21 20:57:32 +01:00
David Muñoz Rey 6aa3898317 fix(apple): rethrow internal invariant violations while resolving a bundle's program file (#11392)
* fix(apple): rethrow internal invariant violations while resolving a bundle's program file

Bundle target resolution decodes Info.plist with the shared binary plist decoder, which reports a broken internal assumption as InternalInvariantError. The resolver caught every decode failure and reported it as a BinaryTargetError ("Info.plist is malformed, unsupported, or lacks CFBundleExecutable"), and its two outer catches wrapped anything else the same way. A REA defect therefore reached the caller as a fact about the user's bundle.

#11029 made the other plist consumers rethrow the invariant. The resolver's decode site and both outer catches now do the same.

Tests: a boundary test opens a .app and a .bundle through parseBinaryTarget with the decoder replaced by one that reports an invariant violation. Before this change both resolved { ok: false } with a BinaryTargetError; now both reject with the InternalInvariantError. The same bundles open normally with the real decoder.

* test(apple): mock the binary plist decoder at its domain path

Main moved the binary plist materializer from src/artifacts/apple to
src/domain/apple, and AppBundleExecutable now imports it from there. The
invariant test still mocked the old path, which no longer exists, so tsc
failed and the mock would have intercepted nothing.

The test now mocks src/domain/apple/binaryPlistMaterializer.js. With the
rethrow removed from AppBundleExecutable both cases fail; with it they pass.
2026-11-21 20:56:47 +01:00
Davmunrey 909d4702f2 test(javascript): cover array holes, nested spreads and an empty spread before an argument in kill signals
Review follow-up: firstRuntimeArgument has separate paths for an array hole, a nested array spread and an empty spread followed by another argument. child.kill(...[, "SIGINT"]) sends SIGTERM, child.kill(...[...["SIGINT"]]) sends SIGINT and child.kill(...[], "SIGKILL") sends SIGKILL; the case now pins all three.
2026-11-21 20:48:31 +01:00
ahmed0magdyandClaude Opus 5.5 4bcd0d864a fix(javascript): resolve literal spreads and const aliases in kill signals
Address review feedback on the kill() signal fact:

- Drop the semanticResolutionBlocked import, which isUnshadowedGlobal
  superseded.
- Expand spreads of array literals before selecting the signal, so
  kill(...[]) reports Node's SIGTERM default and kill(...["SIGINT"])
  reports SIGINT. A spread of anything else stays unknown.
- Follow const aliases whose only write is one unconditional initializer
  (the same !mutable + semanticStableInitializer rule other producers
  use), so `const signal = undefined; kill(signal)` reports SIGTERM.
  let, var, reassigned, and shadowed bindings stay unknown.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 20:48:31 +01:00
morluto 9230f698b3 fix(web): retain Chromium navigation kind in session evidence (#13194)
* fix(web): retain Chromium navigation kind in session evidence

* test(web): use native reload event shape in the shared timeline fixture
2026-11-21 19:47:52 +00:00
David Muñoz Rey 33ecda025f fix(ghidra): name the code seed recovery for addresses outside the listing (#10682)
inspect_native_instruction reports `not-in-listing` when an address lies
in Ghidra's memory but the listing has no instruction or defined data
there. No decode is attempted, so the answer does not show the bytes are
data, yet the result named no way forward. #10623 added the declared-seed
recovery for procedure_not_found and not_in_procedure; this is the
instruction-level sibling, where a `code` seed applies.

A not-in-listing answer now carries ghidraNotInListingLimitation(source).
It names a `code` seed (or a `function` seed for an entry point) in
REA_GHIDRA_SEED_FILE, says which setting to unset first for a selected
project or checkpoint, and does not assert that the address holds code.
decoded, data and other statuses are unchanged. The installation guide's
seed section lists the new carrier.

Validation: src/ghidra/GhidraProvider.behavior.test.ts fails 1/298 with
the caveat removed and passes 298/298 with it; check:fast passes. No
real Ghidra run.

Refs morluto/rea#3767
2026-11-21 20:47:42 +01:00
David Muñoz Rey e7a023263b fix(ghidra): say byte-search pages read match metadata live (#10684)
A search_bytes cursor resumes the same target, profile and query, and
the limitation said only that. In a real session, renaming a function
between pages changed the procedure name on the next page from the same
cursor, while the page Evidence kept the same target and profile digest
and no limitation explained the difference.

The search_bytes limitation now states that the cursor does not pin
match metadata: procedure names and other match metadata are read live
on each page, so a rename in the session between pages appears on later
pages. This takes the issue's "identify that match metadata is live"
option; binding or qualifying pages to a metadata version is left open.

No prose-asserting test was added, following the direction in #10508.
Validation: src/ghidra/GhidraProvider.behavior.test.ts 296/296;
check:fast passes.

Refs morluto/rea#8365
2026-11-21 20:46:47 +01:00
gensokyo-devandgensokyo-dev 62ec695303 fix(ghidra): link the published installation guide from decompiler remediation
The npm package does not ship docs/, so a repository-relative guide path
in doctor's remediation could not be opened by npm users. Link the guide
on GitHub instead.

Refs #7018

Co-Authored-By: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
2026-11-21 20:44:21 +01:00
gensokyo-devandgensokyo-dev dc10161a9e docs(ghidra): link the native build steps for Linux arm64
The Ghidra requirements said official archives may require building the
Linux arm64 decompiler but gave no steps, so doctor's new pointer to that
section led nowhere. Ghidra's own guide lists Linux ARM64 among the
platforms that need user-built natives; link its Building Native
Components section and state it plainly in the remediation too.

Refs #7018

Co-Authored-By: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
2026-11-21 20:44:21 +01:00