A class-data group cut at the member limit left its unread records where the next group would be read, so they were taken as that group's members, and a typed-handler list that stopped early could turn its remaining bytes into a catch-all address. The class data now ends as incomplete before an unread group, and a catch-all is read only after every typed handler.
A private browser or driven Electron app was stopped only when its process handle was dropped, which a crash, a kill, a force quit or an MCP server stopped by its client never does, so the browser was left running and its profile stayed in the temp folder. On Unix a small watcher now stops the browser's process group and deletes its `craft-*` profile once the app is gone, and ends by itself as soon as the browser does. Windows children are held by a Job Object; whether one outlives an abrupt exit is left as a roadmap line.
Refs #810
The indirect symbol limit applied to each section on its own, so many sections could still read an unbounded number of slots. It now applies across all sections, with a warning when slots are left out.
An `LC_UNIXTHREAD` entry point was read from the first state record whatever its CPU or length. It's now read from the record whose flavour matches the file's CPU (x86_64, arm64 or i386) and that holds a complete state, so a short or foreign record no longer gives a made-up entry point.
The export limit counted listed exports but not the function slots examined or the extra names of one function, so a crafted table could still make the reader do unbounded work. Both now count against the limit, and the table says when it was cut.
A string literal cut at the display limit could grow past it once invalid bytes became replacement characters, or end in the middle of a character. The text shown now stays within the limit, on a character boundary, and an incomplete final character isn't shown as a replacement.
Dynamic symbols were recovered from the dynamic segment only when a file had no section headers at all. They're now recovered whenever the sections give none, and symbols, exports and imports already listed aren't added twice.
A core dump's file mapping paths are read one after another, and the reader moved on by the length of the decoded path, which differs from the stored bytes when a path isn't valid UTF-8, so the paths after it went wrong. It now moves on by the bytes it read.
Two imports with the same name from different libraries shared the first one's slot address. Slots are now matched by name and library, and an import that already knows its slot keeps it.
The code path, asset names and exec arguments kept from a Node single-executable program now share an 8 MiB limit on decoded text, and the listing says when metadata was left out instead of keeping all of it.
A PE entry point or import slot was computed with wrapping arithmetic, so an address past the end of a 32-bit image's address space wrapped round to a small one. Such addresses are now refused: the entry point is left unknown with a warning, and an import slot without a valid address isn't listed as one.
Symbol version definitions, requirements and the version index were read from their section's offset onwards with nothing to stop them at the section's end, so a damaged table could take versions from whatever followed. They're now read only within their sections' bytes.
A GNU long name or link longer than the name limit was cut to the limit, so two members could end up with the same name. Such a name now stops the listing with a warning, a long name whose data ends early is reported, and names up to the limit, terminated or not, keep their full text.
A symbol ending `WC` is the function that builds an enum case, and the demangler read the `W` but not the `C`, so every one was reported invalid. It now reads `enum case for` and the case's function, payload and generic parameters included, as `swift-demangle` prints them, and refuses a `WC` after another global.
An optional function type or protocol composition was written without parentheses, so `((Data) async throws -> Data?)?` read as a function returning an optional. The wrapped type is now put in parentheses before `?` or `!`, as `swift-demangle` writes it.
An allocating initialiser read `__allocating_init` everywhere. As `swift-demangle` prints them, only a class's own initialisers keep that name; in a struct, an enum, a protocol or any extension, even of a class, it reads `init`.
A `Qy` associated type names its generic parameter with the same numbering as `q`, where `Qy_` is the second parameter, and the demangler counted from the first, so `B.Iterator` read as `A.Iterator`. It now names the parameter `swift-demangle` names.
An addressor's mangling is `a` (mutable) or `l` followed by a letter for its kind, and the demangler read the kind letter as the next operator, so every addressor was reported invalid. The kind letter is now read (unsafe, owning, native owning and native pinning, mutable and not), and an unknown kind is an error instead of being taken for an unsafe addressor.
A Swift existential type (`any Error`, `A & B`) is mangled as a protocol list where each protocol is a context and a name with no kind letter, and the demangler expected a type there, so every such symbol was reported invalid. Each protocol in a list is now read as a context and a name, taking no substitution slot of its own.
Claude Code builders got a fixed tool list without `Agent`, and since that list limits the whole session, every subagent call failed with "No such tool available: Agent". A Deep build now includes `Agent`: a subagent gets only the builder's tools and the session's permissions, and starting one goes to the approval tool like other actions. Clean room still leaves it out, since all of its reads must reach the approval tool.
Fixes#1105
The two-letter standard type `SQ` in a Swift mangling is the protocol `Swift.Equatable`, and the demangler read it as the enum `ImplicitlyUnwrappedOptional`, so generic constraints named the wrong type and conformances to Equatable were reported invalid. It now reads `SQ` as `Swift.Equatable` in all three manglings.
A path like `vendor/notes-1.2.draft/` was taken for a crate and its version. A Cargo package folder is now split into name and version only where the rest is a complete semantic version and the name is a valid crate name, so hyphens in names and prerelease or build versions (`helper-2-1.2.3-rc.1+build.7`) read correctly and other folders aren't reported.
A row stored before ALTER TABLE ADD COLUMN reads the default as SQLite's default expression gives it, not as a later insert would store it. In a TEXT column a separated literal keeps its spelling without the underscores or a leading plus (`1_000.` reads '1000.', `12_34.5_0` reads '1234.50'), and an integer that fits in 64 bits is written plainly (`0_07` reads '7'), as SQLite 3.50 reads them.
A zero-fill Mach-O section (`S_ZEROFILL`, `S_GB_ZEROFILL`, `S_THREAD_LOCAL_ZEROFILL`) takes memory but has no bytes in the file, so looking one up by name could return unrelated bytes from the start of the file. Each section now keeps its type, and a zero-fill one has no file range.
A method descriptor's parameter list now ends at the parenthesis that follows a whole parameter, so a class name containing a parenthesis no longer cuts the parameters short.
A generic Go function's name with type arguments in brackets, which can hold slashes, is now split at the package before the brackets, so it's attributed to the package that declares it.
A Zstandard member made of several frames, possibly with skippable frames between them, was read only up to its first frame. Every frame is now decoded in turn, within the same output limit.
VLAN tags were only read in Ethernet captures. They're now read after the Linux cooked header too (SLL and SLL2), so tagged frames reach the IP decoder.
A ZIP member with a legacy-encoded name and an Info-ZIP Unicode path field whose checksum matches the name now shows the Unicode name. A field that doesn't match, or a name already flagged as UTF-8, keeps the name as before.
Android resource configurations that differ only in script, variant or numbering system, such as zh-Hant and zh-Hans, now get distinct BCP 47 qualifiers (`b+zh+Hant+TW`) instead of the same `zh-rTW`.
A certificate name is now written with its values escaped as names are written in text, and attributes of one RDN joined with `+`, so a comma or plus sign inside a value can't read as a separator.
An address in a PE file's headers is now resolved only within the headers' declared size, instead of up to the first section, which could reach into padding.
A TEXT column's default that is a real number kept the schema's own text, so `DEFAULT 1e3` showed '1e3' and `DEFAULT 5.` showed '5.'. SQLite reads such a literal as a REAL and writes it as text in its own form, so these now read '1000.0' and '5.0', large numbers switch to scientific notation as SQLite's do, and infinity reads 'Inf'. Integers that fit in 64 bits are still written plainly.
In newc and CRC cpio archives, hard-linked files share an inode and only one copy carries the data. The empty copies are now listed as hard links to the one with the data, instead of as empty files.
A line comment now ends at a carriage return as well as a newline, so a settings file saved with old Mac line endings is read and edited instead of being taken as one long comment.
A source map's `sourceRoot` such as `webpack:///` or `file:///` kept its slashes trimmed when a relative source was joined to it, which broke the URL. A root that already ends in a slash is now joined as it is.
When the string limit is reached, the strings kept are the earliest in the file across both narrow and UTF-16LE text, instead of filling the limit with narrow strings and dropping earlier wide ones.
A HAR summary added the larger of each response's received and decoded sizes into one total. It now reports the received bytes and the decoded content bytes separately, with how many responses didn't record each.
Each method in a type's method range must name that type as its owner, so a damaged or overlapping range is reported instead of attaching another type's methods to it.
The block index and variables table of an asset catalog are read only within the sizes the file declares for them, so a damaged count or name length is reported instead of being read past its table.
A contract function was labelled nonpayable whenever CALLVALUE appeared before its body. It now needs the check to branch to a revert when a value was sent, and a body that halts with an error before any check is reported as unknown.
A PyInstaller PYZ archive holds data files and namespace packages besides modules. Data files are now extracted as they are, without a bytecode header in front, namespace packages are listed instead of being shown as empty modules, and an unknown member type isn't decoded.
A game requested "in Phaser" or "using Bevy" now builds with that framework, as a browser project or a Cargo project in app/, instead of being sent to an editor the person didn't ask for.
A Bun program's modules can carry a stored source map and bytecode, which were only counted in a note. They're now listed and extracted as their own members, in a folder whose name doesn't clash with the program's own files.
A follow-up or a resumed run on an API builder no longer tells it to check its work with `rebuild_check`, which its loop doesn't run; it's told that Craft Anything checks the build after its turn. Coding agents are still told to run the check themselves.