rea-agents 0.3.0 → 0.5.0

package/dist/cliLogging.js

@@ -0,0 +1,21 @@
+/** Log one CLI command with duration and a stable success or failure status. */
+export const logCliCommand = async (logger, command, execute) => {
+    const startedAt = performance.now();
+    try {
+        const value = await execute();
+        logger.info({
+            command,
+            durationMs: Math.round((performance.now() - startedAt) * 100) / 100,
+            status: "ok",
+        }, "CLI command completed");
+        return value;
+    }
+    catch (cause) {
+        logger.error({
+            command,
+            durationMs: Math.round((performance.now() - startedAt) * 100) / 100,
+            status: "error",
+        }, "CLI command failed");
+        throw cause;
+    }
+};

package/dist/config.js

@@ -2,6 +2,9 @@ import { z } from "zod";
 import { ConfigurationError } from "./domain/errors.js";
 import { err, ok } from "./domain/result.js";
 const DEFAULT_HOPPER_LAUNCHER_PATH = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
+const defaultHopperLauncherPath = () => process.platform === "linux"
+    ? "/opt/hopper/bin/Hopper"
+    : DEFAULT_HOPPER_LAUNCHER_PATH;
 const environmentSchema = z.object({
     HOPPER_LAUNCHER_PATH: z.string().min(1).optional(),
     HOPPER_TARGET_PATH: z.string().min(1).optional(),
@@ -11,9 +14,15 @@ const environmentSchema = z.object({
         .enum(["trace", "debug", "info", "warn", "error", "fatal", "silent"])
         .default("info"),
     REA_PROCESS_CAPTURE_ENABLED: z.enum(["true", "false"]).default("false"),
+    REA_PROCESS_ALLOW_EXTERNAL_NETWORK: z
+        .enum(["true", "false"])
+        .default("false"),
     REA_PROCESS_EXECUTABLE_ROOTS_JSON: z.string().default("[]"),
     REA_PROCESS_WORKING_ROOTS_JSON: z.string().default("[]"),
     REA_PROCESS_ALLOWED_ENV_JSON: z.string().default("[]"),
+    REA_EVIDENCE_ROOTS_JSON: z.string().default("[]"),
+    REA_REFERENCE_ROOTS_JSON: z.string().default("[]"),
+    REA_REFERENCE_SECRET_PATTERNS_JSON: z.string().default("[]"),
 });
 const parseStringArray = (encoded, name) => {
     try {
@@ -69,9 +78,18 @@ export const parseConfig = (environment) => {
     const allowedEnvironment = parseStringArray(parsedEnvironment.data.REA_PROCESS_ALLOWED_ENV_JSON, "REA_PROCESS_ALLOWED_ENV_JSON");
     if (!allowedEnvironment.ok)
         return allowedEnvironment;
+    const evidenceRoots = parseStringArray(parsedEnvironment.data.REA_EVIDENCE_ROOTS_JSON, "REA_EVIDENCE_ROOTS_JSON");
+    if (!evidenceRoots.ok)
+        return evidenceRoots;
+    const referenceRoots = parseStringArray(parsedEnvironment.data.REA_REFERENCE_ROOTS_JSON, "REA_REFERENCE_ROOTS_JSON");
+    if (!referenceRoots.ok)
+        return referenceRoots;
+    const secretPatterns = parseStringArray(parsedEnvironment.data.REA_REFERENCE_SECRET_PATTERNS_JSON, "REA_REFERENCE_SECRET_PATTERNS_JSON");
+    if (!secretPatterns.ok)
+        return secretPatterns;
     return ok({
         hopperLauncherPath: parsedEnvironment.data.HOPPER_LAUNCHER_PATH ??
-            DEFAULT_HOPPER_LAUNCHER_PATH,
+            defaultHopperLauncherPath(),
         hopperTargetPath: parsedEnvironment.data.HOPPER_TARGET_PATH,
         hopperTargetKind: parsedEnvironment.data.HOPPER_TARGET_KIND,
         hopperLoaderArgs: parsedArgs.data,
@@ -81,6 +99,22 @@ export const parseConfig = (environment) => {
             executableRoots: executableRoots.value,
             workingRoots: workingRoots.value,
             allowedEnvironment: allowedEnvironment.value,
+            allowExternalNetwork: parsedEnvironment.data.REA_PROCESS_ALLOW_EXTERNAL_NETWORK === "true",
+        },
+        evidenceFilePolicy: {
+            roots: evidenceRoots.value,
+            maxBytes: 64 * 1024 * 1024,
+            maxDepth: 64,
+            maxStringLength: 1024 * 1024,
+            maxNodes: 1_000_000,
+        },
+        referenceSourcePolicy: {
+            roots: referenceRoots.value,
+            secretPatterns: secretPatterns.value,
+            maxBytes: 16 * 1024 * 1024,
+            maxEntries: 10_000,
+            maxDepth: 32,
+            maxPathBytes: 4_096,
         },
     });
 };

package/dist/contracts/artifactComparisonExample.js

@@ -0,0 +1,95 @@
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+const inventory = (digit) => {
+    const sha = digit.repeat(64);
+    const artifactId = `art_${sha}`;
+    const occurrenceId = `occ_${sha}`;
+    return jsonValueSchema.parse({
+        manifest: {
+            schema_version: 1,
+            manifest_id: `agm_${sha}`,
+            root_artifact_id: artifactId,
+            root_sha256: sha,
+            root_format: "file",
+            graph_sha256: sha,
+            node_count: 1,
+            occurrence_count: 1,
+            edge_count: 0,
+        },
+        nodes: {
+            items: [
+                {
+                    artifact_id: artifactId,
+                    kind: "resource",
+                    format: "file",
+                    sha256: sha,
+                    size: 1,
+                    media_type: null,
+                    architecture: null,
+                    executable: false,
+                    content_state: "materialized",
+                    limitations: [],
+                },
+            ],
+            offset: 0,
+            limit: 100,
+            total: 1,
+            next_offset: null,
+        },
+        occurrences: {
+            items: [
+                {
+                    occurrence_id: occurrenceId,
+                    artifact_id: artifactId,
+                    parent_occurrence_id: null,
+                    logical_path: ".",
+                    entry_kind: "file",
+                    declared_size: 1,
+                    compressed_size: null,
+                    executable: false,
+                    encrypted: false,
+                    hash_status: "verified",
+                    source_location: null,
+                    limitations: [],
+                },
+            ],
+            offset: 0,
+            limit: 100,
+            total: 1,
+            next_offset: null,
+        },
+        edges: { items: [], offset: 0, limit: 100, total: 0, next_offset: null },
+        limits: {
+            max_entries: 100,
+            max_total_bytes: 1024,
+            max_entry_bytes: 1024,
+            max_compression_ratio: 10,
+            max_depth: 10,
+            max_path_bytes: 256,
+        },
+        provenance: [],
+        limitations: [],
+    });
+};
+const provider = {
+    id: "rea-artifact",
+    name: "REA artifact graph",
+    version: "1",
+};
+/** Canonical complete inputs used to advertise artifact comparison. */
+export const ARTIFACT_COMPARISON_EXAMPLE = {
+    left: createEvidence(undefined, provider, {
+        operation: "inventory_artifact",
+        parameters: {},
+        result: inventory("0"),
+        confidence: "observed",
+        authority: "shipped-artifact",
+    }),
+    right: createEvidence(undefined, provider, {
+        operation: "inventory_artifact",
+        parameters: {},
+        result: inventory("1"),
+        confidence: "observed",
+        authority: "shipped-artifact",
+    }),
+};

package/dist/contracts/artifactToolContracts.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { artifactOutputSchemas } from "./toolOutputSchemas.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+const pageInput = {
+    node_offset: z.number().int().min(0).default(0),
+    node_limit: z.number().int().min(1).max(500).default(100),
+    occurrence_offset: z.number().int().min(0).default(0),
+    occurrence_limit: z.number().int().min(1).max(500).default(100),
+    edge_offset: z.number().int().min(0).default(0),
+    edge_limit: z.number().int().min(1).max(500).default(100),
+};
+const traversalLimitsInput = {
+    max_entries: z.number().int().min(1).max(1_000_000).default(10_000),
+    max_total_bytes: z
+        .number()
+        .int()
+        .min(1)
+        .max(Number.MAX_SAFE_INTEGER)
+        .default(1_073_741_824),
+    max_entry_bytes: z
+        .number()
+        .int()
+        .min(1)
+        .max(Number.MAX_SAFE_INTEGER)
+        .default(268_435_456),
+    max_compression_ratio: z.number().min(1).max(100_000).default(1_000),
+    max_depth: z.number().int().min(0).max(100).default(20),
+    max_path_bytes: z.number().int().min(1).max(65_535).default(4_096),
+};
+/** Exact caller boundary for deterministic artifact inventory. */
+export const artifactInventoryInputSchema = z.object({
+    ...pageInput,
+    ...traversalLimitsInput,
+});
+/** Exact caller boundary for approved artifact extraction. */
+export const artifactExtractionInputSchema = z.object({
+    approved: z.literal(true),
+    output_root: z.string().min(1).max(4_096),
+    occurrence_ids: z
+        .array(z.string().regex(/^occ_[a-f0-9]{64}$/u))
+        .min(1)
+        .max(500),
+    offset: z.number().int().min(0).default(0),
+    limit: z.number().int().min(1).max(500).default(100),
+    ...traversalLimitsInput,
+});
+const exampleInputSchema = z.record(z.string(), jsonValueSchema);
+const examples = {
+    inventory_artifact: {},
+    extract_artifact: {
+        approved: true,
+        output_root: "/tmp/rea-extracted",
+        occurrence_ids: [`occ_${"0".repeat(64)}`],
+    },
+};
+const artifact = (name, description, inputSchema, mutatesFilesystem) => {
+    const outputSchema = artifactOutputSchemas[name];
+    if (outputSchema === undefined)
+        throw new Error(`Missing artifact output schema for ${name}`);
+    return {
+        name,
+        description,
+        kind: "artifact-provider",
+        inputSchema,
+        outputSchema,
+        annotations: {
+            readOnlyHint: !mutatesFilesystem,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        examples: [
+            {
+                title: `Example ${name.replaceAll("_", " ")} request`,
+                input: exampleInputSchema.parse(examples[name] ?? {}),
+            },
+        ],
+    };
+};
+/** Artifact-graph inventory and explicitly approved safe extraction contracts. */
+export const ARTIFACT_TOOL_CONTRACTS = [
+    artifact("inventory_artifact", "Inventory the active application or package as a deterministic, content-addressed artifact graph. Returns bounded node and edge pages without extracting or mounting by default.", artifactInventoryInputSchema, false),
+    artifact("extract_artifact", "Extract selected graph artifacts beneath an explicit output root. Requires approval, rejects traversal and symlink escapes, never overwrites, enforces bomb limits, and verifies cleanup.", artifactExtractionInputSchema, true),
+];

package/dist/contracts/enhancedInputs.js

@@ -56,6 +56,10 @@ export const enhancedInputSchemas = {
         case_sensitive: z.boolean().default(false),
         limit: z.number().int().min(1).max(100).default(20),
         max_operations: z.number().int().min(1).max(100).default(20),
+        unknown_registry_approved: z
+            .literal(true)
+            .optional()
+            .describe("Explicit approval to record bounded residuals durably"),
     }),
 };
 /** Runtime parser for dispatching only the eight closed enhanced names. */

package/dist/contracts/functionComparisonExample.js

@@ -0,0 +1,57 @@
+import { enhancedInputSchemas } from "./enhancedInputs.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+const bounded = (items) => ({
+    items,
+    total: items.length,
+    returned: items.length,
+    truncated: false,
+    next_offset: null,
+});
+const dossier = (text) => jsonValueSchema.parse({
+    procedure: {
+        address: "0x1000",
+        name: "main",
+        signature: "int main(void)",
+        locals: [],
+    },
+    pseudocode: {
+        text,
+        total_chars: [...text].length,
+        returned_chars: [...text].length,
+        truncated: false,
+        next_offset: null,
+    },
+    assembly: bounded([]),
+    comments: bounded([]),
+    callers: bounded([]),
+    callees: bounded([]),
+    incoming_references: bounded([]),
+    outgoing_references: bounded([]),
+    referenced_strings: bounded([]),
+    referenced_names: bounded([]),
+    basic_blocks: bounded([{ start: "0x1000", end: "0x1001", successors: [] }]),
+    instruction_scan: { scanned: 1, truncated: false },
+});
+const observe = (digit, text) => createEvidence({
+    path: `/tmp/function-${digit}`,
+    sha256: digit.repeat(64),
+    format: "mach-o",
+}, {
+    id: "rea-workflow",
+    name: "REA composed investigation workflow",
+    version: "1",
+}, {
+    operation: "analyze_function",
+    parameters: enhancedInputSchemas.analyze_function.parse({
+        procedure: "main",
+    }),
+    result: dossier(text),
+    confidence: "derived",
+    authority: "shipped-artifact",
+});
+/** Canonical explicit function pair used in public contract examples. */
+export const FUNCTION_COMPARISON_EXAMPLE = {
+    left: observe("0", "return 0;"),
+    right: observe("1", "return 1;"),
+};

package/dist/contracts/investigationExamples.js

@@ -0,0 +1,118 @@
+import { compareFunctions } from "../domain/functionComparison.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { createEvidenceBundle } from "../domain/evidenceBundle.js";
+import { compareProcessCaptures, processCaptureSchema, } from "../domain/processCapture.js";
+import { FUNCTION_COMPARISON_EXAMPLE } from "./functionComparisonExample.js";
+import { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "./processCaptureExample.js";
+const comparison = compareFunctions(FUNCTION_COMPARISON_EXAMPLE.left, FUNCTION_COMPARISON_EXAMPLE.right, 0, 100);
+export const FUNCTION_COMPARISON_EVIDENCE = createEvidence(undefined, {
+    id: "rea-function-comparison",
+    name: "REA function comparison",
+    version: "1",
+}, {
+    predicateType: "rea.function-comparison/v1",
+    operation: "compare_functions",
+    parameters: {
+        left_evidence_ids: [FUNCTION_COMPARISON_EXAMPLE.left.evidence_id],
+        right_evidence_ids: [FUNCTION_COMPARISON_EXAMPLE.right.evidence_id],
+        offset: 0,
+        limit: 100,
+    },
+    result: jsonValueSchema.parse(comparison),
+    confidence: "derived",
+    authority: "analyst-inference",
+    evidenceLinks: [
+        FUNCTION_COMPARISON_EXAMPLE.left.evidence_id,
+        FUNCTION_COMPARISON_EXAMPLE.right.evidence_id,
+    ],
+});
+const PROCESS_PROVIDER = {
+    id: "rea-process",
+    name: "REA deterministic process harness",
+    version: "1",
+};
+const capture = processCaptureSchema.parse(EMPTY_PROCESS_CAPTURE_EXAMPLE);
+const captureEvidence = (scenario) => createEvidence(undefined, PROCESS_PROVIDER, {
+    predicateType: "rea.process-capture/v2",
+    operation: "capture_process_scenario",
+    parameters: { scenario },
+    result: jsonValueSchema.parse(capture),
+    confidence: "observed",
+    authority: "controlled-replay",
+    environment: {
+        id: "fixture-linux",
+        platform: "linux",
+        architecture: "x86_64",
+        isolation: "container",
+    },
+});
+export const PROCESS_CAPTURE_REFERENCE = captureEvidence("reference");
+export const PROCESS_CAPTURE_RECONSTRUCTION = captureEvidence("reconstruction");
+export const PROCESS_COMPARISON_EVIDENCE = createEvidence(undefined, PROCESS_PROVIDER, {
+    predicateType: "rea.process-comparison/v1",
+    operation: "compare_process_captures",
+    parameters: {
+        left_evidence_id: PROCESS_CAPTURE_REFERENCE.evidence_id,
+        right_evidence_id: PROCESS_CAPTURE_RECONSTRUCTION.evidence_id,
+        left_normalization: capture.normalization,
+        right_normalization: capture.normalization,
+    },
+    result: jsonValueSchema.parse(compareProcessCaptures(capture, capture)),
+    confidence: "derived",
+    authority: "analyst-inference",
+    evidenceLinks: [
+        PROCESS_CAPTURE_REFERENCE.evidence_id,
+        PROCESS_CAPTURE_RECONSTRUCTION.evidence_id,
+    ],
+});
+/** Canonical inputs for comparison-composed investigation contracts. */
+export const INVESTIGATION_EXAMPLES = {
+    find_changed_behavior: { comparisons: [FUNCTION_COMPARISON_EVIDENCE] },
+    build_call_path: {
+        functions: [FUNCTION_COMPARISON_EXAMPLE.left],
+        start: { address: "0x1000" },
+        goal: { address: "0x1000" },
+    },
+    correlate_static_and_runtime: {
+        static_comparisons: [FUNCTION_COMPARISON_EVIDENCE],
+        runtime_comparisons: [PROCESS_COMPARISON_EVIDENCE],
+        mappings: [
+            {
+                static: {
+                    comparison_evidence_id: FUNCTION_COMPARISON_EVIDENCE.evidence_id,
+                    selector: { kind: "function", dimension: "pseudocode" },
+                },
+                runtime: {
+                    comparison_evidence_id: PROCESS_COMPARISON_EVIDENCE.evidence_id,
+                    dimension: "terminal",
+                },
+                side_alignment: "left_to_left",
+                hypothesis: {
+                    statement: "Static implementation changed without terminal change.",
+                    expected_pattern: "static_only",
+                },
+            },
+        ],
+    },
+    verify_reconstruction: {
+        specification: {
+            schema_version: 1,
+            name: "Terminal compatibility",
+            claims: [
+                {
+                    kind: "behavioral",
+                    claim_id: "terminal-output",
+                    title: "Terminal output remains equivalent",
+                    comparison_evidence_id: PROCESS_COMPARISON_EVIDENCE.evidence_id,
+                    dimension: "terminal",
+                },
+            ],
+        },
+        evidence_bundle: createEvidenceBundle([
+            PROCESS_CAPTURE_REFERENCE,
+            PROCESS_CAPTURE_RECONSTRUCTION,
+            PROCESS_COMPARISON_EVIDENCE,
+        ]),
+    },
+};

package/dist/contracts/nativeToolContracts.js

@@ -0,0 +1,52 @@
+import { z } from "zod";
+import { nativeOutputSchemas } from "./toolOutputSchemas.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+const examples = {
+    inspect_macho: {},
+    inspect_signature: {},
+    inspect_plist: { relative_path: "Contents/Info.plist" },
+    list_architectures: {},
+    demangle_swift: { symbols: ["$s4Test3fooyyF"] },
+};
+const native = (name, description, inputSchema) => {
+    const outputSchema = nativeOutputSchemas[name];
+    if (outputSchema === undefined)
+        throw new Error(`Missing native output schema for ${name}`);
+    return {
+        name,
+        description,
+        kind: "native-provider",
+        inputSchema,
+        outputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        examples: [
+            {
+                title: `Example ${name.replaceAll("_", " ")} request`,
+                input: z
+                    .record(z.string(), jsonValueSchema)
+                    .parse(examples[name] ?? {}),
+            },
+        ],
+    };
+};
+/** Provider-neutral semantic operations backed initially by macOS utilities. */
+export const NATIVE_TOOL_CONTRACTS = [
+    native("inspect_macho", "Inspect Mach-O slices, load commands, imports, exports, dependencies, build metadata, segments, sections, permissions, and exact command provenance without launching Hopper.", z.object({})),
+    native("inspect_signature", "Inspect the active artifact's code-signing identity, hashes, authorities, requirements, entitlements, hardened-runtime state, and bounded command provenance.", z.object({})),
+    native("inspect_plist", "Parse a plist at a bounded relative path beneath the active artifact container. Symlink and traversal escapes are rejected; output is normalized JSON rather than plutil text.", z.object({
+        relative_path: z
+            .string()
+            .min(1)
+            .max(1_024)
+            .default("Contents/Info.plist"),
+    })),
+    native("list_architectures", "List thin or universal Mach-O slices with offsets, sizes, alignment, explicit coverage, and bounded native-tool provenance.", z.object({})),
+    native("demangle_swift", "Demangle an ordered bounded batch of Swift symbols without requiring Hopper. Each input returns demangled, unchanged, or invalid status.", z.object({
+        symbols: z.array(z.string().min(1).max(4_096)).min(1).max(500),
+    })),
+];

package/dist/contracts/processCaptureExample.js

@@ -0,0 +1,25 @@
+/** Minimal valid process capture used only in public contract examples. */
+export const EMPTY_PROCESS_CAPTURE_EXAMPLE = {
+    schema_version: 2,
+    normalization: {
+        paths: true,
+        pids: true,
+        ports: true,
+        time_bucket_ms: 10,
+        patterns: [],
+    },
+    frames: [],
+    exit: { code: 0, signal: null, reason: "exited" },
+    process_samples: [],
+    protocol_events: [],
+    files_before: [],
+    files_after: [],
+    filesystem_effects: [],
+    truncated: false,
+    limitations: [],
+    residual_unknowns: [],
+    cleanup: {
+        owned_process_group: "verified",
+        temporary_root: "removed",
+    },
+};

package/dist/contracts/toolContractExamples.js

@@ -0,0 +1,69 @@
+import { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "./processCaptureExample.js";
+import { UNKNOWN_CONTRACT_EXAMPLES } from "./unknownContractExamples.js";
+import { ARTIFACT_COMPARISON_EXAMPLE } from "./artifactComparisonExample.js";
+import { FUNCTION_COMPARISON_EXAMPLE } from "./functionComparisonExample.js";
+import { INVESTIGATION_EXAMPLES } from "./investigationExamples.js";
+/** Canonical examples for contracts whose required inputs have no defaults. */
+export const TOOL_EXAMPLE_OVERRIDES = {
+    ...UNKNOWN_CONTRACT_EXAMPLES,
+    ...INVESTIGATION_EXAMPLES,
+    goto_address: { address: "0x1000" },
+    procedure_address: { procedure: "main" },
+    procedure_assembly: { procedure: "main" },
+    procedure_callees: { procedure: "main" },
+    procedure_callers: { procedure: "main" },
+    procedure_info: { procedure: "main" },
+    procedure_references: { procedure: "main" },
+    procedure_pseudo_code: { procedure: "main" },
+    resolve_containing_procedure: { address: "0x1000" },
+    search_procedures: { pattern: "main" },
+    search_strings: { pattern: "authorization failed" },
+    set_address_name: { address: "0x1000", name: "entry" },
+    set_addresses_names: { names: { "0x1000": "entry" } },
+    set_bookmark: { address: "0x1000" },
+    set_comment: { address: "0x1000", comment: "validated entry point" },
+    set_current_document: { document: "fixture" },
+    set_inline_comment: { address: "0x1000", comment: "calls parser" },
+    unset_bookmark: { address: "0x1000" },
+    get_call_graph: { address: "0x1000" },
+    find_xrefs_to_name: { name: "malloc" },
+    analyze_function: { procedure: "main" },
+    trace_feature: { query: "license" },
+    open_binary: { path: "/tmp/fixture" },
+    import_evidence_bundle: { path: "evidence.json" },
+    capture_process_scenario: {
+        approved: true,
+        executable: "/usr/bin/true",
+        working_directory: "/tmp",
+    },
+    compare_process_captures: {
+        left_evidence_id: `ev_${"0".repeat(64)}`,
+        left: EMPTY_PROCESS_CAPTURE_EXAMPLE,
+        right_evidence_id: `ev_${"1".repeat(64)}`,
+        right: EMPTY_PROCESS_CAPTURE_EXAMPLE,
+    },
+    compare_artifacts: ARTIFACT_COMPARISON_EXAMPLE,
+    compare_functions: FUNCTION_COMPARISON_EXAMPLE,
+    compare_bundles: {
+        left: {
+            bundle_version: 2,
+            artifacts: [],
+            providers: [],
+            environments: [],
+            scenarios: [],
+            captures: [],
+            unknowns: [],
+            records: [],
+        },
+        right: {
+            bundle_version: 2,
+            artifacts: [],
+            providers: [],
+            environments: [],
+            scenarios: [],
+            captures: [],
+            unknowns: [],
+            records: [],
+        },
+    },
+};