* fix(javascript): retain array-pattern iterator close effects
* fix(javascript): bound array-pattern close exposure
* fix(javascript): follow stored array elements at iterator close
* fix(javascript): retain iterator closes before array rest
* feat(uefi): add pure-TS UEFI firmware volume/FFS parser with inspect/extract tools
Add a dependency-free rea-uefi provider that maps AMI/Aptio flash images:
- inspect_uefi_firmware: aligned _FVH discovery, volume-relative FFS walking,
guided section/compression classification, conservative PSP-directory probing,
embedded-volume rescan and leftover-region classification; incremental SHA-256
and explicit integrity notes.
- extract_uefi_firmware: whole-image/volume/FFS-file/section extraction with
LZMA-custom/LZMAF86 and AMD-zlib decoding, SafeOutputTree staging, derivations
and extraction_gaps.
- UefiArtifactReader + 'uefi' format wiring across inventory/domain/contracts
so parsed volumes and extracted PE32/TE files hand off to deep-provider
analysis (open_binary -> Ghidra).
* feat(uefi): add inspect_uefi_nvram for AMI NVRAM variable stores
Add a pure-TypeScript tool that maps the vendor AMI NVRAM variable stores
(factory-default "StdDefaults" and peers) inside a flash image:
- scan the raw image for NVAR entry chains ("NVAR" + u16 total size +
u32 attribute 0x8[23]FFFFFF + state + NUL-terminated name + data),
- recurse into a container entry whose data is itself an NVAR chain, so the
StdDefaults setup variables surface as depth/parent_offset rows,
- report attributes, state, data range, SHA-256 and trailing padding per entry.
Verified against B550 AORUS Elite V2 FId: one StdDefaults store at 0x37090 with
the 11 expected nested variables (Setup, PlatformLang, AMITSESetup, XhciDID,
GcSensorVarName, PCI_COMMON, SioSetupData, UsbSupport, NetworkStackVar,
SecureBootSetup, Setup). Exposed as MCP tool and inspect-uefi-nvram CLI command.
* fix(uefi): address review on checksums, compression, guided sections, NVRAM bounds
- FFS file checksum: verify the two's-complement invariant (payload sum +
stored byte == 0 mod 256) instead of comparing sums, and encode the correct
complement in the fixture builder.
- Compression sections (type 0x01): use the 9-byte header and classify EFI
standard compression instead of 'none', so extraction reports a gap rather
than publishing compressed bytes as a raw section.
- GUID-defined sections: derive GUID/data-offset/attributes from the parsed
common header size (compact or extended) and reject out-of-range payload
offsets.
- AMI NVRAM: bound recursive chains to the enclosing container's data end and
report partial coverage when a valid nested chain is cut by max_depth.
* fix(uefi): bound decode memory, serialize operations, enforce deadline, mark truncation
- LZMA worker: enforce max_output_bytes while decoding through a bounded output
sink, so an oversized stream is rejected during expansion instead of after a
full decompression plus a second Buffer copy.
- Provider: serialize admitted operations (the promised single decode-worker
lane must not become one worker per overlapping call) and apply one
whole-request deadline that covers every decode stage, not a fresh per-stream
timer. close() drains the queue and the resource scope.
- Scan: track truncated sections of known type and report coverage partial
instead of complete when a section declares more bytes than are present.
* fix(uefi): cancellable queue, timeout surfacing, availability and reader omissions
- Queue: check the caller signal before enqueue and when a job reaches the head,
and race the queued promise against abort so a cancelled wait returns
immediately instead of blocking behind the active request.
- Deadline: track the internal deadline and return AnalysisTimeoutError instead
of the AnalysisCancelledError that runOwnedCommand reports for any external
abort, preserving the real failure reason for CLI/MCP callers.
- CapabilityInventory: treat inspect_uefi_nvram like the other bundled rea-uefi
tools so discovery does not demand Unblob for it.
- UefiArtifactReader: report image truncation through onOmission so inventory
coverage reflects the unread suffix even when no volume was found.
* fix(uefi): limit early cancellation to unstarted jobs and preserve timeout cleanup
- #raceWithAbort only returns early for jobs that have not started; once a
request is running, await it so worker cleanup and completed output are
preserved instead of being discarded by a bare cancellation.
- Reclassify a deadline-induced cancellation as AnalysisTimeoutError while
keeping its cause and cleanup observations, and never override a different
primary failure.
* docs(licenses): record UEFI decoder dependency notices
* fix(uefi): preserve stream provenance and bound firmware analysis
* feat(uefi): decode LZMAF86 guided sections
* fix(uefi): validate publication before commit and order decoder cleanup
* fix(uefi): preserve unsupported volumes and extraction gaps
---------
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
* fix(zstd): share exact-frame Zstandard decoding across ELF and OTA
Walk RFC 8878 frames once so ELF sections, Android OTA REPLACE_ZSTD, and GPU payloads reject truncated headers, blocks, checksums, and trailing bytes on every supported Node runtime. Bound that walk with the runtime zstd.max_frames setting.
* fix(zstd): keep frame output tight and report GPU frame-cap refusals
Copy each Node 22 frame off its decoder chunk before the next frame is decoded. Map a GPU zstd.max_frames refusal through the resource-limit contract instead of a provider failure.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(zstd): keep frame-cap refusals and bad seeds out of malformed results
Project zstd.max_frames through one resource-limit helper for ELF notes, DWARF, GPU, and artifact reads. An invalid REA_ZSTD_MAX_FRAMES seed stays a configuration failure, and frame-header tests cover content size, window, dictionary id, and RLE blocks.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(zstd): yield GPU frame decoding so cancellation can land
The frame-by-frame fallback awaits a caller pause before each data frame. GPU yields and checks the read signal there, so a many-frame payload does not finish before a disconnect is observed.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(zstd): advertise the frame cap and keep strict GPU decode cancellable
List every operation that enforces zstd.max_frames, including GPU, DWARF, and ELF notes. The strict sequence uses the async decoder and checks the caller signal again after it returns, and a single output buffer is not copied a second time.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(zstd): refresh analysis-setting schemas and GPU frame-cap projection
Regenerate the advertised input summaries for inspect_analysis_settings and update_analysis_settings. GPU inventory now throws the projected zstd.max_frames resource limit from payload decode and #retainFailure, so the adjustable setting survives the public failure.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* style(gpu): format the frame-cap projection throw
oxfmt keeps the zstd.max_frames throw in #retainFailure on one line so CI format:check matches the local formatter.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(zstd): yield after the last frame-by-frame GPU decode
The fallback returned success in the same turn as the final synchronous frame, so a queued abort was still invisible to the caller's signal check. Pause once more before that success, matching the strict sequence.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(zstd): yield ELF, OTA, and DWARF frame decoding on the caller signal
The synchronous frame loop ignored abort signals owned by inspect_elf_notes, inspect_dwarf_units, and Android OTA partition reads. Those callers now use the cooperative decoder and yield before Zstandard work, and 32-frame cancellations cover each path.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(zstd): observe cancellation during structural parsing
* fix(zstd): project section-name frame caps at the ELF directory boundary
readElfDirectoryFromBuffer now requires the caller's operation and throws the adjustable zstd.max_frames resource limit. Hardening, unwind, and the other directory consumers keep that typed refusal instead of an adapter or I/O error.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(zstd): preserve optional ELF evidence when frames are capped
* fix(zip): validate Zstandard members through frame completion (#12461)
fix(zip): require complete Zstandard member frames
* fix(elf): yield hardening section name decoding
* fix(elf): yield section names for unwind and export reads
* fix(zstd): yield ELF directory reads that already own a cancellation signal
Hardening, unwind, initializers, exports, kernel modules, debug link, and Android JNI now read section names through the cooperative directory when their caller has a signal. Readers with no signal stay synchronous.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(elf): share one initializer directory and retain its snapshot
* fix(android): reuse the admitted JNI ELF directory
* fix(elf): retain optional debug candidate evidence through cooperative decoding
* fix(zstd): yield ELF section names for Go, Rust, and IL2CPP
These inspections already own an abort signal. Their ELF directory read now uses the cooperative container decoder so a queued cancellation can land during a many-frame section-name table.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(elf): recognize compressed kernel modules before ELF decoding
The cooperative module reader decoded the bytes as ELF before the container check, so gzip, xz, and zstd modules became malformed images. The compression check now returns the unsupported-container report first.
Co-authored-by: morluto <morluto@users.noreply.github.com>
* refactor(elf): classify each container once before reading it
* fix(il2cpp): preserve admission order during cooperative linking
* fix(elf): reuse section-name decoding in debug-link comparison (#12472)
* style(elf): format updated section-reader test calls
---------
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(javascript): retain proven property presence at reads
The read-time IR and projection boundary builds on the destructuring work in #7716. This change adds an indexed own-slot proof and uses it for ordinary member reads as well.
Co-authored-by: SII-YDD <38822679+SII-YDD@users.noreply.github.com>
* fix(javascript): retain destructuring proof in read order
---------
Co-authored-by: SII-YDD <38822679+SII-YDD@users.noreply.github.com>
* fix(desktop): bind dconf profiles to selected database sources
* fix(desktop): resolve dconf before changing working directory
* fix(desktop): retain refused dconf lookup diagnostics
* fix(desktop): preserve execution-time dconf search fallback
* fix(desktop): keep host spawn failures outside dconf fallback
* fix(desktop): retain staged reader cleanup through command close
* test(kuna): await eviction boundary events explicitly
* test(kuna): bound lifecycle acknowledgements through shared owner
Cherry-picked shared follow-up from a5761c7545.
* fix(desktop): keep dconf sources independent of wrapper stdin
* test(desktop): restrict procfs command checks to Linux
* fix(desktop): own dconf wrapper cleanup before source retirement
* fix(desktop): retain dconf preparation inspection owners
* fix(desktop): classify dconf read failures by kind and errno
Record the failure kind, host errno, exit status, selected command, and
child stderr on DconfDump, and carry those facts to view_failure. Tests
assert the typed fields instead of error prose, including a PATH refusal
whose executable is not the last candidate.
* test(desktop): gate real dconf diagnostics on Linux
The real reader checks /proc file descriptors before launch, so macOS
reports descriptor-unavailable/ENOENT instead of launch-failed/EACCES.
Keep that launch refusal on Linux and cover the Evidence contract with
a mocked reader on every platform.
Co-authored-by: morluto <morluto@users.noreply.github.com>
---------
Co-authored-by: ShuaixinHuang <197200901+ShuaixinHuang@users.noreply.github.com>
Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: morluto <morluto@users.noreply.github.com>
* fix(environment): map id-list elements when a scalar set also changed
When comparing an answer's scalar id list, the id mapping ran only on the
sameItems fast path. Once one element genuinely changed, or the lengths
differed, array fell to pairwise comparison that compared each element
without its id-list field, so scalar skipped the mapping: comparing live
[101,102] with env [1,9] under 101->1, 102->2 reported /ids/0 (101 vs 1) as
a change as well as the real /ids/1 (102 vs 9).
Thread an idList flag from array to scalar, set by the same per-element rule
sameItems uses, so a mapped element matches and is counted as a normalised
id while a genuine change is reported with its original value. Non-id arrays
are unchanged.
* fix(environment): pair id-list survivors by translated identity
The first fix mapped each id-list element but still paired scalar arrays by
position, so a survivor that shifted position paired with the wrong item:
[101,102] versus [2] under 101->1, 102->2 still emitted a false /ids/0 value
difference even though 102->2 is the survivor and only the removal changed.
Pair id-list survivors by the environment identity they map to, then any
remaining live and environment items by position. The translation is one owner
shared with sameItems, and the paired comparison still maps the original live
id and reports its original value on a genuine change. Non-id arrays keep
positional pairing.
* fix(environment): keep id-list order checks to matched survivors
#idListPairs appended a positional fallback pair for a replaced id, and the
order check read every pair, so a single surviving identity that shifted
emitted a spurious order difference: [101,102] versus [2,9] under 101->1,
102->2 reported order as well as the real /ids/0 value change.
Return the identity-matched survivor pairs separately and compute order from
them alone; the positional fallbacks are value replacements, not the same
item in a new position. Two or more reordered survivors still report order.
* perf(environment): limit ID recovery to conflicting components
* fix(environment): prove response list order across maximum matches
* fix(environment): detect complete duplicate ID list reorders
---------
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
* fix(app-bundle): apply the plist decode budget to the XML branch
* test(app-bundle): cover the XML plist decode budget
* decode xml plist once, pass the text to the decode preflight
* fix(app-bundle): keep OpenStep plists out of the XML preflight, keep budget failures typed
OpenStep Info.plist text is not XML, so quoted markup inside it is string
data. Run the XML entity-expansion preflight only on actual XML input,
using the same format check the parser already uses. A valid OpenStep
bundle with a DOCTYPE-looking quoted string no longer fails the budget.
Budget exhaustion also keeps its own error: the resolver now returns a
typed bundle_info_plist_decode_budget_exceeded failure naming the 16 MiB
allowance instead of the malformed-plist diagnosis.
* Fix test names and budget error classification after the merge
* fix: regenerate user-visible error catalogue for plist budget constraint
* test: pin budget-exceeded bundle target to its catalogue row
* refactor(plist): give Info.plist decoding a shared owner
---------
Co-authored-by: Dextheking1 <Dextheking1@users.noreply.github.com>
Co-authored-by: benjaminkincses <4175097+benjaminkincses@users.noreply.github.com>
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
* fix(erlang): disclose BEAM bytes trailing the declared FOR1 form
A conformant FOR1 container sizes its form to the whole file, so bytes
past the form end are an unexamined appended or corrupt region. The
inspector decoded chunks only within the form but still reported
coverage.status "complete" with no mention of the surplus, so a caller
could not distinguish a clean BEAM from one carrying foreign trailing
bytes.
Compute the trailing byte count, report coverage.status "partial" with a
trailing_bytes field, and append a limitation naming the form end and the
unexamined count. Clean containers stay "complete" with trailing_bytes 0.
* fix(erlang): reparse retained BEAM Evidence without the trailing-bytes field
Evidence retained by a build predating coverage.trailing_bytes has no such
property, and projectErlangBeamView reparses that record with the strict
erlangBeamSchema. A required field rejected those records with an input error
before any summary or page could render, breaking the offline retained-Evidence
flow even for clean files.
Default coverage.trailing_bytes to 0 so historical records reparse while every
new parse still emits the concrete count and preserves each record's stored
status.
* fix(erlang): keep retained BEAM trailing coverage unknown, not zero
Defaulting coverage.trailing_bytes to 0 manufactured a "no trailer" reading for
Evidence retained before the field existed, even when its retained bounds
(artifact.bytes versus form.location.bytes) prove a trailer. Make the field
optional so a pre-field record reparses as unknown instead of a fabricated
zero, while every new parse still emits the concrete count.
* fix(erlang): admit chunk extents before applying count limits
* docs(erlang): explain trailing BEAM coverage
---------
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
* test(javascript): cover the isolated-world probe outside Electron identity
* fix(javascript): expand Electron call paths only with an Electron reference
* test(javascript): cover Electron reach through resolved names, aliases and worker URLs
* fix(javascript): attribute call-path unknowns only where the walk can reach Electron
* test(javascript): cover a hoisted read that precedes a loader alias
* fix(javascript): keep call-path unknowns for late-initialized loader aliases
* test(javascript): drop a duplicate loader-alias case
* test(javascript): cover loader aliases reached through bindings and calls
* fix(javascript): prove a late initializer loader-free before dropping its unknown
* test(javascript): cover loaders behind default parameters, wrappers and long alias chains
* fix(javascript): resolve identifiers inside late initializers and bound the loader proof
* fix(javascript): bound late loader proofs and preserve input uncertainty
* fix(javascript): fail closed for receiver and mutated loaders
* fix(javascript): close loader-free proof gaps
* fix(javascript): retain uncertain loader sources
* test(javascript): cover remaining loader proof gaps
* fix(javascript): bound alias writes and preserve loader uncertainty
* test(javascript): cover demand-driven loader mutation facts
* perf(javascript): index loader mutation facts on demand
* style(javascript): apply oxfmt to the loader proof changes
* test(javascript): cover inherited loaders and rebound alias writes
* fix(javascript): preserve inherited loaders and rebound aliases
* test(evaluation): update scoped feature coverage oracle
* test(javascript): cover inherited loader proof gaps
* fix(javascript): preserve projected and inherited loaders
* fix(javascript): prove safe parameter member reads
* test(javascript): cover loader proof review gaps
* fix(javascript): close remaining loader proof gaps
* fix(javascript): preserve qualified global replacements
* fix(javascript): preserve spread rest uncertainty
* fix(javascript): retain retried handler uncertainty
* fix(javascript): retain import.meta loader uncertainty
* fix(javascript): detach fresh constructed aliases
* fix(javascript): check inherited members of ambient loaders
* test(javascript): parse call-path gate fixtures as established CommonJS
* fix(javascript): prove projected locals inside late initializers
A function-local binding was accepted by scope alone, so a destructuring
projection such as `const { r } = {}` inside a late initializer never met
the inherited-member check that a top-level projection goes through. Route
projected locals through the binding proof; locals with inline initializers
keep the scope shortcut, since the walk already visits their expressions.
* fix(javascript): keep late results with changed prototypes or import.meta uncertain
The loader-free proof inspected member expressions inside a late function
but not what its caller does with the result. With `Object.prototype.load =
require`, `var load = () => ({})` and `load().load("electron")` reach the
loader through a member selected after the call, and a bare `import.meta`
returned after `import.meta.load = ...` does the same. Check each result
expression: a literal fails when its prototype chain gained members, a bare
`import.meta` when any of its members changed, and a result of unknown shape
when either happened. Promise and generator results inherit from
Object.prototype as well. `SemanticPropertyPathCoverage.touches` answers
whether any retained write or escape sits below a prefix.
* fix(javascript): detach replacements held by fresh bindings
`alias = replacement` with `const replacement = {}` selected an identifier
initializer, so the later `alias.other = 1` stayed a shared write on the
original alias group and the resolver treated `base` as overwritten,
dropping its bridge call path. Resolve the identifier to its binding and
accept it when that binding only ever received one fresh allocation.
Bindings that can hold the original object keep the shared write.
* fix(javascript): charge loader proofs through the wrapper-visit budget
#11319 replaced the wrapper-visit counter with a Budget, so the loader proof charge no longer compiled on current main. Spend it through the shared helper, which records the same limit.
* test(javascript): keep the alias bound off the quadratic write index
The 8,000 by 8,000 alias bound spent its time in the ambient write index, which walks every store to an object for each member write. That cost is the same on main and is not what the bound covers. Reach the same 64 million alias and write pairs with 32,000 aliases and 2,000 writes, which runs in about 2.5 seconds instead of 8.5 on the same host.
Drop the 30 second overrides on both alias bounds too. They halved the hosted CI deadline the source project gives them, and the testing guide asks tests to leave deadlines to the project.
* refactor(javascript): ask the effect log for loader proof effects
Main now guards reads of the effect indexes outside javascriptSemanticEffectLog.ts. The loader proof read them directly in 15 places. Route those reads through the log: the existing ambientPathMayHaveChanged and bindingHasMemberWrites queries, plus three timeless queries for a path or any member below it, an ambient binding write, and an escape at a site other than the call being proved. The answers are unchanged.
* fix(javascript): retain uncertainty for changed ambient values
---------
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
* refactor(targets): share the resolved target format vocabulary
* test(targets): verify each format kind at compile time
* refactor(targets): share Evidence and explicit format vocabulary (#12168)