rea-agents 4.0.1 → 5.0.0

package/dist/cliOutput.js

@@ -1,5 +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")
@@ -8,41 +10,56 @@ 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_) => {
+const parseCliOutputArguments = (arguments_) => {
     let format = "toon";
+    let filterOutput = false;
     let tokenWindow = false;
     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 { filterOutput, format, parseError: true, tokenWindow: false };
                 format = value;
                 index += 1;
             }
             continue;
         }
-        if (argument?.startsWith("--format=")) {
-            format = argument.slice("--format=".length);
+        if (argument === "--filter-output") {
+            if (arguments_[index + 1]) {
+                filterOutput = true;
+                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 { filterOutput, format, parseError: true, tokenWindow: false };
                 tokenWindow = true;
                 index += 1;
             }
             continue;
         }
-        if (argument?.startsWith("--token-limit=") ||
-            argument?.startsWith("--token-offset="))
-            tokenWindow = true;
     }
+    return { filterOutput, format, parseError: false, tokenWindow };
+};
+/** 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 {
@@ -53,6 +70,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 = {
@@ -67,23 +94,21 @@ export const renderCliOutputArgumentError = (error) => {
 export const sanitizeCliOutput = (output) => {
     const trimmed = output.trimStart();
     if (trimmed.startsWith("{")) {
-        try {
-            const parsed = JSON.parse(trimmed);
-            if (!isRecord(parsed))
-                return output;
-            const error = validationError(parsed);
-            if (error !== undefined) {
-                const safeError = {
-                    code: "VALIDATION_ERROR",
-                    message: SAFE_VALIDATION_MESSAGE,
-                };
-                if (error === parsed)
-                    return `${JSON.stringify(safeError)}\n`;
-                return `${JSON.stringify({ ...parsed, error: safeError })}\n`;
-            }
-        }
-        catch {
+        const decoded = safeParseJson(trimmed);
+        if (!decoded.ok)
+            return output;
+        const parsed = decoded.value;
+        if (!isRecord(parsed))
             return output;
+        const error = validationError(parsed);
+        if (error !== undefined) {
+            const safeError = {
+                code: "VALIDATION_ERROR",
+                message: SAFE_VALIDATION_MESSAGE,
+            };
+            if (error === parsed)
+                return `${JSON.stringify(safeError)}\n`;
+            return `${JSON.stringify({ ...parsed, error: safeError })}\n`;
         }
         return output;
     }

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/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/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/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 }));

package/dist/config/environment.js

@@ -1,10 +1,15 @@
 import { z } from "zod";
 import { isAbsolute } from "node:path";
-import { ConfigurationError } from "../domain/errors.js";
+import { ConfigurationError } from "../domain/configurationErrors.js";
 import { err, ok } from "../domain/result.js";
 import { analysisProviderSelectorSchema } from "../contracts/providerSelection.js";
 const environmentSchema = z.object({
     REA_ANALYSIS_PROVIDER: analysisProviderSelectorSchema.default("auto"),
+    REA_IDA_MCP_CONFIG: z
+        .string()
+        .min(1)
+        .refine(isAbsolute, "REA_IDA_MCP_CONFIG must be absolute")
+        .optional(),
     GHIDRA_INSTALL_DIR: z
         .string()
         .min(1)
@@ -15,6 +20,11 @@ const environmentSchema = z.object({
         .min(1)
         .refine(isAbsolute, "JAVA_HOME must be absolute")
         .optional(),
+    REA_GHIDRA_NATIVEAOT_JAR: z
+        .string()
+        .min(1)
+        .refine(isAbsolute, "REA_GHIDRA_NATIVEAOT_JAR must be absolute")
+        .optional(),
     REA_ILSPY_CMD_PATH: z
         .string()
         .min(1)

package/dist/config/parseConfig.js

@@ -1,10 +1,29 @@
-import { ConfigurationError } from "../domain/errors.js";
+import { accessSync, constants } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { ConfigurationError } from "../domain/configurationErrors.js";
 import { ok } from "../domain/result.js";
 import { parseEnvironment } from "./environment.js";
 import { parseStringArray, parseLoaderArgs } from "./parsers.js";
-const defaultHopperLauncherPath = () => process.platform === "linux"
-    ? "/opt/hopper/bin/Hopper"
-    : "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
+const DEFAULT_HOPPER_LAUNCHER_PATH = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
+const SYSTEM_LINUX_HOPPER = "/opt/hopper/bin/Hopper";
+const executableAvailable = (path) => {
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const defaultHopperLauncherPath = (platform = process.platform, homeDirectory = homedir(), executable = executableAvailable) => {
+    if (platform !== "linux")
+        return DEFAULT_HOPPER_LAUNCHER_PATH;
+    if (executable(SYSTEM_LINUX_HOPPER))
+        return SYSTEM_LINUX_HOPPER;
+    const userLocal = join(homeDirectory, ".local/share/rea/hopper/bin/Hopper");
+    return executable(userLocal) ? userLocal : SYSTEM_LINUX_HOPPER;
+};
 /** Parse provider configuration and runtime prerequisites at the composition root. */
 export const parseConfig = (environment) => {
     const parsed = parseEnvironment(environment);
@@ -19,8 +38,14 @@ export const parseConfig = (environment) => {
         return secretPatterns;
     return ok({
         analysisProvider: env.REA_ANALYSIS_PROVIDER,
+        ...(env.REA_IDA_MCP_CONFIG === undefined
+            ? {}
+            : { idaMcpConfigPath: env.REA_IDA_MCP_CONFIG }),
         ghidraInstallDir: env.GHIDRA_INSTALL_DIR,
         ghidraJavaHome: env.JAVA_HOME,
+        ...(env.REA_GHIDRA_NATIVEAOT_JAR === undefined
+            ? {}
+            : { ghidraNativeAotJar: env.REA_GHIDRA_NATIVEAOT_JAR }),
         ilspyCmdPath: env.REA_ILSPY_CMD_PATH,
         hopperLauncherPath: env.HOPPER_LAUNCHER_PATH ?? defaultHopperLauncherPath(),
         hopperTargetPath: env.HOPPER_TARGET_PATH,

package/dist/config/parsers.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ConfigurationError } from "../domain/errors.js";
+import { ConfigurationError } from "../domain/configurationErrors.js";
 import { err, ok } from "../domain/result.js";
 export const parseStringArray = (encoded, name) => {
     try {

package/dist/contracts/android/androidToolContracts.js

@@ -0,0 +1,77 @@
+import { androidInputSchemas, androidResultSchemas, } from "../../domain/android/androidAnalysis.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+import { toolContractMetadata } from "../toolEffects.js";
+/** Static APK operations backed by a separately supplied headless engine. */
+export const ANDROID_TOOL_CONTRACTS = [
+    {
+        name: "inspect_android_package",
+        ...toolContractMetadata("inspect_android_package"),
+        description: "Inspect a local APK's package, SDK and permission declarations, decoded manifest and class/resource counts. Does not execute the APK or verify signatures. Requires a caller-supplied JADX MCP JAR and JDK; uses one worker in an isolated temporary workspace.",
+        kind: "android-provider",
+        inputSchema: androidInputSchemas.inspect_android_package,
+        outputSchema: evidenceResultOf(androidResultSchemas.inspect_android_package),
+        examples: [
+            { title: "Inspect an APK", input: { path: "/tmp/Example.apk" } },
+        ],
+    },
+    {
+        name: "search_android_classes",
+        ...toolContractMetadata("search_android_classes"),
+        description: "Search complete decompiler class names in an explicit local APK by case-sensitive substring. Empty query inventories all classes. Retains artifact and engine identity; no APK execution.",
+        kind: "android-provider",
+        inputSchema: androidInputSchemas.search_android_classes,
+        outputSchema: evidenceResultOf(androidResultSchemas.search_android_classes),
+        examples: [
+            {
+                title: "Find activity classes",
+                input: { path: "/tmp/Example.apk", query: "Activity" },
+            },
+        ],
+    },
+    {
+        name: "inspect_android_class",
+        ...toolContractMetadata("inspect_android_class"),
+        description: "Inspect one exact Android class's parsed methods, fields and inner classes, including synthetic members. Returns display signatures and explicit unknown DEX descriptors without generating source. Overload indices remain consistent within the artifact and engine session.",
+        kind: "android-provider",
+        inputSchema: androidInputSchemas.inspect_android_class,
+        outputSchema: evidenceResultOf(androidResultSchemas.inspect_android_class),
+        examples: [
+            {
+                title: "Inspect a class",
+                input: { path: "/tmp/Example.apk", class_name: "example.MainActivity" },
+            },
+        ],
+    },
+    {
+        name: "inspect_android_method",
+        ...toolContractMetadata("inspect_android_method"),
+        description: "Decompile one Android method with smali fallback. Requires explicit overload_index when multiple methods share a name. Reports representation, fallback markers and source truncation; never treats display signatures as exact DEX identities.",
+        kind: "android-provider",
+        inputSchema: androidInputSchemas.inspect_android_method,
+        outputSchema: evidenceResultOf(androidResultSchemas.inspect_android_method),
+        examples: [
+            {
+                title: "Decompile a method",
+                input: {
+                    path: "/tmp/Example.apk",
+                    class_name: "example.MainActivity",
+                    method_name: "onCreate",
+                },
+            },
+        ],
+    },
+    {
+        name: "trace_android_references",
+        ...toolContractMetadata("trace_android_references"),
+        description: "Trace incoming static references to an exact Android class or unique method. Overloaded method reference queries are explicitly unsupported by the current engine. Source lines and DEX offsets remain unknown; no runtime calls are inferred.",
+        kind: "android-provider",
+        inputSchema: androidInputSchemas.trace_android_references,
+        outputSchema: evidenceResultOf(androidResultSchemas.trace_android_references),
+        examples: [
+            {
+                title: "Find references to a class",
+                input: { path: "/tmp/Example.apk", class_name: "example.MainActivity" },
+            },
+        ],
+    },
+];