rea-agents 6.1.0 → 6.2.0

package/dist/domain/functionDossierEvidence.js

@@ -1,16 +1,5 @@
 import { parseEvidence } from "./evidence.js";
 import { functionDossierSchema } from "./hopperValues.js";
-const DOSSIER_COLLECTION_FIELDS = [
-    "assembly",
-    "comments",
-    "callers",
-    "callees",
-    "incoming_references",
-    "outgoing_references",
-    "referenced_strings",
-    "referenced_names",
-    "basic_blocks",
-];
 /** Parse one complete analyze_function Evidence record for comparison workflows. */
 export const parseFunctionEvidence = (input) => {
     const evidence = parseEvidence(input);
@@ -20,35 +9,11 @@ export const parseFunctionEvidence = (input) => {
         throw new TypeError("Function comparison requires artifact-bound Evidence");
     const dossier = functionDossierSchema.parse(evidence.normalized_result);
     return {
-        evidence: [evidence],
-        procedure: dossier.procedure,
-        provider: evidence.provider,
+        evidence,
         subject: evidence.subject,
-        pseudocode: {
-            text: dossier.pseudocode,
-            total: [...dossier.pseudocode].length,
-            complete: true,
-            truncated: false,
-        },
-        collections: {
-            assembly: completeCollection(dossier.assembly),
-            comments: completeCollection(dossier.comments),
-            callers: completeCollection(dossier.callers),
-            callees: completeCollection(dossier.callees),
-            incoming_references: completeCollection(dossier.incoming_references),
-            outgoing_references: completeCollection(dossier.outgoing_references),
-            referenced_strings: completeCollection(dossier.referenced_strings),
-            referenced_names: completeCollection(dossier.referenced_names),
-            basic_blocks: completeCollection(dossier.basic_blocks),
-        },
+        dossier,
         limitations: [
             ...new Set([...evidence.limitations, ...dossier.limitations]),
         ].sort((left, right) => left.localeCompare(right)),
     };
 };
-const completeCollection = (items) => ({
-    items,
-    total: items.length,
-    complete: true,
-    truncated: false,
-});

package/dist/domain/javascript/electronActiveObservation.js

@@ -61,61 +61,16 @@ export const electronActiveObservationInputSchema = z.strictObject({
         .optional()
         .describe("Absolute local filesystem root for application-relative paths; omit to derive it from the application path. Relative paths are rejected."),
     args: z
-        .array(z.string().regex(/^[^\0]*$/u, "Electron arguments must not contain NUL"))
+        .array(z
+        .string()
+        .regex(/^[^\u0000]*$/u, "Electron arguments must not contain NUL"))
         .default([]),
     actions: z.array(actionSchema).default([]),
 });
-const ipcEventSchema = z.strictObject({
-    sequence: z.number().int().min(1),
-    correlation_id: z.string().nullable().default(null),
-    kind: z.enum([
-        "main-handler-invocation",
-        "main-event-invocation",
-        "utility-process-fork",
-        "utility-process-message",
-        "ipc-main-to-renderer",
-        "ipc-utility-to-main",
-        "ipc-renderer-send",
-        "ipc-renderer-invoke",
-        "ipc-renderer-post-message",
-    ]),
-    event: z.string().nullable().optional(),
-    phase: z
-        .enum(["attempted", "completed", "blocked", "failed", "observed"])
-        .nullable()
-        .optional(),
-    channel: z.string().nullable(),
-    direction: z
-        .enum([
-        "renderer-to-main",
-        "main-to-renderer",
-        "main-to-utility",
-        "utility-to-main",
-    ])
-        .nullable()
-        .optional(),
-    sender: z.string().nullable().optional(),
-    receiver: z.string().nullable().optional(),
-    frame: z.string().nullable().default(null),
-    target: z.string().nullable().optional(),
-    argument_shapes: z.array(z.string()),
-    result_shape: z.string().nullable(),
-    process_type: z.string().nullable(),
-    source: z.string().default("electron-active-hook"),
-    capture_method: z
-        .enum(["api-wrapper", "event-emitter", "process-hook"])
-        .default("api-wrapper"),
-    artifact_path: z.string().nullable().default(null),
-    artifact_sha256: z
-        .string()
-        .regex(/^[a-f0-9]{64}$/u)
-        .nullable()
-        .default(null),
-    error: z.boolean(),
-});
-const timelineEventSchema = z.strictObject({
+/** Canonical active Electron event shared by the hook boundary and public timeline. */
+export const electronActiveTimelineEventSchema = z.strictObject({
     sequence: z.number().int().min(1),
-    correlation_id: z.string().nullable().default(null),
+    correlation_id: z.string().nullable(),
     kind: z.enum([
         "main-handler-invocation",
         "main-event-invocation",
@@ -168,6 +123,19 @@ const timelineEventSchema = z.strictObject({
         .nullable(),
     error: z.boolean(),
 });
+const ipcEventSchema = electronActiveTimelineEventSchema.extend({
+    kind: z.enum([
+        "main-handler-invocation",
+        "main-event-invocation",
+        "utility-process-fork",
+        "utility-process-message",
+        "ipc-main-to-renderer",
+        "ipc-utility-to-main",
+        "ipc-renderer-send",
+        "ipc-renderer-invoke",
+        "ipc-renderer-post-message",
+    ]),
+});
 const processMetricSchema = z.strictObject({
     pid: z.number().int().min(1),
     type: z.string().min(1),
@@ -237,17 +205,14 @@ export const electronActiveObservationResultSchema = z.strictObject({
     ipc: z.strictObject({
         events: z.array(ipcEventSchema),
         observed: z.number().int().min(0),
-        dropped: z.number().int().min(0).nullable().default(null),
+        dropped: z.number().int().min(0),
     }),
-    timeline: z
-        .strictObject({
-        events: z.array(timelineEventSchema),
+    timeline: z.strictObject({
+        events: z.array(electronActiveTimelineEventSchema),
         observed: z.number().int().min(0),
-        dropped: z.number().int().min(0).nullable().default(null),
-    })
-        .default({ events: [], observed: 0, dropped: null }),
-    retention: z
-        .strictObject({
+        dropped: z.number().int().min(0),
+    }),
+    retention: z.strictObject({
         budget_bytes: z.number().int().min(0),
         estimated_retained_bytes: z.number().int().min(0),
         event_serialized_byte_upper_bound: z.number().int().min(0),
@@ -265,15 +230,7 @@ export const electronActiveObservationResultSchema = z.strictObject({
         dropped_ipc: z.number().int().min(0),
         observed_runtime: z.number().int().min(0),
         dropped_runtime: z.number().int().min(0),
-    })
-        .nullable()
-        .default(null),
-    coverage: coverageSchema.default({
-        status: "partial_attach",
-        observed_event_families: [],
-        unavailable_event_families: [],
-        observed_roles: [],
-        pre_capture_activity: "unavailable",
     }),
+    coverage: coverageSchema,
     limitations: z.array(z.string()),
 });

package/dist/domain/javascript/electronObservation.js

@@ -80,9 +80,20 @@ export const electronPageInspectionSchema = z.object({
             script_key: prefixedDigestSchema("electron_script"),
             frame_id: z.string().nullable().default(null),
             file_path: z.string(),
-            cdp_hash: z.string(),
-            length: z.number().int().min(0),
-            is_module: z.boolean(),
+            cdp_hash: z
+                .string()
+                .nullable()
+                .describe("Producer-reported script hash; null when unavailable."),
+            length: z
+                .number()
+                .int()
+                .min(0)
+                .nullable()
+                .describe("Producer-reported script length; null when unavailable."),
+            is_module: z
+                .boolean()
+                .nullable()
+                .describe("Producer-reported module classification; null when unavailable."),
             language: z.string().nullable(),
             source: electronSourceSchema,
         })),

package/dist/domain/javascript/electronStaticAnalysisBrowser.js

@@ -54,10 +54,16 @@ const collectWindowOptions = (source, options) => {
 const collectWebPreferences = (source, object) => {
     const preferences = [];
     let unknown = 0;
-    let preload = {
-        preload_path: null,
-        preload_resolution_context: null,
-    };
+    const effectivePreload = objectProperty(object, "preload");
+    const preloadPath = effectivePreload.status === "explicit"
+        ? staticPath(effectivePreload.property.value)
+        : undefined;
+    const preload = effectivePreload.status === "explicit" && preloadPath !== undefined
+        ? {
+            preload_path: preloadPath,
+            preload_resolution_context: staticPathResolutionContext(effectivePreload.property.value),
+        }
+        : { preload_path: null, preload_resolution_context: null };
     for (const property of object.properties) {
         if (t.isSpreadElement(property)) {
             unknown += 1;
@@ -85,11 +91,6 @@ const collectWebPreferences = (source, object) => {
             continue;
         }
         const path = name === "preload" ? staticPath(property.value) : undefined;
-        if (path !== undefined)
-            preload = {
-                preload_path: path,
-                preload_resolution_context: staticPathResolutionContext(property.value),
-            };
         const value = path === undefined
             ? electronStaticValue(source, property.value)
             : { status: "literal", value: path, expression: null };

package/dist/domain/javascript/electronStaticAnalysisIpc.js

@@ -1,7 +1,8 @@
 import * as t from "@babel/types";
 import { boundedExpression, electronStaticValue, handlerKind, } from "./electronStaticAnalysisValues.js";
 import { addLocatedFinding } from "./javascriptStaticAnalysisFindings.js";
-import { argumentNode, calleeName, range, semanticStaticPropertyName, } from "./javascriptStaticAnalysisHelpers.js";
+import { argumentNode, calleeName, range, } from "./javascriptStaticAnalysisHelpers.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 /** Inspect Electron IPC operations and validation candidates. */
 export const inspectElectronIpcNode = (node, context) => {
     if (t.isCallExpression(node)) {

package/dist/domain/javascript/electronStaticAnalysisNative.js

@@ -2,7 +2,8 @@ import * as t from "@babel/types";
 import { compareCodePoints } from "../canonicalOrdering.js";
 import { stripQueryAndFragment } from "../artifactPathSyntax.js";
 import { addLocatedFinding } from "./javascriptStaticAnalysisFindings.js";
-import { argumentNode, calleeName, propertyName, range, semanticStaticPropertyName, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
+import { argumentNode, calleeName, range, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
+import { propertyName, semanticStaticPropertyName, } from "./javascriptAstValues.js";
 /** Inspect JavaScript-side imports and re-exports of native .node addons. */
 export const inspectElectronNativeNode = (node, context) => {
     if (t.isImportDeclaration(node))

package/dist/domain/javascript/javascriptApplicationEvidenceSchemas.js

@@ -347,6 +347,8 @@ export const applicationNodeIdentitySchema = z.discriminatedUnion("strategy", [
         source_map_sha256: digestSchema,
         // The exact `sources` entry; `""` is a legal relative reference.
         original_source: z.string(),
+        // Exact leaf-local root; null means omitted or explicitly null.
+        source_root: z.string().nullable(),
         source_sha256: digestSchema.nullable(),
     }),
     z.strictObject({

package/dist/domain/javascript/javascriptApplicationGraph.js

@@ -63,6 +63,18 @@ const checkEvidenceNormalization = (evidence, path, context) => {
             path: [...path, "location"],
         });
 };
+const sourceMapObservationMatchesIdentity = (identity, observation) => {
+    const { evidence, source_map_reference: reference } = observation;
+    return (reference !== null &&
+        evidence.state === "observed" &&
+        evidence.artifact.available &&
+        evidence.artifact.sha256 === identity.source_map_sha256 &&
+        reference.source_name === identity.original_source &&
+        reference.source_root === identity.source_root &&
+        evidence.location.available &&
+        evidence.location.value.kind === "artifact-path" &&
+        reference.map_path === evidence.location.value.path);
+};
 const observationMatchesIdentity = (node, observation) => {
     const { identity } = node;
     const { evidence } = observation;
@@ -71,9 +83,7 @@ const observationMatchesIdentity = (node, observation) => {
             evidence.artifact.available &&
             evidence.artifact.sha256 === identity.sha256);
     if (identity.strategy === "source-map-original")
-        return (evidence.state === "observed" &&
-            evidence.artifact.available &&
-            evidence.artifact.sha256 === identity.source_map_sha256);
+        return sourceMapObservationMatchesIdentity(identity, observation);
     if (identity.strategy === "canonical-path")
         return (evidence.artifact.available &&
             evidence.artifact.sha256 === identity.artifact_sha256 &&
@@ -126,6 +136,19 @@ const checkNode = (node, index, context) => {
                     "observation_id",
                 ],
             });
+        if (node.identity.strategy === "source-map-original" &&
+            !observationMatchesIdentity(node, observation))
+            context.addIssue({
+                code: "custom",
+                message: "Source-map observation must retain its exact declaration and map location",
+                path: [
+                    "nodes",
+                    index,
+                    "observations",
+                    observationIndex,
+                    "source_map_reference",
+                ],
+            });
         checkEvidenceNormalization(observation.evidence, ["nodes", index, "observations", observationIndex, "evidence"], context);
     }
     if (!node.observations.some((observation) => observationMatchesIdentity(node, observation)))

package/dist/domain/javascript/javascriptApplicationGraphSchemas.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { javascriptSourceMapReferenceSchema } from "./javascriptSourceMapPaths.js";
 import { applicationCoverageSchema, applicationGraphEvidenceSchema, applicationNodeIdentitySchema, } from "./javascriptApplicationEvidenceSchemas.js";
 import { jsonValueSchema } from "../jsonValue.js";
 import { prefixedDigestSchema } from "../digests.js";
@@ -61,13 +62,19 @@ export const JAVASCRIPT_APPLICATION_RELATIONS = [
 const applicationRelationSchema = z.enum(JAVASCRIPT_APPLICATION_RELATIONS);
 const applicationPropertiesSchema = z.record(z.string().min(1), jsonValueSchema);
 /** One node observation before its semantic identifier is derived. */
-const applicationNodeObservationInputSchema = z.strictObject({
+const applicationNodeObservationBaseSchema = z.strictObject({
     label: z.string().min(1).nullable(),
+    source_map_reference: javascriptSourceMapReferenceSchema.nullable(),
     properties: applicationPropertiesSchema,
     evidence: applicationGraphEvidenceSchema,
 });
+const applicationNodeObservationInputSchema = applicationNodeObservationBaseSchema.extend({
+    source_map_reference: javascriptSourceMapReferenceSchema
+        .nullable()
+        .default(null),
+});
 /** One immutable, evidence-bearing observation attached to an entity. */
-export const applicationNodeObservationSchema = applicationNodeObservationInputSchema.extend({
+export const applicationNodeObservationSchema = applicationNodeObservationBaseSchema.extend({
     observation_id: prefixedDigestSchema("jag_observation"),
     identifier_strategy: z.strictObject({
         strategy: z.literal("semantic-content-sha256"),

package/dist/domain/javascript/javascriptApplicationVersionItems.js

@@ -1,6 +1,5 @@
 import { absenceClaimable, canonicalDigest, canonicalJson, } from "../comparisonSemantics.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
-import {} from "./javascriptApplicationGraph.js";
 /** Classify matched, unmatched, and ambiguous nodes without inventing absence. */
 export const classifyJavaScriptApplicationVersions = (matching, context) => {
     const pairByLeft = new Map(matching.pairs.map(({ left, right }) => [
@@ -204,7 +203,11 @@ const locations = (node) => node.observations
     .map(({ evidence }) => evidence.location.available ? evidence.location.value : evidence.location)
     .sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right)));
 const properties = (node) => node.observations
-    .map(({ label, properties: values }) => ({ label, properties: values }))
+    .map(({ label, properties: values, source_map_reference }) => ({
+    label,
+    properties: values,
+    source_map_reference,
+}))
     .sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right)));
 const relationshipSignature = (node, side, context) => {
     const graph = side === "left" ? context.leftGraph : context.rightGraph;

package/dist/domain/javascript/javascriptApplicationVersionKeys.js

@@ -1,3 +1,4 @@
+import { canonicalJson } from "../comparisonSemantics.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 const matchTiers = () => [
     {
@@ -112,7 +113,7 @@ const moduleSourceDigestKey = (node) => {
 };
 const sourceMapKey = (node) => node.kind === "source-module" &&
     node.identity.strategy === "source-map-original"
-    ? `source-map\0${node.identity.original_source}`
+    ? `source-map\0${canonicalJson([node.identity.source_root, node.identity.original_source])}`
     : null;
 const structuralFingerprintKey = (node) => {
     if (node.kind !== "javascript-module")

package/dist/{application/javascript/JavaScriptReturnShapeProjection.js → domain/javascript/javascriptExportReturnShapeProjection.js}

@@ -1,7 +1,7 @@
-import { jsonObjectSchema, jsonValueSchema } from "../../domain/jsonValue.js";
-import { partialApplicationCoverage, truncatedApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
-import { flattenSemanticReturnValue } from "../../domain/javascript/javascriptSemanticReturns.js";
-/** Project one exact export/callable link into shallow bounded graph values. */
+import { jsonObjectSchema, jsonValueSchema } from "../jsonValue.js";
+import { partialApplicationCoverage, truncatedApplicationCoverage, } from "./javascriptApplicationEvidenceSchemas.js";
+import { flattenSemanticReturnValue } from "./javascriptSemanticReturns.js";
+/** Project one exact export/callable link into inert return-shape observations. */
 export const projectJavaScriptExportReturnShapes = (input) => {
     if (input.link.callableId === null || input.link.exportedName === null)
         return null;

package/dist/domain/javascript/javascriptExportShapeComparison.js

@@ -2,7 +2,7 @@ import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 import { canonicalExportShapeValue, digestExportShapeValue, } from "./javascriptExportShapeComparisonIdentity.js";
 import { javaScriptExportShapeComparisonResultSchema, } from "./javascriptExportShapeComparisonSchemas.js";
 import { retainJavaScriptExportShapes, selectJavaScriptExport, } from "./javascriptExportShapeSelection.js";
-import { buildJavaScriptExportShapeChanges, hasPartialJavaScriptExportPropertyCoverage, pairJavaScriptExportShapeVariants, } from "./javascriptExportShapeVariants.js";
+import { buildJavaScriptExportShapeChanges, buildJavaScriptExportShapeInventories, hasPartialJavaScriptExportPropertyCoverage, pairJavaScriptExportShapeVariants, } from "./javascriptExportShapeVariants.js";
 /** Compare exact selected export return shapes without executing JavaScript. */
 export const compareJavaScriptExportShapes = (input) => {
     const left = selectJavaScriptExport(input.left);
@@ -21,6 +21,11 @@ export const compareJavaScriptExportShapes = (input) => {
     }));
     const changes = allChanges;
     const omittedChanges = 0;
+    const propertyInventories = buildJavaScriptExportShapeInventories({
+        pairing,
+        leftShapes: leftRetained.shapes,
+        rightShapes: rightRetained.shapes,
+    });
     const coverage = comparisonCoverage({
         input,
         left,
@@ -35,6 +40,7 @@ export const compareJavaScriptExportShapes = (input) => {
     const semantic = {
         left: left.selection,
         right: right.selection,
+        property_inventories: propertyInventories,
         summary: summarize(allChanges),
         changes,
         coverage,

package/dist/domain/javascript/javascriptExportShapeComparisonIdentity.js

@@ -1,6 +1,11 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-/** Canonically encode one export-shape comparison value. */
+/**
+ * Canonically encode one export-shape comparison value.
+ *
+ * Comparison identifiers hash the full result semantics, including each
+ * change's presence object and the per-variant property inventories.
+ */
 export const canonicalExportShapeValue = (value) => {
     const encoded = canonicalize(value);
     if (encoded === undefined)

package/dist/domain/javascript/javascriptExportShapeComparisonSchemas.js

@@ -67,7 +67,10 @@ export const compareJavaScriptExportShapesInputSchema = z
             message: "JavaScript export shape Evidence must be distinct",
         });
 });
-const projectedReturnFieldShape = { path: jsonPointerSchema };
+const projectedReturnFieldShape = {
+    path: jsonPointerSchema,
+    presence: z.enum(["present", "absent", "unknown-coverage"]),
+};
 const projectedReturnFieldSchema = z.discriminatedUnion("state", [
     z.strictObject({
         ...projectedReturnFieldShape,
@@ -209,11 +212,20 @@ const discriminantSchema = z.strictObject({
     path: jsonPointerSchema,
     value: semanticPrimitiveSchema,
 });
+const propertyPresenceSchema = z.enum([
+    "present",
+    "absent",
+    "unknown-coverage",
+]);
 const comparisonChangeSchema = z.strictObject({
     change_id: prefixedDigestSchema("jesc_change"),
     status: z.enum(["added", "removed", "changed", "unknown"]),
     path: jsonPointerSchema,
     discriminant: discriminantSchema.nullable(),
+    presence: z.strictObject({
+        left: propertyPresenceSchema,
+        right: propertyPresenceSchema,
+    }),
     left: valueAvailabilitySchema,
     right: valueAvailabilitySchema,
     left_source_range: sourceRangeSchema.nullable(),
@@ -221,11 +233,27 @@ const comparisonChangeSchema = z.strictObject({
     evidence_links: z.array(evidenceIdSchema).length(2),
     limitations: z.array(textSchema),
 });
+/** One change row; presence is required even when values stay unknown. */
+export const javaScriptExportShapeComparisonChangeSchema = comparisonChangeSchema;
+const inventoryPropertyCoverageSchema = z.strictObject({
+    path: jsonPointerSchema,
+    status: z.enum(["complete", "partial"]),
+});
+const propertyInventorySchema = z.strictObject({
+    side: z.enum(["left", "right"]),
+    variant_index: z.number().int().nonnegative(),
+    discriminant: discriminantSchema.nullable(),
+    paired: z.boolean(),
+    source_range: sourceRangeSchema,
+    properties: z.array(jsonPointerSchema),
+    property_coverage: z.array(inventoryPropertyCoverageSchema),
+});
 /** Static export-return comparison with explicit unknown semantics. */
 export const javaScriptExportShapeComparisonResultSchema = z.strictObject({
     comparison_id: prefixedDigestSchema("jesc"),
     left: selectorResultSchema,
     right: selectorResultSchema,
+    property_inventories: z.array(propertyInventorySchema),
     summary: z.strictObject({
         added: z.number().int().min(0),
         removed: z.number().int().min(0),

package/dist/domain/javascript/javascriptExportShapeSelection.js

@@ -41,11 +41,11 @@ export const selectJavaScriptExport = (side) => {
         limitations: [],
     };
 };
-/** Retain every projected return variant. */
-export const retainJavaScriptExportShapes = (selection) => {
-    const shapes = selection.projection?.static_return_shapes ?? [];
-    return { shapes, omitted: 0 };
-};
+/** Retain every authenticated variant with its explicit slot presence. */
+export const retainJavaScriptExportShapes = (selection) => ({
+    shapes: selection.projection?.static_return_shapes ?? [],
+    omitted: 0,
+});
 const selectorBase = (side, candidates) => ({
     evidence_id: side.evidenceId,
     graph_id: side.graph.graph_id,