rea-agents 2.4.0 → 2.5.0

package/dist/contracts/applicationWorkflowInputContracts.js

@@ -4,6 +4,7 @@ import { compareApplicationVersionsInputSchema } from "../domain/javascriptAppli
 import { compareJavaScriptExportShapesInputSchema } from "../domain/javascriptExportShapeComparisonSchemas.js";
 import { traceApplicationFeatureInputSchema } from "../domain/javascriptFeatureTraceSchemas.js";
 import { javaScriptSemanticQueryInputSchema } from "../domain/javascriptSemanticQuerySchemas.js";
+import { compareSourceToBundleInputSchema } from "../domain/sourceToBundleComparisonSchemas.js";
 const evidenceIdSchema = z
     .string()
     .regex(/^ev_[a-f0-9]{64}$/u)
@@ -89,6 +90,23 @@ export const compareApplicationVersionsRequestSchema = z
         input.right_evidence_id,
     ]);
 });
+/** Historical-source comparison accepting full application Evidence or a ledger reference. */
+export const compareSourceToBundleRequestSchema = z
+    .strictObject({
+    reference: compareSourceToBundleInputSchema.shape.reference,
+    application: evidenceSchema.optional(),
+    application_evidence_id: evidenceIdSchema.optional(),
+    limits: compareSourceToBundleInputSchema.shape.limits,
+    unknown_registry_approved: compareSourceToBundleInputSchema.shape.unknown_registry_approved,
+})
+    .superRefine((input, context) => {
+    requireExactlyOne(context, [
+        "application",
+        input.application,
+        "application_evidence_id",
+        input.application_evidence_id,
+    ]);
+});
 /** MCP/CLI export-shape request accepting full Evidence or ledger references. */
 export const compareJavaScriptExportShapesRequestSchema = z
     .strictObject({

package/dist/contracts/artifactToolContracts.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { artifactOutputSchemas } from "./toolOutputSchemas.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { toolContractMetadata } from "./toolEffects.js";
+import { artifactInspectionLimitsSchema } from "../domain/artifactInspection.js";
 const pageInput = {
     node_offset: z.number().int().min(0).default(0),
     node_limit: z.number().int().min(1).max(500).default(100),
@@ -59,9 +60,29 @@ export const artifactExtractionInputSchema = z.object({
     limit: z.number().int().min(1).max(500).default(100),
     ...traversalLimitsInput,
 });
+/** Bounded provider-neutral inspection using one atomic inventory substep. */
+export const artifactInspectionInputSchema = z
+    .object({
+    native_mount_approved: z.boolean().default(false),
+    integrity_policy: z.enum(["fail", "record-and-continue"]).default("fail"),
+    integrity_continue_approved: z.boolean().default(false),
+    max_integrity_mismatches: z.number().int().min(1).max(100).default(10),
+    ...artifactInspectionLimitsSchema.shape,
+    ...traversalLimitsInput,
+})
+    .superRefine((input, context) => {
+    if (input.integrity_policy === "record-and-continue" &&
+        input.integrity_continue_approved !== true)
+        context.addIssue({
+            code: "custom",
+            path: ["integrity_continue_approved"],
+            message: "record-and-continue requires explicit approval",
+        });
+});
 const exampleInputSchema = z.record(z.string(), jsonValueSchema);
 const examples = {
     inventory_artifact: {},
+    inspect_artifact: {},
     extract_artifact: {
         approved: true,
         output_root: "/tmp/rea-extracted",
@@ -90,5 +111,6 @@ const artifact = (name, description, inputSchema) => {
 /** 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),
+    artifact("inspect_artifact", "Inspect the active artifact through one bounded, cancellable inventory substep. Returns the full substep Evidence and its ID, observations, derived relationships, hypotheses, contradictions, unexplored branches, limitations, and format-specific next probes. Any substep failure fails the whole call.", artifactInspectionInputSchema),
     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),
 ];

package/dist/contracts/browserProviderToolContracts.js

@@ -0,0 +1,7 @@
+import { BROWSER_SCENARIO_TOOL_CONTRACTS } from "./browserScenarioToolContracts.js";
+import { BROWSER_TOOL_CONTRACTS } from "./browserToolContracts.js";
+/** Complete ordered browser-provider contract inventory. */
+export const BROWSER_PROVIDER_TOOL_CONTRACTS = [
+    ...BROWSER_TOOL_CONTRACTS,
+    ...BROWSER_SCENARIO_TOOL_CONTRACTS,
+];

package/dist/contracts/browserScenarioToolContracts.js

@@ -0,0 +1,81 @@
+import { toolContractMetadata } from "./toolEffects.js";
+import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { browserScenarioSchema } from "../domain/browserScenario.js";
+import { browserScenarioCaptureSchema } from "../domain/browserScenarioCapture.js";
+const example = {
+    schema_version: 1,
+    browser: {
+        mode: "launch",
+        executable_path: "/opt/chromium/chrome",
+        headless: true,
+        user_data: "temporary-owned",
+        cleanup: "close-and-delete-profile",
+    },
+    start_url: { url: "https://app.example.test/", query: [] },
+    allowed_origins: ["https://app.example.test"],
+    environment: {
+        viewport: { width: 1_280, height: 720, device_scale_factor: 1 },
+        locale: "en-US",
+        timezone: "UTC",
+        color_scheme: "light",
+        reduced_motion: "reduce",
+        service_workers: "block",
+    },
+    actions: [
+        {
+            step_id: "ready",
+            action: "wait_for",
+            locator: { kind: "test_id", value: "application-ready" },
+            state: "visible",
+        },
+    ],
+    storage: { cookies: [], local_storage: [], session_storage: [] },
+    request_replay: { mode: "disabled" },
+    secrets: [],
+    redaction: {
+        secret_values: "replace-with-secret-reference",
+        query_parameter_names: [],
+        header_names: [
+            "authorization",
+            "cookie",
+            "proxy-authorization",
+            "set-cookie",
+        ],
+    },
+    capture: {
+        after_each_step: ["screenshot", "url", "accessibility"],
+        at_end: ["dom", "history", "storage"],
+        events: ["console", "page-errors", "network", "websockets"],
+    },
+    limits: {
+        max_duration_ms: 60_000,
+        action_timeout_ms: 5_000,
+        navigation_timeout_ms: 10_000,
+        max_events: 2_000,
+        max_frames: 100,
+        max_workers: 20,
+        max_popups: 10,
+        max_websockets: 100,
+        max_dom_nodes: 10_000,
+        max_accessibility_nodes: 10_000,
+        max_screenshots: 16,
+        max_screenshot_bytes: 4_194_304,
+        max_storage_entries: 256,
+        max_total_metadata_bytes: 4_194_304,
+    },
+    approved: true,
+};
+/** Controlled browser scenario contract shared by MCP and catalog generation. */
+export const BROWSER_SCENARIO_TOOL_CONTRACTS = [
+    {
+        name: "capture_browser_scenario",
+        ...toolContractMetadata("capture_browser_scenario"),
+        description: "Run one approved, bounded browser scenario through Playwright. Launch mode owns and terminates a temporary browser profile; connect mode attaches to one exact loopback CDP target and disconnects without terminating the external browser. Only the fixed action vocabulary is accepted. Navigation, storage, requests, redirects, secrets, redaction, captures, and limits must be declared before execution. Returns step-indexed Evidence with screenshots, DOM, accessibility, URL/history/storage state, runtime events, explicit missing/truncated sections, and equality eligibility.",
+        kind: "browser-provider",
+        inputSchema: browserScenarioSchema,
+        outputSchema: evidenceResultOf(browserScenarioCaptureSchema),
+        examples: [
+            { title: "Capture a deterministic browser scenario", input: example },
+        ],
+    },
+];

package/dist/contracts/browserToolContracts.js

@@ -2,7 +2,7 @@ import { browserTargetListSchema, inspectWebPageInputSchema, listBrowserTargetsI
 import { analyzeWebBundleInputSchema, webBundleAnalysisSchema, } from "../domain/webBundleAnalysis.js";
 import { observeWebSessionInputSchema, webObservationSessionSchema, } from "../domain/browserSession.js";
 import { discoverWebMcpToolsInputSchema, webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
-import { compareWebCapturesInputSchema, webCaptureDiffSchema, } from "../domain/webCaptureDiff.js";
+import { browserCaptureComparisonWireSchema, browserCaptureComparisonSchema, } from "../domain/browserCaptureComparison.js";
 import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { evidenceResultOf } from "./toolOutputSchemas.js";
@@ -12,11 +12,81 @@ const inspectionOutputSchema = evidenceResult(webPageInspectionSchema);
 const bundleOutputSchema = evidenceResult(webBundleAnalysisSchema);
 const observationSessionOutputSchema = evidenceResult(webObservationSessionSchema);
 const webMcpOutputSchema = evidenceResult(webMcpDiscoverySchema);
-const captureDiffOutputSchema = evidenceResult(webCaptureDiffSchema);
+const captureDiffOutputSchema = evidenceResult(browserCaptureComparisonSchema);
 const screenshotOutputSchema = evidenceResult(webScreenshotSchema);
 const screenshotDiffOutputSchema = evidenceResult(webScreenshotDiffSchema);
 const endpoint = "http://127.0.0.1:9222";
 const origin = "https://app.example.test";
+const scenarioUrl = {
+    url: `${origin}/`,
+    origin,
+    query_parameter_names: [],
+    redacted: false,
+};
+const scenarioCompleteness = {
+    status: "complete",
+    equality_eligible: true,
+    missing_sections: [],
+    truncated_sections: [],
+};
+const scenarioArtifacts = {
+    screenshot: { state: "not_requested" },
+    dom: { state: "not_requested" },
+    accessibility: { state: "not_requested" },
+    url: { state: "not_requested" },
+    history: { state: "not_requested" },
+    storage: { state: "not_requested" },
+};
+const exampleScenarioCapture = () => ({
+    schema_version: 1,
+    browser: {
+        mode: "connect",
+        process_ownership: "external",
+        cleanup: "disconnected-external",
+        product: "Chromium",
+        version: "149",
+    },
+    scenario: {
+        start_origin: origin,
+        allowed_origins: [origin],
+        action_count: 1,
+        secret_references: [],
+    },
+    duration_ms: 10,
+    steps: [
+        {
+            step_index: 0,
+            step_id: "scenario_start",
+            action: "scenario_start",
+            status: "completed",
+            elapsed_ms: 0,
+            before_url: scenarioUrl,
+            after_url: scenarioUrl,
+            error: null,
+            event_sequence_start: 1,
+            event_sequence_end: 0,
+            artifacts: scenarioArtifacts,
+            completeness: scenarioCompleteness,
+        },
+        {
+            step_index: 1,
+            step_id: "open-settings",
+            action: "click",
+            status: "completed",
+            elapsed_ms: 10,
+            before_url: scenarioUrl,
+            after_url: scenarioUrl,
+            error: null,
+            event_sequence_start: 1,
+            event_sequence_end: 0,
+            artifacts: scenarioArtifacts,
+            completeness: scenarioCompleteness,
+        },
+    ],
+    events: { retained: 0, dropped: 0, items: [] },
+    completeness: scenarioCompleteness,
+    limitations: [],
+});
 /** Origin-scoped, passive browser reverse-engineering contracts. */
 export const BROWSER_TOOL_CONTRACTS = [
     {
@@ -64,6 +134,7 @@ export const BROWSER_TOOL_CONTRACTS = [
                     websocket_shape_approved: false,
                     include_script_sources: false,
                     include_storage_keys: false,
+                    include_storage_fingerprints: false,
                     limits: {
                         max_frames: 200,
                         max_dom_nodes: 2_000,
@@ -175,16 +246,26 @@ export const BROWSER_TOOL_CONTRACTS = [
     {
         name: "compare_web_captures",
         ...toolContractMetadata("compare_web_captures"),
-        description: "Compare two normalized web captures across DOM, scripts, resources, network, safe metadata, and optional WebMCP inventories. Stable observed changes are distinguished from unknown absence caused by incomplete capture coverage.",
+        description: "Compare either passive web captures or step-indexed browser scenarios. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and exposes bounded artifact-level changes plus alignment failures. Missing or truncated evidence never proves equality.",
         kind: "browser-provider",
-        inputSchema: compareWebCapturesInputSchema,
+        inputSchema: browserCaptureComparisonWireSchema,
         outputSchema: captureDiffOutputSchema,
         examples: [
             {
-                title: "Compare two normalized captures",
+                title: "Compare two recorded browser scenarios",
                 input: {
-                    before: { inspection: exampleInspection() },
-                    after: { inspection: exampleInspection() },
+                    before_scenario: exampleScenarioCapture(),
+                    after_scenario: exampleScenarioCapture(),
+                    normalization: {
+                        rules: [
+                            {
+                                rule_id: "volatile-build-id",
+                                artifacts: ["dom", "accessibility"],
+                                match: "build-123",
+                                replacement: "[BUILD_ID]",
+                            },
+                        ],
+                    },
                     max_changes: 2_000,
                 },
             },
@@ -231,97 +312,6 @@ export const BROWSER_TOOL_CONTRACTS = [
         ],
     },
 ];
-function exampleCompleteness() {
-    return {
-        status: "complete_within_window",
-        conditions: ["complete_within_window"],
-        policy_filtered_sections: [],
-        attach_limited_sections: [],
-        truncated_sections: [],
-        unavailable_sections: [],
-        excluded: [],
-        dropped_events: {
-            scripts: 0,
-            network_requests: 0,
-            console_events: 0,
-            websocket_connections: 0,
-            websocket_frames: 0,
-            webmcp_tools: 0,
-            timeline_events: 0,
-            total: 0,
-        },
-    };
-}
-function exampleInspection() {
-    return {
-        schema_version: 2,
-        browser: {
-            product: "Chrome/1",
-            protocol_version: "1.3",
-            revision: "example",
-            user_agent: "Chrome",
-            js_version: "1",
-        },
-        target: {
-            target_id: "page-1",
-            type: "page",
-            title: "Example",
-            url: `${origin}/`,
-            origin,
-            attached: false,
-        },
-        capture_window: {
-            started_at: "2026-07-14T00:00:00.000Z",
-            ended_at: "2026-07-14T00:00:01.000Z",
-            observation_ms: 1_000,
-        },
-        completeness: exampleCompleteness(),
-        frames: [],
-        dom: { total_nodes: 0, nodes: [] },
-        accessibility: {
-            total_nodes: 0,
-            text_capture: {
-                status: "not_approved",
-                retained_bytes: 0,
-                excluded_fields: 0,
-                truncated_fields: 0,
-            },
-            nodes: [],
-        },
-        scripts: { total: 0, items: [] },
-        resources: [],
-        network: {
-            requests: [],
-            websocket_events: [],
-            coverage_started_at: "2026-07-14T00:00:00.000Z",
-            prior_activity_available: false,
-        },
-        console: {
-            events: [],
-            coverage_started_at: "2026-07-14T00:00:00.000Z",
-            prior_activity_available: false,
-        },
-        workers: [],
-        metadata: {
-            responses: [],
-            dom_urls: [],
-            agent_hints: [],
-            excluded_dom_urls: 0,
-            headers_allowlisted: true,
-        },
-        storage: {
-            origin,
-            usage_bytes: null,
-            quota_bytes: null,
-            local_storage_keys: [],
-            session_storage_keys: [],
-            indexed_db_names: [],
-            cache_names: [],
-            values_redacted: true,
-        },
-        limitations: [],
-    };
-}
 function exampleScreenshot() {
     return {
         uri: "rea://web-screenshot/sha256/153cf6c9a526a63053a37b10234c2fd85df38887c2dc0a800d90abfa6631d01c",

package/dist/contracts/enhancedInputs.js

@@ -1,4 +1,14 @@
 import { z } from "zod";
+const traceLiteralInputSchema = z.object({
+    query: z.string().min(1),
+    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"),
+});
 /** Input schemas shared by MCP registration and enhanced application dispatch. */
 export const enhancedInputSchemas = {
     swift_classes: z.object({ pattern: z.string().default("") }),
@@ -51,18 +61,25 @@ export const enhancedInputSchemas = {
             basic_blocks: 0,
         }),
     }),
-    trace_feature: z.object({
-        query: z.string().min(1),
-        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),
+    trace_feature: traceLiteralInputSchema,
+    find_code_for_string: traceLiteralInputSchema,
+    trace_call_path: z.object({
+        start: z.string().describe("A provider-normalized procedure address"),
+        goal: z
+            .string()
+            .describe("An optional provider-normalized destination address")
+            .optional(),
+        direction: z.enum(["forward", "backward"]).default("forward"),
+        max_depth: z.number().int().min(1).max(10).default(5),
+        max_nodes: z.number().int().min(1).max(500).default(100),
+        max_operations: z.number().int().min(1).max(500).default(100),
         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. */
+/** Runtime parser for dispatching only the closed enhanced names. */
 export const enhancedToolNameSchema = z.enum([
     "swift_classes",
     "get_objc_classes",
@@ -74,4 +91,6 @@ export const enhancedToolNameSchema = z.enum([
     "binary_overview",
     "analyze_function",
     "trace_feature",
+    "find_code_for_string",
+    "trace_call_path",
 ]);

package/dist/contracts/functionInstructionContract.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+/** Provider-neutral input for one bounded raw function-instruction window. */
+export const functionInstructionInputSchema = z.object({
+    procedure: z.string().describe("The procedure name or address"),
+    offset: z.number().int().min(0).max(100_000).default(0),
+    limit: z.number().int().min(1).max(500).default(64),
+    document: z.string().optional().describe("The document name"),
+});

package/dist/contracts/hopperMemoryContracts.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+const document = z.string().optional().describe("The document name");
+const address = z
+    .string()
+    .describe("A provider-normalized address; default memory uses 0x-prefixed hexadecimal");
+/** Bounded Hopper memory and file-mapping contracts. */
+export const HOPPER_MEMORY_TOOL_DEFINITIONS = [
+    {
+        name: "read_bytes",
+        description: "Read at most 4,096 analyzed bytes from one provider-normalized virtual address. The hexadecimal payload reports the exact returned length; incomplete reads remain explicit and unsupported provider APIs return typed capability unavailability.",
+        inputSchema: z.object({
+            address,
+            length: z.number().int().min(1).max(4_096).default(256),
+            document,
+        }),
+    },
+    {
+        name: "address_to_file_offset",
+        description: "Map one provider-normalized virtual address to its original nonnegative file offset. Unmapped addresses fail explicitly, and providers without an authoritative mapping API return typed capability unavailability.",
+        inputSchema: z.object({ address, document }),
+    },
+];

package/dist/contracts/javascriptApplicationWorkflowExamples.js

@@ -1,6 +1,7 @@
 import { createEvidence } from "../domain/evidence.js";
 import { reconcileJavaScriptRuntime } from "../domain/javascriptRuntimeReconciliation.js";
 import { JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE, JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE, } from "./javascriptRuntimeReconciliationExample.js";
+import { createHistoricalSourceGraph } from "../domain/referenceSourceGraph.js";
 const reconciliation = reconcileJavaScriptRuntime(JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE);
 const reconciliationEvidence = createEvidence(undefined, {
     id: "rea-javascript-runtime-reconciliation",
@@ -47,6 +48,47 @@ export const JAVASCRIPT_APPLICATION_VERSION_COMPARISON_EXAMPLE = {
     left_evidence_id: EXAMPLE_EVIDENCE_ID,
     right_evidence_id: SECOND_EXAMPLE_EVIDENCE_ID,
 };
+/** Historical source inventory compared with one producer-returned graph ID. */
+export const SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE = {
+    reference: createHistoricalSourceGraph({
+        schema: "HistoricalSourceGraph/v1",
+        authority: "historical-reference",
+        root_alias: "$REFERENCE_ROOT",
+        inventory_state: "complete",
+        entries: [
+            {
+                path: "src",
+                kind: "directory",
+                classifications: ["source"],
+                tree_state: "enumerated",
+                limitations: [],
+            },
+            {
+                path: "src/main.ts",
+                kind: "file",
+                sha256: "2".repeat(64),
+                size: 128,
+                language: "TypeScript",
+                classifications: ["source"],
+                content_state: "hashed",
+                limitations: [],
+            },
+        ],
+        relationships: [],
+        parse_failures: [],
+        exclusions: [],
+        languages: ["TypeScript"],
+        manifests: [],
+        vcs: { kind: "none", head: null, dirty: null },
+        provenance: {
+            importer: "rea",
+            importer_version: "1",
+            caller: "contract-example",
+        },
+        limitations: [],
+    }),
+    application_evidence_id: EXAMPLE_EVIDENCE_ID,
+};
 /** Exact static return-shape comparison using producer-returned Evidence IDs. */
 export const JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE = {
     left_evidence_id: EXAMPLE_EVIDENCE_ID,

package/dist/contracts/javascriptRuntimeObservationToolContracts.js

@@ -0,0 +1,58 @@
+import { toolContractMetadata } from "./toolEffects.js";
+import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { javascriptRuntimeObservationSchema, javascriptRuntimeTargetListSchema, listJavaScriptRuntimeTargetsInputSchema, observeJavaScriptRuntimeInputSchema, } from "../domain/javascriptRuntimeObservation.js";
+const root = "/opt/example-app";
+const endpoint = "http://127.0.0.1:9229";
+/** Passive Node/Electron V8 Inspector discovery and observation contracts. */
+export const JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS = [
+    {
+        name: "list_javascript_runtime_targets",
+        ...toolContractMetadata("list_javascript_runtime_targets"),
+        description: "List attachable Node/Electron V8 Inspector targets from one approved literal-loopback endpoint. Only targets inside exact canonical file roots or exact HTTP(S) origins are retained; excluded target locations never enter Evidence.",
+        kind: "runtime-provider",
+        inputSchema: listJavaScriptRuntimeTargetsInputSchema,
+        outputSchema: evidenceResultOf(javascriptRuntimeTargetListSchema),
+        examples: [
+            {
+                title: "List approved Node Inspector targets",
+                input: {
+                    inspector_endpoint: endpoint,
+                    allowed_file_roots: [root],
+                    allowed_origins: [],
+                    approved: true,
+                    offset: 0,
+                    limit: 100,
+                },
+            },
+        ],
+    },
+    {
+        name: "observe_javascript_runtime",
+        ...toolContractMetadata("observe_javascript_runtime"),
+        description: "Attach passively to one exact approved Node/Electron V8 Inspector target and capture bounded Debugger.scriptParsed plus Runtime execution-context events. REA sends only Runtime.enable and Debugger.enable: it never evaluates, pauses, resumes, reads source, or instruments the target. require/import edges, EventEmitter activity, and Electron IPC remain explicit unknowns; reconcile the returned Evidence with static Application Graph Evidence using reconcile_javascript_runtime.",
+        kind: "runtime-provider",
+        inputSchema: observeJavaScriptRuntimeInputSchema,
+        outputSchema: evidenceResultOf(javascriptRuntimeObservationSchema),
+        examples: [
+            {
+                title: "Observe one approved Node runtime",
+                input: {
+                    inspector_endpoint: endpoint,
+                    allowed_file_roots: [root],
+                    allowed_origins: [],
+                    target_id: "TARGET_ID_FROM_LIST_JAVASCRIPT_RUNTIME_TARGETS",
+                    runtime_kind: "node",
+                    approved: true,
+                    observation_ms: 100,
+                    limits: {
+                        max_events: 10_000,
+                        max_scripts: 2_000,
+                        max_execution_contexts: 1_000,
+                        max_location_bytes: 16_384,
+                        max_total_metadata_bytes: 4_194_304,
+                    },
+                },
+            },
+        ],
+    },
+];