rea-agents 6.2.0 → 6.3.0

package/dist/domain/javascript/javascriptExportShapeComparison.js

@@ -1,4 +1,5 @@
-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";
@@ -65,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/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,24 +48,34 @@ 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 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"]),
@@ -138,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),
@@ -163,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),
 };
@@ -217,7 +226,8 @@ const propertyPresenceSchema = z.enum([
     "absent",
     "unknown-coverage",
 ]);
-const comparisonChangeSchema = z.strictObject({
+/** 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,
@@ -233,8 +243,6 @@ 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"]),
@@ -260,7 +268,7 @@ export const javaScriptExportShapeComparisonResultSchema = z.strictObject({
         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);
@@ -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) => {

package/dist/domain/javascript/javascriptExportShapeVariants.js

@@ -1,5 +1,6 @@
 import { canonicalExportShapeValue, digestExportShapeValue, } from "./javascriptExportShapeComparisonIdentity.js";
-import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 const UNKNOWN_COVERAGE_PRESENCE = {
     left: "unknown-coverage",
     right: "unknown-coverage",
@@ -139,7 +140,7 @@ const addTarget = (map, source, target) => {
     map.set(source, values);
 };
 const indexesNotIn = (shapes, paired) => shapes.map((_, index) => index).filter((index) => !paired.has(index));
-const compareDiscriminants = (left, right) => compareCodePoints(canonicalExportShapeValue(left), canonicalExportShapeValue(right));
+const compareDiscriminants = (left, right) => compareUnicodeCodePoints(canonicalExportShapeValue(left), canonicalExportShapeValue(right));
 const selectionUnknownChange = (input) => changeWithId({
     status: "unknown",
     path: "",

package/dist/domain/javascript/javascriptFeatureSeed.js

@@ -1,9 +1,9 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.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))
-    .sort((left, right) => compareCodePoints(`${left.node_id}\0${left.basis}\0${left.field}`, `${right.node_id}\0${right.basis}\0${right.field}`));
+    .sort((left, right) => compareUnicodeCodePoints(`${left.node_id}\0${left.basis}\0${left.field}`, `${right.node_id}\0${right.basis}\0${right.field}`));
 const seedMatch = (node, seed) => {
     if (seed.kind === "node-id")
         return node.node_id === seed.value
@@ -171,7 +171,9 @@ const propertyFields = (value, prefix) => {
             continue;
         }
         if (current !== null && typeof current === "object") {
-            for (const key of Object.keys(current).sort(compareCodePoints).reverse())
+            for (const key of Object.keys(current)
+                .sort(compareUnicodeCodePoints)
+                .reverse())
                 pending.push({
                     current: current[key] ?? null,
                     path: `${path}.${key}`,

package/dist/domain/javascript/javascriptFeatureTrace.js

@@ -1,5 +1,6 @@
-import { canonicalDigest } from "../comparisonSemantics.js";
-import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { digestCanonicalValue } from "../canonicalDigest.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { createJavaScriptApplicationGraph, } from "./javascriptApplicationGraph.js";
 import { applicationFeatureTraceResultSchema, } from "./javascriptFeatureTraceSchemas.js";
 import { findApplicationFeatureSeeds, } from "./javascriptFeatureSeed.js";
@@ -46,7 +47,7 @@ export const traceApplicationFeature = (input) => {
     };
     return applicationFeatureTraceResultSchema.parse({
         ...semantic,
-        trace_id: `jatr_${canonicalDigest(semantic, "Feature trace")}`,
+        trace_id: `jatr_${digestCanonicalValue(semantic, "Feature trace")}`,
     });
 };
 const noMatchResult = (input) => {
@@ -83,7 +84,7 @@ const noMatchResult = (input) => {
     };
     return applicationFeatureTraceResultSchema.parse({
         ...semantic,
-        trace_id: `jatr_${canonicalDigest(semantic, "Feature trace")}`,
+        trace_id: `jatr_${digestCanonicalValue(semantic, "Feature trace")}`,
     });
 };
 const traceGraph = (input, seedMatches, traversal) => {
@@ -112,7 +113,7 @@ const terminalPaths = (traversal, seeds) => {
         (!seedIds.has(node.node_id) || traversal.nodes.length === 1))
         .map((node) => pathTo(node, traversal.predecessors, edgeById))
         .filter((path) => path !== null)
-        .sort((left, right) => compareCodePoints(left.path_id, right.path_id));
+        .sort((left, right) => compareUnicodeCodePoints(left.path_id, right.path_id));
 };
 const pathTo = (node, predecessors, edgeById) => {
     const nodeIds = [node.node_id];
@@ -144,7 +145,7 @@ const pathTo = (node, predecessors, edgeById) => {
     };
     return {
         ...semantic,
-        path_id: `jatp_${canonicalDigest(semantic, "Feature trace")}`,
+        path_id: `jatp_${digestCanonicalValue(semantic, "Feature trace")}`,
     };
 };
 const isTerminal = (node) => ["endpoint", "storage", "native-addon", "native-export", "unknown"].includes(node.kind);

package/dist/domain/javascript/javascriptFeatureTraceSchemas.js

@@ -36,6 +36,22 @@ const applicationFeatureSeedSchema = z.union([
         case_sensitive: z.boolean().default(false),
     }),
 ]);
+/** Check unique native identities before projecting an application trace. */
+const validateApplicationTraceIdentities = (input, context) => {
+    const ids = input.native_observations.map(({ evidence_id: id }) => id);
+    if (new Set(ids).size !== ids.length)
+        context.addIssue({
+            code: "custom",
+            path: ["native_observations"],
+            message: "Native observations must be unique",
+        });
+};
+/** Validate native trace identities without capturing their complete Evidence. */
+export const applicationTraceIdentitiesSchema = z
+    .object({
+    native_observations: z.array(z.object({ evidence_id: evidenceIdSchema })),
+})
+    .superRefine(validateApplicationTraceIdentities);
 /** Evidence-backed application graph and feature seed. */
 export const traceApplicationFeatureInputSchema = z
     .strictObject({
@@ -44,15 +60,7 @@ export const traceApplicationFeatureInputSchema = z
     seed: applicationFeatureSeedSchema,
     direction: z.enum(["outgoing", "incoming", "both"]).default("both"),
 })
-    .superRefine((input, context) => {
-    const ids = input.native_observations.map(({ evidence_id: id }) => id);
-    if (new Set(ids).size !== ids.length)
-        context.addIssue({
-            code: "custom",
-            path: ["native_observations"],
-            message: "Native observations must be unique",
-        });
-});
+    .superRefine(validateApplicationTraceIdentities);
 const seedMatchSchema = z.strictObject({
     node_id: nodeIdSchema,
     kind: z.string().min(1),

package/dist/domain/javascript/javascriptFeatureTraversal.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.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]));
@@ -29,8 +29,8 @@ export const traverseApplicationFeature = (graph, seedNodeIds, direction) => {
         nodes: [...visited]
             .map((nodeId) => nodeById.get(nodeId))
             .filter((node) => node !== undefined)
-            .sort((left, right) => compareCodePoints(left.node_id, right.node_id)),
-        edges: [...retainedEdges.values()].sort((left, right) => compareCodePoints(left.edge_id, right.edge_id)),
+            .sort((left, right) => compareUnicodeCodePoints(left.node_id, right.node_id)),
+        edges: [...retainedEdges.values()].sort((left, right) => compareUnicodeCodePoints(left.edge_id, right.edge_id)),
         predecessors,
     };
 };
@@ -49,7 +49,7 @@ const buildAdjacency = (edges, direction) => {
             });
     }
     for (const entries of adjacency.values())
-        entries.sort((left, right) => compareCodePoints(`${left.edge.edge_id}\0${left.nextNodeId}`, `${right.edge.edge_id}\0${right.nextNodeId}`));
+        entries.sort((left, right) => compareUnicodeCodePoints(`${left.edge.edge_id}\0${left.nextNodeId}`, `${right.edge.edge_id}\0${right.nextNodeId}`));
     return adjacency;
 };
 const addAdjacency = (adjacency, nodeId, entry) => {

package/dist/domain/javascript/javascriptNativeHandoff.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import {} from "./javascriptApplicationGraphSchemas.js";
 /** Build provider-neutral addon targets and link exact-subject native Evidence. */
 export const buildJavaScriptNativeHandoffs = (nodes, edges, nativeEvidence) => {
@@ -24,7 +24,7 @@ export const buildJavaScriptNativeHandoffs = (nodes, edges, nativeEvidence) => {
                 providers: uniqueProviders(linked),
                 evidence_ids: linked
                     .map(({ evidence_id: id }) => id)
-                    .sort(compareCodePoints),
+                    .sort(compareUnicodeCodePoints),
                 recommended_tools: [
                     "open_binary",
                     "binary_overview",
@@ -35,7 +35,7 @@ export const buildJavaScriptNativeHandoffs = (nodes, edges, nativeEvidence) => {
             },
         ];
     })
-        .sort((left, right) => compareCodePoints(left.native_node_id, right.native_node_id));
+        .sort((left, right) => compareUnicodeCodePoints(left.native_node_id, right.native_node_id));
 };
 const artifactDigest = (node) => {
     if (node.identity.strategy === "content-digest")
@@ -65,7 +65,7 @@ const nativeExportNodes = (addon, edges, nodeById) => {
     return [...new Set(ids)]
         .map((id) => nodeById.get(id))
         .filter((node) => node?.kind === "native-export")
-        .sort((left, right) => compareCodePoints(left.node_id, right.node_id));
+        .sort((left, right) => compareUnicodeCodePoints(left.node_id, right.node_id));
 };
 const requestedExports = (nodes) => {
     const values = nodes.flatMap((node) => node.observations.flatMap((observation) => [
@@ -73,7 +73,7 @@ const requestedExports = (nodes) => {
         ...stringArray(observation.properties.requested_members),
         ...stringArray(observation.properties.members),
     ]));
-    return [...new Set(values)].sort(compareCodePoints);
+    return [...new Set(values)].sort(compareUnicodeCodePoints);
 };
 const stringArray = (value) => Array.isArray(value)
     ? value.filter((item) => typeof item === "string")
@@ -83,4 +83,4 @@ const uniqueProviders = (evidence) => [
         `${provider.id}\0${provider.name}\0${provider.version ?? ""}`,
         provider,
     ])).values(),
-].sort((left, right) => compareCodePoints(`${left.id}\0${left.name}\0${left.version ?? ""}`, `${right.id}\0${right.name}\0${right.version ?? ""}`));
+].sort((left, right) => compareUnicodeCodePoints(`${left.id}\0${left.name}\0${left.version ?? ""}`, `${right.id}\0${right.name}\0${right.version ?? ""}`));

package/dist/domain/javascript/javascriptRuntimeObservation.js

@@ -16,7 +16,6 @@ export const javascriptRuntimeKindSchema = z.enum([
     "electron-renderer",
 ]);
 const observedJavaScriptRuntimeKindSchema = javascriptRuntimeKindSchema.or(z.literal("unknown"));
-/** Input for one bounded, attach-only V8 Inspector observation. */
 /** Input for one passive attach-only V8 Inspector observation. */
 export const observeJavaScriptRuntimeInputSchema = z.strictObject({
     ...runtimeEndpoint,
@@ -33,7 +32,6 @@ export const javascriptRuntimeLocationSchema = z.discriminatedUnion("kind", [
     z.strictObject({
         kind: z.literal("file"),
         file_path: z.string().min(1),
-        authority: z.literal("scope-fallback").optional(),
     }),
     z.strictObject({
         kind: z.literal("url"),
@@ -48,8 +46,13 @@ export const javascriptRuntimeLocationSchema = z.discriminatedUnion("kind", [
 /** Discovery metadata can identify an endpoint target without verifying its file location. */
 export const javascriptRuntimeUnresolvedLocationSchema = z.strictObject({
     kind: z.literal("unresolved"),
-    reported_url: z.string().min(1),
-    reason: z.literal("unverifiable-file-location"),
+    reported_url: z
+        .string()
+        .describe("Raw Inspector URL, which may be empty for anonymous or evaluated code."),
+    reason: z.enum([
+        "unverifiable-file-location",
+        "location-authorization-not-attempted",
+    ]),
 });
 /** Verified locations and explicitly unresolved discovery metadata. */
 export const javascriptRuntimeTargetLocationSchema = z.union([
@@ -74,7 +77,7 @@ export const javascriptRuntimeTargetListSchema = z.strictObject({
 });
 const javascriptRuntimeScriptSchema = z.strictObject({
     script_key: prefixedDigestSchema("v8_script"),
-    location: javascriptRuntimeLocationSchema,
+    location: javascriptRuntimeTargetLocationSchema,
     execution_context_key: z.string().nullable(),
     cdp_hash: z.string().nullable(),
     length: z

package/dist/domain/javascript/javascriptRuntimeReconciliation.js

@@ -1,16 +1,22 @@
 import { classifyStaticLoadStates } from "./javascriptRuntimeLoadState.js";
 import { buildReconciledApplicationGraph } from "./javascriptRuntimeReconciliationGraph.js";
 import { reconcileRuntimeEntities } from "./javascriptRuntimeReconciliationMatching.js";
-import { parseRuntimeCaptures, parseStaticLayers, } from "./javascriptRuntimeReconciliationParsing.js";
+import { parseStaticLayers, } from "./javascriptRuntimeReconciliationParsing.js";
+import { parseRuntimeCaptures, } from "./javascriptRuntimeReconciliationCaptureParsing.js";
 import { createJavaScriptRuntimeReconciliationResult } from "./javascriptRuntimeReconciliationResult.js";
-import { reconcileJavaScriptRuntimeInputSchema } from "./javascriptRuntimeReconciliationSchemas.js";
 import { projectRuntimeCaptures } from "./javascriptRuntimeReconciliationRuntime.js";
 import { collectStaticRuntimeCandidates } from "./javascriptRuntimeStaticCandidates.js";
+/** Parse caller Evidence once into the owner consumed by reconciliation. */
+export const parseRuntimeReconciliationInput = (input) => ({
+    input,
+    layers: parseStaticLayers(input.static_layers, ["static_layers"]),
+    captures: parseRuntimeCaptures(input.runtime_observations, [
+        "runtime_observations",
+    ]),
+});
 /** Reconcile static JAG layers with authorized passive CDP Evidence. */
-export const reconcileJavaScriptRuntime = (input) => {
-    const parsed = reconcileJavaScriptRuntimeInputSchema.parse(input);
-    const layers = parseStaticLayers(parsed.static_layers);
-    const captures = parseRuntimeCaptures(parsed.runtime_observations);
+export const reconcileJavaScriptRuntime = (parsed) => {
+    const { layers, captures } = parsed;
     const runtime = projectRuntimeCaptures(captures);
     const candidates = collectStaticRuntimeCandidates(layers);
     const matching = reconcileRuntimeEntities({

package/dist/domain/javascript/javascriptRuntimeReconciliationActive.js

@@ -1,28 +1,29 @@
 import { isAbsolute } from "node:path";
-import { canonicalDigest } from "../comparisonSemantics.js";
+import { digestCanonicalValue } from "../canonicalDigest.js";
 import { isPathWithinRoot } from "../localPath.js";
 import { z } from "zod";
+import { invalidInput, parseAtPath, } from "./javascriptRuntimeReconciliationInputValidation.js";
 import { classifyBrowserCompleteness, } from "../browserCompleteness.js";
 import { electronActiveObservationResultSchema, } from "./electronActiveObservation.js";
 /** Parse active Electron Evidence as a bounded, target-only runtime capture. */
 export const parseActiveElectronCapture = (evidence) => {
     assertIdentity(evidence);
-    const result = electronActiveObservationResultSchema.parse(evidence.normalized_result);
-    const parameters = z
+    const result = parseAtPath((value) => electronActiveObservationResultSchema.parse(value), evidence.normalized_result, ["normalized_result"]);
+    const parameters = parseAtPath((value) => z
         .object({
         application_path: absolutePathSchema,
         application_root: absolutePathSchema,
     })
         .passthrough()
-        .parse(evidence.parameters);
+        .parse(value), evidence.parameters, ["parameters"]);
     if (result.application.application_path !== parameters.application_path ||
         !isPathWithinRoot(parameters.application_root, result.application.application_path))
-        throw new TypeError("Active Electron Evidence application path disagrees with its configured root");
+        throw invalidInput(["normalized_result", "application", "application_path"], "Active Electron Evidence application path disagrees with its configured root");
     return {
         kind: "electron-active",
         evidence,
         inspection: normalizeInspection(result),
-        captureSha256: canonicalDigest(result, "Runtime reconciliation"),
+        captureSha256: digestCanonicalValue(result, "Runtime reconciliation"),
         scriptsCompleteWithinScope: false,
     };
 };
@@ -36,11 +37,11 @@ const assertIdentity = (evidence) => {
         evidence.provider.version !== "1" ||
         evidence.authority !== "controlled-replay" ||
         evidence.confidence !== "observed")
-        throw new TypeError("Evidence does not match the supported capture_electron_scenario contract");
+        throw invalidInput([], "Evidence does not match the supported capture_electron_scenario contract");
 };
 const normalizeInspection = (result) => ({
     target: {
-        target_id: `electron-active:${canonicalDigest(result.application.application_path, "Runtime reconciliation").slice(0, 32)}`,
+        target_id: `electron-active:${digestCanonicalValue(result.application.application_path, "Runtime reconciliation").slice(0, 32)}`,
         type: "electron-application",
         title: result.application.application_path,
         attached: true,