Files
craft-anything/docs/STATUS.md
BFlat 4402d170f9 Merge pull request #2015 from Plastic-time/bugfix/r3.12-html-legacy-script-language
A script tag with language="VBScript" and no type was listed as JavaScript. When type is absent a browser uses the legacy language value to pick the script's type, so a language that is not a JavaScript one is no longer listed. An explicit type still decides, even an empty one.
2026-11-17 12:05:54 +07:00

297 KiB
Raw Permalink Blame History

Status

What works today and how it was checked. The plan, owners and order of work are in ROADMAP.md. Last updated 2026-11-09. The baseline audit on 2026-10-23 from main had 923 tests passing; workspace clippy, layers, fmt and the secret scan of all history were clean. Chinese UI checks are listed separately below.

What works, and how it was checked

Local Codex discovery and sign-in (R2.2)

macOS Dock launches can find an executable Codex CLI bundled with ChatGPT.app or Codex.app after checking PATH; a selected program remains first. Settings → AI offers a worker-backed Check action for every local agent CLI through the same headless API as ai test. Sign-in comes from the selected backend's adapter and configuration folder, not a model-id check. Known signed-out states include guidance; unknown states leave the version reply unchanged, without claiming sign-in. The check reads no credential files, sends no prompt and does not claim model or quota access. Fixture tests cover bundle layouts, permissions, root order, status parsing, the selected CLI and rendered results. Regression coverage also includes a second adapter's true/false/unknown results, its configuration folder, and unrelated login-shell errors. See Codex setup and limits. A refused tool that setup doesn't approve now says to add the tool inside the generated inline tools table in config.toml; the dotted-table form failed with "cannot extend value of type inline table with a dotted key" (#1867). The hint and both table shapes are covered by tests. Each pending check is tracked by job ID: a worker-start failure or caught panic frees only that agent's Check action for retry, preserving concurrent checks. Local Apple Silicon verification: 777 AI/GUI unit, integration and smoke tests passed with four existing ignored (four test threads), including headless parity. All-target clippy with warnings denied, formatting, layers, locks, translation coverage and secrets passed. The companion CLI was built with locked dependencies.

Area State Verified by
Target file signatures File kinds are named from the shared craft-sniff table, pinned to craft-libs 070005125f0af1a5ae4a59002270e5849505bfc0. The app still breaks ties that need its own parsers (managed PE, Java class versus a universal Mach-O, APK by name or manifest). Fat Mach-O files that start 0xCAFEBABF are recognized. Media and archives the table names, but this app does not inspect by kind, stay unknown. Engine unit tests cover Mach-O, fat Mach-O including CAFEBABF, Java class versus fat, PE, JAR, empty ZIP, XML plist, PNG-as-unknown, scripts and text. Local clippy with warnings denied, xtask layers/locks/secrets, and the craft-anything-engine test suite (699 library tests plus the crate's integration tests) passed.
Engine download redirects Shared engine downloads require HTTPS on every redirect hop. A refused HTTP destination is not requested or included in the refusal diagnostic; existing hashes and file transactions are retained. Six bounded local HTTP/TLS tests cover downgrade rejection with zero HTTP requests, HTTPS redirects, checksum success/failure, file preservation and cleanup, redirect cycles, initial HTTP and untrusted certificates. The downgrade regression records one HTTP request before the policy fix, zero after it. Tested on Windows; no live large engine installation claimed.
Engine downloads behind a proxy Engine downloads use ALL_PROXY/HTTPS_PROXY/HTTP_PROXY; on Windows, without them, the person's manual system proxy (its HTTPS entry, else HTTP), with this computer and Windows' exceptions (or NO_PROXY) going direct. AI clients don't read the system proxy. Unit tests of the setting's forms and exceptions; not run behind a real system proxy, PAC scripts and SOCKS-only settings aren't read, and an exception with a * other than one at its start or end (*github*) is left out.
Engine paths that name a folder A path set in Settings → Engines (engines.tools.<id>) that names a folder, such as a JDK's folder or the folder that holds JDKs, is looked in for the engine's program as an install folder holds it (<folder>/<exe>, bin/, one level of sub-folders, newest version first, or a single-file install's jar); a path to the program is taken as it is. A folder without the program isn't counted as found. engines_list, doctor, Requires::Engine and the tools that look up their program through external_disasm_tools::locate (Vineflower and its Java, ILSpy, objdump, rizin, rtl_433) agree, and say the folder has no such program; gdb, rizin sessions, adb, JADX, Apktool, Frida, tshark, lldb and the browser find the program the same way but keep their own not-found message. Engine unit tests (a JDK's folder, its parent folder, a folder of JDKs that picks the newest, a jar's folder, an empty folder and its message; Vineflower's error for a Java folder with no Java); live in Debian 13 with no system Java, Java set to a JDK's folder: main listed the folder as the Java runtime and Vineflower failed with "permission denied", this branch found bin/java and decompiled. Not run on Windows or macOS (a .app bundle set as a path isn't looked inside).
Required WASM fonts A required craft-fonts build fails when target filtering selects no fonts, even if its manifest lists valid entries. Empty manifests keep their own diagnostic; optional filtered builds stay silent and successful. Eight build-plan tests cover family/style filtering, partial and allowed-only selections, empty manifests, missing files, native builds and required/optional values. Standalone Cargo fixtures using the build script cross-compile to wasm32-unknown-unknown: the original script accepts an empty required selection; the corrected script rejects it and accepts the allowed face. No browser rendering was tested.
CLI signature type handles CLASS, VALUETYPE and generic constructors accept TypeDef/TypeRef handles rather than expanding nested TypeSpec signatures; standalone TypeSpec and custom modifiers remain supported. Four focused groups cover direct and nested invalid handles, legitimate generic types and custom modifiers. The separate recursive fixture times out on the original parser and completes under the same 128 MiB / two-second process limits after the correction.
CLI array shape notation General rank-one arrays remain distinct from vectors, and array dimensions retain declared sizes and signed lower bounds in CLI notation. Five regression groups cover rank-one identity, bounded and partial shapes, nesting, member/local projections, malformed counts and maximum compressed values.
CLI volatile modifiers Type notation recognizes required System.Runtime.CompilerServices.IsVolatile modifiers by their complete qualified name, throughout the modifier list. Optional modifiers and similarly named types do not imply volatile. Six regression groups cover optional and required markers, namespace/name lookalikes, late markers, method and nested signatures, ordinary types and malformed tails after a valid marker.
Objective-C registration identity Classes and categories listed by both ordinary and non-lazy tables appear once per decoded address, in first-seen order. Distinct definitions with the same name remain separate. Three original Mach-O regressions fail before the correction; class/category overlap, chained-pointer aliases and same-named distinct definitions pass afterward, with an ordinary class/protocol control. No Objective-C runtime was executed.
Paged byte searches The match cap keeps the earliest file offsets across hex patterns, UTF-8 and UTF-16LE queries. Counts at the exact cap remain complete; excess matches are disclosed as partial. Engine fixtures cover early text before a full later pattern stream, early wide text before a full narrow stream, the final capped page across all three queries, exact-cap counts and overlapping ties.
CArchive filename boundaries Member names require a NUL terminator inside their TOC record. A damaged name stops the listing with a truncation note; preceding members remain readable. Old and new cookies, valid listings, a damaged second name and extraction of the retained first member.
Source policy gates Process, UI-side-effect and isolated-session checks inspect Rust paths and explicit import aliases; test exemptions follow cfg predicates and explicit module declarations. Hidden module directories remain in scope. Source read/parse/list failures fail visibly, including in the lock check; symlinked source directories are rejected visibly instead of skipped (linked Rust files are read) Synthetic source fixtures and cargo xtask layers / locks; syntax checks only, without macro expansion, re-export resolution or compiler-wide enforcement. Explicit module files reachable from each source root are included within the workspace, including UI modules outside src; missing cfg-dependent files still need compiler checks
PyInstaller archives CArchive members cannot read the table, cookie or appended signing data. Legacy PYZ data members unpack with their original bytes and names. Empty namespace packages are listed as metadata; older namespaces with code still unpack as packages. CArchive range fixtures cover both cookies, cross-boundary members, signed tails and empty options; PYZ fixtures cover mixed member types. Verified source a5bcfaed: formats tests, fmt and clippy; layers, locks, secrets, wasm and unchanged Cargo.lock; unchanged-code regression failures.
Expanded PYZ paths Nested module, resource and unknown-member paths share an 8 MiB retained-byte budget with namespace names across one listing. Complete identities and declared module counts remain available in partial results. Shared-prefix, multiple-PYZ, Unicode namespace and normal extraction regressions. A native PyInstaller 6.16.0 archive writer produced a 5.04 MB CArchive whose unbounded listing retained 146 MB of path text and aborted under a 128 MiB address-space limit. The bounded reader completes under that limit, retaining 8,386,347 expanded-path bytes plus the existing 3,626-byte outer member name, with truncation reported.
Binary property-list object types Accepts compatible version-zero minor signatures and rejects unsupported major versions, invalid simple/date markers and unrepresentable non-string dictionary keys. Typed binary fixtures with valid null, string-key and date controls.
PYZ code header versions Extracted code uses the eight-, twelve- or sixteen-byte timestamp header required by its Python magic number. The same header length counts toward the output limit, preserving the marshal payload at the correct offset. Synthetic direct-wrapper, standalone PYZ and nested CArchive regressions for Python 2.7/3.6 framing, exact output limits, current Python code objects, unknown magic numbers and header-free resources. Legacy framing uses a version-independent marshal value; legacy interpreters were not executed.
Limited string scans The earliest printable strings are retained in address order across narrow and UTF-16LE encodings. Interleaved binary fixture with every result limit from zero to four.
Evidence-based call paths Function studies must identify the same input bytes before their addresses are joined into one call graph. Mixed binaries and missing input hashes are rejected; renamed copies of identical bytes remain compatible. Two real ELF dossiers each lack a main-to-dispatch path, while their mixed records reproduced a false path before the guard. Inline/saved inputs and same-content controls are covered.
Imported function pointer identity Explicit imported-function slots are retained. Missing slots prefer a matching library. A slot without library metadata is used only when both its address and the import's library identity are unambiguous. Same-named PE imports across different and identical libraries; versioned ELF GLOB_DAT/JUMP_SLOT slots, repeated relocations to one address, distinct slot addresses, and same-named imports from different version owners.
Managed PE detection The CLR directory must fit inside the declared optional header before a file is identified as managed. Three regression groups cover PE32/PE32+, short declared headers, exact directory boundaries, directory counts and truncated bytes.
PE import/export text retention A 64 MiB default decoded-name budget covers repeated libraries, import names, export aliases and forwarders. Normal, delay and bound imports share a budget; export name indexing keeps offsets until a row is emitted. Public custom-budget readers disclose partial prefixes and preserve declared counts. Five budget/UTF-8/empty-table controls plus two separately run memory fixtures. Actual public-reader probes for 526,336-byte imports and 1,202,816-byte exports finish under a 128 MiB address-space limit; both unchanged probes abort.
ASAR listings Invalid directory, link and file nodes are rejected instead of becoming empty files. Rejected unsafe names count toward the listing limit alongside retained entries. Expanded entry paths and rejected names share an 8 MiB byte budget; omitted paths are never shortened and partial listings remain marked. ASAR and ZIP extraction preserve listed files with a truncation limitation, partial coverage and no claimed total; JavaScript app maps also retain listing truncation in their coverage. Synthetic regressions cover malformed nodes, ordinary Unicode paths, empty/unpacked files and links, entry limits, shared-prefix amplification and whole-path byte limits. A 1.48 MB manifest retained 145 MB of paths before the byte limit and aborted under a 128 MiB address-space limit; the bounded reader returns a partial listing under that limit. Earlier node-validation source 351002ea: formats tests, fmt and clippy; layers, locks, secrets, wasm and unchanged Cargo.lock; unchanged-code regression failures.
ASAR detection Target kinds use the ASAR reader's own check (asar::looks_like_asar: pickle size 4 and a JSON object at byte 16), as file inventories and js_app_map already did, so a header with spaces or another key before files is an ASAR to all of them. asar_detection.rs: headers the reader accepts are recognized, from the first 17 bytes; the first test fails on the former dispatch check.
HAR input Captures with a leading UTF-8 byte order mark parse like the same capture without it. Synthetic regression reads_a_har_with_a_utf8_bom in the formats crate.
HAR response byte totals The network summary totals received body bytes and decoded content bytes separately. Each total reports how many entries lack its measurement. A known zero-byte transfer stays zero. Compressed, cached and unknown-size response fixtures.
Recorded HAR request content type Recorded request bodies use the request Content-Type when retained. Response content keeps its separate MIME type. HAR round-trips cover flat and outlined headers, case variants and unavailable values.
Tar metadata fields Reject negative GNU base-256 encodings in unsigned fields and stop before an oversized GNU long name or link can become a truncated identity. Numeric-field controls plus GNU long-name/link fixtures at and beyond the name limit, with terminated and size-delimited names and preserved earlier members. Verified source de2c6390: formats tests, fmt and clippy; layers, locks, secrets, wasm and unchanged Cargo.lock; unchanged-code regression failure.
Embedded Godot PCK bounds Embedded PCK directories and member data end before the twelve-byte trailer. Cross-boundary members are listed as unreadable and refused by extraction. Synthetic godot_trailer_boundary regressions (4 tests): PCK versions 1, 2 and 3; member ranges in the footer, directory counts and records crossing it, direct reads of forged entries, and valid embedded/standalone packs. Format checks and compatibility gates passed at 9744a0569a7c.
.NET single-file bundles Entries crossing from the payload into the manifest are reported as unreadable. Synthetic regression a_member_cannot_borrow_bytes_from_the_manifest in the formats crate.
Watched descendant regression A guarded Rust parent starts the heartbeat child in its inherited process group/job. No shell quoting is involved. The watched launch is stopped before missing startup markers can fail an assertion macOS regressions pass for descendant shutdown, startup-timeout cleanup and direct ignored-fixture runs without guards. Windows execution of this replacement remains pending; the prior shell fixture failed there. The platform suite still has the separately tracked preview-connection fixture failure
Disabled chat backends Naming a backend that is off refuses chat and either side of compare with a settings error and guidance, before API or coding-agent setup Isolated hub regressions for disabled API and agent backends, both compare positions, and enabled/automatic controls. Invalid tunnel settings detect API setup before the guard. No live provider or agent was used
Request-based project kinds Low-level tools and media players keep the app target when “level” or “player” describes the tool. Explicit game requests and game engines still select the game target Request-classification regression cases
ZIP64 end-record framing Retain bounded fixed fields with a warning when the declared extent disagrees with its locator. Recover records shifted by prepended data within a 64 KiB lookbehind, checking classic-field agreement and directory placement; records with extensions must frame them exactly for recovery. An unusable locator still keeps classic-directory fallback. Undersized payloads, arithmetic overflow and fixed fields overlapping the locator remain rejected. Synthetic regressions cover CRC-checked payloads, short/long declared extents, shifted genuine ZIP64 records with and without extensions, saturated directory fields, the recovery budget, and classic 65,535-entry archives with locator/record-shaped comments and prepended data. Warnings are serialized only when present.
Runner-owned app windows Runtime capture tries the launched process and its descendants; the captured window owner's PID is also used for the UI tree. Unrelated processes with matching names are excluded. Process discovery has a deadline, output cap and candidate limit Hermetic regressions cover runner/child/grandchild ownership, unrelated windows, direct launches, cycles, malformed rows, caps and errors. A macOS process snapshot finds an owned child without opening a window. Windows and real Go GUI capture have not been run
Failed external programs A program that prints more than its output cap keeps the start for parsers and up to the last 16 KiB for the error. The error names the last error, the excerpt shows the end (a long final line keeps its end), and says when the output was cut; adb, Frida, build checks, screenshots and SSH use the kept end. Process regressions for 4 MiB of stderr and stdout ending in REAL-ERROR, a truncated crash whose error sits above its stack trace, and a long final line; the existing cap, crash and timeout tests.
New-project toolchains New Python, Go, .NET, Maven, Gradle and Make projects use the same build catalogue as existing projects (engine/src/toolchains.toml). A Python project without a root entrypoint can start its one installed [project.scripts] console wrapper from its virtual environment. Shared launch recipes let screenshots, self-tests and Play start Python main.py, app.py or __main__.py, a single Python package with a <name>/__main__.py as python3 -m <name> in a project with a Python marker, Go with a root main.go or a single cmd/<name>/main.go, one root .csproj, and the single runnable jar (its manifest names a Main-Class) a Maven (target/*.jar) or Gradle (build/libs/*.jar) build left, with java -jar. Maven builds with package -DskipTests, so that jar is this build's. Python uses a project-local virtual environment when present, resolves its executable to an absolute path even for relative project folders, and forces fresh syntax compilation; .NET passes app options after --. Manifest markers take priority over standalone Python files. Runtime window-capture requests normalize relative project and runner paths to absolute paths. Godot and Electron receive an absolute project path when launched from a relative workspace. Existing packaged programs, Rust, Electron and Godot keep launch priority. Multiple .csproj, package or runnable-jar matches or a capped scan do not choose a project. Other layouts still need a packaged program or another launch recipe Catalogue and launch regressions cover argv boundaries, ambiguous entrypoints, scan limits and Windows/local interpreter selection, including relative project folders and unchanged argument boundaries. Capture-request tests cover relative placements and PATH results, local interpreters and optional UI-tree output without opening a window. An owned interpreter stand-in runs the full new-project build/screenshot path, rejects failed builds, and verifies a failed screenshot cannot reuse an old PNG. An opt-in real Python 3.15.2 fixture on macOS passes build/screenshot checks, ignores invalid virtualenv code, and rejects a syntax error even when its mtime matches the cached version. Without compileall -f that same syntax-error probe incorrectly exits zero. Real Go/.NET/Maven/Gradle runs, Windows and GUI apps have not been verified for this change; java -jar on a real jar has not been run
Relative project folders Engine build arguments, option runs (--screenshot, --self-test), console run checks, Play and pins resolve their program, working directory and option/output paths to absolute paths before starting a child in app/. Engine and AI regressions cover a relative workspace with a built program: Play and a pinned copy start and exit, an option run saves its file, a console run check compares its output, and Unity build arguments stay absolute; existing absolute-path controls remain.
Cargo target directories A Rust build's program is looked for under CARGO_TARGET_DIR, then the closest config/config.toml build.target-dir (project or ancestor), then the default target/. A shared or ancestor target outside the app supplies only a program the manifests name, and only one whose Cargo record (<name>.d beside it) lists the app's sources, so another project's program of the same name in a shared CARGO_TARGET_DIR isn't taken; of the programs that count, the newest is started. Without a name, only target directories inside the app are searched. A pin made before programs were recorded starts only what is inside its own copy. A pin copies a program built outside the app into its own pin-program/ folder and records the copy. Play, screenshot and self-test checks use it. An AI regression with .cargo/config.toml target-dir = "out" fails before the fix; engine tests cover the environment (relative and absolute), a shared directory's unrelated executable, a named program from a shared directory, a project and ancestor setting, a relative app below a config, the legacy config preference and no fallthrough, the pin copy, a same-named program in a shared directory with no record or another project's record (and the newer of two of the project's own builds), and an older pin beside a newer build in a Cargo setting above it. Not handled: build.dep-info-basedir makes Cargo's record list relative paths, so a program built outside the app with that setting isn't found; a program of the same name from a project that depends on the app by path counts as the app's. No live build with a custom target dir was run.
Pin estimate dialog A pin size estimate that finishes after the dialog closed or another project's dialog opened is ignored; the estimate result and its errors name the project they were for, and the matching project still fills the dialog. UI regressions: a late estimate or error for another project, and an estimate after the dialog closed, leave the open draft unchanged; the matching project fills it. Engine regression: an estimate result and an estimate error name their project.
Keep non-UTF-8 Godot paths from opening a different project Decline a Godot launch when its project path cannot be represented as UTF-8 instead of silently replacing bytes in the selected path. Regression fixtures cover two distinct Unix project directories whose paths collapse under lossy conversion, plus the valid Unicode project.
Cargo paths in Rust binaries A versioned directory contributes dependency evidence only for a valid crate name and complete semantic version. Prerelease and build identifiers remain available. Mixed registry-style path evidence with invalid names, invalid versions and a versioned dependency.
Mac call observation apple_calls_observe launches an executable under LLDB, records named function hits and reports a debugger refusal as an error with remediation. Opt-in engine regression on arm64 macOS 27.0.1 with Apple LLDB 2100.0.16.4 recorded alpha and beta in order and returned ProgramFailed for a non-executable input (#1844).
macOS optional UI tree and screenshots runtime_ui_read with accessibility: false skips the tree and its permission check, returns empty nodes without truncation, and records the skipped read (#307). Walkthroughs still require Accessibility. With screenshot: true, macOS 14+ returns one owned-by-pid window as PNG/base64, restricted by window_id when supplied; without it, the first matching on-screen window. Images are limited to 2048 px per side and 6 MiB PNG. Combined JSON stays within the 16 MiB helper output cap; oversized trees retain a prefix with explicit truncation and partial coverage while preserving the image. Missing Screen Recording permission, a missing window or a capture failure is an explicit screenshot limitation with partial coverage (#248). Denied Accessibility permission returns a tool error before capture when the tree is enabled (the default); set accessibility: false to skip the tree. Permission dialogs are never opened Synthetic Swift serializer regression covers combined tree/image overflow, escaped Unicode values, a single oversized node, an oversized image, and unchanged small/skipped trees. Engine regressions compile/run the real Swift helper: skipped trees at node limits 0/1, screenshot-off control, and impossible-window screenshot errors propagated to evidence. Live helper probe on macOS 27.2 captured only an owned AppKit fixture: valid 320 × 192 PNG (14,400 bytes), matching window id; screenshot-off returned no image/error. No granted-permission tree read, walkthrough, macOS 14 run or MCP transport run
CPIO member names and trailers Keep incomplete pathnames and invalid end markers out of a completed cpio inventory. Extra NUL padding in a name remains valid. Regression cases added: Malformed names, padded names, nonempty trailers and truncated final padding.
Archive comparison rows core_archives_compare keeps complete counts and sets rows_capped when the added, removed, changed or moved lists are cut at max_rows; its evidence then adds a rows_capped limitation and partial coverage. Analysis and engine regressions cover a capped comparison (two changes, one listed row, counts complete) and an uncapped one; the capped assertions fail on the unchanged code.
Firmware archive member completeness Early ZIP, tar and cpio member walks propagate their truncation flag into extraction coverage and diagnostics, including nested archives and directories that consume the listing limit without producing files. Eight real-engine regressions cover the three readers, nested tar, a damaged ZIP directory, exact directory-only limits and recovery after raising the limit. All five regressions fail both before this change and with only the ZIP decode-budget correction; three controls pass.
CPIO hard links Zero-length entries sharing a regular file’s device and inode are listed as hard-link aliases to the member carrying the data. Synthetic newc and CRC archives with payloads before and after the alias and a different-device control.
GNU sparse tar members PAX sparse metadata marks a member as unsupported instead of presenting stored extents as a complete regular file. Original sparse names remain visible. Synthetic sparse 0.0, 0.1 and 1.0 records cover payload alignment, original names, intervening extensions and unaffected following files. Verified source daaeb4fe: formats tests, fmt and clippy; layers, locks, secrets, wasm and unchanged Cargo.lock; unchanged-code regression failures.
DNS service records and address announcements SRV, SOA and CAA answers expose their wire fields. Internet addresses have checked widths. Truncated replies retain their complete records, and unsolicited address announcements keep their owner. Synthetic DNS and mDNS captures cover bounded fields, compressed names, empty UPDATE prerequisites and legacy replies.
Packet capture protocol evidence DNS label rendering escapes literal dots, backslashes and non-printing bytes. HTTP metadata requires a complete request or status line with checked version and status fields; responses retain their status when the reason phrase is absent. Synthetic DNS questions and compressed answer owners, malformed and valid HTTP start lines, HTTP/1.0 and HTTP/1.1 responses without a reason phrase, and unchanged invalid-version/code/control-byte rejection.
SignedData certificate inventory Read X.509 choices from the declared certificate field, skip other certificate choices and apply the certificate limit once. Regression cases added: Mixed certificate choices, field tag mutations and a 70-entry certificate set.
Decode DNS service bindings and authentication records Expose SVCB/HTTPS target and service parameters, SSHFP/TLSA authentication data, and NAPTR/URI/DNAME discovery values through bounded DNS answer decoding. Regression fixtures cover service ports, ALPN and address hints, digest widths, NAPTR strings, URI targets, complete uncompressed names and malformed record fields.
DNS question boundaries A question is retained only when its name, type and class are complete. A missing class byte marks the DNS message incomplete; preceding complete questions remain available, and incomplete questions do not enter the query inventory Four packet regressions cover both truncation lengths, multiple questions, complete class values and the capture summary. No live capture was used
Reject impossible IPv4 header and total lengths IPv4 decoding rejects impossible header lengths and reports incomplete base headers or options. Synthetic byte fixtures in pcap_ipv4_lengths integration regressions. Cover 10–19 captured header bytes, total lengths below IHL, missing options, complete options, truncated transport headers with readable ports, and a cut UDP payload with both ports and its captured length preserved.
Validate the version in IPv6 frames IPv6 decoding checks the packet version before reporting IPv6 facts, including captures declaring raw IPv6; explicit raw IPv4 likewise uses IPv4 validation. Synthetic byte fixtures in pcap_ipv6_version integration regressions. Cover incorrect versions behind the IPv6 EtherType, mismatched explicit raw IPv4 and IPv6 link types, matching explicit and generic raw packets, and valid IPv6 traffic-class bits.
IPv6 No Next Header Packet reports keep the IP header and ignore bytes after Next Header 59. Raw IPv6 fixtures cover an empty payload, padding, a destination-options header and a UDP control.
Stop decoding extension headers inside noninitial IPv6 fragments Noninitial IPv6 fragments no longer supply fabricated extension or transport headers. Synthetic byte fixtures in pcap_ipv6_fragments integration regressions. Cover payloads resembling a second fragment header or destination-options header, plus valid first and atomic fragments.
Enforce the expanded DNS name wire-length limit DNS names obey the 255-byte expanded wire limit. Invalid name-valued RDATA marks parsed answers incomplete; legal empty ANY/NONE UPDATE prerequisites remain supported. Synthetic byte fixtures in pcap_dns_name_limit integration regressions. Cover plain and compressed names at the wire limit, literal-prefix compression overflow in questions and NS/CNAME/PTR/MX records, record boundaries, root names, and legal empty UPDATE prerequisites followed by another record. Coverage is limited to the parsed questions and first 64 answer or UPDATE prerequisite records.
Report truncated DNS TXT strings as incomplete TXT validation covers at most 64 parsed answers, or prerequisites for DNS UPDATE; authority and additional records are not inspected. Empty ANY/NONE UPDATE prerequisites with zero TTL and empty TXT records for wire-identified DNS-SD instance owners in ordinary multicast/unicast DNS are retained. Synthetic byte fixtures in pcap_dns_txt_lengths integration regressions. Cover a cut first string, a cut later string, a missing string body, and valid empty or multiple strings. Review regressions preserve empty UPDATE prerequisites and following records, while checking opcode, class, TTL, and truncated-string boundaries. DNS-SD cases cover known answers, cache-flush records, compressed owners, literal dots and case, plus ordinary/invalid owners and nonempty truncation.
Indexed source maps Reject malformed section tables and offsets, preserve the boundary of an unfetched external map, and reject descending section offsets. Regression cases added: Index shape, offsets, external boundary and resumed lookup fixtures.
Indexed source-map inventories Only the section maps contribute source entries. Regular-map fields on the containing index do not create source matches or consume the output budget. Fixtures cover nested and empty indexes, scoped source roots, a constrained inventory and a regular-map control.
Source-map annotation spacing The trailing annotation reader accepts no space, tabs and repeated spaces after its marker, and rejects whitespace inside a URL. The JavaScript analyzer uses the same reader on both its parsed and lexer paths, so a bundle with the standard no-space form keeps its map. Line, legacy and block comment markers, ordinary spacing and invalid URL controls, plus a JS integration regression through analyze for the same forms, the whitespace URL and an annotation followed by code.
Source-map annotation line endings The trailing annotation reader recognizes LF, CRLF, CR, U+2028 and U+2029. Regressions cover finding the last annotation and the 64-line lookup window.
Source-map block annotation boundaries An unfinished block cannot override a complete annotation. A block ends at its first closing delimiter and accepts both supported markers. Trailing comments on the same line keep the last valid annotation. Fixtures cover malformed blocks, mixed comment sequences, trailing code and line comment controls.
Source-map original recovery Ordinary source paths stay unchanged. Colliding aliases, duplicate entries and file/directory prefixes use a separate directory for each input and source index; the manifest retains the complete source identity and both indices. The manifest also stops retaining originals at the source-map inventory's 1,000,000-path / 64 MiB expanded-path budget, sets originals_truncated, and reports partial coverage with a limitation. Five engine regressions cover slash normalization, duplicate names, prefix conflicts in both orders, same-named input scripts and a 64 KiB source root with 1,200 sources; the collision cases check recovered files and manifest provenance, and the budget case checks retained path bytes, the truncation flag and partial coverage. The collision and budget cases lose originals or over-retain paths on the unchanged implementation. Existing ordinary-path and no-overwrite controls remain in place.
Source-map generated-line budgets A shared max_lines limit (1,000,000 by default) caps line vectors across inline sections, including empty lines that do not spend the segment budget. Line-vector reservation failure returns an error. Six regressions cover default/exact/zero limits, nested and external sections, independent segment budgets and unchanged source positions; a bounded-memory production-module audit reproduces the former empty-line allocation failure.
Source-map parser entries sources, sourcesContent, names and ignore-list entries and index-map sections are counted against one max_entries limit (4,000,000 by default, the segment limit) shared across sections while the JSON is read; a map with more is refused with TooManyEntries before the rest is read. An application graph marks the sources of a map refused at any parser limit (entries, size, segments, lines, depth) truncated with a limitation, so they are uncertain rather than missing. Entries a repeated key replaces, freed before their replacement is read, and an x_google_ignoreList beside ignoreList, give their slots back. Fields the parser doesn't keep are skipped with the same checks as a full read, so maps within the limit read as before, errors included. Eight format regressions cover the limit for every kind of entry, repeated keys (lists, sections and a section's map), sections and their maps, stopping before a broken tail, unknown fields, the same BadJson as a full read for invalid skipped values (lone surrogates, out-of-range numbers, invalid UTF-8, trailing commas, deep nesting) and a map one name over the default; two analysis regressions check that a map refused for its entries or its lines leaves its sources uncertain (the first fails on the former analyzer) and is not marked unreadable. Measured on 64 MiB inputs in a release build: 21 million empty names peak at 0.16 GB (was 1.3 GB), a sections array of 0s at 0.29 GB (was 1.1 GB), 1.5 million external sections at 0.47 GB (was 2.6 GB). A differential run of 200,000 generated maps (repeated keys, wrong types, nested sections, invalid skipped values, truncated JSON; 49,830 of them bad JSON) gave the same result as the former parser, error text included.
External source-map sections An index-map section that points at an external map (url) adds no sources here. The parser counts those unread sections, an application graph records them with a source_map_external_sections limitation, and a source comparison reports otherwise unmatched sources as uncertain (source_map_external_sections) with partial coverage, not as missing; an inline-only map is unchanged, and a sources-only read counts them too. Format, analysis and engine regressions cover an inline section beside an external one, nested index maps, an inline-only map, the sources-only read, many external sections not spending the source budget, and the comparison's limitation and partial coverage.
Unreadable source maps A map that is malformed, has a data URL that can't be decoded, or is listed but wasn't loaded is marked unreadable with a source_map_unreadable limitation; a source comparison then reports otherwise unmatched sources as uncertain (source_map_unreadable) with partial coverage, not as missing. A map refused only for its mappings or section offsets keeps its sources list with a source_map_mappings_unreadable limitation, so its sources match and the ones it doesn't name stay missing; mappings that, as far as they decode, name a source past the end of the list, or a section with neither a map nor a URL, or both, still make the map unreadable. A stand-alone .map file beside an analysed script (no comment pointing at it) is read like a referenced one, after them, sharing the inventory budget; other .map files (game levels, CSS maps, maps beside a page, maps whose script wasn't loaded) stay listed and unread, without affecting the comparison. A map listed as ./path and loaded as path is one map. Graphs saved before the field load as readable. A map too big to be listed in single-file mode still reads as absent. Analysis regressions cover a malformed map, an unloaded map, a bad data URL and an unloaded stand-alone map, a stand-alone map beside its script whose sources now match, other .map files left alone, a ./-listed map read once, and older saved graphs; another covers bad mappings, unordered sections and bad mappings in a section (it fails on the former analyzer), and a format regression covers parse_sources; an engine regression checks the comparison's limitation and partial coverage.
Source-map source inventories Expanded paths are checked before allocation against shared entry and UTF-8 byte limits, keeping complete identities in source order. Defaults retain at most 1,000,000 paths and 64 MiB across indexed sections. Application graphs keep the existing 5,000-path limit per map and share the total budget across maps; omitted paths set sources_truncated and a limitation. Source-to-bundle comparisons preserve positive matches and report other sources as uncertain_sources with the source_map_inventory_truncated reason, separate from confirmed unmatched sources. Tool evidence reports the uncertainty and partial coverage. Format, analysis and public-tool regressions cover repeated large roots, relative and absolute-looking sources, exact and zero limits, UTF-8 bytes, null and empty names, nested sections, application-wide budgets, older saved graphs, complete inventories, retained matches and row limits. The default-byte and omitted-source diff regressions fail on unchanged production code.
Source-bundle comparison row cap A source-to-bundle comparison examines at most max_rows source scripts but reports scripts_examined beside the total, counts every bundle unit without an observed source (not just the listed rows), and sets rows_capped when either the script window or the row list is cut. The tool adds a rows_capped limitation and partial coverage. Analysis regressions cover a capped window (1 of 2 scripts, two unclaimed units, one listed row) and an uncapped comparison; an engine regression checks the tool's limitation, partial coverage and summary.
Folder walk ignore files walk_dir reads each .gitignore through the capped, regular-file-checked reader. A file over 1 MiB, not a regular file, not UTF-8 or otherwise unreadable is skipped, and the source tools and managed reader name every skipped file in a gitignore_skipped limitation or note. An absent .gitignore stays silent, and a symlink to a regular file still applies. Engine regressions cover oversized root and nested ignore files, a non-regular one, a non-UTF-8 one, a symlinked regular one that still applies, and a managed reader that names its skipped ignore file; the disclosure tests fail on the former reader.
Application comparison row caps app_graphs_compare reports complete added_total/removed_total counts and rows_capped for IPC channels, handlers, bridge members, endpoints, URLs, routes, native modules, bundle modules, vendor changes and changed modules' function/export diffs; its summary uses the complete counts. js_exports_compare reports each module diff's totals and a top-level rows_capped. Both add a rows_capped limitation and partial coverage when a list is cut. Analysis regressions cover a 2,001-row diff, capped bundle-module added and changed rows, capped vendors, 2,001 channels, 2,001 exports and nested function/export caps in a changed module; engine regressions check both tools' totals, limitation, partial coverage and summary. The capped cases fail on the former code.
Application comparison limitations app_graphs_compare and js_exports_compare carry each loaded side's analysis limitations into their evidence, labelled left:/right:: path-analysis limitations, saved js_app_map evidence's limitations, and the full re-analysis's limitations when a paged record is expanded. Engine regressions force a malformed source map on both sides of both tools for path and saved-evidence inputs; a clean pair has no source-map limitation. Existing comparison and row-cap tests remain green.
Source map URL roots A relative source keeps the empty authority of webpack:/// and file:/// roots. Generated-position lookups and source lists with scheme roots, an HTTPS directory and a relative directory.
Source map root prefixes A nonempty sourceRoot prefixes every source before URL interpretation, including leading slashes and URL-shaped sources. Empty, absent and null roots preserve the original source identity for compatibility with generated maps. Lookups and recovered source inventories use the same path. Five regression groups cover root/source combinations, empty/absent/null roots, source indexes and content, and independent roots in indexed maps. Three groups fail against the former prefix logic; relative-root and empty-root compatibility controls pass.
Inline maps with URL fragments Ignore a data URL's fragment during decoding, preserve percent-encoded number signs in the data, and accept case-insensitive data and base64 markers. Regression cases added: Raw and encoded fragments, mixed-case markers, queries and non-data schemes.
TLS ClientHello offers Packet inspection validates session IDs, cipher-suite and compression vectors, SNI, ALPN and supported versions. It keeps the first copy of a repeated extension, distinguishes reserved GREASE from unknown versions, and checks ALPN beyond the display limit. Synthetic captures exercise invalid offers and complete legacy and modern handshakes.
HTTP extension methods Packet captures retain method, target and Host evidence for valid HTTP method tokens, including WebDAV methods. IPv4/TCP fixtures cover PROPFIND, MKCOL, LOCK, REPORT, M-SEARCH, case preservation and token punctuation; invalid tokens, versions and incomplete lines stay rejected.
Classic TCP ECN flags Packet reports show ECE and CWR when their TCP header bits are set. Raw IPv4 packet fixtures cover the ECN setup SYN, each flag individually, and ordinary SYN/ACK.
Read HTTP Host fields only from the header section HTTP Host values come only from complete request header lines. Synthetic byte fixtures in pcap_http_host_boundary integration regressions. Cover forged Host lines in bodies, invalid UTF-8 before Host, mixed-case field names, and incomplete header lines.
Keep capture flow timestamps in chronological order Flow time ranges use the earliest and latest available timestamps. Synthetic byte fixtures in pcap_flow_time_range integration regressions. Cover out-of-order timestamps and a flow that starts in an untimestamped simple packet block.
Capture timestamps and malformed packet records Classic captures omit timestamps with out-of-range fractions. Fine pcapng resolutions preserve the interface offset. Rejected packet records share the scan budget and report bounded diagnostics. Synthetic classic pcap and mixed-section pcapng fixtures cover both time units, damaged block lengths, undeclared interfaces and repeated iteration.
Linux cooked VLAN captures Cooked v1 and v2 packet headers expose the IP and transport layers beneath VLAN tags. Synthetic stacked VLAN and truncated controls through both Linux cooked link types, plus the packet and byte-reader suites.
Reject incomplete simple packet block payloads Simple packet blocks validate captured lengths and exclude alignment padding. Rejected lengths count toward the packet scan limit and produce one summary warning when the walk ends. Synthetic byte fixtures in pcapng_simple_payload integration regressions. Cover short payloads, excess payload bytes, unlimited snaplen, legitimate snaplen truncation, alignment padding, bounded warnings, and later valid frames. Unit regressions exercise rejected-only and mixed packet budgets, exact EOF, and repeated iterator exhaustion.
Keep ZIP directory entries within the declared directory ZIP central-directory entries stay within the declared directory. Synthetic byte fixtures in zip_directory_bounds integration regressions. Cover a short declared entry after a valid entry even without a signature, fields borrowing end-record bytes, an oversized directory, both self-extracting offset conventions, and a trailing directory signature.
Cramfs direct block pointers Direct pointers recover shared raw pages and length-prefixed compressed blocks in either image byte order. Ordinary blocks and holes can follow a direct block using its physical end. Six synthetic-image groups cover full/partial pages, raw/compressed mixtures, shared payloads, both byte orders, following holes, unavailable ranges and output budgets. Four successful-recovery groups fail on the original reader; malformed direct pointers remain rejected.
Keep version-two cramfs reads inside the filesystem extent Use the version-two cramfs size to bound root, directory and data reads in either byte order while preserving version-one compatibility. Missing block-pointer tables mark recovery incomplete and retain the readable directory entries. Synthetic production-reader regressions cover file and directory crossings, invalid sizes, physical truncation, big-endian headers, complete images, legacy size-field controls and unavailable block-pointer tables at declared and physical boundaries.
Cramfs uncompressed blocks File and symlink recovery recognizes ordinary uncompressed block pointers in both byte orders, including mixed compressed runs, and requires each block to match its expected file span. Eight regression groups cover full and partial blocks, mixed storage, symlinks, malformed lengths and pointers, budgets, compressed controls and big-endian flag decoding. Four native producer variants (both byte orders, with or without raw blocks) each recover 9,514 bytes matching every original file and link.
JFFS2 decoded extents Raw and zlib nodes must decode to their declared lengths. Invalid or unsupported nodes retain warnings; files are recovered only when later valid raw, zlib or zero nodes replace their damaged extents within the final file size. Twelve synthetic-image regression groups cover short/long decodes, failed inflation, obsolete and partially overwritten damage, split/zero repairs, version and physical order, repeated damage, final-size clipping, unsupported codecs and byte accounting.
Filesystem and archive recovery JFFS2 zero extents and nodes, ROMFS payloads and pointers, cramfs names and zero-filled hole blocks, SquashFS tables and PAX overrides stay within their recorded sizes and recovery budgets. A truncated SquashFS metadata block marks the image incomplete and leaves earlier blocks readable. Synthetic filesystem images and tar archives cover truncation, oversized payloads, padding and normal records. Cramfs hole fixtures cover full and partial pages, compressed neighbors and byte budgets; a native producer image recovers the original file and symlink contents.
Validate every SquashFS data block against its logical file span Require each raw or decoded file block to cover exactly its logical range, including the partial final block, so short blocks cannot shift later contents and long blocks cannot be hidden by truncation. Synthetic production-reader regressions cover short first raw and compressed blocks, short and overlong final blocks, correct multi-block data, and full or partial sparse blocks.
Cramfs byte order Big-endian inode fields, file sizes, name/offset bitfields and compressed-block pointers recover the same files and links as little-endian images. Original paired images cover nested directories, nonzero owner fields, recovery limits and corrupt/truncated records. Native producer images in both byte orders recover the original file and symlink contents.
Recover JFFS2 files from big-endian images Read JFFS2 node, inode and directory integers in the filesystem byte order, including images with erased leading space, and disclose mixed byte orders. Synthetic production-reader regressions cover equivalent trees and payloads in both byte orders, erased prefixes, directory version/deletion records, mixed byte orders and truncated nodes.
ext special inode kinds Device nodes, FIFOs, sockets and unknown inode types remain non-file entries; inode modes govern recovery even when directory hints disagree. Short symlinks retain allocation-based storage selection and unavailable targets remain unknown with their declared size. ext_special_inode_kinds covers the four special kinds, conflicting directory hints, ordinary files and directories, inline symlinks and unknown mode bits. ext_short_symlinks checks the combined behavior for block and inline targets, external attributes and missing data.
Filesystem walk membership ROMFS, ext, SquashFS and JFFS2 walkers use ordered membership for visited nodes, preserving traversal order, existing limits and repeated-node behavior Production ROMFS benchmarks with 8,192–65,536 files and checked metadata checksums; a 4,096-file control checks order, bytes, entry/work limits and cycles through a file or the root. Existing filesystem fixtures and hostile-input tests pass
Recover classic ext triple-indirect file blocks Follow the third classic ext block-pointer level, preserving the full logical span of sparse subtrees and refusing unavailable mapping blocks. Synthetic production-reader regressions cover three-level mapping, a whole sparse double-indirect subtree, unavailable metadata at each level, short files with unused pointers and the existing file-byte budget.
Gzip headers Verify optional header checksums while accepting informational XFL and OS bytes; reserved flag bits remain invalid. Synthetic headers cover extra fields, names, comments, valid and damaged FHCRC, truncated checksums and all informational byte values. Verified source dde4aa02: formats tests, fmt and clippy; layers, locks, secrets, wasm and unchanged Cargo.lock; unchanged-code regression failures.
Firmware ZIP output budgets Each member is written and charged before the next is decoded. Rejected names and failed writes leave room for later files; byte and file caps are reported as truncation. Eight real-engine regressions cover limits, failed CRC checks, duplicate paths, empty files and nested output metadata. A 50,218-byte ZIP expanding to twelve 4 MiB members with room for one measured median peak RSS 62,632 KiB before and 17,944 KiB after in three Linux processes per build; retained output bytes were checked.
Recover ext4 files stored entirely inside their inode Read regular ext4 inline files up to the 60-byte inode payload while preserving byte budgets; unsupported inline continuations and directory layouts remain explicitly unrecovered. Synthetic production-reader regressions cover zero, one, 59 and 60 bytes, an inode with the required system.data attribute, unsupported continuations and missing feature flags, byte accounting and inline-directory refusal.
Multi-frame Zstandard members Concatenated frames decode together, skip frames are ignored, and the output cap covers the complete member. Two compressed frames, a skippable frame, truncated second-frame data and a combined output cap regression.
Recover LZ4-compressed SquashFS metadata and file data Use the existing bounded raw LZ4 decoder for SquashFS metadata, regular data blocks and tail fragments while retaining Unity's exact decoded-size contract. Synthetic production-reader regressions cover compressed metadata, ordinary and overlapping-match data, compressed fragment metadata and payloads, raw-block controls, corrupt blocks, file budgets and the 8 KiB metadata cap.
Concatenated XZ streams Standalone XZ data decodes every stream in order, accepts four-byte stream padding, and applies one combined declared/output budget. Footer/index framing is checked before decoding. SquashFS blocks stop at the first stream. Reference streams plus generated empty streams cover concatenation, exact limits, truncation, invalid padding, checksum damage and malformed index integers/sizes. SquashFS extraction and decoder tests cover the first-stream boundary, trailing data, output limits and damaged first streams.
Refuse split ZIP archives without their other volumes ZIP archives requiring other volumes are reported as unsupported. Explicit classic directory sizes and offsets must agree with ZIP64 unless set to their own sentinel. Synthetic byte fixtures in zip_split_volumes integration regressions. Cover classic disk markers and counts, ZIP64 locator and record fields, conflicting classic/ZIP64 entry counts, entry disk sentinels both alone and after the sizes and local offset, and valid single-volume controls with mixed count sentinels. Additional regressions cover explicit directory-bound conflicts and each independently saturated end field.
Unreal DXT3 textures PF_DXT3 uses the shared bounded texture decoder, preserving explicit four-bit alpha and the four-colour palette even when the first endpoint is smaller. Synthetic cooked Unreal package and pixel fixtures cover all alpha levels, colour interpolation, clipped edges, mip boundaries, truncated blocks and output budgets.
Unity RGB9e5 textures RGB9e5Float textures unpack shared-exponent RGB and use the existing linear-to-sRGB display conversion with opaque alpha and Unity row inversion. Synthetic serialized Texture2D and pixel fixtures cover shared exponent/channel order, comparison with RGBAFloat, zero and finite maximum encodings, mip length, truncation and output limits.
Unity RG32, RGB48 and RGBA64 textures Decode two, three or four unsigned 16-bit channels through the bounded first-mip pipeline, quantizing each channel to RGBA8 with nearest rounding. Missing blue is zero; missing alpha is opaque. Six synthetic unity_unorm16_textures regressions cover names/sizes, unsigned boundaries, little-endian channels, alpha, row inversion, truncated input, output budgets, trailing mips and serialized Texture2D fixtures.
Local PAX sizes Invalid nonempty size overrides stop the TAR listing before the affected member. Earlier members remain readable; decimal, zero and empty overrides keep their behavior. Seven malformed sizes and four valid controls; native bsdtar 3.8.9 diagnoses negative and overflowing sizes.
TAR PAX size precedence A valid local or global PAX size determines the member extent even when the overridden size field is unreadable. Metadata records still use their own lengths. Fixtures cover local and inherited overrides, a zero override, invalid unoverridden size fields and boundaries of following members.
Old GNU sparse TAR listings Skip sparse map blocks before the stored extents so later archive members remain readable. Sparse reconstruction stays unsupported. Regressions cover zero, one and two extension blocks, plus a truncated extension.
CRC cpio symlink checksums Zero-checksum symbolic links keep their targets without a false damage warning. A nonzero link checksum and all regular-file checksums are still checked. Fixtures cover GNU-style links and incorrect stored checksums.
Global PAX archive attributes TAR members inherit global paths, link targets and stored sizes until replaced or deleted. Per-member PAX values take precedence; metadata headers keep their own lengths. Global sparse attributes keep unsupported stored extents out of regular files. Global records use the existing framing, name and record limits; a 64 MiB inherited-name copy budget retains a partial inventory and refuses engine installation before writes. Ten original global/local/deletion/framing/sparse/budget regressions, including nine failures against the unchanged reader, plus three copy-budget controls and an installer preservation regression. Native GNU tar confirms global inheritance, deletion and precedence over GNU long names on generated archives; existing local-empty-value behavior is preserved.
Unity R16 and RG16 textures R16 exports unsigned 16-bit samples as normalized grayscale; RG16 exports two eight-bit red/green channels with blue zero and alpha opaque. Both use the existing bounded first-mip pipeline. Synthetic unity_integer_textures regressions (4 tests): Unsigned extrema and quantization boundaries, red/green channel order, Unity row inversion, first-mip length, truncated pixels, zero/huge dimensions and output budgets. Format checks and compatibility gates passed at 540b4947aa1b.
Unity EAC textures EAC_R, EAC_R_SIGNED, EAC_RG and EAC_RG_SIGNED decode their 11-bit channel values before display quantization. Single channels appear in grey; dual channels use red/green with blue zero. Signed values map -1..1 to 0..255. Seven synthetic regression groups cover specification-derived pixel values, all modifier tables and selectors, signed bases, clamping, channel order, clipped edges, mip/output limits and complete Texture2D objects. All seven fail on the original reader.
Unity ETC1 textures ETC_RGB4 decodes individual and differential blocks with both subblock orientations, all modifier tables and Unity row order. Invalid differential base colours are rejected; clipped edges and output budgets use the shared pixel pipeline. Seven original synthetic cases cover selector planes, all tables, signed deltas, colour clipping, edge blocks, first-mip limits, malformed blocks and a serialized Texture2D object.
Unity floating-point textures The PNG exporter reads RHalf, RGHalf, RGBAHalf, RFloat, RGFloat and RGBAFloat. RGB is converted from linear light to 8-bit sRGB, alpha stays linear, and scalar textures are shown in grey. Synthetic half- and full-precision textures cover every channel layout, short mips, row order, non-finite values and clipping.
Unity sounds game_unity_asset_export saves an AudioClip (Unity 5 and later) from the .resource file it's stored in, beside the serialized file or inside the bundle. An FMOD bank (FSB5) holding one 16-bit PCM sample in mono or stereo becomes a WAV; other codecs (Vorbis, ADPCM…), other PCM, more channels or samples, and banks this doesn't read (another version, a sample header with bit 6 set, which readings of the format disagree on) are saved as the bank, with a stored_as_is limitation. The output gets .wav or .fsb to match. A clip whose fields don't end where its object does is refused as a layout this doesn't know; banks of over 65,536 samples and sounds over 256 MiB are refused. Synthetic clips for Unity 5.6 to 6000.0, banks with stereo, a channel and a frequency chunk, two samples, 24-bit PCM, short data and broken headers, and the export from an .assets file and from a bundle. On three installed games every AudioClip in every serialized file was saved: Unity 5.6.7 (302: 100 WAV, 202 Vorbis banks), 2019.4.19 (99 Vorbis banks) and 2022.3.43 (368: 7 WAV, 361 Vorbis banks); each WAV's length agrees with its clip's within 0.1 ms in ffprobe, and each bank is whole. Not run on a bundle from a real game, an FSB5 version 0 bank or a big-endian file.
Check Unity bundle blocks against their declared output lengths Unity bundle pieces must match their declared decoded lengths; LZMA must finish within the supplied compressed piece. Synthetic byte fixtures in unity_bundle_decompressed_length integration regressions. Cover stored pieces that are short or long, LZ4 and LZ4HC size mismatches, LZMA with or without end markers, empty and short zero streams, bounded dictionary/output growth, oversized dictionary properties, and truncated or trailing compressed bytes.
Standalone LZMA budgets Check declared output before decoding and bound the internal dictionary to the caller's output budget or the decoder's 4 KiB minimum window. Public standalone-reader regressions cover large declared sizes, oversized dictionary properties, exact/zero limits and a damaged stream that exceeds a small budget before its tail. Verified source 5da8880d: formats tests, fmt and clippy; layers, locks, secrets, wasm and unchanged Cargo.lock; unchanged-code regression failures.
Unity LZ4 match expansion Long overlapping LZ4 matches copy the repeating run in growing blocks. Exact output against liblz4 1.9.4 fixtures and release-mode timings on three four-MiB inputs.
Unity stored block range reads Uncompressed blocks are read directly for the requested range, allowing small metadata and object reads from blocks larger than the index memory limit. Stored size mismatches remain errors; compressed blocks retain their existing cache. Original synthetic sparse files with a 512 MiB + 1 byte stored block exercise public bundle and object listing with members at the beginning and end. Small ordinary/mismatched-size controls and repeated ranges across stored/LZ4/stored blocks preserve existing behavior. No Unity Editor or real game bundle was run.
Firmware ZIP extents Stored nested ZIPs keep their outer archive boundary, member paths and following siblings. End records must match the same archive start, including ZIP64 records and their extensible data. Eight formats regressions cover nested archives, payload markers, prefixed firmware, adjacent archives, comments, directory signatures, ZIP64 and the truncated first-member fallback. Three real-engine regressions check region listing, nested extraction bytes and parent paths, and adjacent archive extraction.
ZIP member detection APK sniffing uses the archive's central directory, ignoring names inside nested archives and comments. Search retains only the matching entry. Four public-helper regressions cover nested ZIPs, archive comments, missing end records, actual manifests and prepended stubs. A Python zipfile-generated nested archive confirms the outer member list contains only the backup.
ZIP directory attributes Read the DOS/Windows directory bit and Unix directory file type even when the ZIP name has no trailing slash. Regression cases added: DOS, NTFS and Unix directories with regular-file and symlink controls.
Recognize macOS and VFAT ZIP entry attributes Recognize Unix file modes from macOS ZIP hosts and the DOS directory attribute from VFAT hosts, preserving directory and symlink identity without a trailing slash. Regression fixtures cover macOS directories, regular files and symlinks, VFAT directory and file bits, and unsupported-host controls.
ZIP bzip2 and XZ members Extract methods 12 and 95 with the existing pure-Rust decoders, output limits, declared-size checks and CRC verification. Full ZIP fixtures carry known-good bzip2/XZ streams; controls cover damaged data, understated sizes, limits, CRC mismatches and encryption. Verified source 4cac3638: formats tests, fmt and clippy; layers, locks, secrets, wasm and unchanged Cargo.lock; unchanged-code regression failures.
Legacy Zstandard ZIP members Methods 20 and 93 use the same bounded Zstandard decoder. Firmware discovery recognizes both IDs. Full ZIP fixtures cover extraction, limits and archive discovery.
ZIP Unicode member names Names in valid Info-ZIP Unicode Path extra fields are used when the legacy filename checksum matches and the main UTF-8 flag is clear. ZIP parser controls for a valid override, stale checksum, unknown version and UTF-8 flag precedence.
ZIP LZMA members Decode method-14 property headers and select size-delimited or end-marker decoding, with bounded dictionaries/output and existing size/CRC checks. Generated ZIP fixtures exercise both framing modes, zero literals, corrupt/truncated/trailing data, output limits and oversized dictionary properties. Verified source 61fdab39: formats tests, fmt and clippy; layers, locks, secrets, wasm and unchanged Cargo.lock; unchanged-code regression failures.
Locate Unity bundle metadata within the declared bundle size Unity bundle metadata placement respects the declared bundle extent. Synthetic byte fixtures in unity_bundle_declared_size integration regressions. Cover versions 6 through 8, front and trailing tables, padding, appended bytes, invalid extents, and header-only prefixes of larger bundles.
Keep Unity bundle blocks inside the data region The shared table parser refuses compressed block totals crossing the trailing table or the declared bundle end before listing or extraction can read block contents. Synthetic unity_bundle_data_region regressions cover versions 6–8, both table positions, data alignment, appended bytes, cumulative sizes above 32 bits, exact fits, spare bytes and empty blocks. No real game bundle was run for this correction.
Unity bundle member ranges The shared directory reader marks invalid member extents with range_valid: false while preserving directory entries and valid siblings. Bundle listings disclose skipped ranges; object listings preserve partial coverage, and explicit reads or exports from invalid members are refused. Member metadata and reads retain node identity when names repeat. Cross-block members, aliases, empty end ranges and streams above 4 GiB remain supported Six original header/table regressions cover invalid extents, mixed valid/invalid entries, empty block lists, valid boundaries and 64-bit totals without allocating advertised large contents. Six public Engine regressions cover recovered member/object listings, complete directory versus partial object coverage, metadata limits, duplicate names, valid streamed PNG export and rejection of invalid members or streams
Unity serialized metadata ranges Metadata reads require a complete declared metadata range within the file and before object data. Short inputs and impossible public Header ranges return errors. Synthetic unity_metadata_range regressions (4 tests): Every prefix before the metadata end, shortened declared metadata, arithmetic overflow and impossible public Header ranges, plus equality of full-file and exact-prefix results. Format checks and compatibility gates passed at de9d7444f509.
Reject Unity serialized objects outside their declared file Unity serialized object ranges must fit the declared file. Synthetic byte fixtures in unity_serialized_object_ranges integration regressions. Cover offset and end overflow, ranges crossing the file boundary, both byte orders, valid existing objects, and empty objects at EOF.
Unreal packed textures PF_A2B10G10R10 preserves normalized 10-bit RGB and two-bit alpha. PF_FloatR11G11B10 widens unsigned packed floats into the shared half reader before sRGB display conversion, preserving Unreal row order and the common bounds. Five cooked-package/pixel groups cover channel order, every alpha level, explicit float pixel values, subnormal and nonfinite inputs, row order, mip selection and budgets. A numeric unit test checks exact subnormal/normal boundary values before display quantization. All five public groups fail on the original reader.
Unreal floating-point textures Cooked R16F/G16R16F/FloatRGBA and R32_FLOAT/G32R32F/A32B32G32R32F textures export through the shared float decoder. RGB becomes 8-bit sRGB, alpha remains linear, and values outside the display range are clipped. Synthetic unreal_float_textures regressions (4 tests): Cooked package fixtures reaching all six channel layouts, filtered aliases, negative/non-finite values, alpha behavior, stored row order, short mips, zero/huge dimensions and output budgets. Format checks and compatibility gates passed at 75b507c0b96f.
Preserve compression method slots in Unreal pak indexes PAK compression names retain their original method numbers. Synthetic byte fixtures in unreal_pak_compression_slots integration regressions. Cover interior and leading empty slots in plain and packed indexes, plus unchanged contiguous method tables.
Require complete terminators in Unreal FString values PAK and IoStore strings require complete terminators. Synthetic byte fixtures in unreal_fstring_terminators integration regressions. Cover missing ANSI and UTF-16 terminators, zero-length strings, terminated empty strings, Unicode names, and the shared IoStore path.
IoStore directory references Missing name or chunk references are diagnosed instead of producing a placeholder path or a zero-byte asset. Altered directory and file entries at three listing limits.
Count every compression block spanned by an IoStore chunk IoStore stored-size totals include every block touched by a chunk. Synthetic byte fixtures in iostore_unaligned_chunk_blocks integration regressions. Cover unaligned chunks spanning two or three blocks, aligned chunks, exact-boundary endings, and empty chunks.
Reject truncated IoStore fixed headers IoStore parsing rejects incomplete fixed headers. Synthetic byte fixtures in iostore_complete_header integration regressions. Cover every truncation in the reserved header tail and complete fixtures for the supported header versions.
Reject invalid marshal long integer digits Python marshal long integers reject invalid digit encodings. Synthetic byte fixtures in pyc_long_limb_validation integration regressions. Cover positive and negative invalid digits, leading zero digits, canonical zero, ordinary integers, and valid large integers.
Python bytecode header flags Undefined modern header flag bits are retained and reported as warnings. The defined low bits still select timestamp, unchecked hash or checked hash invalidation, and readable code, names and constants remain available. Synthetic fixtures cover every undefined bit with all four defined combinations and both supported code layouts, compare the complete code inventory with clean headers, and retain header-only reports for unsupported layouts and unknown releases. A public-tool regression checks that the warning is also a parse-warning limitation alongside the recovered names and constants. Defined flags and legacy timestamp words remain unchanged; input bytecode is not executed.
Python 3.5.0 to 3.5.2 compiled files A .pyc with magic number 3350, which Python 3.5.0, 3.5.1 and 3.5.2 wrote, is a 3.5 release (is_release: true), not a pre-release; 3.5.3 and later wrote 3351. A 3.5 file is still read up to its header only. Unit test with 3350, 3351 and the 3.5 beta number 3340. The magic number of every CPython release tag from 2.5 to 3.14 (251 tags) was read from its source; 3.5 is the only line with two. The output for 27,890 real .pyc files from Python 3.8 to 3.14 is unchanged.
Check expanded RGBA image sizes before allocation Pixel decoding checks expanded RGBA size, applies a caller-selected output budget (256 MiB by default), and reserves output fallibly. Packed 16-bit layouts decode without an intermediate image allocation. Synthetic byte fixtures in pixel_rgba_output_overflow cover budget rejection before source access, exact output limits, caller overrides, overflow, ordinary and packed pixels, partial blocks, empty pictures, and truncated input. Large-dimension checks use empty source data; a 32-bit expansion-overflow regression is included.
Safetensors header and payload coverage Reports non-string metadata, oversized headers, invalid packed tensor lengths, overlapping ranges, gaps and unclaimed trailing data. Duplicate tensor names, descriptor fields and metadata keys are rejected before they can overwrite earlier evidence. Summary text uses the same bound as the metadata view. Header-only fixtures retain reordered and empty tensor controls. Duplicate-key regressions fail on unchanged main and pass with the correction, including escaped equivalent names; distinct objects may reuse field names and other invalid metadata retains its existing diagnostics. Linux formats tests, strict clippy and portability checks pass. No model inference was run.
GGUF identity uniqueness Repeated metadata keys and tensor names are rejected before metadata projection or parameter totals can become ambiguous. Identity uses complete borrowed bytes, independently of display truncation and retained-entry limits. Five regression groups cover both byte orders, duplicate model names and architecture keys, tensor totals, long shared prefixes, duplicates after the retained metadata cap, distinct names and incomplete headers. Four groups fail on the original reader.
Count empty tensor shapes consistently across axis orders Zero-sized tensors have zero elements regardless of dimension order. Synthetic byte fixtures in tensor_zero_dimension_product integration regressions. Cover zero-dimension permutations in safetensors and GGUF, scalar shapes, nonempty tensors, and shapes with genuine multiplication overflow.
APK signed metadata Overall signer verification requires complete required fields, identical ordered signature/digest algorithm lists, and matching signed/unsigned SDK ranges for v3/v3.1. Recovered or capped metadata cannot stand in for the complete signer; primitive signature and content-digest results remain visible with the reason verification is incomplete Genuine RSA APK fixtures cover SDK mismatches, stripped/added/reordered algorithms, partial lists and records, skipped certificates, missing attributes, trailing signer bytes and the 64/65-entry boundary. Complete v2/v3/v3.1 signers retain matching unknown algorithms and attributes
Find APK signatures through valid ZIP comments APK signing-block lookup validates EOCD framing and central-directory bounds, prefers recoverable signers over empty or unreadable decoys, and warns when distinct readable signing blocks remain ambiguous. Directory, pair and signer probes share a scan-wide record budget; bounded caches reuse directory prefixes and physical pair and signer records while checking each candidate’s own extent. Comment-boundary regressions cover nested empty, unknown and unreadable blocks, a fully framed spanning pair, ambiguous readable blocks, empty signed ZIPs and thousands of candidates sharing the genuine directory. Existing damaged-block recovery and directory-framing tests remain; unit tests cover probe recovery, parser limits, directory-cache isolation, optional tails, repeated signer probes with shorter and longer bounds, and work/cache exhaustion.
UTF-16 keyed-archive NIBs The format detector recognizes either UTF-16 byte order after its BOM, so valid XML NIBs reach the existing plist and keyed-archive decoders. The bounded probe respects code-unit alignment and borrows its input. Little- and big-endian XML archives retain the same Unicode text, objects, classes and references as their binary equivalents; exact scan boundaries, misaligned data and existing UTF-8/binary controls are covered.
NIB retained object bytes Copies of shared NIB data, keys and class names spend a common byte budget of 64 MiB or three times the input size, whichever is larger. Unused value-table keys remain indices; skipped value copies and stopped object lists report budget exhaustion. Separate shared-data, shared-key and shared-class fixtures below 48 KiB previously retained more than 64 MiB each (128 MiB for the data fixture). All now stay within the byte budget; an ordinary shared-value document remains complete.
Certificate issuer selection A matching name selects an issuer only after its key verifies the signature. Same-name key rollover can reach its actual issuer. Only a verified self-signed top completes a chain; cycles are distinguished from the 16-link walk limit Genuine signatures with same-name wrong-key decoys, both candidate orders, a self-issued rollover, missing issuers, 2- and 16-certificate cycles, a root at link 16, a chain beyond 16 links, and the 64-certificate candidate boundary
X.509 subject and issuer names The certificate reader escapes literal separators and displays attributes of a single relative distinguished name together. Synthetic certificate with comma and plus characters, and an encoded two-attribute RDN.
Non-minimal ASN.1 length encodings The reader retains definite-length elements with redundant encodings and marks them on each TLV. Certificate, CMS, PE, Mach-O, JAR and Android views retain readable facts with a not-strict-DER note; a bounded structural walk is not a full DER validator. Short/long boundaries, zero and multi-octet lengths, outer and nested certificate/CMS elements, unchanged genuine signatures, PE reports with and without encapsulated content, and bounded nesting.
EC public-key curve binding ECDSA verification uses the complete named-curve parameter in SubjectPublicKeyInfo. Missing, malformed, extra or unsupported parameters cannot select a supported curve by point length Genuine P-256 signatures with misleading curve declarations and malformed parameters; valid compressed and uncompressed P-256/P-384 controls and tampered messages
RSASSA-PSS parameters Certificate and CMS verification use declared SHA-2 hashes and salt lengths, compare signed/outer certificate parameters, and enforce PSS key restrictions. Defaults are decoded; SHA-1 and differing message/MGF1 digests remain explicitly unsupported. Malformed CMS parameters preserve readable signer metadata Genuine RSA signatures covering SHA-256/384/512, zero and non-default salts, parameter disagreement, restricted/unrestricted keys, defaults, equivalent digest identifiers, malformed parameters and detached CMS with/without attributes
NIB variable-length integers NIB lengths and indices reject tenth-byte payload bits outside the unsigned 64-bit range instead of truncating them into smaller values. All overflowing terminal payloads, the full unsigned range, unterminated values, and complete NIB fixtures with overflow in each variable-length field.
CMS signer identity Match issuer/serial or subject key identifiers before attributing a signature or ordering its certificate chain. An absent match remains unknown. A mismatched SignerInfo version or empty serial is disclosed without losing readable certificates and algorithms. Genuine RSA signatures with matching and mismatched identities, a later matching certificate, absent/malformed/duplicate key-identifier extensions, critical-flag encodings, inconsistent identifier versions and empty serials.
Keep Mach-O load-command facts within their command Mach-O command facts stay inside their declared command boundaries. Synthetic byte fixtures in macho_load_command_framing integration regressions. Cover undersized build commands, a shortened command region, tool entries spilling into the next command, truncated section arrays in both parsers with later complete commands preserved, and complete commands in both byte orders.
Mach-O load-command path termination Malformed command paths stay out of both binary and dependency summaries. Later valid commands still read. Binary fixtures cover dependency names and runpath commands in both views.
Mach-O thread-state entry points UNIXTHREAD records are delimited by their declared word count. An entry point comes only from a complete supported state matching the image CPU, including a later state record. Short and truncated states, mismatched CPU flavors, later matching records, and complete i386, x86-64 and arm64 controls.
Mach-O virtual sections File-data lookup distinguishes ordinary sections from the three zero-fill section types. Native Mach-O parser and byte-reader tests with zero-offset zero-fill sections and an ordinary embedded plist.
Keep Mach-O function starts within their declared payload Mach-O function-start deltas stay within their payload and cannot wrap addresses. Synthetic byte fixtures in macho_function_starts_payload_boundary integration regressions. Cover a continuation byte at the payload end, retained complete deltas, address overflow, and valid multibyte deltas with a terminator.
Mach-O indirect-symbol work budget Pointer and stub sections share one image-wide indirect-index budget. Local and invalid indices count as inspected work; omitted slots produce a limit warning. Repeated table references across sections, local and invalid indices, and small/exact-budget controls.
Source map position deltas Decode the reserved signed minimum correctly, reject magnitudes past the 32-bit range and accept zero-extension groups without overflowing shifts. Regression cases added: Signed limits, numeric overflow, redundant zero groups and accumulated generated positions.
Keep code-signature children within their declared superblob Code-signature metadata and engine verification reads stay inside the declared superblob. Stored page and special-slot hashes also stay inside their own CodeDirectory; invalid relative offsets leave them unchecked. Declared special slots whose stored hashes cannot be read remain visible as not-checked with stored: null. Synthetic codesign_superblob_length_boundary regressions cover an external CMS blob, a cut index, a short header, and a complete signature. Engine signature regressions keep appended entitlements and stored page hashes out of verification, with complete-signature and genuine CMS controls. An engine regression covers all five reported special-slot identities with unreadable stored hashes. Engine regressions also cover stored hashes past a CodeDirectory but inside the superblob, and special-slot offsets before the CodeDirectory.
CMS signed-attribute binding SignedData signed attributes require one OCTET STRING message digest and one OBJECT IDENTIFIER content type matching EncapsulatedContentInfo. Duplicate, multi-valued and incomplete attribute structures retain readable certificates, signer and algorithms but report failed authentication with a concrete reason Genuine RSA signatures over malformed attributes previously returned authenticated=true. Regressions cover required tags, cardinality, type binding, complete framing and retained metadata, including simultaneous signer-identity notes and malformed-attribute reasons in both verification reports; valid unknown attributes and direct detached signatures remain supported
Code-directory flag names code_directories[].flag_names use the bits and names codesign -d shows (hard, kill, expires, restrict, enforcement, library-validation, runtime, linker-signed, host, adhoc) Unit test against codesign's output for each flag; flag values of the signed Mach-O files on a Mac compared with codesign -d
Keep PE optional-header reads within the declared header PE optional-header reads respect the declared header size. Synthetic byte fixtures in pe_optional_header_framing integration regressions. Cover short fixed headers, partial directory entries, zero or one directory in both PE variants, and unused bytes before the section table.
Bound the .NET PE reader to the declared optional header dotnet::pe::parse_pe reads the optional header through its declared size, so data directory 14 cannot come from section-table bytes; a short header is refused as truncated before any CLI directory is read. Synthetic managed-assembly regression shortens SizeOfOptionalHeader to 96, moves the section table into the directory area and leaves the old CLI-directory bytes; it fails on the former reader. Fixed fields of 0, 2, 70 and 95 bytes and the valid sample are covered too.
Firmware PE carve optional header The firmware carver includes a PE certificate table only when data directory 4 lies inside the declared optional header, and reads SizeOfHeaders only when the fixed fields are declared, so a short header cannot borrow section-table or padding bytes to over-carve into the next object. Synthetic PE32 and PE32+ fixtures declare only the fixed optional header (or less) with a large SizeOfHeaders and certificate bytes past it; a full-header control still extends the region. The short cases fail on the former carver.
PE import directory boundaries Normal imports follow complete descriptors through their terminator within the selected file mapping; a zero or short declared size produces a warning without hiding imports. Delay-load and bound import metadata also stay inside their declared directories. Incomplete records are reported; separately addressed normal and delay import names remain readable. Zero and short normal-import sizes, partial descriptors, bound forwarder/name boundaries, selected-section extent, valid external names and the existing 200,000-row cap. A module containing 32 invalid forwarder names produces one diagnostic while remaining truncated. The shared retained-text budget also covers bound names and forwarders.
Bound PE import name terminators Bound module and forwarder names require a NUL byte inside the declared directory; an unterminated field remains incomplete instead of borrowing its terminator from following bytes. Synthetic 31- and 39-byte directory boundaries retain valid preceding names and reject the unterminated field.
Fixed PE version value bounds File and product versions are published only from a complete declared binary VS_FIXEDFILEINFO value inside its version node. Adjacent bytes cannot supply missing fields; independent string tables remain readable. Six regressions cover absent, short, overdeclared and physically cut values, node boundaries, wrong value types, complete/extended values and retained string tables; five fail on the original reader.
PE header addresses Import and resource lookups stop at SizeOfHeaders when an address falls outside every section. PE header and section boundary regression with a gap before the first raw section.
PE address-space boundaries Entry points and import slots that exceed the PE32 or PE32+ address space remain unknown, and invalid exception function starts are omitted. A rejected slot stays unknown through final binary enrichment. PE32/PE32+ image-base overflow, IAT indices crossing the RVA limit, delay imports, exception records, same-named mixed valid/invalid slots and high valid addresses.
Keep PE resource metadata within the resource directory PE resource metadata stays within the declared directory and the contiguous range selected by the existing RVA mapping, including raw extents, section priority, header-prefix boundaries, and 32-bit address limits. Resource names must fit their full declared UTF-16 span before the existing 4096-unit output cap is applied. Synthetic byte fixtures in pe_resource_directory_boundary integration regressions. Cover escaping subdirectories and names, partial data-entry records, a valid resource whose payload is addressed separately from its metadata, complete versus directory-truncated names above the output cap, names crossing a section's raw extent with the resource root at its start or inside it, metadata in the header prefix, mapping changes caused by section priority, zero-extent and lower-priority controls, and the end of the RVA address space.
PE export work and alias budgets Empty function slots count toward the scan limit, and aliases share the export output limit with ordinal-only entries. Omitted work is reported as truncated. A sparse table with a function beyond 200,000 slots, a large alias list after an ordinal-only export, and a small complete-table control.
Certificate verification inputs Read the algorithm OID only at the start of its sequence, require octet-aligned nonempty keys and signatures, and check the issuer and subject name tags before linking certificates. Regression cases added: Field mutations on generated certificates and public keys, and an out-of-order algorithm identifier.
Certificate signature OID agreement The signed and outer signature-algorithm OIDs must agree before a certificate supplies verification inputs. Malformed signed algorithm fields are rejected. RSA NULL and absent parameters remain accepted Genuine RSA signatures over conflicting and malformed signed algorithm fields, both v1 and v3 certificate layouts, and all NULL/absent combinations for matching SHA-256 OIDs
Go package counts for generic functions The package name comes from the declaration, also when an instantiated type names a different import path. Parser regressions for a function and a generic receiver.
Go referenced function names Retained name bytes have a 64 MiB or three-times-table-size budget across every supported pclntab layout, including UTF-8 replacement expansion. Recovered functions keep their addresses; omitted names produce truncated coverage and a specific budget warning Shared-name regressions for Go 1.2, 1.16, 1.18 and 1.20, lossy names, coexistence with unreadable-name warnings and small complete controls. A 4,817,160-byte synthetic ELF with 100,000 references completes public inspection under a 128 MiB address-space limit
Go partial function tables Keep complete functions before a later unreadable record or overflowing address. Any omitted declared function, including unreadable names, marks the table as truncated. Go 1.2, 1.16 and 1.20 layouts with a damaged or truncated second record; address overflow; name omissions and the warning limit; public ELF inspection and function extraction. Existing section-boundary regressions remain in place.
Keep Go function tables and names within their section Go function tables and names respect every containing file-backed section during scan recovery, including unnamed and overlapping sections. Recovery outside known sections keeps the whole-file extent. A named table with no readable functions allows bounded recovery while retaining its partial evidence if no replacement is found. Synthetic byte fixtures in go::tests unit regressions. Cover Go 1.16 and 1.20 table entries, unterminated names, public inspect()/functions() recovery from truncated or empty named sections and interior headers, unreadable named tables with or without a readable interior replacement, unnamed entry/name boundaries, overlapping or expired extents, and recovery outside known sections or without section headers, with complete-table controls.
Padded CLI signature blobs Method, property, field, local, method-instantiation and standalone TypeSpec readers retain decoded types with trailing bytes and report a warning through assembly, member and native-boundary views. Managed tools carry the warning as a limitation. The application graph merges all three views' warnings, preserving their leading diagnostics and deduplicating before the display cap. Nested function pointers remain incremental. Regression groups cover all complete entry points, trailing-byte variants, malformed prefixes, empty locals, TypeSpecs, nested parameters and incremental type reading. A generated assembly with padded signatures retains member types, local types and call targets while exposing the warning in public views and tool results. Graph regressions cover an attribute-only signature note and combine repeated signature notes with 25 distinct native-mapping warnings under one display cap.
Application graph caps An application graph counts the unique edges its 4 × max_nodes cap drops, records an edge_cap limitation beside node_cap, and js_app_map marks coverage partial when either cap cut the graph. Analysis regressions cover a dense graph (16 mutually importing modules, edges capped at 4 × max_nodes) and a graph within both caps; engine regressions check partial coverage and the edge_cap/node_cap limitations.
Application graph import facts js_app resolves every import ModuleFacts retained (up to its per-file list limit) instead of the first 2,000, and aggregates every truncated list into one facts_truncated limitation naming the kinds and the number of files; js_app_map marks coverage partial when facts were cut. Analysis regressions cover a dependency reached only past 2,000 imports and a 5,001st import cut at the facts limit; an engine regression checks the limitation and partial coverage. The capped cases fail on the former code.
Preserve complete Unicode characters in shortened .NET strings .NET user-string limits preserve supplementary Unicode characters. Synthetic byte fixtures in dotnet_user_string_surrogate_limit integration regressions. Cover supplementary characters at several limits, a zero-character limit, and unpaired surrogates followed by valid characters.
CIL branch destinations Relative branch and switch destinations must lie inside the method body and cannot wrap through a negative displacement. An invalid destination stops decoding before that instruction, retaining the valid prefix. Five regression groups cover short and long branches, signed extremes, partial switch validity, backward and forward controls, truncated operands and instruction budgets. Three invalid-destination groups fail on the original decoder.
CIL exception section framing Method exception handlers come only from the defined exception-table section kind, a complete declared section, and whole clause records. Unknown section kinds are diagnosed and skipped while linked sections remain readable. Six synthetic small/fat section regressions cover valid handlers, unknown kinds, cut headers, truncated declared extents, partial clauses and a following valid table. Five cases fail against the original parser. No managed program was executed.
CIL nonfinite method fingerprints Normalized CIL hashes distinguish positive infinity, negative infinity and NaN bits instead of serializing every nonfinite operand as null. Single-precision NaNs retain their original bits before widening; decoded values and JSON output stay unchanged. Nine bytecode regressions cover both precisions, signaling/quiet NaN collisions, payload/sign distinctions, fixed fingerprints, numeric display, JSON compatibility and finite instruction equality. Finite and infinity encodings retain their existing hashes. No managed program was executed.
ELF dynamic library names Needed libraries and dynamic path names stay within DT_STRSZ when the executable declares it. An ELF64 fixture moves the bound to the beginning and to the terminator of a needed library name.
ELF dynamic symbols with partial section tables PT_DYNAMIC supplies imports and exports when retained section headers omit usable dynamic symbols. Retained ordinary symbols stay available and matching facts are not duplicated. ELF32 and ELF64 in both byte orders, retained local and duplicate symbols, and a complete dynamic-section control.
sBPF global table limits Symbol and relocation output stops at the existing 400,000-record limit across repeated ELF tables, preserving earlier records, order and null-symbol handling. Seven synthetic ELF regressions cover repeated SYMTAB/DYNSYM and REL/RELA tables, exact limits, null/empty tables and smaller inputs. Three over-limit cases report 400,001 records before the fix; all seven pass afterward, together with existing symbol-framing and Solana tests.
Locate ELF core mapping names after the complete declared table ELF core filenames follow the full declared mapping table. Synthetic byte fixtures in elf_core_file_name_count_cap integration regressions. Cover 65,537 declared mappings with capped output, an impossible declared table, and a small complete mapping table.
ELF core mapping path cursors NT_FILE mapping paths advance by the original NUL-terminated byte strings, even when the displayed path is lossy or capped. Invalid UTF-8 and long first paths followed by another mapping; valid UTF-8 and unterminated final-path controls.
Keep DOS relocations inside the declared executable header DOS relocation records stay inside the declared MZ header. Synthetic byte fixtures in dos_relocation_header_boundary integration regressions. Cover records extending into the load module, a partial final record, and complete records ending exactly at the header boundary.
DOS extended-header identification The DOS header report recognizes a PE extension only when its complete signature is present, including where the PE header overlaps the DOS header. Fixtures cover truncated and mismatched PE markers, complete signatures at overlapping offsets, and complete PE, NE, LE and LX markers.
ELF symbol-version section bounds Version definitions, requirements and symbol-version indices stay inside their declared section byte ranges. Both byte orders with escaping auxiliary records and indices, plus complete version-table controls.
Java constant-pool slots Long and Double constants must fit their two declared pool slots; impossible final-slot entries return a malformed-format error without overflowing the cursor. Synthetic java_constant_pool_slots regressions (4 tests): Long and Double entries at ordinary and maximum u16 boundaries, valid two-slot tail entries, ordinary constants and an existing class fixture. Full Linux gate passed at e0dbc3a5b60b.
Preserve encoded identity in certificate name values Decode complete BMPString and UniversalString values, legacy TeletexString as Latin-1 and the supported ASCII name strings; retain malformed or unknown values as hexadecimal DER instead of lossy text. Regression fixtures cover universalString characters, valid BMP/UTF-8 controls, odd BMP widths, surrogate and out-of-range code points, invalid UTF-8 and non-string values.
Java attribute-name storage Attribute readers borrow their shared constant-pool names at class, field, method and Code scope; repeated unknown attributes no longer allocate another copy of each name. Known attributes remain intact in all four scopes. Four original fixtures below 100 KiB each abort the prior reader under a 128 MiB process address-space limit and pass after the change; unrestricted native test-process peak RSS falls from about 258 MiB to 6 MiB. The four memory regressions are ignored in ordinary runs and were each run separately with the limit; no JVM was executed.
Java class attribute table coverage Class files with incomplete attribute counts, headers or bodies now report the incomplete table. Complete attributes preceding it remain readable. Byte fixtures cover missing counts, truncated class-level attribute bodies, and complete class attributes and unknown-attribute controls.
Trace JVM bootstrap dependencies at their bytecode use sites Connect class literals, method types, method handles and dynamic bootstrap arguments to their actual load or call instruction, with a shared linkage-work limit. Regression fixtures cover literal classes and method handles, array components in method types, invokedynamic factories and arguments, dynamic constants and unused-bootstrap controls.
JAR manifest attribute bytes Unfold continuation bytes before decoding UTF-8, preserve value whitespace and recognize CR, LF and CRLF. Orphan continuations cannot remove section boundaries. A filename with a UTF-8 character split at byte 72, whitespace-sensitive entry digest checks, all three and mixed newline forms, and orphan continuations at the start or after a section.
Repeated JAR manifest entry sections Integrity checks merge digest attributes for each exact entry path, with later values overriding the same attribute. Missing attributes retain earlier values, digest preference is preserved, and each file is read and counted once Genuine CMS signature and whole-manifest digest over repeated sections, valid/invalid later overrides, missing later digests, mixed algorithms, case-insensitive attribute names and case-sensitive file paths
Java decompilation java_vineflower_decompile decompiles a real JAR to source with the pinned Vineflower 1.12.0, run through the configured Java Live run on Linux x86-64 (OpenJDK 21.0.12.1) against Apache Commons IO 2.16.1 (497 KB, 374 entries): 253 source files, exit 0; org.apache.commons.io.FileUtils returned 1,350 lines with the class and its file-reading methods present. The engine install matched the pinned SHA-256. Not checked: Windows and macOS, a .class input, or a second JAR
JVM switch payloads Both switch decoders require their full payload before reserving pairs. Dense-table counts cannot narrow across the pointer-width boundary, and lookup keys must increase in signed order. Invalid tables stop method decoding with partial coverage. Duplicate/descending keys, signed extremes, empty lookups, all four alignments, every truncated payload prefix, and oversized or absent tables. A truncated million-pair table aborts the original decoder under a 12 MiB process address-space limit; the fixed decoder returns normally for both switch forms.
JVM array allocation operands Invalid newarray primitive type codes and zero-dimensional multianewarray instructions stop decoding with partial coverage, retaining the valid prefix. Four regression groups cover every primitive type byte, all nonzero dimension bytes, nonzero instruction offsets and truncated operands. Two fail before the correction. Constant-pool type/rank verification and JVM execution were not added.
Conversation width Agent paragraphs, inline code and fenced code stay within the message column, including glossary terms followed by long file links (#523) UI regression checks painted text and subsequent answers against the composer bounds in Project and Ask at 1920 × 1032 and 1280 × 820; Unicode/formatted glossary hover check
Settings saved on exit Pending app settings merge the session's latest AI table when its guard is available. A busy session defers non-AI edits in config.pending.toml without waiting for the tool; startup recovers them with the latest committed AI table Isolated child-process regression exercises idle and busy exit saves, a late AI commit, startup recovery and pending non-AI edits; engine tests cover sidecar migrations and damaged/newer files. No live desktop shutdown was exercised
Config read at startup A config.toml that can't be read at startup is read again after waits of 100 to 500 ms, 2 s in all, before the session runs on defaults that refuse every save; a missing file, or a folder in its place, isn't waited for. Edits deferred at the last exit are merged only once the file could be read; until then they stay beside it. Other reads of the file (a build's AI settings, the model tools) don't wait. Unit test of the waits with an injected read; on Unix, a file without read permission that becomes readable on the third try loads its settings (without waits it stands in with defaults as before), and deferred edits are kept while it stays unreadable and merged once it isn't. Not run on Windows with a file held by another program.
Atomic-write temporary files Reserve short temporary names distinct from the destination and its filename aliases, with exclusive creation and bounded collision retries. Private files have owner-only Unix permissions from creation; cleanup removes only a file reserved by the current write. Original implementation 5f0f1ce2 passed full Linux CI. The review follow-up preserves collision, symlink, inherited-permission, retry-limit and cleanup assertions, and adds a bounded probe for a valid long name, direct creation-permission checks and deterministic destination-alias exclusion checks. 27e5d631 passed full Linux CI.
SQLite b-tree completeness Null, cyclic, reused, missing or wrong-kind children leave row counts as lower bounds and row reads marked incomplete. Readable siblings survive, and traversal limits or skipped rows are disclosed. Synthetic table and WITHOUT ROWID regressions cover both child positions, reused leaves, missing pages, page kinds and the depth cap; complete-tree order, pagination and empty-leaf controls.
SQLite payload limits Capped records retain column positions, disclose partial TEXT and BLOB values, omit incomplete BLOB hashes, and report partial coverage with read notes Hand-built overflow-page regressions for five oversized records (including WITHOUT ROWID in declaration order) and two controls; table and index engine coverage and limitation regressions
SQLite added columns Short records include missing trailing fields using literal column defaults, or NULL when absent; unsupported default expressions produce NULL with a row note. A default is read with its column's affinity, as SQLite reads it: a TEXT column's DEFAULT 5 is '5', an INTEGER column's DEFAULT '7' is 7, and a BLOB or untyped column (or a STRICT table's ANY column) keeps the literal as written. Bare or double-quoted words are text constants, DEFAULT -'5' coerces a numeric string, and one underscore between digits is a digit separator. A non-integer REAL default uses SQLite's REAL text (1e3 is '1000.0', 5. is '5.0', infinity is 'Inf'). Stored fields and records longer than the schema retain their values. Defaults are filled before restoring rowid aliases Hand-built parser regressions and an engine tool test cover added-column defaults, rewritten records and short records with a rowid alias, including a missing alias field; defaults of every affinity (rowid, WITHOUT ROWID and STRICT tables, UTF-8 and UTF-16le) compared with the official SQLite library on generated files
SQLite primary-key collations Repeated key columns with distinct collations keep their distinct record slots. Identical collations share a slot, and later values stay aligned. Binary row regressions checked against SQLite index_xinfo and SELECT results.
Parenthesized SQLite primary-key columns WITHOUT ROWID row layouts keep the full key list and honor collations on grouped column names. Binary row regressions checked against SQLite index_xinfo and SELECT results.
Ghidra and closing the app Closing the app stops an analysis a build started, and waits for it to end, so java.exe isn't left running (#946). Deleting the project ends the analysis its build started, within seconds; pausing leaves it running, so it isn't lost (#948). An app that crashes or is killed can still leave one (#951). Deep mode doesn't analyse an Electron program's runtime, whose logic is in app.asar (#947) Stopping tested with a waiting analysis, on closing and on deleting the project; not run against a live Ghidra. A Ghidra with no decompiler program for this computer, as public downloads have on macOS, is refused before the analysis starts, with the command that builds one.
Gemini tool calls A tool call's extra_content (Gemini's thought signature) goes back with it unchanged, so Gemini 3 builders get past their first tool call; errors Gemini wraps in an array show their message (#978) Unit-tested; not run against the live API
OpenCode models and thinking OpenCode V2 locally and over SSH; Settings → AI lists only that instance's enabled chat models and supported Low/Medium/High/Xhigh/Max variants. Selection is validated and saved through UI, CLI and ai_models_list / ai_model_set. Explicit selections run natively with the Craft Anything MCP server (local runs, and over SSH: one ssh run checks craft-anything-cli on the host's PATH and writes the config on the host, ~/.cache/craft-anything/, mode 600). Discovery, including the model check before each turn, uses a private server too (--standalone, unless a --server is chosen), so it never starts the shared service that resumes unfinished sessions (#1115). See OpenCode. Stand-in catalogue/process, persistence, remote-command and UI tests; local live catalogue checks (34 models, all five depths represented). Regression checks route explicit selections natively and parse V2 tool events. Live (2026-11-04, Windows, OpenCode 2.2.5, opencode-go/deepseek-v4.1-flash): a --standalone run connected the server (38 tools) and called core_session_show. The SSH path is covered by a POSIX-shell regression test (probe fails fast without the helper; config written byte-exact, mode 600, atomic rename) and was exercised against a localhost SSH host; it has not been run with a live agent over SSH. No paid generation used. Live (2026-11-08, Linux, OpenCode 2.2.5, a local Qwen model): before discovery used a private server, a build's model check started the shared service, which resumed a session left unfinished days before and went on editing another project. Live (2026-11-08, Linux, OpenCode 2.2.5 and 2.2.6, a local Qwen model through an OpenAI-compatible server): "a scientific calculator" reached Ready twice (one run, stopped by its time limit, finished with --resume); our tools reached the builder through 2.x's execute, and it opened its own screenshots and a 3840×2400 reference picture with OpenCode's read tool and acted on what they showed (a key that did nothing; a recoloured icon)
MCP progress notifications Progress is sent only for a tools/call carrying a string or number _meta.progressToken, and before the response; a missing, null, object, array or boolean token gets none. MCP tests cover a missing token, null/object/array/boolean tokens, a string and a number token, and the notification-before-response order. The live OpenCode 2.x warning was not rechecked.
Claude desktop app without Claude Code When the claude command isn't found but the Claude desktop app is (Windows: the Store package's claude-desktop app alias, else its package folder, or the older installer's AnthropicClaude folder; macOS: Claude.app), the builder dialog under "No coding agent was found" and ai detect (on stderr) say the desktop app is installed but building needs Claude Code, installed apart (#259). The hint stays when the only suggestions are unchecked agents from ~/.ssh/config. A claude program inside the desktop app (on PATH) is never offered or started as Claude Code: detection, the hint and a run's program look through one cli_agents::find_program; with only the desktop app there, a run, ai test and the builder check fail with "Claude Code isn't installed" instead of starting it, also when claude (by name or as the desktop app's own file) is the saved program; a link to the app counts as the app, and a name saved on purpose (claude.cmd) that starts Claude Code itself is kept. Typed as DetectHint from AiHub::detect_hints A regression finds the app in temp folders laid out as each Windows installer leaves it, and nothing on Linux; a UI test shows the hint in the dialog, with only SSH suggestions too, and not once an agent here is found; a test passes over the desktop app's claude.exe on a search path, and program_of with the app first, the real one first, a saved path that's gone, and the app alone, and a saved claude by name or as the app's file, a saved wrapper name kept, and a link to the app passed over (links checked where they can be made: not on Windows without the right). On Windows 10 the real Store package's alias was found. Not checked: macOS, the older installer, and a computer with no claude installed
Missing program paths A program started by its path (a saved agent program, for one) that has no file there is reported with that path, as possibly moved by an update, with reason path_missing, instead of "isn't installed or isn't on your PATH"; a bare name still speaks of PATH. A relative path is looked up where the program starts (on Unix, its working folder), so a script there whose interpreter is missing isn't called a path with no file. It stays a missing program (EngineMissing), so builder turns aren't retried (#721). ai test names the agent program it ran and the saved one it replaced (program, saved_program_replaced), and doctor says a saved path has no program there a_saved_program_that_is_gone_is_named_by_test_and_doctor runs both with a removed path. A regression starts a program at a path with no file on Windows 10 and checks the message, remediation and reason, with a bare-name control; on Linux (Docker), a relative script with a missing interpreter started in its folder, through Process and Launch. Not checked: a real Codex desktop update, or the app's Settings screen with a stale path
Saved API keys Settings → AI shows whether an API backend's key is saved in the app, and can replace it or forget it without removing the backend; forgetting falls back to the key in the environment (#1358). ai key <name> shows, replaces or forgets it headlessly, and never prints it. The key itself never enters the UI; reads and writes run on a worker Unit and CLI tests replace and forget a saved key and leave the backend; a UI test shows the saved-key, replacement-field and agent states. No live system-keychain run
npm agents without Node on Windows Programs are also looked for in nvm for Windows' version folders (NVM_HOME, else %APPDATA%\nvm, newest first, after PATH), so an npm shim such as claude.cmd finds Node when no nvm use link exists. When a shim's interpreter is still missing, starting it fails with EngineMissing, reason interpreter_missing, naming node and nvm use, instead of Rust's "batch file arguments are invalid" On Windows 10 (Rust 1.99.1): unit tests for version-folder listing with nvm's own files beside the versions, the missing-interpreter check (no Node, Node on the search path, Node beside the shim) and the error's fields; the existing shim tests, including a real multi-line prompt through Node, and the platform crate's 70 tests pass. The failure was seen with Craft Anything 0.4.0 (Claude Code 1.0.96 npm shim, nvm with no version in use). Not checked: the fixed desktop app or CLI on that machine, and a build through a shim found only in nvm's folders
Mach-O Objective-C pointers Chained offsets mapped only into file-empty __PAGEZERO reach the image-base fallback; pointer candidates must be backed by file bytes Synthetic thin and fat Mach-O regression, plain-pointer and authenticated-rebase controls, null and unmapped-pointer checks. Real binaries were not checked for this correction
Swift existentials (apple_swift_symbols_demangle) A protocol in a protocol list (…_p) is read as the mangling writes it, a context and a name with no P kind letter, so an existential such as Swift.Error, __C.NSLocking or a composition A & B decodes. The protocol takes no substitution slot. Class-bound lists (Xl) and existential metatypes (Xp) are still reported invalid, and an optional composition prints without parentheses (A & B? for (A & B)?) Integration test on seven symbols from macOS system binaries. 133,643 distinct Swift symbols from the system apps, frameworks and /usr/libexec of macOS 15.7 compared with swift-demangle: 6,275 of the 8,899 reported invalid as "expected a type" now decode (4,460 match exactly; 1,761 differ only in rendering this change leaves alone, such as the (extension in …) prefix; 34 also contain SQ, read as ImplicitlyUnwrappedOptional until the Equatable fix; 20 are optional compositions without parentheses), and no symbol that matched before changed. Giving the protocol a slot would change 119 symbols that match
Swift function type attributes (apple_swift_symbols_demangle) A function type takes its markers in the one order the mangling has them: a global actor (Yc, with its type) or @isolated(any) (YA), then throws or a typed throws(E) (YK, with its type), then @Sendable (Yb), then async (Ya). They print as @Swift.MainActor @Sendable (…) async throws(E) -> …, for c, F and the X function types. A marker out of order, repeated, with a global actor and @isolated(any) together, or without its type is reported invalid, as swift-demangle does. The parameter and result markers Yi (isolated), Yu and YT (sending) and Yt (_const) are still reported invalid Integration test on 23 symbols (6 from macOS and Xcode system binaries, the rest built with swiftc) and 19 invalid ones. 2,361,216 distinct Swift symbols from nm -j on 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: 15,690 of the 19,217 reported invalid as "unsupported function attribute" now match exactly (14,518 text, 1,172 apart from the (extension in …) prefix), no symbol that matched before changed, and no symbol swift-demangle rejects decodes
Swift value witnesses (apple_swift_symbols_demangle) A symbol ending w and one of the 24 two-letter codes swift-demangle accepts reads as that value witness of its type, such as destroy value witness for Foundation.Data (…wxx) or getEnumTag value witness for Swift.Result (…wug); a merged one (…Tm) adds merged. Another code, or a module, a name, a member, an extension or another global before w, is reported invalid, as swift-demangle does. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Integration test on 15 symbols from macOS and Xcode system binaries, 27 constructed ones and 13 constructed invalid ones, checked with swift-demangle. 2,361,216 distinct Swift symbols from 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: 154,554 value witness symbols reported invalid ("unsupported operator 'w'") now decode (151,914 match exactly; 2,640 differ only in the (extension in …) prefix), 34,051 others stay invalid for other manglings, and no symbol that decoded before changed
Swift lazy witness table cache variables (apple_swift_symbols_demangle) A symbol ending WL reads a type and a conformance, as the lazy accessor Wl does, and prints lazy protocol witness table cache variable for type T and conformance C, so …SwiftUI4EdgeO3SetVAESQAAWL decodes. It is as strict as Wl: a metadata or witness symbol as the type, a type as the module, a missing operand or a conformance with generic requirements is reported invalid. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Integration test on 12 expected strings (5 from macOS and Xcode system binaries, 7 constructed) and 13 constructed invalid symbols, checked with swift-demangle. 2,361,216 distinct Swift symbols from 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: of 79,029 symbols ending WL, 67,626 that were invalid ("N nodes left after decoding") now decode (66,463 match exactly; 1,163 differ only in the (extension in …) prefix), 11,403 stay invalid for other manglings, and no symbol that decoded before changed
Objective-C method record layouts Absolute and relative method records require their complete 24-byte or 12-byte layout and the full declared stride to be backed before facts are published. Complete extended strides remain supported. Undersized absolute/relative strides, incomplete backed records, and standard/extended controls preserving selectors, types and implementations.
Mach-O entry points The LC_MAIN file offset maps through the segment whose file bytes hold it, so a segment with no file bytes (__PAGEZERO, or a __DATA of only zero-fill sections, which also records file offset 0) never takes the entry; an offset outside every segment's file bytes gives no entry Synthetic regression. All 3,205 executable slices of 1,794 Mach-O files on macOS 15.7 (/bin, /sbin, /usr/bin, /usr/sbin, /usr/libexec, app bundles) match otool -l (__TEXT address plus entryoff, or the LC_UNIXTHREAD program counter); 270 slices in 153 files read the wrong address before
Swift symbol substitutions (apple_swift_symbols_demangle) A later A… reference names the type the mangling means: an Sg optional and a Qz/Qy associated type take a substitution slot and an extension doesn't. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Unit test on eight symbols from macOS system binaries. 133,643 distinct Swift symbols from the system apps, frameworks and /usr/libexec of macOS 15.7 compared with swift-demangle: 199 that named a wrong type now name the same types (35 match exactly; the rest differ only in rendering this change leaves alone, such as the (extension in …) prefix), 948 reported invalid now decode, and no symbol that matched before changed
Swift substitution memory Saving and reusing substitution trees charges the existing expansion budget before copying; a zero-repeat reference does not allocate a copy. Oversized nested types return an invalid-symbol result instead of retaining unbudgeted trees. Nested nominal and optional expansion regressions, ordinary symbol controls, and separate 3.9 KB / 3.6 KB symbols run under 64 MiB / 128 MiB process limits.
Swift Equatable (apple_swift_symbols_demangle) The standard type SQ reads as the protocol Swift.Equatable, as swift-demangle reads it in the $s, $S and _T0 manglings, so Equatable conformance descriptors and witness tables decode and a requirement names Swift.Equatable. A spelled-out ImplicitlyUnwrappedOptional still prints as T! Integration test on six symbols from macOS system binaries and four constructed ones checked with swift-demangle. 133,643 distinct Swift symbols from the system apps, frameworks and /usr/libexec of macOS 15.7 compared with swift-demangle: 1,773 reported invalid ("expected a protocol") now decode (1,759 match exactly; 14 differ only in the (extension in …) prefix), 3 that named ImplicitlyUnwrappedOptional now name Equatable (1 matches exactly; 2 differ only in that prefix and an _: label), and no symbol that matched before changed
Swift concurrency types (apple_swift_symbols_demangle) Sc and a letter reads as the concurrency type swift-demangle prints in module Swift: 19 letters, among them ScT Task, ScG TaskGroup, ScS AsyncStream, ScA Actor, ScM MainActor and Sci AsyncSequence. The protocols work where a protocol is needed (conformance descriptors, witnesses, existentials, generic requirements). Any other letter after Sc is reported invalid, as swift-demangle does Integration test: five tests on real symbols from macOS and Xcode system binaries and constructed ones checked with swift-demangle. 2,361,216 distinct Swift symbols from nm -j on 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: 13,601 reported invalid ("concurrency standard types are not supported") changed; 2,646 now match exactly, 110 differ only in the (extension in …) prefix, 10,845 stay invalid for other reasons (21 of them symbols swift-demangle rejects too), and no symbol that matched before changed
Swift metadata caches (apple_swift_symbols_demangle) A symbol ending Ml reads as type metadata singleton initialization cache for its type and one ending ML as lazy cache variable for type metadata for, as swift-demangle names them. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Integration test on eight symbols from macOS and Xcode system binaries, two constructed ones and three constructed invalid ones, checked with swift-demangle. 2,361,216 distinct Swift symbols from 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: 5,334 of the 6,000 ending Ml decoded with the ML name and now read the right one (5,301 match exactly; 33 differ only in the (extension in …) prefix), the other 666 stay invalid for other manglings, and no other symbol changed
Swift one-time initialization (apple_swift_symbols_demangle) A symbol ending WZ reads as one-time initialization function for and one ending Wz as one-time initialization token for, followed by the variable's name, as swift-demangle prints it. The context before the name (a module, a nominal type or an extension) is read and not printed. A symbol whose operand is not a variable name, such as a bare name or a type, stays invalid. A WZ followed by Tv (outlined variable), a local-scope context or a generic requirement stays invalid. Other rendering (no (extension in …) prefix) is unchanged Integration test on thirteen symbols from macOS and Xcode system binaries, five constructed ones and nine constructed invalid ones, checked with swift-demangle. 2,361,216 distinct Swift symbols from 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle from the Command Line Tools (Swift 6.1.2): 15,628 of the 15,713 symbols ending WZ or Wz now match, 2 already matched, and 83 stay invalid (78 with a local-scope, generic-requirement or other context that swift-demangle reads, 5 that swift-demangle also rejects); 201 WZTm symbols now match; 767 WZTv… symbols change reason only and stay invalid; no symbol that decoded before changed
Swift enum cases (apple_swift_symbols_demangle) A symbol ending WC reads as enum case for and the function it names, as swift-demangle prints it, for cases with and without a payload, in generic and nested enums. A module or another global before WC (a metadata or witness symbol) is reported invalid, as swift-demangle does. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Integration test on ten symbols from macOS system binaries, four constructed ones and nine constructed invalid ones, checked with swift-demangle. 133,643 distinct Swift symbols from the system apps, frameworks and /usr/libexec of macOS 15.7 compared with swift-demangle: 6,441 of the 6,556 ending WC and reported invalid now decode (6,367 match exactly; 74 differ only in the (extension in …) prefix and the parentheses around an optional function type), the other 115 stay invalid for other manglings, and no symbol that matched before changed
Swift opaque result types (apple_swift_symbols_demangle) A declaration that returns some P reads some in place of the type (Qr, and QR with an index for a second or later one in a tuple), so a.mk() -> some and a.H.body.getter : some decode. A use of it elsewhere (QO, then its generic arguments, then Qo and an index) reads <<opaque return type of …>>.N with the declaration's own text, takes a substitution slot, and an optional or metatype of it is put in parentheses, as swift-demangle prints it. An index missing, a Qo with no declaration or argument list, an argument that is not a type and a second Qo in a row are reported invalid. MQ (the opaque type descriptor), generic parameters at a depth (qd_) and the other Q forms are unchanged Integration test of eight tests (41 expected strings: 14 real symbols from macOS and Xcode system binaries, the rest built with swiftc or edited by hand, all checked with swift-demangle; 10 invalid ones). 2,361,216 distinct Swift symbols from nm -j on macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: of the 29,707 reported "unsupported associated type", 5,350 now match exactly and 2,800 differ only in the (extension in …) prefix, the rest stay invalid for other manglings, and no symbol that matched or differed before changed
Swift private declarations (apple_swift_symbols_demangle) A private or fileprivate declaration (its name, an identifier for its file, then LL) reads as (name in _ABC…), as swift-demangle prints it, for types, protocols, functions and variables, nested or used as a generic argument, and when a later substitution refers back to it. LL after anything but two identifiers, or a private name where a context or a type belongs, is reported invalid, as swift-demangle does. The other L forms (local declarations L_, Ll, Le) are still reported invalid. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Integration test on eleven symbols from macOS and Xcode system binaries, five constructed ones and eight constructed invalid ones, checked with swift-demangle. 2,361,216 distinct Swift symbols from 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: of the 326,718 reported invalid at L, 139,551 now decode (133,558 match exactly; 3,324 differ only in the (extension in …) prefix; 2,669 differ in rendering this change leaves alone, mostly _: labels and the Ml name), the other 187,167 stay invalid for other manglings (10,421 of them at another L form), and no other symbol changed
Swift outlined value operations (apple_swift_symbols_demangle) A symbol with WO and a letter reads as the outlined operation on the type before it, such as outlined destroy of ACPToolLib.ResetSchema (…WOh) or outlined enum tag store of (…WOi0_, the index is not printed). The letters are h c e y b d f g s r i j. A merged one (…Tm) adds merged. A letter swift-demangle does not know, a missing index, or a module, a name, a global or another outlined operation before WO, is reported invalid. An operand under a generic signature (…RzlWOh) stays invalid. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Integration test with 14 symbols from macOS and Xcode system binaries, 14 constructed ones (one per letter, with indexes) and 8 constructed invalid ones, all checked with swift-demangle. 2,361,216 distinct Swift symbols from 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: 28,391 symbols with WO changed from "unsupported witness kind"; 28,249 now decode (27,987 match exactly, 262 differ only in the (extension in …) prefix), 139 under a generic signature and 1 with a different reason stay invalid, 2 that swift-demangle also rejects change reason only, and no symbol that matched before changed
Runtime UI evidence A denied macOS Accessibility permission is an error (no_permission, naming System Settings → Privacy & Security → Accessibility), not a successful read of an empty tree (#240). Any other refusal from the helper is also an error, never nodes: [] Unit regression maps the helper's refusal object, keeps a genuinely empty tree a success, and covers the unknown refusal; live runtime_ui_read --pid 1 on macOS with the permission denied returned the structured error. The granted-permission path was not re-run for this correction
Keyed-archive object pages Only requested object rows copy names and collect references. Class counts still cover the full archive and use borrowed names until serialization. Existing full-table reads and page ordering, totals and offsets are preserved. Parser boundary and borrowed-name tests plus real engine calls on normal and shared-class archives. For a 97,483-byte fixture and a one-row page, row class copies fall from 64 MiB to 64 KiB; three local process samples have median peak RSS 81,800 → 15,044 KiB and tool time 36.101 → 4.141 ms. Timings describe this synthetic local run.
Property-list date precision Binary plist dates and keyed-archive NSDate values retain fractional seconds in their JSON projection, rounded to microseconds; pre-epoch times and second/day carries use the same calendar conversion. Binary date and keyed-archive fixtures, modern dates that expose floating-point noise, microsecond rounding boundaries, and whole-second/XML compatibility controls.
XML property-list documents Requires a closed plist with one root, preserves scalar whitespace after XML line-ending normalization, rejects stray content and invalid encodings, and consumes whole processing instructions, internal DTD subsets and quoted tag attributes. XML root, byte-order and processing-instruction fixtures; CRLF/CR text, keys, CDATA and character references in UTF-8 and both UTF-16 byte orders. Quoted greater-than signs match Python plistlib; unterminated attribute quotes are rejected.
Swift addressors (apple_swift_symbols_demangle) A variable or subscript addressor reads its kind letter after a (mutable) or l, so …vau is ….unsafeMutableAddressor : T, and the owning, native owning and native pinning kinds are named the same way. An addressor with no kind letter, or one swift-demangle doesn't name, is reported invalid instead of read as unsafe Integration test on three symbols from macOS system binaries and fourteen constructed ones checked with swift-demangle. 133,643 distinct Swift symbols from the system apps, frameworks and /usr/libexec of macOS 15.7 compared with swift-demangle: all 1,176 addressors (…vau) were reported invalid; 1,002 now decode (793 match exactly; 209 differ only in the (extension in …) prefix), and 174 stay invalid because of other manglings this demangler doesn't support. No symbol that matched before changed
Swift outlined variables (apple_swift_symbols_demangle) Tv with an optional index reads as outlined variable #N of and the symbol before it, as swift-demangle prints it: Tv_ is #0 and Tv0_ is #1. The operand is a function, a type, a witness or a global, but not a bare name, a module or another outlined variable. An index of 2^31 or more is reported invalid Integration test on four symbols from macOS and Xcode system binaries and constructed ones checked with swift-demangle. 2,361,216 distinct Swift symbols from nm -j on 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta, compared with swift-demangle: 9,102 outputs changed, of which 8,514 are now the same as swift-demangle and 561 now differ only in the (extension in …) prefix; 27 stay invalid because of another operator (Tv_r, an outlined read-only object). No symbol that matched before changed
Swift subscript accessors (apple_swift_symbols_demangle) A subscript's getter, setter, read, modify or addressor reads ….subscript.getter : (Swift.Int) -> A, the accessor after subscript and the type after a colon, as swift-demangle prints it, also inside dispatch thunks, method descriptors and protocol witnesses. A subscript with no accessor (a property descriptor) still reads ….subscript(Swift.Int) -> A. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Integration test on fourteen symbols from macOS and Xcode system binaries, three constructed ones and three constructed invalid ones, checked with swift-demangle. 2,361,216 distinct Swift symbols from 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: all 4,378 decoded subscript accessors printed the accessor last and now read it in place (3,957 match exactly; 392 differ only in the (extension in …) prefix; 29 only in an _: argument label), the other 3,920 stay invalid for other manglings, and no other symbol changed
Swift key path accessors (apple_swift_symbols_demangle) A key path getter or setter (TK or Tk) after a property descriptor, a static property or a subscript and the type the path starts from reads key path getter for ….subscript(Swift.Int) -> A : B, as swift-demangle prints it. A missing base or descriptor, a module or name as the base, and a global before the operator stay invalid. Key paths with a generic signature and key paths with the trailing q (serialized) also stay invalid Integration test on five symbols from macOS and Xcode system binaries, five constructed ones and eight constructed invalid ones, checked with swift-demangle. 2,361,216 distinct Swift symbols from 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: 14,668 undecoded key path accessors now decode, 14,029 exactly as swift-demangle prints them and 639 only without the (extension in …) prefix; 113 stay invalid (78 with a generic signature, 35 with a trailing q), and no other symbol changed
Swift metadata kinds (apple_swift_symbols_demangle) M followed by K, D, F, A, P, B, U, t or s reads as swift-demangle prints it: a metadata instantiation cache (of a conformance descriptor or another symbol), a demangling cache variable, a reflection field, associated type or builtin descriptor, a generic type metadata pattern, and the Objective-C metadata update function and resilient class stubs of a class. Kinds that describe a type refuse a module, a function, a conformance or another global, and an associated type descriptor needs a type, a protocol and a module, as swift-demangle does. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Integration test on 27 symbols from macOS and Xcode system binaries and seven built with swiftc or written by hand, plus invalid cases, checked with swift-demangle. 2,361,216 distinct Swift symbols from nm -j on 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: all 206,266 symbols ending in one of these nine kinds were reported invalid; 202,975 now match exactly, 3,287 differ only in the (extension in …) prefix, 1 differs in a rendering this change leaves alone (an existential metatype .Type for .Protocol), and 3 stay invalid because of other manglings. No symbol that matched before changed, and none that swift-demangle rejects now decodes
Apple app graphs Selecting a macOS bundle recognises its root-relative Contents/Info.plist and retains its service/extension type; nested XPC bundles appear in services and as xpc-service graph nodes, including their executables when hosted in frameworks Synthetic inventory tests, including parent-directory and flat bundle layouts, selected services/extensions, framework-hosted service executables, and bare-program controls. Ordinary selected directories with Contents/Info.plist need an Apple bundle suffix; archives retain layout-based recognition. Framework libraries and dylibs stay excluded from executables. Real app bundles were not checked for this correction
Apple asset catalog tree coverage Short tree or node headers, unreadable declared children, broken leaf chains, missing entry blocks and exhausted tree limits disclose an incomplete inventory. Readable entries remain available and apple_assets_list reports partial coverage. Empty trees and ordinary non-tree metadata warnings retain their previous coverage. An exact entry-limit fit stays complete. Twelve format regressions cover malformed and empty trees, retained entries, forward links and the exact entry-limit boundary; real engine calls check partial coverage and complete controls.
Apple asset catalog directories A BOM block index and its named variables must fit inside their declared table ranges. Bytes belonging to the next section cannot complete a truncated entry. A valid two-variable store and shortened or oversized directory lengths.
Swift associated type parameters (apple_swift_symbols_demangle) Qy numbers its generic parameter the way q does, so Qy_ names an associated type of B and Qy0_ one of C, as swift-demangle reads them; Qz still names one of A. The depth form (Qyd__) is still reported invalid, as qd__ is Integration test on three symbols from macOS system binaries and six constructed ones checked with swift-demangle. 133,643 distinct Swift symbols from the system apps, frameworks and /usr/libexec of macOS 15.7 compared with swift-demangle: the 6 that named A for B now match exactly, and no other symbol's output changed
Swift metadata kind names (apple_swift_symbols_demangle) MN, Mj and Mz name their kind as swift-demangle does: MN is noncanonical specialized generic type metadata, Mj an opaque type descriptor accessor key, Mz the flag for loading canonical specialized generic type metadata. A bare N after Swift.MainActor keeps its phrase Integration test on two system symbols and constructed ones checked with swift-demangle. 2,361,216 distinct Swift symbols from nm -j on 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: the 2 MN symbols that said type metadata for now match exactly, and no other symbol's output changed
Swift witness table accessors (apple_swift_symbols_demangle) A symbol ending Wl, Wb, WT or WI reads as the accessor swift-demangle prints: lazy protocol witness table accessor for type T and conformance C, base witness table accessor for P in C, associated type witness table accessor for P.A : Q in C (the path may have several elements) and instantiation function for generic protocol witness table for C, where C is type : protocol in module. A metadata or witness symbol, an entity or a type where the module belongs, a missing operand or an associated type path without its _ is reported invalid, as swift-demangle does. A conformance with generic requirements (…Rzl) and the other manglings in the operands stay unsupported and are reported invalid. Other rendering (no (extension in …) prefix) is unchanged Integration test on 15 symbols from macOS system binaries, nine constructed ones and 18 constructed invalid ones, checked with swift-demangle. 2,361,216 distinct Swift symbols from nm -j on 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: of the 102,757 ending Wl, Wb, WT or WI (with or without Tm) and reported invalid, 99,778 now match exactly and 1,832 differ only in the (extension in …) prefix; 1,143 stay invalid (1,142 conformances with generic requirements, one symbol whose leftover nodes swift-demangle prints in front) and 4 are symbols swift-demangle rejects too. No symbol that matched before changed, and none that swift-demangle rejects decodes
Asset catalog key formats (apple_assets_list) A catalog built for a system older than one of its key attributes, which actool marks with a stand-in in KEYFORMAT and the real attribute in KEYFORMATWORKAROUND, takes the real one, so display gamut is named display-gamut in the key format and rendition keys instead of placeholder Hand-built fixture; 738 catalogs on macOS 15.7 and one built by actool for macOS 10.11 compared with assetutil --info. iOS catalogs were not checked
Chinese UI Simplified (zh-hans) and Traditional (zh-hant) Chinese in Settings → General → Language; System chooses a supported OS language, otherwise English. Both catalogs cover UI controls and tool titles; translated titles are searchable. Raw tool data, AI text, logs, CLI/MCP and the separate browser viewer keep their original text. See localisation. Catalog integrity and locale-resolution tests; cargo xtask i18n-coverage; isolated UI language-switch test. Platform visual checks are recorded separately.
DEX payload attachment Source switch/array payloads and their attached copies share a 64 MiB default byte budget. Exhaustion omits payload detail, preserves instruction offsets and marks the listing partial; the existing per-array cap also marks it partial. Payload lookup uses ordered offsets without cloning an intermediate payload table. Array, packed/sparse switch, backward-reference, exact/zero-budget and instruction-cap controls; a 77,832-byte method with 2,048 shared array references is checked separately under a 128 MiB process limit.
Dart snapshot metadata extent An adjacent record can no longer supply a snapshot version hash or feature string. Serialized length fixtures cover the end of the fixed header and hash.
Dart string-pool limits Duplicate tracking borrows only retained URI and token slices, so discarded unique values no longer keep growing an owned-string set after the result cap. The full region is still scanned and omitted unique values mark the corresponding result partial. Four ordering, duplicate, independent-limit and zero-limit controls; two separate large-input regressions are run explicitly in a 128 MiB process, with two million tokens or 1.5 million URIs and output limits of one.
Swift initialiser names (apple_swift_symbols_demangle) An allocating initialiser (fC) reads __allocating_init only when its context is a class, Objective-C classes and generic or nested ones included. In a struct, an enum, a protocol or an extension, even of a class, it reads init, as swift-demangle prints it Integration test on nine symbols from macOS system binaries and one constructed one checked with swift-demangle. 133,643 distinct Swift symbols from the system apps, frameworks and /usr/libexec of macOS 15.7 compared with swift-demangle: 4,262 that read __allocating_init for init now read init (3,841 match exactly; 421 differ only in the (extension in …) prefix, an _: label or parentheses around an optional function type), the 2,191 class initialisers still read __allocating_init, and no symbol that matched before changed
Swift special types (apple_swift_symbols_demangle) A type written X and a kind letter reads as swift-demangle prints it: a non-escaping function type (XE) and the @autoclosure (XK, XA), @convention(c) (XC), @convention(block) (XB) and @convention(thin) (Xf) function types, with their throws and async; AnyObject after a protocol list (Xl); a class with protocols (Xc); the metatype of an existential (Xp); Self (XD); weak, unowned and unowned(unsafe) types (Xw, Xo, Xu); a box (Xb); and a metatype with its representation (XM, Xm). An operand that is missing, is not a type or is out of order is reported invalid, as swift-demangle does. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Integration test on nineteen symbols from macOS and Xcode system binaries and twenty-seven constructed ones, and twenty-nine constructed invalid ones, checked with swift-demangle. 2,361,216 distinct Swift symbols from nm -j on 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle from the Command Line Tools (Swift 6.1.2): of 55,696 reported invalid ("unsupported special type"), 33,617 now match exactly (30,478 identically; 3,139 differ only in the (extension in …) prefix), 7 decode and differ in the generic constraints of an extension, and 22,039 stay invalid because of other manglings this demangler doesn't support; no symbol that matched before changed and none that swift-demangle rejects now decodes
Swift argument labels (apple_swift_symbols_demangle) When a function, initialiser or subscript has at least one argument label, an argument without one reads _:, as swift-demangle prints it (append(_: Swift.UnsafeRawPointer, length: Swift.Int)), in protocol witnesses, dispatch thunks, method descriptors and other globals that name the function too. With no label at all, or a label list of _ only, the arguments print bare, and so does a single argument that isn't wrapped in a tuple. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Integration test on fourteen symbols from macOS and Xcode system binaries, seven constructed ones and four constructed invalid ones, checked with swift-demangle. 2,361,216 distinct Swift symbols from 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: 21,370 outputs changed, all of them _: labels that were missing (19,845 now match exactly; 1,496 differ only in the (extension in …) prefix; 29 subscript accessors still differ in how the accessor is written), and no other symbol changed
Swift operator functions (apple_swift_symbols_demangle) A function named by an operator reads as swift-demangle prints it: the operator and its fixity in the name, static Swift.Int.% infix(Swift.Int, Swift.Int) -> Swift.Int, - prefix(…) and ... postfix(…), including a private operator ((< infix in _…)) and every symbol built around the function (witnesses, dispatch thunks, method descriptors, merged functions). A letter that is not an operator character, a missing name, an unknown fixity letter or an operator used as a type or module is reported invalid. Other rendering (no (extension in …) prefix, unsupported manglings reported invalid) is unchanged Integration test on 16 symbols from macOS and Xcode system binaries, seven constructed with swiftc and 23 constructed invalid ones, checked with swift-demangle. 2,361,216 distinct Swift symbols from 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: 34,816 outputs changed, all of them symbols that were invalid (unsupported operator 'o') (28,898 now decode: 27,701 match exactly, 1,159 differ only in the (extension in …) prefix, 38 differ in the constraint an extension adds to a generic type; 5,793 stay invalid for other manglings; 125 that swift-demangle rejects stay invalid), and no other symbol changed
Android binary XML event framing Incomplete events and malformed attribute layouts set the truncation flag. Namespace data follows the declared node header. Parent, child, extended-header, stride and typed-value byte fixtures.
Android manifest evidence coverage Package evidence is partial when the manifest is missing, unreadable or recovered incompletely. Component pages remain partial after a truncated manifest, including the last and empty pages; the unknown total is omitted while pagination over recovered rows remains usable. Real engine calls with a recovered binary XML document, missing and unreadable manifests, all component page positions, and complete-manifest controls; returned evidence identifiers verify.
Android component export defaults When the target SDK is omitted, component export inference uses the minimum SDK when declared. Decimal and hexadecimal SDK integers use their numeric values. The report preserves the source SDK attributes. Binary manifest fixtures cover omitted, legacy and explicit values, hexadecimal integers and unresolved SDK strings.
Android string-pool retention Decoded UTF-8/UTF-16 pools retain a prefix within a byte budget: 64 MiB or three times the declared chunk size, whichever is larger. Shared offsets spend the same budget; unrelated bytes after a chunk cannot enlarge it. Binary XML and resource tables disclose capped global, type and key pools through warnings and partial coverage Shared-offset byte-budget regressions in both encodings, appended-byte and small-pool controls, and XML/global/package warning propagation; a 49,188-byte UTF-8 pool retains 64 MiB instead of 128 MiB
Android SDK-M permission declarations Permission inventories include the platform-recognized uses-permission-sdk-m alias. A binary manifest fixture covers the legacy tag, both existing forms and a nameless declaration.
Android resource parent bounds Resource tables, packages and child chunks enforce their enclosing byte ranges. Invalid library counts and incomplete headers produce warnings while earlier decoded entries remain available. Synthetic arsc_parent_chunk_boundaries regressions (7 tests): Table/package crossings, escaped package pools, retained earlier entries, sibling library data, short headers, truncated bag parents and both legacy 284-byte and current 288-byte package headers. Format checks and compatibility gates passed at ea680eeb9e92.
Preserve Android resource identities with incomplete bags Keep entry data after the offset table. An incomplete bag header or record array retains the readable resource identity with an empty bag and no parent, while a warning and partial-table flag disclose the missing data. Complete bags retain their values and existing output limits. resource_table_regions covers offset-table overlap, short headers, incomplete records and complete-style controls; arsc_parent_chunk_boundaries covers sibling isolation and retained identities.
Android resource locale groups Explicit script, variant and numbering-system subtags distinguish resource groups, while region-only locales retain their existing form. Resource and binary XML parser tests including traditional and simplified Chinese resource configurations.
Keep Android device configuration selectors distinct Retain carrier zero, grammatical gender, round-screen and color capabilities, and keyboard/navigation availability in resource configuration names. Regression fixtures cover each omitted selector, qualifier order, the distinction between locale and gender, and bytes outside a shorter declared configuration.
Android resource type identities Package type-ID offsets are included in type and resource IDs, while type names keep their local string-pool indices. Older 284-byte headers imply zero offset. Out-of-range offsets or shifted IDs produce partial coverage and diagnostics instead of wrapped identities. Five byte-fixture regressions cover shifted values and bags, multiple packages, the one-byte boundary and legacy headers; four fail against the previous parser. Checked against the native format reader's identity rules; no Android runtime was executed.
Swift optional function types (apple_swift_symbols_demangle) The type inside ? or ! sugar goes in parentheses when it is a function type, async and throwing ones included, or a protocol composition, as swift-demangle prints it, so (() -> Swift.Int)? no longer reads as () -> Swift.Int?. Other wrapped types print as before Integration test on four symbols from macOS system binaries and six constructed ones checked with swift-demangle. 133,643 distinct Swift symbols from the system apps, frameworks and /usr/libexec of macOS 15.7 compared with swift-demangle: the 506 decoded ones with an optional function type now put it in parentheses (413 match exactly; 93 differ only in the (extension in …) prefix, an _: label or __allocating_init), and no symbol that matched before changed
Swift async thunks (apple_swift_symbols_demangle) Tu reads as async function pointer to and the function, and TY or TQ with an index as (N) suspend resume partial function for or (N) await resume partial function for and the function, where N is the index plus one, as swift-demangle prints them. The function can be a closure, a dispatch thunk, a protocol witness or a partial apply forwarder. A missing or bad index, an index above 2^31 - 1, and a name, marker or module in place of the function are reported invalid Integration test on eleven symbols from macOS and Xcode system binaries and ten constructed ones checked with swift-demangle, and constructed invalid ones. 2,361,216 distinct Swift symbols from nm -j on 4,113 Mach-O files of macOS 15.7.4 and Xcode 26.0 beta compared with swift-demangle: 25,198 symbols that were invalid now decode (22,916 match exactly; 2,282 differ only in the (extension in …) prefix), and no symbol that matched before changed
ext symlink storage Short symlinks use inode allocation metadata to choose inline targets or block mappings, including external-attribute accounting. Unavailable targets keep their declared size and remain unknown. Six fixture groups cover classic and extent-backed short links, inline targets with attributes, allocation clusters, EA_INODE, high block counts, unavailable blocks and unsupported inline-data storage.
Firmware extraction buffers Recovered filesystem file bytes move into extraction without a second full payload copy. File classification, path checks and skipped entries keep their existing behavior. Real-engine controls cover directories, symlinks, refused names, missing content and a recovered file. Three Linux processes per build extracting a 32 MiB single-file ROMFS image measured median peak RSS of 144448 KiB before and 110996 KiB after; output bytes were checked.
Bounded regular-file inputs Binary, text, archive and evidence-bundle readers reject non-regular files before reading and enforce whole-file caps on the actual bytes. Prefix readers check EOF before giving a content hash; file size remains the metadata report. Unix opens cannot wait on a FIFO swapped in after the path check. Directory targets and regular-file symlinks remain supported. Engine regressions cover live-writer pipes at text, bundle import and bundle comparison entry points, a normal export/import/show/compare round trip, device-file refusal, zero-size metadata with readable bytes, partial-prefix hashes, exact and empty caps, the largest representable cap, directory targets and regular-file symlink/prefix controls.
Builder file reads build_file_read refuses a project file over 16 MiB before reading it, so a large generated file cannot allocate unbounded memory; files at or under the cap still page as before. Engine regression: a 16 MiB + 1 text file is refused with OverLimit; a file exactly at 16 MiB still returns its first page.
Engine 300 engine tools (320 with the AI and setup layers') across native, managed, Java, Android, Apple, JS/Electron, web, firmware, packets, databases, game archives and assets; see tools.md and tool-status.md. A saved result can be narrowed without running again (core_evidence_browse keeps the rows matching given field values, cut to chosen fields); for Claude Code, a result over 80 KB comes back summary-first, pointing at it; every summary names the lists it can page, with their lengths A functional audit that ran every tool on real inputs on Windows, plus 600+ unit and integration tests. Live in a Claude Code 2.1.322 chat on macOS: a 581 KB function line-up paged with core_evidence_browse, and a 79.5 KB page received whole
Tar engine installation GNU name or link metadata with a truncated body, missing block padding, overflowing padded extent or an overlong identity refuses installation before any member is written. Earlier members remain available to inspection, and readable regular members without trailing block padding or an end marker still unpack. Oversized/truncated identities and short/overflowing GNU records preserve an existing file; valid bounded names and ordinary members remain accepted. Exact source 25c45ef0 passed formats and engines tests (1,200 passed, one existing network test ignored), fmt, clippy and L0 gates. The same run reproduces four failures and seven passing controls with production code unchanged.
Tool argument correction Shared parameter parsing keeps schema types strict and reports the rejected value's JSON Pointer when known, the original type error and guidance to correct the call. Unknown locations are null; a root failure uses the empty pointer Parser regressions cover string/array mismatches, nested indices, escaped keys, oversized paths, enum locations, defaults and strict fields. Shared engine dispatch is checked for Agent, MCP and CLI callers: rejected arrays create no record, and corrected input creates one. No live Qwen or Ollama build was run for this correction
One-module webpack chunks A chunk push whose module object has a single property is read as a webpack chunk only when that property is a module factory (a function of at most three parameters) and the file names webpack or the push goes onto (g = g || []) or (g ||= []), webpack's chunk global under any name. An ordinary queue.push([[1], { callback: () => 42 }]) no longer makes a webpack module, chunk ids or a webpack classification. Tables of two or more factories are read as before. Regression tests: three ordinary pushes (an arrow, a method and a plain value) give no modules, chunk ids or bundlers, where the first two made a webpack-chunk module before; one-module chunks with webpackChunk…, webpackJsonp, a renamed global, ||= and a file naming __webpack_require__ still read as one module and webpack; a non-function value in a real chunk records nothing. The bundle output of 5,593 local JavaScript files, 133 of them classified webpack, was identical before and after.
Skip comments in GraphQL operation headers Skip GraphQL header comments before reading operation names and selection sets. JavaScript crate regression tests on Windows cover corrected behavior and retained controls. No browser or live application run.
GraphQL block strings Escaped triple quotes stay inside block strings, so operation names survive in queries with block string arguments and variable defaults. Regressions with argument text, variable defaults and an unfinished string.
GraphQL quoted string boundaries A regular quoted string cannot supply operation evidence if it contains a physical line break. Block strings and textual escapes still read. Fixtures cover carriage returns, line feeds, backslash continuations and valid strings.
API endpoints in URL paths GraphQL and tRPC endpoints are read from a URL's path only. The host ends at the first /, ? or #, so a URL with no path whose query or fragment holds a slash (https://auth.example.test?next=/graphql, #next=/trpc/user.list) is no longer a GraphQL endpoint or tRPC procedure. A scheme counts only before any /, ? or #, so /api/graphql?next=https://x.test stays a relative path. Run-time text in a partly literal URL (https://{document.querySelector(#api).value}/graphql) ends neither the host nor the path, and a :// or / inside it is neither a scheme nor a segment boundary. Regression tests: six such URLs, including a redirect to a real GraphQL URL in the query, give no API; paths with a query or fragment after them (/graphql?next=/home, /v1/gql#top, /api/trpc/user.list?batch=1) still do, as do relative paths, also with https:// in their query, where main found none; ?, # and / inside {…} in the host or path end nothing, and {proto}://{host}/graphql still reads; a hole holding https://…?x=1 before the real ://, or /trpc/user.list inside a path, no longer moves the scheme or adds a tRPC procedure; end to end, fetch of the two redirect URLs records no API operations and a real endpoint still does. The serialized analysis of 5,593 local JavaScript files was identical before and after.
Webpack recovery with direct eval Factory parameter names are preserved when a possible direct eval call can inspect them, including inside nested functions. Indirect eval still permits renaming. Four regression groups cover direct and dynamic eval arguments, parentheses, escaped identifier spelling, nested functions, optional/indirect calls, property calls and text-only mentions. The baseline failed three groups. A recovered synthetic factory threw ReferenceError under Node.js before the guard and returns 42 after it.
JavaScript fact line numbers CR, LF, CRLF, U+2028 and U+2029 advance source locations correctly. Regression tests cover parsed/fallback imports, mixed terminators, multibyte text and existing LF/CRLF controls.
JavaScript line-comment boundaries CR, LF, U+2028 and U+2029 end line comments, so following code reaches the nesting check and lexer fallback. Unicode line terminators separate identifiers without consuming a token slot. Synthetic comments followed by imports, IPC and fetch calls; a small configured nesting limit; LF/CRLF and strings, templates and block comments as controls. Existing JS unit and esbuild-budget tests pass. No stack overflow was triggered or real application executed.
JavaScript chain nesting A call, index read or template that follows another (f()(), a[0][1], tagged-template chains) and a label that follows another (a: b:) each count one level in the nesting estimate, so a source nested deeper than the parser's stack takes the lexer fallback instead of stopping the process. Comments do not break a chain. A closed bracket that the expression goes on after (((f)())(), f(g(x)())(), (a + b) + c) keeps what was counted inside it; of siblings such as (a) && (b) only the deepest counts. The tokenizer skips JavaScript's non-ASCII spaces and the vertical tab, which it used to read as part of a name, so they can't break a chain either. An else chain counts one level per link at its own scope, so a ; inside a block consequent does not reset the enclosing chain, and neither does a comma in an unbraced one; a class nested after extends counts a heritage level; prefix ++/-- count while postfix ones do not; / after an update operator or a member name (. or ?.) divides. After yield, a regex is read when one closes on the same line; LF, CR, U+2028 and U+2029 end the lookahead (even after a backslash), its shared budget across the source keeps hostile input linear, and running out fails admission closed instead of guessing division, as do a quote or backtick inside the token, a closing / immediately followed by * or / (a comment in sloppy code), and a following /, ++ or -- that the division reading would tokenize differently. Its brackets and every !, +, -, ~, *, %, ?, &, | or ^ are counted and kept in the expression depth, so later nesting adds to them; the same text is division in sloppy code. Regression tests: 5,000-link call, index, template and label chains are refused, also with a vertical tab, no-break space, byte-order mark or other space separator between links; chains split across 100 closing groups, call arguments, assignments, index brackets or function bodies count past 6,000 (about 160–260 before); two-million-link call, spaced call, grouped call and label chains, which overflowed the parser thread's stack and stopped the test process before this change, now report the lexer fallback; 5,000-link else-if, else-if with comma consequents, alternating block and unbraced consequents, class extends, prefix ++, false-regex, yield-regex, yield-plus-prefix-operator and yield-plus-addition-chain sources are refused, and a 6,000-link analysis of each reaches the lexer fallback with a nesting reason; a unit test covers the bounded yield lookahead, an end-to-end test covers exhaustion with the 160-level limit, another checks a diverging follow and a quote inside the token (beside the compact-regex control), another checks a conditional chain and each bitwise chain at the 160-level limit, another checks a closing slash before a block comment, another checks that 100 operators plus 100 following brackets exceed 160, and another checks LF, CR, U+2028, U+2029 and an escaped line end; tokenizer controls keep yield /a[0]/g, yield /a+b/ and return /a[0]/g as regexes (code after the closing delimiter still tokenized) while yield / 2 divides; declarations, case clauses, object keys, conditionals and short chains stay below 16. Over 5,594 local JavaScript files, estimates rose by at most 46 and no file crossed the native (4096) or wasm (160) limit. The wasm stack itself was not measured.
Scoped JavaScript banner names Package scopes remain attached to names in license banners: a word that starts with @ keeps its / (@scope/pkg@1.2.3, @scope/pkg v1.2.3). Every other word still splits on /, so a banner that names its package by URL (https://mths.be/punycode v1.4.1) still reads punycode. Regression tests cover attached/spaced versions, parsed/fallback analysis, ordinary unscoped banners, and URL banners (https://mths.be/punycode v1.4.1, https://unpkg.com/axios@1.6.0/dist/axios.min.js). Vendors from 5,593 local JavaScript files were identical to main.
JavaScript export lists export { f } marks the function bound to f once the whole file has been read, so a list before the declaration counts. A function is bound to f when it is declared as f, initializes const f = …, or is assigned by f = … anywhere, including inside another function. Other functions that only share the name (nested functions, methods, named callbacks, the getters of __export({ f: () => f })) are no longer marked. A listed name that resolves to no binding is still matched by name against module-level functions. Regression tests: lists before a declaration and before bound arrow and function expressions (renamed and as default) mark them, which they did not before; nested declarations, arrows and named callbacks called f, an object method setup and a named callback handler beside the exported ones stay unmarked; functions assigned to the listed variable inside init() or an IIFE are marked; lists after the declaration and export function read as before. Over 5,593 local JavaScript files, export marks changed in 39, none gained and 5,146 lost, most of them the __export getters of six transformers.js bundles; the rest were inner handlers such as hono's return async function basicAuth(…), object methods and nested declarations. No other output changed.
Require a call before reporting a fallback tRPC operation Require call syntax for tRPC client hooks in JavaScript lexer fallback facts. JavaScript crate regression tests on Windows cover corrected behavior and retained controls. No browser or live application run.
JavaScript side-effect import fallback Bare import declarations survive lexer fallback and obey the existing import cap. Every fallback import form now records an import as the syntax-tree pass does: past the cap imports is marked truncated, and a .node specifier is also a native module. Regression tests cover comments, escapes, size-based fallback, locations, the list cap and other import forms; 5,001 bare, from, require and import() imports each keep 5,000 and mark imports truncated while exactly 5,000 do not; ./addon.node loaded by a bare import, from or require is a native module in both passes. Facts from 5,593 local JavaScript files (five on the lexer fallback) were unchanged by the cap and .node changes.
JavaScript dynamic import options The lexer fallback keeps the literal path of an import with an options argument or trailing comma. Regressions compare both fact readers and cover computed paths, property calls and require controls.
JavaScript lexer fallback list caps The lexer fallback, used for huge, deeply nested or unparsable sources, bounds endpoints (fetch calls and URL literals) and exposed objects at MAX_LIST, as the syntax-tree pass does, and records endpoints in truncated when a fetch call is dropped. A JS unit regression forces the lexer path with more than MAX_LIST fetch and exposeInMainWorld calls, checks both lists stop at the cap, that a URL literal adds nothing past it, and that endpoints says it was cut.
JavaScript constant text budget Text read through constants (base + "/v1", `${base}/v1`) is at most 4 KiB per value, and all constants in a file share a budget of the source's size plus 1 MiB. Longer text reads as not literal, so const a1 = a0 + a0; const a2 = a1 + a1; … no longer doubles without end. A later var of the same name replaces the earlier value once its initializer has been read, even when the new value can't be read, so the old text is never reported in its place; the initializer itself (var u = fetch(u)) still sees the old value. Regression tests: 26 doublings of an 8-byte constant (a 592-byte file that peaked at 1.5 GB before) and 64 doublings both finish with a non-literal endpoint of at most 4 KiB; 2,000 four-fold copies of a 1,000-byte constant stop at the shared budget; a redeclaration with a too-long or unknown value hides the earlier URL, and var u = u + '/v1' and var u = fetch(u) still read the earlier URL; ordinary concatenation and templates still give literal URLs. Facts from 5,594 local JavaScript files were identical before and after.
TypeScript module kind by extension .cts reads as CommonJS and .mts as an ES module whatever the file contains, as in Node and TypeScript; .ts, .tsx and .d.ts are still decided by their syntax. A .cts file that calls require used to read as a script, one with import syntax as a module, and an .mts file without import or export as a script. Regression tests: .cts with require (also in upper case) and with TypeScript import/export = syntax read as commonjs and parse without errors, keeping their imports and exports; .mts with plain code, top-level await or import reads as module; .ts, .tsx and .d.ts controls keep their syntax-based kind. Over 3,193 local .cts/.mts files (3,191 of them declaration files), 588 .d.cts files changed from module to commonjs and two .d.mts files from script to module; no file's parse mode or error count changed.
Decode JavaScript legacy escapes and line continuations Decode legacy octal escapes, Unicode line continuations and zero-padded braced Unicode escapes in JavaScript strings. JavaScript crate regression tests on Windows cover corrected behavior and retained controls. No browser or live application run.
JavaScript numbers in constant text Text read through constants follows JavaScript's +: two numbers add ('/v' + (1 + 2) is /v3, 1 + 2 + '/y' is 3/y), text on either side joins, and a number added to something unreadable is not literal. Number literals read as JavaScript turns them into text (0x10 is 16, 1e3 is 1000, 1_000 is 1000, 1.50 is 1.5), and a constant remembers whether it holds a number, so const n = 1; n + 1 is 2. Regression tests: '/v' + (1 + 2), 1 + 2 + '/y', `/v${1 + 2}` and numeric constants add, where they read /v12, 12/y and the like before; hex, octal, binary, exponent, separator and trailing-zero literals read as their value, where '/w' + 0x10 read /w0x10 before; '/x' + 1 + 2, a numeric port after text, a text constant '1' and a text base still join; '/u' + (x + 1) stays not literal. Over 5,593 local JavaScript files one changed: two setTimeout delays written 5e3 and 1e3 now read 5000 and 1000.
CR-only JSONC editing Insertions and first-object creation preserve CR-only line endings and existing member indentation; removing a whole member line consumes its CR terminator. Four regression groups cover tab indentation, nested values, comment-only documents, removal beside comments, and LF/CRLF controls.
JSONC registration comments A bare carriage return ends a line comment, so registrations on the next line remain visible when settings are opened or edited. Seven JSONC module tests on Linux, including a comment before the root and one inside it.
First JSONC object Creating the first object preserves the file's CRLF line endings and existing comments or BOM. Empty files keep LF. Whitespace-only, comment-only, BOM and unterminated final-comment controls; parsed registration values stay intact.
German UI German (de, informal "du") in Settings → General → Language; System picks it for a German OS language. The catalog has the same keys as the Chinese ones. Drafted with an AI, not yet reviewed by a native speaker. Requests such as "Ein einfaches Snake-Spiel" or "Eine Website für …" keep their project kind. See localisation. Catalog and locale tests, key-set comparison with the Chinese catalogs, the isolated language-switch test, a kind-detection test; fmt, clippy, layers, locks and secrets are clean. Not checked: how the German texts look in the running window (length, line breaks), and the de.tsv wording by a native speaker.
Estonian UI Estonian (et) in Settings → General → Language; System picks it for an Estonian OS language (et, et-EE). The catalog has the same keys as the other catalogs. Drafted with an AI from the English source; corrections from native speakers are welcome. Requests such as "Lihtne usumäng" or "Veebileht minu …" keep their project kind. See localisation. Catalog and locale tests, key-set comparison with the other catalogs, a kind-detection test, cargo xtask i18n-coverage (0 missing), a --lang et Settings snapshot (the text fits at 2160×1350); fmt, clippy, layers, locks and secrets are clean. Not checked: the other screens in the running window and platform dialogs.
Georgian UI Georgian (ka) in Settings → General → Language; System picks it for a Georgian OS language. The catalog has the same keys as the other ones. Written with Claude Code from the meaning of each English string; terminology and doubtful strings decided by a native Georgian speaker (@devius). See localisation. Catalog and locale tests, key-set comparison with the other catalogs, the isolated language-switch test, the craft-fonts glyph test with a Georgian line. Not checked: how the Georgian texts look in the running window (length, line breaks).
Spanish UI Spanish (es, informal "tú", Mexican vocabulary) in Settings → General → Language; System picks it for a Spanish OS language. The catalog has the same keys as the Chinese ones. Register and glossary chosen by a native speaker, the text drafted with AI assistance. Requests such as "Un juego de serpiente sencillo" or "Un sitio web para mi panadería" keep their project kind. See localisation. Catalog and locale tests, key-set comparison with the Chinese catalogs, a kind-detection test. Not checked: how the Spanish texts look in the running window (length, line breaks).
Italian UI Italian (it, informal "tu") in Settings → General → Language; System picks it for an Italian OS language. The catalog has the same keys as the others. Drafted with an AI, not yet reviewed by a native speaker. Requests such as "Un semplice gioco del serpente" or "Un sito per …" keep their project kind. See localisation. Placeholder and ellipsis check against the English keys, and a kind-detection test. Not checked: the running window (length, line breaks), a native-speaker review, or the full UI catalog test suite.
Vietnamese UI Vietnamese (vi, Tiếng Việt) in Settings → General → Language; System picks it for a Vietnamese OS language (vi, vi-VN). The catalog has the same keys as the Chinese ones. Drafted with an AI from the English source, not yet reviewed by a native speaker. Requests such as "Một trò chơi rắn săn mồi" or "Một trang web cho …" keep their project kind. Letters with stacked marks need craft-fonts (releases and CI have it); they come from Noto Sans CJK, not Figtree. See localisation. Catalog and locale tests, key-set comparison with the Chinese catalogs, the isolated language-switch test, a kind-detection test, cargo xtask i18n-coverage (0 missing); the craft-fonts script test with every Vietnamese letter, and a --lang vi Settings snapshot on macOS with the pinned craft-fonts; clippy, layers, locks and secrets are clean. Not checked: the vi.tsv wording by a native speaker, and the other screens in the running window (length, line breaks).
JVM method descriptor class names Parameter and return types keep legal parentheses inside internal class names. Class-file parser regression and an independent OpenJDK 17 MethodType check.
DEX capped table alignment Truncated class-data groups cannot invent following members, and catch-all addresses are read only after the complete typed-handler list. Synthetic dex_capped_table_boundaries regressions (5 tests): Over-cap and exact-cap class members; oversized, truncated, empty and exact-cap typed-handler lists with real catch-all controls. Format checks and compatibility gates passed at 149f060b9959.
Java class usage java_class_users_find includes the component class of multidimensional object arrays; primitive-array descriptors do not match an unrelated class with the same descriptor letter Synthetic class files parsed by the built-in reader: one- and two-dimensional allocations, class names beginning with L, primitive arrays, hit limits and method filters; formats tests. This correction was not checked with javac output or a JVM
Keyed-archive reference graphs Object rows expose edges from arrays and UID aliases. Projection follows inline dictionaries, arrays and aliases, including cycles. Repeated scalar references spend a shared byte budget. Binary/XML fixture and nested object, alias and cycle regressions.
Keyed-archive null-marker text Only the $null string at object-table index zero is a null sentinel. The same text in other objects remains a string, including dictionary keys, UID aliases and paged object rows. Four regressions parse both binary and XML fixtures, retain the zero sentinel and ordinary strings, and verify literal keys and values. Three fail before the correction. No Apple application was executed.
Worker execution roles Worker, service-worker and utility-process spawn edges keep their child modules in the inferred worker role. Ordinary worker dependencies share that role; modules also imported by the parent keep the existing role precedence. Public application-graph fixtures cover Worker/SharedWorker/URL launches, service-worker registration, utility/child-process forks, endpoint and node roles, shared dependencies and nested workers. Synthetic inputs only.
Node SEA module formats Reads the explicit CommonJS or module tag in the newer blob header, preserving the actual script, asset and execution-argument offsets. Older header layouts remain supported; unknown tags and incomplete layouts are refused. CommonJS and ESM blobs generated by the official Node.js v25.7.0 Linux x64 binary from small original scripts, one asset and one execution argument. Both failed to list before the header correction. Regressions also cover all three older layouts, exact extraction bytes, malformed tails and the existing metadata budget.
Node SEA metadata budgets Asset and argument metadata obey entry caps and a shared 8 MiB decoded-text budget. Declared counts and truncation remain visible, and omitted fields still undergo complete layout validation. Synthetic node_sea_metadata_budget regressions (7 tests): Entry limits including empty arguments, oversized paths/keys, invalid UTF-8 expansion, malformed bytes after the retained prefix and ordinary metadata. Format checks and compatibility gates passed at ce34c2446499.
Python code inventory truncation A shortened code name, filename, qualified name or text constant sets the existing partial-inventory flag. The UTF-8 ellipsis also counts toward the shared retained-text budget, so returned text stays within that budget. Three new regressions fail on unchanged main and pass with the correction. Fixtures cover ASCII and multibyte constants, every displayed name field, exact marker budgets and unchanged short text. Linux formats tests, strict clippy and portability checks pass; no Python interpreter was executed.
Single-file apps and game files core_packed_files_list and core_packed_files_unpack read Bun and Node.js single-file programs, .NET single-file apps, PyInstaller and Godot packs through one seam (formats::packed); formats_bytecode_show reads Python bytecode, game_unity_code_names_show Unity IL2CPP metadata, formats_ai_weights_show GGUF and safetensors headers. app_folder_explain says what an install folder is made with and what to run next Unit tests with damaged files. Real files: a 279 MB Bun program, Node blobs, PyInstaller programs (Python 3.9, 3.14), .NET 8 single-file apps (macOS, Linux, Windows, compressed), Godot 3.6, 4.3 and 4.5 packs, 214 Python modules against CPython's own reader, a GGUF and a safetensors file, about 25 installed Mac apps. IL2CPP on synthetic files only
Text sources outside a build core_text_read reads a script, Markdown, settings or a log as text in Deep mode, paged by lines (200 by default, at most 2000 and 256 KiB a page), UTF-8 and UTF-16 with a byte-order mark, invalid bytes counted as U+FFFD, a file with a zero byte in its first 8 KiB refused as binary; recognised text targets carry kind: text and a text description in the target list, opening response, triage and desktop app; triage recommends core_text_read rather than native_bytes_show (#539, R3.11) Unit tests (paging, CRLF, UTF-16 LE/BE, a UTF-8 mark, invalid bytes, a lone surrogate, long lines, empty and binary files, Clean room). Run through the CLI on macOS against a .md and a .ps1, and in live chat --deep runs on macOS: Claude Code 2.1.322 and Codex 0.162.1 each reached core_text_read and quoted the file exactly, with no byte search. New target-identification regression tests cover UTF-8, UTF-8 BOM, UTF-16 BOM, text and binary; not yet executed on this branch. Not run on Windows, where #539 was reported
Cut text-read pages A text page containing a cut line reports partial coverage even at the end of the file. The known line count, next-line offset and existing truncation limitation stay available. Engine fixtures cover one long line, a long final line on a later page, UTF-16 text cut at a character boundary, complete short text and ordinary pagination.
Gzip packed members Read all concatenated gzip members within one output limit and validate every trailer before returning contents. Synthetic packed members cover CRC/ISIZE corruption, missing trailers, trailing garbage, empty streams and combined output limits. Verified source 3f3ec6a4: formats tests, fmt and clippy; layers, locks, secrets, wasm and unchanged Cargo.lock; unchanged-code regression failures.
IL2CPP literal byte limits Literal text stays within its output byte limit, including lossy UTF-8 replacements; a clipped valid character is not emitted partially. Synthetic il2cpp_literal_budget regressions (4 tests): ASCII and empty values, multi-byte UTF-8 across every short boundary, invalid bytes, incomplete input sequences and replacement expansion. Format checks and compatibility gates passed at d81b7d570546.
IL2CPP method owners Names and type membership are shown only when method records agree with the types that claim them. Conflicting ownership falls back to header information. Declaring-type and overlapping-range fixtures across each supported layout.
Source map lookup on long lines Binary-search sorted section starts and segment columns. A lookup examines only the matching positions, while preserving duplicates and unmapped boundaries. Regression cases added: A repeated lookup fixture and equal-column and unmapped boundary cases.
Numeric bundle identities Recovered numeric module keys, loader references, browserify dependency mappings and chunk IDs use JavaScript number spelling. Equivalent numeric literals connect to one module identity, while string IDs retain their exact spelling. Synthetic hexadecimal, binary, octal, separator and exponent literals, array tables, browserify maps, chunk IDs and downstream application-graph edges. Decimal and repeated-load controls, existing JS unit tests and esbuild-budget tests pass; no real application was run for this correction.
Preserve void expressions around dynamic with scopes Preserve void zero expressions when a with statement can dynamically resolve undefined. JavaScript crate regression tests on Windows cover corrected behavior and retained controls. No browser or live application run.
Webpack module-loader bindings Module dependencies and application-graph edges follow the wrapper's loader binding. Nested parameters, block variables and catch bindings with the same name do not become module loads; closures that capture the loader keep their dependencies. Synthetic function, arrow and chunk wrappers, destructured parameters, duplicate calls and application-graph edges. Existing JS unit and esbuild-budget tests also pass. Sources above the existing 16 MiB semantic-analysis limit retain name-based resolution; no real application was run for this correction.
App-map role traversal Reachable modules keep their inferred role when many imports repeat the same dependency. The traversal and queue are bounded by distinct newly discovered modules, with the existing role precedence. Public application-graph fixtures cover 52 modules with 2,000 repeated imports per hop, cycles, shared children, orphans, and main/preload/renderer/inline-script roles. Synthetic inputs only.
esbuild module dependencies Recognised CommonJS and ESM wrappers keep their dependency edges after identifier minification; semantic bindings distinguish shadowed and reused names, and repeated calls produce one edge. Ordinary calls do not consume the 4096-wrapper dependency budget, including when the wrapper is declared later 50 JS tests pass. Synthetic regressions cover short names, forward declarations, both wrapper kinds and function/arrow bodies, shadowed parameters, reused names, unrelated calls and duplicates. Public analysis fixtures include 4096 distinct ordinary calls before a wrapper dependency and 4097 real wrapper dependencies to check the cap and first-seen order. No real minified application was run for this correction; sources above the existing semantic-analysis size limit retain name-based resolution
Program facts across builds native_library_calls_list (delay-load too), native_offered_symbols_list, native_publisher_show (checks the file hash and the signature, not Windows trust), app_builds_line_up pairs functions across two builds and says how (Rust names across toolchains too, with the crate hash left out), native_source_folder_write writes pseudo-C to a folder and picks up where it stopped, android_components_list Unit tests. Real PE, ELF and Mach-O files; two builds of a 276 MB program; a signed Microsoft DLL; 69 real signed files (Windows programs, installers and DLLs, signed EFI boot files) match the section-by-section hash, read on Linux, none with gaps between sections and none checked on Windows; Android components from one real APK, spot-checked
Native function body evidence Reference listings and function dossiers include code blocks below the entry while excluding unrelated code in gaps. Pseudo-C infers its entry-block arguments from the actual entry, not the lowest-address block. Real engine calls on an ELF fixture with a backward conditional branch, a referenced string and import, an unrelated function in the gap, and a forward-layout control. Three checks fail before the correction; the control passes.
Native string reference caps native_strings_find lists at most 32 references per matching string, reports reference_count (complete within the analysis unless the analysis xref limit was reached), a per-row references_capped flag, a references_capped limitation when any match was cut, and propagates the analysis xref_limit limitation; native_strings_browse already reports the full count. Engine regression checks an existing one-reference string's count and flag, plus a paginated boundary program whose 40-xref analysis limit leaves 39 references on the first string: 32 listed, the cap flag, both limitation messages, xref_limit on a page whose row isn't capped, and a null function for a reference outside every function. A 33-reference helper regression checks the counting and wording directly.
Native value-flow node limits Incoming parameters and decoded instructions share the requested node limit. Decoding stops at that limit, omitted code is marked partial, and an incomplete block cannot propagate a stale value past an unseen overwrite. Public graph regressions cover budgets below the parameter count, exact limits, omitted returns, backward branches with an omitted entry block, and the per-block decode limit. Complete graphs retain their return and loop edges.
ARM32 value flow A32 and Thumb calls define ARM scratch registers, and word results flow through r0 into returns in native_value_flow_show. Conditional A32 calls retain the earlier value when skipped and a possible returned result; calls to known non-returning targets keep only the skipped path Synthetic instruction fixtures for leaf results and indirect calls in both modes, with AArch64 and x86-64 controls; direct and indirect A32 conditional calls within and across basic blocks, including a named abort target and unconditional controls. This correction was not checked on real ARM binaries or devices
AArch64 address evidence Runtime register addends and memory indices do not become zero offsets. Word arithmetic zero-extends its wrapped result; loads retire written-back base values while retaining their own resolved slots, and calls retire the old link-register slot. Known immediate offsets and ordinary import loads remain resolved. Nine decoded-instruction and real ELF program regressions; eight fail on unchanged production code and one control passes. The fixed checks exclude false imported-function names from unknown offsets and stale base addresses. No hardware execution was performed.
AArch64 control-transfer registers Returns read their selected target without defining it. Authenticated branches read target and modifier registers; calls define only the link register, and authenticated returns read the link and stack registers. RETAA/RETAB conservatively may-read x16 for the additional modifier used with FEAT_PAuth_LR and PSTATE.PACM=1; CPU features and PSTATE are not tracked. Ten instruction and actual value-flow regressions cover ordinary and authenticated returns, both authentication keys, zero and stack modifiers, and a callee-saved target used after a call. Reaching definitions for the possible x16 modifier are retained, while ordinary RET only reads x16 when it is the selected target. No hardware execution was performed.
EVM metadata arrays Ordinary three-integer metadata arrays keep their array type. Version formatting is limited to compiler version fields. Solidity and Vyper version controls, unrelated arrays, invalid version shapes and truncated CBOR.
EVM dispatcher selector lookup Deduplicate numeric selectors with a bounded ordered set before formatting, preserving first-match evidence and the 4,096-selector cap without repeatedly scanning the output inventory. Four regressions cover duplicate destinations, encounter order, PUSH-width aliases, rejected candidates and unique-selector limits; optimized production-module timing compares repeated large dispatchers.
AArch64 exclusive memory operations Exclusive stores define their status result; pair loads define both results, and acquire loads retain their load classification. Pseudo-C preserves exclusive instructions as assembly, including loads from known import slots, so monitor and conditional-store behavior is not replaced with ordinary assignments. Eleven synthetic decoder, register-flow, pseudo-C and real-ELF regressions pass; eight fail against unchanged production code and three controls pass. Covers all single-store widths, acquire/release variants, discarded results, retry conditions, both pair outputs and ordinary memory operations. No hardware execution.
AArch64 discarded arithmetic results Writing an arithmetic result to XZR or WZR keeps both source registers as inputs, without inventing a write to the first source. Reaching definitions and proven import-slot bases remain available to later instructions. The arithmetic-only handling preserves the result registers of exclusive pair loads and atomic operations. Seven public-decoder, def-use and ELF import-resolution regressions cover 32/64-bit arithmetic, logical and divide/multiply instructions, flag-setting aliases, real destinations, stack-pointer updates, zero sources, load writeback, LDXP and LDADD. No AArch64 code is executed.
AArch64 extended memory indices A register-offset memory operand keeps the index register's width and its extension or shift: [x1, w2, sxtw #2] addresses with the sign-extended 32-bit index, [x7, x8, lsl #3] with the shift, and an index used unchanged stays plain. The operand list, the instruction's register reads and pseudo-C agree; x86 scaled indices keep their scale rendering. Decoder and pseudo-C regressions cover SXTW, UXTW, LSL and SXTX indices over 32- and 64-bit loads, a sign-extended word store, a halfword store, an unextended W index and an unshifted control; both fail on unchanged production code. Instruction words follow the architecture's register-offset encoding and were checked against LLVM's disassembler; no AArch64 code was executed.
AArch64 MOVZ/MOVK constants A MOVZ (or an already folded MOVK) beside a MOVK on the same register, with nothing between that reads or writes it, lifts to one constant assignment (w9 = 0x92492493;), chaining across a full 64-bit build and keeping a W pair's 32-bit domain. A read between the pair, a page load that overwrites the register, or a MOVK on an unknown value keeps the two statements; x86 lifting is unchanged. Pseudo-C regressions cover the roadmap's W pair, a four-MOVK 64-bit chain, a MOVN low half, an intervening read and an intervening page load; the fold test fails with the folding disabled. Instruction words were checked against an independent disassembler; no AArch64 code was executed.
EVM payment guards A CALLVALUE read is evidence of a payment guard only when a conditional branch sends nonzero payments to a rejecting path. A guard bypassed before dispatch is not applied to every selector. Runtime bytecode fixtures with a plain read, a rejecting guard and a bypass.
Require matching operands before reporting EVM dispatch facts Require the selector division operand order, the Vyper memory load and the four-byte calldata threshold before reporting those dispatch patterns; invalid jump destinations retain unknown payability. Regression fixtures cover unused and reversed selector divisors, unrelated arithmetic, different calldata thresholds and invalid jump targets.
EVM metadata map identity Duplicate keys and map keys outside the supported text-key representation leave the trailer in the analyzed bytecode instead of overwriting metadata entries. Synthetic trailers cover duplicate compiler versions, identical duplicates, numeric/text collisions, non-text key forms, nested maps and ordinary compiler metadata.
Stand-in backends web_standin_build turns a HAR into standin.json (secrets dropped, varying path parts templated); web_standin_start answers from it on loopback; web_standin_show lists what it had no answer for. A 304 without a usable cached body is counted at build time and skipped during replay; if its matching group has no usable answer, requests get a 404 with cached_body_unavailable, also shown in the request log. Writes replay what was recorded and don't change later reads. Older saved query variants keep explicit empty pairs when credential rules are reapplied; raw separators remain ignored and the 200-pair limit matches capture. App maps list GraphQL and tRPC operations; web_walkthrough_check checks a scripted session without a browser. A Deep website study writes capture/original.har from the start page's traffic and the answers it gave (analysis::web_har::har_from_network), so a rebuilt front end can be given a stand-in from a recording the study made itself, and the brief then says so Unit tests, real loopback requests, and a run with curl on a hand-written HAR. The 304 correction passes 99 analysis tests and a real-loopback regression, covering mixed samples, omitted bodies, matching boundaries and existing v1 files. Hosted CI for #543 also passed the full engine tests and workspace gates. Public capture/replay regressions cover legacy empty pairs, raw separators and the query-pair limit. A recording written from kept browser requests builds a stand-in in the tests, and the brief test writes its recording with the same function the study uses. No live study recording or real front end yet
Stand-in sample metadata Consecutive samples compare all response fields before retained bytes are charged. Header comparison ignores name case and ordering between different names, while preserving repeated-value order and the stored headers. At capacity, a usable response replaces only an unavailable 304 for the same path, query and request key; refused bodies preserve existing evidence. All 24 combined replay regressions pass locally on the refresh onto cf414ff4. The same replay implementation and four regression files passed in frozen candidate 8758b6df on base b2d7e89e. Historical standalone revision f79dc0bd passed its 14 metadata and header/capacity regressions in full Linux CI. See this PR's checks for the current revision's complete gate.
Reject unsupported HTML script type suffixes Match HTML script types against complete JavaScript MIME names and the exact module keyword. JavaScript crate regression tests on Windows cover corrected behavior and retained controls. No browser or live application run.
Exact HTML module script keyword Whitespace around the module keyword and whitespace-only types stay out of script evidence. Classic MIME types still accept surrounding ASCII whitespace. Fixtures cover padded keywords, a decoded line break, the empty type and classic MIME controls.
Legacy HTML script language HTML script evidence applies legacy language values when no type is present. An explicit type controls classification. Fixtures cover unsupported and classic languages, whitespace, and explicit type precedence.
HTML comment endings The HTML scanner resumes after browser-recognized --!> comment endings. Tags inside comments remain hidden. Regression tests and a check against Edge 157 HTML parsing.
Bogus HTML comments Unknown declarations and malformed end tags no longer contribute scripts or preloads hidden inside comment text. Fixtures cover both openers, EOF and resuming at real tags.
Incomplete HTML start tags Script, preload, title and CSP evidence comes from complete start tags. Earlier complete tags survive a truncated page ending. Fixtures cover quoted and unquoted attributes, a quoted greater-than sign, and complete tags.
HTML meta security policy list Page evidence retains nonempty meta security policies in document order in the existing string field. Fixtures cover multiple policies and blank or missing content.
Websites as targets web_site_open keeps a private browser for the session and deletes its temporary profile when the browser closes or fails to start, and on macOS and Linux a watcher stops the browser and deletes the profile if the app ends without closing it (#810); every browser tool inspects that page; web_site_capture records screenshots at each width (desktop, tablet and phone), rendered HTML, design tokens (colours in hex, spacing, content widths), the CSS breakpoints, the layout at each width (page width, heading sizes, each section's padding, gap, content column and items per row), page health (script and console errors, failed requests) and an accessibility outline, layout outline, assets with font files and requests, links and form outlines. In Clean room the capture keeps only what a visitor sees (no HTML, CSS rules, scripts, requests or errors), and opening a site reports no load errors. A JavaScript dialog the page opens by itself no longer stalls the open (#2010): an alert or beforeunload is accepted so the page can go on, a confirm or prompt is dismissed so nothing is agreed to for the person, and the result and page health list each dialog with its answer (in Clean room too). A site behind a sign-in can be studied signed in (#1178): web_site_sign_in opens a visible window where the person signs in themselves (we never see the password or read cookies; saving passwords, addresses and cards is turned off in those profiles, and the browser's password and card stores are never copied, including from profiles saved before), the profile is copied into Craft Anything's config folder when the window closes, and later opens of that normalized host and effective port use a copy by default (HTTP defaults to 80, HTTPS to 443). The sign-in window waits without holding the engine session lock, so other tools remain usable; overlapping same-site saved-profile operations return a retryable busy error, while other sites and explicitly fresh opens remain available. Replacing the saved profile restarts the study browser; signed_in: false always starts fresh, and web_site_sign_out forgets it; a restricted MCP server (--restricted, even with --allow-web) always opens fresh and refuses signed_in: true; a sign-in records its evidence and journal entry in the project it started in, and Stop ends its wait for a busy session without losing that record; capture.json and the brief say when a capture was signed in, and a signed-out capture of a page with a password field suggests signing in. Sign-ins that last only while the browser is open are kept too (the sign-in profile is set to continue where it left off). Right after saving, the site is opened once more headless to check it: check.sign_in_page says whether it still asks for a password, with a picture kept in the site's own owner-only folder. A capture using a saved profile that still asks for a password says the sign-in may have ended. Otherwise the builder is told profile use does not prove authentication (public pages and passwordless sign-in can still be signed out), and to ask the person if the intended view is unclear. The Flatpak build can't start a browser on the computer (#841) Live runs on example.com and a local page with Chromium on Linux, and on a local page that opens an alert on first visit with Chrome 157 on macOS (timed out before #2010, opens after); including profile cleanup after success and failed startup; the sign-in handoff (window under a virtual display, a scripted sign-in, headless capture signed in), overlapping signed-in opens, the timeout and no-desktop paths ran live with Chromium 157 on Linux against a local test site; the window's own report (chrome://version, chrome://prefs-internals) that it opens the Default profile with password and card saving off ran live with Chrome for Testing 156 (the_sign_in_window_runs_the_prepared_profile_with_saving_off, with a --no-sandbox wrapper because this host's AppArmor refuses an unprofiled Chromium's sandbox); unit tests. Session-lock concurrency, cancellation finalization and same-site reservations have deterministic stand-in regressions; no new live-browser run for that correction. Brave on macOS was not run; a confined Snap or Flatpak browser and a real site's sign-in were not run
macOS signed-in website study Running-browser markers are excluded before profile metadata is read; session-only cookies are restored without copying old tab files. Chrome for Testing 157: both live sign-in runs passed on macOS; the Linux-only no-desktop test returns early. Keychain and password-bubble behavior were not observed.
Electron window comparisons app_graphs_compare retains every unassigned window and every construction with a reused local binding. Windows are paired by module, binding and occurrence, so inserting comments does not hide preference changes. Colliding display labels receive a separate #N suffix without changing literal binding names or occurrence indices Synthetic applications parsed through the ordinary analyzer exercise anonymous and reused bindings, shifted source lines, unequal counts, literal names resembling occurrence or collision suffixes, and stable labels when only one window changes. Pairing remains positional within each binding group; reordered constructions and real application releases were not checked for this correction
Repeated evidence observations Bundle comparisons retain every operation/subject record, match verified identical IDs first, and preserve repeated-record counts. Remaining versions pair in a stable order without hiding altered records. Nine Engine regressions cover exported text pages, same-parameter annotation versions, additions/removals, tampered copies, duplicate IDs and record order. Eight regressions fail on unchanged production; all nine pass after the fix.
Build tool app/ path fallback build_files_list, build_file_read, build_file_edit and build_file_write fall back to app/ when given a relative path from build_command_run compiler diagnostics that does not exist at the workspace root (and for build_file_write, when its parent folder exists inside app/ and not at root), while normalising leading ./ components so app/… and ./app/… never fall back into a nested app/app/ and keeping root-level stray file detection and containment checks intact Unit regression app_relative_paths_fall_back_to_app_dir covers read, edit, list, new-file write, overwrite, root stray-file behavior, and ./app/ equivalence with a nested app/app/ present
Rebuild workflow (Study → Build → Check → Refine) crates/ai/src/rebuild/ (kinds, checks and stacks are pluggable: docs/extending.md). Three kinds: website, app, game (a project whose stack is a game engine is always a game). A new website's builder writes app/README.md saying how to build and serve it without Craft Anything, which serves the built folder itself (#1590). A new build whose stack needs a program this computer doesn't have (Cargo, for the Rust stacks and Bevy) stops before the builder's first turn, saying how to get it (#1837). The request decides how to build: a language, framework, engine or platform it names wins over the kind's default stack (Rust + egui for apps, Unity for games, the original's for websites), and the build check, the recorded stack and Play follow what was built (an Electron app opens in its own Electron; a plain static site has nothing to build and passes the build check as it is). Websites: Study also captures up to 4 other pages of the site; menus are opened on a computer and on a phone; the check serves the build on loopback and compares every page at 1440, 768 and 390 px (likeness = mean of layout and perceptual detail, SSIM, averaged over pages, leaving out the parts of the original that change by themselves, found by photographing it three times; the note adds text, page structure, the colours, font, text sizes and spacing the build misses, and per width a page that scrolls sideways, heading sizes and sections whose padding, items per row or content column differ, the errors, failed requests and accessibility gaps the build adds, and the opened menus and pop-ups). A stack or library named in the request (Next.js, shadcn/ui, Tailwind CSS…, stacks.toml) is what the builder uses; with none named, a website's stack is the builder's choice (told to match what the original is built with) and the stack it used is recorded from app/package.json. The builder leads: it studies, asks the tools follow-up questions, records what it can't find out as unknowns (core_unknown_add; the run reports the open ones), and tests its own build mid-turn with rebuild_check (the same checks, for every kind); a check with anything it couldn't compare, or any claim that fails (a website page that scrolls sideways, logs new errors, fails to load a file, lacks a landmark, or a menu that doesn't open; for games each self-test step, for mechanics sheets the still-unmeasured behavior, for console apps the same exit and output as the original's runs), isn't good enough; apps and games by whether they build. Up to 6 refinement rounds, or until a website reaches 90% likeness. A turn cut off by a time limit, crash or dropped connection resumes (up to 3 times); builder turns may run 24 h. A project copied from another computer (or moved to another folder) keeps building with Claude Code: the project keeps a copy of the builder's session (agent-session.jsonl) after every turn and puts it back where Claude Code finds it on a computer without it, so the same conversation carries on (#451); when the session still isn't there, a new one starts from the brief, what's in app/ and the kept requests and replies (or the last summary), and questions about the build put the kept session back too, else are answered from the files and forget the missing session (#452). A session is resumed only in the mode it was saved in (R2.9): agent_session_deep in craft.json; one saved before the mode was kept counts as Deep, so a Clean room build starts from the brief and a Clean room question is answered from the files rather than continuing a Deep session; a run whose kept conversation is in the other mode studies again, and so does one whose capture was studied in the other mode (capture_deep in craft.json; a capture from before the field counts as Deep, and one with no recorded mode is studied again), so a Deep capture isn't handed to a Clean room build, and the API loop does the same when its transcript is from the other mode; the project keeps one session at a time, so a build that saves a new one in the other mode replaces the id and its mode. The shared investigation chat follows the same principle for its agent session: after a switch from Deep to Clean room it starts a new session instead of continuing the Deep one, while Clean room to Deep still continues. Live runs with Claude Code 2.1.316 on one Mac (2026-11-02), a second computer stood in for by a separate signed-in CLAUDE_CONFIG_DIR: a copied project's session was put back and resumed (the builder recalled its first reply from memory); a kept copy of another session was refused and the new session used the handoff; a real project synced from Windows whose session was missing started afresh and reached Ready. Not yet run between two real computers Unit tests for prompts, stack choice, site detection, feed folding; live runs reached Build and decompiling (below)
Console numeric comparisons Capture two original runs per input. Compare the number count and numeric positions that agree across those observations, while ignoring varying timing or process values. A changing count or unavailable repeat has an explicit word-comparison fallback. Program-name normalization preserves exponent spans. Sixteen public regression groups and a real Unix counter program cover stable signed results alongside varying timing, number counts, incomplete and legacy captures, exponent-like filenames, decimal/radix notation and large integers.
Check rounds that can't stall silently A round of the builder's own checks has a 30-minute limit; Pause is looked at before each check; and every check is said as its own step ("Checking its work (2 of 4): app-screenshot…" in the Build stage, "Checking the build (2 of 4): …" in the Check stage), so a stall names the check it is in. A check that would start past the limit is reported as not run, and a check already running is stopped at the limit by its own program runs, which watch the round's limit and the person's pause — a build step that makes no tool call is cut too. A run that ends by a caught bug records "Needs you" with why, instead of leaving the project saying "Checking" while nothing runs Unit regressions: a round past its limit, a paused round and a round with time left; a real round's check lines arrive as Check steps and a self-check round's as Build steps; a running build step is cut at the round's limit; a step that would start past the limit or while paused is refused before it starts; a caught bug leaves NeedsYou. Not checked: a live Windows build with Godot/Codex (the reporters' setup)
Context-summary usage Successful API context summaries contribute to the message totals consumed by build usage and receive a model_turn journal entry with purpose: context_summary. Input tokens include cached ones, as coding agents report them (Ollama 0.40 sends them apart). Cached-token pricing is retained; an unknown summary price makes the total unknown, and a failed call adds no invented usage Scripted-model tests exercise the real ApiConversation, transcript resumption, exact input/output and cache-price totals, journal entries, empty summaries, local zero cost, unknown prices and failed summaries. No live provider or end-to-end rebuild was used for this correction
Local model builds Regression coverage confirms that a fenced call followed by a summary or protocol marker is not run and the next model message says to retry it without trailing text (R5.4). Protocol markers between calls retain this retry condition even when later calls follow; ordinary words between calls remain supported in both ReAct modes. No live local-model build has been run after this change. Earlier, Ollama 0.40.7 with qwen2.5-coder:14b (32k context) wrote calls as JSON text, which ran whole or after a sentence; by check 3 its project compiled, but main.rs was still cargo's "Hello, world!", so the screenshot check failed at the round limit. A lean local builder's prompt asks for no memory tools it isn't offered, and a project one folder down is named in the check Historical live evidence: four CLI builds of "a scientific calculator" on Windows (RTX 5090), 2026-11-04, one fix added per run
Builders that can't see pictures A builder in the API loop (BriefCx::sees_pictures is false; agent apps open pictures with Read) is never sent to open or look at a picture. In its place: capture.json's layouts for a website's screenshots, each round's checks/round-N/capture.json beside the original's, a program's capture/ui-tree.json and the check's likeness, and asking the person with core_person_ask what their pictures show. Agent apps' prompts are unchanged apart from the --screenshot contract's last sentence (R5.4) a_builder_that_cant_see_is_never_sent_to_a_picture covers every kind, target, mode and picture case (144) and was shown to fail when a sighted phrase came back; all 150 sighted briefs and refinements were compared byte for byte before and after. No live API-loop build was run after this change
API answer time limit timeout_secs in [[ai.backends]] also bounds an API backend's streamed answer, waiting for it to start included (five minutes to start and one hour in all when unset or 0), so a slow local model can take longer for a long answer (#1096). A stream that runs out of time says to set it Unit tests for the limit taken from the setting and for the remediation on a body timeout; no live slow model was run, and a request queued on a shared server (#1239) was not run live
AI connection errors An API backend that took the request and didn't start answering says so, instead of "Couldn't reach". For an address on this computer (localhost, 127.x.x.x, ::1), the advice says a large model may still be loading or reading a long prompt and that a smaller context length helps, and a failed connection says to check that the server is running on this computer, without the internet advice remote services get Unit tests for both kinds of failure on local and remote addresses, and for what counts as this computer. Seen live with a local Ollama whose 131,072-token model took over five minutes to start answering (before the change); the new messages were not run live
Backend request rate requests_per_minute in [[ai.backends]] spaces an API backend's requests out for a service that limits them (120 for two a second): each waits its turn, across every conversation on that backend in the app, and Stop ends the wait. Zero or omission sends them as they come. Set it in Settings → AI, using ai request-rate <name> [requests-per-minute], or in config.toml. Coding-agent apps send their own requests and aren't paced pace tests cover the spacing, a second backend not waiting, and a stop; no live provider was used
Backend context budgets context_tokens in [[ai.backends]] controls when an API conversation is trimmed and summarised. Zero or omission retains local/cloud defaults; a nonzero conversation override takes priority. Before each attempt, including a fallback, fitting adds estimated history growth since the last successful request to its reported input size. Trimming resets that reference, and successful requests refresh it; summary usage remains in message totals. When a server refuses a request for its context window and says the size (Ollama and llama.cpp's "exceeds the available context size", OpenAI-style "maximum context length is"), the error carries it (context_window, prompt_tokens), the conversation is fitted to three quarters of it (it replaces the local/cloud guess; a set budget stays the most) measured with the server's own count, and the request is sent once more, by each backend in the chain and only when room was made (without the server's count, the refused request is taken as one token over the window); if that fails too, the remediation says how to raise the window (#962). Before a backend's first request, and once more after it while the server hasn't said, an OpenAI-compatible server or OpenRouter is asked for the window it has loaded (crate::window: context_length, context_window, max_model_len or meta.n_ctx in its model list; one on this computer or its network is also asked through llama-swap's /upstream/<model>/props for a loaded model, llama.cpp's /props, LM Studio's loaded_context_length, Ollama's /api/ps); three quarters of it is the budget for a local model, and it only lowers a paid service's 150k default; a budget set on any backend is kept up to the window Regressions cover settings and model construction, defaults/overrides, smaller fallback budgets, large-budget arithmetic and new tool output growing beyond a fallback budget even when the history estimate alone is below the reported input. The latest tool results are preserved, and a short follow-up does not count already-sent history twice. a_request_too_long_for_the_servers_window_is_fitted_and_asked_once_more covers a refit that then fits and one that doesn't (asked once more, never again); a_refit_makes_room_first_and_each_backend_gets_its_own covers a refusal without a count, one with nothing to trim, and a fallback refused for its own window; the window is read from the whole message, and OpenAI's prompt part "in the messages", not its total; the server's two wordings are parsed in http. This does not set server context parameters, and LM Studio's refusal names no size, so it isn't refitted; no live provider was used for the refit. Each window probe has unit tests on recorded response shapes (an unloaded llama-swap model is never asked through its upstream route, a trained window is not taken for the loaded one, hostile shapes read as nothing); asked live, a llama-swap server read 524288 from its model list for a loaded and an unloaded model and loaded nothing, and a real chat through it journaled that window before its first request; its /upstream/ route read 262144 for a loaded model and for an alias of it, and nothing (loading nothing) for an unloaded one. With Ollama 0.40.15 and qwen3:0.6b, a chat before the model was loaded logged no window and one after read 4096 from /api/ps (Ollama's default). LM Studio and plain llama.cpp were not run live
Builder tool lists Each API backend's tools in [[ai.backends]] picks the tools a builder on it is offered. Lean is the building list (#417, LOCAL_BUILDER_CORE) and a system prompt without the memory steps; Full is every tool and the memory steps. Auto (the default) is Full on a paid service, and on a local model Full when the conversation's budget is FULL_TOOLS_BUDGET (49,152, a 64k window less its quarter) or more, else Lean, so a local model with no window known stays lean as before. The loop asks the server for its window before choosing and chooses again before each turn, rewriting the system prompt when the list changes (journaled as tools). Chats keep every tool (R5.4). Choose it in Settings → AI, which shows what Auto works out to for that AI (by its window on a local model, every tool on a paid service), or with ai tools <name> [auto|lean|full]; Auto is saved as no setting, and agent apps are refused (they choose their own tools) ai_tools_reads_changes_and_clears_an_api_backends_tool_list and an_api_backends_tool_list_is_chosen_in_settings cover the CLI and the Settings choice. a_builders_tool_list_follows_its_setting_and_the_servers_window covers each setting on local and paid backends, a window named after the first turn (lean, then full), a set budget and a chat; it was seen to fail when the prompt wasn't rewritten and when the server wasn't asked before choosing. Live on Linux, a Qwen model with a 512k window through llama-swap (2× RTX 6000), "a scientific calculator" with no target and one refinement round, unattended: Auto chose the full list (budget 393,216) before the first request. 2 of 3 full-list builds were Ready (22 and 26 minutes, the check's screenshot a working calculator) and used the brief, handoff and finding tools, one also enabling the Runtime toolset to read its own window; the third stopped at check 2 in 3 minutes after the model twice wrote calls to tools that don't exist (web_search, web_fetch) as text, which ended its turn. The same build on the lean list was Ready in 32 minutes. A small local model wasn't run
Games Engine detection for 12 engines (Unreal, Unity, Godot, Source, GameMaker, RPG Maker, Ren'Py, MonoGame, LÖVE, CryEngine, Cocos, Cube) with versions. Unreal and Godot games are rebuilt in the same engine, others in Unity; installed engines are found, Godot installs itself, others get guided installs. Picking an inner folder (Engine, Binaries, Paks…) finds the game's folder. In a Windows game's folder picked on Linux or macOS, its .exe is the program to study (Ghidra in Deep mode), although nothing tries to start it there. Just look inside a game shows what it's made of (core_target_triage on its folder: engine and version, how its code ships, the libraries its Unity assembly names give away, its own code, scenes and size) and opens it in the chat to ask about it. The builder keeps app/MECHANICS.md and its structured twin app/mechanics.json (checked after each build), in Deep mode only, may reuse the original's readable files for private use (never decrypting; generated pictures and 3D models replace its art when the person turns them on; Clean room copies none of its files), lists them in CREDITS.md (checked, with the private-use line in README.md); a game is ready only when its --self-test shows the player moving, acting and the HUD drawn, and the result can be started from the project page Unit tests; live runs on Windows
Explicit Phaser and Bevy game requests A request to use Phaser or Bevy selects that framework without requesting an editor installation. Seven stack catalogue tests on Linux, including Phaser with Vite, Bevy, and a phaser cannon mentioned in game content.
Clean room and Deep mode Clean room (the default) runs only the tools in engine/src/clean_room.rs: ones that touch no target or watch from outside (the website as a visitor sees it, pictures of a window, its controls, recorded runs, a phone's screen). Every other tool, a plugin's included, is refused in the app, CLI, MCP and agents, with a way to turn on Deep mode. A Clean room build studies an app or a game only from the person's pictures and words (and a picture of its window when runtime study is on); its builder's reads and commands go through an approval rule that keeps it out of the original's folder and site (with Claude Code, and with ACP agents for what they ask about; other agents aren't held to it, see roadmap R2.2). A builder over SSH starts the remote host's own craft-anything-cli mcp with this run's --deep or --clean-room, so the remote settings don't decide the mode; every release since 0.1.0 knows those flags and --all-tools, the only ones it is given (a test on mcp_for keeps it so; Codex's adapter adds only --all-tools). Claude Code, Codex and OpenCode builds over SSH first check that the host has craft-anything-cli. No release up to 0.5.0 reads CRAFT_ANYTHING_AGENT, so there a CLI the remote builder starts calls tools as the person (R2.8). Deep mode (deep_mode in Settings, --deep for one CLI run) uses every tool: the builder sees them all, and a website's study also reads its JavaScript and watches its start page for ten seconds (capture/how-it-works.md). Ghidra adds its decompiler in Deep mode when it's installed: it is found, or installed after asking. Study starts one analysis of the main program, saved and shared with the builder's tool server through a lock file (up to 8 h, Java gets half the machine's memory or the amount set in Settings → Engines, 4 to 31 GB, four slow passes skipped). The builder must decompile before the build is checked; addresses the built-in analysis can't place go to Ghidra, which makes a function on demand (for this run only) where its analysis has none, e.g. code reached only through tables of pointers. Before a decompile, a jump on a byte through a table with no bounds check (Rust's async state machines) is cut to the table's real entries, so it doesn't run away (#1715). Without Ghidra, Deep mode uses the built-in engines Live runs with Ghidra 12.1.4 on Windows (a shared analysis, and a decompile in seconds on a large program). Live runs with Ghidra 12.2 on Linux x86-64 (decompiles by name in position-independent programs and shared libraries, whose addresses Ghidra moves). The guided install of Ghidra and its Java is offered on Linux and macOS too. On Linux it was tried on 2026-11-16 (main at 8dec7849, through engines_install, which the app's Settings → Engines also calls): on a clean Debian 13 container and on a Debian 13 desktop (x86-64), it downloaded Ghidra 12.1.4 and Temurin 21 in 43–64 s (1.2 GB in the engine store), engines_list then found it, and a Deep-mode native_function_pseudocode came from Ghidra (engine: ghidra) in about 10 s. The Java it brings is also the Java runtime other tools use (Vineflower decompiled a jar with it, and JADX gets it as JAVA_HOME, so Java source of an Android class comes back with no system Java; Debian 13 container). Ghidra laid out as Arch-based packages install it (in /opt/ghidra, with a /usr/bin/ghidra start script; recreated from the official release, as Arch's own repositories have no package) is found with no setting and with the Ghidra folder set to /usr/bin (#85). With the Ghidra folder set to a file, the file is run only if it is the headless launcher or a script that runs it; the /usr/bin/ghidra start script and a linked ghidraRun are followed to their Ghidra folder (tried live on Debian 13 with that layout: decompiles came from Ghidra), and any other file isn't listed as Ghidra. Not tried: macOS, the app's buttons themselves, and a distribution's own Ghidra package. Clean room and Deep mode: engine, AI, MCP, CLI and app tests; no live Clean room build run yet
Auto mode Settings → Safety, on by default. Builder actions go ahead without asking, except a fixed set that is never done unasked (deleting outside the project, system changes, publishing…); questions get "decide yourself"; asset spending stops at the budget. Each project can choose allow, ask or refuse per kind of action instead (project_approvals_set, the Approvals menu under the prompt box, or /approvals publish ask; read-only gh … view/list count as commands, not publishing) Unit tests, UI tests; not tried in a live build
Generated assets Off until the person turns them on for a game (the switch on Make and on the project, project_assets_allow, rebuild --generate-assets, saved in craft.json; turning it on without a fal.ai key asks for one); the brief and the asset tools need both that and a key. assets_image_generate (Nano Banana Pro by default) and assets_model_generate (picture → Tripo P1 low-poly GLB with a face limit) through the person's key for each asset provider (fal.ai today), with agent apps and API-key builds alike; per-project budget, $5 by default ([assets] budget_usd in config.toml); models and prices from the assets.toml table (picture model selectable: Nano Banana Pro, FLUX dev or schnell; priced per picture or per megapixel); every call reports its cost Unit tests; a live 3D generation with a real key (picture, then model) with FLUX dev; Nano Banana Pro not yet run with a real key; an API-key build not yet run with one
Claude Code builder Runs the person's own claude in headless mode (no --model by default, so the model its own settings name applies, custom ones included; a built-in Claude model can be picked instead; high effort unless configured) with our MCP server, a permission-prompt tool and core_person_ask; preflights for our CLI (a build stops plainly if it's missing or won't start) and sign-in Argument and stream-parser tests; live preflight; live builder turns; see claude-code.md
DeepSeek Harness builder Runs the person's own dsh --profile headless with the preamble and task on stdin, which answers one task and prints its last message as text. The harness takes its tool servers from profile patch layers and has no per-run flag for one, so our tool server arrives as a generated --patch overlay for that run (the run's project, inbox and mode included), under a server name of its own so it doesn't clash with a craft-anything entry the person registered; the person's own profile is untouched, a question gets no tool server, and its headless profile keeps no session to resume. Standard npm shims are unwrapped to their interpreter; the desktop app's custom .cmd launcher receives only options, avoiding batch newline and command-line length limits. Requires a headless profile with stdin support (0.2.2-rc.1 verified); older versions without it reject the missing task and need updating Adapter and YAML-overlay tests; live preflight (ai test); live builder turns on a website (follow-up build, 3 min 10 s, 100% alike at 1440/768/390 px, Ready) where the builder's own journal entries show rebuild_check, core_unknown_add, core_plan_update and core_handoff_write going through our tool server, and that server started with the run's --project/--inbox. Not checked: resume (none exists) and a build with the harness's desktop profile. Also verified on macOS arm64 (2026-11-07, DSH 0.2.2-rc.1, stored sign-in restored for the headless profile as its README describes): a static website reached Ready with one check pass, and the builder called our MCP tools after renaming a pre-existing craft-anything MCP registration to avoid the generated overlay's matching serverName; Windows (2026-11-07): the new batch-launch regression failed with the reported startup error before the fix and then passed, including exact UTF-8 and 40,831-character task delivery. A patched Craft CLI chat through the official desktop dsh.cmd returned the expected answer with a local authentication overlay; no new GUI or full rebuild run was performed
Aider builder Runs the person's own aider --message-file <file>, one message per run: the message is written to a private file in the temp folder and removed after the run, so a long one passes Windows' command-line limit (#402); over SSH it still goes in --message. Flags stop it asking or acting on its own: no git repository or .gitignore change, no update check or release notes, no analytics, Playwright, URL or shell-suggestion prompt, no model-warning page, and plain output. BROWSER points at a command that does nothing, so no page can open from a run. Before a run it refuses when no model or key is set up, or an OpenRouter model has no OpenRouter key: both would offer a sign-in and wait five minutes for a browser nobody is at (#72). That check reads Aider's settings (.aider.conf.yml, .env) where Aider does: in the folder the run starts in (links resolved), at the top of its git repository (a .git file, or a .git folder with HEAD, as GitPython finds it) and in the home folder, plus an --env-file from its arguments; the one Aider loads last wins, and a .env wins over the environment, as Aider loads it over the environment. An empty KEY= in a later file doesn't clear a key set in an earlier one, and --config isn't read. Its arguments count --api-key, --set-env and Aider's dedicated --<provider>-api-key flags; config key lists may be block or flow style. Over SSH the bounded preflight checks the remote environment and home settings, plus a named --env-file when supplied. Only the two definite answers refuse (no model or key, or an OpenRouter model without its key); any other check failure is logged and the run starts, so a host without awk/wc, an unreadable file, or no POSIX sh fails later with ssh's or Aider's own error. It sets BROWSER=true on the SSH host. Outside a build --dry-run keeps a chat from writing files. Aider gets no tool server, and its own reads can't be checked, so a Clean room run is refused (R2.2). A failed flag check keeps this adapter: Aider's plain form reads the message as a file name Argument, registration and setup-refusal tests, including settings in the project folder, the git repository's top and which file wins (from Aider's main.py; not run against a real Aider). Ran Aider 0.86.2 with these exact arguments: no prompt, no browser, reached the model call; the no-model and OpenRouter cases were reproduced (each waited for the sign-in) and are now refused before the run, and also at a real build start with the key unset. Live build (2026-11-07, Linux, Aider 0.86.2 through rebuild --backend Aider --unattended, one round, free nvidia/nemotron-3-ultra-550b-a55b:free through OpenRouter): a static site reached Ready in about 66 s with four files written in app/, no question waited and no browser opened; the file-creation questions took their default on closed stdin. The page only shows an alert where the request asked for a colour change, so the output was not judged. An earlier try with cohere/north-mini-code:free looped, wrote nothing and stopped after two turns, and Aider offered to open a help page that opened nothing. Aider reports no token counts, so usage shows 0. Not checked: a stronger or paid model, resume, Windows, macOS. --message-file (2026-11-15, Windows 11, Aider 0.86.2, these flags): a 40,000-character file was read and the run went on to the model call; no build was run on Windows. Remote setup regressions run the on-host script with a fixture HOME and cleared environment: absent settings, an unreadable settings file, a host-exported key or model, a saved OpenRouter key, .env, a quoted --env-file, the last assignment in one dotenv file, and no credentials on the command line. A pre-stopped run returns Cancelled before ssh starts. Only the two definite answers (10 and 11) refuse; 12, 13 and other codes log and proceed.
GitHub Copilot Installed copilot through ACP by default, with CLI-owned login (no credential import), explicit Craft Anything MCP tool allowlist, model selection and fresh read-only build questions. Target handoff retains the last 128 entries with the active target last; context discovery respects tool cancellation and shared picker warnings name the agent Authenticated builds, model discovery and real-account session resume confirmed by the person using the app. Target-boundary, cancellation and agent-warning regressions supplement unit tests and an offline CLI 1.0.105 compatibility test covering all five access modes. See copilot.md
Grok Build Installed grok through ACP by default (grok agent --no-leader stdio). Sign-in stays in grok login. An existing auth.json counts as signed in and is not read; a missing file is unknown, so the run itself reports an authentication problem. XAI_API_KEY is separate: detection reads it and the xAI API backend can use it; this adapter does not. Clean room, deep chat, and questions are refused, because Grok can read and edit without a permission request and grok agent has no flag that holds those modes. A deep build is allowed. The chosen model is applied with session/set_config_option after session/new, because the CLI --model flag does not survive that call. Reasoning effort is passed after agent and set again after the model. Our MCP server is attached on the session, and only this agent is sent "type": "stdio". The person's own Grok MCP servers are not removed. Thinking uses the shared model picker; there is no context-window control. acp = false and SSH are refused Scripted ACP tests for the argument order, "type": "stdio" on Grok's server only, and session/set_config_option before the prompt, including a value the session already has. initialize, session/new and session/set_config_option were checked against Grok 1.0.77. A live deep build on 2026-11-06 (Grok 1.0.77, temporary ask-mode home) finished, called the Craft Anything server, and answered one permission request. The person's own config was not changed. See grok.md
Shared investigation for local agents A worker saves session-only investigations before starting MCP, shares open targets in a mode-aware handoff, and reloads externally recorded evidence/findings. Builder refresh failures warn rather than ending the turn. The workbench Evidence pane shows fnd_* records with proof links; core_finding_edit preserves ids and omitted confidence while checking evidence and stale revisions Engine persistence/correction tests, process-level MCP target tests in both modes, and headless findings-rendering test; live authenticated target-to-finding workflow confirmed by the person using the app
Copilot model options Shared agent catalogue, model/thinking picker, cli_model/cli_thinking and ai_models_list/ai_model_set; selected-model reasoning metadata reloads without a prompt. Context tiers remain separate through ai_model_options_show/ai_model_options_set, preserving thinking. Legacy reasoning settings remain readable Isolated catalogue/validation, flags, persistence, stale-result and headless UI tests. Previous authenticated metadata checks used CLI 1.0.105; no new live-account run after the shared-picker rework. Numeric context limits are not advertised in its initial ACP metadata
Investigation writer coordination Every project-backed mutation holds one OS file lock over load, revision validation, mutation and state/Markdown writes. Waits are bounded and cancellable; unreadable state is not overwritten Separate-process append/revision-race tests, matching Markdown renders, lock timeout/cancellation/release and malformed-state regressions
Agents over ACP Opt-in per backend (acp = true): Gemini CLI, Qwen Code, opencode, goose, Hermes, Maki and Devin in their ACP mode, one agent process per chat or build with our MCP server; Maki's and Devin's ACP modes take the backend's model (cli_model). An agent in ACP_KEY_AGENTS (Devin today) gets the backend's stored key when its authMethods ask the host to authenticate (authenticate with meta.api_key; Devin needs this — its own CLI sign-in doesn't count over ACP). A builder whose saved session the agent can't take back fails the turn marked lost, and the run starts the new session from the brief. In chat, permission requests become consent questions; in builds they go through the same approval policy as Claude Code's (inbox, Auto mode). While a saved session loads, replayed updates are withheld from the new turn Protocol unit tests against scripted agent messages and an approval-policy test. Run live with Maki 0.7.0 only (2026-11-02, Linux, headless CLI): a static page built to Ready in 38 s, a follow-up continued the same session with session/load, and with Auto mode off its command and tool requests were refused in an unattended run. Replay suppression passes scripted load-history, success/error and cancellation tests; this correction has not been rerun with a live agent. Run live with Devin 3000.11.238 (2026-11-03, Windows, headless CLI): devin acp authenticated with the backend's stored key, answered a chat, and built a Rust app to Ready through a rebuild run. Turns report token counts as unknown over ACP; context-window updates aren't counted as per-turn input or output
WASM plugins With --features wasm-plugins: [[plugins.wasm]] components exporting craft-anything:plugin/tools add tools, and ones exporting craft-anything:plugin/checks add checks run after each kind's own (they get the build's file list as JSON) (added, listed, turned on or off and removed in Settings → Plugins or with plugins_add/plugins_remove/plugins_list); no imports, fresh instance per call, fuel and memory limits Tests with components written in WAT (describe, call, checks, a looping call stopped, imports refused, end to end through the engine); examples/wasm-plugin-wordcount built from Rust and loaded
WebAssembly custom inventories Repeated custom sections share module-wide name and producer inventory limits, and omitted metadata sets truncation. Existing retained names can still be updated. Synthetic wasm_custom_inventory_budget regressions (5 tests): Repeated function-name sections, updates at the cap, producer values and empty fields across sections, each local cutoff and an ordinary module fixture. Format checks and compatibility gates passed at 232100030ace.
WebAssembly component layout Component reports show the outer section names, offsets and byte lengths. A truncated section keeps the earlier layout and reports a parse error. Byte fixtures cover nested binaries, following custom sections, truncation and section limits.
WebAssembly referenced strings Cached type signatures and their retained copies share a byte budget with attached function names: 64 MiB or three times the input size. Omitted derived metadata sets truncation and a warning; actual function/tag index spaces and body counts remain intact. Summary and complete tool views disclose truncation without assuming an entry-count limit Valid shared-type modules and repeated export names, over-limit import metadata even after validation fails, imported/defined tags, mixed reference kinds and ordinary controls. The unchanged implementation fails four new regressions; the corrected focused suite passes 12 tests. Engine regressions exercise budget exhaustion and ordinary modules in both tool views
WebAssembly tag interfaces formats_wasm_compare resolves retained imported and defined tag exports to their declared parameter types. Identical unresolved or invalid diagnostics may still count as unchanged; those counts do not establish interface compatibility, and invalid/partial limitations remain present Synthetic core modules with tag changes and re-exports, mixed index spaces, import/tag limits, and missing or non-function type references; formats and engine tests. No real module corpus or WebAssembly execution was used for this correction
Questions and approvals A file inbox per project; core_person_ask, core_action_approve and MCP consent requests become cards in the app Cross-handle round-trip tests, a full approval round trip through the engine
Runtime assets in pinned builds Settings → Builds shows the total bytes copied when the listed builds were pinned, excluding files shared with a project. Frozen and light pins, size estimates and project copies keep runtime files in obj folders. An obj directory beside a regular C#, F# or Visual Basic project file is still recognised as compiler output; ambiguous folders are retained. New pins record the direct-launch program relative to the copy so a newer helper cannot replace it; older pins retain discovery behavior Synthetic filesystem tests cover both pin modes, model bytes, compiler-output controls and project duplication. A Linux tool-level regression starts temporary scripts through project_pin_open, with a newer Build/obj/helper, and verifies the originally selected program and its output; a missing recorded program is refused. No real pinned application was launched for this correction
Desktop app Simple mode: sidebar with New project and the project history (kept across restarts); New project makes something, works on a project the person already has (Work on my project: its folder's files are the app, edited in place without a question, and the project takes the folder's name), or just looks inside an app or file, a website or a game's files; a Game files screen (a game's archives; pictures from Unreal paks, Unity .assets files and Unity bundles saved as PNG after the person confirms they may unpack the game; uncompressed textures and the block formats DXT1, DXT5 and BC4–BC7), make prompt with picture attachments (picked, dropped, or pasted with Ctrl+V, shown as picture tiles) and, for anything recreated, a Clean room / Deep choice (also in the title bar; in Clean room, Just look inside, Game files, opening a file and the workbench ask for Deep mode instead), project screen (steps with the time spent and the AI cost and tokens of every build, plus each question's own cost, saved in the project's usage.json by the run or question tool (a coding agent's figure is shown as an estimate at API prices, not the bill; a question answered from a fork of the builder's session costs what it added since the builder's last turn), what the build is on now and its activity as it arrives (kept in build-activity.log), pinned builder checklist (its X folds it away between builds, kept in the project, project_plan_fold; a later run's checklist shows again; its steps scroll past a height set by dragging the divider above it, or with Up and Down, kept across restarts, #826), feed (each message and answer has a copy button, shown on hover or keyboard focus, #825), question and approval cards, a Continue card when a build was paused or stopped part-way (the app or computer closed; the project shows Interrupted) that carries on the builder's own session instead of starting over, and "It's done" beside Continue or Try again to keep the build as it is (project_build_finish), checks with screenshots and the requirements not met yet, the builder's open questions, preview, play, folder, follow-ups while it builds, which Claude Code takes at its next step; Up in the prompt box takes back the last note still waiting). Projects can start in a folder the person picks, whose files are either the app, edited in place (its stack read from those files unless the request names another, and, with nothing to recreate, judged by its own build and tests, whatever it's written in), or material to start from (asked, or the answer remembered in Settings), and are listed from any number of folders (project_folders, project_list, rebuild --project-folder). A folder that already holds a project is attached, keeping its saved target, builder, asset budget, asset setting and stack, and the typed request is a follow-up; the run uses that saved builder, keeps a live feed when the project is already building, and records the request in the feed when it starts; new-project-only choices are refused. Make says which AI builds ("Built by": automatic, or any AI that can build, by name); a pick stays with the project and builds its later changes, and is read or changed from the CLI and MCP too (project_builder_set, default giving it back to automatic; it runs in Clean room, since it never looks at the target). With nothing to build with, Start offers the coding agents found on the computer. Settings → AI turns an AI off or removes it, and sets how hard the Claude API or Claude Code thinks (every Claude level, low to max; also ai effort in the CLI), or an OpenAI, OpenRouter, Gemini or OpenAI-compatible AI (OpenAI's levels, none to xhigh, or for Gemini minimal to high, which every Gemini model takes; sent as reasoning_effort, or OpenRouter's reasoning.effort, only once one is chosen, #1813). Each Claude Code AI can keep its sign-in in a folder of its own (its CLAUDE_CONFIG_DIR, so its own account; ai folder in the CLI, a folder on that computer over SSH), used for its runs, its sign-in check and its kept session, and Add another adds a second Claude Code for a second account. In the prompt box, Up at the very start and Down at the very end go through earlier prompts when no note is waiting. Questions about a build ("Just ask" under the prompt box, or a message starting with /btw, the first slash command; rebuild_question_ask) are answered in the conversation, where each folds away and is kept in the project, without a build or a round and changing nothing (the next message or a note tells the builder the latest few as background, a Clean room build only those asked in Clean room): Claude Code answers from a read-only copy of the builder's own session. When the project's builder is an agent that can't be held to reading (Codex, OpenCode…), the ask box says so before anything is sent, and a question stays in the box (#1695). Under each project's prompt box, "Builder's questions: Ask me / Decide yourself" chooses whether the builder's questions come to the person as cards or are decided by the builder, which says what it chose (project_questions_set; the default is in Settings and follows Auto mode until picked). Projects can be renamed, duplicated and deleted (right-click in the sidebar, or the project's page; a delete keeps the person's own files). A build can be pinned (Pin this build on its page, or project_pin_* from the CLI and MCP): a frozen copy in the project's pinned/ folder (the default) or a light one that shares dependencies and media with the project through hard links (each one's size shown first), opened from the sidebar's collapsible Pinned section (icons with a running dot when folded); a pin or Play runs once per folder unless another copy is asked for, and a start that quits at once says so with its last output. Typed drafts survive a restart. In a narrow window the sidebar folds to icons and the project's details move above its feed; messages float over the screen and errors stay until dismissed. Advanced mode: workbench with every panel wired to real tools, as a screen beside the projects (builds and their questions stay a click away). On macOS the menu bar has the app's actions (open, new project, settings, Simple / Advanced, Clean room / Deep, the command palette, help) with the usual shortcuts UI unit and smoke tests (egui_kittest), offscreen snapshots of every screen; the CLI, rebuild_start and UI attach regressions
Waiting notes in the project feed Notes waiting for the builder scroll with the conversation above the live activity, so a long note leaves the activity and prompt box reachable. UI regression for a long note during a simulated build
CLI Every tool, --deep or --clean-room for one run (never saved), rebuild (including --continue-in, --resume to carry on a stopped build, and --project-folder, which attaches a folder that already holds a project and sends the request as its follow-up), mcp (--inbox, --restricted, --allow-web, --allow-capture), ai, setup, doctor, report CLI integration tests
SQLite database files (db_sqlite_show) A rowid alias column (INTEGER PRIMARY KEY, including the table-constraint form) shows the rowid; DESC, non-INTEGER and composite keys keep their stored values; a VIRTUAL generated column, which SQLite computes when a row is read and never stores, shows as not read, and the columns after it keep their own values; a whole number in a REAL, FLOAT or DOUBLE column, which SQLite stores as an integer, reads as a REAL, as SQLite returns it; a missing TEXT field with a separated decimal default retains its literal spelling after separators are removed Hand-built fixtures; generated files compared with the official SQLite library
SQLite WITHOUT ROWID tables Read from the index b-tree, interior records and overflow included; rows in primary-key order, values in declaration order, rowid null; WITHOUT ROWID and STRICT are found after the column list's own closing parenthesis, so a ) in a trailing comment doesn't hide them Hand-built fixtures; generated files compared with the official SQLite library
SQLite row-page retention Rows before the requested offset are decoded and discarded immediately; only the requested page is retained, including for WITHOUT ROWID tables. Zero-sized first pages do not scan table cells; offsets still count readable rows and clamp at the end Rowid and multi-level WITHOUT ROWID paging, defaults, damaged-cell and zero-limit regressions; a SQLite-generated 64 MiB database completes deep and empty pages under a 128 MiB address-space limit
SQLite b-tree walk scaling Row and count walks use ordered page membership, avoiding repeated linear scans as visited pages grow; repeated children and cycles are still visited once, and rows remain in key order Wide multi-level tree and repeated-child/cycle tests; production-module benchmark on SQLite-generated databases with 8,343, 16,683 and 33,402 pages
SQLite column whitespace Carriage return and form feed separate unquoted column names from their types. INTEGER primary-key columns retain their rowid values. All five SQL whitespace characters, CRLF, quoted-name controls and row decoding regressions; a SQLite 3.53.1-generated database reproduces NULL before the fix and rowid 7 after it.
Quoted SQLite column types Read quoted type names and check the complete type spelling before using a primary key as a rowid alias. Declarations such as "INTEGER"(10) and "INTEGER" EXTRA keep their stored key. Row decoding and schema regressions plus a generated keyword matrix against SQLite 3.50.4.
SQLite CREATE TABLE longer than 4 KiB Parsed whole (up to 1 MiB), so its later columns, rowid alias, WITHOUT ROWID and added columns' defaults hold; the statement shown is still cut at 4 KiB Hand-built fixtures; generated files compared with the official SQLite library
Builder discovery smoke fixture The missing-builder smoke fixture controls discovery state and supplies a synthetic result. All original warning, modal, action and build-availability assertions are retained. Source inspection only; automated validation has not yet run for this change.
Parser review follow-ups Java reference scans retain partial coverage; DEX signed LEB128 enforces 32-bit values; legacy AAPT strings stay inside their pool with a shared recovery probe limit; missing classic ext indirect metadata is not recovered as zeros. Shared-budget revision 29c48e03 passed full Linux CI. The merge with main 41d2175e awaits a new CI run. Extent-tree metadata handling is unchanged.
Keep unavailable ext4 extent mappings from fabricating file bytes Require complete, structurally consistent extent nodes and child depths before returning a file mapping; missing or invalid metadata leaves the file unrecovered instead of replacing unknown ranges with zeros. Synthetic production-reader regressions cover bad root headers, unavailable and physically partial children, a missing later subtree, mismatched depth and node capacity, plus valid indexed, sparse and unwritten-extent controls.
Stand-in retained body budgets Check per-body limits after redaction and charge the capture budget only for distinct retained samples. Budget-rejected cached 304 responses remain unavailable. All four original capture regressions and six deduplication regressions passed in full Linux CI at revision d601bc4e. Workspace tests, strict Clippy, formatting, layers, locks, secrets, wasm-plugin checks, shared WASM compilation and the lockfile check passed.
Project evidence when another opens Opening a different project in the same session replaces the session's evidence ledger and open questions with that project's; reopening the same project refreshes its stored records without clearing them, and a failed read leaves the current project untouched. Engine regression: two projects with stored evidence and an open question; switching loads only the second project's records, reopening the same project keeps its ledger, and reopening the first restores its records.

| Plan steps stopped at a run's end | A run that finishes (ready, failed or paused) marks still-open steps Stopped on the plan card instead of leaving them "Doing" until the card is folded (#504). The stopped steps stay in the saved conversation (FEED_VERSION 5); a later run's checklist updates the list again, and a plan left partly unticked still shows with its stopped steps | Regression tests in ai::rebuild::feed (ready, paused and no-checklist finishes, a later run taking the list over) and an engine save/load round trip of a stopped step; the checklist draws a warning circle for stopped steps. Not checked: a live desktop run |

Builder retry policy

Builder failures carry a typed reason through Conversation::last_failure. Typed authentication, billing, missing programs, unavailable tools, configuration and unknown protocol failures stop for attention. Transport interruptions, rate limits and nonzero process exits without a typed error get at most three retries; the decision no longer searches English error messages. A Claude Code rate limit after its stream said the plan's limit refused the turn (rate_limit_event with status: rejected: the 5-hour or weekly allowance) isn't retried; the build stops and says which limit and about when it resets (#1919). Unit-tested on the stream; not seen live with a used-up plan. Structured provider waits win; the earlier numeric “retry in” hint is only a delay fallback after a failure has already been classified as retryable. All waits remain cancellable and bounded to fifteen minutes. Local inbox and workspace write failures are not retried using a concurrent backend failure's retry advice; the original local error is returned. A missing saved session starts afresh only when a fresh request is available; otherwise the run stops without retrying the unavailable session.

Claude Code's failed or unauthenticated craft-anything MCP server in its init event stops the owned CLI process. Pending servers and failures in unrelated optional servers do not stop it. Claude assistant error codes, HTTP status/provider errors and ACP authentication errors retain their typed meanings. A later generic result does not erase a more specific error.

API retries continue the existing history without inserting the user's message again or replaying completed tools. Stateless CLI retries receive the whole original request. OpenCode now uses run --format json: its API error status and retry flag decide retryability while text, tools and usage still reach the feed. Missing or invalid step costs keep the turn's cost unknown; explicit zero remains a known cost. A CLI that fails with only a numeric exit also uses bounded retries; its display error remains available if recovery fails. The process wrapper sends one final turn event and becomes available for the next request.

Protocol fixtures, a loopback HTTP server, scripted API turns and executable CLI stand-ins cover these paths, including cancellation and the retry cap. An executable that exits 1 without a structured error resumes its saved session, while typed setup errors retain priority over the same exit status. No live provider or paid-model run was performed. The separate source of #64's 41 attempts remains unverified.

Bun stored-text encoding

The packed-file tools list and extract the original Bun source-map and bytecode bytes alongside module contents. Payload paths use the module index and a directory separate from original paths.

Packed Bun members with encoding value 2 are labelled utf16le, matching their stored UTF-16LE bytes. Reading or unpacking preserves those bytes. Synthetic graphs cover UTF-16LE (including a surrogate pair), Latin1 and binary members across both supported module-record and offsets-block sizes. A freshly compiled Bun program and the CLI/MCP transport were not run for this correction.

Native tool-call stop reasons

Native OpenAI-compatible tool calls retain a reported output limit or refusal instead of replacing it with a tool-use stop. The conversation can therefore reject those calls before running a tool, including calls whose arguments happen to be valid JSON. A normal stop with tool calls still works for servers that omit tool_calls as the finish reason. Calls retained after a pause or another terminal stop get matching non-execution results, so subsequent requests keep valid tool-call history. A pause continues the same turn; terminal stops wait for the next user message. Checked with streamed-call fixtures and HTTP/SSE stand-ins through the real conversation and engine loop. Three history-pairing regressions fail without the follow-up and pass with it. The affected crate's 223 tests and Clippy checks passed locally. The initial stop-reason correction also passed hosted CI in PR #544. This correction concerns reported finish reasons; handling of a missing finish reason is unchanged. No live provider or local-model build was run.

OpenCode review follow-up

OpenCode variants now use the shared five-level Effort type while retaining exact catalogue validation. Hub and headless tool selections share a strict disk-based save that preserves unrelated settings changes and refuses damaged files or changed backends. Regression tests cover both entry points. Rejected or cancelled model validation emits a terminal turn event so headless chat exits.

Unreal setup

Unreal installations registered in ~/.config/Epic/UnrealEngine/Install.ini are found on Linux. A valid absolute UE_ROOT selects an installation explicitly; an invalid override falls back to registered installations. The version comes from Engine/Build/Build.version, and C++ readiness checks for the selected engine's bundled Clang, not an unrelated system compiler or another installation's SDK. The Linux requirements summary (Builder::needs for Unreal) now describes the bundled Clang toolchain. The guided installer now gives Linux-specific guidance: it names the bundled Clang and points at the engine's Engine/Build/BatchFiles/Linux/SetupToolchain.sh (or Setup.sh for a source build) when Clang is missing. On macOS, the status line and requirements summary now name Xcode, matching the guided step. The guidance strings are unit-tested; no live Unreal install or macOS run was performed for this copy change.

Checked with isolated registry and SDK fixtures and with a native Fedora install of Unreal 5.8.4. On Windows, Visual Studio C++ readiness also checks instances registered in %ProgramData%\Microsoft\VisualStudio\Packages\_Instances\*\state.json and explicit developer environment roots (VSINSTALLDIR, VCINSTALLDIR, VCToolsInstallDir), requiring cl.exe under an MSVC toolset's bin tree rather than an empty VC/Tools/MSVC or version folder; checked with isolated fixtures and on Windows 11 against Visual Studio Community 2026 (18.9.2, MSVC 14.51.36231). Readiness is a tool-presence check; a complete Unreal game build and SDK compatibility validation have not been run for this change.

Provider error messages

HTTP failures include the provider's message from error.metadata.raw, when it contains a message, detail or string error. Object payloads, JSON-encoded strings and plain-text reasons are supported, with the provider's name when supplied. A repeated outer message does not hide a distinct nested detail. JSON-string wrappers are decoded to a bounded depth before reading message fields; arbitrary, malformed or excessively wrapped structured metadata is not dumped. HTTP status classification and remediation are retained, and displayed details are bounded by Unicode characters. Checked with synthetic response bodies, repeated messages, encoded payloads with adjacent headers, malformed metadata and Unicode length controls. The affected crate's 222 tests and all-target Clippy checks passed locally for PR #542. No live API-key build or account-specific diagnosis was performed.

Fixed during the audit

Web tools couldn't launch a browser on Windows/macOS (Chrome/Edge are off PATH) or be pointed at a URL; the desktop app looked tools up by ids that didn't exist (website, phone, imports, classes, modules, pseudo-C, disassembly, source and network panels were dead); evidence wasn't reloaded from a project in a new process; report citations were unresolved; the CLI's --format clashed with tools' own format; raw binaries couldn't be opened from the CLI; function discovery claimed complete coverage when capped; .NET/Go binaries were called "stripped"; Windows path separators and CRLF checkouts broke two tests; decompiler tail calls and Win64 stack arguments. Added since: byte search, Rust binaries, Electron fuses, WASM interface diff, packet captures, objdump, rizin commands, GDB sessions, then rizin debug sessions (native_rizin_session_*, checked with Rizin 0.9.1 on Windows) and radio decoding with rtl_433 (radio_recording_decode, radio_decoders_list, checked with rtl_433 25.12 on Windows) and Cutter sessions the person shares with =h& 9090 (native_cutter_sessions_list, native_cutter_command_run; tested against a stand-in server, not yet a real Cutter). Every tool is listed in docs/tools.md.

SquashFS extended directories

The filesystem reader recovers the same files and bytes from basic and extended directory inodes. Synthetic images cover an extended root, a nested extended directory with a nonzero listing offset, and both together; the results are compared with the existing basic-directory fixture. Compressed metadata, directory indexes and a real firmware extraction were not newly checked for this fix.

Keep-awake helper cleanup

Rebuilds release their keep-awake guard before emitting Finished and clearing the running flag. The guard waits up to five seconds for the owned helper's supervised cleanup, logging a warning if that deadline passes. Cleanup runs on the rebuild worker, with a bounded shutdown wait.

Checked on Linux with real subprocess stand-ins: dropping a guard closes the helper's listener, a stand-in CLI can drop it and exit immediately without leaving the helper running, and an already-finished helper releases promptly. The immediate-exit case fails with the earlier asynchronous cleanup. The intermittent Windows report and Windows/macOS sleep inhibition have not been rechecked for this change; Windows runtime validation remains on the roadmap.

The full workspace gates (cargo xtask ci) passed in hosted CI for #541.

Tool calls written as JSON

The text fallback accepts complete bare or fenced JSON calls with name and arguments (parameters also accepted), including a function wrapper and JSON-encoded arguments. Automatic recovery also handles these responses when native tool calling was offered. A call must name a tool offered in that turn; ordinary JSON answers and JSON examples surrounded by prose are left as text. Native calls are kept once; text-call recovery skips truncated or refused replies. Complete backtick-fenced legacy ReAct steps remain supported when their body begins with an explicit protocol marker. Both parsers use the same fence boundaries: at least three opening backticks and a standalone closing line of at least that length, with no earlier matching closing fence. Shorter backtick lines inside a longer fence remain content. Ordinary fenced code, malformed fences and non-call JSON objects or examples containing protocol markers remain text; valid call arguments may contain those markers. The parser regressions failed on the previous guards and passed with their corrections. Fenced JSON calls also use these boundaries during automatic recovery and accept only an empty or json info string. Checked with parser fixtures, HTTP/SSE stand-ins exercising real engine tool execution in both protocols, and non-action, stop-reason and duplicate-call controls. No live local-model build was run; other text-call formats remain unsupported.

Calls in Qwen's markup (<tool_call>, <function=name>, <parameter=key> value </parameter>) are read too: a llama.cpp server hands one back as text when it names a tool the model wasn't offered, and a live build on a 512k-window Qwen model stopped in 3 minutes when the loop took web_search and web_fetch calls for its final answer. Words may come before the first call; the last </tool_call> may be missing. When every name is offered the calls run, a parameter the schema says is a string staying as written and any other read as JSON when it parses. When any isn't, nothing runs and the next message names the wrong ones and the tools the model has; words after the last call ask for it again without them, as with fenced calls. A call in a code fence or in the middle of a line, or one missing </parameter>, stays text. Checked with the live runs' texts, an HTTP/SSE stand-in where the model calls a missing tool, is told, runs a real one and answers, and two mutations (the reader off, names not de-duplicated) that the tests caught. Not yet run live after the change. Hermes-style <tool_call>{json}</tool_call> is still text.

Linux quick start (R5.7)

README's "Get started" install steps were followed as written on clean Ubuntu 24.04 and Debian 13 containers (2026-11-16, main at 9460af21, Rust 1.100.0 from rustup, x86-64): the README's packages, git clone, cargo run --release -p craft-anything, cargo install --path apps/craft-anything-cli and craft-anything-cli doctor. With only the packages the README listed, every build stopped at once on both with "linker cc not found": a clean system has no C compiler, which Rust needs to link. The package line now starts with build-essential. With it, the desktop app built in about 4 minutes on each, the CLI installed, and doctor reported healthy (the MCP self-test listed 30 tools; every optional engine but objdump absent, as expected). In a container the app has no screen, so cargo run stopped with winit's "neither WAYLAND_DISPLAY nor WAYLAND_SOCKET nor DISPLAY is set." On a Debian 13 desktop (GNOME on X11, NVIDIA RTX 3060, driver 550.163.01; not a clean machine) the release build opened its window, drawing with Vulkan on the NVIDIA card. Then (2026-11-16, main at 090188d7) the window on a clean machine: a fresh Ubuntu 24.04 container with the README's packages (by then with build-essential) built the release app first time, and was given a virtual screen (Xvfb, X11, software rendering; added only so the container has a screen). The app stopped before its window with "Library libxkbcommon-x11.so could not be loaded": nothing in the package line installs the X11 half of xkbcommon, which desktop systems usually already have. With libxkbcommon-x11-0 added (now in the package line) the window opened on its welcome screen, drawing on llvmpipe. The README's craft-anything-cli rebuild - "A snake game in Rust" --rounds 1 ran on the Debian 13 desktop above with Claude Code 2.1.322 signed in, adding --unattended, --backend "Claude Code" and --projects-dir so it could run without a terminal: Ready in 3 min 24 s, 3 of 4 checks passing (build, a picture of the running game, the self-test playing move, eat and score); the mechanics comparison stayed unverified, as there was no original to measure. That folder's own Cargo settings sent builds elsewhere (build.target-dir), so the first check didn't find the program and the builder set target-dir = "target" in the app's .cargo/config.toml. Not checked: Wayland, a real screen on a clean machine, the website rebuild examples (they need a browser), Fedora or another distribution, and the app beyond its first screen.

Linux graphics card choice

On Linux the desktop app draws on the GPU that drives the screen (#571), read from the connected displays in /sys/class/drm: the built-in panel's GPU on a laptop, the only GPU with monitors on a desktop, and the discrete GPU when monitors are on more than one GPU or nothing can be read. WGPU_ADAPTER_NAME and WGPU_POWER_PREF still decide when set. desktop.log says which adapter was chosen and why.

Checked live on one laptop (AMD Renoir iGPU driving the panel, NVIDIA RTX 3050, CachyOS, KDE Plasma on Wayland): the window opens in 3 s on the AMD GPU instead of 18–25 s on NVIDIA, and the desktop no longer lags; WGPU_POWER_PREF=high, WGPU_ADAPTER_NAME=nvidia and DRI_PRIME=1 with WGPU_POWER_PREF=none still draw on NVIDIA. Desktops with monitors on one or two GPUs and Intel laptops are covered by unit tests on fake /sys/class/drm folders only.

Windows renderer fallback

On Windows the window draws with DX12 on the graphics card. A start that never opens its window (a driver that crashes the process, or a wgpu error such as DX12 refusing egui's pipeline, #794) makes the next start take the next renderer: WARP, then Vulkan, then OpenGL, then DX12 again. After a wgpu error the app starts again by itself with the next one; after a native crash the person starts it. The renderer that opened the window is kept in renderer beside desktop.log for this app version, so an update tries DX12 first again. WGPU_BACKEND and CRAFT_ANYTHING_RENDERER still decide when set.

Checked live on an RX 6900 XT (Windows 11): a build that turned every DX12 start into #794's wgpu error went DX12 → WARP → Vulkan by itself in about 2 s, opened on Vulkan, kept it at the next start, and went back to DX12 for another app version. The real #794 failure wasn't reproduced: DX12 and WARP both draw on that machine.

Headless project and engine tools

Rebuild runs save the project's conversation in the versioned feed.json, including runs from the CLI. project_show reads it with offset/limit paging, and project_inbox_answer answers waiting questions and approvals. These tools are available through the engine, CLI and MCP.

engines_list reports external and game-engine readiness; engines_install installs Ghidra, Godot and pinned engines. Unity and Unreal still need their vendor's installer and account: the tool opens an installer where supported, or reports the download page and requirements. project_play launches a built app or game with consent, project_preview serves a built website on loopback, and project_open_folder opens its folder. A preview lasts for the session; use wait to keep a CLI preview serving until cancellation. The desktop app calls these tools too.

core_report_write lists up to 30 distinct limitations and then says how many it omitted, in both Markdown and HTML; a report with 30 or fewer is unchanged. Checked with 31 synthetic limitations; the omitted marker is absent on the former renderer.

Checked against the registered tool implementations and rebuild feed writer; no live install, launch or preview was run for this documentation correction.

Known limits

  • Locks: every mutex but the browser viewer's goes through platform::sync. A deadlock on one thread or across threads is broken when it forms, with an error and a report in logs/; a watchdog looks every 5 s; a holder that isn't a labelled job is reported after 2 minutes and waited on for 15 at most. Tools are labelled, so they may run as long as they need. Checked by unit tests of each case, not by a live deadlock in the desktop app. Waits on channels and join aren't watched; each child program has its own deadlines.
  • A failed agent CLI run says what ran and what it printed, and writes a private log to logs/ in the config folder (the newest 50 are kept; the person's message is left out; Open log in the app, log: in the CLI). Checked live against a GitHub ssh alias from the CLI; the button by a UI test, not by clicking it in the desktop app. A failed API-backend turn writes one too (the error's code, its HTTP status and a known error code from the service; its message, and a code that isn't a known one, are left out), and so does a local MCP plugin that doesn't start or stops answering (its exit code and stderr; its env is left out and keys in its arguments are hidden); a remote one doesn't.
  • Live end-to-end runs (2026-10-18, Windows 10, headless CLI): a website clone reached Ready at 96% likeness in 1.5 min; a small desktop app rebuilt in Rust + egui reached Ready in 9 min (checked only by building); a game rebuild in Rust reached Build and was stopped before Check. The website case is an opt-in test: CRAFT_E2E=1 cargo test -p craft-anything-cli --test live_rebuild.
  • Approvals differ by agent (roadmap R2.2): Claude Code asks our approval tool; OpenCode's builder runs with --auto, with OpenCode's own rules denying its edit tool our records (craft.json, inbox/ and the rest; not its shell; checked live with OpenCode 2.2.6 on Linux: a --auto run's write to app/ went through, and its writes to inbox/ and craft.json were refused); Hermes's -z turns its approvals off on every run, chats included, so a Hermes chat isn't limited to analysing and Clean room's approval rule doesn't reach it. Hermes is opt-in and hasn't been run live here.
  • Grok Build (grok agent stdio) is offered when grok is installed and speaks ACP by default. Model and reasoning effort are set again with session/set_config_option after session/new, because the CLI --model flag does not stick; --reasoning-effort is also passed after agent. Our MCP server is added on the session. "type": "stdio" is sent only for Grok. The person's own Grok MCP servers stay available. Clean room, deep chat, and questions are refused: a native read does not ask permission, and a saved permission can edit without a request. A deep build is allowed, and an edit is gated only when Grok sends session/request_permission. A missing auth.json is unknown, so an API key is not blocked. Checked against Grok 1.0.77: initialize, session/new and session/set_config_option. A live deep build on 2026-11-06 finished, called the Craft Anything server, and answered one permission request under a temporary ask-mode home. The person's own config was not changed. A config that approves every tool does not ask. See grok.md.
  • Maki (maki -p, or over ACP with acp = true) is offered when adding a coding agent and found by Detect. Over ACP it asks us before commands, our own tools and writes outside its working folder; writes inside that folder (a build's project folder, our own records included) and every read never ask, so the approval policy and Clean room's read rule don't reach those. Plain maki -p doesn't ask at all, so a Clean room build's reads aren't checked either; outside a build it runs with its writing tools, shell and code execution switched off, and Maki refuses anything else that would ask (an MCP server's tools, in subagents too) unless the person allowed it in Maki's own permissions. It hasn't been run as a maki -p builder here.
  • Claude Code is fully wired as a builder; Codex works through its own flags (our tools are pre-approved for codex exec and every tool permitted by the current mode is listed from startup, see docs/codex.md) and resumes its reported thread on follow-up turns and when reopening a saved session. A missing-thread stderr diagnostic clears the saved id and marks the session lost, allowing the existing runner to start fresh; other stderr failures keep the session. The live smoke check also verified missing-thread recovery on 0.169.0-alpha.11.1; older Codex versions remain unverified. Native runs refuse --ephemeral before starting Codex, because those sessions are not persisted for resume; a two-turn fixture verifies no process or session is created. Codex 0.166.0 received the full Clean room inventory through a loopback model. An opt-in live adapter check on macOS with Codex 0.169.0-alpha.11.1 and gpt-6.1-sol verified a real MCP call, a sandboxed file write, a second turn and reopening the same thread (2026-11-14). No complete real-account rebuild or GUI run was checked; Copilot builds, model discovery and real-account session resume were confirmed by the person using the app. Other agent programs without an adapter get plain text in and out. API-key backends (Anthropic, OpenRouter, OpenAI, Gemini through a Google AI Studio key, local; Kimi K3.1 Pro through OpenRouter is offered by Detect; a backend chosen as the Extractor takes a Deep-mode game's own files out into app/Original/ after the study) build with our own loop and the Build tools, trim and summarise long conversations and keep them in transcript.json, resumed only in the mode that saved it (one saved before the mode was kept counts as Deep); no live API build has been run yet.
  • Website checks compare the start page and up to 12 linked pages at the configured widths; the start page's menus, pop-ups and tabs are opened on the build too and compared in the note (the first few only, never menus inside menus or hover-only ones). Apps and games are checked by building and by a screenshot compared with the person's pictures (and the original's window when runtime study is on; then the build is also started normally, and its window and labelled controls are compared with the original's); games (and apps decompiled in Deep mode) also keep app/mechanics.json, which is checked for readability and reports provenance gaps. Its behavior remains unverified in saved results and the final summary: source literals, equivalent calculations and core-loop self-tests do not measure its values. This unknown does not trigger builder retries; missing or malformed sheets still do. Ready means a usable build, and can retain unverified comparisons after checks. Every game must also pass its own --self-test (the build plays its core loop with scripted input and reports whether the player moved, acted and the HUD was drawn), and a Deep-mode game that uses the original's files must have app/CREDITS.md and the private-use line in app/README.md. The self-test is the build's own report: Craft Anything doesn't yet watch the game play or measure the values itself.
  • In Deep mode, app and game targets get a static study (triage, engine detection, file inventory, JS app graph, Ghidra when installed); in Clean room only the person's pictures and words. With runtime study on, the original is also started once for a picture of its window and its UI tree (Windows and macOS); it isn't driven or watched over time.
  • Several projects build at once ([build] parallel, 2 by default; Settings → Builds); more wait their turn. Queued builds start on their own as places come free, from MCP too. A build with an API key works alone, for now: it shares the app's session, so others wait for it and it for them.
  • Engine gaps from the audit: Frida session tools are partly simulated; imports outside the argument-count table show only the arguments set in the calling block. See tool-status.md.

Next

See ROADMAP.md for the ordered plan.

Build progress across runs

When app files can be compared, a build stops after two consecutive completed builder turns leave them unchanged. The versioned inbox/build-progress.json record keeps that count when the project is reopened or Try again is pressed. A record that can't be read still stops the run, and the error says the file is Craft Anything's, that something else changed it, and to rename or delete it to go on. A record from a newer version stops it too, and that error says to update Craft Anything instead. Every brief names craft.json, feed.json and inbox/ as records a builder must not write (an OpenCode builder once kept its own notes in this file). File contents and executable permissions decide progress, so rewriting identical bytes does not reset it. An actual app edit or a new nonempty request starts another attempt, including notes queued during a turn or check and notes consumed by a builder hook. Empty notes and plain Try again keep the saved count. Dependency/build caches, git metadata and Craft's own records, including checks in a project edited in place, do not count. Symlinks are recorded without following their targets. A successful check may still finish the second unchanged turn, and a run waiting only for checks does not start the builder again. Within a run, file digests are reused while size, modification time and executable bits match; Unix file identity and change time also invalidate a cached read. The first scan reads content, but unchanged imported assets are not read again before and after every turn. The metadata is only a cache key: rewriting identical bytes still produces the same content fingerprint. The cache is isolated by project root, drops deleted or retyped paths, and is discarded after scan errors or cancellation. It is not persisted, and the version-1 fingerprint/schema is unchanged. Sockets, pipes and devices contribute their names and types without opening their contents. If a scan cannot finish because of limits, permissions or changing files, the feed says why the unchanged-turn limit is skipped for that run. The saved fingerprint and count are cleared so a later readable run starts a fresh comparison. Checks and the existing round limit still apply. Cancellation still stops the run; completed builder replies are saved as awaiting checks before the post-turn scan. Broken or newer progress records and record-write failures remain errors.

A check round in which every check worked is kept (in memory, and as checked in the record once craft.json has the round). While nothing it looks at changes (the app's files as above, the names, sizes and times of reference/ and capture/, the kind, stack, mode, plugin checks and the project's folder), the next check, the builder's own rebuild_check included, takes its results instead of building and starting the app again, and the feed says so. A round with any failure is never kept, so Try again always looks again. Not run live.

Scripted API turns and executable CLI stand-ins cover the stop, persistence, fresh requests and check recovery. This change has not been verified with a paid model or a live provider. Copying a whole project keeps its progress record; Duplicate creates a new attempt with a fresh conversation and count, as it already does for usage. An existing root-level file or directory named build-progress.json remains app data: it is fingerprinted, copied by Duplicate and kept when Craft's project records are removed. Its JSON shape does not make it a Craft record, and it is never migrated into the inbox.

Notes consumed by builder hooks now only queue a progress reset while the turn is running. The reset is saved after the successful turn and its awaiting_check recovery state are persisted. Multiple consumed notes coalesce into one reset; blank notes do not reset the count. A broken or inaccessible progress record still returns its actual error at that safe boundary, without starting another provider request or losing the finished builder reply. If the turn fails or is cancelled after consuming a note, its reset is saved before the run ends so reopening keeps the new request's full allowance. The original failure or cancellation remains the result; a reset that cannot be saved is reported separately and never overwrites a broken or newer record. Scripted turns cover both outcomes, blank notes and unreadable records.

DNS answer name boundaries

Within the first 64 decoded answer/prerequisite records, NS, CNAME, PTR and MX values must be fully encoded inside their declared RDATA. DNS UPDATE RRset prerequisites may carry an empty value only with CLASS ANY/NONE and TTL zero; later prerequisite records are still decoded. Backward compression pointers still work, including names with a label before the pointer. A truncated name, missing MX preference or extra bytes after a name marks the DNS message incomplete and keeps that answer out of the packet and capture inventories. Earlier complete answers remain available. Eleven synthetic packet regressions cover those boundaries, root names, literal names, legal and malformed UPDATE prerequisites, and the summary inventory; no live capture was used.

Local model identifier task hints

Automatic local setup recognizes numeric suffixes on known embedding, reranking and speech task tokens. Generic GGUF filenames (ggml-model-*.gguf, ggml-model.gguf and model.gguf) also keep their immediate model directory as a task hint, with either path separator. Named model files, publisher prefixes and unrelated words are not classified by arbitrary ancestor directories. Regression tests cover mixed model lists and servers listing only specialised models through the local discovery API. Classification remains a name heuristic; it does not probe model capabilities.

Quantized GGUF tensor ranges

Model-header inspection calculates byte lengths for the supported Q4/Q5/Q8, K and IQ block formats, including their scales. A row must contain whole blocks; malformed row widths and overflowing shapes remain unknown with a diagnostic. Truncation checks include quantized payloads and use nonwrapping offset arithmetic. Synthetic headers cover all 21 supported quantized layouts, exact and short files, multiple rows, unknown types and overflowing offsets. Tensor data is not decoded, and no model inference was run for this change.

sBPF symbol record boundaries

sBPF inspection requires each ELF symbol record, including its declared padding, to fit inside the file. Missing or undersized entry strides and partial trailing records produce diagnostics. Symbol and section names come only from a linked string-table section with a NUL terminator inside its declared bytes. Invalid names remain unknown instead of creating false entrypoint or syscall identities. Five synthetic regression tests exercise oversized offsets, malformed strides, missing padding, broken string-table links and incomplete names; all five fail against the unchanged parser. No Solana program was deployed or executed.