rea-agents 4.0.1 → 4.1.0

package/dist/application/CapabilityInventory.js

@@ -128,6 +128,24 @@ const javascriptApplicationAvailability = ({ name, }) => {
         : null;
 };
 const workflowAvailabilityFor = ({ name, kind, policy, }) => {
+    if (kind === "firmware-provider") {
+        const enabled = name === "inspect_firmware_regions"
+            ? policy.firmwareInspectionEnabled
+            : policy.firmwareExtractionEnabled;
+        return enabled === true
+            ? { reason: "available", remediation: null }
+            : {
+                reason: "provider_missing",
+                remediation: "On Linux, provide an absolute REA_BINWALK_COMMAND (Binwalk 3.1.0) or REA_UNBLOB_COMMAND (Unblob 26.6.4) path and util-linux prlimit. Extraction also requires the selected format’s external extractor.",
+            };
+    }
+    if (kind === "android-provider")
+        return policy.androidAnalysisEnabled === true
+            ? { reason: "available", remediation: null }
+            : {
+                reason: "provider_missing",
+                remediation: "Set REA_JADX_MCP_JAR to a caller-supplied jadx-headless-mcp 0.7.1 JAR and provide Java on Linux or macOS. Only Linux has real-provider verification.",
+            };
     const browser = browserProviderAvailability(name, kind, policy);
     if (browser !== null)
         return browser;

package/dist/application/ClientConfigPath.js

@@ -26,7 +26,9 @@ export const resolveClientConfigTransactionPath = async (requestedPath, fileSyst
             ? canonicalPath
             : undefined;
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: unreadable or vanishing config paths mean no registration.
+        void cause;
         return undefined;
     }
 };

package/dist/application/ClientConfigurationDocument.js

@@ -31,7 +31,9 @@ const parseDocument = (text, format) => {
     if (format === "toml")
         return objectSchema.parse(parseToml(text));
     const errors = [];
-    const document = parseJsonc(text, errors, { allowTrailingComma: true });
+    // Accept a UTF-8 BOM without shifting diagnostics or editing the original text.
+    const jsonText = text.startsWith("\uFEFF") ? ` ${text.slice(1)}` : text;
+    const document = parseJsonc(jsonText, errors, { allowTrailingComma: true });
     const firstError = errors[0];
     if (firstError !== undefined)
         throw new SyntaxError(`Invalid JSON/JSONC at offset ${firstError.offset}: ${printParseErrorCode(firstError.error)}`);
@@ -94,6 +96,14 @@ export const clientRegistrationEntry = (format, command, environment) => {
                 tools: ["*"],
                 ...(Object.keys(environment).length === 0 ? {} : { env: environment }),
             };
+        case "commandcode":
+            return {
+                transport: "stdio",
+                enabled: true,
+                command: executable,
+                args,
+                ...(Object.keys(environment).length === 0 ? {} : { env: environment }),
+            };
         default:
             return {
                 command: executable,

package/dist/application/ClientRegistrationStatus.js

@@ -12,6 +12,7 @@ const registrationSchema = z
     args: z.array(z.string()).default([]),
     startup_timeout_sec: z.number().positive().optional(),
     type: z.string().optional(),
+    transport: z.string().optional(),
     tools: z.array(z.string()).optional(),
     disabled: z.boolean().optional(),
     enabled: z.boolean().optional(),
@@ -77,6 +78,8 @@ const registrationAligned = (registration, client, currentCommandPath) => {
         (registration.type !== "stdio" ||
             JSON.stringify(registration.tools) !== JSON.stringify(["*"])))
         return false;
+    if (client.format === "commandcode" && registration.transport !== "stdio")
+        return false;
     if (command.length === 4 &&
         command[0] === "npx" &&
         command[1] === "-y" &&
@@ -108,6 +111,8 @@ const parseRegistration = (value, client) => {
     if ((client.format === "vscode" || client.format === "copilot_cli") &&
         registration.type !== "stdio")
         throw new TypeError("Expected an stdio registration");
+    if (client.format === "commandcode" && registration.transport !== "stdio")
+        throw new TypeError("Expected an stdio registration");
     return registration;
 };
 const remediation = "Run rea setup to refresh this registration, then restart the client.";
@@ -128,7 +133,9 @@ const exists = async (path) => {
         await access(path);
         return true;
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: optional registration probing; absence means unregistered.
+        void cause;
         return false;
     }
 };

package/dist/application/CompositeProvider.js

@@ -1,4 +1,4 @@
-import { AnalysisCapabilityUnavailableError } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
 import { err, ok } from "../domain/result.js";
 import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
 /** Synthetic compatibility identity for a deterministic provider set. */

package/dist/application/DirectAnalysis.js

@@ -1,10 +1,13 @@
 import { parseConfig } from "../config.js";
 import { EnhancedTools } from "./EnhancedTools.js";
+import { executeFunctionAnalysisEvidence } from "./FunctionAnalysisEvidence.js";
 import { createBinarySession, createManagedBinarySession } from "./runtime.js";
 import { silentLogger } from "../logger.js";
 import { createEvidence } from "../domain/evidence.js";
 import { isManagedToolName, } from "../contracts/managedToolContracts.js";
-import { EvidenceIntegrityError, projectAnalysisError, } from "../domain/errors.js";
+import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import {} from "../domain/analysisErrorBase.js";
 import { access } from "node:fs/promises";
 import { readAnalysisSnapshot, writeAnalysisSnapshot, } from "./AnalysisSnapshotFiles.js";
 import { parseBinaryTarget } from "./BinaryTargetResolver.js";
@@ -22,6 +25,9 @@ export const runDirectAnalysis = async (path, tool, arguments_, options = {}) =>
     logger: options.logger ?? silentLogger,
     snapshotPath: options.snapshotPath,
     signal,
+    ...(options.formatHint === undefined
+        ? {}
+        : { formatHint: options.formatHint }),
     ...(options.providerId === undefined
         ? {}
         : { providerId: options.providerId }),
@@ -71,12 +77,18 @@ const runAnalysis = async (path, tool, arguments_, options) => {
         const prepared = await prepareSnapshot({
             path,
             snapshotPath,
+            ...(options.formatHint === undefined
+                ? {}
+                : { formatHint: options.formatHint }),
         });
         if (!prepared.ok)
             return cliError(prepared.error);
         const { snapshot } = prepared.value;
         const opened = await session.open(path, {
             signal,
+            ...(options.formatHint === undefined
+                ? {}
+                : { formatHint: options.formatHint }),
             ...(snapshot === undefined ? {} : { snapshot }),
             ...(options.providerId === undefined
                 ? {}
@@ -86,7 +98,7 @@ const runAnalysis = async (path, tool, arguments_, options) => {
             return cliError(opened.error);
         const evidenceProfile = analysisProfileForEvidence(session, tool);
         const bindingProfile = session.analysisProfile();
-        if (tool !== "trace_native_ui_action" &&
+        if (canReplayDirectTool(session, tool) &&
             snapshot !== undefined &&
             evidenceProfile !== undefined &&
             bindingProfile !== undefined) {
@@ -127,10 +139,16 @@ const runAnalysis = async (path, tool, arguments_, options) => {
         await session.close();
     }
 };
+const canReplayDirectTool = (session, tool) => tool !== "trace_native_ui_action" && session.allowsSnapshotReplay(tool);
 const executeAnalysisTool = async (input) => {
     const { session, tool, signal, evidenceProfile } = input;
+    if (tool === "analyze_function") {
+        const result = await executeFunctionAnalysisEvidence(session, input.arguments, input.openedTarget, { signal });
+        return result.ok
+            ? { output: result.value, evidence: result.value }
+            : { output: cliError(result.error) };
+    }
     if (tool === "binary_overview" ||
-        tool === "analyze_function" ||
         tool === "inspect_native_api" ||
         tool === "inspect_native_dispatch_metadata" ||
         tool === "trace_feature" ||
@@ -139,9 +157,7 @@ const executeAnalysisTool = async (input) => {
         const result = await new EnhancedTools(session).execute(tool, input.arguments, signal);
         if (!result.ok)
             return { output: cliError(result.error) };
-        const evidence = createEvidence(input.openedTarget, tool === "analyze_function"
-            ? session.providerIdentity(tool)
-            : REA_WORKFLOW_PROVIDER, {
+        const evidence = createEvidence(input.openedTarget, REA_WORKFLOW_PROVIDER, {
             operation: tool,
             parameters: input.arguments,
             result: result.value,
@@ -193,7 +209,7 @@ const prepareSnapshot = async (options) => {
     const loaded = await readAnalysisSnapshot(snapshotPath);
     if (!loaded.ok)
         return loaded;
-    const target = await parseBinaryTarget(path);
+    const target = await parseBinaryTarget(path, process.cwd(), process.arch, undefined, options.formatHint);
     if (!target.ok)
         return target;
     if (!snapshotMatchesTarget(loaded.value.target, target.value))

package/dist/application/DirectAnalysisStatus.js

@@ -1,5 +1,5 @@
 import { parseConfig } from "../config.js";
-import { projectAnalysisError } from "../domain/errors.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { createServerIdentity } from "../serverIdentity.js";
 import { silentLogger } from "../logger.js";
@@ -21,7 +21,7 @@ const runSessionStatus = async (logger = silentLogger, environment = process.env
         await session.close();
     }
 };
-/** List complete provider identities, capabilities, and availability. */
+/** List binary-session provider candidates and auxiliary operation availability. */
 export const runProviderStatus = (logger = silentLogger, environment = process.env) => runSessionStatus(logger, environment);
-/** List complete operation descriptors and availability. */
+/** List binary-session operation descriptors; this is not the full MCP catalog. */
 export const runCapabilityStatus = (logger = silentLogger, environment = process.env) => runSessionStatus(logger, environment);

package/dist/application/Doctor.js

@@ -2,6 +2,7 @@ import { constants } from "node:fs";
 import { access, readFile, readdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
+import { analysisErrorRemediationAction } from "../domain/analysisErrorPresentation.js";
 import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { execFileOutput } from "../process/ExecFileOutput.js";
 import { probeHomebrew } from "./homebrew.js";
@@ -12,7 +13,7 @@ import { readClientRegistrationStatuses, } from "./ClientRegistrationStatus.js";
 import { collectDoctorDiagnostics, doctorHealthy, } from "./DoctorDiagnostics.js";
 import { normalizeDoctorScope, scopeDoctorChecks, } from "./DoctorScope.js";
 /** Deep provider IDs whose readiness can be selected explicitly by doctor. */
-export const DOCTOR_PROVIDER_IDS = ["hopper", "ghidra"];
+export const DOCTOR_PROVIDER_IDS = ["hopper", "ghidra", "ida"];
 /**
  * Check requirements and an optional target without mutating the host.
  * Every failed check includes remediation suitable for either the one-shot CLI
@@ -147,6 +148,32 @@ export const systemDoctorHost = (options = {}) => {
         async validTarget(path) {
             return (await parseBinaryTarget(path, process.cwd(), architecture)).ok;
         },
+        async inspectTarget(path) {
+            const result = await parseBinaryTarget(path, process.cwd(), architecture);
+            if (result.ok)
+                return {
+                    name: "target",
+                    ok: true,
+                    classification: "healthy",
+                    detail: path,
+                };
+            const error = result.error;
+            return {
+                name: "target",
+                ok: false,
+                classification: error.constraint === "directory_requires_file"
+                    ? "unsupported_target"
+                    : "config_drift",
+                detail: path,
+                details: {
+                    reason: error.reason,
+                    ...(error.constraint === undefined
+                        ? {}
+                        : { constraint: error.constraint }),
+                },
+                remediation: analysisErrorRemediationAction(error),
+            };
+        },
         executable: (path) => executableAvailable(path, platform, hostExecFileOutput, commandEnvironment),
         linuxDemoRuntimeCheck: options.linuxDemoRuntimeCheck ?? uncomposedLinuxDemoRuntimeCheck,
         supportedLinuxHopper: linuxHopperBinarySupported,
@@ -156,7 +183,9 @@ export const systemDoctorHost = (options = {}) => {
                     const prefix = (await hostExecFileOutput(command, ["--prefix", "--cask", "hopper-disassembler"], commandEnvironment)).stdout.trim();
                     return `${prefix}/Hopper Disassembler.app/Contents/MacOS/hopper`;
                 }
-                catch {
+                catch (cause) {
+                    // best-effort cleanup: optional Homebrew probing; absence means uninstalled.
+                    void cause;
                     return undefined;
                 }
             });
@@ -173,7 +202,9 @@ export const systemDoctorHost = (options = {}) => {
                     ...commandEnvironment,
                 })).stdout);
             }
-            catch {
+            catch (cause) {
+                // best-effort cleanup: optional version probing; failure means unavailable.
+                void cause;
                 return undefined;
             }
         },
@@ -184,7 +215,9 @@ export const systemDoctorHost = (options = {}) => {
                 return uniqueLines((await hostExecFileOutput(command, arguments_, commandEnvironment))
                     .stdout);
             }
-            catch {
+            catch (cause) {
+                // best-effort cleanup: optional path probing; failure means none found.
+                void cause;
                 return [];
             }
         },
@@ -199,7 +232,9 @@ const readMacosVersion = async (run = execFileOutput, options = { env: process.e
     try {
         return (await run("sw_vers", ["-productVersion"], options)).stdout.trim();
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: optional OS version probing; failure means unknown.
+        void cause;
         return undefined;
     }
 };
@@ -211,7 +246,9 @@ const executableAvailable = async (path, platform = process.platform, run = exec
         const linked = await run("ldd", [path], options);
         return linuxSharedLibrariesAvailable(`${linked.stdout}\n${linked.stderr}`);
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: optional executable probing; failure means unavailable.
+        void cause;
         return false;
     }
 };
@@ -231,8 +268,9 @@ const manualHopperPaths = async (home = homedir()) => {
                     paths.push(join(root, entry.name, "Contents/MacOS/hopper"));
             }
         }
-        catch {
+        catch (cause) {
             // A missing or unreadable optional application directory is not fatal.
+            void cause;
         }
     }
     return paths;
@@ -249,7 +287,9 @@ const installedSkillIdentity = async (home) => {
                 null,
         };
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: optional skill probing; failure means unknown.
+        void cause;
         return undefined;
     }
 };

package/dist/application/DoctorDiagnostics.js

@@ -52,7 +52,7 @@ export const doctorHealthy = (checks, providers) => {
             providers.providerInspections.some(({ available }) => available)));
 };
 const nodeCheck = (host) => check("node", supportsNodeVersion(host.nodeVersion), host.nodeVersion, {
-    remediation: "Install Node.js 22.19+ or 24.11+.",
+    remediation: "Install Node.js 22.x (>=22.19), 24.x (>=24.11), or 26+.",
     classification: "missing_dependency",
 });
 const hostCheck = async (host) => {
@@ -123,10 +123,12 @@ const optionalIlspyCheck = async (host) => {
 };
 const optionalTargetCheck = async (target, host) => target === undefined
     ? undefined
-    : check("target", await host.validTarget(target), target, {
-        remediation: "Supply a readable local app or program path.",
-        classification: "config_drift",
-    });
+    : host.inspectTarget !== undefined
+        ? host.inspectTarget(target)
+        : check("target", await host.validTarget(target), target, {
+            remediation: "Supply a readable local app or program path.",
+            classification: "config_drift",
+        });
 const check = (name, ok, detail, failure) => ({
     name,
     ok,

package/dist/application/DoctorScope.js

@@ -1,3 +1,4 @@
+import { uniqueSorted } from "../domain/canonicalOrdering.js";
 /** Normalize a caller-selected doctor readiness boundary. */
 export const normalizeDoctorScope = (requested, target) => ({
     mode: requested === undefined ? "audit-wide" : "explicit",
@@ -92,5 +93,4 @@ const selectedSkillCheck = (state, checks) => checks.find(({ name }) => name ===
         ? { detail: "Installed REA skill identity is aligned." }
         : { remediation: "Run rea setup to update the installed REA skill." }),
 };
-const uniqueSorted = (values) => [...new Set(values)].sort((left, right) => left.localeCompare(right));
 const doctorProviderCheckName = (providerId, name) => name === providerId || name.startsWith(`${providerId}-`);

package/dist/application/ElectronActiveEvidence.js

@@ -1,6 +1,6 @@
+import { canonicalDigest } from "../domain/comparisonSemantics.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { digestCanonicalJson } from "../domain/browserScenarioNormalization.js";
 /** Create Evidence without retaining arbitrary runtime argument values. */
 export const createElectronActiveEvidence = (input, result, provider) => createEvidence(undefined, provider, {
     predicateType: "rea.electron-active-scenario",
@@ -29,5 +29,5 @@ const scenarioProjection = (input) => ({
 });
 const parameters = (input) => ({
     ...scenarioProjection(input),
-    scenario_sha256: digestCanonicalJson(scenarioProjection(input)),
+    scenario_sha256: canonicalDigest(scenarioProjection(input), "Browser scenario"),
 });

package/dist/application/ElectronActiveObservationService.js

@@ -1,6 +1,7 @@
 import { dirname } from "node:path";
 import { realpath } from "node:fs/promises";
-import { AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { err } from "../domain/result.js";
 import { createElectronActiveEvidence } from "./ElectronActiveEvidence.js";
 const OPERATION = "capture_electron_scenario";

package/dist/application/ElectronBoundaryAnalysis.js

@@ -1,3 +1,4 @@
+import { compareCodePoints } from "../domain/canonicalOrdering.js";
 import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
 /** Flatten all per-file IPC facts into deterministic application records. */
 export const collectElectronIpcRecords = (analysis) => analysis.files
@@ -110,4 +111,3 @@ const resolvesToFile = (input) => {
         (input.kind === undefined || input.files.get(resolved)?.kind === input.kind));
 };
 const ipcRecordKey = (path, finding) => `${path}\0${String(finding.location.start.line)}:${String(finding.location.start.column)}\0${finding.side}\0${finding.operation}`;
-const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/application/ElectronObservationService.js

@@ -1,4 +1,5 @@
-import { AnalysisCapabilityUnavailableError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { err, ok } from "../domain/result.js";
 import { createElectronEvidence } from "./ElectronEvidence.js";
 /** List local file pages exposed by the explicitly selected endpoint. */

package/dist/application/EnhancedLiteralTracing.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { AnalysisOutputError } from "../domain/errors.js";
+import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { err, ok } from "../domain/result.js";
 const LITERAL_SEARCH_SOURCES = [
     ["search_strings", "string"],

package/dist/application/EnhancedToolTypes.js

@@ -1,4 +1,5 @@
-import { AnalysisInputError } from "../domain/errors.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { err } from "../domain/result.js";
 import { enhancedInputSchemas, } from "../contracts/enhancedInputs.js";
 export const invalidEnhancedInput = (name, cause) => Promise.resolve(err(new AnalysisInputError(name, { cause })));

package/dist/application/EnhancedTools.js

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { enhancedInputSchemas } from "../contracts/enhancedInputs.js";
-import { AnalysisCancelledError, AnalysisOutputError, projectAnalysisError, } from "../domain/errors.js";
+import { AnalysisCancelledError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import {} from "../domain/analysisErrorBase.js";
 import { addressDistance, functionDossierSchema, parseDocuments, parseFunctionDossier, parseListCount, parseRelatedAddresses, parseSegments, } from "../domain/hopperValues.js";
 import { err, ok } from "../domain/result.js";
 import { categorizeSwiftTypes, discoverObjcClasses, discoverObjcProtocols, } from "../domain/symbolAnalysis.js";

package/dist/application/EvidenceBundleCommands.js

@@ -1,4 +1,5 @@
-import { EvidenceIntegrityError, } from "../domain/errors.js";
+import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
+import {} from "../domain/analysisErrorBase.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
 import { compareBundles } from "../domain/bundleComparison.js";

package/dist/application/EvidenceBundleFiles.js

@@ -1,5 +1,5 @@
 import { parseEvidenceBundle, serializeEvidenceBundle, } from "../domain/evidenceBundle.js";
-import { EvidenceFileError, EvidenceIntegrityError } from "../domain/errors.js";
+import { EvidenceFileError, EvidenceIntegrityError, } from "../domain/evidenceErrors.js";
 import { err, ok } from "../domain/result.js";
 import { parseProcessCapture } from "../domain/processCapture.js";
 import { readJsonFile, writeTextFile } from "./JsonFiles.js";

package/dist/application/EvidenceInputResolver.js

@@ -0,0 +1,30 @@
+import { EvidenceReferenceError } from "../domain/evidenceErrors.js";
+import { err, ok } from "../domain/result.js";
+/** Resolve an exact reference without selecting a target or running analysis. */
+export const resolveEvidenceInput = (input, lookup) => {
+    if (!("kind" in input))
+        return ok(input);
+    const record = lookup?.(input.evidence_id);
+    if (record === undefined)
+        return err(new EvidenceReferenceError(input.evidence_id, "missing", "Evidence retained in this session", null));
+    if (record.evidence_id !== input.evidence_id)
+        return err(new EvidenceReferenceError(input.evidence_id, "identity_mismatch", input.evidence_id, record.evidence_id));
+    return ok(record);
+};
+/** Resolve an application's Evidence before its existing semantic validation. */
+export const resolveApplicationEvidenceRequest = (input, lookup) => {
+    const application = resolveEvidenceInput(input.application, lookup);
+    if (!application.ok)
+        return application;
+    return ok({ ...input, application: application.value });
+};
+/** Resolve explicitly paired Evidence without guessing another session's record. */
+export const resolvePairedEvidenceRequest = (input, lookup) => {
+    const left = resolveEvidenceInput(input.left, lookup);
+    if (!left.ok)
+        return left;
+    const right = resolveEvidenceInput(input.right, lookup);
+    if (!right.ok)
+        return right;
+    return ok({ ...input, left: left.value, right: right.value });
+};

package/dist/application/EvidenceLedger.js

@@ -1,6 +1,7 @@
 import canonicalize from "canonicalize";
 import { createEvidenceBundle, parseEvidenceBundle, validateResidualUnknownAddition, } from "../domain/evidenceBundle.js";
-import { EvidenceIntegrityError, UnknownRegistryError, } from "../domain/errors.js";
+import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
+import { UnknownRegistryError } from "../domain/unknownRegistryError.js";
 import { parseEvidence } from "../domain/evidence.js";
 import { createResidualUnknown, updateResidualUnknown, } from "../domain/residualUnknown.js";
 import { err, ok } from "../domain/result.js";

package/dist/application/FirmwareAnalysisPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/FirmwareAnalysisService.js

@@ -0,0 +1,35 @@
+import { firmwareRequestSchema, } from "../domain/firmwareAnalysis.js";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonObjectSchema } from "../domain/jsonValue.js";
+import { err, ok } from "../domain/result.js";
+/** Shared CLI/MCP validation and Evidence composition for arbitrary firmware files. */
+export class FirmwareAnalysisService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Execute an explicit inspection or extraction and preserve its producing identity. */
+    async execute(operation, input, options) {
+        if (options?.signal?.aborted === true)
+            return err(new AnalysisCancelledError(operation));
+        const parsed = firmwareRequestSchema.safeParse({ operation, input });
+        if (!parsed.success)
+            return err(new AnalysisInputError(operation, { cause: parsed.error }));
+        const executed = await this.provider.execute(parsed.data, options);
+        if (!executed.ok)
+            return executed;
+        const execution = executed.value;
+        if (execution.subject === null)
+            return err(new AnalysisOutputError(operation, "Firmware execution did not bind its source artifact"));
+        return ok(createEvidence(execution.subject, execution.provider, {
+            operation,
+            parameters: jsonObjectSchema.parse(parsed.data.input),
+            result: execution.result,
+            rawResult: execution.rawResult,
+            locations: execution.locations,
+            limitations: execution.limitations,
+            confidence: "observed",
+        }));
+    }
+}

package/dist/application/FunctionAnalysisEvidence.js

@@ -0,0 +1,32 @@
+import { toolContract } from "../contracts/toolContracts.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { createEvidence } from "../domain/evidence.js";
+import { parseFunctionDossier } from "../domain/hopperValues.js";
+import { jsonObjectSchema } from "../domain/jsonValue.js";
+import { err, ok } from "../domain/result.js";
+import { projectInputIssues } from "../domain/inputIssueProjection.js";
+/** Preserve the provider's observations when presenting a validated function dossier. */
+export const executeFunctionAnalysisEvidence = async (analysis, parameters, target, options) => {
+    const input = toolContract("analyze_function").inputSchema.safeParse(parameters);
+    if (!input.success)
+        return err(new AnalysisInputError("analyze_function", { cause: input.error }, projectInputIssues(input.error.issues, parameters)));
+    const arguments_ = jsonObjectSchema.parse(input.data);
+    const execution = await analysis.execute("analyze_function", arguments_, options);
+    if (!execution.ok)
+        return execution;
+    const dossier = parseFunctionDossier(execution.value.result);
+    if (!dossier.ok)
+        return dossier;
+    const observation = execution.value;
+    return ok(createEvidence(observation.subject ?? target, observation.provider, {
+        operation: "analyze_function",
+        parameters: arguments_,
+        result: dossier.value,
+        rawResult: observation.rawResult,
+        limitations: observation.limitations,
+        locations: observation.locations,
+        ...(observation.analysisProfile === undefined
+            ? {}
+            : { analysisProfile: observation.analysisProfile }),
+    }));
+};

package/dist/application/InventoryProjectionEvidence.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
+import {} from "../domain/analysisErrorBase.js";
 import { createEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";