* fix(elf): decode a 32-bit prpsinfo whose ABI gives pr_uid 32 bits
`decodeCorePrpsinfo` assumed every ELFCLASS32 core carries the i386/ARM `struct elf_prpsinfo`:
16-bit `pr_uid`/`pr_gid` and a 124-byte descriptor.
`pr_uid` is `__kernel_uid_t`, and its width is an ABI property, not an ELF-class one. Only
`arch/x86/include/uapi/asm/posix_types_32.h` and its ARM/m68k/sparc counterparts narrow it to
`unsigned short`; everything else takes `asm-generic/posix_types.h`'s `unsigned int`, so MIPS o32,
PowerPC-32, s390 and `compat_elf_prpsinfo` (`include/asm-generic/compat.h`:
`typedef u32 __compat_uid_t`) write a 128-byte struct with every member after `pr_flag` four bytes
later.
Reading a 128-byte descriptor with the 124-byte offsets published wrong values rather than null.
Measured through `parseElfNotes`, with `uid 70000, gid 80000, pid 4242, fname mips-proc`:
before: {"pid":80000,"ppid":4242,"pgrp":1,"sid":4242,"uid":4464,"gid":1,
"filename":"\u{10}","psargs":""}
after: {"pid":4242,"ppid":1,"pgrp":4242,"sid":4242,"uid":70000,"gid":80000,
"filename":"mips-proc","psargs":"./mips-proc --serve"}
`pid` came out of the middle of `gid` and the two text fields came from the wrong offsets
entirely.
The kernel writes `sizeof(*psinfo)` as the descriptor — `fs/binfmt_elf.c`:
`fill_note(&info->psinfo, PRPSINFO, sizeof(*psinfo), psinfo)` — so the declared length already
carries the distinction and no machine table is needed. The 32-bit id width is now
`descriptor.length >= 128 ? 4 : 2`, and `pr_pid`/`pr_fname`/`pr_psargs` are derived from it. The
124-byte and 136-byte decodes are unchanged; the second new case pins that.
`src/native/elf` and `src/domain/native` — 535 passing. Forcing the 16-bit layout fails the new case.
* test(elf): produce the 32-bit prpsinfo layout from the shared note builder
Review finding: the regression hand-encoded a second NT_PRPSINFO layout while `corePrpsinfoNote` is
the repository's producer for this format, so nothing else could represent the MIPS/PowerPC/s390
ABI and the two encodings could drift.
`corePrpsinfoNote` takes `idWidth: 2 | 4` now. It allocates 124 or 128 bytes from it, writes
`pr_uid`/`pr_gid` at that width, and derives `pr_pid` through `pr_psargs` from `8 + idWidth * 2`
instead of the fixed 12/28/44 offsets. The option is ignored for a 64-bit image, whose layout is
fixed at 136.
Both new cases build their descriptor through the producer, so the test no longer carries offsets
the fixture does not know about.
* test(elf): drop the duplicate 124-byte prpsinfo case
The previous commit's rewrite left the original hand-built 124-byte block in place, so the same
regression ran twice — once through `corePrpsinfoNote`, once with the offsets written out again.
Keeping both is exactly the drift the shared producer was supposed to end.
* fix(elf): preserve SuperH PRPSINFO decoding
---------
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
Co-authored-by: wunianze666-netizen <wunianze666@gmail.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>
* feat(elf): decode FDO packaging and dlopen note metadata
Name FDO notes within their owner's namespace: type 0xcafe1a7e is
fdo_packaging_metadata and 0x407c0c0a is fdo_dlopen_metadata. One
elfNoteTypeName(owner, type) replaces the GNU-only gnuNoteTypeName.
Each entry gains an fdo field next to gnu. metadata holds the descriptor's
JSON object (packaging) or array (dlopen) when it is NUL-terminated UTF-8
JSON followed only by NUL padding; otherwise metadata is null and issue
names the broken rule, without failing the inspection. Each descriptor
range is decoded once and its retained JSON text is charged to the shared
note text budget per repeated entry. A limitation marks the metadata as a
producer declaration.
Fixes#7235
* fix(elf): key FDO note decoding by note type
The FDO decode cache was keyed by descriptor range only, but the note
type selects the required JSON shape. Overlapping PT_NOTE and SHT_NOTE
tables can give one descriptor range a packaging note and a dlopen note,
and the second reused the first note's verdict. Include the type name in
the key.
Refs #7235
* fix(elf): bound FDO note decoding before parsing JSON
The FDO decoder charged only descriptor source bytes before JSON.parse,
but a dense JSON value such as [{},{},...] decodes to about 50 times its
source size in heap before the service and Evidence copy it again. A
16 MiB descriptor took about 790 MiB of heap; one near the default
64 MiB file budget could exhaust the Node heap. Leave descriptors above
64 KiB undecoded with an issue naming the limit; real FDO notes are a
few hundred bytes.
Refs #7235
* fix(elf): share one FDO decode allowance across the report
The 64 KiB FDO decode bound applied to each descriptor, so raising
max_entries to 256 admitted 256 distinct dense 64 KiB notes: a 16 MiB
file added about 700 MiB of heap before Evidence copied it again.
Charge each distinct descriptor's size to one 64 KiB allowance per
report; a range repeated by another table reuses its decode, and notes
past the allowance keep their entry with an issue.
Refs #7235
* test(desktop): exercise the shared JSON depth guard in the heap suite
---------
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
inspect_elf_notes and inspect_elf_debug_link now examine up to 128 note
entries by default instead of 32; the ceiling stays 256. Ubuntu 26.04's
libc.so.6 is examined as 85 entries, 79 of them SystemTap probes, and both
tools refused it with default arguments.
* refactor(domain): move the native section directory and ELF string readers into domain
* test(native): fingerprint the moved section directory in the JNI qualification script
* test(architecture): fail on a stale layer baseline and document the declared layers
verify:module-boundaries reported a layer baseline entry whose imports were
gone but still passed, so main kept process -> artifacts at 20 after it fell
to 17 and a later change could add three imports back unnoticed. A stale
entry now fails like growth; --shrink-layer-baseline lowers it in the change
that removes the imports. The architecture map and CONTRIBUTING name
scripts/lib/module-layers.mjs as the per-directory layer declaration.
* test(architecture): refuse to lower the layer baseline after an inspection failure
A file that cannot be parsed contributes no imports, so a shrink run would record counts that fail as growth once the file is fixed. Whole-command tests cover stale rejection, shrinking, refused growth and the inspection failure.
* refactor(ports): move the progress, work-scope and inspection-scope ports to src/ports (#11214)
* refactor(ports): move the progress, work-scope and inspection-scope ports to src/ports
Pure move with git mv and import specifier updates.
* test(architecture): declare the ports layer and lower the layer baseline
src/ports sits between the foundation and the providers. Moving the three
ports removes 11 provider -> application imports.
* refactor(ports): move AnalysisProvider to src/ports (#11217)
* refactor(ports): move AnalysisProvider to src/ports
Pure move with git mv and import specifier updates in its importers, the
built-fixture path, the CI scope glob and the lint-rule test spellings.
* test(architecture): lower the layer baseline after moving AnalysisProvider
* refactor(ports): move the per-feature provider ports to src/ports (#11226)
* refactor(ports): move the per-feature provider ports to src/ports
Pure move with git mv and import specifier updates: the 47 *Port.ts and
*Ports.ts files that providers implement, plus OptionalObservationProviders,
which only composes the observation ports.
* test(architecture): lower the layer baseline after moving the feature ports
* refactor(providers): move closeAnalysisClient and the Frida session input errors to their owners (#11233)
* refactor(providers): move closeAnalysisClient to src/providers and the Frida session input errors to src/frida
Pure move with git mv and import specifier updates.
* test(architecture): drop the application-providers and application-frida cycles from the layer baseline
* fix(ci): keep provider lanes selecting the ports moved to src/ports
Each lane glob that matched a moved port under src/application gains its src/ports counterpart; the change-scope test pins one moved port per lane.
* refactor(domain): declare the localPath host exception and read HOST_PLATFORM there (#11256)
absoluteLocalPathStringSchema decides which paths are absolute on the running host, so it reads HOST_PLATFORM instead of process.platform. Domain may not import outside domain/contracts; module-layers now declares LAYER_EXCEPTIONS, exact file-to-file imports with a reason, and both the layer count and the pure-layer boundary skip only that import. Any other domain -> platform import still fails.
* refactor(ports): move the doctor check and provider inspection types to src/ports (#11246)
* refactor(ports): move the doctor check and provider inspection types to src/ports
Declaration move from application/Doctor.ts (unchanged text) and import updates; no re-export from Doctor.ts.
* test(architecture): lower the layer baseline after moving the doctor provider types
* refactor(ports): move the packet capture and signal recording ports to src/ports (#11249)
* refactor(ports): move the packet capture and signal recording ports to src/ports
Declaration move (unchanged text) out of the two application services, with import updates.
* test(architecture): lower the layer baseline after moving the capture and signal ports
* refactor(domain): move the analysis error projection schema from contracts to domain (#11251)
* refactor(domain): move the analysis error projection schema from contracts to domain
Declaration move (unchanged text) of the projection schemas that domain modules embed; contracts/errorSchemas.ts keeps the CLI envelope and the published JSON Schema. Import updates only.
* test(architecture): drop the contracts-domain cycle from the layer baseline
* refactor(ports): drop the imports the moved capture, signal and doctor types left behind
Also give the packet capture and signal recording lanes the new port paths, with change-scope cases.
* refactor(resources): add src/resources and move AnalysisCleanupLease and ArtifactReader there (#11259)
* refactor(resources): move AnalysisCleanupLease to src/resources
Pure move: git mv plus import specifier rewrites (source, tests, and the dist paths the verifier scripts load).
* refactor(resources): declare src/resources as a foundation unit
src/resources owns the shared analysis resource modules that process, windows and providers hold; AnalysisCleanupLease is the first. Its tests join the adapters project, the apk signature lane selects it beside src/artifacts, and the layer baseline drops the process and windows imports of the lease.
* test(ci): pin the apk signature lane on the moved cleanup lease
* refactor(resources): move ArtifactReader to src/resources
Pure move: git mv plus import specifier rewrites (source, tests, and the dist path a verifier script loads).
* test(architecture): lower the layer baseline after moving ArtifactReader
windows no longer imports src/artifacts; process -> artifacts 11 -> 9. The CI lanes that selected src/artifacts/ArtifactReader.ts select its new path, pinned in the change-scope test.
* refactor(resources): move ArtifactResourceScope to src/resources (#11265)
* refactor(artifacts): name the output tree and private root capabilities the resource scope releases
ArtifactResourceScope typed its output-tree and private-runtime-root owners with SafeOutputTree (src/artifacts) and PrivateRuntimeRoot (src/process). It only calls rollback() and close(), so it now declares those capabilities itself and names neither unit, which lets it move to src/resources without a resources <-> process cycle. The withheld-export test narrows to SafeOutputTree where it reads the published flag.
* refactor(resources): move ArtifactResourceScope to src/resources
Pure move: git mv plus import specifier rewrites (source, tests, the dist paths verifier scripts load, and the FIFO probe's module-relative URL).
* test(architecture): lower the layer baseline after moving ArtifactResourceScope
process -> artifacts 9 -> 5, and the artifacts <-> dotnet mutual pair is gone. The sqlite and agentenv lanes select the scope at its new path, pinned in the change-scope test.
* refactor(resources): move ArtifactFileOperation to src/resources (#11269)
* refactor(resources): move ArtifactFileOperation to src/resources
Pure move: git mv plus import specifier rewrites (source, tests, and the dist paths verifier scripts load).
* test(architecture): lower the layer baseline after moving ArtifactFileOperation
process -> artifacts 5 -> 1.
* refactor(resources): move readStableArtifact to src/resources (#11271)
* refactor(resources): move readStableArtifact to src/resources
Pure move: git mv plus import specifier rewrites.
* test(architecture): lower the layer baseline after moving readStableArtifact
process no longer imports src/artifacts: process -> artifacts 1 -> 0 and the artifacts <-> process mutual pair is gone. The seven lanes that selected readStableArtifact select its new path, pinned in the change-scope test; the architecture map lists what src/resources owns.
* refactor(hopper): take Linux launcher verification from composition through a port (#11278)
The Hopper launcher imported inspectLinuxHopperLauncher and retryLinuxHopperPublisherCleanup from src/application (the two hopper -> application imports). src/ports/LinuxHopperLauncherVerification.ts now names that capability; src/application/LinuxHopper.ts provides LINUX_HOPPER_LAUNCHER_VERIFICATION, binary composition passes it to HopperProvider, and the provider hands it to the launcher. A launcher built without one refuses a Linux demo launch with reason verification_unavailable before running the launcher. Layer baseline: hopper -> application 2 -> 0.
* refactor(config): move Hopper launcher discovery to a src/hopperPaths foundation unit (#11292)
* refactor(hopper): move the launcher discovery and macOS Hopper paths to src/hopperPaths
Pure move: git mv plus import specifier rewrites.
* refactor(hopper): declare src/hopperPaths as a foundation unit with the Linux launcher candidates
Hopper install paths and launcher discovery are pure path facts that the
Hopper provider, doctor and setup all read. Declare src/hopperPaths in the
foundation layer, add it to the adapters test project, the architecture
map and the package-baseline CI lane, and move the Linux launcher
candidates out of src/application/LinuxHopper.ts into
src/hopperPaths/LinuxHopperPaths.ts so discovery no longer imports
application code.
* refactor(config): leave Hopper launcher discovery to the Hopper provider
parseConfig resolved an unset HOPPER_LAUNCHER_PATH by probing the
filesystem through application-owned discovery, so config imported
application (config -> application 2, application <-> config cycle) and
read process.platform ambiently.
AppConfig.hopperLauncherPath is now the caller's HOPPER_LAUNCHER_PATH
unchanged (string | undefined). src/hopperPaths/HopperLauncherDiscovery.ts
owns the selection (selectedHopperLauncherPath: the configured spelling,
else discovery from the caller environment's home on the provider's
platform); HopperProvider and the two real-Hopper verifiers read it.
Discovery tests move from config.test.ts to src/hopperPaths; a provider
test covers discovery from the provider's own platform and home.
Module layers: config -> application 2 -> 0; application <-> config removed.
Architecture guards: ambient platform reads in parseConfig.ts 2 -> 0.
* refactor(providers): move owned-process prerequisite availability out of application (#11294)
* refactor(providers): move the owned-process prerequisite availability mapping to src/providers
Pure move: git mv plus import specifier rewrites.
* test(architecture): lower the layer baseline after moving owned-process availability
android -> application 1 -> 0; apktool -> application 1 -> 0.
* refactor(process): move the regular-file read owner out of application (#11299)
* refactor(process): move the regular-file read owner from src/application to src/process
Pure move: git mv plus import specifier rewrites.
* test(architecture): lower the layer baseline after moving the regular-file read owner
desktop -> application 5 -> 4; dotnet -> application 2 -> 1.
The agentenv lane listed src/application/RegularFileRead.ts. At its new
path it is a src/process/ shared boundary: fast qualification selects the
code and runtime checks (and the single owning lane, web_source_map, via
src/process/**), and full qualification selects every lane, as for every
other src/process/ module. A second owner entry would only suppress the
web_source_map selection, so the agentenv entry is removed, not renamed.
* refactor(resources): give atomic text writes their own owner (#11302)
* refactor(resources): give atomic text writes their own owner in src/resources
src/application/JsonFiles.ts owned both JSON input reads and the atomic
text write (writeTextFile / writeTextParts and their staged-output
publication). The write side depends only on domain, filesystem and
resource owners, but il2cpp's Ghidra seed writer had to import
application to reach it (il2cpp -> application).
Move the write side verbatim to src/resources/TextFileWrite.ts
(TextWriteCancellation, writeTextFile, writeTextParts and their private
staging, publication and failure classification helpers). JsonFiles keeps
the JSON read owner and reads the shared errno-to-reason classifier
(fileAccessFailureReason) from the write owner instead of a copy.
Importers (il2cpp seed writer, evidence bundle files, desktop build
solves, analysis snapshot files and four boundary tests) read the new
path; no re-export is left in JsonFiles.
* test(architecture): lower the layer baseline after moving the text write owner
il2cpp -> application 1 -> 0.
* refactor(ports): move the desktop build host contract to src/ports (#11303)
* refactor(domain): move the setup cancellation check from src/application to src/domain
Pure move: git mv plus import specifier rewrites.
* refactor(ports): move the desktop build host contract to src/ports
The desktop provider implements doctor's desktop build facts reader and
setup's desktop build host, but the contract it implements lived in
application (DesktopBuildDoctor, SetupDesktopBuild, Doctor's
clientRegistrations signature, ClientRegistrationEnvironment's setting
types), so desktop imported application four times and the two units
were a recorded mutual pair.
src/ports/DesktopBuildHost.ts now holds that contract, moved verbatim:
DesktopBuildCommand, DesktopBuildFacts, DesktopBuildFactsInput,
DesktopBuildSetupFacts, DesktopBuildSetupHost, RecordedProviderSettings
and OwnedProviderSetting. Two names are new: DesktopBuildRegistration,
the registration facts the host reads (client, command and the
recorded-settings names; client registration status satisfies it), and
DesktopBuildRegistrationReader, which replaces
DoctorHost["clientRegistrations"] in the setup host. The facts input's
registration reader returns DesktopBuildRegistration instead of the full
application status; the setup facts' settings are spelled
Readonly<Record<string, string>> (SetupProviderEnvironment's definition).
Application imports the types from the port; no re-export is left.
* test(architecture): lower the layer baseline after the desktop build host port
desktop -> application 4 -> 0; the application <-> desktop mutual pair is gone.
* refactor(domain): define the resolved app bundle resource root beside its schema (#11304)
* refactor(domain): define the resolved app bundle resource root beside its provenance schema
ResolvedAppBundleResourceRoot (an app directory's resource-only identity)
is a pure type over BundleResourceRoot's layout, but it lived in
src/application/AppBundleExecutable.ts, so the native and artifact
providers that receive it imported application.
Move the interface verbatim to src/domain/apple/bundleResourceRoot.ts,
which owns BundleResourceRoot, and point its eight readers there (native
macOS provider and plist source, artifact provider, binary composition,
and the binary session, status, port and bundle-resource session). The
resolver that produces it stays in application.
* test(architecture): lower the layer baseline after moving the resource root type
native -> application 2 -> 0; artifacts -> application 2 -> 1 (the
artifact provider still constructs BundleResourceSession).
* refactor(config): move the pwntools input bound parser to src/config (#11306)
* refactor(config): move the pwntools input bound parser from src/native to src/config
Pure move: git mv plus import specifier rewrites, and the module path in docs/design/rea-limit-inventory.md (table realigned by oxfmt).
* test(architecture): lower the layer baseline after moving the pwntools input bound
config -> native 1 -> 0. The binary_layout and recorded_crash lanes, which
select src/native/pwntools/**, also select src/config/pwntoolsInputLimit*.ts;
ciChangeScope.test.ts pins both.
* refactor(filesystem): move REA cache directory helpers out of config (#11309)
* refactor(filesystem): move the REA cache directory and lexical directory helpers from src/config to src/filesystem
Pure move: git mv plus import specifier rewrites.
* test(architecture): drop the config and filesystem cycle from the layer baseline
config no longer imports filesystem; filesystem still reads the Windows
ChangeTime settle budget from config.
* refactor(windows): break the process and windows import cycle (#11317)
* refactor(domain): move the runtime-control and private-runtime-root refusals from src/process to src/domain
Pure move: git mv plus import specifier rewrites (including the dist path scripts/verify-windows-native.mjs loads).
* refactor(windows): type Job Object cleanup by what a Windows job reports
WindowsOwnedProcess.cleanup() returned process-ownership's
ProcessCleanupResult, so src/windows imported src/process for a type while
process imports windows to supervise Windows trees. A Job Object stop only
ever reports settled-and-signalled or a reason it did not settle; name that
subset WindowsJobCleanupResult in windows. It stays assignable to
ProcessCleanupResult, so the process supervisor reads it unchanged.
* test(architecture): drop the process and windows cycle from the layer baseline
* test(architecture): ratchet cross-provider imports and imports past a provider entry (#11386)
* test(architecture): ratchet cross-provider imports and imports past a provider entry
A provider folder may import the domain, contracts, foundation and ports layers, the shared provider core (src/providers) and its own files; an import of another provider folder is a recorded exception. Application, composition and the CLI/MCP adapters reach a provider only through src/<provider>/index.ts. verify:module-boundaries counts both kinds of import per unit pair in the layer baseline (crossProvider, providerEntry); like the upward counts they may only shrink, and a pair missing from the baseline fails.
* refactor(resources): move StableArtifactFailure and StableArtifactObservation into src/resources (#11387)
* refactor(resources): move StableArtifactFailure and StableArtifactObservation into src/resources
Providers project stable-read failures through StableArtifactFailure next to the other shared provider toolkit owners (ArtifactReader, ArtifactResourceScope, ArtifactFileOperation, AnalysisCleanupLease, readStableArtifact) that already live in src/resources. Under src/artifacts it made every provider that reads a stable artifact import the artifacts provider. Pure move: git mv plus import specifier and baseline updates; the layer baseline drops the provider-boundary counts the move removes.
* refactor(resources): reach the shared provider toolkit through src/resources/index.ts (#11390)
* refactor(resources): import the shared provider toolkit through src/resources/index.ts
Adds src/resources/index.ts, which exports the toolkit names that production code outside src/resources uses, and rewrites those importers (420 files) to import from it, merging each importer's toolkit imports into one declaration. Mechanical: import declarations only.
* test(architecture): reach src/resources only through its entry file
verify:module-boundaries now counts any production import of a src/resources file other than src/resources/index.ts, from any unit, with the imports past a provider entry. The count is renamed from providerEntry to entry ("import past the entry file"); it may only shrink, and src/resources starts at zero.
* test(architecture): cover provider boundary counts through the verifier command
* refactor(resources): move the safe output tree and artifact path owners into src/resources (#11398)
* refactor(resources): move the safe output tree and artifact path owners into src/resources
SafeOutputTree (with its admission, creation failure, readback, cleanup and identity files), StreamBytes, ArtifactPaths and readArtifactFileChunks depend only on domain, filesystem, platform and the toolkit, and browser, firmware, ghidra, javascript, android and apktool use them to publish outputs. Under src/artifacts every such provider imported the artifacts provider. Pure move: git mv, importers moved onto src/resources/index.ts (names added to the entry), the moved files import toolkit modules directly, path keys in the CI scopes and guard baseline follow the move, and the layer baseline drops the removed imports.
* test(architecture): give the shared provider core its own layer below the providers (#11401)
src/providers (deferred client owners and failure attribution) now imports only domain, ports, process, filesystem and the resources toolkit. Declaring it as the providerCore layer, between ports and providers, makes any import from it into a provider folder an upward import that verify:module-boundaries rejects, and lets every unit in the providers layer be a provider folder.
* test(architecture): declare each provider's entry files instead of a provider barrel (#11407)
* chore: ignore the source map parser move (#11348) in blame
* test(architecture): declare inspector's use of the browser CDP client as a provider dependency (#11420)
* refactor: report NativeAOT, Interface Builder and owned-MCP output limits through the shared limit owners
* refactor(errors): carry a parser's required value on its limit reference and in adjustable-budget refusals (#11201)
* fix(android): keep the JADX output-limit refusal's retained process output
* refactor(native): name PE and native-export allowances in the BinaryResourceFailure limit (#11253)
PeImportLimitFailure, PeLoadConfigLimitFailure and NativeExportLimitFailure kept a parallel `limit` field beside the LimitRef their BinaryResourceFailure base already carries (named only "structure"). The allowance name now lives in the LimitRef, consumers read it with binaryResourceAllowance against the parser's exported allowance list, and the three subclasses are removed. The local-limit-error-class guard also counts limit subclasses of BinaryResourceFailure.
* feat(elf): decode Linux core dump process and memory mapping notes
Inspect Linux core dump note tables and decode structured metadata without
requiring external tools or debuggers:
- NT_PRPSINFO (type 3): decode process ID, parent ID, process group,
session, UID, GID, execution state, filename, and command line arguments
bounded by the text budget.
- NT_FILE (type 0x46494c45): decode mapped memory ranges (start_address,
end_address, file_offset_pages) and mapped file paths with page size.
- NT_SIGINFO (type 0x53494749): decode faulting signal number, errno, and code.
- NT_AUXV (type 6): decode auxiliary vector pairs with known AT_* tag names.
- Support both 32-bit and 64-bit, little-endian and big-endian targets.
- Retain unknown core note types gracefully without partial success errors.
- Add comprehensive unit tests, fixtures, acceptance tests, and documentation.
* fix(elf): preserve raw path bytes and enforce auxv termination
* fix(elf): account for path hex text budget and enforce auxv trailing padding
* fix(elf): account for row and scan limits, ABI signal order, and lossless source IDs
* fix(elf): cache auxv padding scans, pre-charge entries, and isolate page-size test
Centralize ELF section and Godot trailer declarations while preserving caller admission policies. Route six PE entrypoints through canonical DOS ownership so relocation data cannot establish a PE header, and update NativeAOT interpretation identity and verifier dependency coverage.
Share exact ELF program-header facts across nine consumers while preserving their admission and precision policies. Centralize conformance path and digest binding, retain verifier-specific checks, and route fixture-owner changes to CI qualification.
Explain unreadable ELF note section names without discarding complete note coverage. Keep export and PE import rows when only version or DLL-name metadata is unresolved, and stop claiming those retained rows were unreported.
Use native byte equality for the 4 MiB ELF extended-numbering source-preservation checks; generic deep equality enumerated every buffer byte and exhausted the test worker heap. The full fixture and byte coverage remain.
Validation: focused ELF note, native export, and PE import regressions plus complete CLI/MCP adapter files passed under the existing 512 MiB heap limit. Build, typecheck/lint, formatting, and documentation checks passed.
Refuse compressed note sections with typed unsupported-target semantics before framing or decoding, preserving stored-range checks and physical descriptor-offset provenance. Flutter retains independent build IDs with partial coverage when compressed notes are skipped. Verify the existing shared alignment fix with prefixed notes across classes and table kinds.
Fixes#6869Closes#6563
Retain bounded FAT and offset-tagged PE observations through archive hashing,
classification, and content nodes. Preserve PyInstaller member paths according
to the observed carrier dialect and share APK v1 signing-name semantics.
Read SQLite's implicit sqlite_schema table without inventing a stored schema
declaration. Distinguish unsupported ELF numbering and decoded-name admission
from malformed data and fixed scan allowances. Preserve Sigrok basenames and
classify matching explicit input-format refusals at their owning boundary.
Validation: 554 distinct tests passed, 3 skipped across serial focused runs;
build, typecheck/lint, docs, formatting, and discovery (2141 files) passed.
Sigrok command-boundary simulators do not establish real-tool decoding.
Small repeated public PyInstaller CLI runs had equivalent inventory facts;
warm median elapsed 0.5431s before / 0.5426s after, with no speed claim.
Fixes#6733Fixes#6741Fixes#6722Fixes#6732Fixes#6736Fixes#6734Fixes#6764Fixes#6766
Refs #6739
Normalize parsed facts at their owning boundaries across PE exports and certificates, ELF section names, GPU bundles, IL2CPP generic types, dyld slice selection, source maps, environment replay, and JavaScript mapped arguments. Preserve partial facts and explicit unsupported cases; clarify the corresponding documentation.
Validation: 831 affected tests passed with one existing skip across 23 files; build, typecheck/lint, documentation, formatting, and 2133-file test discovery passed. Format controls are synthetic; real Unity, GPU, and ARM-device execution is unverified.
Fixes#6709Fixes#6688Fixes#6719Fixes#6718Fixes#6704Fixes#6703Fixes#6692Fixes#6723Fixes#6687Fixes#6726Fixes#6696Fixes#6691Fixes#6727
Inspect selected ELF32/ELF64 PT_NOTE and SHT_NOTE declarations without executing
the artifact, retaining independent table identities, source ranges, descriptor
digests, GNU build-id/ABI fields and explicit coverage limitations.
Integrate mvanhorn's implementation and hardening with current main while
preserving byte-entropy registration and the Windows curated regression suite.
The maintainer follow-up uses ordinary merges/pushes, not history rewriting.
Executed validation: 96 focused/shared/docs tests, complete static/docs checks,
eleven real CLI/MCP pairs including GCC ELF32 and Clang big-endian PowerPC64,
and two actual Codex task traces checked against their Evidence. Full costs,
grader correction and verification limits are recorded in PR #4837.
Refs #6262.