mirror of
https://github.com/morluto/rea.git
synced 2026-11-16 19:53:50 +00:00
Eleven tests were named "beyond the former ..." and pinned a value just above a limit that no longer exists. Each now states and checks the current contract: - jsonShape: the caller's byte allowance is the only bound; a shape that fits exactly is complete and one byte less is a capacity refusal. - Hopper download: chunks arriving just inside the stall bound complete (the trickle case already covers the total bound). - Firmware: a selected analysis_timeout_ms above the default governs the owned command, expressed from the default constant. - Provider process output, CDP resources/timeline/WebMCP frames, Playwright steps/artifacts/Electron waits, scenario diff and Bun ELF names: renamed to the unbounded-count or exact-selection contract they check, with a note on what bound (if any) still applies and where it is covered. The six JavaScript analyzer tests with the same naming are left to their workstream. Refs #10515
2004 lines
63 KiB
TypeScript
2004 lines
63 KiB
TypeScript
/**
|
|
* Lifecycle regression coverage for every provider id in
|
|
* `CAPABILITY_DECLARATIONS`.
|
|
*
|
|
* Each stage either names real regression tests (file and literal test title),
|
|
* is not applicable for a stated reason, or is an explicit gap. Gaps are also
|
|
* listed in `PROVIDER_LIFECYCLE_GAPS`; that list may only shrink, so closing a
|
|
* gap means naming its tests here and removing the gap entry. A newly
|
|
* registered provider must add its own entry.
|
|
*
|
|
* Stages: `launch` starts the owned process (including launch failure and
|
|
* refusal at the launch boundary); `handshake` is the first readiness or
|
|
* identity exchange after launch; `operation` is a completed analysis request;
|
|
* `cancel` is caller cancellation of admitted work; `cleanup` retains and
|
|
* reports a failed or unproven cleanup; `retry` releases a retained cleanup on
|
|
* a later attempt.
|
|
*
|
|
* Providers that run in-process (no owned process or connection) are tracked
|
|
* for operation and cancellation only. Their descriptor and snapshot cleanup
|
|
* belongs to the resource owners' own tests.
|
|
*/
|
|
|
|
export const LIFECYCLE_STAGES = [
|
|
"launch",
|
|
"handshake",
|
|
"operation",
|
|
"cancel",
|
|
"cleanup",
|
|
"retry",
|
|
] as const;
|
|
|
|
export type LifecycleStage = (typeof LIFECYCLE_STAGES)[number];
|
|
|
|
export interface LifecycleRegression {
|
|
/** Repository-relative test file. */
|
|
readonly path: string;
|
|
/** Literal title of a test in that file. */
|
|
readonly title: string;
|
|
}
|
|
|
|
export type StageCoverage =
|
|
| {
|
|
readonly kind: "covered";
|
|
readonly tests: readonly [LifecycleRegression, ...LifecycleRegression[]];
|
|
}
|
|
| { readonly kind: "not_applicable"; readonly reason: string }
|
|
| { readonly kind: "gap"; readonly reason: string };
|
|
|
|
export type ProviderOwnership = "process" | "connection" | "in_process";
|
|
|
|
export interface ProviderLifecycleCoverage {
|
|
readonly ownership: ProviderOwnership;
|
|
readonly stages: Readonly<Record<LifecycleStage, StageCoverage>>;
|
|
}
|
|
|
|
const test = (path: string, title: string): LifecycleRegression => ({
|
|
path,
|
|
title,
|
|
});
|
|
const covered = (
|
|
first: LifecycleRegression,
|
|
...rest: LifecycleRegression[]
|
|
): StageCoverage => ({ kind: "covered", tests: [first, ...rest] });
|
|
const notApplicable = (reason: string): StageCoverage => ({
|
|
kind: "not_applicable",
|
|
reason,
|
|
});
|
|
const gap = (reason: string): StageCoverage => ({ kind: "gap", reason });
|
|
|
|
const ONE_SHOT = notApplicable(
|
|
"One-shot command per request: there is no handshake after launch.",
|
|
);
|
|
const ATTACH_ONLY = notApplicable(
|
|
"Attaches to a caller-started engine endpoint; REA launches no process.",
|
|
);
|
|
const IN_PROCESS = notApplicable(
|
|
"In-process provider: no owned process or connection to launch, hand shake with, clean up or retry.",
|
|
);
|
|
|
|
const inProcess = (
|
|
operation: StageCoverage,
|
|
cancel: StageCoverage,
|
|
): ProviderLifecycleCoverage => ({
|
|
ownership: "in_process",
|
|
stages: {
|
|
launch: IN_PROCESS,
|
|
handshake: IN_PROCESS,
|
|
operation,
|
|
cancel,
|
|
cleanup: IN_PROCESS,
|
|
retry: IN_PROCESS,
|
|
},
|
|
});
|
|
|
|
const typedFailures = (path: string) =>
|
|
covered(test(path, "returns typed resource and cancellation failures"));
|
|
|
|
const HISTORICAL_DECODER =
|
|
"tests/boundary/browser/historicalCaptureDecoder.test.ts";
|
|
/** HAR, qlog, SAZ and mitmproxy captures share one owned decoder child. */
|
|
const historicalCapture = (
|
|
operation: StageCoverage,
|
|
): ProviderLifecycleCoverage => ({
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
HISTORICAL_DECODER,
|
|
"cancels after snapshot acquisition before launch and removes private input declarations",
|
|
),
|
|
),
|
|
handshake: notApplicable(
|
|
"The decoder child writes one reply per request; there is no handshake.",
|
|
),
|
|
operation,
|
|
cancel: covered(
|
|
test(
|
|
HISTORICAL_DECODER,
|
|
"preserves the exact cancellation reason observed during final runtime close",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
HISTORICAL_DECODER,
|
|
"retains completed capture facts and binds final root cleanup to its retry lease",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
HISTORICAL_DECODER,
|
|
"keeps late cancellation primary when runtime close also fails, then clears on retry",
|
|
),
|
|
),
|
|
},
|
|
});
|
|
|
|
const FIRMWARE_INTEGRATION =
|
|
"tests/boundary/firmware/firmwareIntegration.test.ts";
|
|
const REVERSE_LAUNCH_ERRORS =
|
|
"tests/composition/reverseProviderLaunchErrors.test.ts";
|
|
const REVERSE_EDGE_CASES =
|
|
"tests/composition/reverseEngineeringEdgeCases.test.ts";
|
|
const SOURCE_MAP_DECODER_BOUNDARY =
|
|
"tests/boundary/javascript/sourceMapDecoder.test.ts";
|
|
const CDP_BROWSER_SOCKET =
|
|
"tests/boundary/browser/cdpBrowserProvider.browserSocket.test.ts";
|
|
const CDP_CLEANUP_CANCELLATION =
|
|
"tests/boundary/browser/cdpCleanupCancellation.test.ts";
|
|
|
|
export const PROVIDER_LIFECYCLE_COVERAGE: Readonly<
|
|
Record<string, ProviderLifecycleCoverage>
|
|
> = {
|
|
adb: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/adb/AdbCommand.test.ts",
|
|
"reports an adb that never started without claiming an exit code",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"src/adb/AdbProvider.test.ts",
|
|
"pulls one device file with a digest",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"src/adb/AdbProvider.test.ts",
|
|
"reports cancellation arriving during the version probe",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"src/adb/AdbProvider.test.ts",
|
|
"retains failed snapshot cleanup with completed push Evidence until close retries",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/adb/AdbProvider.test.ts",
|
|
"retains failed snapshot cleanup with completed push Evidence until close retries",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"aioquic-qlog-json": historicalCapture(
|
|
gap(
|
|
"Successful qlog decoding is covered at the parser; no regression completes it through the decoder child.",
|
|
),
|
|
),
|
|
"apk-signature": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/apkSignatureViewIdentity.test.ts",
|
|
"checks parent subject identity again when signing facts are already cached",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"tests/process-global/apkSignatureLifecycle.test.ts",
|
|
"keeps the abort reason itself as the cancellation cause",
|
|
),
|
|
),
|
|
),
|
|
apktool: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/apktool/ApktoolProvider.test.ts",
|
|
"reports launcher disappearance after version admission as a provider failure",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"src/apktool/ApktoolProvider.test.ts",
|
|
"decodes resources with target identity, metadata, and strings",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"src/apktool/ApktoolVersionProbe.lifecycle.test.ts",
|
|
"stops an interpreter launcher and its pipe-holding child when the probe is cancelled",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"src/apktool/ApktoolProvider.test.ts",
|
|
"retains completed Evidence and live cleanup until a denied workspace removal recovers",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/apktool/ApktoolProvider.test.ts",
|
|
"retains failed workspace cleanup and retries it on close",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
binwalk: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/firmware/FirmwareCommand.test.ts",
|
|
"does not relabel an unrelated launch failure when a deadline also fires",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
FIRMWARE_INTEGRATION,
|
|
"binds region observations to exact bytes and preserves provider-reported uncertainty",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
FIRMWARE_INTEGRATION,
|
|
"cancels an owned active process and permits the next queued operation",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
FIRMWARE_INTEGRATION,
|
|
"retains an uncertain worker's workspace and blocks later launches",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/firmware/firmwareReportFiles.test.ts",
|
|
"retains the analysis timeout and command output while report cleanup is pending and after retry",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"byte-entropy": inProcess(
|
|
covered(
|
|
test(
|
|
"src/application/binaryDiagnostics/ByteEntropyService.test.ts",
|
|
"keeps whole-file identity and entropy while selecting unaligned blocks and a partial tail",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"src/application/binaryDiagnostics/ByteEntropyService.test.ts",
|
|
"honors cancellation before and during streaming",
|
|
),
|
|
),
|
|
),
|
|
"cutter.python-plugin": {
|
|
ownership: "connection",
|
|
stages: {
|
|
launch: ATTACH_ONLY,
|
|
handshake: covered(
|
|
test(
|
|
"tests/boundary/providers/cutterBridgeProducer.test.ts",
|
|
"authenticates bridge peers before payloads and permits status recovery after a poisoned UI timeout",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/mcp/cutterMcp.test.ts",
|
|
"preserves live Cutter command Evidence and parity through the MCP boundary",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/mcp/cutterCancellationMcp.test.ts",
|
|
"propagates MCP cancellation into an active Cutter command",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/providers/CutterBridgeService.test.ts",
|
|
"clears a poisoned command only after its exact UI-dispatcher receipt",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/providers/cutterBridgeProducer.test.ts",
|
|
"retains failed receipt acknowledgements and retries before another command",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"electron-fuses": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/electronFusesCli.test.ts",
|
|
"retains Windows drive, root, and mixed-separator path resolution",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"src/electron/ElectronFuseCleanup.test.ts",
|
|
"retains the exact caller reason and completed Evidence when final close succeeds after cancellation",
|
|
),
|
|
),
|
|
),
|
|
"evmole-interface": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/evm/EvmoleFailures.test.ts",
|
|
"maps real selected-path failures before the EVM worker starts",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/evm/evmoleInterfaceProvider.test.ts",
|
|
"retains raw metadata and ordered duplicate selector inferences after worker admission",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/evm/evmCleanupRetry.test.ts",
|
|
"preserves an active cancellation through denied owned-group cleanup and later retry",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/evm/evmoleInterfaceProvider.test.ts",
|
|
"retains original format failure when owned-root cleanup fails",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/evm/EvmoleInterfaceProvider.test.ts",
|
|
"retains a real cleanup owner through failed EVM close and releases it on retry",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"fiddler-saz": historicalCapture(
|
|
covered(
|
|
test(
|
|
"tests/boundary/browser/sazWebCapture.test.ts",
|
|
"uses HTTP optional whitespace for SAZ identity codings without changing raw headers",
|
|
),
|
|
),
|
|
),
|
|
flutter: inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/flutterBuildProvider.test.ts",
|
|
"inspects a full synthetic AOT image end to end",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/flutterBuildProvider.test.ts",
|
|
"cancels before creating any snapshot root",
|
|
),
|
|
),
|
|
),
|
|
frida: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/frida/FridaInstrumentationManager.test.ts",
|
|
"retains a failed startup's spawn and remote lease until cleanup succeeds",
|
|
),
|
|
),
|
|
handshake: notApplicable(
|
|
"Frida runs in-process through its Node bindings; device and session attach is the launch stage.",
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"src/frida/FridaInstrumentationManager.test.ts",
|
|
"loads instrumentation before resuming a spawned target",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"src/application/frida/FridaInstrumentationService.test.ts",
|
|
"cleans up a session and returns typed cancellation after a pending start",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"src/frida/FridaInstrumentationManager.test.ts",
|
|
"refuses new session work after incomplete close while retaining cleanup for retry",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/frida/FridaInstrumentationManager.test.ts",
|
|
"retains a failed script handle until a later cleanup retry releases it",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
ghidra: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/ghidra/GhidraLaunchFailure.test.ts",
|
|
"retains the failed launcher command outcome on the launch error",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/ghidra/ghidraClient.test.ts",
|
|
"cancels startup promptly and leaves no project or process",
|
|
),
|
|
),
|
|
handshake: covered(
|
|
test(
|
|
"tests/boundary/providers/ghidra/ghidraClient.test.ts",
|
|
"completes an exact, fragmented post-analysis handshake",
|
|
),
|
|
test(
|
|
"tests/boundary/mcp/ghidraReopen.test.ts",
|
|
"refuses an uncommitted handshake report before the first query and replaces that session on reopen",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/providers/ghidra/ghidraClient.test.ts",
|
|
"correlates an admitted inventory request after startup",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/providers/ghidra/ghidraClient.test.ts",
|
|
"cancels queued work and stops active provider work on cancellation",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/ghidra/ghidraClient.test.ts",
|
|
"retains the identity refusal when cancellation arrives during final startup cleanup",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/mcp/ghidraReopen.test.ts",
|
|
"retains failed cleanup and refuses replacement until cleanup can be retried",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/ghidra/GhidraProvider.behavior.test.ts",
|
|
"reports rejection cleanup that failed and retries it on close",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/ghidra/ghidraClient.test.ts",
|
|
"redacts authentication after failed startup cleanup and retry",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"gnu.gdb": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"tests/boundary/providers/GdbSessionManagerCoverage.test.ts",
|
|
"retains ownership when GDB startup fails before its prompt and stop is incomplete",
|
|
),
|
|
),
|
|
handshake: covered(
|
|
test(
|
|
"tests/boundary/providers/GdbSessionManagerCoverage.test.ts",
|
|
"returns startup timeout when the MI prompt never arrives",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/GdbSessionManagerCoverage.test.ts",
|
|
"retries MI2 after an MI3 process exits before its startup prompt",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/providers/GdbSessionManagerCoverage.test.ts",
|
|
"correlates command output records and reports invalid or cancelled requests",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/mcp/gdbCancellationMcp.test.ts",
|
|
"propagates MCP cancellation into a running GDB command",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/cli/gdbStartupCleanupCli.test.ts",
|
|
"marks the CLI failed when retained GDB cleanup remains incomplete",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/cli/gdbStartupCleanupCli.test.ts",
|
|
"retries retained GDB cleanup when CLI session startup fails",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/GdbSessionManagerCoverage.test.ts",
|
|
"retains failed startup ownership when stop rejects and resolves it on retry",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"go-build-info": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/goBinaryCli.test.ts",
|
|
"delivers a Go CLI summary with its unchanged complete source bundle",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"src/application/go/GoBinaryService.test.ts",
|
|
"honors cancellation before reading and after a completed observation",
|
|
),
|
|
),
|
|
),
|
|
"gpu-code-objects": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/gpu/codeObjects.test.ts",
|
|
"does not decode unselected payloads and keeps stable positional identities",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"tests/process-global/gpuFileLifetime.test.ts",
|
|
"preserves completed observations when caller cancellation arrives during final close",
|
|
),
|
|
),
|
|
),
|
|
"har-schema/lossless-json": historicalCapture(
|
|
covered(
|
|
test(
|
|
"tests/boundary/browser/historicalWebCapture.test.ts",
|
|
"preserves opaque HAR container fields through CLI and MCP",
|
|
),
|
|
),
|
|
),
|
|
hopper: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"tests/acceptance/providers/hopperStartupRecovery.test.ts",
|
|
"recovers a denied Hopper launch through the same stdio MCP session and CLI",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/hopper/hopperClient.protocol.test.ts",
|
|
"records process exit code, stage, and restart guidance on unexpected exit",
|
|
),
|
|
),
|
|
handshake: covered(
|
|
test(
|
|
"tests/boundary/providers/hopper/hopperClient.health.test.ts",
|
|
"reports launch work until the first authenticated handshake completes",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/hopper/hopperClient.handshakeRecovery.test.ts",
|
|
"recovers an application exit after the first valid handshake occurs during cleanup",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/providers/hopper/hopperClient.protocol.test.ts",
|
|
"does not start cold and preserves normal dispatch once ready",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/providers/hopper/hopperClient.progress.test.ts",
|
|
"cancels and ignores late responses without corrupting the session",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/providers/hopper/hopperClient.cleanupRetry.test.ts",
|
|
"retains failed startup cleanup until an owned process and its backing image are closed",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/providers/hopper/hopperClient.cleanupRetry.test.ts",
|
|
"retries a failed lease release after document, process, and runtime cleanup are confirmed",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
ida: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/ida/IdaMcpEnvironment.test.ts",
|
|
"launches the owned stdio server with only the selected snapshot, never ambient variables",
|
|
),
|
|
test(
|
|
"src/ida/IdaMcpWindowsLaunch.test.ts",
|
|
"refuses a network-share executable before launch with a drive-letter remedy",
|
|
),
|
|
),
|
|
handshake: covered(
|
|
test(
|
|
"src/ida/IdaMcpOwnedCleanup.test.ts",
|
|
"keeps a failed handshake's incomplete cleanup observable with the redacted server tail",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"src/ida/IdaNativeProtocol.test.ts",
|
|
"retains native tool provenance, reads recorded metadata, and closes only its connection",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"src/ida/IdaSessionClient.test.ts",
|
|
"drains in-flight read-only work on cancellation before closing its proxy",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"src/ida/IdaSessionClient.test.ts",
|
|
"retains the private workspace and reports cleanup failure when worker release is unverified",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/ida/IdaSessionClient.test.ts",
|
|
"retries failed worker release through the retained connection before removing its workspace",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"il2cpp-metadata": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/il2cppMetadataCli.test.ts",
|
|
"queries compact retained metadata through the real SDK with exact row identities and fields",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"tests/boundary/il2cpp/il2cppMetadataProvider.test.ts",
|
|
"accepts cancellation between binary linking batches and keeps the metadata source",
|
|
),
|
|
),
|
|
),
|
|
jadx: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"tests/boundary/process/jadxStartup.test.ts",
|
|
"returns terminal startup diagnostics and partial identity through the MCP contract",
|
|
),
|
|
),
|
|
handshake: covered(
|
|
test(
|
|
"tests/boundary/process/jadxIntegration.test.ts",
|
|
"classifies a heap shortage that stops the bridge before the handshake",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/process/jadxIntegration.test.ts",
|
|
"retires an idle engine and starts a fresh one for a later request",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/process/jadxIntegration.test.ts",
|
|
"cancels active and queued requests, cleans ownership and never launches a queued cancelled request",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/process/jadxIntegration.test.ts",
|
|
"retains an uncertain workspace and blocks later launches after cleanup cannot be verified",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/process/jadxStartup.test.ts",
|
|
"retains the startup primary across cleanup failure and retry",
|
|
),
|
|
test(
|
|
"tests/boundary/android/jadxMcpTransport.test.ts",
|
|
"retries an incomplete owned stop while joining concurrent close callers",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
jeb: {
|
|
ownership: "connection",
|
|
stages: {
|
|
launch: ATTACH_ONLY,
|
|
handshake: covered(
|
|
test(
|
|
"tests/boundary/providers/jebMcpCatalog.test.ts",
|
|
"reads every JEB catalog page and refreshes the connected engine catalog",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/jebMcpConnection.test.ts",
|
|
"reconnects after a catalog refresh loses its session without replaying the refresh",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/providers/jebMcpReplies.test.ts",
|
|
"retains own structured fields through the JEB SDK transport",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"src/jeb/JebProvider.test.ts",
|
|
"forwards in-flight cancellation to the MCP call",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/providers/jebMcpConnection.test.ts",
|
|
"retains failed cleanup ownership and does not reuse the invalid session before cleanup succeeds",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/providers/jebMcpConnection.test.ts",
|
|
"retains the typed timeout when disposal fails and retries owned cleanup before reconnecting",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
kuna: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"tests/boundary/providers/kuna/kunaSelectedCommand.test.ts",
|
|
"uses the selected Kuna launcher and its sibling producer for readiness and commands",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/kuna/kunaProvider.test.ts",
|
|
"refuses to launch an executable replaced after the target was opened",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/providers/kuna/kunaIndependentDecompileMcp.test.ts",
|
|
"runs a cold independent request without starting a project export",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/providers/kuna/kunaCommandCancellation.test.ts",
|
|
"keeps cancellation output and primary reason while exact command cleanup is retried",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/kuna/kunaProvider.test.ts",
|
|
"stops waiting for the export when the caller cancels, without abandoning it",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/providers/kuna/kunaPublicationCleanup.test.ts",
|
|
"preserves the original failed export when staging cleanup also fails",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/kuna/kunaProjectCache.test.ts",
|
|
"keeps staging owned when a cancelled Kuna process cannot be proven stopped",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/providers/kuna/kunaProvider.test.ts",
|
|
"keeps reporting a failed close and succeeds once a retry proves the stop",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"mitmproxy-native-tnetstring": historicalCapture(
|
|
gap(
|
|
"The decoder tests bind mitmproxy configuration but no regression completes a mitmproxy capture.",
|
|
),
|
|
),
|
|
"model-artifact": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/modelArtifactCli.test.ts",
|
|
"bounds compact model warnings and omits unselected long labels while retaining complete Evidence",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"tests/boundary/model/modelArtifactPartialCancellation.test.ts",
|
|
"retains GGUF tensor declarations and layout limitations before later tensor bytes cancel",
|
|
),
|
|
),
|
|
),
|
|
"native-macos": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"tests/boundary/providers/native/lldbCallTracerFailures.test.ts",
|
|
"releases a launch failure after the bridge proves the process exited",
|
|
),
|
|
),
|
|
handshake: covered(
|
|
test(
|
|
"tests/boundary/providers/native/lldbLauncherBoundary.test.ts",
|
|
"reports why the host could not establish the launched target's identity",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/providers/native/nativeCallObservation.test.ts",
|
|
"launches the active Mach-O through the tracer and projects its run",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/providers/native/lldbCallTracerFailures.test.ts",
|
|
"preserves cancellation and journal/output evidence after runtime cleanup",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/native/LldbCallTracer.cleanup.test.ts",
|
|
"does not retain a target when cancellation proves LLDB never launched",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/providers/native/LldbCallTracer.cleanup.test.ts",
|
|
"retains an unidentified debuggee and runtime until exit can be confirmed",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/providers/native/LldbCallTracer.cleanup.test.ts",
|
|
"retains a real LLDB process owner and runtime until a later cleanup retry succeeds",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/native/nativeCommandTermination.test.ts",
|
|
"retains and retries every failed native command cleanup owner before launching another command",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"objdump.command": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
REVERSE_LAUNCH_ERRORS,
|
|
"preserves Darwin process ownership inspection preparation error without blaming objdump command",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"tests/composition/objdumpSelectedDisassembly.test.ts",
|
|
"keeps omitted and undefined selection out of default command Evidence",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/composition/reverseEngineeringAdmission.test.ts",
|
|
"preserves the caller reason when cancellation arrives after provider output",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
REVERSE_EDGE_CASES,
|
|
"retains an objdump command's unverified process owner until a later inspection stops it",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
REVERSE_EDGE_CASES,
|
|
"retains an objdump command's unverified process owner until a later inspection stops it",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
pcap: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"tests/boundary/pcap/pcapCommand.test.ts",
|
|
"attributes a refused limiter spawn to the limiter, not Wireshark",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/pcap/pcapProvider.test.ts",
|
|
"inspects a capture with endpoints, DNS, TLS SNI, and HTTP",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/pcap/pcapCommand.test.ts",
|
|
"preserves a failed producer when cancellation arrives during its final cleanup",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/pcap/pcapCommand.test.ts",
|
|
"returns complete stdout while retaining unresolved process cleanup",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/pcap/pcapCredentialErrors.test.ts",
|
|
"retains safe cleanup observations and retries their original owner",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"pwntools-elf": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/native/pwntools/PwntoolsFailures.test.ts",
|
|
"does not read an errno from another syscall as a launch refusal",
|
|
),
|
|
),
|
|
handshake: covered(
|
|
test(
|
|
"tests/process-global/pwntoolsCliFinalization.test.ts",
|
|
"preserves cancellation across a late owned process handshake",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/process-global/pwntoolsCliFinalization.test.ts",
|
|
"recovers a completed worker reply after terminal process cleanup succeeds",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/process-global/pwntoolsCleanup.test.ts",
|
|
"cancels queued inspections promptly and drains the running inspection when closing",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/process-global/pwntoolsCliFinalization.test.ts",
|
|
"preserves the validated report when runtime removal remains denied",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/process-global/pwntoolsCleanup.test.ts",
|
|
"retains a failed root removal and retries it before acquiring another decoder",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"rea-analysis-view": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/applications/progressiveAnalysisViews.test.ts",
|
|
"loads retained analysis views only when needed, preserving complete schemas, source facts and Evidence",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"src/application/analysisView/AnalysisViewService.test.ts",
|
|
"returns typed cancellation when a running file request is aborted",
|
|
),
|
|
),
|
|
),
|
|
"rea-android-application": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/mcp/androidPackageSummaryMcp.test.ts",
|
|
"retains complete APK Evidence and reads exact manifest without its source or another engine launch",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"tests/boundary/mcp/androidPackageSummaryMcp.test.ts",
|
|
"rejects unavailable retention, invalid selectors and cancellation before provider execution",
|
|
),
|
|
),
|
|
),
|
|
"rea-apple-application": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: gap(
|
|
"No regression for an assetutil or Interface Builder tool launch failure.",
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"src/artifacts/apple/AppleAssetCatalogAnalysis.test.ts",
|
|
"joins only explicit resource-key fields with archive provenance",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"src/artifacts/apple/AppleAssetCatalogAnalysis.test.ts",
|
|
"settles a cancelled assetutil run only after its process exits",
|
|
),
|
|
),
|
|
cleanup: gap("No regression for failed assetutil process cleanup."),
|
|
retry: gap("No regression for assetutil cleanup retry."),
|
|
},
|
|
},
|
|
"rea-apple-ips": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/appleIpsJoin.test.ts",
|
|
"joins matching UUID and architecture and derives static addresses",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"src/native/apple/AppleIpsProvider.test.ts",
|
|
"retains completed join facts when cancellation arrives during join parsing",
|
|
),
|
|
),
|
|
),
|
|
"rea-artifact-graph": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"tests/boundary/providers/native/nativeDmgArtifactReader.test.ts",
|
|
"distinguishes child launch and host permission failures",
|
|
),
|
|
),
|
|
handshake: notApplicable(
|
|
"DMG attach and detach are one-shot hdiutil commands; other formats are read in-process.",
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/providers/native/nativeDmgArtifactReader.test.ts",
|
|
"uses plist attachment metadata and detaches returned devices",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/providers/native/artifactProvider.zipCancellation.test.ts",
|
|
"preserves a real ZIP stream's caller cancellation through extraction rollback",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/providers/native/nativeDmgArtifactReader.test.ts",
|
|
"retains the root and reports unknown ownership when recovery discovery fails",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/providers/native/nativeDmgArtifactReader.test.ts",
|
|
"retains a mounted directory after its close fails and retries before detach",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/native/artifactProvider.cleanupRetry.test.ts",
|
|
"retains a failed reader close, blocks new work, and retries the same reader",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"rea-binary-hardening": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/binaryHardeningCli.test.ts",
|
|
"reads ELF and PE hardening through the CLI and MCP",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/binaryHardening.test.ts",
|
|
"returns typed resource and cancellation failures and leaves bytes unchanged",
|
|
),
|
|
),
|
|
),
|
|
"rea-cdp-browser": {
|
|
ownership: "connection",
|
|
stages: {
|
|
launch: ATTACH_ONLY,
|
|
handshake: covered(
|
|
test(
|
|
CDP_BROWSER_SOCKET,
|
|
"times out a WebSocket handshake that never completes",
|
|
),
|
|
test(
|
|
CDP_BROWSER_SOCKET,
|
|
"coalesces concurrent cold-start calls onto one browser WebSocket handshake",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
CDP_BROWSER_SOCKET,
|
|
"reuses one admitted browser socket across sequential operations and closes on provider shutdown",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/browser/cdpBrowserProvider.lifecycle_failures.test.ts",
|
|
"cancels observation and still detaches without closing the page",
|
|
),
|
|
test(
|
|
CDP_CLEANUP_CANCELLATION,
|
|
"releases cleanup when cancellation arrives after capture completes",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
CDP_BROWSER_SOCKET,
|
|
"surfaces cleanupIncomplete when forced shared-socket close fails after detach rejection",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
CDP_BROWSER_SOCKET,
|
|
"records cleanup lease ownership when finish() callback rejects and resolves on retryPending",
|
|
),
|
|
test(
|
|
CDP_BROWSER_SOCKET,
|
|
"blocks new admissions while forced shared-socket cleanup fails with an active peer, then recovers cleanly",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"rea-cdp-electron": {
|
|
ownership: "connection",
|
|
stages: {
|
|
launch: ATTACH_ONLY,
|
|
handshake: gap(
|
|
"No Electron-provider regression for a late, absent or failed CDP handshake.",
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/browser/cdpElectronProvider.test.ts",
|
|
"returns every Electron page target exposed by the endpoint inline",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/browser/cdpElectronProvider.test.ts",
|
|
"retains a completed page observation when cancellation arrives during final detach",
|
|
),
|
|
test(
|
|
CDP_CLEANUP_CANCELLATION,
|
|
"classifies cancellation that arrives during final Electron detach",
|
|
),
|
|
),
|
|
cleanup: gap(
|
|
"No regression retains a failed Electron inspection cleanup; the cleanup tests cover cancellation during a successful close.",
|
|
),
|
|
retry: gap("No regression for Electron inspection cleanup retry."),
|
|
},
|
|
},
|
|
"rea-devicetree": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/devicetreeCli.test.ts",
|
|
"rejects ambiguous Devicetree node paths in correctly hashed Evidence",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"src/application/binaryDiagnostics/DevicetreeService.test.ts",
|
|
"retains a completed observation when the caller cancels as the provider completes",
|
|
),
|
|
),
|
|
),
|
|
"rea-dotnet-static": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/dotnetBundleJourney.test.ts",
|
|
"inspects and extracts ${format} through public CLI and stdio MCP",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"tests/boundary/providers/managed/managedStaticProvider.test.ts",
|
|
"preserves cancellation when snapshot cleanup also fails",
|
|
),
|
|
),
|
|
),
|
|
"rea-dotnet-workflows": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/mcp/managedWorkflowUnknownIdentityMcp.test.ts",
|
|
"retains partial native export coverage after an observed match",
|
|
),
|
|
),
|
|
gap("No cancellation regression for the managed workflow provider."),
|
|
),
|
|
"rea-elf-notes": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/elfNotesCli.test.ts",
|
|
"resolves section note names from zlib and Zstandard string tables through the CLI",
|
|
),
|
|
),
|
|
typedFailures("tests/boundary/filesystem/elfNotes.test.ts"),
|
|
),
|
|
"rea-elf-unwind-ranges": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/elfUnwindRanges.test.ts",
|
|
"accepts a header whose search table is omitted, as GNU ld writes it",
|
|
),
|
|
),
|
|
typedFailures("tests/boundary/filesystem/elfUnwindRanges.test.ts"),
|
|
),
|
|
"rea-erlang-beam": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/erlangBeamCli.test.ts",
|
|
"reports BEAM tables and code through the public CLI",
|
|
),
|
|
),
|
|
typedFailures("tests/boundary/filesystem/erlangBeam.test.ts"),
|
|
),
|
|
"rea-harmony-application": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/harmonyArtifactJourney.test.ts",
|
|
"preserves Harmony archive formats through the public CLI/MCP lifecycle",
|
|
),
|
|
),
|
|
gap("No cancellation regression for the Harmony application provider."),
|
|
),
|
|
"rea-javascript-application": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: gap(
|
|
"No regression for a JavaScript analysis worker process that fails to launch.",
|
|
),
|
|
handshake: gap(
|
|
"No regression for a late or invalid worker admission frame from the provider side.",
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/acceptance/javascriptRoutesCli.test.ts",
|
|
"keeps a large source's partial route facts queryable through SDK delivery",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/filesystem/javascript-applications/javascriptApplicationService.test.ts",
|
|
"keeps unselected files outside scope when the real worker cancels after the last selected file",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"src/javascript/analysis/JavaScriptAnalysisWorker.inspection.test.ts",
|
|
"retains a mixed identity batch's actual descriptor until the same owner retries",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/javascript/analysis/JavaScriptAnalysisWorker.inspection.test.ts",
|
|
"retries the exact failed inspection owner before releasing its error",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"rea-javascript-application-workflows": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/javascriptApplicationWorkflows.test.ts",
|
|
"traces a contextBridge API through IPC into linked native evidence",
|
|
),
|
|
),
|
|
gap("No cancellation regression for JavaScript application workflows."),
|
|
),
|
|
"rea-javascript-runtime-reconciliation": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/javascript-applications/javascriptRuntimeReconciliation.test.ts",
|
|
"matches renderer, frame, script bytes, and worker without claiming execution",
|
|
),
|
|
),
|
|
gap("No cancellation regression for JavaScript runtime reconciliation."),
|
|
),
|
|
"rea-kernel-build-config": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/kernelBuildConfig.test.ts",
|
|
"reports an ordinary IKCFG_ST string as no config with file Evidence",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"src/native/elf/KernelBuildConfig.test.ts",
|
|
"honors an abort raised while the parse is running",
|
|
),
|
|
),
|
|
),
|
|
"rea-kernel-module": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/kernelModuleCli.test.ts",
|
|
"reports license, duplicate aliases, and version CRCs through the public CLI",
|
|
),
|
|
),
|
|
typedFailures("tests/boundary/filesystem/kernelModule.test.ts"),
|
|
),
|
|
"rea-native-exports": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/nativeExports.test.ts",
|
|
"binds PE and ELF export inventories to the selected file",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/nativeExports.test.ts",
|
|
"returns typed input, unsupported, budget and cancellation failures",
|
|
),
|
|
),
|
|
),
|
|
"rea-native-initializers": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/nativeInitializersCli.test.ts",
|
|
"lists Mach-O initializers and finalizers through the public CLI",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"src/native/initializers/NativeInitializersParsers.test.ts",
|
|
"observes cancellation during the section relocation walk",
|
|
),
|
|
),
|
|
),
|
|
"rea-pe-certificates": inProcess(
|
|
gap(
|
|
"Successful certificate tables are covered at the parser and through generated CLI titles, not by a literal-titled provider regression.",
|
|
),
|
|
typedFailures("tests/boundary/filesystem/peCertificates.test.ts"),
|
|
),
|
|
"rea-pe-imports": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/peImports.test.ts",
|
|
"retains partial Evidence for an import name beyond the read allowance",
|
|
),
|
|
),
|
|
typedFailures("tests/boundary/filesystem/peImports.test.ts"),
|
|
),
|
|
"rea-pe-load-config": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/peLoadConfig.test.ts",
|
|
"retains completed PE acquisition through %s",
|
|
),
|
|
),
|
|
typedFailures("tests/boundary/filesystem/peLoadConfig.test.ts"),
|
|
),
|
|
"rea-pe-resources": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/peResources.test.ts",
|
|
"admits the largest measured stock Windows resource table by default",
|
|
),
|
|
),
|
|
typedFailures("tests/boundary/filesystem/peResources.test.ts"),
|
|
),
|
|
"rea-playwright-browser-scenario": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/browser/PlaywrightScenarioBrowser.test.ts",
|
|
"normalizes a genuine Playwright launch timeout and releases its profile",
|
|
),
|
|
test(
|
|
"src/browser/PlaywrightScenarioBrowser.test.ts",
|
|
"passes the selected environment to the actual browser launch boundary",
|
|
),
|
|
),
|
|
handshake: covered(
|
|
test(
|
|
"src/browser/PlaywrightScenarioBrowser.test.ts",
|
|
"applies command_timeout_ms to the primary connect handshake when service workers are allowed",
|
|
),
|
|
test(
|
|
"src/browser/PlaywrightScenarioBrowser.test.ts",
|
|
"closes a browser that connects after its deadline without waiting to report the timeout",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"src/browser/PlaywrightBrowserScenarioProvider.test.ts",
|
|
"returns an initial state and every step of a long scenario",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"src/browser/PlaywrightBrowserScenarioProvider.test.ts",
|
|
"cancels an active action and still closes the session",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"src/browser/PlaywrightBrowserScenarioProvider.test.ts",
|
|
"returns a cleanup failure with completed observations when close fails",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/browser/PlaywrightBrowserScenarioProvider.test.ts",
|
|
"shares concurrent close and retries browser cleanup after failure",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"rea-playwright-electron-active": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/browser/PlaywrightElectronActiveProvider.test.ts",
|
|
"passes the selected environment and ownership token to Electron launch",
|
|
),
|
|
),
|
|
handshake: covered(
|
|
test(
|
|
"src/browser/PlaywrightElectronActiveProvider.test.ts",
|
|
"joins a late launch acknowledgement and its cleanup after shutdown",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"src/browser/PlaywrightElectronActiveActions.test.ts",
|
|
"runs an untargeted deep-link without requiring a BrowserWindow",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"src/browser/PlaywrightElectronActiveProvider.test.ts",
|
|
"cancels a windowless wait action and cleans up the owned application",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"src/browser/PlaywrightElectronActiveProvider.test.ts",
|
|
"keeps cleanup failure precedence over cancellation observed during cleanup",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/browser/PlaywrightElectronActiveProvider.test.ts",
|
|
"retains failed ownership-helper cleanup until provider close retries it",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"rea-python-pyc": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/mcp/pythonPycMcp.test.ts",
|
|
"reads signed TYPE_INT64 constants and rejects a truncated payload",
|
|
),
|
|
),
|
|
typedFailures("tests/boundary/filesystem/pythonPyc.test.ts"),
|
|
),
|
|
"rea-release-exposure": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/releaseExposure.test.ts",
|
|
"audits an ASAR whose unpacked module was signed after packaging",
|
|
),
|
|
),
|
|
typedFailures("tests/boundary/filesystem/releaseExposure.test.ts"),
|
|
),
|
|
"rea-v8-code-cache": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/v8CodeCacheCli.test.ts",
|
|
"reports the observed header and payload through the public CLI",
|
|
),
|
|
),
|
|
gap("No cancellation regression for the V8 code cache provider."),
|
|
),
|
|
"rea-v8-inspector": {
|
|
ownership: "connection",
|
|
stages: {
|
|
launch: ATTACH_ONLY,
|
|
handshake: gap(
|
|
"No regression for a late, absent or failed inspector WebSocket handshake.",
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/acceptance/tools/inspectorLifecycle.test.ts",
|
|
"observes a real Node Inspector and releases attachments after cancellation and failures",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"src/inspector/V8InspectorCaptureProjection.test.ts",
|
|
"stops finalization when cancellation arrives during location authorization",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"src/inspector/V8InspectorProvider.closeOwnership.test.ts",
|
|
"retains cancelled final-close ownership and retries the exact transport before replacement observation",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/inspector/V8InspectorProvider.closeOwnership.test.ts",
|
|
"retains cancelled final-close ownership and retries the exact transport before replacement observation",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"rea-web-module-trace": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/browser/modules/NativeModuleResolver.test.ts",
|
|
"retains the selected executable and actual startup diagnostic",
|
|
),
|
|
),
|
|
handshake: gap(
|
|
"No regression for a late or failed browser-engine connection after Chromium launches.",
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/filesystem/webModuleArtifacts.test.ts",
|
|
"verifies original bytes and tolerates relocation without inventing URL paths",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"src/browser/modules/NativeModuleResolver.test.ts",
|
|
"does not acquire a browser after caller cancellation",
|
|
),
|
|
test(
|
|
"src/application/WebModuleTraceService.test.ts",
|
|
"does not start the native resolver after cancellation during artifact admission",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"src/browser/modules/NativeModuleResolver.test.ts",
|
|
"returns cleanup_incomplete when owned cleanup fails after an engine error",
|
|
),
|
|
),
|
|
retry: gap(
|
|
"The resolver retries retained browser cleanup before later work, but no regression names that retry.",
|
|
),
|
|
},
|
|
},
|
|
"rea-web-script-export": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/javascriptExportShapeComparison.test.ts",
|
|
"preserves accessor-effect uncertainty through analyzed Evidence and export comparison",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"tests/boundary/filesystem/webScriptExport.test.ts",
|
|
"cancels before work and rolls back cancellation after output creation",
|
|
),
|
|
),
|
|
),
|
|
"rea-web-source-location": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
SOURCE_MAP_DECODER_BOUNDARY,
|
|
"removes the private request when launching the codec fails",
|
|
),
|
|
),
|
|
handshake: notApplicable(
|
|
"The source-map codec child writes one reply per request; there is no handshake.",
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/filesystem/webSourceLocationArtifacts.test.ts",
|
|
"reads exact selected map bytes, retaining a BOM and explicitly selected URL context",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
SOURCE_MAP_DECODER_BOUNDARY,
|
|
"cancels a real owned process and removes the runtime request",
|
|
),
|
|
test(
|
|
"src/application/WebSourceLocationService.test.ts",
|
|
"honors cancellation both before acquisition and across decoder completion",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"src/javascript/sourceMaps/SourceMapDecoder.test.ts",
|
|
"settles every source-map cleanup failure when final close releases the exact runtime",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/javascript/sourceMaps/SourceMapDecoder.test.ts",
|
|
"retains physical failure and late cancellation through cleanup failure and retry",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"rea-windows-shortcut": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/acceptance/windowsShortcutCli.test.ts",
|
|
"reports Shell Link facts through CLI and stdio MCP",
|
|
),
|
|
),
|
|
typedFailures("tests/boundary/filesystem/windowsShortcut.test.ts"),
|
|
),
|
|
rizin: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
REVERSE_LAUNCH_ERRORS,
|
|
"preserves provider-launch ENOENT for a real execute_rizin_command target and records launch failure",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"tests/composition/reverseEngineering.test.ts",
|
|
"passes decoder and map inputs to Rizin before the path and records them",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/composition/reverseEngineeringCancellation.test.ts",
|
|
"waits for a cancelled Rizin process to exit before returning",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
REVERSE_EDGE_CASES,
|
|
"retains a capability failure when its injected owned runner also reports incomplete cleanup",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
REVERSE_EDGE_CASES,
|
|
"releases a retained provider owner after cleanup succeeds",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"rizin.debugger": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"tests/boundary/providers/RizinDebugSessionCoverage.part2.test.ts",
|
|
"maps injected spawn errors and startup protocol failure",
|
|
),
|
|
),
|
|
handshake: covered(
|
|
test(
|
|
"tests/boundary/providers/RizinDebugSessionCoverage.part1.test.ts",
|
|
"times out startup through the frame wait when Rizin never emits a frame",
|
|
),
|
|
test(
|
|
"tests/boundary/providers/RizinDebugSessionReviewRegressions.test.ts",
|
|
"rejects startup when Rizin exits immediately after its initial frame",
|
|
),
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/providers/RizinDebugSessionCoverage.part3.test.ts",
|
|
"correlates an injected command frame with its generated marker",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/mcp/rizinDebuggerCancellationMcp.test.ts",
|
|
"propagates MCP cancellation into a running Rizin debugger command",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/providers/RizinDebugSessionCoverage.part1.test.ts",
|
|
"retains owned fixture processes and files until a failed cleanup can complete",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/providers/RizinDebugSessionCoverage.part1.test.ts",
|
|
"retains close failures and resolves their owner after cleanup retry",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"rust-auditable": inProcess(
|
|
covered(
|
|
test(
|
|
"tests/boundary/rust/rustBinaryBudget.test.ts",
|
|
"recovers the same complete Rust image after input and report budget changes",
|
|
),
|
|
),
|
|
covered(
|
|
test(
|
|
"src/application/rust/RustBinaryService.test.ts",
|
|
"retains completed Rust Evidence on late cancellation and keeps output failure precedence",
|
|
),
|
|
),
|
|
),
|
|
"sigrok-recording": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"tests/boundary/signals/resourceLimits.test.ts",
|
|
"preserves lower inherited file/CPU limits in the real launch",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/signals/recordingProvider.test.ts",
|
|
"decodes an immutable copy, preserves options and warnings, and releases its directory",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/signals/recordingProvider.test.ts",
|
|
"retains a completed observation when cancellation arrives at the service boundary",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/signals/recordingProvider.test.ts",
|
|
"retains a completed observation and cleanup ownership for retry",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/signals/recordingProvider.test.ts",
|
|
"releases a retained decoder process cleanup before the next decode completes",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
sqlite: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: gap(
|
|
"No regression for a SQLite worker process that fails to launch.",
|
|
),
|
|
handshake: notApplicable(
|
|
"The SQLite worker writes one reply per request; there is no handshake.",
|
|
),
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/sqlite/sqliteDatabaseProvider.test.ts",
|
|
"enforces a selected worker budget and completes the corrected same-database retry",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/sqlite/sqliteDatabaseDescriptorCleanup.test.ts",
|
|
"retains cancellation diagnostics and the interrupt exit code through CLI shutdown",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/sqlite/sqliteDatabaseCleanup.test.ts",
|
|
"retains the snapshot until a failed worker cleanup owner can be stopped",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/sqlite/sqliteDatabaseCleanup.test.ts",
|
|
"retains failed snapshot owners and blocks new acquisition until retry succeeds",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"tshark-capture": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"tests/boundary/captures/resourceLimits.test.ts",
|
|
"preserves lower inherited file/CPU limits in the real launch",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/captures/captureProvider.test.ts",
|
|
"returns canonical alias output through the public packet-capture CLI",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/captures/captureProvider.test.ts",
|
|
"retains a completed observation when cancellation arrives at the service boundary",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/captures/captureProvider.test.ts",
|
|
"retains a completed observation and cleanup ownership for retry",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/captures/captureProvider.test.ts",
|
|
"releases a retained decoder process cleanup before the next inspection completes",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
unblob: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
FIRMWARE_INTEGRATION,
|
|
"retains startup stderr when Unblob exits 1 without a report",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
FIRMWARE_INTEGRATION,
|
|
"extracts a selected interval with verified file identity and parent-byte lineage",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/process-global/firmwareFileLifetime.test.ts",
|
|
"preserves primitive cancellation before publication commit and rolls back the output",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
FIRMWARE_INTEGRATION,
|
|
"retains the complete firmware result when published output cleanup stays uncertain",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
FIRMWARE_INTEGRATION,
|
|
"retains a setup-failed publication tree for provider cleanup retry",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
"wabt-artifact": {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/wasm/WabtFailures.test.ts",
|
|
"reports a WABT tool the host refused to start as unavailable",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"src/wasm/WabtArtifactProvider.test.ts",
|
|
"admits a compatible caller WABT release and records the observed banner",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"src/wasm/WabtArtifactProvider.test.ts",
|
|
"reports a snapshot write the caller cancelled as that caller's cancellation",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"src/wasm/WabtArtifactProvider.test.ts",
|
|
"bounds the excerpt when cleanup also fails after the output budget",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"src/wasm/WabtArtifactProvider.test.ts",
|
|
"retries a retained input descriptor before admitting the next WABT operation",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
wakaru: {
|
|
ownership: "process",
|
|
stages: {
|
|
launch: covered(
|
|
test(
|
|
"src/javascript/recovery/WakaruCommand.test.ts",
|
|
"preserves a real launch failure when the caller cancels after it",
|
|
),
|
|
),
|
|
handshake: ONE_SHOT,
|
|
operation: covered(
|
|
test(
|
|
"tests/boundary/javascript-recovery/wakaruIntegration.test.ts",
|
|
"preserves selected source identities and layout through a symlink followed by ..",
|
|
),
|
|
),
|
|
cancel: covered(
|
|
test(
|
|
"tests/boundary/javascript-recovery/wakaruIntegration.test.ts",
|
|
"cancels an active recovery and verifies owned cleanup",
|
|
),
|
|
),
|
|
cleanup: covered(
|
|
test(
|
|
"tests/boundary/javascript-recovery/wakaruIntegration.test.ts",
|
|
"reports cleanup failure and retains the workspace named by the error",
|
|
),
|
|
),
|
|
retry: covered(
|
|
test(
|
|
"tests/boundary/javascript-recovery/wakaruIntegration.test.ts",
|
|
"retains a setup-failed publication tree for provider cleanup retry",
|
|
),
|
|
),
|
|
},
|
|
},
|
|
};
|
|
|
|
/**
|
|
* Every stage marked as a gap above, as `providerId:stage`. This list may only
|
|
* shrink: close a gap by naming its regression tests and removing the entry.
|
|
*/
|
|
export const PROVIDER_LIFECYCLE_GAPS: readonly string[] = [
|
|
"aioquic-qlog-json:operation",
|
|
"mitmproxy-native-tnetstring:operation",
|
|
"rea-apple-application:cleanup",
|
|
"rea-apple-application:launch",
|
|
"rea-apple-application:retry",
|
|
"rea-cdp-electron:cleanup",
|
|
"rea-cdp-electron:handshake",
|
|
"rea-cdp-electron:retry",
|
|
"rea-dotnet-workflows:cancel",
|
|
"rea-harmony-application:cancel",
|
|
"rea-javascript-application-workflows:cancel",
|
|
"rea-javascript-application:handshake",
|
|
"rea-javascript-application:launch",
|
|
"rea-javascript-runtime-reconciliation:cancel",
|
|
"rea-pe-certificates:operation",
|
|
"rea-v8-code-cache:cancel",
|
|
"rea-v8-inspector:handshake",
|
|
"rea-web-module-trace:handshake",
|
|
"rea-web-module-trace:retry",
|
|
"sqlite:launch",
|
|
];
|