rea-agents 6.1.0 → 6.3.0

package/dist/domain/javascript/javascriptExportShapeVariants.js

@@ -1,5 +1,10 @@
 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",
+};
 /** Pair variants only through reciprocal unique exact literal discriminants. */
 export const pairJavaScriptExportShapeVariants = (left, right) => {
     const leftKeys = discriminantOccurrences(left);
@@ -61,12 +66,41 @@ export const buildJavaScriptExportShapeChanges = (input) => {
     });
     return [...paired, ...unpairedLeft, ...unpairedRight];
 };
+/** List observed property names per retained variant, including unknown values. */
+export const buildJavaScriptExportShapeInventories = (input) => {
+    const leftPairs = new Map(input.pairing.pairs.map((pair) => [pair.leftIndex, pair]));
+    const rightPairs = new Map(input.pairing.pairs.map((pair) => [pair.rightIndex, pair]));
+    return [
+        ...input.leftShapes.map((shape, index) => inventoryFor("left", index, shape, leftPairs.get(index))),
+        ...input.rightShapes.map((shape, index) => inventoryFor("right", index, shape, rightPairs.get(index))),
+    ];
+};
+const inventoryFor = (side, variantIndex, shape, pair) => ({
+    side,
+    variant_index: variantIndex,
+    discriminant: pair?.discriminant ?? null,
+    paired: pair !== undefined,
+    source_range: shape.source_range,
+    properties: uniqueSorted([
+        ...shape.fields
+            .filter((field) => fieldPresence(shape, field, field.path) === "present")
+            .map(({ path }) => path),
+        ...shape.property_coverage.map(({ path }) => path),
+    ]).filter((path) => path !== ""),
+    property_coverage: shape.property_coverage.map(({ path, status }) => ({
+        path,
+        status,
+    })),
+});
 /** Report whether any retained shape lacks complete property coverage. */
-export const hasPartialJavaScriptExportPropertyCoverage = (shapes) => shapes.some((shape) => shape.property_coverage.some(({ status }) => status === "partial"));
+export const hasPartialJavaScriptExportPropertyCoverage = (shapes) => shapes.some((shape) => shape.property_coverage.some(({ status }) => status === "partial") ||
+    shape.fields.some((field) => fieldPresence(shape, field, field.path) === "unknown-coverage"));
 const discriminantOccurrences = (shapes) => {
     const output = new Map();
     shapes.forEach((shape, index) => {
         for (const field of shape.fields) {
+            if (fieldPresence(shape, field, field.path) !== "present")
+                continue;
             const value = literalValue(field);
             if (!value.found)
                 continue;
@@ -106,11 +140,12 @@ 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: "",
     discriminant: null,
+    presence: UNKNOWN_COVERAGE_PRESENCE,
     left: selectionAvailability(input.leftSelection.selection, "left"),
     right: selectionAvailability(input.rightSelection.selection, "right"),
     left_source_range: null,
@@ -124,6 +159,7 @@ const emptyShapeUnknownChange = (input) => changeWithId({
     status: "unknown",
     path: "",
     discriminant: null,
+    presence: UNKNOWN_COVERAGE_PRESENCE,
     left: emptyShapeAvailability(input.leftShapes, "left"),
     right: emptyShapeAvailability(input.rightShapes, "right"),
     left_source_range: null,
@@ -159,6 +195,10 @@ const diffPair = (left, right, discriminant, evidenceLinks) => {
                 status,
                 path,
                 discriminant,
+                presence: {
+                    left: fieldPresence(left, leftField, path),
+                    right: fieldPresence(right, rightField, path),
+                },
                 left: fieldAvailability(leftField),
                 right: fieldAvailability(rightField),
                 left_source_range: left.source_range,
@@ -181,29 +221,42 @@ const fieldAtPath = (shape, fields, path) => {
         return undefined;
     return {
         path,
+        presence: "present",
         state: "unknown",
         value: null,
         reason: "A static container is retained at this path, but no primitive field value is projected.",
     };
 };
 const fieldChangeStatus = ({ leftShape, rightShape, path, leftField, rightField, }) => {
-    if (leftField !== undefined && rightField !== undefined) {
-        if (canonicalExportShapeValue(leftField) ===
+    const leftPresence = fieldPresence(leftShape, leftField, path);
+    const rightPresence = fieldPresence(rightShape, rightField, path);
+    if (leftField !== undefined &&
+        rightField !== undefined &&
+        canonicalExportShapeValue(leftField) ===
             canonicalExportShapeValue(rightField))
-            return null;
+        return null;
+    if (leftPresence === "absent" && rightPresence === "absent")
+        return null;
+    if (leftPresence === "unknown-coverage" ||
+        rightPresence === "unknown-coverage")
+        return "unknown";
+    if (leftPresence === "absent")
+        return "added";
+    if (rightPresence === "absent")
+        return "removed";
+    if (leftField !== undefined && rightField !== undefined) {
         return leftField.state === "unknown" || rightField.state === "unknown"
             ? "unknown"
             : "changed";
     }
-    const present = leftField ?? rightField;
-    if (present === undefined)
-        return null;
-    const parent = parentPointer(path);
-    const parentsComplete = propertyCoverageComplete(leftShape, parent) &&
-        propertyCoverageComplete(rightShape, parent);
-    if (present.state === "unknown" || !parentsComplete)
-        return "unknown";
-    return leftField === undefined ? "added" : "removed";
+    return null;
+};
+const fieldPresence = (shape, field, path) => {
+    if (field !== undefined)
+        return field.presence;
+    return propertyCoverageComplete(shape, parentPointer(path))
+        ? "absent"
+        : "unknown-coverage";
 };
 const propertyCoverageComplete = (shape, path) => path !== null &&
     shape.property_coverage.some((coverage) => coverage.path === path && coverage.status === "complete");
@@ -214,7 +267,7 @@ const parentPointer = (path) => {
     return separator < 0 ? null : path.slice(0, separator);
 };
 const fieldAvailability = (field) => {
-    if (field === undefined)
+    if (field === undefined || field.presence === "absent")
         return { availability: "absent" };
     if (field.state === "unknown")
         return {
@@ -245,6 +298,7 @@ const unpairedChange = (side, shape, evidenceLinks) => changeWithId({
     status: "unknown",
     path: "",
     discriminant: null,
+    presence: UNKNOWN_COVERAGE_PRESENCE,
     left: {
         availability: "unknown",
         reason: side === "left"

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
@@ -62,6 +62,16 @@ const candidateFields = (node, seedKind) => {
                         value: observation.label,
                     },
                 ]),
+            ...(observation.source_map_reference !== null &&
+                observation.source_map_reference.resolution.kind !== "unresolved"
+                ? [
+                    {
+                        basis: "property",
+                        field: `observations[${String(index)}].source_map_reference.resolution.path`,
+                        value: observation.source_map_reference.resolution.path,
+                    },
+                ]
+                : []),
             ...propertyFields(observation.properties, `observations[${String(index)}].properties`),
         ]),
     ];
@@ -89,6 +99,7 @@ const relevantFields = {
         ".path",
         ".source",
         ".original_source",
+        ".source_root",
         ".exports",
     ],
     "native-export": [".label", ".key", ".requested_members", ".members"],
@@ -104,6 +115,15 @@ const identityFields = (node) => {
                 field: "identity.original_source",
                 value: identity.original_source,
             },
+            ...(identity.source_root === null
+                ? []
+                : [
+                    {
+                        basis: "identity",
+                        field: "identity.source_root",
+                        value: identity.source_root,
+                    },
+                ]),
         ];
     if (identity.strategy === "canonical-path")
         return [
@@ -151,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,5 +1,4 @@
-import {} from "./javascriptApplicationGraph.js";
-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]));
@@ -30,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,
     };
 };
@@ -50,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,5 +1,5 @@
-import { compareCodePoints } from "../canonicalOrdering.js";
-import {} from "./javascriptApplicationGraph.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) => {
     const nodeById = new Map(nodes.map((node) => [node.node_id, node]));
@@ -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/javascriptRuntimeLoadState.js

@@ -1,4 +1,3 @@
-import {} from "./javascriptApplicationGraph.js";
 import { uniqueSorted } from "../canonicalOrdering.js";
 import { createStaticRuntimeScope, mappedRuntimePaths, staticNodeWithinRuntimeScope, } from "./javascriptRuntimeStaticCandidates.js";
 /** Classify static code presence without claiming bundled module execution. */

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,11 +77,19 @@ 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.number().int().min(0),
-    is_module: z.boolean(),
+    length: z
+        .number()
+        .int()
+        .min(0)
+        .nullable()
+        .describe("Producer-reported script length; null when unavailable."),
+    is_module: z
+        .boolean()
+        .nullable()
+        .describe("Producer-reported module classification; null when unavailable."),
     status: z.literal("observed-loaded"),
 });
 const javascriptRuntimeContextSchema = z.strictObject({

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,