rea-agents 4.0.1 → 5.0.0

package/dist/contracts/toolOutputSchemaGroups.js

@@ -1,25 +1,27 @@
 import { z } from "zod";
-import { nativeUiResultSchema } from "../domain/nativeUiObservation.js";
-import { nativeValueTraceSchema } from "../domain/nativeValueTrace.js";
-import { nativeDataTypeSchema } from "../domain/nativeDataType.js";
-import { nativeInstructionSchema, nativeCallTargetsSchema, } from "../domain/nativeInstruction.js";
+import { nativeFunctionAnnotationsSchema } from "../domain/native/nativeFunctionAnnotations.js";
+import { nativeLoadImageSchema } from "../domain/native/nativeLoadImage.js";
+import { nativeUiResultSchema } from "../domain/native/nativeUiObservation.js";
+import { nativeValueTraceSchema } from "../domain/native/nativeValueTrace.js";
+import { nativeDataTypeSchema } from "../domain/native/nativeDataType.js";
+import { nativeInstructionSchema, nativeCallTargetsSchema, } from "../domain/native/nativeInstruction.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { residualUnknownSchema } from "../domain/residualUnknown.js";
 import { evidenceBundleSchema } from "../domain/evidenceBundle.js";
 import { processCaptureComparisonSchema, processCaptureSchema, } from "../domain/processCapture.js";
 import { functionInstructionWindowSchema, referenceKindSchema, } from "../domain/hopperValues.js";
-import { nativeApiInspectionResultSchema } from "../domain/nativeApiBoundary.js";
-import { demangleSwiftSchema, inspectMachoSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, } from "../domain/nativeInspection.js";
+import { nativeApiInspectionResultSchema } from "../domain/native/nativeApiBoundary.js";
+import { demangleSwiftSchema, inspectMachoSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, } from "../domain/native/nativeInspection.js";
 import { artifactExtractionResultSchema } from "../domain/artifactGraph.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
-import { interfaceBuilderAnalysisSchema } from "../domain/interfaceBuilderGraph.js";
-import { keyedArchiveResultSchema } from "../domain/keyedArchive.js";
-import { appleAssetCatalogResultSchema } from "../domain/appleAssetCatalog.js";
-import { managedArtifactInspectionSchema, managedMemberInspectionSchema, managedNativeBoundaryInspectionSchema, } from "../domain/managedArtifact.js";
-import { managedMemberComparisonResultSchema } from "../domain/managedMemberComparison.js";
-import { managedNativeVerificationResultSchema } from "../domain/managedNativeVerification.js";
-import { managedReconstructionImportResultSchema } from "../domain/managedReconstruction.js";
-import { managedApplicationGraphResultSchema } from "../domain/managedApplicationGraph.js";
+import { interfaceBuilderAnalysisSchema } from "../domain/apple/interfaceBuilderGraph.js";
+import { keyedArchiveResultSchema } from "../domain/apple/keyedArchive.js";
+import { appleAssetCatalogResultSchema } from "../domain/apple/appleAssetCatalog.js";
+import { managedArtifactInspectionSchema, managedMemberInspectionSchema, managedNativeBoundaryInspectionSchema, } from "../domain/managed/managedArtifact.js";
+import { managedMemberComparisonResultSchema } from "../domain/managed/managedMemberComparison.js";
+import { managedNativeVerificationResultSchema } from "../domain/managed/managedNativeVerification.js";
+import { managedReconstructionImportResultSchema } from "../domain/managed/managedReconstruction.js";
+import { managedApplicationGraphResultSchema } from "../domain/managed/managedApplicationGraph.js";
 import { artifactComparisonResultSchema } from "../domain/artifactComparison.js";
 import { functionComparisonResultSchema } from "../domain/functionComparison.js";
 import { bundleComparisonResultSchema } from "../domain/bundleComparison.js";
@@ -28,8 +30,8 @@ import { callPathResultSchema } from "../domain/callPath.js";
 import { staticRuntimeCorrelationResultSchema } from "../domain/staticRuntimeCorrelation.js";
 import { reconstructionVerificationResultSchema } from "../domain/reconstructionVerification.js";
 import { analysisErrorProjectionSchema } from "./errorSchemas.js";
-import { nativeDispatchMetadataResultSchema } from "../domain/objcSwiftMetadata.js";
-import { nativeInvestigationTraceSchema } from "../domain/nativeInvestigationGraph.js";
+import { nativeDispatchMetadataResultSchema } from "../domain/native/objcSwiftMetadata.js";
+import { nativeInvestigationTraceSchema } from "../domain/native/nativeInvestigationGraph.js";
 import { addressList, addressedValue, addressedEntry, containingProcedureResolution, functionDossierOutput, graphNode, lifecycleResultOf, nullableText, procedureIdentity, procedureInfoOutput, evidenceResultOf as resultOf, segmentOutput, sessionProvider, symbolDiscoveryOutput, targetFormatSchema, targetKindSchema, } from "./toolOutputSchemaPrimitives.js";
 const contextFacetSchema = z.discriminatedUnion("state", [
     z.object({ state: z.literal("available"), value: jsonValueSchema }),
@@ -60,6 +62,8 @@ const addressedString = z.object({
 });
 /** Exact structured-content schemas shared by direct analysis providers. */
 export const officialOutputSchemas = {
+    annotate_native_function: resultOf(nativeFunctionAnnotationsSchema),
+    inspect_native_load_image: resultOf(nativeLoadImageSchema),
     inspect_native_data_type: resultOf(nativeDataTypeSchema),
     inspect_native_instruction: resultOf(nativeInstructionSchema),
     resolve_native_call_targets: resultOf(nativeCallTargetsSchema),

package/dist/contracts/toolOutputSchemaPrimitives.js

@@ -29,6 +29,7 @@ export const targetFormatSchema = z.enum([
     "elf",
     "pe",
     "dos-mz",
+    "dos-com",
     "zip",
     "ipa",
     "apk",

package/dist/contracts/webRuntimeToolContracts.js

@@ -0,0 +1,43 @@
+import { toolContractMetadata } from "./toolEffects.js";
+import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { observeWebExecutionInputSchema, webExecutionSchema, } from "../domain/webExecution.js";
+import { inspectWebEventListenersInputSchema, webEventListenersSchema, } from "../domain/webEventListeners.js";
+/** Native website runtime primitives distinguish instrumentation from listener inspection. */
+export const WEB_RUNTIME_TOOL_CONTRACTS = [
+    {
+        name: "observe_web_execution",
+        ...toolContractMetadata("observe_web_execution"),
+        description: "Instrument one selected CDP page for a finite, externally driven precise coverage window. Resets execution counters and prevents optimized execution until stopped. Returns complete nested UTF-16 ranges/counts, independently hashed script text and request initiator associations by session script ID. Does not navigate, click, evaluate selected code or close the externally owned page. Navigation ends document-scoped collection; workers and UI causality remain outside this claim. Emits an actual armed progress notification before external actions.",
+        kind: "browser-provider",
+        inputSchema: observeWebExecutionInputSchema,
+        outputSchema: evidenceResultOf(webExecutionSchema),
+        examples: [
+            {
+                title: "Attribute externally triggered page execution",
+                input: {
+                    cdp_endpoint: "http://127.0.0.1:9222",
+                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
+                    observation_ms: 10_000,
+                },
+            },
+        ],
+    },
+    {
+        name: "inspect_web_event_listeners",
+        ...toolContractMetadata("inspect_web_event_listeners"),
+        description: "Inspect listeners registered directly on the first main-document CSS match in one selected CDP page. Returns event flags, native callback locations, source ownership and exact script text/digests inline. Does not dispatch events, evaluate JavaScript or invoke handlers. Delegated ancestor/framework listeners and execution history remain unknown. Releases REA's object group and transport, preserving the external page.",
+        kind: "browser-provider",
+        inputSchema: inspectWebEventListenersInputSchema,
+        outputSchema: evidenceResultOf(webEventListenersSchema),
+        examples: [
+            {
+                title: "Find a selected button's callback source",
+                input: {
+                    cdp_endpoint: "http://127.0.0.1:9222",
+                    target_id: "TARGET_ID_FROM_LIST_BROWSER_TARGETS",
+                    selector: "#submit",
+                },
+            },
+        ],
+    },
+];

package/dist/contracts/webScriptToolContracts.js

@@ -0,0 +1,68 @@
+import { exportWebScriptsInputSchema, webScriptExportResultSchema, } from "../domain/webScriptExport.js";
+import { webModuleTraceInputSchema, webModuleTraceResultSchema, } from "../domain/webModuleTrace.js";
+import { toolContractMetadata } from "./toolEffects.js";
+import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { webSourceLocationInputSchema, webSourceLocationResultSchema, } from "../domain/webSourceLocation.js";
+/** Local captured-script publication contracts shared by CLI and MCP. */
+export const WEB_SCRIPT_TOOL_CONTRACTS = [
+    {
+        name: "trace_web_source_location",
+        ...toolContractMetadata("trace_web_source_location"),
+        description: "Trace one generated position in an exported website script through an explicitly paired local source map. Verifies manifest, selected script and map SHA-256/byte identities; returns every equal-position mapping, reported source/root, resolved source URL, embedded sourcesContent and original position inline. One-based lines and zero-based UTF-16 columns; greatest generated position <= requested across lines. Duplicate sources and generated-only mappings remain distinct. Caller-selected pairing does not establish deployment authenticity or execution. Regular maps and inline indexed sections only; external section URLs are unsupported. No network access or application execution; uses the pinned upstream codec in an owned Node process with private temporary files, independent 192 MiB old-generation heap and 20-second deadline. 4 MiB map, 32 MiB reply; complete evidence or actionable resource failure. Cleanup may extend the deadline.",
+        kind: "application",
+        inputSchema: webSourceLocationInputSchema,
+        outputSchema: evidenceResultOf(webSourceLocationResultSchema),
+        examples: [
+            {
+                title: "Trace a selected captured JavaScript point to embedded original source",
+                input: {
+                    manifest_path: "/analysis/scripts/manifest.json",
+                    script_index: 0,
+                    source_map: {
+                        path: "/analysis/app.js.map",
+                        url: "https://example.test/app.js.map",
+                    },
+                    generated_position: { line: 1, column: 25 },
+                },
+            },
+        ],
+    },
+    {
+        name: "trace_web_module_imports",
+        ...toolContractMetadata("trace_web_module_imports"),
+        description: "Trace one exported website script's outgoing native ES imports/re-exports, using exact URL and optional selected import-map context. Reads a local export_web_scripts manifest and verifies the selected source's SHA-256/size; returns source positions, native resolved URLs or exact errors, every matching captured candidate and explicit unknown execution. Query/fragment identities are preserved. Computed imports and bundler IDs remain unknown. Select importer_url for unknown inline/document-base context. Caller-supplied Chromium executes only a trusted REA resolver stub in an owned context with page requests locally fulfilled/blocked; no captured application execution or asset refetch. Requires absolute REA_BROWSER_EXECUTABLE for literal imports. 32 MiB manifest, 16 MiB source, 4 MiB map and 20-second native deadline; cleanup may extend the deadline.",
+        kind: "application",
+        inputSchema: webModuleTraceInputSchema,
+        outputSchema: evidenceResultOf(webModuleTraceResultSchema),
+        examples: [
+            {
+                title: "Trace an exported module under a selected import map",
+                input: {
+                    manifest_path: "/analysis/exported-scripts/manifest.json",
+                    script_index: 0,
+                    import_map: {
+                        path: "/analysis/import-map.json",
+                        base_url: "https://example.test/app/",
+                    },
+                },
+            },
+        ],
+    },
+    {
+        name: "export_web_scripts",
+        ...toolContractMetadata("export_web_scripts"),
+        description: "Export JavaScript bytes already retained in one local inspect_web_page or capture_browser_scenario JSON capture (normalized result or complete Evidence). Writes scripts and a digest-verified manifest into an absent absolute output_directory. Returns all source URLs, script or transaction/event references, unavailable states, and an analysis_input for analyze_javascript_application when any bytes were exported. Include script sources in inspect_web_page or select capture.network.response_body in scenarios. No refetch or execution. Safe unambiguous URL layouts preserve relative module paths; versions, query variants, inline scripts, and path collisions are isolated with explicit resolution limitations.",
+        kind: "application",
+        inputSchema: exportWebScriptsInputSchema,
+        outputSchema: evidenceResultOf(webScriptExportResultSchema),
+        examples: [
+            {
+                title: "Export a saved website capture for static JavaScript analysis",
+                input: {
+                    capture_path: "/analysis/capture.json",
+                    output_directory: "/analysis/exported-scripts",
+                },
+            },
+        ],
+    },
+];

package/dist/doctorRuntime.js

@@ -1,10 +1,14 @@
 import { systemDoctorHost, } from "./application/Doctor.js";
 import { fileURLToPath } from "node:url";
 import { inspectSystemGhidraProvider } from "./ghidra/GhidraDoctor.js";
+import { inspectIdaRegistration } from "./ida/IdaDoctor.js";
 import { selectLinuxPrivateDisplayStrategy } from "./hopper/LinuxPrivateDisplayProbe.js";
 /** Compose provider diagnostics at the outer CLI adapter boundary. */
 export const createSystemDoctorHost = () => systemDoctorHost({
-    providerInspections: async () => [await inspectSystemGhidraProvider()],
+    providerInspections: async () => [
+        await inspectSystemGhidraProvider(),
+        inspectIdaRegistration(process.env.REA_IDA_MCP_CONFIG),
+    ],
     linuxDemoRuntimeCheck: inspectLinuxPrivateDisplay,
 });
 const HOPPER_DEMO_HELPER_PATH = fileURLToPath(new URL("../scripts/hopper-demo-x11.py", import.meta.url));

package/dist/domain/analysisErrorBase.js

@@ -0,0 +1,33 @@
+/** Stable tags exposed by safe analysis-error projections. */
+const ANALYSIS_ERROR_TAGS = [
+    "AnalysisProtocolError",
+    "AnalysisInputError",
+    "AnalysisOutputError",
+    "AnalysisCapabilityUnavailableError",
+    "AnalysisCancelledError",
+    "AnalysisTimeoutError",
+    "ProviderSelectionError",
+    "ProviderAdapterError",
+    "BrowserObservationError",
+    "ArtifactOperationError",
+    "ProcessCaptureError",
+    "EvidenceIntegrityError",
+    "EvidenceFileError",
+    "UnknownRegistryError",
+    "HopperTimeoutError",
+    "HopperCancelledError",
+    "HopperProtocolError",
+    "HopperRemoteError",
+    "HopperProcessError",
+    "HopperStartError",
+    "ConfigurationError",
+    "NoBinaryOpenError",
+    "BinaryTargetError",
+];
+/** Base class for expected analysis, provider, and session failures. */
+export class AnalysisError extends Error {
+    userMessage = undefined;
+    userCategory = undefined;
+    cleanupIncomplete = false;
+    cleanupResources = [];
+}

package/dist/domain/analysisErrorCore.js

@@ -0,0 +1,62 @@
+import { AnalysisError } from "./analysisErrorBase.js";
+/** Provider-neutral invalid analysis input or output at an application boundary. */
+export class AnalysisProtocolError extends AnalysisError {
+    _tag = "AnalysisProtocolError";
+}
+/** Caller input failed provider-neutral application parsing. */
+export class AnalysisInputError extends AnalysisError {
+    operation;
+    issues;
+    _tag = "AnalysisInputError";
+    constructor(operation, options, issues = []) {
+        super(`Invalid analysis input for ${operation}`, options);
+        this.operation = operation;
+        this.issues = issues;
+    }
+}
+/** Provider output failed provider-neutral application parsing. */
+export class AnalysisOutputError extends AnalysisError {
+    operation;
+    reason;
+    _tag = "AnalysisOutputError";
+    constructor(operation, reason, options) {
+        super(`Invalid analysis output for ${operation}: ${reason}`, options);
+        this.operation = operation;
+        this.reason = reason;
+    }
+}
+/** Selected provider cannot execute a declared analysis operation. */
+export class AnalysisCapabilityUnavailableError extends AnalysisError {
+    providerId;
+    operation;
+    reason;
+    _tag = "AnalysisCapabilityUnavailableError";
+    userMessage;
+    constructor(providerId, operation, reason, options) {
+        super(`Provider ${providerId} cannot execute ${operation}: ${reason}`, options);
+        this.providerId = providerId;
+        this.operation = operation;
+        this.reason = reason;
+        this.userMessage = options?.userMessage;
+    }
+}
+/** Caller cancellation won before provider-neutral work completed. */
+export class AnalysisCancelledError extends AnalysisError {
+    operation;
+    _tag = "AnalysisCancelledError";
+    constructor(operation) {
+        super(`Analysis operation was cancelled: ${operation}`);
+        this.operation = operation;
+    }
+}
+/** Provider-neutral operation exceeded its declared execution deadline. */
+export class AnalysisTimeoutError extends AnalysisError {
+    operation;
+    timeoutMs;
+    _tag = "AnalysisTimeoutError";
+    constructor(operation, timeoutMs) {
+        super(`Analysis operation timed out after ${String(timeoutMs)}ms: ${operation}`);
+        this.operation = operation;
+        this.timeoutMs = timeoutMs;
+    }
+}

package/dist/domain/analysisErrorPresentation.js

@@ -1,4 +1,13 @@
-import { AnalysisInputError, ArtifactOperationError, BinaryTargetError, BrowserObservationError, ConfigurationError, EvidenceFileError, EvidenceIntegrityError, HopperRemoteError, HopperProcessError, HopperStartError, HopperTimeoutError, NoBinaryOpenError, ProviderSelectionError, UnknownRegistryError, } from "./errors.js";
+import { AnalysisInputError } from "./analysisErrorCore.js";
+import { ArtifactOperationError } from "./artifactOperationError.js";
+import { BinaryTargetError, ConfigurationError, NoBinaryOpenError, } from "./configurationErrors.js";
+import { BrowserObservationError } from "./browserObservationError.js";
+import { EvidenceFileError, EvidenceIntegrityError, EvidenceReferenceError, } from "./evidenceErrors.js";
+import { HopperRemoteError, HopperProcessError, HopperStartError, HopperTimeoutError, } from "./hopperErrors.js";
+import { ProviderSelectionError } from "./providerSelectionError.js";
+import { UnknownRegistryError } from "./unknownRegistryError.js";
+import {} from "./analysisErrorBase.js";
+import {} from "./analysisErrorProjection.js";
 export const analysisErrorRemediationAction = (error) => {
     if (error instanceof HopperTimeoutError)
         return error.providerState === "busy"
@@ -12,6 +21,11 @@ export const analysisErrorRemediationAction = (error) => {
             : `Use the active REA session ${error.ownerRunId} or close it before opening this target again.`;
     if (error instanceof HopperRemoteError)
         return "Review the Hopper diagnostic details; correct the request or retry if the failure was transient.";
+    if (error instanceof EvidenceReferenceError)
+        return "Use an exact Evidence reference retained by this session, supply the complete inline Evidence, re-run its producer, or import its Evidence bundle. close_binary clears retained records.";
+    if (error instanceof BinaryTargetError &&
+        error.constraint === "directory_requires_file")
+        return "For a JavaScript/Electron application directory, call analyze_javascript_application with input_path or run `rea analyze <directory>`. For binary analysis, select its executable file.";
     if (error instanceof AnalysisInputError)
         return "Correct the listed arguments and retry.";
     if (error instanceof UnknownRegistryError && error.reason === "not-found")
@@ -82,6 +96,10 @@ export const analysisErrorUserMessage = (error) => {
         return standardMessage;
     if (error instanceof ArtifactOperationError)
         return artifactMessage(error.reason);
+    if (error instanceof EvidenceReferenceError)
+        return error.reason === "missing"
+            ? `Evidence ${error.evidenceId} is not retained in this session. Supply complete inline Evidence, re-run its producer, or import its bundle before using this reference.`
+            : `Evidence ${error.evidenceId} does not match the requested reference (${error.reason}). Check the expected and actual identity in the diagnostic details.`;
     if (error instanceof EvidenceIntegrityError)
         return "Evidence is invalid or has changed. Recreate or re-import it, then try again.";
     if (error instanceof EvidenceFileError)
@@ -95,7 +113,9 @@ export const analysisErrorUserMessage = (error) => {
     if (error instanceof NoBinaryOpenError)
         return error.message;
     if (error instanceof BinaryTargetError)
-        return "REA could not open that app or binary. Check that the path exists, is readable, and points to a supported file.";
+        return error.constraint === "directory_requires_file"
+            ? "open_binary accepts files and macOS app bundles. This target is a directory; JavaScript/Electron application directories can be analyzed directly with analyze_javascript_application or `rea analyze <directory>`."
+            : `${error.message}. Check that the path exists, is readable, and points to a supported file.`;
     if (error._tag === "ProcessCaptureError")
         return (error.userMessage ??
             "Process capture could not complete. Run `rea doctor`, then review capture policy and try again.");

package/dist/domain/analysisErrorProjection.js

@@ -1,5 +1,14 @@
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisTimeoutError, ArtifactOperationError, BinaryTargetError, BrowserObservationError, EvidenceFileError, EvidenceReferenceError, HopperCancelledError, HopperProcessError, HopperRemoteError, HopperTimeoutError, ProviderAdapterError, ProviderSelectionError, UnknownRegistryError, } from "./errors.js";
 import { analysisErrorCategory, analysisErrorRemediationAction, analysisErrorUserMessage, assertKnownAnalysisErrorTag, } from "./analysisErrorPresentation.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, AnalysisTimeoutError, } from "./analysisErrorCore.js";
+import { ArtifactOperationError } from "./artifactOperationError.js";
+import { BinaryTargetError } from "./configurationErrors.js";
+import { BrowserObservationError } from "./browserObservationError.js";
+import { EvidenceFileError, EvidenceReferenceError } from "./evidenceErrors.js";
+import { HopperCancelledError, HopperProcessError, HopperRemoteError, HopperTimeoutError, } from "./hopperErrors.js";
+import { ProviderAdapterError } from "./providerAdapterError.js";
+import { ProviderSelectionError } from "./providerSelectionError.js";
+import { UnknownRegistryError } from "./unknownRegistryError.js";
+import {} from "./analysisErrorBase.js";
 /** Project expected failures into exhaustive, secret-safe caller fields. */
 export const projectAnalysisError = (error) => {
     assertKnownAnalysisErrorTag(error._tag);
@@ -111,6 +120,8 @@ const errorDetails = (error) => requestErrorDetails(error) ??
     providerErrorDetails(error) ??
     lifecycleErrorDetails(error);
 const requestErrorDetails = (error) => {
+    if (error instanceof AnalysisOutputError)
+        return { operation: error.operation, reason: error.reason };
     if (error instanceof AnalysisInputError && error.issues.length > 0)
         return {
             operation: error.operation,
@@ -145,6 +156,7 @@ const artifactStateErrorDetails = (error) => {
             operation: error.operation,
             reason: error.reason,
             ...(error.reason === "limit" ? { truncated: true } : {}),
+            ...(error.detail === undefined ? {} : { detail: error.detail }),
         };
     if (error instanceof UnknownRegistryError)
         return { reason: error.reason };
@@ -154,7 +166,11 @@ const artifactStateErrorDetails = (error) => {
 };
 const providerErrorDetails = (error) => {
     if (error instanceof AnalysisCapabilityUnavailableError)
-        return { provider_id: error.providerId, operation: error.operation };
+        return {
+            provider_id: error.providerId,
+            operation: error.operation,
+            reason: error.reason,
+        };
     if (error instanceof ProviderSelectionError)
         return {
             operation: error.operation,
@@ -261,7 +277,13 @@ const lifecycleErrorDetails = (error) => {
         error.userCategory === "cancelled")
         return { operation: "process_capture", cleanup: "complete" };
     if (error instanceof BinaryTargetError)
-        return { path: error.path };
+        return {
+            path: error.path,
+            reason: error.reason,
+            ...(error.constraint === undefined
+                ? {}
+                : { constraint: error.constraint }),
+        };
     return undefined;
 };
 const RETRYABLE_CODES = new Set([

package/dist/domain/analysisSnapshot.js

@@ -14,6 +14,7 @@ const formatSchema = z.enum([
     "elf",
     "pe",
     "dos-mz",
+    "dos-com",
     "zip",
     "ipa",
     "apk",

package/dist/domain/android/androidAnalysis.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+const target = {
+    path: z
+        .string()
+        .min(1)
+        .describe("Local APK path; the target is never executed"),
+};
+const classTarget = {
+    ...target,
+    class_name: z.string().min(1).describe("Exact fully qualified class name"),
+};
+/** Caller intent for static Android inspection, independent of its engine. */
+export const androidInputSchemas = {
+    inspect_android_package: z.strictObject(target),
+    search_android_classes: z.strictObject({
+        ...target,
+        query: z
+            .string()
+            .describe("Case-sensitive class-name substring; empty lists all classes"),
+    }),
+    inspect_android_class: z.strictObject(classTarget),
+    inspect_android_method: z.strictObject({
+        ...classTarget,
+        method_name: z.string().min(1),
+        overload_index: z
+            .number()
+            .int()
+            .nonnegative()
+            .optional()
+            .describe("Explicit index among same-name methods; required when ambiguous"),
+    }),
+    trace_android_references: z.strictObject({
+        ...classTarget,
+        method_name: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("Omit for class references; ambiguous overloaded methods are unsupported"),
+    }),
+};
+/** Validate operation and input together so their types remain correlated. */
+export const androidRequestSchema = z.discriminatedUnion("operation", [
+    z.strictObject({
+        operation: z.literal("inspect_android_package"),
+        input: androidInputSchemas.inspect_android_package,
+    }),
+    z.strictObject({
+        operation: z.literal("search_android_classes"),
+        input: androidInputSchemas.search_android_classes,
+    }),
+    z.strictObject({
+        operation: z.literal("inspect_android_class"),
+        input: androidInputSchemas.inspect_android_class,
+    }),
+    z.strictObject({
+        operation: z.literal("inspect_android_method"),
+        input: androidInputSchemas.inspect_android_method,
+    }),
+    z.strictObject({
+        operation: z.literal("trace_android_references"),
+        input: androidInputSchemas.trace_android_references,
+    }),
+]);
+const textCoverage = z.strictObject({
+    status: z.enum(["complete", "partial"]),
+    text: z.string(),
+    reported_total_bytes: z.number().int().nonnegative().nullable(),
+});
+const method = z.strictObject({
+    name: z.string(),
+    reported_signature: z.string(),
+    overload_index: z.number().int().nonnegative(),
+    is_constructor: z.boolean(),
+    dex_descriptor: z.null(),
+});
+const engine = z.strictObject({
+    name: z.string().min(1),
+    version: z.string().nullable(),
+    artifact_sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+    source_revision: z.string().nullable(),
+    worker_count: z.number().int().positive(),
+    heap_limit_mib: z.number().int().positive().nullable(),
+});
+const common = { engine };
+/** Portable observations with explicit decompiler and identity limitations. */
+export const androidResultSchemas = {
+    inspect_android_package: z.strictObject({
+        ...common,
+        package_name: z.string().nullable(),
+        version_name: z.string().nullable(),
+        version_code: z.string().nullable(),
+        min_sdk: z.string().nullable(),
+        target_sdk: z.string().nullable(),
+        permissions: z.array(z.string()),
+        manifest: textCoverage,
+        class_count: z.number().int().nonnegative(),
+        resource_count: z.number().int().nonnegative(),
+        signature_verification: z.literal("not_performed"),
+    }),
+    search_android_classes: z.strictObject({
+        ...common,
+        query: z.string(),
+        total_classes: z.number().int().nonnegative(),
+        matches: z.array(z.string()),
+        coverage: z.literal("complete"),
+    }),
+    inspect_android_class: z.strictObject({
+        ...common,
+        class_name: z.string(),
+        methods: z.array(method),
+        fields: z.array(z.strictObject({ name: z.string(), reported_type: z.string() })),
+        inner_classes: z.array(z.string()),
+    }),
+    inspect_android_method: z.strictObject({
+        ...common,
+        class_name: z.string(),
+        method: method,
+        overload_count: z.number().int().positive(),
+        representation: z.enum(["java", "smali"]),
+        body_status: z.enum(["available", "not_available"]),
+        fell_back: z.boolean(),
+        markers: z.array(z.string()),
+        source: textCoverage,
+    }),
+    trace_android_references: z.strictObject({
+        ...common,
+        class_name: z.string(),
+        method_name: z.string().nullable(),
+        total: z.number().int().nonnegative(),
+        references: z.array(z.strictObject({
+            kind: z.string(),
+            name: z.string(),
+            reported_full_name: z.string(),
+            containing_class: z.string(),
+            top_class: z.string(),
+            source_line: z.null(),
+            dex_offset: z.null(),
+        })),
+        coverage: z.literal("complete"),
+    }),
+};

package/dist/domain/{androidApplication.js → android/androidApplication.js}

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
-import { parseArtifactInventoryEvidence } from "./artifactInventoryEvidence.js";
-import { evidenceSchema } from "./evidence.js";
-import { digestSchema } from "./../domain/digests.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { parseArtifactInventoryEvidence } from "../artifactInventoryEvidence.js";
+import { evidenceSchema } from "../evidence.js";
+import { digestSchema } from "../digests.js";
+import { prefixedDigestSchema } from "../digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const pathSchema = z.string().min(1);
 const componentSchema = z.strictObject({
@@ -86,6 +86,7 @@ export const projectAndroidApplication = (input) => {
             ? ["Source inventory pages are incomplete; absence is unknown."]
             : []),
         "Manifest, resource, signing, and bytecode semantics require a dedicated Android provider; this projection reports exact inventory paths and hashes only.",
+        "Runtime families are inferred from inventory formats and paths; filename suffixes do not establish valid DEX or JVM class bytes.",
         "Bridge candidates are path-based hypotheses, not decoded JNI declarations or observed runtime calls.",
     ];
     const withoutId = {
@@ -123,9 +124,9 @@ const classify = (all) => ({
 const runtimeFamilies = (all) => {
     const paths = all.map(({ path }) => path.toLowerCase());
     const families = new Set();
-    if (all.some(({ path, format }) => format === "dex" || path.endsWith(".dex")))
+    if (all.some(({ path, format }) => format === "dex" || path.toLowerCase().endsWith(".dex")))
         families.add("dalvik-art");
-    if (all.some(({ path, format }) => format === "jvm-class" || path.endsWith(".class")))
+    if (all.some(({ path, format }) => format === "jvm-class" || path.toLowerCase().endsWith(".class")))
         families.add("java-kotlin");
     if (all.some(({ format }) => format === "elf"))
         families.add("native");