rea-agents 4.0.1 → 5.0.0

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

@@ -1,16 +1,7 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
 import { z } from "zod";
+import { canonicalDigest, canonicalJson } from "../comparisonSemantics.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 import { applicationEdgeInputSchema, applicationEdgeSchema, applicationNodeInputSchema, applicationNodeObservationSchema, applicationNodeSchema, javascriptApplicationGraphInputSchema, javascriptApplicationGraphRecordSchema, } from "./javascriptApplicationGraphSchemas.js";
-/** Compare strings by Unicode code point for canonical graph ordering. */
-export const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;
-const canonicalJson = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("JavaScript Application Graph could not canonicalize data");
-    return encoded;
-};
-const digestCanonical = (value) => createHash("sha256").update(canonicalJson(value)).digest("hex");
 const OBSERVATION_IDENTIFIER_STRATEGY = {
     strategy: "semantic-content-sha256",
     stability: "observation-exact",
@@ -19,8 +10,7 @@ const EDGE_IDENTIFIER_STRATEGY = {
     strategy: "semantic-content-sha256",
     stability: "relationship-exact",
 };
-const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);
-const limitKey = (limit) => canonicalJson(limit);
+const limitKey = (limit) => canonicalJson(limit, "JavaScript Application Graph");
 const normalizeLimits = (limits) => [...new Map(limits.map((limit) => [limitKey(limit), limit])).values()].sort((left, right) => compareCodePoints(limitKey(left), limitKey(right)));
 const normalizeEvidence = (evidence) => ({
     ...evidence,
@@ -38,10 +28,10 @@ const nodeSemantic = (node) => ({
     kind: node.kind,
     identity: node.identity,
 });
-const nodeId = (node) => `jag_node_${digestCanonical(nodeSemantic(node))}`;
+const nodeId = (node) => `jag_node_${canonicalDigest(nodeSemantic(node), "JavaScript Application Graph")}`;
 const observationSemantic = (nodeIdentifier, observation) => ({ node_id: nodeIdentifier, ...observation });
-const observationId = (nodeIdentifier, observation) => `jag_observation_${digestCanonical(observationSemantic(nodeIdentifier, observation))}`;
-const edgeId = (edge) => `jag_edge_${digestCanonical(edge)}`;
+const observationId = (nodeIdentifier, observation) => `jag_observation_${canonicalDigest(observationSemantic(nodeIdentifier, observation))}`;
+const edgeId = (edge) => `jag_edge_${canonicalDigest(edge, "JavaScript Application Graph")}`;
 const sortedUniqueIssue = (values, path, label, context) => {
     for (let index = 1; index < values.length; index += 1) {
         if (compareCodePoints(values[index - 1] ?? "", values[index] ?? "") < 0)
@@ -113,8 +103,8 @@ const checkNode = (node, index, context) => {
             path: ["nodes", index, "node_id"],
         });
     if (node.identity.strategy === "structural-fingerprint" &&
-        canonicalJson(node.identity.basis) !==
-            canonicalJson(uniqueSorted(node.identity.basis)))
+        canonicalJson(node.identity.basis, "JavaScript Application Graph") !==
+            canonicalJson(uniqueSorted(node.identity.basis), "JavaScript Application Graph"))
         context.addIssue({
             code: "custom",
             message: "Structural fingerprint basis must be sorted and unique",
@@ -198,7 +188,8 @@ const checkGraphInvariants = (graph, context) => {
         checkEvidenceNormalization(edge.evidence, ["edges", index, "evidence"], context);
     }
     const { graph_id: identifier, ...semantic } = graph;
-    if (identifier !== `jag_${digestCanonical(semantic)}`)
+    if (identifier !==
+        `jag_${canonicalDigest(semantic, "JavaScript Application Graph")}`)
         context.addIssue({
             code: "custom",
             message: "Graph identifier does not match its semantic content",
@@ -261,12 +252,12 @@ export const createJavaScriptApplicationGraph = (input) => {
     };
     return javascriptApplicationGraphSchema.parse({
         ...semantic,
-        graph_id: `jag_${digestCanonical(semantic)}`,
+        graph_id: `jag_${canonicalDigest(semantic, "JavaScript Application Graph")}`,
     });
 };
 /** Parse a stored graph and reject stale IDs. */
 export const parseJavaScriptApplicationGraph = (input) => javascriptApplicationGraphSchema.parse(input);
 /** Compute the byte-stable SHA-256 commitment of a verified graph. */
-export const computeJavaScriptApplicationGraphSha256 = (input) => digestCanonical(parseJavaScriptApplicationGraph(input));
+export const computeJavaScriptApplicationGraphSha256 = (input) => canonicalDigest(parseJavaScriptApplicationGraph(input), "JavaScript Application Graph");
 /** Serialize a verified graph as RFC 8785 canonical JSON. */
-export const serializeJavaScriptApplicationGraph = (input) => canonicalJson(parseJavaScriptApplicationGraph(input));
+export const serializeJavaScriptApplicationGraph = (input) => canonicalJson(parseJavaScriptApplicationGraph(input), "JavaScript Application Graph");

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { applicationCoverageSchema, applicationGraphEvidenceSchema, applicationNodeIdentitySchema, } from "./javascriptApplicationEvidenceSchemas.js";
-import { jsonValueSchema } from "./jsonValue.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { jsonValueSchema } from "../jsonValue.js";
+import { prefixedDigestSchema } from "../digests.js";
 const boundedTextSchema = z.string().min(1);
 /** Node kinds admitted by JavaScript Application Graph. */
 export const JAVASCRIPT_APPLICATION_NODE_KINDS = [

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

@@ -1,8 +1,7 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
+import { canonicalDigest } from "../comparisonSemantics.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
 import { buildJavaScriptApplicationChangeGraph } from "./javascriptApplicationChangeGraph.js";
 import { applicationVersionComparisonResultSchema, } from "./javascriptApplicationVersionComparisonSchemas.js";
-import { compareCodePoints } from "./javascriptApplicationGraph.js";
 import { classifyJavaScriptApplicationVersions } from "./javascriptApplicationVersionItems.js";
 import { matchJavaScriptApplicationVersions } from "./javascriptApplicationVersionKeys.js";
 /** Compare application entities with ordered unique-only identity tiers. */
@@ -50,7 +49,7 @@ export const compareJavaScriptApplicationVersions = (input) => {
     };
     return applicationVersionComparisonResultSchema.parse({
         ...semantic,
-        comparison_id: `javc_${digestCanonical(semantic)}`,
+        comparison_id: `javc_${canonicalDigest(semantic, "Application version comparison")}`,
     });
 };
 const summary = (items) => ({
@@ -103,10 +102,3 @@ const comparisonLimitations = (input) => uniqueSorted([
             "At least one source graph is incomplete; unmatched entities on the opposite side remain unknown rather than added or removed.",
         ]),
 ]);
-const digestCanonical = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Application version comparison could not canonicalize data");
-    return createHash("sha256").update(encoded).digest("hex");
-};
-const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);

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

@@ -1,9 +1,9 @@
 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 { javascriptApplicationGraphSchema } from "./javascriptApplicationGraph.js";
 import { JAVASCRIPT_APPLICATION_NODE_KINDS } from "./javascriptApplicationGraphSchemas.js";
-import { prefixedDigestSchema } from "./../domain/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/{javascriptApplicationVersionItems.js → javascript/javascriptApplicationVersionItems.js}

@@ -1,5 +1,6 @@
-import { absenceClaimable, canonicalDigest, canonicalJson, } from "./comparisonSemantics.js";
-import { compareCodePoints, } from "./javascriptApplicationGraph.js";
+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 }) => [
@@ -279,7 +280,7 @@ const pairLimitations = (pair, status) => [
 ];
 const itemWithId = (semantic) => ({
     ...semantic,
-    item_id: `javc_item_${digestCanonical(semantic)}`,
+    item_id: `javc_item_${canonicalDigest(semantic, "Application version item")}`,
 });
 const stringProperty = (node, key) => {
     const values = [
@@ -291,4 +292,3 @@ const stringProperty = (node, key) => {
 };
 const graphsComplete = (context) => absenceClaimable(context.leftGraph.coverage) &&
     absenceClaimable(context.rightGraph.coverage);
-const digestCanonical = (value) => canonicalDigest(value, "Application version item");

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

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "./javascriptApplicationGraph.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 const matchTiers = () => [
     {
         match: { basis: "exact-content-digest", confidence: "exact" },
@@ -136,16 +136,21 @@ const semanticKey = (node) => {
     return value === null ? null : `semantic\0${node.kind}\0${value}`;
 };
 const semanticValue = (node, properties) => {
-    if (node.kind === "endpoint")
-        return joined(properties.endpoint_kind, properties.value);
+    if (node.kind === "endpoint") {
+        const kind = nonEmptyString(properties.endpoint_kind);
+        const value = exactString(properties.value);
+        return kind === null || value === null ? null : `${kind}\0${value}`;
+    }
     if (node.kind === "storage")
         return joined(properties.storage_kind, properties.name ?? properties.mechanism);
     if (node.kind === "ipc-channel")
         return properties.resolution === "dynamic"
             ? null
-            : (stringValue(properties.channel) ?? firstLabel(node));
+            : (exactString(properties.channel) ?? firstLabel(node));
     if (node.kind === "context-bridge-api")
-        return firstLabel(node) ?? stringValue(properties.api_name);
+        return (firstLabel(node) ??
+            exactString(properties.api_key) ??
+            nonEmptyString(properties.api_name));
     if (node.kind === "native-export")
         return (joined(properties.specifier, stringList(properties.requested_members).join(",")) ?? firstLabel(node));
     if ([
@@ -156,8 +161,8 @@ const semanticValue = (node, properties) => {
     ].includes(node.kind))
         return joined(properties.declared_path, properties.resolved_path);
     if (node.kind === "package")
-        return stringValue(properties.name);
-    return canonicalPath(node) ?? stringValue(properties.path);
+        return nonEmptyString(properties.name);
+    return canonicalPath(node) ?? nonEmptyString(properties.path);
 };
 const canonicalPath = (node) => node.identity.strategy === "canonical-path" ? node.identity.path : null;
 const firstProperties = (node) => node.observations[0]?.properties ?? {};
@@ -171,10 +176,12 @@ const uniqueStringProperty = (node, name) => {
     return values.length === 1 ? (values[0] ?? null) : null;
 };
 const joined = (...values) => {
-    const strings = values.map(stringValue);
+    const strings = values.map(nonEmptyString);
     return strings.some((value) => value === null) ? null : strings.join("\0");
 };
-const stringValue = (value) => typeof value === "string" && value !== "" ? value : null;
+const nonEmptyString = (value) => typeof value === "string" && value !== "" ? value : null;
+/** A literal value such as `ipcMain.handle("")` keeps its exact empty text. */
+const exactString = (value) => typeof value === "string" ? value : null;
 const stringList = (value) => Array.isArray(value)
     ? value
         .filter((item) => typeof item === "string")

package/dist/domain/javascript/javascriptArtifactFiles.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,24 +1,31 @@
 import { createHash } from "node:crypto";
 import * as t from "@babel/types";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import { propertyName } from "./javascriptAstValues.js";
+import { stringValue } from "./javascriptStaticAnalysisHelpers.js";
 /** Derive a rename-resistant syntax fingerprint without code execution. */
 export const fingerprintJavaScriptAst = (node) => {
     const tokens = [];
-    t.traverseFast(node, (current) => {
-        tokens.push(...semanticTokens(current));
-        return undefined;
+    traverseJavaScriptAst(node, {
+        enter: (current) => {
+            tokens.push(...semanticTokens(current));
+            return undefined;
+        },
     });
     return createHash("sha256").update(JSON.stringify(tokens)).digest("hex");
 };
 /** Collect statically declared CommonJS/bundler export names from one factory. */
 export const collectJavaScriptExports = (node) => {
     const exports = new Set();
-    t.traverseFast(node, (current) => {
-        if (t.isAssignmentExpression(current))
-            collectAssignmentExports(current.left, current.right, exports);
-        if (t.isCallExpression(current))
-            collectCallExports(current, exports);
-        return undefined;
+    traverseJavaScriptAst(node, {
+        enter: (current) => {
+            if (t.isAssignmentExpression(current))
+                collectAssignmentExports(current.left, current.right, exports);
+            if (t.isCallExpression(current))
+                collectCallExports(current, exports);
+            return undefined;
+        },
     });
     return {
         values: [...exports].sort(compareCodePoints),
@@ -93,18 +100,27 @@ const addExport = (output, name) => {
     output.add(name);
 };
 const memberPath = (node) => {
-    if (node === undefined || node === null)
-        return "";
-    if (t.isIdentifier(node) || t.isPrivateName(node))
-        return t.isIdentifier(node) ? node.name : "";
-    if (t.isThisExpression(node))
-        return "this";
-    if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        const object = t.isNode(node.object) ? memberPath(node.object) : "";
-        const property = propertyName(node.property);
-        return object === "" ? property : `${object}.${property}`;
+    const properties = [];
+    let current = node;
+    while (current !== undefined &&
+        current !== null &&
+        (t.isMemberExpression(current) || t.isOptionalMemberExpression(current))) {
+        properties.push(propertyName(current.property));
+        current = t.isNode(current.object) ? current.object : undefined;
+    }
+    const root = current !== undefined && t.isIdentifier(current)
+        ? current.name
+        : current !== undefined && t.isThisExpression(current)
+            ? "this"
+            : "";
+    if (properties.length === 0)
+        return root;
+    properties.reverse();
+    const path = root === "" ? [] : [root];
+    for (const property of properties) {
+        if (path.length === 0 && property === "")
+            continue;
+        path.push(property);
     }
-    return "";
+    return path.join(".");
 };
-const stringValue = (node) => t.isStringLiteral(node) ? node.value : undefined;
-const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/domain/javascript/javascriptAstValues.js

@@ -0,0 +1,23 @@
+import * as t from "@babel/types";
+/** Read an identifier or literal property name without evaluating syntax. */
+export const propertyName = (node) => {
+    if (t.isIdentifier(node))
+        return node.name;
+    if (t.isStringLiteral(node) || t.isNumericLiteral(node))
+        return String(node.value);
+    return "";
+};
+/** Read a property name only when its syntax commits to one exact key. */
+export const semanticStaticPropertyName = (property, computed) => semanticStaticPropertyKey(property, computed) ?? "";
+/** Read an exact property key, preserving the legal empty-string key. */
+export const semanticStaticPropertyKey = (property, computed) => {
+    if (t.isStringLiteral(property) || t.isNumericLiteral(property))
+        return String(property.value);
+    return !computed && t.isIdentifier(property) ? property.name : null;
+};
+/**
+ * Display an exact JavaScript string as nonempty label text. Graph labels and
+ * artifact-local keys are nonempty, so the legal empty value is shown as `""`;
+ * producers keep the exact value in their properties.
+ */
+export const javascriptDisplayText = (value) => value === "" ? '""' : value;

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

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "./javascriptApplicationGraph.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
 import { digestExportShapeValue } from "./javascriptExportShapeComparisonIdentity.js";
 import { javaScriptExportShapeComparisonResultSchema, } from "./javascriptExportShapeComparisonSchemas.js";
 import { retainJavaScriptExportShapes, selectJavaScriptExport, } from "./javascriptExportShapeSelection.js";
@@ -136,4 +136,3 @@ const evidencePair = (left, right) => [
     left,
     right,
 ];
-const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { evidenceSchema } from "./evidence.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { evidenceSchema } from "../evidence.js";
+import { prefixedDigestSchema } from "../digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const graphIdSchema = prefixedDigestSchema("jag");
 const nodeIdSchema = prefixedDigestSchema("jag_node");

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

@@ -1,5 +1,5 @@
-import { compareCodePoints } from "./javascriptApplicationGraph.js";
 import { projectedExportReturnShapesSchema, } from "./javascriptExportShapeComparisonSchemas.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 /** Select one exact trusted export and its exact static return-shape observation. */
 export const selectJavaScriptExport = (side) => {
     const candidates = exportCandidates(side.graph);

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

@@ -1,5 +1,5 @@
-import { compareCodePoints } from "./javascriptApplicationGraph.js";
 import { canonicalExportShapeValue, digestExportShapeValue, } from "./javascriptExportShapeComparisonIdentity.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 /** Pair variants only through reciprocal unique exact literal discriminants. */
 export const pairJavaScriptExportShapeVariants = (left, right) => {
     const leftKeys = discriminantOccurrences(left);
@@ -138,7 +138,12 @@ const emptyShapeUnknownChange = (input) => changeWithId({
 const diffPair = (left, right, discriminant, evidenceLinks) => {
     const leftFields = new Map(left.fields.map((field) => [field.path, field]));
     const rightFields = new Map(right.fields.map((field) => [field.path, field]));
-    const paths = uniqueSorted([...leftFields.keys(), ...rightFields.keys()]);
+    const paths = uniqueSorted([
+        ...leftFields.keys(),
+        ...rightFields.keys(),
+        ...left.property_coverage.map(({ path }) => path),
+        ...right.property_coverage.map(({ path }) => path),
+    ]);
     return paths.flatMap((path) => {
         const leftField = fieldAtPath(left, leftFields, path);
         const rightField = fieldAtPath(right, rightFields, path);
@@ -282,4 +287,3 @@ const isPrimitive = (value) => value === null ||
     typeof value === "number" ||
     typeof value === "boolean";
 const capitalize = (value) => `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
-const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);

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

@@ -1,4 +1,5 @@
-import { compareCodePoints } from "./javascriptApplicationGraph.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
+import { featureSeedMatchMode, } from "./javascriptFeatureTraceSchemas.js";
 /** Locate every graph node matching a typed literal seed without regex execution. */
 export const findApplicationFeatureSeeds = (nodes, seed) => nodes
     .flatMap((node) => seedMatch(node, seed))
@@ -17,7 +18,7 @@ const seedMatch = (node, seed) => {
             : [];
     if (!kindMatches(node, seed.kind))
         return [];
-    const mode = seed.match ?? (seed.kind === "string" ? "contains" : "exact");
+    const mode = featureSeedMatchMode(seed);
     const query = normalized(seed.value, seed.case_sensitive);
     const match = candidateFields(node, seed.kind).find((candidate) => {
         const value = normalized(candidate.value, seed.case_sensitive);
@@ -67,11 +68,20 @@ const candidateFields = (node, seedKind) => {
     if (seedKind === "string")
         return fields;
     const names = relevantFields[seedKind];
-    return fields.filter(({ field }) => names.some((name) => field === "identity" || field.endsWith(name)));
+    return fields.filter(({ field, selectionPath = field }) => names.some((name) => {
+        const path = memberFieldSuffixes.has(name) ? selectionPath : field;
+        return path === "identity" || path.endsWith(name);
+    }));
 };
+const memberFieldSuffixes = new Set([
+    ".members",
+    ".methods",
+    ".exports",
+    ".requested_members",
+]);
 const relevantFields = {
     route: [".label", ".value", ".path"],
-    api: [".label", ".api_name", ".key", ".methods", ".members"],
+    api: [".label", ".api_name", ".api_key", ".key", ".methods", ".members"],
     channel: [".label", ".channel", ".key"],
     module: [
         ".label",
@@ -113,29 +123,40 @@ const identityFields = (node) => {
 };
 const propertyFields = (value, prefix) => {
     const output = [];
-    const pending = [
-        { current: value, path: prefix },
-    ];
+    const pending = [{ current: value, path: prefix, selectionPath: prefix }];
     while (pending.length > 0) {
         const next = pending.pop();
         if (next === undefined)
             continue;
-        const { current, path } = next;
+        const { current, path, selectionPath } = next;
         if (typeof current === "string") {
-            output.push({ basis: "property", field: path, value: current });
+            output.push({
+                basis: "property",
+                field: path,
+                selectionPath,
+                value: current,
+            });
             continue;
         }
         if (Array.isArray(current)) {
             for (let index = current.length - 1; index >= 0; index -= 1) {
                 const item = current[index];
                 if (item !== undefined)
-                    pending.push({ current: item, path: `${path}[${String(index)}]` });
+                    pending.push({
+                        current: item,
+                        path: `${path}[${String(index)}]`,
+                        selectionPath,
+                    });
             }
             continue;
         }
         if (current !== null && typeof current === "object") {
             for (const key of Object.keys(current).sort(compareCodePoints).reverse())
-                pending.push({ current: current[key] ?? null, path: `${path}.${key}` });
+                pending.push({
+                    current: current[key] ?? null,
+                    path: `${path}.${key}`,
+                    selectionPath: `${selectionPath}.${key}`,
+                });
         }
     }
     return output;

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

@@ -1,6 +1,6 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
-import { compareCodePoints, createJavaScriptApplicationGraph, } from "./javascriptApplicationGraph.js";
+import { canonicalDigest } from "../comparisonSemantics.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { createJavaScriptApplicationGraph, } from "./javascriptApplicationGraph.js";
 import { applicationFeatureTraceResultSchema, } from "./javascriptFeatureTraceSchemas.js";
 import { findApplicationFeatureSeeds, } from "./javascriptFeatureSeed.js";
 import { traverseApplicationFeature, } from "./javascriptFeatureTraversal.js";
@@ -46,7 +46,7 @@ export const traceApplicationFeature = (input) => {
     };
     return applicationFeatureTraceResultSchema.parse({
         ...semantic,
-        trace_id: `jatr_${digestCanonical(semantic)}`,
+        trace_id: `jatr_${canonicalDigest(semantic, "Feature trace")}`,
     });
 };
 const noMatchResult = (input) => {
@@ -83,7 +83,7 @@ const noMatchResult = (input) => {
     };
     return applicationFeatureTraceResultSchema.parse({
         ...semantic,
-        trace_id: `jatr_${digestCanonical(semantic)}`,
+        trace_id: `jatr_${canonicalDigest(semantic, "Feature trace")}`,
     });
 };
 const traceGraph = (input, seedMatches, traversal) => {
@@ -142,7 +142,10 @@ const pathTo = (node, predecessors, edgeById) => {
         authorities: uniqueSorted(edges.map(({ evidence }) => evidence.authority)),
         contains_inference: edges.some(({ evidence }) => evidence.state === "inferred"),
     };
-    return { ...semantic, path_id: `jatp_${digestCanonical(semantic)}` };
+    return {
+        ...semantic,
+        path_id: `jatp_${canonicalDigest(semantic, "Feature trace")}`,
+    };
 };
 const isTerminal = (node) => ["endpoint", "storage", "native-addon", "native-export", "unknown"].includes(node.kind);
 const factSummary = (nodes, edges) => {
@@ -169,10 +172,3 @@ const sourceCoverageLimitations = (graph) => graph.coverage.status === "complete
     : [
         "The source application graph is incomplete; unmatched seeds and frontiers remain unknown.",
     ];
-const digestCanonical = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Feature trace could not canonicalize data");
-    return createHash("sha256").update(encoded).digest("hex");
-};
-const uniqueSorted = (values) => [...new Set(values)].sort(compareCodePoints);

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

@@ -1,27 +1,41 @@
 import { z } from "zod";
-import { evidenceSchema, providerSchema } from "./evidence.js";
+import { evidenceSchema, providerSchema } from "../evidence.js";
 import { javascriptApplicationGraphSchema } from "./javascriptApplicationGraph.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 nodeIdSchema = prefixedDigestSchema("jag_node");
 const edgeIdSchema = prefixedDigestSchema("jag_edge");
 const boundedTextSchema = z.string().min(1);
-/** Literal starting point for one application feature trace. */
-const applicationFeatureSeedSchema = z.strictObject({
-    kind: z.enum([
-        "node-id",
-        "route",
-        "string",
-        "api",
-        "channel",
-        "module",
-        "native-export",
-    ]),
-    value: boundedTextSchema,
-    match: z.enum(["exact", "contains"]).nullable().default(null),
-    case_sensitive: z.boolean().default(false),
-});
+/** Matching mode for a literal seed: string seeds default to containment. */
+export const featureSeedMatchMode = (seed) => seed.match ?? (seed.kind === "string" ? "contains" : "exact");
+const literalSeedKinds = [
+    "route",
+    "string",
+    "api",
+    "channel",
+    "module",
+    "native-export",
+];
+/**
+ * Literal starting point for one application feature trace. An empty value,
+ * such as the channel in `ipcMain.handle("")`, must be an explicit exact
+ * literal seed: empty containment would select every node.
+ */
+const applicationFeatureSeedSchema = z.union([
+    z.strictObject({
+        kind: z.enum(["node-id", ...literalSeedKinds]),
+        value: boundedTextSchema,
+        match: z.enum(["exact", "contains"]).nullable().default(null),
+        case_sensitive: z.boolean().default(false),
+    }),
+    z.strictObject({
+        kind: z.enum(literalSeedKinds),
+        value: z.literal(""),
+        match: z.literal("exact"),
+        case_sensitive: z.boolean().default(false),
+    }),
+]);
 /** Evidence-backed application graph and feature seed. */
 export const traceApplicationFeatureInputSchema = z
     .strictObject({

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

@@ -1,4 +1,5 @@
-import { compareCodePoints, } from "./javascriptApplicationGraph.js";
+import {} from "./javascriptApplicationGraph.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 /** Traverse a JAG without treating edge inference as observed reachability. */
 export const traverseApplicationFeature = (graph, seedNodeIds, direction) => {
     const nodeById = new Map(graph.nodes.map((node) => [node.node_id, node]));
@@ -53,5 +54,9 @@ const buildAdjacency = (edges, direction) => {
     return adjacency;
 };
 const addAdjacency = (adjacency, nodeId, entry) => {
-    adjacency.set(nodeId, [...(adjacency.get(nodeId) ?? []), entry]);
+    const entries = adjacency.get(nodeId);
+    if (entries === undefined)
+        adjacency.set(nodeId, [entry]);
+    else
+        entries.push(entry);
 };

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

@@ -1,4 +1,5 @@
-import { compareCodePoints, } from "./javascriptApplicationGraph.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
+import {} from "./javascriptApplicationGraph.js";
 /** Build provider-neutral addon targets and link exact-subject native Evidence. */
 export const buildJavaScriptNativeHandoffs = (nodes, edges, nativeEvidence) => {
     const nodeById = new Map(nodes.map((node) => [node.node_id, node]));