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.
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.
Null, cyclic and reused b-tree children were skipped while row counts and row pages still read as complete, so a readable sibling could look like the whole table. Such skips, along with missing pages, wrong page kinds, skipped rows and walk limits, now mark a count as a lower bound and a row page as incomplete, while the readable rows are kept.
ZIP, tar and cpio readers can stop their member listings early, but firmware extraction ignored their truncation flags, so directory entries could use up the member limit and later files were left out while the result reported complete coverage. A cut-short member listing, in any region or nested archive, now marks the extraction truncated with a limitation saying what to raise or inspect.
A ZIP stored inside a firmware ZIP member could supply the first plausible end record, so the scanner cut the outer archive short at the inner one: extraction left out outer members and wrote the inner contents at the wrong path. Each end record and central directory is now matched to the archive whose extent it describes, so a nested ZIP stays a member of the outer one and its siblings are all extracted.
Firmware extraction decoded ZIP members into a queue before charging their output bytes, so each member got the same remaining budget and a small compressed archive could hold many times the output limit; a member that hit the decode limit also left the truncation flag unset. Paths and the remaining file and byte limits are now checked before a member is decoded, each member is decoded only up to what's left, and a member stopped by the limit marks the extraction truncated.
Filesystem recovery already owns each extracted file's bytes, but firmware extraction copied them into its output queue and kept the originals, so a large recovered file took two full copies in memory before it was written. The recovered buffers are now moved into the queue. Path checks, byte and file limits, nested scans and the report are unchanged.
A truncated asset catalog tree or node header could give no entries and no warning, and apple_assets_list then reported a complete empty listing; other interrupted tree walks kept what they read but called the result complete. Tree completeness is now tracked through the headers, child and leaf links, missing blocks and walk limits. Readable entries are kept, and an incomplete tree marks coverage partial, sets tree_incomplete and says so in the summary. Legal empty trees still read as complete.
apple_archive_decode built every object row before paging and copied a shared class name once per object while counting classes, so a 97 KB archive with 1,024 objects sharing one 64 KiB class name held 64 MiB of class text even when one row was asked for. Only the requested rows are built now, and class names are borrowed from their shared class object while the class counts are taken. Totals, order, offsets, limits and the output shape are unchanged.
The Python bytecode reader shortened long constants and names to its per-string limit and marked them with an ellipsis, but still reported the code inventory as complete, and the ellipsis it added wasn't counted against the overall text budget. A shortened constant, name, file name or qualified name now marks the inventory cut short, the budget counts the marker, and shortened text still ends on a whole character.
The value-flow graph decoded every instruction of every block and only then applied its node limit, so a huge function did all that work before most of it was thrown away. The node budget is now spent as nodes are made: parameters first, then instructions, and decoding stops once it runs out. Blocks that weren't decoded in full are tracked so their edges and definitions aren't treated as complete, and the graph is marked truncated.
The safetensors reader kept the last value for a repeated JSON key, so two tensors with the same name, or a repeated dtype, shape, offset or metadata field, produced a complete-looking report while earlier entries were silently lost. The header is now read through a duplicate-checking JSON reader, and a header with a repeated key in any object is refused as malformed, as the safetensors format requires distinct keys.
AArch64 exclusive stores treated their status result as an input and never defined it, exclusive pair loads defined only their first result, and acquire-exclusive single loads were unknown operations. The value-flow graph lost the status edge into a retry loop's condition and the second loaded value, and pseudo-C could show an exclusive store as an assignment from its status register, or drop an exclusive load from a known import slot. Exclusive stores now write their status (unless it's discarded to WZR) and read their values, exclusive and acquire-exclusive loads are loads, pair forms define both results, and pseudo-C keeps them as memory operations.
app_builds_line_up paired only 1,448 of about 36,000 functions across two Rust toolchains, because every v0 crate hash changed, so exact names rarely matched. A new name_without_hash stage, after exact names, pairs Rust names (legacy and v0) that are equal once demangled without the compiler's hashes, and keeps the instantiating crate so each crate's copy of a generic impl stays separate. Called names are compared the same way, so the structure fingerprint survives a toolchain change, and a pair whose names differ only by hash isn't counted as renamed. On the same two cargo builds this pairs 14,036 functions (13,356 by name), with masked-bytes pairs down from 888 to 233. The crate lookup reads only the end of a name, so a long crafted symbol can't make it slow.
A long follow-up pasted into the prompt box during a build made its waiting note taller than the window: the note was drawn outside the conversation's scroll area, so it pushed the prompt box off screen and left no room for the live activity. Waiting notes now sit inside the conversation's scroll area, above the live activity, with their Take back and Send now controls scrolling with them. Up arrow still brings back the last waiting note. A smoke test checks a 160-line note in a 600-point window.
An MZ header with zero pages, a last-page size above 512, a header shorter than its fixed fields or a header larger than the declared image was read into clamped sizes with nothing said. Each of these is now reported as a problem, so the DOS tool marks the file inconsistent and the binary listing warns, while the entry point, relocations and load module still read. Full pages written with a last-page size of 0 or 512 stay clean.
A source map segment could point past the end of the sources or names arrays, as ACAA does with one declared source, and the index was kept. Such mappings are now refused as bad mappings. An explicitly unknown source (null) is still accepted.
A ROMFS name exactly as long as the name limit stopped the directory walk, because the scan for its terminator didn't look one byte past the limit: with max_name = 12, readme12.txt was refused. The scan now includes the terminator's byte, and a name one byte longer is still refused.
A Swift symbol ending in WZ is a stored variable's one-time initialization function, and one ending in Wz its one-time initialization token. The demangler reported both as "unsupported witness kind", including merged forms such as WZTm. They now read as swift-demangle prints them: the kind and the variable's name, with the surrounding module, type or extension left out and a private variable keeping its discriminator.
The UnityFS directory reader checked that compressed blocks fit the file but returned member offsets and sizes without checking the uncompressed stream they point into, so a member could lie past all data, overflow, or claim bytes in an empty stream. Block sizes are now summed with checked arithmetic, and a member whose range doesn't fit the stream is marked as unreadable. It keeps its directory entry, but its contents aren't read. Listings say how many such members there are, mark coverage partial and count objects as "at least", and the other members stay readable. An overflowing total of block sizes still makes the table unreadable.
The cramfs reader read the uncompressed-block flag (bit 31) as part of a block's end offset, so valid files and symlinks with blocks stored uncompressed were reported as corrupt. The flag is now separated from the end pointer, in either byte order, before the span is checked, and an uncompressed block is taken as is when its length matches the full or final partial block. Compressed runs, zero-filled holes and the size budgets are unchanged, and direct-pointer blocks are reported as unsupported.
Tv with an optional index is an outlined variable, the compiler's copy of a value named after the symbol before it (Tv_ is #0, Tv0_ is #1). The demangler reported every one as "unsupported thunk or specialization". They now read as swift-demangle prints them, "outlined variable #N of" a function, type, protocol witness or other global. A bare name, a module, an outlined variable of an outlined variable, or an index of 2^31 or more is still refused.
The .NET signature reader called a type volatile when any of its first eight custom modifiers contained IsVolatile, so optional modifiers, a Custom.IsVolatile type and IsVolatileExtra all counted, and a real required marker after eight other modifiers was missed. A type is now volatile only when a required modifier is exactly System.Runtime.CompilerServices.IsVolatile, checked across every modifier.
A Swift function type can carry markers after its parameters and result, and the demangler read only Ya (async): Yb (@Sendable), Yc (a global actor such as @Swift.MainActor), YA (@isolated(any)) and YK (typed throws) were reported invalid, the first failure for 19,217 symbols in macOS and Xcode system binaries, mostly closures and functions that take a @Sendable or @MainActor closure. Function types now keep these attributes and print them as swift-demangle does, with typed throws as throws(E).
A Swift symbol ending in TK is a key path's getter and Tk its setter, with the property or subscript the path reads under the type it starts from. The demangler reported them as "unsupported thunk or specialization". They now read as swift-demangle prints them: key path getter (or setter) for the property with its type, then the base type. A global, module or bare name in either place is still refused.
Three Swift metadata kinds read with the wrong phrase: MN said "type metadata for" where swift-demangle prints "noncanonical specialized generic type metadata for", Mj said "module descriptor" for what is an "opaque type descriptor accessor key for" a type, and Mz said "type metadata heap reference for" for the "flag for loading of canonical specialized generic type metadata for". They now read as swift-demangle prints them.
A small metadata or object read from a Unity bundle read and copied every block it touched in full, stored blocks included, so a valid stored block over the 512 MiB read limit made ordinary bundle and object listing fail even for a 496-byte member, and smaller stored blocks allocated bytes nobody asked for. For a stored block the reader now checks that its stored and uncompressed sizes agree and reads just the requested part from the file. Compressed blocks keep the existing decompress-and-cache path, and the 256 MiB per-request limit stays.
The tar reader handled per-member PAX extensions but ignored global ones, so later members could get the wrong path, link target or stored size, and a global size override left the next header at the wrong offset. Global path, link and size attributes are now kept until a later global record replaces or deletes them, applied after per-member PAX values and before GNU long names or the plain header. Each metadata header is read at its own stored length, inherited sizes must be unsigned decimals, and inherited sparse attributes are reported as unsupported. Copies of inherited names share a 64 MiB budget; engine installs refuse an archive that exceeds it before writing anything.
The firmware scanner recognised both cramfs byte orders, but the filesystem reader refused big-endian images before reading anything; their inodes also pack the size, name length and offset into different bit positions, so the magic alone wasn't enough. The byte order is now taken from the magic and used for inode modes, sizes, the name-length and offset bitfields (size in the upper 24 bits, name length in the upper 6, offset in the lower 26) and the compressed-block pointers. Directory traversal keeps the same span checks and recovery budgets.
PYZ name limits applied to the names stored in its table, but each nested entry also repeats the surrounding CArchive member path, so a short table under a long shared prefix could hold far more path text than its size suggests: a valid 5 MB archive made with PyInstaller 6.16 kept 146 MB of paths for 40,001 entries. Expanded module, package, resource and unknown-member paths, and namespace-package names, now share an 8 MiB budget per listing, across all nested PYZ members and in standalone PYZ listings. Each complete path is checked before it's built; when the budget runs out, the entries read so far are kept and the listing is marked truncated.
Code taken out of a PyInstaller PYZ archive was always given a 16-byte .pyc header, although Python 2.5 to 3.2 use 8 bytes and 3.3 to 3.6 use 12, so older code had extra zeros between the header and the marshalled code and couldn't be read at its own header boundary. The output limit reserved 16 bytes too, refusing an exact limit for 2.7 or 3.6 code. Wrapping, header parsing and the PYZ output limit now share one header-size lookup from the release table, and unknown magic numbers keep the 16-byte form. Tests cover standalone and nested PYZ archives, modules and packages, and exact limits.
ASAR entry and depth limits didn't bound the combined size of expanded paths: a compact directory tree could repeat one long parent prefix across thousands of short names, and a valid 1.5 MB archive kept 145 MB of path text. Expanded entry paths and rejected names now share an 8 MiB budget, checked before each path is built; when it runs out, the entries read so far are kept and the listing is marked truncated. core_archive_extract used to ignore a truncated listing and call the extraction complete; for ASAR and ZIP it now extracts what was listed, adds a limitation that the listing was cut short, and marks coverage partial with no claimed total. The JavaScript app analysis carries the same flag.
The Swift compiler writes outlined value operations (a copy, move, destroy or enum tag operation for one type) as the type followed by WO and a letter. The demangler read WO as an unsupported witness kind, so these were invalid: 28,456 symbols in macOS and Xcode system binaries, 28,391 of which now decode. Each letter reads as swift-demangle prints it, such as outlined destroy of T, including the indexed enum operations and merged ones.
A Swift function, variable or subscript that returns some P writes that result as Qr (a later opaque type in a tuple is QR with an index), and elsewhere the same opaque type is named by its declaration with QO, generic arguments and Qo. The demangler knew only Qz and Qy, so all of these were invalid ("unsupported associated type"), the first reason for 29,707 symbols in macOS and Xcode system binaries. They now read as swift-demangle prints them.
PE import descriptors and export aliases can point at the same strings again and again, and the row limits didn't bound the text kept: a 526 KB import fixture and a 1.2 MB export fixture each ran out of memory under a 128 MiB limit, and export indexing decoded every name before deciding which rows fit. Retained names (library names, import names, export aliases and forwarders) now draw on a 64 MiB budget, one shared by the normal, delay-load and bound import directories and one for exports. Export names are decoded only for rows that are kept. When the budget runs out, the rows read so far and the declared export count are kept, and the table is marked truncated with a warning.
A JAR manifest may describe one file in several sections, whose attributes merge with later values replacing earlier ones. The integrity check verified each section on its own, so a valid signed manifest could report the same file as both matching and mismatching, and the ZIP entry was read more than once. Digest attributes are now merged by exact entry path before checking: a later section replaces only the attributes it has, the existing digest preference applies, and each file is checked and counted once. Attribute names still match case-insensitively and file paths case-sensitively.
Certificate verification treated every RSASSA-PSS algorithm identifier as SHA-256 with a digest-sized salt, and CMS verification took its hash from the separate digest field, so a signature could verify despite conflicting hashes, salt lengths or key restrictions, while genuine SHA-384 signatures and other valid salt lengths were refused. The complete PSS parameters are now read (hash, MGF1 hash, salt length and trailer field) with the RFC 4055 defaults, and incomplete, repeated, out-of-order or unsupported parameters are refused with a reason. Verification uses the declared parameters, checks them against an RSA-PSS key's restrictions, and requires a certificate's signed and outer parameters to agree.
A Swift symbol ending in WL is the cache variable of a lazy protocol witness table and names a type and the conformance it's used with, like the lazy accessor Wl. The demangler took one operand for it and reported these symbols invalid ("N nodes left after decoding"). They now read as swift-demangle prints them: lazy protocol witness table cache variable for type T and conformance C. Wl and WL share one reader.
The Mach-O reader walks both the ordinary and the non-lazy Objective-C registration lists, and the compiler puts non-lazy classes and categories in both, so they appeared twice with their methods repeated. Each class and category is now listed once by its decoded address, in first-seen order. Two different definitions with the same name stay separate.
A cramfs hole has no compressed bytes: its end pointer repeats the previous block boundary. The reader handed that empty span to the zlib decoder and lost an otherwise valid file, which affected all-zero files, holes between data blocks and zero-filled tails. A block whose end equals its start now reads as zeros, sized to the rest of the file for the last block, within the existing per-file and total size budgets. Backward and out-of-image pointers are still corrupt, and compressed blocks must still decode to their exact length.
Node.js 25.7 writes a module-format byte after the exec-argument extension in a single-executable-application blob header. The reader knew only the three older layouts, so new CommonJS and ESM blobs both failed with "no known Node blob layout accounts for every byte", although their script paths, code, assets and arguments were all there, one byte further on. The new layout is now read, with its two defined values (CommonJS and module), and the listing reports module_format (null for older layouts, which don't store it). Complete-layout checks and the refusal of ambiguous blobs are unchanged. Tests use blobs made with the official Node.js 25.7 binary from small original scripts.
Unity textures in format 34 (ETC_RGB4) were unsupported, so a readable asset whose first mip used ETC1 couldn't produce a picture. A new ETC1 decoder reads the 4x4 RGB blocks, covering individual and differential base colours, both subblock orientations, every modifier table and ETC1's column-major selector bits, and format 34 now uses it. First-mip sizing, the output pixel limit and edge cropping apply as for the other block formats. Truncated blocks and invalid differential colours are refused.
The Swift demangler limited the nodes it copied out of its substitution table, but saving a new substitution cloned the whole tree without charging that budget, so nested nominal and optional types in a small symbol could keep many overlapping trees; reusing a substitution also cloned it before checking the repeat count and budget. Saving a substitution now spends the node budget before cloning, and a reuse borrows the stored tree, checks the count and cost, then copies only what's needed. Ordinary nested types and repeated references still decode, and an oversized expansion is reported invalid with "symbol expands too much".
After the WebAssembly reader began leaving out derived metadata once its byte budget is spent, formats_wasm_module_show still said lists stop at 100,000 entries even when the byte budget ran out much earlier, and its summary view left out the reader's truncated flag. The limitation now says lists or derived metadata are incomplete and points to the warnings for which limit was reached, and the summary view includes truncated as the complete view already did.
Unity RG32, RGB48 and RGBA64 textures (formats 72–74), with two, three or four unsigned 16-bit channels, showed as unknown formats and couldn't be previewed or exported. They're now decoded to RGBA8 with the same rounding as R16: missing blue is zero, missing alpha opaque, and Unity's row order and first-mip limits apply. Tests cover the byte widths, channel order, rounding boundaries, alpha, short pixel data and serialized Texture2D fixtures for all three.
CLI signatures accepted a TypeSpec handle after CLASS or VALUETYPE, including as the base of a generic instantiation, which made up types such as Container<int, string><int> and could expand a recursive signature again and again. Those positions now take only TypeDef or TypeRef handles, as ECMA-335 requires. TypeSpec handles are still read for standalone type names and custom modifiers, where they're allowed.
The CMS reader took the first value of each signed attribute without checking its type or count, let a repeated required attribute overwrite the first, never compared contentType with the encapsulated content, and accepted the readable start of a malformed attribute list, so a genuine signature over such attributes could report authenticated for Mach-O CMS and a valid detached JAR signature. Signed attributes now need a complete list with exactly one messageDigest OCTET STRING and one contentType OID that matches the encapsulated type. When they don't, the signature stays readable, with its certificates, signer and algorithms, and is reported as not authenticated with the reason. Unknown well-formed attributes are kept.