rea-agents 1.7.0 → 2.1.0

package/dist/application/JavaScriptReplayService.js

@@ -0,0 +1,292 @@
+import { z } from "zod";
+import writeFileAtomic from "write-file-atomic";
+import { controlledReplayInputSchema, replayExecutionResultSchema, controlledReplayOutputSchema, replayEvidenceSchema, } from "../domain/javascriptReplay.js";
+import { AnalysisCapabilityUnavailableError, AnalysisCancelledError, AnalysisInputError, AnalysisProtocolError, PermissionRequiredError, ReplayPlanStaleError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { projectInputIssues } from "../domain/inputIssueProjection.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { err, ok } from "../domain/result.js";
+import { replayPermissionRequest } from "./JavaScriptReplayPermission.js";
+import { digestBytes, prepareReplayPlan, } from "./JavaScriptReplayPlanning.js";
+const OPERATION = "run_controlled_replay";
+const isAborted = (signal) => signal?.aborted === true;
+/** Plan or execute one content-bound extracted-module replay experiment. */
+export const runControlledReplay = async (dependencies, rawInput, options = {}) => {
+    const parsed = controlledReplayInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }, projectInputIssues(parsed.error.issues, rawInput)));
+    return runControlledReplayValidated(dependencies, parsed.data, options);
+};
+/** Plan or execute replay input already parsed by a trusted adapter. */
+export const runControlledReplayValidated = async (dependencies, input, options = {}) => {
+    const authorized = await authorizeReplay(dependencies, input, options.signal);
+    if (!authorized.ok)
+        return authorized;
+    const prepared = await prepareValidatedReplay(dependencies, input, options.signal);
+    if (!prepared.ok)
+        return prepared;
+    if (isAborted(options.signal))
+        return err(new AnalysisCancelledError(OPERATION));
+    if (input.mode === "plan")
+        return ok(asJson({
+            phase: "plan",
+            plan: prepared.value.publicPlan,
+            source_evidence: [],
+            evidence: null,
+        }));
+    if (input.plan_digest !== prepared.value.publicPlan.plan_digest)
+        return err(new ReplayPlanStaleError(input.plan_digest ?? "", prepared.value.publicPlan.plan_digest));
+    const exportContext = await authorizeReproducerExport(dependencies.authority, input, prepared.value);
+    if (!exportContext.ok)
+        return exportContext;
+    const executed = await executeValidatedReplay(dependencies, prepared.value, exportContext.value, options);
+    if (!executed.ok)
+        return executed;
+    try {
+        return ok(buildReplayOutput(prepared.value, executed.value.executed, executed.value.sourceEvidence));
+    }
+    catch (cause) {
+        return err(new AnalysisProtocolError(cause instanceof z.ZodError
+            ? "Controlled replay produced an invalid bounded result"
+            : "Controlled replay could not establish or clean up its sandbox", { cause }));
+    }
+};
+const authorizeReplay = async (dependencies, input, signal) => {
+    if (!dependencies.policy.enabled)
+        return err(new AnalysisCapabilityUnavailableError("rea-javascript-replay", OPERATION, "controlled replay is disabled; configure exact roots and executables before enabling it"));
+    if (dependencies.authority === undefined)
+        return err(new AnalysisCapabilityUnavailableError("rea-javascript-replay", OPERATION, "JavaScript replay permission policy is not configured"));
+    if (isAborted(signal))
+        return err(new AnalysisCancelledError(OPERATION));
+    const request = replayPermissionRequest(input, dependencies.policy);
+    const authorized = input.mode === "plan"
+        ? await dependencies.authority.explain(request, "read")
+        : await dependencies.authority.authorize(request, "read");
+    if (!authorized.ok)
+        return err(authorized.error instanceof PermissionRequiredError
+            ? authorized.error
+            : new AnalysisProtocolError(authorized.error.message, {
+                cause: authorized.error,
+            }));
+    return ok(true);
+};
+const prepareValidatedReplay = async (dependencies, input, signal) => {
+    if (isAborted(signal))
+        return err(new AnalysisCancelledError(OPERATION));
+    try {
+        return ok(await prepareReplayPlan(input, dependencies.policy, dependencies.host));
+    }
+    catch (cause) {
+        return err(new AnalysisCapabilityUnavailableError("rea-javascript-replay", OPERATION, cause instanceof Error ? cause.message : "replay planning failed"));
+    }
+};
+const authorizeReproducerExport = async (authority, input, prepared) => {
+    if (input.reproducer_export === undefined)
+        return ok(undefined);
+    if (input.reproducer_export.approved !== true)
+        return err(new AnalysisInputError(`${OPERATION}:reproducer_export`));
+    if (authority === undefined)
+        return err(new AnalysisCapabilityUnavailableError("rea-javascript-replay", OPERATION, "JavaScript replay permission policy is not configured"));
+    const exportAuthorized = await authority.authorize({
+        capability: "evidence_write",
+        roots: [input.reproducer_export.path],
+        executables: [],
+        environment_names: [],
+        network: "none",
+        mount: false,
+        operation_identity: `${OPERATION}:reproducer:${prepared.publicPlan.plan_digest}`,
+    }, "write");
+    if (!exportAuthorized.ok)
+        return err(exportAuthorized.error instanceof PermissionRequiredError
+            ? exportAuthorized.error
+            : new AnalysisProtocolError(exportAuthorized.error.message, {
+                cause: exportAuthorized.error,
+            }));
+    const canonicalExportPath = exportAuthorized.value.request.roots[0];
+    if (canonicalExportPath !== input.reproducer_export.path)
+        return err(new AnalysisInputError(`${OPERATION}:reproducer_export:path`, {
+            cause: new TypeError(`Use the canonical reproducer path: ${canonicalExportPath ?? "unavailable"}`),
+        }));
+    return ok({
+        path: canonicalExportPath,
+        includeSources: input.reproducer_export.include_sources === true,
+    });
+};
+const executeValidatedReplay = async (dependencies, prepared, exportContext, options) => {
+    await options.progress?.report({
+        phase: OPERATION,
+        completed: 0,
+        total: 1,
+        message: "Admitting approved modules into the isolated replay worker",
+    });
+    if (isAborted(options.signal))
+        return err(new AnalysisCancelledError(OPERATION));
+    try {
+        let executed = replayExecutionResultSchema.parse(await dependencies.runner.execute(prepared, dependencies.policy, options.signal));
+        await options.progress?.report({
+            phase: OPERATION,
+            completed: 1,
+            total: 1,
+            message: "Controlled replay stopped and sandbox cleanup was observed",
+            terminal: true,
+        });
+        if (executed.termination === "cancelled")
+            return err(new AnalysisCancelledError(OPERATION));
+        executed = await applyReproducerExport(executed, exportContext, prepared);
+        const sourceEvidence = buildSourceEvidence(prepared, executed);
+        return ok({ executed, sourceEvidence });
+    }
+    catch (cause) {
+        return err(new AnalysisProtocolError(cause instanceof z.ZodError
+            ? "Controlled replay produced an invalid bounded result"
+            : "Controlled replay could not establish or clean up its sandbox", { cause }));
+    }
+};
+const applyReproducerExport = async (executed, exportContext, prepared) => {
+    if (exportContext === undefined || executed.cleanup.state !== "complete")
+        return executed;
+    const manifest = {
+        schema_version: 1,
+        plan: prepared.publicPlan,
+        result: executed,
+        sources: exportContext.includeSources
+            ? {
+                left: prepared.leftSources,
+                ...(prepared.rightSources === undefined
+                    ? {}
+                    : { right: prepared.rightSources }),
+            }
+            : null,
+    };
+    const encoded = Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`);
+    try {
+        await writeFileAtomic(exportContext.path, encoded, {
+            mode: 0o600,
+        });
+        return replayExecutionResultSchema.parse({
+            ...executed,
+            reproducer: {
+                state: "written",
+                path: exportContext.path,
+                sha256: digestBytes(encoded),
+            },
+        });
+    }
+    catch (cause) {
+        return replayExecutionResultSchema.parse({
+            ...executed,
+            limitations: [
+                ...executed.limitations,
+                "Replay completed, but the separately approved reproducer export failed.",
+            ],
+            reproducer: {
+                state: "failed",
+                path: exportContext.path,
+                error: cause instanceof Error
+                    ? cause.message
+                    : "unknown reproducer export failure",
+            },
+        });
+    }
+};
+const buildSourceEvidence = (prepared, executed) => {
+    const leftCount = prepared.publicPlan.cases.length;
+    return [
+        createReplayEvidence(prepared, executed, "left", executed.outcomes.slice(0, leftCount)),
+        ...(prepared.publicPlan.right === undefined
+            ? []
+            : [
+                createReplayEvidence(prepared, executed, "right", executed.outcomes.slice(leftCount)),
+            ]),
+    ];
+};
+const buildReplayOutput = (prepared, executed, sourceEvidence) => {
+    const subject = prepared.publicPlan.left.modules[0];
+    const evidence = createEvidence(subject === undefined
+        ? undefined
+        : {
+            path: subject.canonical_path,
+            sha256: subject.sha256,
+            format: "javascript",
+        }, {
+        id: "rea-javascript-replay",
+        name: "REA isolated JavaScript replay",
+        version: "1",
+    }, {
+        predicateType: "javascript-controlled-replay",
+        operation: OPERATION,
+        parameters: {
+            replay_plan: jsonValueSchema.parse(JSON.parse(JSON.stringify(prepared.publicPlan))),
+        },
+        result: jsonValueSchema.parse(JSON.parse(JSON.stringify(executed))),
+        rawResult: jsonValueSchema.parse(JSON.parse(JSON.stringify({
+            cases: prepared.publicPlan.cases,
+            outcomes: executed.outcomes,
+            stderr: executed.stderr,
+        }))),
+        confidence: executed.comparison === undefined ? "observed" : "derived",
+        authority: "controlled-replay",
+        environment: {
+            id: prepared.publicPlan.plan_digest,
+            platform: process.platform,
+            architecture: process.arch,
+            isolation: "container",
+        },
+        limitations: executed.limitations,
+        locations: prepared.publicPlan.left.modules.map((module) => ({
+            kind: "artifact-path",
+            path: module.canonical_path,
+        })),
+        evidenceLinks: sourceEvidence.map(({ evidence_id: id }) => id),
+    });
+    return asJson({
+        phase: "execute",
+        plan: null,
+        source_evidence: sourceEvidence.map((item) => replayEvidenceSchema.parse(item)),
+        evidence: replayEvidenceSchema.parse(evidence),
+    });
+};
+const createReplayEvidence = (prepared, executed, side, outcomes) => {
+    const manifest = side === "left" ? prepared.publicPlan.left : prepared.publicPlan.right;
+    const subject = manifest?.modules[0];
+    const result = replayExecutionResultSchema.parse({
+        ...executed,
+        outcomes,
+        comparison: undefined,
+        reproducer: null,
+    });
+    return createEvidence(subject === undefined
+        ? undefined
+        : {
+            path: subject.canonical_path,
+            sha256: subject.sha256,
+            format: "javascript",
+        }, {
+        id: "rea-javascript-replay",
+        name: "REA isolated JavaScript replay",
+        version: "1",
+    }, {
+        predicateType: "javascript-controlled-replay-observation",
+        operation: OPERATION,
+        parameters: {
+            replay_plan: jsonValueSchema.parse(JSON.parse(JSON.stringify(prepared.publicPlan))),
+            side,
+        },
+        result: jsonValueSchema.parse(JSON.parse(JSON.stringify(result))),
+        rawResult: jsonValueSchema.parse(JSON.parse(JSON.stringify({ cases: prepared.publicPlan.cases, outcomes }))),
+        confidence: "observed",
+        authority: "controlled-replay",
+        environment: {
+            id: prepared.publicPlan.plan_digest,
+            platform: process.platform,
+            architecture: process.arch,
+            isolation: "container",
+        },
+        limitations: executed.limitations,
+        locations: (manifest?.modules ?? []).map((module) => ({
+            kind: "artifact-path",
+            path: module.canonical_path,
+        })),
+    });
+};
+const asJson = (value) => jsonValueSchema.parse(JSON.parse(JSON.stringify(controlledReplayOutputSchema.parse(value))));

package/dist/application/JavaScriptRuntimeReconciliationEvidence.js

@@ -0,0 +1,25 @@
+import { createEvidence, } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER } from "./InvestigationProviders.js";
+/** Create derived Evidence v2 for one exact set of static/runtime inputs. */
+export const createJavaScriptRuntimeReconciliationEvidence = (input, result) => createEvidence(undefined, JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER, {
+    predicateType: "rea.javascript-runtime-reconciliation/v1",
+    operation: "reconcile_javascript_runtime",
+    parameters: parameters(input),
+    result: jsonValueSchema.parse(result),
+    rawResult: null,
+    confidence: "inferred",
+    authority: "analyst-inference",
+    environment: null,
+    limitations: result.limitations,
+    evidenceLinks: result.evidence_links,
+});
+const parameters = (input) => ({
+    static_layers: input.static_layers.map((layer) => ({
+        role: layer.role,
+        evidence_id: layer.analysis.evidence_id,
+        runtime_mappings: layer.runtime_mappings,
+    })),
+    runtime_evidence_ids: input.runtime_observations.map(({ evidence_id: id }) => id),
+    limits: input.limits,
+});

package/dist/application/JavaScriptRuntimeReconciliationService.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { projectInputIssues } from "../domain/inputIssueProjection.js";
+import { reconcileJavaScriptRuntime } from "../domain/javascriptRuntimeReconciliation.js";
+import { reconcileJavaScriptRuntimeInputSchema } from "../domain/javascriptRuntimeReconciliationSchemas.js";
+import { err, ok } from "../domain/result.js";
+import { createJavaScriptRuntimeReconciliationEvidence } from "./JavaScriptRuntimeReconciliationEvidence.js";
+const OPERATION = "reconcile_javascript_runtime";
+/** Derive a combined JAG from verified static and passive-runtime Evidence. */
+export const reconcileJavaScriptRuntimeEvidence = (rawInput) => {
+    const parsed = reconcileJavaScriptRuntimeInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(OPERATION, undefined, projectInputIssues(parsed.error.issues, rawInput)));
+    return reconcileJavaScriptRuntimeEvidenceValidated(parsed.data);
+};
+/** Reconcile input already parsed by a trusted adapter boundary. */
+export const reconcileJavaScriptRuntimeEvidenceValidated = (input) => {
+    try {
+        const result = reconcileJavaScriptRuntime(input);
+        return ok(createJavaScriptRuntimeReconciliationEvidence(input, result));
+    }
+    catch (cause) {
+        return err(cause instanceof z.ZodError || cause instanceof TypeError
+            ? new AnalysisInputError(OPERATION)
+            : new AnalysisProtocolError("JavaScript runtime reconciliation produced an invalid result", { cause }));
+    }
+};

package/dist/application/LinuxHopper.js

@@ -26,6 +26,16 @@ const SUPPORTED_RELEASES = {
         file_hash: "92d780b61cab38eda95dc4112dee4fbeb0920f46",
     },
 };
+/** Describe the release and package-manager commands without downloading or writing. */
+export const linuxHopperInstallDisclosure = (family, isRoot) => {
+    const release = SUPPORTED_RELEASES[family];
+    return {
+        downloadUrl: release.filename,
+        expectedBytes: Number(release.file_length),
+        expectedSha1: release.file_hash,
+        commands: linuxPackageManagerCommands(family, `<verified-hopper.${family}>`, isRoot).map(({ executable, args }) => `${executable} ${args.join(" ")}`),
+    };
+};
 /** Parse an os-release document without executing its shell syntax. */
 export const parseLinuxDistribution = (text) => {
     const fields = new Map();

package/dist/application/MacHopper.js

@@ -10,6 +10,16 @@ const RELEASES_URL = "https://www.hopperapp.com/include/files-api.php?request=re
 const DOWNLOAD_PREFIX = "https://www.hopperapp.com:443/downloader/public/";
 const MAX_PACKAGE_BYTES = 100_000_000;
 const BUNDLE_IDENTIFIER = "com.cryptic-apps.hopper-web-4";
+/** Stable network and command effects disclosed before macOS Hopper setup. */
+export const macHopperInstallDisclosure = {
+    networkOrigins: [RELEASES_URL, DOWNLOAD_PREFIX],
+    commands: [
+        "hdiutil attach -readonly -nobrowse -mountpoint <private-mount> <verified-hopper.dmg>",
+        "codesign --verify --deep --strict <mounted-hopper.app>",
+        "ditto <mounted-hopper.app> <user-Applications-stage>",
+        "open <installed-hopper.app>",
+    ],
+};
 /** Download, verify, and install Hopper into the current user's Applications directory. */
 export const installMacHopper = async (options = {}, host = systemMacHopperInstallHost()) => {
     let temporary;
@@ -66,17 +76,7 @@ export const installMacHopper = async (options = {}, host = systemMacHopperInsta
     }
 };
 const systemMacHopperInstallHost = () => ({
-    async download(url) {
-        const response = await fetch(url, {
-            headers: { accept: "application/json", "user-agent": "rea-installer" },
-            signal: AbortSignal.timeout(120_000),
-        });
-        const length = Number(response.headers.get("content-length") ?? "0");
-        if (length > MAX_PACKAGE_BYTES)
-            return { ok: false, bytes: new Uint8Array() };
-        const bytes = new Uint8Array(await response.arrayBuffer());
-        return { ok: response.ok && bytes.byteLength <= MAX_PACKAGE_BYTES, bytes };
-    },
+    download: downloadPackage,
     createTemporaryDirectory: () => mkdtemp(join(tmpdir(), "rea-hopper-mac-")),
     createMountDirectory: (path) => mkdir(path),
     writePackage: (path, bytes) => writeFile(path, bytes, { mode: 0o600 }),
@@ -170,6 +170,17 @@ const systemMacHopperInstallHost = () => ({
     cleanup: (path) => rm(path, { recursive: true, force: true }),
     destination: () => join(homedir(), "Applications/Hopper Disassembler.app"),
 });
+const downloadPackage = async (url) => {
+    const response = await fetch(url, {
+        headers: { accept: "application/json", "user-agent": "rea-installer" },
+        signal: AbortSignal.timeout(120_000),
+    });
+    const length = Number(response.headers.get("content-length") ?? "0");
+    if (length > MAX_PACKAGE_BYTES)
+        return { ok: false, bytes: new Uint8Array() };
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    return { ok: response.ok && bytes.byteLength <= MAX_PACKAGE_BYTES, bytes };
+};
 const parseJson = (bytes) => JSON.parse(new TextDecoder().decode(bytes));
 const integrityMatches = (bytes, release) => bytes.byteLength === Number(release.file_length) &&
     bytes.byteLength <= MAX_PACKAGE_BYTES &&

package/dist/application/ManagedApplicationGraphService.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { managedApplicationGraphResultSchema, projectManagedApplicationGraph, projectManagedApplicationGraphInputSchema, } from "../domain/managedApplicationGraph.js";
+import { err, ok } from "../domain/result.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+const OPERATION = "project_managed_application_graph";
+/** Project authenticated managed Evidence into a provider-neutral graph. */
+export const projectManagedApplicationGraphEvidence = (rawInput) => {
+    const parsed = projectManagedApplicationGraphInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+    try {
+        const result = projectManagedApplicationGraph(parsed.data);
+        return ok(createManagedApplicationGraphEvidence(parsed.data, result));
+    }
+    catch (cause) {
+        return err(cause instanceof TypeError || cause instanceof z.ZodError
+            ? new AnalysisInputError(OPERATION, { cause })
+            : new AnalysisProtocolError("Managed application graph projection produced an invalid result", { cause }));
+    }
+};
+const createManagedApplicationGraphEvidence = (input, result) => createEvidence(subjectTarget(input), MANAGED_WORKFLOW_PROVIDER, {
+    predicateType: "rea.managed-application-graph/v1",
+    operation: OPERATION,
+    parameters: {
+        managed_artifact_evidence_id: input.managed_artifact?.evidence_id ?? null,
+        managed_members_evidence_id: input.managed_members?.evidence_id ?? null,
+        managed_native_boundaries_evidence_id: input.managed_native_boundaries?.evidence_id ?? null,
+        limits: jsonValueSchema.parse(input.limits),
+    },
+    result: jsonValueSchema.parse(managedApplicationGraphResultSchema.parse(result)),
+    rawResult: null,
+    confidence: "inferred",
+    authority: "analyst-inference",
+    environment: null,
+    limitations: result.limitations,
+    evidenceLinks: result.evidence_links,
+});
+const subjectTarget = (input) => {
+    const subject = input.managed_artifact?.subject ??
+        input.managed_members?.subject ??
+        input.managed_native_boundaries?.subject;
+    if (subject === undefined || subject === null || subject.format !== "pe")
+        return undefined;
+    return {
+        path: subject.local_path,
+        sha256: subject.digest.sha256,
+        format: "pe",
+        ...(subject.architecture === null
+            ? {}
+            : { architecture: subject.architecture }),
+    };
+};

package/dist/application/ManagedMemberComparisonService.js

@@ -0,0 +1,122 @@
+import { readFile, stat } from "node:fs/promises";
+import { z } from "zod";
+import { compareManagedMembers, managedMemberComparisonResultSchema, parseManagedMemberEvidence, } from "../domain/managedMemberComparison.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { parseBinaryTarget } from "../domain/binaryTarget.js";
+import { err, ok } from "../domain/result.js";
+import { inspectManagedMembersBytes } from "../dotnet/ManagedMemberInspector.js";
+import { MANAGED_STATIC_PROVIDER } from "./InvestigationProviders.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+/** Compare managed members from input parsed by a trusted adapter. */
+export const compareManagedMembersEvidenceValidated = (input) => {
+    const operation = "compare_managed_members";
+    try {
+        const left = parseManagedMemberEvidence(input.left);
+        const right = parseManagedMemberEvidence(input.right);
+        const result = compareManagedMembers({ evidenceId: left.evidenceId, result: left.result }, { evidenceId: right.evidenceId, result: right.result }, input.limits);
+        return ok(createManagedMemberComparisonEvidence(input, result));
+    }
+    catch (cause) {
+        return workflowFailure(operation, cause);
+    }
+};
+/** Inspect two local PE artifacts and return one derived comparison Evidence. */
+export const compareManagedMemberPaths = async (input) => {
+    const operation = "compare_managed_members";
+    try {
+        const [leftTarget, rightTarget] = await Promise.all([
+            parseBinaryTarget(input.leftPath),
+            parseBinaryTarget(input.rightPath),
+        ]);
+        if (!leftTarget.ok)
+            return err(new AnalysisInputError(operation, { cause: leftTarget.error }));
+        if (!rightTarget.ok)
+            return err(new AnalysisInputError(operation, { cause: rightTarget.error }));
+        const [leftStat, rightStat] = await Promise.all([
+            stat(leftTarget.value.path),
+            stat(rightTarget.value.path),
+        ]);
+        if (leftStat.size > input.memberLimits.maxFileBytes ||
+            rightStat.size > input.memberLimits.maxFileBytes)
+            return err(new AnalysisInputError(operation, {
+                cause: new RangeError(`Managed comparison input exceeds max_file_bytes ${String(input.memberLimits.maxFileBytes)}`),
+            }));
+        const [leftBytes, rightBytes] = await Promise.all([
+            readFile(leftTarget.value.path),
+            readFile(rightTarget.value.path),
+        ]);
+        const leftInspection = inspectManagedMembersBytes(leftBytes, leftTarget.value, input.memberLimits);
+        const rightInspection = inspectManagedMembersBytes(rightBytes, rightTarget.value, input.memberLimits);
+        const leftEvidence = createEvidence(leftTarget.value, MANAGED_STATIC_PROVIDER, {
+            operation: "inspect_managed_members",
+            parameters: memberLimitParameters(input.memberLimits),
+            result: jsonValueSchema.parse(leftInspection),
+            rawResult: null,
+            limitations: leftInspection.limitations,
+            locations: [{ kind: "artifact-path", path: leftTarget.value.path }],
+        });
+        const rightEvidence = createEvidence(rightTarget.value, MANAGED_STATIC_PROVIDER, {
+            operation: "inspect_managed_members",
+            parameters: memberLimitParameters(input.memberLimits),
+            result: jsonValueSchema.parse(rightInspection),
+            rawResult: null,
+            limitations: rightInspection.limitations,
+            locations: [{ kind: "artifact-path", path: rightTarget.value.path }],
+        });
+        const result = compareManagedMembers({
+            evidenceId: leftEvidence.evidence_id,
+            result: leftInspection,
+        }, {
+            evidenceId: rightEvidence.evidence_id,
+            result: rightInspection,
+        }, input.comparisonLimits);
+        return ok(createManagedMemberComparisonEvidence({
+            left: leftEvidence,
+            right: rightEvidence,
+            limits: input.comparisonLimits,
+        }, result));
+    }
+    catch (cause) {
+        return workflowFailure(operation, cause);
+    }
+};
+const createManagedMemberComparisonEvidence = (parameters, result) => createEvidence(undefined, MANAGED_WORKFLOW_PROVIDER, {
+    predicateType: "rea.managed-member-comparison/v1",
+    operation: "compare_managed_members",
+    parameters: {
+        left_evidence_id: parameters.left.evidence_id,
+        right_evidence_id: parameters.right.evidence_id,
+        limits: jsonValueSchema.parse(parameters.limits),
+    },
+    result: jsonValueSchema.parse(result),
+    rawResult: null,
+    confidence: "inferred",
+    authority: "analyst-inference",
+    environment: null,
+    limitations: result.limitations,
+    evidenceLinks: result.evidence_links,
+});
+const memberLimitParameters = (limits) => ({
+    type_offset: limits.typeOffset,
+    type_limit: limits.typeLimit,
+    method_offset: limits.methodOffset,
+    method_limit: limits.methodLimit,
+    field_offset: limits.fieldOffset,
+    field_limit: limits.fieldLimit,
+    member_ref_offset: limits.memberRefOffset,
+    member_ref_limit: limits.memberRefLimit,
+    edge_offset: limits.edgeOffset,
+    edge_limit: limits.edgeLimit,
+    instruction_anchor_limit: limits.instructionAnchorLimit,
+    max_file_bytes: limits.maxFileBytes,
+    max_metadata_bytes: limits.maxMetadataBytes,
+    max_table_rows: limits.maxTableRows,
+    max_heap_item_bytes: limits.maxHeapItemBytes,
+    max_method_body_bytes: limits.maxMethodBodyBytes,
+    max_method_instructions: limits.maxMethodInstructions,
+});
+const workflowFailure = (operation, cause) => err(cause instanceof z.ZodError || cause instanceof TypeError
+    ? new AnalysisInputError(operation, { cause })
+    : new AnalysisProtocolError("Managed member comparison produced an invalid result", { cause }));

package/dist/application/ManagedNativeVerificationService.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { managedNativeVerificationInputSchema, verifyManagedNativeBoundaries, } from "../domain/managedNativeVerification.js";
+import { err, ok } from "../domain/result.js";
+import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+const OPERATION = "verify_managed_native_boundaries";
+/** Verify managed/native boundary declarations against native Evidence. */
+export const verifyManagedNativeBoundariesEvidence = (rawInput) => {
+    const parsed = managedNativeVerificationInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
+    try {
+        const result = verifyManagedNativeBoundaries(parsed.data);
+        return ok(createManagedNativeVerificationEvidence(parsed.data, result));
+    }
+    catch (cause) {
+        return err(cause instanceof TypeError || cause instanceof z.ZodError
+            ? new AnalysisInputError(OPERATION, { cause })
+            : new AnalysisProtocolError("Managed/native verification produced an invalid result", { cause }));
+    }
+};
+const createManagedNativeVerificationEvidence = (input, result) => createEvidence(undefined, MANAGED_WORKFLOW_PROVIDER, {
+    predicateType: "rea.managed-native-verification/v1",
+    operation: OPERATION,
+    parameters: {
+        managed_boundaries_evidence_id: input.managed_boundaries.evidence_id,
+        native_evidence_ids: jsonValueSchema.parse(input.native_observations.map(({ evidence_id: id }) => id)),
+        limits: jsonValueSchema.parse(input.limits),
+    },
+    result: jsonValueSchema.parse(result),
+    rawResult: null,
+    confidence: "inferred",
+    authority: "analyst-inference",
+    environment: null,
+    limitations: result.limitations,
+    evidenceLinks: result.evidence_links,
+});