The ZIP64 end record's declared size wasn't checked. A record smaller than its fixed fields, an extent that overflows, or fixed fields that run into the locator now make the archive corrupt; a declared extent that doesn't end at the locator, or a locator that doesn't point to a record (as in archives with a stub in front), keeps reading the directory with a warning, as before.
The tokenizer split 1e+5 and 2.5E-3 into three tokens, because a number ended at the sign. A + or - right after e or E, followed by a digit, now stays in the number, except in hex, binary and octal literals, where 0x1e+5 is still 0x1e, +, 5.
The XML plist reader already decodes UTF-16 after either byte-order mark, but the check that decides a file is a plist only looked for ASCII <plist, so UTF-16 NIB archives were turned away first. The check now also finds the UTF-16LE and UTF-16BE marker after its byte-order mark, on code-unit boundaries, within the same 1 KiB probe.
A type chunk whose entry data started inside its offset table or past the chunk was still read, and a bag entry with a short header, or more values than fit in the chunk, read past its data. The type is now skipped with a warning in the first case; in the second the entry is kept without its parent and values, the table is marked truncated, and a warning says why. A bag with more values than the reader keeps is marked truncated too.
Binary plist dates and keyed-archive NSDate values were shown floored to whole seconds, so events within one second looked the same. They now keep their fraction, rounded to microseconds (finer would only show the float's noise for present-day dates), with a rounded-up second carried into the date; whole seconds still show without a fraction.
A data node that failed to inflate, used an unsupported compression or decoded to a length other than its declared size was skipped, leaving zeros or older bytes in the file while it looked recovered, and an overlong raw node could overwrite the next extent. Such nodes now mark their extent damaged; a newer valid node can still replace it, and a file is left unrecovered only if a damaged extent survives into its final contents.
The DER reader accepted redundant length encodings (a long form under 128, or a leading zero length byte) without saying so. Each element now records whether its length is minimal; certificate, CMS, Authenticode and certificate-chain views keep everything they read and add one note that an element is not strict DER, and signatures over those bytes are checked as before.
Lossy decoding turned different malformed name values into the same replacement characters, and UniversalString values weren't decoded. Name values are now decoded by their string type (UTF-8; Printable, IA5, Visible and Numeric as ASCII; T61 as Latin-1; BMP and UniversalString as UTF-16 and UTF-32), and a value that is malformed or of another type is shown as its hex DER encoding.
Signature readers returned the decoded signature and silently accepted bytes after it. Complete method, field, local, TypeSpec and instantiation signatures now note when their blob carries extra bytes: the decoded types are kept, as the runtime uses them, and the inventory, member and native-boundary views say once that some signatures have trailing data that wasn't interpreted.
Godot reads --path as UTF-8, and the path was passed through a lossy conversion, so a project folder whose name isn't valid UTF-8 could open a different project with a similar name. Such a project now isn't launched instead.
Resource configurations that differed only in grammatical gender, round screens, wide colour gamut, HDR, or keyboard and navigation visibility got the same qualifier string, and MNC 00 was shown as 65535. Those qualifiers are now named as Android names them.
The contract dispatcher patterns accepted instructions a few positions apart, so unrelated code could be read as selector extraction, a Vyper selector comparison or a short-calldata check. Each pattern now needs its exact instruction sequence and operands, and a dispatch to something that isn't a JUMPDEST reports its mutability as unknown.
ZIP entries made on macOS (host 19) now keep their Unix mode, so their directories and symlinks are recognised, and VFAT entries (host 14) are recognised as directories by their DOS attribute, as MS-DOS and NTFS entries already were.
Searches for where a class is used missed lambdas, method handles, method types, class literals and dynamic constants. ldc and invokedynamic now link through the class's BootstrapMethods table to the method handle and static arguments they use, reported at the instruction that loads or calls them, within a shared work limit.
SVCB and HTTPS answers (priority, target, ALPN, port and address hints; unknown keys kept as hex), NAPTR, DNAME, SSHFP, TLSA and URI records now show their values instead of a byte count. A record that doesn't decode marks its message incomplete, keeping the answers before it, as other records do.
A bound import's module or forwarder name was read up to 256 bytes from its offset, even past the end of the directory. A name now has to end inside the directory, or it's reported as outside it, as the other bound-import checks are.
A note sent during a build waits in the inbox for the builder's next step; if the app closed before the builder took it, the next run deleted it as it started (#1620). The note's file now also keeps the person's own words, how the feed shows them and the pictures, and a run started without a message sends what an earlier run left waiting, oldest first, before the folder is cleared, as the app already does with notes a finished run didn't get to.
unquote_prefix read the digits of \x, \u and \U escapes with from_str_radix, which accepts a leading '+', so a malformed escape like \x+a was read as a newline. The digits must now all be hex, so such a string doesn't parse; a test covers all three escapes.
The XZ decoder expected the file to end right after one stream's footer, so valid .xz files with several streams or the standard four-byte padding were refused. It now finds each stream's bounds from the end, through its checksummed footer and index, and decodes them in order under one output budget; index integers, declared sizes and padding alignment are checked, and every read of the input is bounds-checked. SquashFS blocks keep the single-stream decoder, as before.
PF_A2B10G10R10 and PF_FloatR11G11B10 textures couldn't be exported. The shared pixel decoder now reads both: 10-bit red, green and blue with two-bit alpha, and unsigned 11/11/10-bit floats shown as sRGB like the other float formats.
Unity's EAC_R, EAC_R_SIGNED, EAC_RG and EAC_RG_SIGNED textures were recognised but couldn't be exported. The shared pixel decoder now reads EAC's 11-bit channel blocks (modifier tables, column-major selectors and the zero-multiplier rule), showing one channel as grey and two as red and green, with signed values mapped so zero is mid-grey.
A rank-one general ARRAY signature was shown like a vector (int[]), and declared sizes and signed lower bounds were dropped, so different managed types looked the same. Type names now keep the general-array form (int[*] at rank one), each dimension, and explicit bounds (int[0...2], int[-1...]), in method, field, local, generic and nested-array names.
A repeated metadata key could overwrite the reported model identity, and a repeated tensor name could inflate the parameter total; display truncation and retention caps could hide the repeat. The reader now tracks complete keys and tensor names and reports a file that repeats one as malformed, as the format's own loader does.
The cramfs reader gave up on any file with a direct block pointer. It now follows them: the shifted start address, uncompressed blocks of the expected size, and compressed blocks prefixed by their two-byte length, in both byte orders, with ordinary blocks after a direct one starting where it ended. Bounds and output limits are as before.
The Status section called the workflow Study → Build → Check → Refine while the rest of the README and the app name the last step Ready; it now says Ready too.
The ext reader took every symlink shorter than 60 bytes as stored inline, so a short target kept in a data block was read from the block-pointer bytes and came out wrong. It now tells inline targets from block-backed ones by the inode's allocated blocks, allowing for extended attributes, ext4 allocation units and large block counts; inline-data symlinks are reported as not read, and a target whose data can't be read stays unknown, with its declared length kept.
Signed branch and switch displacements were cast back to unsigned offsets even when the destination lay before the method or past its last byte, so invalid targets reached control-flow analysis. Short branches, long branches and every switch destination are now checked against the body; an invalid one stops decoding before that instruction with a reported issue, keeping the instructions decoded before it.
The question prompt described a file changed a day ago as "1 days ago". It now says "yesterday" for ages from 24 up to 48 hours, as the app's own age labels do, and a test checks both edges.
Normal, delay-load and bound import readers now stop at the end of the file bytes their directory maps to, require complete descriptor and forwarder records, and mark the table truncated with a warning when they don't get them. A normal import table that runs past its declared Size, or has Size 0, is still read to its terminator, as Windows does, with a warning. Names and forwarders outside the bound import directory are reported instead of read from beyond it. The resource reader shares the same mapping-length helper, unchanged.
parse_address handed the digits after 0x (or before a trailing h) to from_str_radix, which accepts a leading sign, so 0x+10 and +10h read as 0x10. Hex addresses must now be non-empty hex digits, and anything else gets the usual "not an address" error. The address test covers 0x+10, +10h and 0x-10.
The cpio reader parsed header numbers with from_str_radix, which accepts a leading '+', so a malformed field such as "+000000A" read as a valid number. Hex and octal fields now must be all digits of their base, or they read as unreadable fields like any other malformed one. A test covers both kinds.
A number option parsed with f64, which accepts NaN, inf and infinity; JSON can't hold those, so the value silently became null. The CLI now refuses non-finite numbers with its usual "expects a number" error, and a test covers NaN, inf, -inf and infinity.
`core_evidence_exports_compare` indexes each operation/subject by a single record. Normal exports can contain several observations of that subject, including different text pages or successive versions of the same address annotation. Later index insertions silently overwrite earlier observations, so additions and removals disappear, changing record order changes the comparison, and one intact page can hide a tampered page from the changed count.
The AArch64 address tracker kept an old value after an addition with an unknown register, read unknown memory indices as zero, could keep a stale base after a load with writeback or a stale link register after a call, and did W-register additions in 64 bits, so stale values could name a later indirect call as an import its instructions didn't establish. Address facts are now kept only when the operands prove them: unknown addends and indices clear the result, W additions wrap at 32 bits, every register an instruction writes is forgotten before new facts are recorded, and calls clear the link register too.
The application graph recognizes a worker entry point but then follows its spawn edge while assigning the parent's role. Worker modules, their ordinary dependencies and their endpoint evidence consequently appear as `main`, `page` or `package`. The later worker-role pass cannot correct a role that was already assigned. Use the existing worker/service-worker/utility-process edge classification to stop parent-role traversal at execution-context boundaries. Worker roots still receive their own role and propagate it through ordinary imports. Spawn edges remain in the graph, and a module also directly imported by the parent retains the existing role precedence.
A package with 52 reachable modules loses the final module's role when each hop repeats the same `require()` 2,000 times. The graph resolves those imports, but role propagation charges its 100,000-step limit for duplicate queue entries, eventually leaving reachable modules as `unknown`. Mark modules in the existing role map before enqueueing them. Repeated imports, cycles and shared dependencies then use one queue entry per newly discovered module. The limit remains 100,000 newly discovered modules per assignment, and the existing main/preload/renderer/page/worker precedence stays intact. Inline scripts continue to inherit their page's role.
The token scanner ended `//` comments only at LF. A bare CR, U+2028 or U+2029 therefore hid following executable code inside the comment. That dropped imports, IPC and fetch facts in lexer fallback and prevented the parser admission check from seeing excessive nesting after the comment. Recognize every JavaScript line terminator when scanning line comments, skip Unicode terminators before charging the token budget, and stop identifiers at those boundaries. Strings, templates and block comments keep their existing handling.
A module keyed by `0x10` and a loader call written as `16` produced different identities. Numeric separators and exponent notation caused the same problem, including dangling `requires` targets in the application graph. Different spellings of one numeric dependency could also occupy separate list entries. Use the existing syntax library's JavaScript number conversion for numeric module keys, loader arguments, browserify mappings and chunk IDs. Explicitly enable its already-present `to_js_string` feature. String identifiers retain their literal spelling, including strings such as `"0x10"` that identify a different property from numeric `0x10`.
A text-read page that reached the last line of a file but cut a line at the 256 KiB limit reported cut_lines correctly, yet its coverage said complete because it was worked out from the line count alone. Coverage is now partial whenever a line on the page was cut.
Function studies identify their source bytes, but `app_call_path_find` currently joins their addresses without checking that source identity. Two different binaries can therefore contribute different edges at the same addresses and produce a call path that exists in neither binary. The regression uses two real ELF targets: one has main → helper, the other has helper → dispatch, and neither contains the complete main → dispatch path. Both inline records and saved evidence references reproduce the false path.
With FEAT_PAuth_LR and PSTATE.PACM set, RETAA and RETAB use x16 as an extra modifier. The decoder knows neither the CPU's features nor PSTATE, so authenticated returns now also record a possible read of x16, beside their link register and stack pointer, and value flow keeps that input.
The input loaders trust an earlier file-size report before reading to EOF. A regular virtual file can report zero bytes and still return data beyond the configured limit, and files can grow between the size check and read. Some loaders accept devices or pipes, allowing a text or evidence-bundle request to wait indefinitely for a writer. Prefix reads also use metadata size to decide whether to assign a whole-file hash, so a truncated prefix of a zero-size-reporting file is misidentified as the whole input.
A native function can branch to a body block placed before its entry address. The control-flow graph already included that block, but reference and string scans only looked from the entry onward, and parameter inference took the lowest-address block as the entry, so a register set by the real entry could become a false parameter while the real input disappeared. Reference scans now cover the address range of all of the function's body blocks, and parameters are read from the block at the function's actual entry.
A modern .pyc header's flag word defines only its two low bits, and other bits were read without comment. Undefined bits are now reported as a header warning, while the invalidation mode, source fields and code are read from the defined bits as before, so a file from a future Python release that adds a flag stays readable. Legacy headers, which have a timestamp in that position, are unaffected.
The AArch64 decoder drops XZR and WZR from the register list, so for an ordinary arithmetic instruction whose result is discarded, the first remaining source register was marked as written. That false write broke reaching definitions and could erase a proven import-slot base before a later load and call. The discarded-destination rule, which covered only flag-setting instructions, now applies to ordinary arithmetic too, so those registers stay inputs.
entropy() returned -0.0 for constant or zero-filled input, because summing the single symbol's term gives a negative zero, which shows as "-0.00". Adding 0.0 before the conversion turns it into +0.0 and leaves every other value unchanged. A test covers constant and zero-filled data.
Ordinary AArch64 returns treated the selected target register as a destination and unconditionally read `x30`, even for `ret x19`. Authenticated branches and calls had correct control-flow categories but fell through the generic operand-write rule, which overwrote their target's reaching definition. Authenticated returns also omitted their stack-pointer input.
A webpack wrapper can have a loader parameter named `r` while a nested function uses its own unrelated parameter with the same spelling. The dependency visitor treated both calls as module loads, adding false `requires` edges to the application graph. Resolve loader calls against the wrapper parameter's semantic binding. This retains closures that capture the real loader, distinguishes function/arrow parameters, block and catch bindings, and avoids treating the placeholder for a destructured parameter as an actual loader name. First-seen ordering and dependency deduplication stay intact.
core byte search ran its hex, UTF-8 and UTF-16LE queries in turn against one shared 100,000-match allowance, so a stream of later hex matches could use it up before an earlier text match was considered, and sorting afterwards couldn't bring that match back. Each query now keeps up to the cap, the results are merged in file-offset order and cut to the cap, and the result says when the cap was reached.