rea-agents 6.1.0 → 6.3.0

package/dist/domain/javascript/javascriptApplicationVersionComparisonSchemas.js

@@ -1,21 +1,14 @@
 import { z } from "zod";
 import { emptyArraySchema } from "../emptyArraySchema.js";
 import { evidenceSchema } from "../evidence.js";
-import { javascriptApplicationGraphSchema } from "./javascriptApplicationGraph.js";
+import { isValidatedImmutableJavaScriptApplicationGraph, javascriptApplicationGraphSchema, } from "./javascriptApplicationGraph.js";
 import { JAVASCRIPT_APPLICATION_NODE_KINDS } from "./javascriptApplicationGraphSchemas.js";
 import { prefixedDigestSchema } from "../digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const nodeIdSchema = prefixedDigestSchema("jag_node");
 const textSchema = z.string().min(1);
-/** Two authenticated application versions and their native observations. */
-export const compareApplicationVersionsInputSchema = z
-    .strictObject({
-    left: evidenceSchema,
-    right: evidenceSchema,
-    left_native_observations: z.array(evidenceSchema).default([]),
-    right_native_observations: z.array(evidenceSchema).default([]),
-})
-    .superRefine((input, context) => {
+/** Check paired version identities and per-side native identity uniqueness. */
+const validateApplicationVersionIdentities = (input, context) => {
     if (input.left.evidence_id === input.right.evidence_id)
         context.addIssue({
             code: "custom",
@@ -34,8 +27,26 @@ export const compareApplicationVersionsInputSchema = z
                 message: "Native observations must be unique on each side",
             });
     }
-});
-const emptyCandidateNodesSchema = emptyArraySchema;
+};
+const evidenceIdentitySchema = z.object({ evidence_id: evidenceIdSchema });
+/** Validate paired version identities without capturing whole analysis graphs. */
+export const applicationVersionIdentitiesSchema = z
+    .object({
+    left: evidenceIdentitySchema,
+    right: evidenceIdentitySchema,
+    left_native_observations: z.array(evidenceIdentitySchema),
+    right_native_observations: z.array(evidenceIdentitySchema),
+})
+    .superRefine(validateApplicationVersionIdentities);
+/** Two authenticated application versions and their native observations. */
+export const compareApplicationVersionsInputSchema = z
+    .strictObject({
+    left: evidenceSchema,
+    right: evidenceSchema,
+    left_native_observations: z.array(evidenceSchema).default([]),
+    right_native_observations: z.array(evidenceSchema).default([]),
+})
+    .superRefine(validateApplicationVersionIdentities);
 const candidateNodesSchema = z.tuple([nodeIdSchema]).rest(nodeIdSchema);
 const exactMatchSchema = z.strictObject({
     status: z.literal("matched"),
@@ -45,22 +56,22 @@ const exactMatchSchema = z.strictObject({
         "exact-module-source-digest",
     ]),
     confidence: z.literal("exact"),
-    candidate_left_node_ids: emptyCandidateNodesSchema,
-    candidate_right_node_ids: emptyCandidateNodesSchema,
+    candidate_left_node_ids: emptyArraySchema,
+    candidate_right_node_ids: emptyArraySchema,
 });
 const sourceMapMatchSchema = z.strictObject({
     status: z.literal("matched"),
     basis: z.literal("source-map-identity"),
     confidence: z.literal("high"),
-    candidate_left_node_ids: emptyCandidateNodesSchema,
-    candidate_right_node_ids: emptyCandidateNodesSchema,
+    candidate_left_node_ids: emptyArraySchema,
+    candidate_right_node_ids: emptyArraySchema,
 });
 const inferredMatchSchema = z.strictObject({
     status: z.literal("matched"),
     basis: z.enum(["structural-fingerprint", "semantic-key"]),
     confidence: z.literal("medium"),
-    candidate_left_node_ids: emptyCandidateNodesSchema,
-    candidate_right_node_ids: emptyCandidateNodesSchema,
+    candidate_left_node_ids: emptyArraySchema,
+    candidate_right_node_ids: emptyArraySchema,
 });
 const matchedItemMatchSchema = z.union([
     exactMatchSchema,
@@ -71,14 +82,14 @@ const unmatchedItemMatchSchema = z.strictObject({
     status: z.literal("unmatched"),
     basis: z.literal("none"),
     confidence: z.literal("unknown"),
-    candidate_left_node_ids: emptyCandidateNodesSchema,
-    candidate_right_node_ids: emptyCandidateNodesSchema,
+    candidate_left_node_ids: emptyArraySchema,
+    candidate_right_node_ids: emptyArraySchema,
 });
 const leftAmbiguousMatchSchema = z.strictObject({
     status: z.literal("ambiguous"),
     basis: z.literal("none"),
     confidence: z.literal("unknown"),
-    candidate_left_node_ids: emptyCandidateNodesSchema,
+    candidate_left_node_ids: emptyArraySchema,
     candidate_right_node_ids: candidateNodesSchema,
 });
 const rightAmbiguousMatchSchema = z.strictObject({
@@ -86,7 +97,7 @@ const rightAmbiguousMatchSchema = z.strictObject({
     basis: z.literal("none"),
     confidence: z.literal("unknown"),
     candidate_left_node_ids: candidateNodesSchema,
-    candidate_right_node_ids: emptyCandidateNodesSchema,
+    candidate_right_node_ids: emptyArraySchema,
 });
 const comparisonItemContextShape = {
     item_id: prefixedDigestSchema("javc_item"),
@@ -194,3 +205,7 @@ export const applicationVersionComparisonResultSchema = z
             message: "Comparison coverage must match source graph completeness",
         });
 });
+/** Reuse the exact owned change graph while validating the rest of the result. */
+export const ownedApplicationVersionComparisonResultSchema = applicationVersionComparisonResultSchema.safeExtend({
+    graph: z.custom(isValidatedImmutableJavaScriptApplicationGraph),
+});

package/dist/domain/javascript/javascriptApplicationVersionItems.js

@@ -1,6 +1,6 @@
-import { absenceClaimable, canonicalDigest, canonicalJson, } from "../comparisonSemantics.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
-import {} from "./javascriptApplicationGraph.js";
+import { absenceClaimable, canonicalJson } from "../comparisonSemantics.js";
+import { digestCanonicalValue } from "../canonicalDigest.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 /** Classify matched, unmatched, and ambiguous nodes without inventing absence. */
 export const classifyJavaScriptApplicationVersions = (matching, context) => {
     const pairByLeft = new Map(matching.pairs.map(({ left, right }) => [
@@ -11,7 +11,13 @@ export const classifyJavaScriptApplicationVersions = (matching, context) => {
         right.node_id,
         `pair:${left.node_id}:${right.node_id}`,
     ]));
-    const fullContext = { ...context, pairByLeft, pairByRight };
+    const fullContext = {
+        ...context,
+        pairByLeft,
+        pairByRight,
+        leftRelationships: indexRelationships(context.leftGraph),
+        rightRelationships: indexRelationships(context.rightGraph),
+    };
     const leftItems = matching.unmatchedLeft.map((node) => {
         const candidates = matching.candidatesForLeft.get(node.node_id) ?? [];
         return unmatchedItem({
@@ -31,7 +37,7 @@ export const classifyJavaScriptApplicationVersions = (matching, context) => {
             ...matching.pairs.map((pair) => matchedItem(pair, fullContext)),
             ...leftItems,
             ...rightItems,
-        ].sort((left, right) => compareCodePoints(left.item_id, right.item_id)),
+        ].sort((left, right) => compareUnicodeCodePoints(left.item_id, right.item_id)),
     };
 };
 const matchedItem = (pair, context) => {
@@ -202,38 +208,46 @@ const contentIdentity = (node) => {
 };
 const locations = (node) => node.observations
     .map(({ evidence }) => evidence.location.available ? evidence.location.value : evidence.location)
-    .sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right)));
+    .sort((left, right) => compareUnicodeCodePoints(canonicalJson(left), canonicalJson(right)));
 const properties = (node) => node.observations
-    .map(({ label, properties: values }) => ({ label, properties: values }))
-    .sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right)));
+    .map(({ label, properties: values, source_map_reference }) => ({
+    label,
+    properties: values,
+    source_map_reference,
+}))
+    .sort((left, right) => compareUnicodeCodePoints(canonicalJson(left), canonicalJson(right)));
+const indexRelationships = (graph) => {
+    const adjacency = new Map();
+    const add = (nodeId, relationship) => {
+        const existing = adjacency.get(nodeId);
+        if (existing === undefined)
+            adjacency.set(nodeId, [relationship]);
+        else
+            existing.push(relationship);
+    };
+    for (const edge of graph.edges) {
+        add(edge.source_node_id, {
+            direction: "out",
+            relation: edge.relation,
+            neighborId: edge.target_node_id,
+        });
+        if (edge.target_node_id !== edge.source_node_id)
+            add(edge.target_node_id, {
+                direction: "in",
+                relation: edge.relation,
+                neighborId: edge.source_node_id,
+            });
+    }
+    return {
+        nodeById: new Map(graph.nodes.map((value) => [value.node_id, value])),
+        adjacency,
+    };
+};
 const relationshipSignature = (node, side, context) => {
-    const graph = side === "left" ? context.leftGraph : context.rightGraph;
+    const { nodeById, adjacency } = side === "left" ? context.leftRelationships : context.rightRelationships;
     const paired = side === "left" ? context.pairByLeft : context.pairByRight;
-    const nodeById = new Map(graph.nodes.map((value) => [value.node_id, value]));
-    const signatures = graph.edges.flatMap((edge) => {
-        if (edge.source_node_id === node.node_id)
-            return [
-                edgeSignature({
-                    direction: "out",
-                    relation: edge.relation,
-                    neighborId: edge.target_node_id,
-                    paired,
-                    nodeById,
-                }),
-            ];
-        if (edge.target_node_id === node.node_id)
-            return [
-                edgeSignature({
-                    direction: "in",
-                    relation: edge.relation,
-                    neighborId: edge.source_node_id,
-                    paired,
-                    nodeById,
-                }),
-            ];
-        return [];
-    });
-    return canonicalJson(signatures.sort(compareCodePoints));
+    const signatures = (adjacency.get(node.node_id) ?? []).map((relationship) => edgeSignature({ ...relationship, paired, nodeById }));
+    return canonicalJson(signatures.sort(compareUnicodeCodePoints));
 };
 const edgeSignature = (context) => {
     const mapped = context.paired.get(context.neighborId);
@@ -247,7 +261,7 @@ const itemEvidenceLinks = (left, right, context) => [
         ...nativeLinks(left, context.leftNativeEvidence),
         ...nativeLinks(right, context.rightNativeEvidence),
     ]),
-].sort(compareCodePoints);
+].sort(compareUnicodeCodePoints);
 const nativeLinks = (node, evidence) => {
     const digest = node === undefined
         ? null
@@ -280,7 +294,7 @@ const pairLimitations = (pair, status) => [
 ];
 const itemWithId = (semantic) => ({
     ...semantic,
-    item_id: `javc_item_${canonicalDigest(semantic, "Application version item")}`,
+    item_id: `javc_item_${digestCanonicalValue(semantic, "Application version item")}`,
 });
 const stringProperty = (node, key) => {
     const values = [

package/dist/domain/javascript/javascriptApplicationVersionKeys.js

@@ -1,4 +1,5 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { canonicalJson } from "../comparisonSemantics.js";
+import { compareUnicodeCodePoints, compositeKey, } from "../unicodeCodePointOrder.js";
 const matchTiers = () => [
     {
         match: { basis: "exact-content-digest", confidence: "exact" },
@@ -39,7 +40,7 @@ export const matchJavaScriptApplicationVersions = (leftNodes, rightNodes) => {
     const leftIds = new Set(remainingLeft.map(({ node_id: id }) => id));
     const rightIds = new Set(remainingRight.map(({ node_id: id }) => id));
     return {
-        pairs: pairs.sort((a, b) => compareCodePoints(`${a.left.node_id}\0${a.right.node_id}`, `${b.left.node_id}\0${b.right.node_id}`)),
+        pairs: pairs.sort((a, b) => compareUnicodeCodePoints(`${a.left.node_id}\0${a.right.node_id}`, `${b.left.node_id}\0${b.right.node_id}`)),
         unmatchedLeft: remainingLeft,
         unmatchedRight: remainingRight,
         candidatesForLeft: filteredCandidates(leftCandidates, rightIds),
@@ -49,7 +50,7 @@ export const matchJavaScriptApplicationVersions = (leftNodes, rightNodes) => {
 const applyTier = (context) => {
     const leftByKey = nodesByKey(context.left.values(), context.tier.key);
     const rightByKey = nodesByKey(context.right.values(), context.tier.key);
-    for (const key of [...leftByKey.keys()].sort(compareCodePoints)) {
+    for (const key of [...leftByKey.keys()].sort(compareUnicodeCodePoints)) {
         const leftGroup = leftByKey.get(key) ?? [];
         const rightGroup = rightByKey.get(key) ?? [];
         if (rightGroup.length === 0)
@@ -97,7 +98,7 @@ const recordCandidates = (left, right, leftCandidates, rightCandidates) => {
 const filteredCandidates = (candidates, retained) => new Map([...candidates.entries()].flatMap(([nodeId, values]) => {
     const filtered = [...values]
         .filter((value) => retained.has(value))
-        .sort(compareCodePoints);
+        .sort(compareUnicodeCodePoints);
     return filtered.length === 0 ? [] : [[nodeId, filtered]];
 }));
 const nodeIdentityKey = (node) => `node\0${node.kind}\0${node.node_id}`;
@@ -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")
@@ -177,7 +178,7 @@ const uniqueStringProperty = (node, name) => {
 };
 const joined = (...values) => {
     const strings = values.map(nonEmptyString);
-    return strings.some((value) => value === null) ? null : strings.join("\0");
+    return strings.some((value) => value === null) ? null : compositeKey(strings);
 };
 const nonEmptyString = (value) => typeof value === "string" && value !== "" ? value : null;
 /** A literal value such as `ipcMain.handle("")` keeps its exact empty text. */
@@ -185,6 +186,6 @@ const exactString = (value) => typeof value === "string" ? value : null;
 const stringList = (value) => Array.isArray(value)
     ? value
         .filter((item) => typeof item === "string")
-        .sort(compareCodePoints)
+        .sort(compareUnicodeCodePoints)
     : [];
-const sortedNodes = (nodes) => [...nodes].sort((left, right) => compareCodePoints(left.node_id, right.node_id));
+const sortedNodes = (nodes) => [...nodes].sort((left, right) => compareUnicodeCodePoints(left.node_id, right.node_id));

package/dist/domain/javascript/javascriptAstFingerprint.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import * as t from "@babel/types";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { propertyName } from "./javascriptAstValues.js";
 import { stringValue } from "./javascriptStaticAnalysisHelpers.js";
 /** Derive a rename-resistant syntax fingerprint without code execution. */
@@ -28,7 +28,7 @@ export const collectJavaScriptExports = (node) => {
         },
     });
     return {
-        values: [...exports].sort(compareCodePoints),
+        values: [...exports].sort(compareUnicodeCodePoints),
     };
 };
 const semanticTokens = (node) => {

package/dist/domain/javascript/javascriptAstValues.js

@@ -1,6 +1,27 @@
 import * as t from "@babel/types";
+/**
+ * Remove wrappers that affect TypeScript or Flow checking but not runtime
+ * expression identity. The returned depth lets bounded evaluators account for
+ * syntax that normalization would otherwise skip.
+ */
+export const unwrapJavaScriptExpression = (node) => {
+    let current = node;
+    let depth = 0;
+    while (t.isParenthesizedExpression(current) ||
+        t.isTSAsExpression(current) ||
+        t.isTSTypeAssertion(current) ||
+        t.isTSNonNullExpression(current) ||
+        t.isTSSatisfiesExpression(current) ||
+        t.isTSInstantiationExpression(current) ||
+        t.isTypeCastExpression(current)) {
+        current = current.expression;
+        depth += 1;
+    }
+    return { node: current, depth };
+};
 /** Read one syntax-level primitive only when its value is exact. */
 export const readExactJavaScriptLiteral = (node) => {
+    node = unwrapJavaScriptExpression(node).node;
     if (t.isStringLiteral(node))
         return { found: true, value: node.value };
     if (t.isNumericLiteral(node) && Number.isFinite(node.value))
@@ -31,6 +52,7 @@ export const propertyName = (node) => {
 export const semanticStaticPropertyName = (property, computed) => semanticStaticPropertyKey(property, computed) ?? "";
 /** Read an exact property key, preserving the legal empty-string key. */
 export const semanticStaticPropertyKey = (property, computed) => {
+    property = unwrapJavaScriptExpression(property).node;
     if (t.isStringLiteral(property) || t.isNumericLiteral(property))
         return String(property.value);
     return !computed && t.isIdentifier(property) ? property.name : null;

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

@@ -1,8 +1,9 @@
-import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.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 +22,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 +41,7 @@ export const compareJavaScriptExportShapes = (input) => {
     const semantic = {
         left: left.selection,
         right: right.selection,
+        property_inventories: propertyInventories,
         summary: summarize(allChanges),
         changes,
         coverage,
@@ -59,7 +66,7 @@ const sortChanges = (changes) => changes
         change_id: change.change_id,
     }),
 }))
-    .sort((left, right) => compareCodePoints(left.sortKey, right.sortKey) ||
+    .sort((left, right) => compareUnicodeCodePoints(left.sortKey, right.sortKey) ||
     left.index - right.index)
     .map(({ change }) => change);
 const comparisonCoverage = (context) => {

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

@@ -5,7 +5,6 @@ const evidenceIdSchema = prefixedDigestSchema("ev");
 const graphIdSchema = prefixedDigestSchema("jag");
 const nodeIdSchema = prefixedDigestSchema("jag_node");
 const textSchema = z.string().min(1);
-const selectorTextSchema = textSchema;
 const semanticPrimitiveSchema = z.union([
     z.string(),
     z.number().finite(),
@@ -49,25 +48,38 @@ const sourceRangeSchema = z
             message: "Source range end must not precede its start",
         });
 });
-/** Two authenticated application graphs and exact export selectors. */
-export const compareJavaScriptExportShapesInputSchema = z
-    .strictObject({
-    left: evidenceSchema,
-    right: evidenceSchema,
-    left_module_path: selectorTextSchema,
-    left_export_name: selectorTextSchema,
-    right_module_path: selectorTextSchema,
-    right_export_name: selectorTextSchema,
-})
-    .superRefine((input, context) => {
+/** Check that export-shape comparisons bind distinct source Evidence. */
+const validateJavaScriptExportShapeIdentities = (input, context) => {
     if (input.left.evidence_id === input.right.evidence_id)
         context.addIssue({
             code: "custom",
             path: ["right"],
             message: "JavaScript export shape Evidence must be distinct",
         });
-});
-const projectedReturnFieldShape = { path: jsonPointerSchema };
+};
+const evidenceIdentitySchema = z.object({ evidence_id: evidenceIdSchema });
+/** Validate export-shape identities without capturing complete source graphs. */
+export const javaScriptExportShapeIdentitiesSchema = z
+    .object({
+    left: evidenceIdentitySchema,
+    right: evidenceIdentitySchema,
+})
+    .superRefine(validateJavaScriptExportShapeIdentities);
+/** Two authenticated application graphs and exact export selectors. */
+export const compareJavaScriptExportShapesInputSchema = z
+    .strictObject({
+    left: evidenceSchema,
+    right: evidenceSchema,
+    left_module_path: textSchema,
+    left_export_name: textSchema,
+    right_module_path: textSchema,
+    right_export_name: textSchema,
+})
+    .superRefine(validateJavaScriptExportShapeIdentities);
+const projectedReturnFieldShape = {
+    path: jsonPointerSchema,
+    presence: z.enum(["present", "absent", "unknown-coverage"]),
+};
 const projectedReturnFieldSchema = z.discriminatedUnion("state", [
     z.strictObject({
         ...projectedReturnFieldShape,
@@ -135,8 +147,8 @@ const projectedReturnShapeSchema = z
 export const projectedExportReturnShapesSchema = z
     .strictObject({
     semantic_role: z.literal("export-return-shapes"),
-    module_path: selectorTextSchema,
-    exported_name: selectorTextSchema,
+    module_path: textSchema,
+    exported_name: textSchema,
     callable_id: textSchema,
     callable_kind: z.enum(["function", "class", "method"]),
     static_return_shapes: z.array(projectedReturnShapeSchema),
@@ -160,16 +172,16 @@ export const projectedExportReturnShapesSchema = z
 });
 const exportCandidateSchema = z.strictObject({
     node_id: nodeIdSchema,
-    module_path: selectorTextSchema,
-    export_name: selectorTextSchema,
+    module_path: textSchema,
+    export_name: textSchema,
     matches_requested_module: z.boolean(),
     matches_requested_export: z.boolean(),
 });
 const selectorResultShape = {
     evidence_id: evidenceIdSchema,
     graph_id: graphIdSchema,
-    requested_module_path: selectorTextSchema,
-    requested_export_name: selectorTextSchema,
+    requested_module_path: textSchema,
+    requested_export_name: textSchema,
     candidates: z.array(exportCandidateSchema),
     omitted_candidates: z.number().int().min(0),
 };
@@ -209,11 +221,21 @@ const discriminantSchema = z.strictObject({
     path: jsonPointerSchema,
     value: semanticPrimitiveSchema,
 });
-const comparisonChangeSchema = z.strictObject({
+const propertyPresenceSchema = z.enum([
+    "present",
+    "absent",
+    "unknown-coverage",
+]);
+/** One change row; presence is required even when values stay unknown. */
+export const javaScriptExportShapeComparisonChangeSchema = 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,18 +243,32 @@ const comparisonChangeSchema = z.strictObject({
     evidence_links: z.array(evidenceIdSchema).length(2),
     limitations: z.array(textSchema),
 });
+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),
         changed: z.number().int().min(0),
         unknown: z.number().int().min(0),
     }),
-    changes: z.array(comparisonChangeSchema),
+    changes: z.array(javaScriptExportShapeComparisonChangeSchema),
     coverage: z.strictObject({
         status: z.enum(["complete-within-inputs", "partial", "truncated"]),
         left_graph_status: z.enum([

package/dist/domain/javascript/javascriptExportShapeSelection.js

@@ -1,5 +1,5 @@
 import { projectedExportReturnShapesSchema, } from "./javascriptExportShapeComparisonSchemas.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 /** Select one exact trusted export and its exact static return-shape observation. */
 export const selectJavaScriptExport = (side) => {
     const candidates = exportCandidates(side.graph);
@@ -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,
@@ -90,7 +90,7 @@ const exportCandidates = (graph) => {
             });
         }
     }
-    return [...candidates.values()].sort((left, right) => compareCodePoints(candidateKey(left), candidateKey(right)));
+    return [...candidates.values()].sort((left, right) => compareUnicodeCodePoints(candidateKey(left), candidateKey(right)));
 };
 const candidateKey = (candidate) => `${candidate.modulePath}\0${candidate.exportName}\0${candidate.node.node_id}`;
 const returnShapeFor = (node, side) => {