rea-agents 6.1.0 → 6.3.0

package/dist/contracts/artifactComparisonExample.js

@@ -1,20 +1,18 @@
-import { canonicalDigest } from "../domain/comparisonSemantics.js";
+import { digestCanonicalValue } from "../domain/canonicalDigest.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 const inventory = (digit) => {
     const sha = digit.repeat(64);
-    const artifactId = `art_${canonicalDigest({ sha256: sha }, "Artifact example")}`;
-    const occurrenceId = `occ_${canonicalDigest({ root: artifactId }, "Artifact example")}`;
+    const artifactId = `art_${digestCanonicalValue({ sha256: sha }, "Artifact example")}`;
+    const occurrenceId = `occ_${digestCanonicalValue({ root: artifactId }, "Artifact example")}`;
     const nodes = [
         {
             artifact_id: artifactId,
-            kind: "resource",
             format: "file",
             sha256: sha,
             size: 1,
             media_type: null,
             architecture: null,
-            executable: false,
             content_state: "materialized",
             limitations: [],
         },
@@ -26,6 +24,8 @@ const inventory = (digit) => {
             parent_occurrence_id: null,
             logical_path: ".",
             entry_kind: "file",
+            artifact_kind: "resource",
+            artifact_format: "file",
             declared_size: 1,
             compressed_size: null,
             executable: false,
@@ -35,7 +35,7 @@ const inventory = (digit) => {
             limitations: [],
         },
     ];
-    const graphSha256 = canonicalDigest({
+    const graphSha256 = digestCanonicalValue({
         nodes,
         occurrences,
         edges: [],
@@ -43,7 +43,7 @@ const inventory = (digit) => {
     }, "Artifact example");
     return jsonValueSchema.parse({
         manifest: {
-            manifest_id: `agm_${canonicalDigest({
+            manifest_id: `agm_${digestCanonicalValue({
                 root_artifact_id: artifactId,
                 graph_sha256: graphSha256,
             }, "Artifact example")}`,

package/dist/contracts/artifactToolContracts.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { artifactOutputSchemas } from "./toolOutputSchemas.js";
+import { artifactOutputSchemas } from "./toolOutputSchemaGroups.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";

package/dist/contracts/browserScenarioToolContracts.js

@@ -1,5 +1,5 @@
 import { toolContractMetadata } from "./toolEffects.js";
-import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
 import { browserScenarioInputSchema } from "../domain/browserScenario.js";
 import { browserScenarioCaptureSchema } from "../domain/browserScenarioCapture.js";
 const example = {

package/dist/contracts/browserToolContracts.js

@@ -1,21 +1,20 @@
-import { browserTargetListSchema, inspectWebPageInputSchema, listBrowserTargetsInputSchema, webPageInspectionSchema, } from "../domain/browserObservation.js";
+import { inspectWebPageInputSchema, listBrowserTargetsInputSchema, } from "../domain/browserObservation.js";
+import { browserTargetListSchema, webPageInspectionSchema, } from "../domain/browserObservationSchemas.js";
 import { analyzeWebBundleInputSchema, webBundleAnalysisSchema, } from "../domain/webBundleAnalysis.js";
 import { observeWebSessionInputSchema, webObservationSessionSchema, } from "../domain/browserSession.js";
 import { discoverWebMcpToolsInputSchema, webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
-import { browserCaptureComparisonSchema } from "../domain/browserCaptureComparison.js";
+import { browserCaptureComparisonInputSchema, browserCaptureComparisonSchema, } from "../domain/browserCaptureComparison.js";
 import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
 import { toolContractMetadata } from "./toolEffects.js";
-import { evidenceResultOf } from "./toolOutputSchemas.js";
-import { browserCaptureToolInputSchema } from "./browserCaptureToolInputSchema.js";
-const evidenceResult = evidenceResultOf;
-const listOutputSchema = evidenceResult(browserTargetListSchema);
-const inspectionOutputSchema = evidenceResult(webPageInspectionSchema);
-const bundleOutputSchema = evidenceResult(webBundleAnalysisSchema);
-const observationSessionOutputSchema = evidenceResult(webObservationSessionSchema);
-const webMcpOutputSchema = evidenceResult(webMcpDiscoverySchema);
-const captureDiffOutputSchema = evidenceResult(browserCaptureComparisonSchema);
-const screenshotOutputSchema = evidenceResult(webScreenshotSchema);
-const screenshotDiffOutputSchema = evidenceResult(webScreenshotDiffSchema);
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
+const listOutputSchema = evidenceResultOf(browserTargetListSchema);
+const inspectionOutputSchema = evidenceResultOf(webPageInspectionSchema);
+const bundleOutputSchema = evidenceResultOf(webBundleAnalysisSchema);
+const observationSessionOutputSchema = evidenceResultOf(webObservationSessionSchema);
+const webMcpOutputSchema = evidenceResultOf(webMcpDiscoverySchema);
+const captureDiffOutputSchema = evidenceResultOf(browserCaptureComparisonSchema);
+const screenshotOutputSchema = evidenceResultOf(webScreenshotSchema);
+const screenshotDiffOutputSchema = evidenceResultOf(webScreenshotDiffSchema);
 const endpoint = "http://127.0.0.1:9222";
 const origin = "https://app.example.test";
 const scenarioUrl = {
@@ -50,6 +49,11 @@ const exampleScenarioCapture = () => ({
         start_origin: origin,
         action_count: 1,
         secret_references: [],
+        network_content: {
+            request_body: false,
+            response_body: false,
+            header_values: false,
+        },
     },
     duration_ms: 10,
     steps: [
@@ -182,9 +186,9 @@ export const BROWSER_TOOL_CONTRACTS = [
     {
         name: "compare_web_captures",
         ...toolContractMetadata("compare_web_captures"),
-        description: "Compare passive web captures by providing before and after, each with the complete inspect_web_page result in inspection and an optional complete discover_webmcp_tools result in webmcp; or compare recorded scenarios by passing complete capture_browser_scenario results in before_scenario and after_scenario with an optional normalization policy. Use exactly one input group. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and returns every artifact-level difference plus alignment failures inline. Missing or truncated evidence never proves equality.",
+        description: "Compare passive web captures by providing before and after, each with the complete inspect_web_page normalized_result in inspection and an optional complete discover_webmcp_tools normalized_result in webmcp; or compare recorded scenarios by passing complete capture_browser_scenario normalized_result objects in before_scenario and after_scenario with an optional normalization policy. Use exactly one input group. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and returns every artifact-level difference plus alignment failures inline. Missing or truncated evidence never proves equality.",
         kind: "browser-provider",
-        inputSchema: browserCaptureToolInputSchema,
+        inputSchema: browserCaptureComparisonInputSchema,
         outputSchema: captureDiffOutputSchema,
         examples: [
             {

package/dist/contracts/enhancedInputs.js

@@ -27,11 +27,11 @@ export const enhancedInputSchemas = {
         category: z
             .enum(["classes", "structs", "enums", "protocols", "extensions", "other"])
             .optional()
-            .describe("Limit results to one Swift symbol category."),
+            .describe("Limit categorized results to one Swift category; unresolved category observations remain in unclassified."),
         pattern: z
             .string()
             .optional()
-            .describe("Case-sensitive literal filter applied to mangled symbol names."),
+            .describe("Case-sensitive literal filter applied to provider procedure names and their supporting Swift manglings."),
     }),
     find_xrefs_to_name: z.strictObject({ name: z.string() }),
     binary_overview: z.strictObject({}),

package/dist/contracts/enhancedToolContracts.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { enhancedInputSchemas } from "./enhancedInputs.js";
-import { enhancedOutputSchemas, requireOutputSchema, } from "./toolOutputSchemas.js";
+import { enhancedOutputSchemas } from "./toolOutputSchemaGroups.js";
+import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
 import { examplesFor } from "./toolContractHelpers.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { FUNCTION_WORKFLOW_TOOL_CONTRACTS } from "./functionWorkflowToolContracts.js";
@@ -18,9 +19,9 @@ export const ENHANCED_TOOL_CONTRACTS = [
     enhanced("inspect_native_dispatch_metadata", "Inspect the bound provider's name inventory for Objective-C class/method symbols and Swift mangled symbols, returning at most max_records decoded names. Includes target SHA-256 when available, provider identity/version, analysis-profile digest, facet coverage, and per-record Evidence. This is symbol-level evidence, not runtime metadata: ivar layouts, protocol conformances, witness/class tables, and relative pointers are explicitly marked unsupported unless a provider supplies those decoders. The provider controls how its name inventory is acquired.", enhancedInputSchemas.inspect_native_dispatch_metadata),
     enhanced("get_objc_classes", "Discover and deduplicate Objective-C class labels, optionally filtering by literal substring.", enhancedInputSchemas.get_objc_classes),
     enhanced("get_objc_protocols", "Discover and deduplicate Objective-C and Swift protocol labels.", enhancedInputSchemas.get_objc_protocols),
-    enhanced("batch_decompile", "Decompile each explicit procedure symbol or address concurrently. Returns ordered per-item success or error results and aggregate counts.", enhancedInputSchemas.batch_decompile),
+    enhanced("batch_decompile", "Decompile each explicit procedure symbol or address concurrently. Preserves each input selector in address and reports the observed canonical entry and entry label in procedure; identity or label failures remain explicit without discarding usable pseudocode. Returns ordered per-item success or error results and aggregate counts.", enhancedInputSchemas.batch_decompile),
     enhanced("get_call_graph", "Resolve one symbol or address to its canonical procedure entry, then traverse the bound provider's caller or callee relationships until the reachable graph is exhausted. Every node uses a canonical address and has an ok/error status; failures use safe typed projections. Unresolved indirect calls may be missing and results are not a whole-program CFG.", enhancedInputSchemas.get_call_graph),
-    enhanced("analyze_swift_types", 'Categorize analyzed procedure names into Swift classes, structs, enums, protocols, extensions, and other symbols. Returns deduplicated names grouped with counts. Optionally select one category and/or apply a case-sensitive literal name filter; for example, use {category: "classes", pattern: "Account"} to find matching class symbols.', enhancedInputSchemas.analyze_swift_types),
+    enhanced("analyze_swift_types", 'Categorize analyzed Swift procedure names using their manglings or same-address Swift symbol aliases. Decodes legacy and literal modern nominal contexts into classes, structs, enums, protocols, and extensions. Preserves provider names and supporting mangled_names; unresolved categories appear in other and in unclassified, which remains inline even under category filters. Returns deduplicated procedure-name counts, not unique source types, plus identification limitations. Optionally select one category and/or apply a case-sensitive literal filter to provider names or supporting manglings; for example, use {category: "structs", pattern: "Pair"}.', enhancedInputSchemas.analyze_swift_types),
     enhanced("find_xrefs_to_name", "Resolve an exact name against the bound provider's name inventory and return a resolved or unresolved result. Unresolved names use the stable name_not_found reason; this xref workflow returns address-only projections.", enhancedInputSchemas.find_xrefs_to_name),
     enhanced("binary_overview", "Return native-binary metadata, every segment with its length, and exhaustive procedure/string counts. Use search_procedures, list_procedures, or analyze_function directly when you already know which procedure to inspect.", enhancedInputSchemas.binary_overview),
     ...FUNCTION_WORKFLOW_TOOL_CONTRACTS,

package/dist/contracts/errorSchemas.js

@@ -68,7 +68,9 @@ export const analysisCliErrorEnvelopeSchema = z
     .object({
     error: z.string().min(1),
     input_path: z.string().optional(),
-    input_reason: z.enum(["invalid-json", "read-failed"]).optional(),
+    input_reason: z
+        .enum(["invalid-json", "read-failed", "too-large"])
+        .optional(),
 })
     .passthrough()
     .superRefine((value, context) => {

package/dist/contracts/evm/evmToolContracts.js

@@ -1,6 +1,6 @@
 import { inspectEvmInterfaceInputSchema, evmInterfaceSchema, } from "../../domain/evm/evmInterface.js";
 import { toolContractMetadata } from "../toolEffects.js";
-import { evidenceResultOf } from "../toolOutputSchemas.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
 /** Target-free EVM capabilities are independent of archive/Apple artifact providers. */
 export const EVM_TOOL_CONTRACTS = [
     {

package/dist/contracts/functionComparisonExample.js

@@ -5,6 +5,11 @@ const dossier = (text) => jsonValueSchema.parse({
     procedure: {
         address: "0x1000",
         name: "main",
+        classification: null,
+        body: {
+            available: false,
+            reason: "The fixture omits function-body extent observations.",
+        },
         signature: "int main(void)",
         locals: [],
     },
@@ -18,6 +23,9 @@ const dossier = (text) => jsonValueSchema.parse({
     referenced_strings: [],
     referenced_names: [],
     basic_blocks: [{ start: "0x1000", end: "0x1001", successors: [] }],
+    native_api: null,
+    native_value_flow: null,
+    limitations: ["The fixture omits native API and value-flow observations."],
 });
 const observe = (digit, text) => createEvidence({
     path: `/tmp/function-${digit}`,

package/dist/contracts/functionWorkflowToolContracts.js

@@ -2,7 +2,7 @@ import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { enhancedInputSchemas } from "./enhancedInputs.js";
 import { TOOL_EXAMPLE_OVERRIDES } from "./toolContractExamples.js";
 import { toolContractMetadata } from "./toolEffects.js";
-import { enhancedOutputSchemas } from "./toolOutputSchemas.js";
+import { enhancedOutputSchemas } from "./toolOutputSchemaGroups.js";
 import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
 const functionWorkflow = (name, description) => {
     const inputSchema = enhancedInputSchemas[name];

package/dist/contracts/inputSchemaPresentation.js

@@ -0,0 +1,181 @@
+import { isDeepStrictEqual } from "node:util";
+const schemaMaps = new Set([
+    "$defs",
+    "definitions",
+    "properties",
+    "patternProperties",
+    "dependentSchemas",
+    "dependencies",
+]);
+const schemaArrays = new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+const schemaChildren = new Set([
+    "items",
+    "additionalItems",
+    "contains",
+    "additionalProperties",
+    "unevaluatedProperties",
+    "unevaluatedItems",
+    "propertyNames",
+    "not",
+    "if",
+    "then",
+    "else",
+]);
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const resolveReference = (root, reference) => {
+    if (!reference.startsWith("#/"))
+        return undefined;
+    let value = root;
+    for (const token of reference.slice(2).split("/")) {
+        const key = token.replaceAll("~1", "/").replaceAll("~0", "~");
+        if (!isObject(value) || !Object.hasOwn(value, key))
+            return undefined;
+        value = value[key];
+    }
+    return value;
+};
+const referencedDescription = (root, schema) => {
+    let value = schema;
+    const active = new Set();
+    while (isObject(value)) {
+        if (typeof value.description === "string")
+            return value.description;
+        if (typeof value.$ref !== "string" || active.has(value.$ref))
+            return undefined;
+        active.add(value.$ref);
+        value = resolveReference(root, value.$ref);
+    }
+    return undefined;
+};
+const describeSchema = (schema, root, describeProperty) => {
+    if (!isObject(schema))
+        return schema;
+    return Object.fromEntries(Object.entries(schema).map(([key, value]) => {
+        if (schemaMaps.has(key) && isObject(value))
+            return [
+                key,
+                Object.fromEntries(Object.entries(value).map(([name, child]) => {
+                    const described = describeSchema(child, root, describeProperty);
+                    return [
+                        name,
+                        key === "properties" && isObject(described)
+                            ? {
+                                ...described,
+                                description: referencedDescription(root, described) ??
+                                    describeProperty(name),
+                            }
+                            : described,
+                    ];
+                })),
+            ];
+        if (schemaArrays.has(key) && Array.isArray(value))
+            return [
+                key,
+                value.map((child) => describeSchema(child, root, describeProperty)),
+            ];
+        if (schemaChildren.has(key))
+            return [
+                key,
+                Array.isArray(value)
+                    ? value.map((child) => describeSchema(child, root, describeProperty))
+                    : describeSchema(value, root, describeProperty),
+            ];
+        // Annotation values and literal const/enum data are not schemas.
+        return [key, value];
+    }));
+};
+const objectBranch = (root, branch) => {
+    // Reference siblings evaluate separately from the target in 2020-12, so a
+    // merged object could accept inputs the branch rejects.
+    const resolved = isObject(branch) && typeof branch.$ref === "string"
+        ? Object.keys(branch).length === 1
+            ? resolveReference(root, branch.$ref)
+            : undefined
+        : branch;
+    return isObject(resolved) &&
+        resolved.type === "object" &&
+        isObject(resolved.properties)
+        ? resolved
+        : undefined;
+};
+const requiredProperties = (branch) => Array.isArray(branch.required)
+    ? branch.required.filter((name) => typeof name === "string")
+    : [];
+const sharedRequiredProperties = (branches) => {
+    const [first = [], ...others] = branches.map(requiredProperties);
+    return first.filter((name) => others.every((names) => names.includes(name)));
+};
+const inputGroup = (branch) => {
+    const required = requiredProperties(branch);
+    const optional = Object.keys(branch.properties ?? {})
+        .filter((name) => !required.includes(name))
+        .map((name) => `[${name}]`);
+    return [...required, ...optional].join(" + ");
+};
+// Anthropic tool input schemas reject anyOf, oneOf, and allOf at the root, and
+// clients then drop the tool or advertise it without parameters. Present a
+// root union of strict object groups as one object whose properties are the
+// union of the groups. The canonical Zod schema still enforces the exact group.
+const flattenRootObjectUnion = (root) => {
+    const { anyOf, oneOf, ...rest } = root;
+    const alternatives = Array.isArray(anyOf) ? anyOf : oneOf;
+    if (!Array.isArray(alternatives) ||
+        alternatives.length === 0 ||
+        root.properties !== undefined)
+        return root;
+    const branches = alternatives.map((branch) => objectBranch(root, branch));
+    if (!branches.every((branch) => branch !== undefined))
+        return root;
+    const variants = new Map();
+    for (const branch of branches)
+        for (const [name, schema] of Object.entries(branch.properties ?? {})) {
+            const known = variants.get(name) ?? [];
+            if (!known.some((seen) => isDeepStrictEqual(seen, schema)))
+                known.push(schema);
+            variants.set(name, known);
+        }
+    const required = sharedRequiredProperties(branches);
+    // A field unique to a group still needs that group's required partners.
+    // Counting properties alone would let optional fields pad an incomplete pair.
+    const dependencies = Object.fromEntries([...variants.keys()].flatMap((name) => {
+        const owners = branches.filter((branch) => Object.hasOwn(branch.properties ?? {}, name));
+        const partners = sharedRequiredProperties(owners).filter((partner) => partner !== name && !required.includes(partner));
+        return partners.length > 0 ? [[name, partners]] : [];
+    }));
+    const fewestRequired = Math.min(...branches.map((branch) => requiredProperties(branch).length));
+    // Groups that differ only in property values add no caller guidance.
+    const groups = [...new Set(branches.map(inputGroup))];
+    const description = [
+        typeof rest.description === "string" ? rest.description : undefined,
+        groups.length > 1
+            ? `Provide a complete input group: ${groups.join("; ")}.`
+            : undefined,
+    ].filter((text) => text !== undefined);
+    return {
+        ...rest,
+        type: "object",
+        ...(description.length > 0 ? { description: description.join(" ") } : {}),
+        properties: Object.fromEntries([...variants].map(([name, schemas]) => [
+            name,
+            schemas.length === 1 ? schemas[0] : { anyOf: schemas },
+        ])),
+        ...(required.length > 0 ? { required } : {}),
+        ...(fewestRequired > 0 ? { minProperties: fewestRequired } : {}),
+        ...(Object.keys(dependencies).length > 0
+            ? {
+                [root.$schema === "http://json-schema.org/draft-07/schema#"
+                    ? "dependencies"
+                    : "dependentRequired"]: dependencies,
+            }
+            : {}),
+        ...(branches.every((branch) => branch.additionalProperties === false)
+            ? { additionalProperties: false }
+            : {}),
+    };
+};
+/** Describe canonical input fields and present the root as one object. */
+export const presentInputJsonSchema = (root, describeProperty) => {
+    const flattened = flattenRootObjectUnion(root);
+    const described = describeSchema(flattened, flattened, describeProperty);
+    return isObject(described) ? described : flattened;
+};

package/dist/contracts/investigationExamples.js

@@ -1,9 +1,10 @@
-import { compareFunctions } from "../domain/functionComparison.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { compareProcessCaptures, parseProcessCapture, } from "../domain/process/processCapture.js";
+import { compareProcessCaptures } from "../domain/process/processComparison.js";
+import { parseProcessCapture } from "../domain/process/processCaptureParsing.js";
 import { FUNCTION_COMPARISON_EXAMPLE } from "./functionComparisonExample.js";
-import { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "./process/processCaptureExample.js";
+import { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "../domain/process/processCaptureExample.js";
+import { compareFunctions } from "../domain/functionComparison.js";
 const comparison = compareFunctions(FUNCTION_COMPARISON_EXAMPLE.left, FUNCTION_COMPARISON_EXAMPLE.right);
 export const FUNCTION_COMPARISON_EVIDENCE = createEvidence(undefined, {
     id: "rea-function-comparison",

package/dist/contracts/javascript/electronToolContracts.js

@@ -1,5 +1,5 @@
 import { toolContractMetadata } from "../toolEffects.js";
-import { evidenceResultOf } from "../toolOutputSchemas.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
 import { electronPageInspectionSchema, electronTargetListSchema, inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "../../domain/javascript/electronObservation.js";
 import { electronActiveObservationInputSchema, electronActiveObservationResultSchema, } from "../../domain/javascript/electronActiveObservation.js";
 import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../../domain/javascript/javascriptApplicationAnalysis.js";
@@ -54,7 +54,7 @@ export const ELECTRON_TOOL_CONTRACTS = [
     {
         name: "analyze_javascript_application",
         ...toolContractMetadata("analyze_javascript_application"),
-        description: "Reconstruct one local ASAR or extracted JavaScript application as an inline application graph without executing it. Returns all recovered graph nodes, edges, semantic relations, limitations, and coverage.",
+        description: "Reconstruct one local ASAR or extracted JavaScript application as an inline application graph without executing it. Returns recovered graph nodes, edges, semantic relations, integrity contradictions, limitations, and coverage. Integrity mismatches fail by default; record-and-continue retains observed bytes as untrusted and marks graph coverage partial.",
         kind: "electron-provider",
         inputSchema: analyzeJavaScriptApplicationInputSchema,
         outputSchema: applicationOutputSchema,
@@ -64,6 +64,7 @@ export const ELECTRON_TOOL_CONTRACTS = [
                 input: {
                     input_path: "/Applications/Example.app/Contents/Resources/app.asar",
                     format: "auto",
+                    integrity_policy: "fail",
                 },
             },
         ],

package/dist/contracts/javascript/javascriptApplicationWorkflowExamples.js

@@ -1,8 +1,9 @@
 import { createEvidence } from "../../domain/evidence.js";
-import { reconcileJavaScriptRuntime } from "../../domain/javascript/javascriptRuntimeReconciliation.js";
+import { parseRuntimeReconciliationInput, reconcileJavaScriptRuntime, } from "../../domain/javascript/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);
+import { reconcileJavaScriptRuntimeInputSchema } from "../../domain/javascript/javascriptRuntimeReconciliationSchemas.js";
+const reconciliation = reconcileJavaScriptRuntime(parseRuntimeReconciliationInput(reconcileJavaScriptRuntimeInputSchema.parse(JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE)));
 const reconciliationEvidence = createEvidence(undefined, {
     id: "rea-javascript-runtime-reconciliation",
     name: "REA JavaScript runtime reconciliation",
@@ -82,23 +83,3 @@ export const SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE = {
     }),
     application: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
 };
-/** Exact static return-shape comparison with both Evidence records inline. */
-export const JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE = {
-    left: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
-    right: reconciliationEvidence,
-    left_module_path: "parser.mjs",
-    left_export_name: "default",
-    right_module_path: "parser.mjs",
-    right_export_name: "default",
-};
-/** Full-Evidence compatibility fixture used by pure domain and adapter tests. */
-export const JAVASCRIPT_FEATURE_TRACE_FULL_EVIDENCE_EXAMPLE = {
-    application: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
-    seed: TRACE_SEED,
-    direction: "both",
-};
-/** Full-Evidence compatibility comparison fixture. */
-export const JAVASCRIPT_VERSION_COMPARISON_FULL_EVIDENCE_EXAMPLE = {
-    left: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
-    right: reconciliationEvidence,
-};