The PE version reader found the VS_FIXEDFILEINFO signature in the surrounding resource and then read the version fields without checking that the whole fixed record sat inside the node's declared value, so bytes from a neighbouring child, or from past the node, could supply a file or product version the node didn't contain. The fixed record is now read only from the node's declared binary value, which must be binary, hold all 52 bytes and end inside the node. Version strings in StringFileInfo are still read when no valid fixed record exists.
A Go function table can reuse one name offset for many records, and the function and per-name limits still let a small table hold hundreds of megabytes of names: 100,000 references to one 4 KB name in a real ELF ran out of memory under a 128 MiB limit. Kept function names now draw on a byte budget (64 MiB, or three times the table's extent if larger) in every table layout. When it runs out, the functions read so far keep their exact addresses, the list is marked truncated with a warning naming the limit, and the declared count is kept. Repeated names that fit stay complete.
In a Swift symbol, Sc and one more letter is a short spelling of a concurrency type, as Si is Swift.Int: ScT is Task, ScG is TaskGroup, ScA is the Actor protocol, and so on. The demangler read Sc and stopped, so every symbol that contained one was invalid ("concurrency standard types are not supported"). Each now reads in module Swift as swift-demangle prints it, for example Swift.Task<(), Swift.Never>, and a letter with no type is still refused.
A Swift function named by an operator (==, +, a prefix -, a postfix ...) is mangled as its name, then o and a fixity letter, with each operator character written as a letter. The demangler stopped at the o ("unsupported operator 'o'"), so every operator function, and every witness, thunk and descriptor built around one, read as invalid: 34,816 of 2.36 million symbols in macOS and Xcode system binaries, 28,898 of which now decode. Operators now read as swift-demangle prints them, such as static Swift.Int.% infix(Swift.Int, Swift.Int) -> Swift.Int.
Android resource packages with a nonzero typeIdOffset published the unshifted type byte, so a package with offset 3 and local string type 1 reported 0x7f010000 instead of 0x7f040000, and packages sharing a package ID could seem to define the same resources. The offset is now read from package headers of 288 bytes or more and added, checked, to public type and resource IDs, while type names are still looked up by the local ID. Legacy 284-byte headers keep an offset of zero. An oversized offset, or a shifted type outside the one-byte field, marks the result partial with a warning and leaves valid sibling types readable.
DEX disassembly copied array and switch payloads into every instruction that referred to them, and the instruction cap didn't bound those copies: a 77 KB input with 2,048 references to one 64 KiB array ran out of memory under a 128 MiB limit. A shared payload budget (64 MiB by default, decode_with_payload_limit to choose one) now pays for each payload and each attached copy before it is made. A payload that doesn't fit is left off its instruction, whose offset, name and width stay, and the listing is marked incomplete. The payload lookup no longer clones payloads, and android_method_show says a listing can be partial because of instruction or payload limits.
The Java class reader copied every attribute's name out of the constant pool, so thousands of attributes pointing at one long name made a class file under 100 KB allocate over 250 MB. Attribute names are now borrowed from the pool for the parse, as attribute bodies already borrow their bytes. Parsed structures and the handling of unknown attributes are unchanged.
Four kinds of Swift symbol end in W and a letter (Wl, Wb, WT, WI), each a function that finds or builds a protocol witness table. The demangler read the W but not the letter and reported every one invalid ("unsupported witness kind"). They now read as swift-demangle prints them: lazy protocol witness table accessors, base witness table accessors, associated type witness table accessors and instantiation functions for generic protocol witness tables. Operands that aren't the expected type, protocol or module are refused.
In a Swift mangling, X and a kind letter write a type with no letter of its own; the commonest is XE, a non-escaping function type. The demangler stopped at every X with "unsupported special type", so any symbol that mentioned such a type was invalid: 55,696 of 2.36 million symbols in macOS and Xcode system binaries. These special types now read as swift-demangle prints them, including non-escaping closures and AnyObject.
When no certificate matched a CMS signer's issuer and serial, the signer was taken to be the first certificate, so a valid signature could be credited to a certificate the SignerInfo never named; version-3 signers identified by subject key identifier also fell back that way. Both identifier forms of RFC 5652 are now matched: issuer and serial, or a complete, unambiguous Subject Key Identifier extension. When nothing matches, the signer stays unknown and no chain is built from an arbitrary certificate. A version that doesn't fit the identifier form, or an empty serial, is noted in the report while the signature's certificates and algorithms stay readable.
Reading a page of rows deep in a SQLite table kept every decoded row before the offset, even when one row was asked for, and a zero-sized first page fell into the walk's unlimited mode. A 67 MB database with 16,384 rows of 4,000-byte text ran out of memory under a 128 MiB limit reading its last row. Rows before the offset are now counted and dropped as they're read, the walk stops once the requested range is consumed, and a zero-sized page reads no cells. Offsets, unreadable-cell notes, rowid aliases, added-column defaults, key order and WITHOUT ROWID handling are unchanged.
The YAML reader looked only at the first document while edits could land anywhere in the file, so a coding agent's config with several documents was edited or diagnosed against an incomplete view. A config with more than one document is now refused, with a plain message, before an edit is planned or an entry removed. A single document with explicit start and end markers is still accepted.
The EVM metadata decoder overwrote repeated CBOR map keys and turned non-text keys into JSON strings, so conflicting compiler entries or colliding key types could produce misleading metadata while the whole trailer was cut out of the bytecode analysis. A map key must now be an encoded text string and appear once, in nested maps too. A trailer that breaks either rule is no longer read as metadata and stays in the analysed bytecode. Ordinary compiler metadata reads as before.
Swift async functions add three thunk operators: Tu, the async function pointer, and TY and TQ with an index, the suspend and await resume partial functions. The demangler reported every one invalid ("unsupported thunk or specialization"). They now read as swift-demangle prints them: "async function pointer to" the function, and "(N) suspend resume partial function for" or "(N) await resume partial function for" it.
APK signer verification accepted the unsigned SDK range without comparing it with its signed copy, chose a signature without checking that the ordered algorithm list matched the signed digest list, and accepted a readable prefix of incomplete signer fields, so each of these could still report verified with a genuine signature. A signer now verifies only when its required fields are complete, the signature and digest algorithm lists match in order, and the v3/v3.1 SDK ranges match their signed copies. A signer that fails these checks is still listed, with a note saying why it isn't verified. The separate signature, content-digest and public-key results are unchanged.
In Settings → AI the "Found on this computer" caption, the Providers and Harnesses tabs and the Detect button shared one row, with Detect pinned to the right, so at narrower widths it covered the Harnesses tab (#1519). The caption now sits on its own line, and the tabs and Detect share one spacing and wrap together. A smoke test checks both modes, empty and populated lists, and widths of 760, 900 and 1280 points, and that the Harnesses tab can still be chosen.
A //# sourceMappingURL= line comment ending in */ lost those characters, so https://example.test/maps/*/ was read as https://example.test/maps/. Only a block annotation (/*# sourceMappingURL= … */) has its closing */ removed now, once. A test covers both line-comment prefixes and an ordinary block annotation.
The Dart snapshot string scanner capped what it returned but kept every unique URI and identifier it dropped in its de-duplication sets, so a caller asking for one result could hold millions of strings while scanning a snapshot. Only values actually kept are now tracked, as slices of the input, and each limit is checked before a new value is added. The scan still runs to the end and reports that values were left out. First-seen order, the separate URI and token limits, duplicate handling and the scanned-byte count are unchanged.
The metadata entry limit didn't bound the text that references produce: a valid 401 KB module with one 1,000-parameter type and 100,000 functions kept 500 MB of repeated signatures, and re-exporting one long function name copied it into every export. Each referenced type signature is now formatted once and cached, and the cache and every kept copy of a signature or name draw on one budget (64 MiB, or three times the input if larger) that is checked before copying. Metadata left out marks the report truncated with a warning. Function and tag index counting carries on past the display limit, so leaving rows out can't shift later indices or report a false declaration-body mismatch.
Each candidate selector comparison in an EVM dispatcher formatted a new string and searched every function found so far, so a dispatcher that repeated its comparisons could multiply the work without reaching the 4,096-selector cap. Selectors seen are now kept in an ordered set and checked before formatting. First-seen order, the original destination, the eligibility rules and the cap are unchanged. The same selector pushed at different widths counts once, and rejected candidates don't reserve one.
Choosing the same coding agent twice in one setup, for example by claude_code and claude-code, planned two writes to one config file. The second write saw the first as an outside edit and rolled the installation back. Aliases are now resolved first, and each client is kept once, in the order chosen. A test applies the plan in a temporary home and checks that running it again changes nothing.
Recovered modules are named after their sanitized id, and a collision added eight characters of the content hash once. Three modules with the same id and body gave the second and third the same path, so extraction refused the third and left that module out; a later module's id could also equal an earlier generated name. Each generated name is now checked against the names already used: the first collision keeps its existing name, and any further one gets an occurrence suffix.
The binary XML reader marks a recovered or capped manifest as truncated, but android_package_show dropped that flag and called its evidence complete, counted by the APK's ZIP entries, even when the manifest was missing or unreadable. android_components_list also reported complete coverage on the last page of a recovered manifest. Package evidence is now complete only when the manifest read in full, and component pages of a truncated manifest stay partial, with no claimed total and next_offset kept for paging.
A short certificate cycle ran out of supplied certificates and was described as reaching the 16-link walk limit, and a cycle of exactly 16 certificates read the same way. The walker now looks at the next certificate at the boundary before deciding why it stopped: a repeated certificate reports a loop, and a new one beyond 16 verified links reports the walk limit. No 17th link is added or verified, and a root reached at link 16 still completes the chain.
The segment budget didn't count empty generated lines, so a small source map made of semicolons could exhaust memory without a single segment, and each inline section allocated again. A generated-line budget (1,000,000 by default, shared by all inline sections) now counts empty and final lines and refuses a map that goes over with TooManyLines. The line index is reserved fallibly and reports LineAllocationFailed when memory can't be had. Generated coordinates, the segment limit and external sections are unchanged.
Swift binaries carry compiler-generated metadata symbols ending in M and one of K, D, F, A, P, B, U, t or s. The demangler stopped at the second letter and reported all of them invalid ("unsupported metadata kind"), about 206,000 symbols across macOS and Xcode system binaries. Each now reads as swift-demangle prints it: metadata instantiation caches, demangling cache variables, reflection field, associated-type and builtin descriptors, generic metadata patterns, and Objective-C metadata update functions and resilient class stubs. An operand that isn't a type where one is required is still refused.
Connecting to a coding agent whose YAML config ends with a document-end marker (...) appended the new server table after it, so it became a second document. Reading the config back saw only the first, and setup failed and rolled back. A missing table now goes in before the document end, keeping comments and line endings. Tests cover LF and mixed CRLF, a comment on the end marker, repeated edits, removal, and a key that starts with ....
Unity RGB9e5Float textures (format 22) were reported as an unknown format and couldn't be exported. They're now decoded: three 9-bit mantissas share a 5-bit exponent, the linear RGB goes through the same display conversion as the other floating-point layouts, and alpha is opaque. Unity's row order, first-mip framing and output limits apply as before. Tests cover channel placement, exponent extremes, HDR clipping, short pixel data, oversized images and a serialized Texture2D.
Unminifying split a comma sequence into separate statements, so in function f(){"hello","use strict";return this;} the two strings became a directive prologue, turned on strict mode and changed what this is. A sequence that starts with a string literal now stays together, and ordinary call sequences still split. Tests cover function and script bodies.
The ROMFS, ext, SquashFS and JFFS2 walkers kept visited nodes in a list and searched all of it before each new node, so wide images spent quadratic time on cycle checks even within the entry limit. All four now use an ordered set, checking and inserting in one step. Traversal order, repeated-node and cycle detection, root handling, and the depth, byte and entry limits are unchanged. A 65,536-file ROMFS image read about 14 times faster in the author's measurement, and a new 4,096-file test checks order, bytes, limits and cycles.
HTML inspection returned a page title as written in the source, so <title>Fish & Chips</title> read "Fish & Chips". The title now goes through the existing character-reference decoder once before the 200-character limit. Unknown references stay as written, and the limit counts the decoded characters.
A project's capture/ can be left by a study in the other mode, and the run only checked that the folder existed, so a Clean room build could be handed a Deep capture, and a Deep run could skip its inside study by using a Clean room one. craft.json now records the mode the current capture was studied in (capture_deep, format version 5; a version-4 capture migrates as Deep, like a saved session), and a run studies again when its capture isn't from its mode. A study clears the record before it starts, so one that fails partway leaves nothing a later run trusts, and a Clean room study removes the files only a Deep study writes (how-it-works.md, page.html, runs/). The extractor's fresh-study decision and the run queue use the same check.
The certificate chain walker took the first certificate whose name matched the issuer, even when its key didn't verify the child, so a same-name decoy could hide the real issuer. Equal subject and issuer names were also taken as proof of a self-signed certificate, which stopped a key-rollover certificate from reaching its signer, and a cycle of valid signatures could report fully linked without ever reaching a root. The walker now tries same-name candidates until one's key verifies the child, calls a certificate self-signed only when its own key verifies it, and reports fully linked only once verified links reach a verified self-signed top. The 16-link bound stays, the issuer search covers the first 64 certificates, and a note says when either limit applied. Tests use real RSA and P-256 signatures with wrong-key decoys.
ECDSA verification picked P-256 or P-384 from the public key's point length and never read the curve the key declares, so a real P-256 signature verified even when the key said secp256k1, another curve or none at all. The verifier now reads the key's complete named-curve parameter and checks only a declared P-256 or P-384 key. Missing, malformed, duplicate or unsupported parameters are reported as not checked. Compressed and uncompressed points and the supported curve and digest pairs still work, as RFC 5480 describes.
Cooked Unreal textures in PF_DXT3 were recognised but couldn't be previewed or exported, because the shared pixel decoder had no DXT3 (BC2) layout. It now decodes 16-byte DXT3 blocks: each texel's explicit 4-bit alpha is widened to 8 bits, and the colour block always uses four-colour interpolation. Clipped edge blocks and the image size budget work as for the other block formats. Tests cover every alpha level, low-first endpoints, odd sizes, truncated blocks, output limits and a cooked Unreal package.
Certificate checks read the outer signatureAlgorithm but skipped the algorithm named inside the signed TBSCertificate. A certificate could declare SHA-1 inside, carry a valid SHA-256 signature outside, and still be reported as verified and fully linked. The verifier now reads the signed algorithm, in both the v1 and v3 field layouts, and refuses a certificate whose inner and outer algorithm OIDs differ or whose inner field is malformed, as RFC 5280 requires. RSA with NULL or absent parameters is accepted as before. Tests use real RSA signatures over the changed certificates.
Android string pools capped how many strings were read and how long each could be, but every offset was decoded into its own copy, so a 49 KB chunk pointing thousands of times at one long string kept 128 MiB in memory. Each pool now has a byte budget (64 MiB, or three times the chunk's declared size if larger). Decoding stops at the first string that doesn't fit and keeps what came before it. Binary XML and resource tables mark a capped global, type or key pool as partial and say how many strings were kept. Tests cover shared offsets in UTF-8 and UTF-16, bytes appended after the chunk, small pools and the warnings.
SQLite row and count walks kept visited pages in a list and searched it for every new page, so wide databases spent quadratic time on the check. Both walks now use an ordered set, checking and inserting in one step, with the same traversal order, cycle and repeated-child handling, and page, depth and row budgets. Tests add a 1,023-row multi-level WITHOUT ROWID table and repeated-child and cycle cases.
A Go function table whose later record couldn't be read returned nothing at all, so every complete function before it was lost; unreadable names and the warning limit could drop functions while the table still read as complete. A damaged record now stops the scan with a warning and keeps the functions before it (a wholly unreadable first record is still refused), and the table is marked truncated whenever fewer named functions than declared were recovered. Tests cover Go 1.2, 1.16 and 1.20 layouts, truncated and damaged later records, address overflow, unreadable names and the public ELF inspection.
The JVM tableswitch and lookupswitch decoders reserved room for their declared entries before checking those entries were there, so a truncated 12-byte table could ask for 16 MiB; and a lookup table took duplicate or descending keys, though its signed keys must strictly increase. The whole table must now be present before anything is reserved, a dense table's count is converted without narrowing, and a lookup table with keys out of order isn't decoded (the instructions before it are kept and the coverage is reported incomplete).
A JAR manifest's lines were decoded as UTF-8 one physical line at a time, so a character split at the 72-byte fold became replacement characters; values lost their leading and trailing spaces, and only LF line ends were read. JAR integrity checks could then ask for a different entry name and miss the file meant. Continuation lines are now joined as bytes before decoding, only the space after the colon is dropped, CR, LF and CRLF all end a line, and a continuation after an empty line doesn't join two sections.
In a live run, an agent asked core_evidence_browse for a list by a name that wasn't one and had to run the tool again to find the right one, as neither the result's summary nor the error named its lists. A result's summary now carries its lists and their lengths, by the names core_evidence_browse reaches them with, in a detail: summary answer, the MCP server's summary-first answer and browse's own summary; and browse's errors for a name that isn't a list say which lists there are.
A .NET method body's extra sections were read as an exception table whenever their kind was odd, and clauses were read before the section's whole declared size was checked, so unknown sections, cut-off sections and partial clauses could show up as real exception handlers. A section now needs its complete header and declared size, only the exception-table kind (flags masked off) is read as one, it must hold a whole number of clauses, and an unknown kind is reported and skipped while chained sections are still followed.
The NIB reader limited how many values objects copied but not how big they were, so objects sharing a large data value, a long key or a long class name could turn a 45 KB archive into over 130 MB in memory. Copied data, keys and class names now share one byte budget, 64 MiB or three times the input size, whichever is larger, checked before each copy; the reader says when the budget stopped it.
The Solana sBPF symbol reader took any entry stride and read fields before checking the whole record was there, so a crafted file could panic on its largest offset, a truncated record could become a symbol, and bytes from a section that isn't a string table, or a name with no end, could be reported as an entrypoint or syscall. A symbol table now needs a valid entry size and each complete record before its fields are read, a partial last record is reported, and names come only from string tables with a terminator inside their range.
An Interface Builder NIB integer is up to ten groups of seven bits, and only one bit of the tenth group fits in 64 bits. The reader checked the shift but not the bits it dropped, so a tenth byte above 1 turned an out-of-range value into an unrelated small length or table index. Such an integer is now refused, and the whole unsigned range still reads.
Docs only. A live chat --deep run with Claude Code on a 581 KB comparison of two builds showed it asking for a summary, then paging the result with core_evidence_browse and quoting the rows, with no result over the 80 KB budget, and a page just under the budget reaching it whole. The roadmap line is ticked with what the run showed, and two new lines record the gaps it found: name the lists core_evidence_browse can page, and compare Rust names without their crate hash.
A text file (notes, source code, settings) was a target of unknown kind, so the target list and triage called it a file we don't recognise yet. Text now has its own target kind, found by the same check the text reader uses (a byte-order mark, or valid UTF-8 with no zero bytes and few control characters near the start) after every other format, so lists and triage call it a text file and point to core_text_read. A binary file stays unknown.
A GGUF model's quantized tensors (Q4, Q5, Q8, K and IQ types) had no byte length in the model-header report, so a complete tensor table could describe a truncated payload without that tensor being counted as past the end of the file. Their storage length is now calculated from each type's block layout, scale bytes included; a row width that isn't a whole number of blocks is reported, an unsupported type keeps an unknown length, and the end-of-file checks can't overflow.
A key saved in the app silently wins over the one in the environment, so a rotated key stayed hidden behind the old one unless the backend was removed or the keychain edited by hand. Settings → AI now shows for every API backend whether a key is saved; a saved one can be forgotten, so the environment's is used again, and a new one saved in its place, without removing the backend. The CLI does the same with ai key <name> (--key-env, --key-stdin or --forget), and never prints the key. A new key is read back after saving, and a forget that a locked or failing keychain can't confirm says so instead of reporting success.
Refs #1358