- Scope `dataflow::ignored(mode, r)` so `"r13"` and `"r15"` are filtered as SP/PC bookkeeping only in `Mode::A32` and `Mode::T32`, preserving `r14` scratch reuse on ARM and general-purpose `r13`/`r15` reaching definitions on `Mode::X64`.
- Trim the fallback 32-/16-bit x86 `clobbered` list in `dataflow::def_use` to canonical `&["rax", "rcx", "rdx"]`.
- Add `dataflow_mode_registers` regressions and update `docs/ROADMAP.md` and `docs/STATUS.md`.
Reading a source folder with its `.gitignore` files applied differed from git in four ways. A pattern starting with a backslash to mean a literal `*`, `[` or `?` was read as a wildcard. A name ending in an escaped space lost the space. `**` inside a name (`a**b.js`) crossed folders, where git treats it as one `*`. And a file under an ignored folder could be brought back by a later `!` rule, which git doesn't allow. Each now matches what `git check-ignore` reports.
For a type nested in a generic type, .NET metadata lists the type arguments of the whole chain together. They were all written after the last name, so `Outer<int>.Inner` was shown as ``Outer`1/Inner<int>`` and `Outer<string>.Inner2<int>` as ``Outer`1/Inner2<string, int>``, and comparing C# source with the program reported such methods as different. Each part of the name now gets the arguments it declares. When the counts don't add up (obfuscated metadata), the arguments are kept together at the end as before.
A backtick string with no `${}` in it is a plain string, but several readers took its text as written in the source, escapes and all, or ignored it: ``require(`node\x3afs`)`` was recorded as that spelling, not `node:fs`, and a route, a preload setting or a bundle's module id written with backticks was missed. One helper now reads a quoted string or such a template by its value everywhere a string is expected. A template with an invalid escape, which is a syntax error unless tagged, is no longer reported as text.
32-bit ARM code keeps constants and addresses in small pools beside the code and loads them with `ldr rX, [pc, #off]`. Those loads recorded no reference, so strings, data and imported functions reached that way had no cross-references, and the stubs that jump to an imported function (`ldr pc, [pc, #off]`) weren't recognised as imports. The address each such load reads is now recorded, the stubs are named after the function they jump to, and the pseudo-C shows these 32-bit loads as `uint32_t`, not `uint64_t`.
Recovering a bundle's modules and saving a capture's scripts each had their own copy of the code that decides whether two paths are one file on a disk that ignores case; both now use the one in the js crate. That key also treats `ß` and `SS` as the same, as a Mac disk does. And a file planned at a path that another file needs as a folder (`pkg.js` beside `pkg.js/child.js`) is renamed whichever of the two comes first, where the later one used to fail to write.
- Escape `\n`, `\r`, `\t`, and remaining control characters (as fixed three-digit octal byte escapes) in `quote`, and decode standard C escapes (`\a`, `\b`, `\f`, `\v`) plus `\xHH` hex byte escapes in `unquote` so console commands and stderr log lines stay single-line MI records and round-trip cleanly.
- Clamp unmatched closing braces and brackets at nesting depth zero in `fields` so malformed tuple delimiters outside quotes cannot hide subsequent top-level MI fields such as `reason`.
- Normalize CRLF line endings in `drain` and pass `expected_token` to `absorb` so late or untokenized result records from other commands cannot taint `c.result` or `c.error`, while clearing stale errors on non-error records in `take_output` and still recording `^exit`.
Follow-up to #2076, which stopped a program's own `App.String` being read as `string` but left two conversion operators unmatched against a .NET program's metadata: one to `System.Collections.Generic.List<String>`, and one to `String` in a type that also converts to an unrelated `Other.String`. A short type name in a conversion target is now looked up first in the enclosing types and namespaces among the types the program has; only when nothing there has that name is it read as the built-in (`String` as `string`).
In eBPF and Solana programs, `ja32` (opcode 0x06) is an unconditional jump whose distance is in the 32-bit immediate. It was decoded as a conditional branch using the 16-bit offset, so the jump went to the wrong place and the code after it looked reachable. It is now a plain jump to the right target. Three opcodes that no version defines (0x0d, 0x0e, and 0x9d before version 2) were read as `ja` or `exit`; they are now shown as unknown, while version 2's `return` (0x9d) is kept.
A 32-bit ARM shared library has no entry point, so it was always decoded as ARM code, also when it was built as Thumb, and came out as nonsense. The mode is now taken from its function symbols, exports and function starts: Thumb when most of them carry the Thumb bit. In Thumb code that bit is also cleared wherever an address names code (functions that never return, exports, the entry point, code pointers and pointers found in data), so those match the functions they point at; on other processors an odd address is left as it is.
Setup refused a Hermes `config.yaml` whose server list was written `{ }`, `Null` or `NULL`, though each means an empty list; those are accepted now. A server entry written as a flow mapping over several lines can't be bounded by indentation, and editing one left its closing brace behind: setup and uninstall now stop and say to edit the file by hand rather than guess. An entry whose flow value is complete on its own line is edited as before, and its siblings are left byte for byte as they were.
Two modules recovered from a bundle whose paths differed only in letter case (`X.js` and `x.js`) were given both names. On Windows and on a default Mac disk those are one file, so writing the second was refused and the module was left out. Names are now compared without regard to case, also after a hash or a number has been added, so the second module gets a name of its own.
The live browser and Electron capture tools had their own copy of the code that hides declared secrets, and only that copy hid two secrets that overlap: in a network recording or a stand-in built from one, `Bearer abc` and `abc123456789` in `Bearer abc123456789` left `123456789` showing. All three now use one implementation, in the analysis crate, which hides overlapping matches as one.
Matching C# source declarations against a .NET program's metadata reported methods as different when they were the same, in four cases: a parameter of a nested type or one written with `global::`; any type or namespace with "ref" in its name (`Preference` became `Pref erence`); a type of the program's own named like a built-in (`App.String` was read as `string`); and arrays of two or more dimensions, which metadata writes as `[0...,0...]` and C# as `[,]`. Each is now read the same way on both sides.
Saving the scripts of a web capture planned two files for URLs that differed only in letter case; on Windows and on a default Mac disk those are one file, so the second script was skipped. Paths are now compared without regard to case. A script whose URL ends in `.JS`, `.MJS` or `.CJS` no longer gets a second `.js` added, and a script captured many times is numbered `.hash.2`, `.hash.3` and so on, where each copy used to add to the last one's name until it was too long to write.
- Update `analysis::web_har::replace_needles_with` to scan each UTF-8 character
boundary for the longest matching needle and merge overlapping matched byte
spans before replacing, closing the suffix leak on partially overlapping
declared secrets in HAR inspection and stand-in builds while keeping distinct
non-overlapping adjacent matches separate for stand-in deduplication budgets.
- Export `encode_query`, `contains_ascii_ci`, and `replace_needles_with` from
`analysis::web_har` and call them directly from `engine::tools::web_common`,
removing the duplicate implementations so all three redactors stay in sync.
- Strip `global::` and convert metadata `/` nested-type separators in `norm_type`
as well as `norm_type_qualified` so method parameters taking nested or
`global::`-qualified types reconcile without mismatch.
- Emit `ref ` only for leading `ref` modifiers followed by whitespace and a type
start, avoiding spurious spaces inside identifiers containing `ref` or on `@ref`
value types.
- Keep non-`System` types named like CLR built-ins (such as `App.String`) distinct
from C# built-in keywords in qualified conversion-target comparisons.
- Collapse multi-dimensional zero-lower-bound CLI array shapes (`[0...,0...]`) to
C# rank commas (`[,]`) while preserving rank-1 `[0...]` and non-zero/sized bounds.
When an app's files named the same library more than once, with a version in one place and without one in another, comparing two versions of the app kept only the last entry. A later entry with no version erased the known one on both sides, so a library upgrade went unreported. Every version found for a library is now kept (several are listed together), and entries without a version no longer replace one.
The same gap as #2053, in the live browser and Electron capture tools: a value declared as secret could still appear when it was written the way a form posts it, with lower-case or mixed-case percent escapes, or in another letter case. Those spellings are now matched without regard to case, longest first, in one pass.
The pseudo-C folded an argument's assignment into the call that follows, even when a register that assignment read had been overwritten in between: `rsi = rdi; edi += 1; f(...)` showed the call taking the new `rdi` where it takes the old one. An assignment whose source register changes before the call is now left as its own statement, and the call is shown taking the assigned register or stack slot. This covers calls, tail calls and Win64 stack arguments.
When a function was scanned before the next function's start was known, it could run on into it; the second, trimmed scan fixed its blocks, but the references the first scan had recorded stayed and still counted against the limit. References are now kept per function, replaced when a function is scanned again, and the overall limit is shared out in the order functions were found, with freed room going to functions that had been cut short.
core_archive_show on a folder added every folder and link before any file, so when max_entries cut the list, folders pushed the files out: a folder with 5 files and 2,001 subfolders read "0 files in 100 entries". Folders, links and files are now one list sorted by path before the cut, and no file after the cut is read.
When config.toml couldn't be loaded, the app refuses to save over it, and the toast for that was the engine's English message alone, without its remediation. It now leads with "Couldn't save your settings." in the UI's language, then the engine's message and what to do about it. The line is in every catalog.
Reading a link whose target isn't there answers "not found", so a config.toml that is such a link (a synced folder not mounted yet, a drive not attached) loaded as plain defaults, and the next save, or a deferred save recovered at the start, put a file where the link was. "Not found" is a first start now only when nothing is at the path itself. A link without its target loads as defaults that refuse to be saved, naming where it points, and deferred edits aren't merged over it. The note on kept copies said "up to 16"; they are config.toml.broken, then .broken.1 to .broken.15.
Scan every UTF-8 character boundary for the longest declared secret spelling,
merge overlapping or adjacent matched byte spans, and replace each merged span
once so an earlier shorter match cannot expose the suffix of a longer secret.
When two modules recovered from a bundle had the same path, the second was renamed with a `.js` ending whatever it was, so a duplicate `.ts`, `.css` or `.json` module came out as `.js`; the copy now keeps its own extension. A module id is also stripped of at most one `webpack://`, `webpack:` or `file://` prefix instead of every repeated one.