rea-agents 4.1.0 → 6.0.0

package/dist/cli/webSourceLocationCommands.js

@@ -0,0 +1,42 @@
+import { z } from "incur";
+import { createWebSourceLocationService } from "../composition/webSourceLocations.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** Expose the same explicit selected map/point contract through the CLI. */
+export const registerWebSourceLocationCommands = (cli, logger, environment) => {
+    const service = createWebSourceLocationService(environment);
+    cli.command(CLI_COMMANDS.traceWebSourceLocation, {
+        description: "Trace one retained script position through an explicitly selected local source map",
+        args: z.object({
+            manifestPath: z
+                .string()
+                .describe("Absolute export_web_scripts manifest path"),
+            scriptIndex: z.coerce
+                .number()
+                .int()
+                .min(0)
+                .describe("Zero-based manifest script index"),
+            sourceMapPath: z.string().describe("Absolute local source-map path"),
+            sourceMapUrl: z
+                .string()
+                .describe("Absolute source-map URL context; no fetch"),
+            line: z.coerce.number().int().min(1).describe("One-based generated line"),
+            column: z.coerce
+                .number()
+                .int()
+                .min(0)
+                .describe("Zero-based UTF-16 generated column"),
+        }),
+        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.traceWebSourceLocation, async () => {
+            const result = await service.trace({
+                manifest_path: args.manifestPath,
+                script_index: args.scriptIndex,
+                source_map: { path: args.sourceMapPath, url: args.sourceMapUrl },
+                generated_position: { line: args.line, column: args.column },
+            }, { signal });
+            return result.ok ? result.value : projectAnalysisError(result.error);
+        })),
+    });
+};

package/dist/cli.js

@@ -1,3 +1,5 @@
+import { registerEvmCommands } from "./cli/evmCommands.js";
+import { registerBinaryDiagnosticsCommands } from "./cli/binaryDiagnosticsCommands.js";
 import { Cli } from "incur";
 import { createLogger, parseLogLevel } from "./logger.js";
 import { PRODUCT_IDENTITY } from "./identity.js";
@@ -11,6 +13,12 @@ import { registerAndroidCommands } from "./cli/androidCommands.js";
 import { registerEvidenceCommands } from "./cliEvidenceCommands.js";
 import { registerProcessCommands } from "./cli/processCommands.js";
 import { registerBrowserCommands } from "./cli/browserCommands.js";
+import { registerWebScriptCommands } from "./cli/webScriptCommands.js";
+import { registerWebModuleCommands } from "./cli/webModuleCommands.js";
+import { registerWebSourceLocationCommands } from "./cli/webSourceLocationCommands.js";
+import { registerWebRuntimeCommands } from "./cli/webRuntimeCommands.js";
+import { registerWebNetworkCaptureCommands } from "./cli/webNetworkCaptureCommands.js";
+import { registerJavaScriptRecoveryCommands } from "./cli/javascriptRecoveryCommands.js";
 import { registerAdvancedBrowserCommands } from "./cli/browserAdvancedCommands.js";
 import { registerBrowserScenarioCommands } from "./cliBrowserScenarioCommands.js";
 import { registerElectronCommands } from "./cli/electronCommands.js";
@@ -21,7 +29,7 @@ import { registerApplicationCommands } from "./cli/applicationCommands.js";
  * Analysis commands acquire and close their own sessions; bare `mcp` and
  * `--mcp` are intercepted by the executable dispatcher before this module loads.
  */
-export const createCli = (environment = process.env) => {
+export const createCli = (environment = process.env, resultOutput) => {
     const logger = createLogger("cli", environment.REA_LOG_LEVEL === undefined
         ? "silent"
         : parseLogLevel(environment.REA_LOG_LEVEL));
@@ -35,18 +43,26 @@ export const createCli = (environment = process.env) => {
         sync: false,
     });
     registerSetupCommands(cli, logger);
-    registerCoreAnalysisCommands(cli, logger);
+    registerCoreAnalysisCommands(cli, logger, resultOutput);
     registerUtilityCommands(cli, logger, environment);
+    registerEvmCommands(cli, logger, environment);
     registerArtifactCommands(cli, logger);
     registerManagedCommands(cli, logger);
     registerAndroidCommands(cli, logger, environment);
     registerFirmwareCommands(cli, logger, environment);
+    registerBinaryDiagnosticsCommands(cli, logger, environment);
     registerEvidenceCommands(cli, logger);
     registerProcessCommands(cli, logger, environment);
     registerBrowserCommands(cli, logger);
+    registerWebScriptCommands(cli, logger);
+    registerWebModuleCommands(cli, logger, environment);
+    registerWebSourceLocationCommands(cli, logger, environment);
+    registerWebRuntimeCommands(cli, logger);
+    registerWebNetworkCaptureCommands(cli, logger, environment);
+    registerJavaScriptRecoveryCommands(cli, logger, environment);
     registerAdvancedBrowserCommands(cli, logger);
     registerBrowserScenarioCommands(cli, logger);
-    registerElectronCommands(cli, logger);
+    registerElectronCommands(cli, logger, resultOutput);
     registerJavaScriptRuntimeObservationCommands(cli, logger);
     registerApplicationCommands(cli, logger);
     return cli;

package/dist/cliBrowserContext.js

@@ -1,7 +1,9 @@
-import { CdpBrowserProvider } from "./browser/CdpBrowserProvider.js";
+import { createBrowserObservationProvider } from "./composition/browserObservation.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 /** Build the passive browser provider; scope is supplied on each request. */
-export const browserContext = () => ({ provider: new CdpBrowserProvider() });
+export const browserContext = () => ({
+    provider: createBrowserObservationProvider(),
+});
 /** Project a browser operation failure consistently across CLI command groups. */
 export const browserCliError = (error) => ({
     error: "Browser observation failed",

package/dist/cliBrowserScenarioCommands.js

@@ -1,12 +1,13 @@
 import { Cli } from "incur";
 import { z } from "zod";
 import { captureBrowserScenario } from "./application/BrowserScenarioCaptureService.js";
-import { PlaywrightBrowserScenarioProvider } from "./browser/PlaywrightBrowserScenarioProvider.js";
+import { createBrowserScenarioProvider } from "./composition/browserScenario.js";
 import { CLI_COMMANDS } from "./cliCommandNames.js";
-import { parseCliJsonInput } from "./cliJsonInput.js";
+import { parseCliJsonInput, resolveCliJsonPaths } from "./cliJsonInput.js";
 import { logCliCommand } from "./cliLogging.js";
 import { AnalysisInputError } from "./domain/analysisErrorCore.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
+import { projectInputIssues } from "./domain/inputIssueProjection.js";
 import { browserScenarioSchema } from "./domain/browserScenario.js";
 const OPERATION = "capture_browser_scenario";
 /** Register the one-shot controlled browser scenario command. */
@@ -22,10 +23,10 @@ export const registerBrowserScenarioCommands = (cli, logger) => {
             const input = await parseCliJsonInput(args.inputJson, OPERATION);
             if (!input.ok)
                 return input.error;
-            const scenario = browserScenarioSchema.safeParse(input.value);
+            const scenario = browserScenarioSchema.safeParse(resolveCliJsonPaths(input.value, [["browser", "executable_path"]]));
             if (!scenario.success)
-                return cliError(new AnalysisInputError(OPERATION));
-            const result = await captureBrowserScenario(new PlaywrightBrowserScenarioProvider(), scenario.data);
+                return cliError(new AnalysisInputError(OPERATION, { cause: scenario.error }, projectInputIssues(scenario.error.issues, input.value)));
+            const result = await captureBrowserScenario(createBrowserScenarioProvider(), scenario.data);
             return result.ok ? result.value : cliError(result.error);
         }),
     });

package/dist/cliCommandNames.js

@@ -1,5 +1,11 @@
 /** Canonical names used by every one-shot CLI command registration. */
 export const CLI_COMMANDS = Object.freeze({
+    inspectEvmInterface: "inspect-evm-interface",
+    inspectWebNetworkCapture: "inspect-web-network-capture",
+    observeWebExecution: "observe-web-execution",
+    inspectWebEventListeners: "inspect-web-event-listeners",
+    traceWebSourceLocation: "trace-web-source-location",
+    traceWebModuleImports: "trace-web-module-imports",
     analyze: "analyze",
     inspect: "inspect",
     decompile: "decompile",
@@ -23,6 +29,7 @@ export const CLI_COMMANDS = Object.freeze({
     extractArtifact: "extract-artifact",
     decodeInterfaceBuilder: "decode-interface-builder",
     inspectKeyedArchive: "inspect-keyed-archive",
+    traceDylibResolution: "trace-dylib-resolution",
     inspectNativeDataType: "inspect-native-data-type",
     inspectNativeLoadImage: "inspect-native-load-image",
     readBytes: "read-bytes",
@@ -32,6 +39,8 @@ export const CLI_COMMANDS = Object.freeze({
     resolveNativeCallTargets: "resolve-native-call-targets",
     inspectAssetCatalog: "inspect-asset-catalog",
     inspectManagedArtifact: "inspect-managed-artifact",
+    inspectRecordedCrash: "inspect-recorded-crash",
+    inspectBinaryLayout: "inspect-binary-layout",
     inspectFirmwareRegions: "inspect-firmware-regions",
     extractFirmware: "extract-firmware",
     inspectAndroidPackage: "inspect-android-package",
@@ -46,6 +55,7 @@ export const CLI_COMMANDS = Object.freeze({
     importManagedReconstruction: "import-managed-reconstruction",
     projectManagedApplicationGraph: "project-managed-application-graph",
     observeNativeUi: "observe-native-ui",
+    observeNativeCalls: "observe-native-calls",
     captureNativeUiScenario: "capture-native-ui-scenario",
     inspectMacho: "inspect-macho",
     inspectSignature: "inspect-signature",
@@ -60,6 +70,8 @@ export const CLI_COMMANDS = Object.freeze({
     listBrowserTargets: "list-browser-targets",
     inspectWebPage: "inspect-web-page",
     analyzeWebBundle: "analyze-web-bundle",
+    exportWebScripts: "export-web-scripts",
+    recoverJavaScriptSources: "recover-javascript-sources",
     observeWebSession: "observe-web-session",
     discoverWebMcpTools: "discover-webmcp-tools",
     compareWebCaptures: "compare-web-captures",
@@ -80,6 +92,8 @@ export const CLI_COMMANDS = Object.freeze({
     compareJavaScriptExportShapes: "compare-javascript-export-shapes",
     buildReconstructionObligationLedger: "build-reconstruction-obligation-ledger",
     evaluateReconstructionCoverage: "evaluate-reconstruction-coverage",
+    projectAndroidApplicationGraph: "project-android-application-graph",
+    projectAppleApplicationGraph: "project-apple-application-graph",
 });
 /** Ordered primary CLI inventory; aliases are intentionally excluded. */
 export const CLI_COMMAND_NAMES = Object.freeze(Object.values(CLI_COMMANDS));

package/dist/cliJavaScriptRuntimeCommands.js

@@ -1,9 +1,9 @@
 import { Cli, z } from "incur";
-import { listJavaScriptRuntimeTargets, observeJavaScriptRuntime, } from "./application/JavaScriptRuntimeObservationService.js";
-import { V8InspectorProvider } from "./browser/V8InspectorProvider.js";
+import { listJavaScriptRuntimeTargets, observeJavaScriptRuntime, } from "./application/javascript/JavaScriptRuntimeObservationService.js";
+import { createJavaScriptRuntimeObservationProvider } from "./composition/javascriptRuntimeObservation.js";
 import { CLI_COMMANDS } from "./cliCommandNames.js";
 import { logCliCommand } from "./cliLogging.js";
-import { javascriptRuntimeKindSchema, listJavaScriptRuntimeTargetsInputSchema, observeJavaScriptRuntimeInputSchema, } from "./domain/javascriptRuntimeObservation.js";
+import { javascriptRuntimeKindSchema, listJavaScriptRuntimeTargetsInputSchema, observeJavaScriptRuntimeInputSchema, } from "./domain/javascript/javascriptRuntimeObservation.js";
 import { AnalysisInputError } from "./domain/analysisErrorCore.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 const observeOptionsSchema = z.object({
@@ -59,7 +59,9 @@ export const registerJavaScriptRuntimeObservationCommands = (cli, logger) => {
         }),
     });
 };
-const runtimeContext = () => ({ provider: new V8InspectorProvider() });
+const runtimeContext = () => ({
+    provider: createJavaScriptRuntimeObservationProvider(),
+});
 const inputError = (operation) => cliError(new AnalysisInputError(operation));
 const cliError = (error) => ({
     error: "JavaScript runtime observation failed",

package/dist/cliJsonInput.js

@@ -1,4 +1,5 @@
 import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
 import { AnalysisInputError } from "./domain/analysisErrorCore.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 import { safeParseJson } from "./domain/safeJson.js";
@@ -7,8 +8,6 @@ export const parseCliJsonInput = async (value, operation) => {
     const inline = parseJson(value);
     if (inline !== undefined)
         return { ok: true, value: inline };
-    if (["{", "["].includes(value.trimStart()[0] ?? ""))
-        return { ok: false, error: inputError(operation) };
     try {
         // Read raw bytes so invalid UTF-8 is rejected by parseJson instead of
         // being silently replaced by lossy "utf8" decoding.
@@ -18,9 +17,46 @@ export const parseCliJsonInput = async (value, operation) => {
             : { ok: true, value: parsed };
     }
     catch (cause) {
+        if (["{", "["].includes(value.trimStart()[0] ?? "") &&
+            cannotBeAnExistingFile(cause) &&
+            !hasExplicitJsonFileExtension(value))
+            return { ok: false, error: inputError(operation) };
         return jsonFileError(value, operation, "read-failed", cause);
     }
 };
+/**
+ * Resolve named string fields of CLI-supplied JSON against the operator
+ * working directory. Each entry is a key path from the document root; only
+ * fields holding strings are resolved, everything else passes through
+ * untouched. Shared MCP contracts reject relative paths, so CLI workflows
+ * resolve operator-relative values before validation.
+ */
+export const resolveCliJsonPaths = (value, paths) => {
+    let resolved = value;
+    for (const keys of paths)
+        resolved = resolveJsonPath(resolved, keys);
+    return resolved;
+};
+const resolveJsonPath = (value, keys) => {
+    const [head, ...tail] = keys;
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return value;
+    const entries = Object.entries(value).map(([key, entry]) => {
+        if (key !== head)
+            return [key, entry];
+        if (tail.length === 0)
+            return [key, typeof entry === "string" ? resolve(entry) : entry];
+        return [key, resolveJsonPath(entry, tail)];
+    });
+    return Object.fromEntries(entries);
+};
+const cannotBeAnExistingFile = (cause) => typeof cause === "object" &&
+    cause !== null &&
+    "code" in cause &&
+    (cause.code === "ENOENT" ||
+        cause.code === "ENAMETOOLONG" ||
+        cause.code === "ENOTDIR");
+const hasExplicitJsonFileExtension = (value) => value.toLowerCase().endsWith(".json");
 const parseJson = (value) => {
     let text;
     if (typeof value === "string") {

package/dist/cliOutput.js

@@ -1,6 +1,7 @@
 import { safeParseJson } from "./domain/safeJson.js";
 const SAFE_VALIDATION_MESSAGE = "REA could not read the command arguments. Run `rea --help`, correct the arguments, then try again.";
 const UNSUPPORTED_OUTPUT_COMBINATION_MESSAGE = "Token windows cannot preserve structured output. Remove --token-limit/--token-offset and use --filter-output or command pagination.";
+const INCUR_OUTPUT_FORMATS = new Set(["toon", "json", "yaml", "md", "jsonl"]);
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const validationError = (value) => {
     if (value.code === "VALIDATION_ERROR")
@@ -9,41 +10,71 @@ const validationError = (value) => {
         return value.error.code === "VALIDATION_ERROR" ? value.error : undefined;
     return undefined;
 };
-/** Reject text-window controls that would corrupt a structured document. */
-export const validateCliOutputArguments = (arguments_) => {
+/** Read effective Incur output controls at the executable boundary. */
+export const parseCliOutputArguments = (arguments_) => {
     let format = "toon";
+    let filterOutput;
+    let fullOutput = false;
+    let tokenCount = false;
     let tokenWindow = false;
+    const parsed = (parseError) => ({
+        filterOutput,
+        format,
+        fullOutput,
+        parseError,
+        tokenCount,
+        tokenWindow: parseError ? false : tokenWindow,
+    });
     for (let index = 0; index < arguments_.length; index += 1) {
         const argument = arguments_[index];
-        if (argument === "--")
-            break;
+        // Incur scans builtins across `--` and accepts only spaced value forms.
+        // Mirror those effective values at the executable output boundary.
         if (argument === "--json") {
             format = "json";
             continue;
         }
         if (argument === "--format") {
             const value = arguments_[index + 1];
-            if (value !== undefined) {
+            if (value) {
+                // Incur stops parsing at an invalid format before applying any later
+                // output controls. Let it report that malformed flag itself.
+                if (!INCUR_OUTPUT_FORMATS.has(value))
+                    return parsed(true);
                 format = value;
                 index += 1;
             }
             continue;
         }
-        if (argument?.startsWith("--format=")) {
-            format = argument.slice("--format=".length);
+        if (argument === "--filter-output") {
+            if (arguments_[index + 1]) {
+                filterOutput = arguments_[index + 1];
+                index += 1;
+            }
             continue;
         }
         if (argument === "--token-limit" || argument === "--token-offset") {
-            if (arguments_[index + 1] !== undefined) {
+            const value = arguments_[index + 1];
+            if (value) {
+                const numericValue = Number(value);
+                if (!Number.isFinite(numericValue) || value.trim() === "")
+                    return parsed(true);
                 tokenWindow = true;
                 index += 1;
             }
             continue;
         }
-        if (argument?.startsWith("--token-limit=") ||
-            argument?.startsWith("--token-offset="))
-            tokenWindow = true;
+        if (argument === "--full-output")
+            fullOutput = true;
+        if (argument === "--token-count")
+            tokenCount = true;
     }
+    return parsed(false);
+};
+/** Reject text-window controls that would corrupt a structured document. */
+export const validateCliOutputArguments = (arguments_) => {
+    const { format, parseError, tokenWindow } = parseCliOutputArguments(arguments_);
+    if (parseError)
+        return { ok: true };
     if (tokenWindow &&
         (format === "json" || format === "jsonl" || format === "yaml"))
         return {
@@ -54,6 +85,16 @@ export const validateCliOutputArguments = (arguments_) => {
         };
     return { ok: true };
 };
+/** Preserve a complete document when Incur filters the entire result away. */
+export const renderEmptyFilteredCliOutput = (arguments_) => {
+    const { filterOutput, format, parseError } = parseCliOutputArguments(arguments_);
+    if (parseError)
+        return undefined;
+    if (filterOutput &&
+        (format === "json" || format === "jsonl" || format === "yaml"))
+        return "{}\n";
+    return undefined;
+};
 /** Render one complete structured error before command execution. */
 export const renderCliOutputArgumentError = (error) => {
     const value = {

package/dist/composition/android.js

@@ -0,0 +1,3 @@
+import { JadxProvider } from "../android/JadxProvider.js";
+/** Construct one APK provider with its own queue and cleanup-failure state. */
+export const createAndroidAnalysisProvider = (environment = process.env, launcher) => new JadxProvider(environment, launcher);

package/dist/composition/auxiliaryAnalysisProviders.js

@@ -0,0 +1,30 @@
+import { ARTIFACT_PROVIDER_IDENTITY, artifactCapabilities, } from "../artifacts/ArtifactProviderMetadata.js";
+import { MANAGED_STATIC_PROVIDER_IDENTITY, managedStaticCapabilities, } from "../dotnet/ManagedStaticProviderMetadata.js";
+import { NATIVE_MACOS_PROVIDER_IDENTITY, nativeMacOSCapabilities, } from "../native/NativeMacOSProviderMetadata.js";
+/** Wire the three existing auxiliary AnalysisProvider implementations lazily. */
+export const auxiliaryAnalysisProviderDeclarations = (platform = process.platform) => [
+    {
+        identity: ARTIFACT_PROVIDER_IDENTITY,
+        capabilities: artifactCapabilities(platform),
+        load: async () => {
+            const { ArtifactProvider } = await import("../artifacts/ArtifactProvider.js");
+            return new ArtifactProvider(platform);
+        },
+    },
+    {
+        identity: NATIVE_MACOS_PROVIDER_IDENTITY,
+        capabilities: nativeMacOSCapabilities(platform),
+        load: async () => {
+            const { NativeMacOSProvider } = await import("../native/NativeMacOSProvider.js");
+            return new NativeMacOSProvider(undefined, platform);
+        },
+    },
+    {
+        identity: MANAGED_STATIC_PROVIDER_IDENTITY,
+        capabilities: managedStaticCapabilities(),
+        load: async () => {
+            const { ManagedStaticProvider } = await import("../dotnet/ManagedStaticProvider.js");
+            return new ManagedStaticProvider();
+        },
+    },
+];

package/dist/composition/binary.js

@@ -0,0 +1,25 @@
+import { HopperProvider } from "../hopper/HopperProvider.js";
+import { GhidraProvider } from "../ghidra/GhidraProvider.js";
+import { IdaProvider } from "../ida/IdaProvider.js";
+import { silentLogger } from "../logger.js";
+import { auxiliaryAnalysisProviderDeclarations } from "./auxiliaryAnalysisProviders.js";
+import { AnalysisProviderRegistry } from "../application/binary/AnalysisProviderRegistry.js";
+import { composeBinarySession } from "../application/binary/BinarySessionComposition.js";
+import { LazyAnalysisProvider } from "../application/binary/LazyAnalysisProvider.js";
+import { ManagedStaticProvider } from "../dotnet/ManagedStaticProvider.js";
+import { SessionProviderRouter } from "../application/binary/SessionProviderRouter.js";
+/**
+ * Compose the target-switching runtime shared directly by CLI and MCP adapters.
+ * This is the sole production wiring point, so both adapters share identical
+ * provider selection, profile, lifecycle, and Evidence semantics.
+ */
+export const createBinarySession = (config, logger = silentLogger) => {
+    const hopper = new HopperProvider(config, logger);
+    const ghidra = new GhidraProvider(config, logger);
+    const ida = new IdaProvider(config);
+    return composeBinarySession(new AnalysisProviderRegistry([hopper, ghidra, ida], config.analysisProvider), auxiliaryAnalysisProviderDeclarations().map((declaration) => new LazyAnalysisProvider(declaration)));
+};
+/** Compose an execution-free managed session without native provider selection. */
+export const createManagedBinarySession = () => composeBinarySession(SessionProviderRouter.selectable(new AnalysisProviderRegistry([]), [
+    new ManagedStaticProvider(),
+]));

package/dist/composition/binaryDiagnostics.js

@@ -0,0 +1,8 @@
+import { RecordedCrashService } from "../application/binaryDiagnostics/RecordedCrashService.js";
+import { PwntoolsRecordedCrashProvider } from "../native/pwntools/PwntoolsRecordedCrashProvider.js";
+import { BinaryLayoutService } from "../application/binaryDiagnostics/BinaryLayoutService.js";
+import { PwntoolsLayoutProvider } from "../native/pwntools/PwntoolsLayoutProvider.js";
+/** Compose the offline adapter without import-time I/O or dependency acquisition. */
+export const createBinaryLayoutService = (environment = process.env) => new BinaryLayoutService(new PwntoolsLayoutProvider(environment));
+/** Compose recorded-core inspection without acquiring a debugger or toolchain. */
+export const createRecordedCrashService = (environment = process.env) => new RecordedCrashService(new PwntoolsRecordedCrashProvider(environment));

package/dist/composition/browserObservation.js

@@ -0,0 +1,3 @@
+import { CdpBrowserProvider } from "../browser/CdpBrowserProvider.js";
+/** Construct a fresh provider without opening a target or acquiring an engine. */
+export const createBrowserObservationProvider = () => new CdpBrowserProvider();

package/dist/composition/browserScenario.js

@@ -0,0 +1,3 @@
+import { PlaywrightBrowserScenarioProvider } from "../browser/PlaywrightBrowserScenarioProvider.js";
+/** Construct a fresh provider without opening a target or acquiring an engine. */
+export const createBrowserScenarioProvider = () => new PlaywrightBrowserScenarioProvider();

package/dist/composition/directAnalysis.js

@@ -0,0 +1,17 @@
+import { runDirectAnalysis as executeDirectAnalysis, runProviderAnalysis as executeProviderAnalysis, runManagedProviderExecution as executeManagedProvider, } from "../application/DirectAnalysis.js";
+import { runCapabilityStatus as executeCapabilityStatus, runProviderStatus as executeProviderStatus, } from "../application/DirectAnalysisStatus.js";
+import { createBinarySession, createManagedBinarySession } from "./binary.js";
+const dependencies = {
+    createBinarySession,
+    createManagedBinarySession,
+};
+/** Run one isolated binary operation through the production session factory. */
+export const runDirectAnalysis = executeDirectAnalysis.bind(undefined, dependencies);
+/** Run one isolated native, artifact or managed operation. */
+export const runProviderAnalysis = executeProviderAnalysis.bind(undefined, dependencies);
+/** Execute managed metadata without constructing native provider candidates. */
+export const runManagedProviderExecution = executeManagedProvider.bind(undefined, dependencies);
+/** Report production provider candidates without opening a target. */
+export const runProviderStatus = executeProviderStatus.bind(undefined, dependencies);
+/** Report production session operations without opening a target. */
+export const runCapabilityStatus = executeCapabilityStatus.bind(undefined, dependencies);

package/dist/composition/electronObservation.js

@@ -0,0 +1,3 @@
+import { CdpElectronProvider } from "../browser/CdpElectronProvider.js";
+/** Construct a fresh provider without opening a target or acquiring an engine. */
+export const createElectronObservationProvider = () => new CdpElectronProvider();

package/dist/composition/electronScenario.js

@@ -0,0 +1,3 @@
+import { PlaywrightElectronActiveProvider } from "../browser/PlaywrightElectronActiveProvider.js";
+/** Construct a fresh provider without opening a target or acquiring an engine. */
+export const createElectronScenarioProvider = () => new PlaywrightElectronActiveProvider();

package/dist/composition/evm.js

@@ -0,0 +1,4 @@
+import { EvmInterfaceService } from "../application/evm/EvmInterfaceService.js";
+import { EvmoleInterfaceProvider } from "../evm/EvmoleInterfaceProvider.js";
+/** Compose offline interface analysis without import-time I/O or dependency acquisition. */
+export const createEvmInterfaceService = (environment = process.env) => new EvmInterfaceService(new EvmoleInterfaceProvider(environment));

package/dist/composition/firmware.js

@@ -0,0 +1,3 @@
+import { FirmwareProvider } from "../firmware/FirmwareProvider.js";
+/** Construct one firmware provider without launching or acquiring an engine. */
+export const createFirmwareAnalysisProvider = (environment = process.env, launcher) => new FirmwareProvider(environment, launcher);

package/dist/composition/javascriptRecovery.js

@@ -0,0 +1,3 @@
+import { WakaruProvider } from "../javascript/recovery/WakaruProvider.js";
+/** Construct optional recovery without acquiring tools, processes or workspaces. */
+export const createJavaScriptRecoveryProvider = (environment = process.env, launcher) => new WakaruProvider(environment, launcher);

package/dist/composition/javascriptRuntimeObservation.js

@@ -0,0 +1,3 @@
+import { V8InspectorProvider } from "../inspector/V8InspectorProvider.js";
+/** Construct a fresh provider without opening a target or acquiring an engine. */
+export const createJavaScriptRuntimeObservationProvider = () => new V8InspectorProvider();

package/dist/composition/optionalObservationProviders.js

@@ -0,0 +1,49 @@
+import { CDP_BROWSER_PROVIDER_IDENTITY, PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY, CDP_ELECTRON_PROVIDER_IDENTITY, PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY, } from "../browser/providerIdentities.js";
+import { V8_INSPECTOR_PROVIDER_IDENTITY } from "../inspector/providerIdentity.js";
+import { err, ok } from "../domain/result.js";
+const productionFactories = {
+    browserObservation: async () => (await import("./browserObservation.js")).createBrowserObservationProvider(),
+    browserScenarioCapture: async () => (await import("./browserScenario.js")).createBrowserScenarioProvider(),
+    electronObservation: async () => (await import("./electronObservation.js")).createElectronObservationProvider(),
+    electronActiveObservation: async () => (await import("./electronScenario.js")).createElectronScenarioProvider(),
+    javascriptRuntimeObservation: async () => (await import("./javascriptRuntimeObservation.js")).createJavaScriptRuntimeObservationProvider(),
+};
+const loadPort = async (factory, providerId) => {
+    try {
+        return ok(await factory());
+    }
+    catch (cause) {
+        return err({
+            providerId,
+            reason: cause instanceof Error ? cause.message : String(cause),
+        });
+    }
+};
+/** Load each adapter independently, retaining healthy peers and exact failures. */
+export const loadOptionalObservationProviders = async (factories = productionFactories) => {
+    const [browser, scenario, electron, electronActive, runtime] = await Promise.all([
+        loadPort(factories.browserObservation, CDP_BROWSER_PROVIDER_IDENTITY.id),
+        loadPort(factories.browserScenarioCapture, PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY.id),
+        loadPort(factories.electronObservation, CDP_ELECTRON_PROVIDER_IDENTITY.id),
+        loadPort(factories.electronActiveObservation, PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY.id),
+        loadPort(factories.javascriptRuntimeObservation, V8_INSPECTOR_PROVIDER_IDENTITY.id),
+    ]);
+    return {
+        ...(browser.ok ? { browserObservation: browser.value } : {}),
+        ...(scenario.ok ? { browserScenarioCapture: scenario.value } : {}),
+        ...(electron.ok ? { electronObservation: electron.value } : {}),
+        ...(electronActive.ok
+            ? { electronActiveObservation: electronActive.value }
+            : {}),
+        ...(runtime.ok ? { javascriptRuntimeObservation: runtime.value } : {}),
+        optionalProviderLoadFailures: {
+            ...(browser.ok ? {} : { browserObservation: browser.error }),
+            ...(scenario.ok ? {} : { browserScenarioCapture: scenario.error }),
+            ...(electron.ok ? {} : { electronObservation: electron.error }),
+            ...(electronActive.ok
+                ? {}
+                : { electronActiveObservation: electronActive.error }),
+            ...(runtime.ok ? {} : { javascriptRuntimeObservation: runtime.error }),
+        },
+    };
+};

package/dist/composition/webModules.js

@@ -0,0 +1,5 @@
+import { WebModuleTraceService } from "../application/WebModuleTraceService.js";
+import { LocalWebModuleArtifacts } from "../browser/modules/WebModuleArtifacts.js";
+import { NativeModuleResolver } from "../browser/modules/NativeModuleResolver.js";
+/** Assemble optional module tracing without acquiring a browser or reading files. */
+export const createWebModuleTraceService = (environment = process.env) => new WebModuleTraceService(new LocalWebModuleArtifacts(), new NativeModuleResolver(environment));

package/dist/composition/webNetworkCaptures.js

@@ -0,0 +1,6 @@
+import { WebNetworkCaptureService } from "../application/WebNetworkCaptureService.js";
+import { HistoricalCaptureDecoder } from "../browser/history/HistoricalCaptureDecoder.js";
+import { HarCaptureAdapter } from "../browser/history/HarCaptureAdapter.js";
+import { MitmproxyCaptureAdapter } from "../browser/history/MitmproxyCaptureAdapter.js";
+/** Compose offline format adapters without import-time reads, installation or process startup. */
+export const createWebNetworkCaptureService = (environment = process.env) => new WebNetworkCaptureService(new HistoricalCaptureDecoder([new HarCaptureAdapter(), new MitmproxyCaptureAdapter(environment)], environment));

package/dist/composition/webRuntime.js

@@ -0,0 +1,4 @@
+import { WebRuntimeService } from "../application/WebRuntimeService.js";
+import { CdpWebRuntimeProvider } from "../browser/execution/CdpWebRuntimeProvider.js";
+/** Construct the live attribution workflow without opening a browser connection. */
+export const createWebRuntimeService = () => new WebRuntimeService(new CdpWebRuntimeProvider());

package/dist/composition/webSourceLocations.js

@@ -0,0 +1,5 @@
+import { WebSourceLocationService } from "../application/WebSourceLocationService.js";
+import { LocalWebSourceLocationArtifacts } from "../browser/assets/WebSourceLocationArtifacts.js";
+import { SourceMapDecoder } from "../javascript/sourceMaps/SourceMapDecoder.js";
+/** Compose local source/map analysis without import-time reads or process acquisition. */
+export const createWebSourceLocationService = (environment = process.env) => new WebSourceLocationService(new LocalWebSourceLocationArtifacts(), new SourceMapDecoder({ environment }));