rea-agents 4.0.1 → 5.0.0

package/dist/domain/{javascriptStaticAnalysisHelpers.js → javascript/javascriptStaticAnalysisHelpers.js}

@@ -1,7 +1,9 @@
 import { createHash } from "node:crypto";
 import { posix } from "node:path";
+import { fileURLToPath } from "node:url";
 import * as t from "@babel/types";
 import { semanticStaticPropertyName } from "./javascriptAstValues.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 export { propertyName, semanticStaticPropertyName, } from "./javascriptAstValues.js";
 /** Explicit result for source text that Babel cannot parse. */
 export const failedJavaScriptStaticAnalysis = () => ({
@@ -41,20 +43,34 @@ export const chunkRuntime = (call) => {
     return findChunkRuntime(call.callee.object);
 };
 const findChunkRuntime = (node) => {
-    if (t.isIdentifier(node) && /(?:webpack|rspack)Chunk/iu.test(node.name))
-        return node.name;
-    if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        const property = semanticStaticPropertyName(node.property, node.computed);
-        if (/(?:webpack|rspack)Chunk/iu.test(property))
-            return property;
-        return t.isNode(node.object) ? findChunkRuntime(node.object) : undefined;
+    const pending = [node];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            continue;
+        if (t.isIdentifier(current) &&
+            /(?:webpack|rspack)Chunk/iu.test(current.name))
+            return current.name;
+        if (t.isMemberExpression(current) ||
+            t.isOptionalMemberExpression(current)) {
+            const property = semanticStaticPropertyName(current.property, current.computed);
+            if (/(?:webpack|rspack)Chunk/iu.test(property))
+                return property;
+            if (t.isNode(current.object))
+                pending.push(current.object);
+            continue;
+        }
+        if (t.isAssignmentExpression(current)) {
+            pending.push(current.right, current.left);
+            continue;
+        }
+        if (t.isLogicalExpression(current) || t.isBinaryExpression(current)) {
+            pending.push(current.right, current.left);
+            continue;
+        }
+        if (t.isParenthesizedExpression(current) || t.isTSAsExpression(current))
+            pending.push(current.expression);
     }
-    if (t.isAssignmentExpression(node))
-        return findChunkRuntime(node.left) ?? findChunkRuntime(node.right);
-    if (t.isLogicalExpression(node) || t.isBinaryExpression(node))
-        return findChunkRuntime(node.left) ?? findChunkRuntime(node.right);
-    if (t.isParenthesizedExpression(node) || t.isTSAsExpression(node))
-        return findChunkRuntime(node.expression);
     return undefined;
 };
 /** Return a literal function factory from one module-table property. */
@@ -124,13 +140,16 @@ const staticCallPath = (node) => {
             ? stringValue(node.arguments[0])
             : undefined;
     if (name === "fileURLToPath" || name.endsWith(".fileURLToPath")) {
-        const argument = argumentNode(node.arguments[0]);
-        return argument === undefined ? undefined : staticPathAt(argument);
+        return staticFileUrlPath(argumentNode(node.arguments[0]));
     }
     if ((name === "dirname" || name.endsWith(".dirname")) &&
         isFileIdentity(argumentNode(node.arguments[0])))
         return "";
-    if (!name.endsWith(".join") && !name.endsWith(".resolve") && name !== "join")
+    if (name.endsWith(".resolve"))
+        return name === "win32.resolve" || name.endsWith(".win32.resolve")
+            ? undefined
+            : staticResolvedPath(node);
+    if (!name.endsWith(".join") && name !== "join")
         return undefined;
     const parts = [];
     for (const argument of node.arguments) {
@@ -143,6 +162,74 @@ const staticCallPath = (node) => {
     }
     return parts.length === 0 ? undefined : posix.join(...parts);
 };
+const staticFileUrlPath = (argument) => {
+    if (argument === undefined)
+        return undefined;
+    return isSourceFileUrl(argument)
+        ? sourceRelativeFileUrlPath(argument)
+        : staticPathAt(argument);
+};
+/** Project a known source-relative URL through the actual file URL decoder. */
+const sourceRelativeFileUrlPath = (node) => {
+    if (!isSourceFileUrl(node))
+        return undefined;
+    const value = stringValue(node.arguments[0]);
+    if (value === undefined ||
+        (value.split(/[?#]/u, 1)[0] ?? "") === "" ||
+        value !== value.trim() ||
+        value.includes("\\") ||
+        [...value].some((character) => character.charCodeAt(0) < 32) ||
+        /^[a-z][a-z0-9+.-]*:/iu.test(value) ||
+        value.startsWith("//") ||
+        /%(?:2e|2f|5c)/iu.test(value.split(/[?#]/u, 1)[0] ?? ""))
+        return undefined;
+    // A sufficiently deep inert anchor preserves any leading parent segments
+    // without using this host's cwd or inventing the application's directory.
+    const directory = `/${"source/".repeat(value.split("/").length + 1)}`;
+    try {
+        const resolved = new URL(value, `file://${directory}entry.js`);
+        const path = fileURLToPath(resolved, { windows: false });
+        if (value.startsWith("/"))
+            return path;
+        const relative = posix.relative(directory, path) || ".";
+        // Keep the established explicit source-directory observation spelling.
+        return value.startsWith("./") &&
+            relative !== "." &&
+            !relative.startsWith("../")
+            ? `./${relative}`
+            : relative;
+    }
+    catch (cause) {
+        // Malformed escapes and non-file URL forms remain unknown.
+        void cause;
+        return undefined;
+    }
+};
+const isSourceFileUrl = (node) => (t.isCallExpression(node) || t.isNewExpression(node)) &&
+    (calleeName(node.callee) === "URL" ||
+        calleeName(node.callee).endsWith(".URL")) &&
+    isFileIdentity(argumentNode(node.arguments[1]));
+const staticResolvedPath = (node) => {
+    const parts = [];
+    for (const argument of node.arguments) {
+        if (isDirectoryIdentity(argumentNode(argument))) {
+            parts.push(null);
+            continue;
+        }
+        const value = t.isNode(argument) ? staticPathAt(argument) : undefined;
+        // Validate every argument, including those before the last anchor.
+        if (value === undefined)
+            return undefined;
+        parts.push(value);
+    }
+    const anchor = parts.findLastIndex((part) => part === null || posix.isAbsolute(part));
+    // Relative-only calls depend on the target process cwd, which is unknown.
+    if (anchor === -1)
+        return undefined;
+    // A null anchor is the source directory; preserve its relative projection.
+    const path = posix.join(...parts.slice(anchor).filter((part) => part !== null));
+    return path === "/" ? path : path.replace(/\/$/u, "");
+};
 const isFilesystemPathExpression = (node) => {
     if (t.isStringLiteral(node))
         return node.value.startsWith("/");
@@ -153,6 +240,8 @@ const isFilesystemPathExpression = (node) => {
             isFilesystemPathExpression(node.right));
     if (t.isCallExpression(node) || t.isNewExpression(node)) {
         const name = calleeName(node.callee);
+        if (name.endsWith(".resolve") && staticCallPath(node) !== undefined)
+            return true;
         if (name === "URL" || name.endsWith(".URL"))
             return isFileIdentity(argumentNode(node.arguments[1]));
         if (name === "fileURLToPath" || name.endsWith(".fileURLToPath"))
@@ -195,14 +284,135 @@ const isFileIdentity = (node) => {
     return ((name === "fileURLToPath" || name.endsWith(".fileURLToPath")) &&
         isFileIdentity(argumentNode(node.arguments[0])));
 };
+const XHR_METHODS = new Set([
+    "CONNECT",
+    "DELETE",
+    "GET",
+    "HEAD",
+    "OPTIONS",
+    "PATCH",
+    "POST",
+    "PUT",
+    "TRACE",
+]);
+/** An absolute HTTP(S)/WebSocket URL, or an absolute or relative path. */
+const isRequestUrlLiteral = (value) => /^(?:https?|wss?):\/\//iu.test(value) ||
+    value.startsWith("/") ||
+    value.startsWith("./") ||
+    value.startsWith("../");
+/**
+ * Browsing-context and document `open` take a URL or type first and a target
+ * name second. The name is only a spelling, since `parent` or `self` may be a
+ * local XHR binding, so it never overrides a literal HTTP method.
+ */
+const WINDOW_OPEN_CALL = /(?:^|\.)(?:window|self|globalThis|top|parent|opener|frames|document)\.open$/u;
+/** Node `fs.open` flag strings, which are never request URLs. */
+const FS_OPEN_FLAGS = new Set([
+    "a",
+    "a+",
+    "as",
+    "as+",
+    "ax",
+    "ax+",
+    "r",
+    "r+",
+    "rs",
+    "rs+",
+    "sa",
+    "sa+",
+    "sr",
+    "sr+",
+    "w",
+    "w+",
+    "wx",
+    "wx+",
+    "xa",
+    "xa+",
+    "xw",
+    "xw+",
+]);
+/** Reserved browsing-context names (ASCII case-insensitive). */
+const BROWSING_CONTEXT_KEYWORDS = new Set([
+    "_blank",
+    "_parent",
+    "_self",
+    "_top",
+]);
+/**
+ * Read `XMLHttpRequest.open(method, url)`. `fs.open(path, "r")` and
+ * `window.open(url, "_blank")` share the callee name. A literal method must
+ * be an HTTP method; with a computed method, the second literal is a URL
+ * unless it is provably an fs flag or a browsing-context keyword, or the
+ * receiver is spelled as a browsing context or storage. XHR normalizes the standard
+ * methods' case; extension methods such as WebDAV `PROPFIND` are
+ * conventionally uppercase tokens.
+ */
+const xhrOpenUrl = (name, methodNode, urlNode) => {
+    const url = stringValue(urlNode);
+    if (url === undefined)
+        return undefined;
+    const method = stringValue(methodNode);
+    // IndexedDB and Cache Storage `open` take a name and a version, so a
+    // receiver spelled as storage needs a standard HTTP method literal.
+    const storage = storageKind(name) !== undefined;
+    if (method === undefined)
+        return storage ||
+            WINDOW_OPEN_CALL.test(name) ||
+            FS_OPEN_FLAGS.has(url) ||
+            BROWSING_CONTEXT_KEYWORDS.has(url.toLowerCase())
+            ? undefined
+            : url;
+    return XHR_METHODS.has(method.toUpperCase()) ||
+        (!storage && /^[A-Z][A-Z-]*$/u.test(method))
+        ? url
+        : undefined;
+};
+const KEYED_COLLECTION_CONSTRUCTORS = new Set([
+    "FormData",
+    "Headers",
+    "Map",
+    "Set",
+    "URLSearchParams",
+    "WeakMap",
+    "WeakSet",
+]);
+/**
+ * Whether a get/delete receiver is spelled as a keyed collection: a
+ * constructed Map, Set, Headers, FormData, or URLSearchParams, or a
+ * `headers`/`searchParams` property. Spelling alone does not prove the
+ * binding, so callers keep URL and path literals as requests.
+ */
+const isKeyedCollectionReceiver = (callee) => {
+    if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee))
+        return false;
+    const receiver = callee.object;
+    if (t.isNewExpression(receiver))
+        return (t.isIdentifier(receiver.callee) &&
+            KEYED_COLLECTION_CONSTRUCTORS.has(receiver.callee.name));
+    if (!t.isMemberExpression(receiver) &&
+        !t.isOptionalMemberExpression(receiver))
+        return false;
+    const property = semanticStaticPropertyName(receiver.property, receiver.computed);
+    return property === "headers" || property === "searchParams";
+};
 /** Select the literal URL argument for recognized network callees. */
-export const endpointArgument = (name, args) => {
+export const endpointArgument = (name, args, callee) => {
     if (name === "fetch" || name.endsWith(".fetch") || name === "WebSocket")
         return stringValue(args[0]);
-    if (name.endsWith(".open") && stringValue(args[1]) !== undefined)
-        return stringValue(args[1]);
-    if (["get", "post", "put", "patch", "delete", "request"].some((method) => name === method || name.endsWith(`.${method}`)))
-        return stringValue(args[0]);
+    if (name.endsWith(".open"))
+        return xhrOpenUrl(name, args[0], args[1]);
+    const method = ["get", "post", "put", "patch", "delete", "request"].find((candidate) => name === candidate || name.endsWith(`.${candidate}`));
+    if (method !== undefined) {
+        const value = stringValue(args[0]);
+        // Only get and delete also belong to the keyed-collection APIs, whose
+        // keys are header, field, and parameter names rather than URLs or paths.
+        return value !== undefined &&
+            (method === "get" || method === "delete") &&
+            !isRequestUrlLiteral(value) &&
+            isKeyedCollectionReceiver(callee)
+            ? undefined
+            : value;
+    }
     if (name.endsWith("loadURL"))
         return stringValue(args[0]);
     return undefined;
@@ -222,20 +432,24 @@ export const storageKind = (name) => {
     return undefined;
 };
 /** Produce a dotted callee name from member syntax. */
-export const calleeName = (node) => calleeNameAt(node);
-const calleeNameAt = (node) => {
-    if (t.isIdentifier(node))
-        return node.name;
-    if (t.isImport(node))
-        return "import";
-    if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        const object = t.isNode(node.object) ? calleeNameAt(node.object) : "";
-        // A dynamic key commits no name: `target[method]()` must not be reported as
-        // `target.method`, which would fabricate a runtime call shape.
-        const property = memberPropertyName(node);
-        return object === "" ? property : `${object}.${property}`;
+export const calleeName = (node) => {
+    const segments = [];
+    while (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+        // Dynamic keys retain their syntax identity instead of inventing a name.
+        segments.push(memberPropertyName(node));
+        if (!t.isNode(node.object))
+            break;
+        node = node.object;
     }
-    return "";
+    const base = t.isIdentifier(node)
+        ? node.name
+        : t.isImport(node)
+            ? "import"
+            : "";
+    segments.push(base);
+    segments.reverse();
+    const first = segments.findIndex((segment) => segment !== "");
+    return first === -1 ? "" : segments.slice(first).join(".");
 };
 /** Read a member property only when its syntax commits an exact name. */
 const memberPropertyName = (node) => node.computed &&
@@ -243,14 +457,19 @@ const memberPropertyName = (node) => node.computed &&
     !t.isNumericLiteral(node.property)
     ? `[computed@${String(node.property.start ?? -1)}]`
     : semanticStaticPropertyName(node.property, node.computed);
-/** Return a string literal value without evaluating an expression. */
-export const stringValue = (node) => (t.isStringLiteral(node) ? node.value : undefined);
-/** Return a string or numeric argument literal. */
-export const argumentValue = (node) => {
-    if (t.isStringLiteral(node) || t.isNumericLiteral(node))
-        return String(node.value);
+/**
+ * Return a string literal value without evaluating an expression. A template
+ * literal without substitutions denotes the same exact string.
+ */
+export const stringValue = (node) => {
+    if (t.isStringLiteral(node))
+        return node.value;
+    if (t.isTemplateLiteral(node) && node.expressions.length === 0)
+        return node.quasis[0]?.value.cooked ?? undefined;
     return undefined;
 };
+/** Return a string or numeric argument literal. */
+export const argumentValue = (node) => t.isNumericLiteral(node) ? String(node.value) : stringValue(node);
 /** Prefix a static argument value when one is available. */
 export const prefixedArgument = (prefix, node) => {
     const value = argumentValue(node);
@@ -284,7 +503,8 @@ export const sourceRangesEqual = (left, right) => left !== null &&
     left.end.column === right.end.column;
 const pointForOffset = (source, offset) => {
     const before = source.slice(0, offset);
-    const lines = before.split("\n");
+    // Match JavaScript line terminators, treating CRLF as a single newline.
+    const lines = before.split(/\r\n|[\n\r\u2028\u2029]/u);
     return { line: lines.length, column: lines.at(-1)?.length ?? 0 };
 };
 /** Observe known bundler/framework marker strings without claiming dependency use. */
@@ -295,8 +515,6 @@ export const registrationKey = (registration) => `${registration.runtime}\0${reg
 export const sortedUnique = (values, key) => [...new Map(values.map((value) => [key(value), value])).values()].sort((left, right) => compareCodePoints(key(left), key(right)));
 /** Hash exact UTF-8 source text. */
 export const sha256Text = (value) => createHash("sha256").update(value).digest("hex");
-/** Compare strings by Unicode code point for canonical ordering. */
-export const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 /** Recognized route-construction call suffixes. */
 export const STATIC_ROUTE_CALL_NAMES = [
     "route",

package/dist/domain/{sourceToBundleComparison.js → javascript/sourceToBundleComparison.js}

@@ -1,4 +1,5 @@
-import { absenceClaimable, canonicalDigest } from "./comparisonSemantics.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { absenceClaimable, canonicalDigest } from "../comparisonSemantics.js";
 import { SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS, sourceToBundleComparisonResultSchema, } from "./sourceToBundleComparisonSchemas.js";
 import { buildSourceToBundleCandidateIndex, candidateIdsForSource, historicalSourceFiles, scoreSourceToBundleCandidate, sourceBearingNodes, } from "./sourceToBundleSignals.js";
 /** Compare historical source files to static source-bearing application nodes. */
@@ -32,7 +33,7 @@ export const compareSourceToBundle = (input) => {
     };
     return sourceToBundleComparisonResultSchema.parse({
         ...semanticResult,
-        comparison_id: `stbc_${digestCanonical(semanticResult)}`,
+        comparison_id: `stbc_${canonicalDigest(semanticResult, "Source-to-bundle comparison")}`,
     });
 };
 const projectComparison = (input) => {
@@ -208,11 +209,11 @@ const markMergedMappings = (input, items) => {
         return { ...semantic, mapping_id: mappingId(input, semantic) };
     });
 };
-const mappingId = (input, item) => `stbc_item_${digestCanonical({
+const mappingId = (input, item) => `stbc_item_${canonicalDigest({
     reference_root_sha256: input.reference.root_sha256,
     application_graph_id: input.application.graph.graph_id,
     ...item,
-})}`;
+}, "Source-to-bundle comparison")}`;
 const comparisonSummary = (items) => ({
     unchanged: countStatus(items, "unchanged"),
     modified: countStatus(items, "modified"),
@@ -246,7 +247,4 @@ const comparisonLimitations = (factors) => uniqueSorted([
 ]);
 const hasSignal = (candidate, kind) => candidate.signals.some((signal) => signal.kind === kind);
 const compareCandidates = (left, right) => right.score - left.score ||
-    compareText(left.current_node_id, right.current_node_id);
-const digestCanonical = (value) => canonicalDigest(value, "Source-to-bundle comparison");
-const uniqueSorted = (values) => [...new Set(values)].sort(compareText);
-const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+    compareCodePoints(left.current_node_id, right.current_node_id);

package/dist/domain/{sourceToBundleComparisonSchemas.js → javascript/sourceToBundleComparisonSchemas.js}

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { evidenceSchema } from "./evidence.js";
+import { evidenceSchema } from "../evidence.js";
 import { JAVASCRIPT_APPLICATION_NODE_KINDS } from "./javascriptApplicationGraphSchemas.js";
-import { historicalSourceGraphSchema } from "./referenceSourceGraph.js";
-import { digestSchema } from "./../domain/digests.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { historicalSourceGraphSchema } from "../referenceSourceGraph.js";
+import { digestSchema } from "../digests.js";
+import { prefixedDigestSchema } from "../digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const nodeIdSchema = prefixedDigestSchema("jag_node");
 const textSchema = z.string().min(1);

package/dist/domain/{sourceToBundleSignals.js → javascript/sourceToBundleSignals.js}

@@ -1,6 +1,7 @@
 import { posix } from "node:path";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import { SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS, } from "./sourceToBundleComparisonSchemas.js";
-import { isDigest } from "./digests.js";
+import { isDigest } from "../digests.js";
 const RELEVANT_NODE_KINDS = new Set([
     "javascript-asset",
     "javascript-module",
@@ -23,11 +24,11 @@ const signalWeight = (kind) => {
 /** Keep source-bearing application nodes in stable identifier order. */
 export const sourceBearingNodes = (nodes) => nodes
     .filter(({ kind }) => RELEVANT_NODE_KINDS.has(kind))
-    .sort((left, right) => compareText(left.node_id, right.node_id));
+    .sort((left, right) => compareCodePoints(left.node_id, right.node_id));
 /** Keep historical source files in stable path order. */
 export const historicalSourceFiles = (graph) => graph.entries
     .filter((entry) => entry.kind === "file" && entry.classifications.includes("source"))
-    .sort((left, right) => compareText(left.path, right.path));
+    .sort((left, right) => compareCodePoints(left.path, right.path));
 /** Build deterministic candidate indices without assigning fuzzy matches. */
 export const buildSourceToBundleCandidateIndex = (nodes) => {
     const projections = nodes.map(projectCurrentNode);
@@ -62,7 +63,7 @@ export const candidateIdsForSource = (source, index) => {
     for (const group of groups) {
         if (group === undefined)
             continue;
-        for (const nodeId of [...group].sort(compareText)) {
+        for (const nodeId of [...group].sort(compareCodePoints)) {
             if (seen.has(nodeId))
                 continue;
             seen.add(nodeId);
@@ -149,7 +150,7 @@ const signal = (kind, sourceValue, currentValues) => ({
     kind,
     weight: signalWeight(kind),
     source_value: sourceValue,
-    current_values: [...new Set(currentValues)].sort(compareText),
+    current_values: [...new Set(currentValues)].sort(compareCodePoints),
 });
 const candidateConfidence = (signals) => {
     const kinds = new Set(signals.map(({ kind }) => kind));
@@ -190,7 +191,7 @@ const normalizeCurrentPath = (raw) => {
 };
 const uniquePaths = (paths) => [
     ...new Map(paths.map((path) => [`${path.kind}\0${path.value}`, path])).values(),
-].sort((left, right) => compareText(`${left.kind}\0${left.value}`, `${right.kind}\0${right.value}`));
+].sort((left, right) => compareCodePoints(`${left.kind}\0${left.value}`, `${right.kind}\0${right.value}`));
 const pathSuffixes = (path) => {
     const parts = path.split("/");
     return parts.map((_, index) => parts.slice(index).join("/"));
@@ -200,4 +201,3 @@ const addIndexValue = (index, key, nodeId) => {
     values.add(nodeId);
     index.set(key, values);
 };
-const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/domain/jsonShape.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { compareCodePoints } from "./canonicalOrdering.js";
 const jsonValueTypeSchema = z.enum([
     "object",
     "array",
@@ -24,7 +25,9 @@ export const inferJsonShape = (text) => {
     try {
         root = JSON.parse(text);
     }
-    catch {
+    catch (cause) {
+        // Invalid JSON is represented by the null return.
+        void cause;
         return null;
     }
     const properties = new Map();
@@ -76,7 +79,8 @@ export const inferJsonShape = (text) => {
             types: [...value.types].sort(),
             observations: value.observations,
         }))
-            .sort((left, right) => left.path.localeCompare(right.path)),
+            .sort((left, right) => left.path.localeCompare(right.path) ||
+            compareCodePoints(left.path, right.path)),
     });
 };
 const jsonValueType = (value) => {

package/dist/domain/{managedApplicationGraph.js → managed/managedApplicationGraph.js}

@@ -1,13 +1,13 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { z } from "zod";
-import { evidenceSchema, parseEvidence } from "./evidence.js";
-import { createJavaScriptApplicationGraph, javascriptApplicationGraphSchema, } from "./javascriptApplicationGraph.js";
+import { evidenceSchema, parseEvidence } from "../evidence.js";
+import { createJavaScriptApplicationGraph, javascriptApplicationGraphSchema, } from "../javascript/javascriptApplicationGraph.js";
 import { managedArtifactInspectionSchema, managedMemberInspectionSchema, managedNativeBoundaryInspectionSchema, } from "./managedArtifact.js";
 import { assessManagedGraphOmissions, managedGraphEvidenceCoverage, managedGraphResultCoverage, } from "./managedApplicationGraphCoverage.js";
 import { addArtifactNode, addArtifactIdentityNodes, addBoundaryNodes, addMemberNodes, } from "./managedApplicationGraphNodes.js";
-import { digestSchema } from "./../domain/digests.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { digestSchema } from "../digests.js";
+import { prefixedDigestSchema } from "../digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const textSchema = z.string().min(1);
 /** Authenticated managed Evidence records projected into the application graph. */

package/dist/domain/{managedApplicationGraphNodes.js → managed/managedApplicationGraphNodes.js}

@@ -1,5 +1,5 @@
 import { basename } from "node:path";
-import { createJavaScriptApplicationEdge, createJavaScriptApplicationNode, } from "./javascriptApplicationGraph.js";
+import { createJavaScriptApplicationEdge, createJavaScriptApplicationNode, } from "../javascript/javascriptApplicationGraph.js";
 import { managedSourceCoverage } from "./managedApplicationGraphCoverage.js";
 import {} from "./managedArtifact.js";
 import { moduleCoverageState } from "./managedApplicationGraphNodeCoverage.js";

package/dist/domain/{managedArtifact.js → managed/managedArtifact.js}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { digestSchema } from "./../domain/digests.js";
+import { digestSchema } from "../digests.js";
 const tokenSchema = z.string().regex(/^0x[0-9a-f]{8}$/u);
 const offsetSchema = z.number().int().min(0);
 /** A 16-byte CLI metadata GUID without RFC 4122 version/variant restrictions. */

package/dist/domain/{managedMemberComparison.js → managed/managedMemberComparison.js}

@@ -1,12 +1,12 @@
 import { z } from "zod";
-import { emptyArraySchema } from "./emptyArraySchema.js";
-import { evidenceSchema } from "./evidence.js";
+import { emptyArraySchema } from "../emptyArraySchema.js";
+import { evidenceSchema } from "../evidence.js";
 import { cliMetadataGuidSchema, } from "./managedArtifact.js";
 import { buildComparisonCoverage, buildComparisonMatching, buildComparisonSummary, comparisonLimitations, sideManifest, } from "./managedMemberComparisonCoverage.js";
 import { buildFieldItems, buildMethodItems, } from "./managedMemberComparisonItems.js";
 import { keyMembers, sha256 } from "./managedMemberComparisonMatch.js";
-import { digestSchema } from "./../domain/digests.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { digestSchema } from "../digests.js";
+import { prefixedDigestSchema } from "../digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const tokenSchema = z.string().regex(/^0x[0-9a-f]{8}$/u);
 const boundedTextSchema = z.string().min(1);
@@ -97,6 +97,7 @@ const methodComparisonItemSchema = comparisonItemSchema({
     ...comparisonItemContextShape,
     item_id: prefixedDigestSchema("mmc_method"),
     dimensions: z.array(z.enum([
+        "metadata",
         "signature",
         "cil",
         "opcode-shape",

package/dist/domain/{managedMemberComparisonCoverage.js → managed/managedMemberComparisonCoverage.js}

@@ -33,7 +33,7 @@ export const buildComparisonSummary = (items) => ({
 });
 export const buildComparisonMatching = (methodItems, fieldItems) => ({
     exact_il_signature: methodItems.filter(({ match }) => match.basis === "exact-il-signature").length,
-    exact_signature: methodItems.filter(({ match }) => match.basis === "exact-signature").length,
+    exact_signature: [...methodItems, ...fieldItems].filter(({ match }) => match.basis === "exact-signature").length,
     structural_method_shape: methodItems.filter(({ match }) => match.basis === "structural-method-shape").length,
     field_signature: fieldItems.filter(({ match }) => match.basis === "field-signature").length,
     ambiguous: methodItems.filter(({ match }) => match.status === "ambiguous").length +
@@ -44,6 +44,7 @@ export const comparisonLimitations = (left, right) => {
     const limitations = [
         "Metadata tokens are build-local coordinates; matched pairs are remaps, not persistent identities.",
         "Methods pair by exact CIL/signature, then declared type, name, and signature, then structural shape; names alone are never a matching basis.",
+        "Fields pair by exact signature, then declared type, name, and signature; an undecoded signature is compared only by its raw bytes, and an unmatched member with one stays unknown.",
     ];
     if (left.coverage.state !== "complete" || right.coverage.state !== "complete")
         limitations.push("At least one managed member observation is partial.");