rea-agents 6.1.0 → 6.3.0

package/dist/domain/javascript/javascriptRuntimeReconciliationCaptureParsing.js

@@ -0,0 +1,212 @@
+import { z } from "zod";
+import { browserAllowedOriginsSchema, browserEndpointSchema, } from "../browserObservation.js";
+import { webPageInspectionSchema, } from "../browserObservationSchemas.js";
+import { classifyBrowserCompleteness, } from "../browserCompleteness.js";
+import { electronPageInspectionSchema, } from "./electronObservation.js";
+import { javascriptRuntimeObservationSchema, javascriptRuntimeKindSchema, } from "./javascriptRuntimeObservation.js";
+import { digestCanonicalValue } from "../canonicalDigest.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+import { parseEvidence } from "../evidence.js";
+import { parseActiveElectronCapture } from "./javascriptRuntimeReconciliationActive.js";
+import { assertEvidenceIdentity, invalidInput, parseAtPath, } from "./javascriptRuntimeReconciliationInputValidation.js";
+/** Parse only supported passive web/Electron inspection Evidence. */
+export const parseRuntimeCaptures = (observations, path = ["runtime_observations"]) => observations
+    .map((observation, index) => parseRuntimeCapture(observation, [...path, index]))
+    .sort((left, right) => compareUnicodeCodePoints(left.evidence.evidence_id, right.evidence.evidence_id));
+const parseRuntimeCapture = (input, evidencePath) => {
+    const evidence = parseAtPath(parseEvidence, input, evidencePath);
+    if (evidence.operation === "inspect_web_page")
+        return parseBrowserCapture(evidence, evidencePath);
+    if (evidence.operation === "inspect_electron_page")
+        return parseElectronCapture(evidence, evidencePath);
+    if (evidence.operation === "observe_javascript_runtime")
+        return parseV8Capture(evidence, evidencePath);
+    if (evidence.operation === "capture_electron_scenario") {
+        return parseAtPath(() => parseActiveElectronCapture(evidence), evidence, evidencePath);
+    }
+    throw invalidInput(evidencePath, "Runtime reconciliation requires inspect_web_page, inspect_electron_page, observe_javascript_runtime, or capture_electron_scenario Evidence");
+};
+const parseBrowserCapture = (evidence, path) => {
+    assertEvidenceIdentity(evidence, {
+        operation: "inspect_web_page",
+        predicate: "rea.web-page-inspection",
+        providerId: "rea-cdp-browser",
+        providerName: "REA Chrome DevTools Protocol observation provider",
+        providerVersion: "2",
+        authority: "external-service",
+        confidence: "observed",
+    }, path);
+    const inspection = parseAtPath((value) => webPageInspectionSchema.parse(value), evidence.normalized_result, [...path, "normalized_result"]);
+    assertRuntimeParameters(evidence, {
+        kind: "browser",
+        targetId: inspection.target.target_id,
+        targetOrigin: inspection.target.origin,
+        sourceIncluded: inspection.scripts.items.some(({ source }) => source.included),
+    }, path);
+    return {
+        kind: "browser",
+        evidence,
+        inspection,
+        captureSha256: digestCanonicalValue(inspection, "Runtime reconciliation"),
+        scriptsCompleteWithinScope: scriptsComplete(inspection.completeness),
+    };
+};
+const parseElectronCapture = (evidence, path) => {
+    assertEvidenceIdentity(evidence, {
+        operation: "inspect_electron_page",
+        predicate: "rea.electron-page-inspection",
+        providerId: "rea-cdp-electron",
+        providerName: "REA Electron file-page CDP observation provider",
+        providerVersion: "1",
+        authority: "external-service",
+        confidence: "observed",
+    }, path);
+    const inspection = parseAtPath((value) => electronPageInspectionSchema.parse(value), evidence.normalized_result, [...path, "normalized_result"]);
+    assertRuntimeParameters(evidence, {
+        kind: "electron",
+        targetId: inspection.target.target_id,
+        sourceIncluded: inspection.scripts.items.some(({ source }) => source.included),
+    }, path);
+    return {
+        kind: "electron",
+        evidence,
+        inspection,
+        captureSha256: digestCanonicalValue(inspection, "Runtime reconciliation"),
+        scriptsCompleteWithinScope: scriptsComplete(inspection.completeness),
+    };
+};
+const parseV8Capture = (evidence, path) => {
+    assertEvidenceIdentity(evidence, {
+        operation: "observe_javascript_runtime",
+        predicate: "rea.javascript-runtime-observation",
+        providerId: "rea-v8-inspector",
+        providerName: "REA passive Node/Electron V8 Inspector provider",
+        providerVersion: "1",
+        authority: "external-service",
+        confidence: "observed",
+    }, path);
+    const result = parseAtPath((value) => javascriptRuntimeObservationSchema.parse(value), evidence.normalized_result, [...path, "normalized_result"]);
+    assertV8RuntimeParameters(evidence, result, path);
+    return {
+        kind: "v8-inspector",
+        evidence,
+        inspection: normalizeV8Inspection(result),
+        captureSha256: digestCanonicalValue(result, "Runtime reconciliation"),
+        scriptsCompleteWithinScope: false,
+    };
+};
+const assertV8RuntimeParameters = (evidence, result, path) => {
+    const parameters = parseAtPath((value) => z
+        .object({
+        inspector_endpoint: browserEndpointSchema,
+        target_id: z.string().trim().min(1),
+        runtime_kind: javascriptRuntimeKindSchema.optional(),
+    })
+        .passthrough()
+        .parse(value), evidence.parameters, [...path, "parameters"]);
+    if (parameters.target_id !== result.target.target_id ||
+        (parameters.runtime_kind !== undefined &&
+            parameters.runtime_kind !== result.target.runtime_kind))
+        throw invalidInput([...path, "parameters", "target_id"], "Runtime Evidence target or declared role disagrees with its result");
+    if (result.target.location.kind === "builtin" &&
+        !result.target.location.specifier.startsWith("node:"))
+        throw invalidInput([...path, "normalized_result", "target", "location"], "Runtime Evidence contains an invalid builtin location");
+    for (const [index, { location }] of result.scripts.items.entries())
+        if (location.kind === "builtin" && !location.specifier.startsWith("node:"))
+            throw invalidInput([...path, "normalized_result", "scripts", "items", index, "location"], "Runtime Evidence contains an invalid builtin location");
+};
+const normalizeV8Inspection = (result) => ({
+    target: {
+        target_id: result.target.target_id,
+        type: result.target.protocol_type,
+        title: result.target.runtime_kind,
+        attached: result.target.attached,
+        ...(result.target.location.kind === "unresolved"
+            ? { unresolved_location: result.target.location }
+            : runtimeLocation(result.target.location)),
+    },
+    frames: [],
+    scripts: {
+        items: result.scripts.items.map((script) => ({
+            script_key: script.script_key,
+            frame_id: script.execution_context_key,
+            ...runtimeLocation(script.location),
+            cdp_hash: script.cdp_hash,
+            length: script.length,
+            is_module: script.is_module,
+            language: null,
+            source: {
+                included: false,
+                reason: "V8 Inspector source capture is outside passive authority.",
+            },
+        })),
+    },
+    workers: [],
+    completeness: classifyBrowserCompleteness({
+        policyFilteredSections: new Set(excludedV8Scripts(result) > 0 ? ["scripts"] : []),
+        attachLimitedSections: new Set([
+            "frames",
+            "scripts",
+            "script_sources",
+            "workers",
+        ]),
+        truncatedSections: new Set(result.capture.truncated ? ["scripts"] : []),
+        unavailableSections: new Set(["frames", "script_sources", "workers"]),
+        excluded: excludedV8Scripts(result) === 0
+            ? []
+            : [
+                {
+                    section: "scripts",
+                    reason: "out_of_target_scope",
+                    count: excludedV8Scripts(result),
+                },
+            ],
+        droppedEvents: {
+            scripts: result.capture.events_dropped,
+            network_requests: 0,
+            console_events: 0,
+            websocket_connections: 0,
+            websocket_frames: 0,
+            webmcp_tools: 0,
+            timeline_events: 0,
+        },
+    }),
+});
+const runtimeLocation = (location) => {
+    if (location.kind === "unresolved")
+        return { unresolved_location: location };
+    if (location.kind === "file")
+        return { file_path: location.file_path };
+    if (location.kind === "url")
+        return { url: location.sanitized_url };
+    return { url: location.specifier };
+};
+const excludedV8Scripts = (result) => Object.values(result.scripts.excluded).reduce((total, count) => total + count, 0);
+const assertRuntimeParameters = (evidence, expected, path) => {
+    const common = {
+        target_id: z.string().trim().min(1),
+        cdp_endpoint: browserEndpointSchema,
+        include_script_sources: z.boolean(),
+    };
+    if (expected.kind === "browser") {
+        const parameters = parseAtPath((value) => z
+            .object({ ...common, allowed_origins: browserAllowedOriginsSchema })
+            .passthrough()
+            .parse(value), evidence.parameters, [...path, "parameters"]);
+        if (parameters.target_id !== expected.targetId)
+            throw invalidInput([...path, "parameters", "target_id"], "Runtime Evidence target disagrees with its captured result");
+        if (!parameters.allowed_origins.includes(expected.targetOrigin))
+            throw invalidInput([...path, "parameters", "allowed_origins"], "Browser Evidence target is outside its recorded origin scope");
+        if (expected.sourceIncluded && !parameters.include_script_sources)
+            throw invalidInput([...path, "parameters", "include_script_sources"], "Runtime Evidence contains source without source-capture selection");
+        return;
+    }
+    const parameters = parseAtPath((value) => z.object(common).passthrough().parse(value), evidence.parameters, [...path, "parameters"]);
+    if (parameters.target_id !== expected.targetId)
+        throw invalidInput([...path, "parameters", "target_id"], "Runtime Evidence target disagrees with its captured result");
+    if (expected.sourceIncluded && !parameters.include_script_sources)
+        throw invalidInput([...path, "parameters", "include_script_sources"], "Runtime Evidence contains source without source-capture selection");
+};
+const scriptsComplete = (completeness) => !completeness.truncated_sections.includes("scripts") &&
+    !completeness.unavailable_sections.includes("scripts") &&
+    completeness.dropped_events.scripts === 0;

package/dist/domain/javascript/javascriptRuntimeReconciliationGraph.js

@@ -1,5 +1,6 @@
 import { createJavaScriptApplicationGraph, createJavaScriptApplicationNode, } from "./javascriptApplicationGraph.js";
-import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 /** Merge source graphs, runtime nodes, and inferred mappings into one valid JAG. */
 export const buildReconciledApplicationGraph = (input) => {
     const merged = mergeNodes([
@@ -44,11 +45,11 @@ export const buildReconciledApplicationGraph = (input) => {
 const boundGraphContent = (input, nodes, edges) => {
     const allRoots = preferredRootIds(input);
     const rootNodeIds = allRoots;
-    const sortedNodes = [...nodes].sort((left, right) => compareCodePoints(left.node_id, right.node_id));
+    const sortedNodes = [...nodes].sort((left, right) => compareUnicodeCodePoints(left.node_id, right.node_id));
     const retainedNodes = sortedNodes;
     const retainedIds = new Set(retainedNodes.map(({ node_id: id }) => id));
     const retainedEdges = [...edges]
-        .sort((left, right) => compareCodePoints(left.edge_id, right.edge_id))
+        .sort((left, right) => compareUnicodeCodePoints(left.edge_id, right.edge_id))
         .filter(({ source_node_id: source, target_node_id: target }) => retainedIds.has(source) && retainedIds.has(target));
     return {
         rootNodeIds,
@@ -143,7 +144,7 @@ const mergeNodes = (nodes) => {
             ...new Map(group
                 .flatMap(({ observations: values }) => values)
                 .map((observation) => [observation.observation_id, observation])).values(),
-        ].sort((left, right) => compareCodePoints(left.observation_id, right.observation_id));
+        ].sort((left, right) => compareUnicodeCodePoints(left.observation_id, right.observation_id));
         return createJavaScriptApplicationNode({
             kind: first.kind,
             identity: first.identity,

package/dist/domain/javascript/javascriptRuntimeReconciliationInputValidation.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+/** Prefix caller paths on a nested Zod validation boundary. */
+export const parseAtPath = (parse, input, path) => {
+    try {
+        return parse(input);
+    }
+    catch (cause) {
+        if (cause instanceof z.ZodError)
+            throw new z.ZodError(cause.issues.map((issue) => ({
+                ...issue,
+                path: [...path, ...issue.path],
+            })));
+        throw cause;
+    }
+};
+/** Represent one semantic caller constraint as a standard validation issue. */
+export const invalidInput = (path, message) => new z.ZodError([{ code: "custom", path: [...path], message }]);
+/** Verify an authenticated Evidence record against one runtime workflow. */
+export const assertEvidenceIdentity = (evidence, expected, path) => {
+    if (evidence.operation !== expected.operation ||
+        evidence.predicate_type !== expected.predicate ||
+        evidence.provider.id !== expected.providerId ||
+        evidence.provider.name !== expected.providerName ||
+        evidence.provider.version !== expected.providerVersion ||
+        evidence.authority !== expected.authority ||
+        evidence.confidence !== expected.confidence)
+        throw invalidInput(path, `Evidence does not match the supported ${expected.operation} contract`);
+};

package/dist/domain/javascript/javascriptRuntimeReconciliationMatching.js

@@ -1,12 +1,12 @@
-import { createJavaScriptApplicationEdge, } from "./javascriptApplicationGraph.js";
-import { canonicalDigest } from "../comparisonSemantics.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { createJavaScriptApplicationEdge } from "./javascriptApplicationGraph.js";
+import { digestCanonicalValue } from "../canonicalDigest.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { mappedRuntimePaths, } from "./javascriptRuntimeStaticCandidates.js";
 /** Match runtime entities conservatively and emit only inferred observed_as edges. */
 export const reconcileRuntimeEntities = (input) => {
     const index = indexCandidates(input.candidates);
     const evaluated = input.entities.map((entity) => reconcileEntity(entity, index, input.layers));
-    const retained = evaluated.sort((left, right) => compareCodePoints(left.item.reconciliation_id, right.item.reconciliation_id));
+    const retained = evaluated.sort((left, right) => compareUnicodeCodePoints(left.item.reconciliation_id, right.item.reconciliation_id));
     return {
         items: retained.map(({ item }) => item),
         edges: retained.flatMap(({ edge }) => (edge === null ? [] : [edge])),
@@ -105,7 +105,7 @@ const candidatesWithLocation = (entity, index, layers) => {
                 if (!located.has(key))
                     located.set(key, { candidate, mapping });
             }
-    return [...located.values()].sort((left, right) => compareCodePoints(candidateKey(left.candidate), candidateKey(right.candidate)));
+    return [...located.values()].sort((left, right) => compareUnicodeCodePoints(candidateKey(left.candidate), candidateKey(right.candidate)));
 };
 const indexCandidates = (candidates) => {
     const byCategoryDigest = new Map();
@@ -189,7 +189,7 @@ const createItem = (entity, input) => {
         candidate_static_nodes: candidateReferences.items,
     };
     return {
-        reconciliation_id: `jrr_item_${canonicalDigest(semantic, "Runtime reconciliation")}`,
+        reconciliation_id: `jrr_item_${digestCanonicalValue(semantic, "Runtime reconciliation")}`,
         ...semantic,
     };
 };

package/dist/domain/javascript/javascriptRuntimeReconciliationParsing.js

@@ -1,25 +1,15 @@
-import { z } from "zod";
-import { browserAllowedOriginsSchema, browserEndpointSchema, webPageInspectionSchema, } from "../browserObservation.js";
-import { classifyBrowserCompleteness, } from "../browserCompleteness.js";
-import { electronPageInspectionSchema, } from "./electronObservation.js";
-import { javascriptRuntimeObservationSchema, javascriptRuntimeKindSchema, } from "./javascriptRuntimeObservation.js";
-import { canonicalDigest } from "../comparisonSemantics.js";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { digestCanonicalValue } from "../canonicalDigest.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { parseEvidence } from "../evidence.js";
 import { javascriptApplicationAnalysisResultSchema, } from "./javascriptApplicationAnalysis.js";
-import {} from "./javascriptApplicationGraph.js";
-import { parseActiveElectronCapture } from "./javascriptRuntimeReconciliationActive.js";
+import { assertEvidenceIdentity, invalidInput, parseAtPath, } from "./javascriptRuntimeReconciliationInputValidation.js";
 /** Parse and semantically bind every static analysis Evidence layer. */
-export const parseStaticLayers = (layers) => layers
-    .map((layer) => parseStaticLayer(layer))
-    .sort((left, right) => compareCodePoints(left.layerId, right.layerId));
-/** Parse only supported passive web/Electron inspection Evidence. */
-export const parseRuntimeCaptures = (observations) => observations
-    .map((observation) => parseRuntimeCapture(observation))
-    .sort((left, right) => compareCodePoints(left.evidence.evidence_id, right.evidence.evidence_id));
-const parseStaticLayer = (layer) => {
-    const evidence = parseEvidence(layer.analysis);
-    const result = javascriptApplicationAnalysisResultSchema.parse(evidence.normalized_result);
+export const parseStaticLayers = (layers, path = ["static_layers"]) => layers
+    .map((layer, index) => parseStaticLayer(layer, [...path, index, "analysis"]))
+    .sort((left, right) => compareUnicodeCodePoints(left.layerId, right.layerId));
+const parseStaticLayer = (layer, evidencePath) => {
+    const evidence = parseAtPath(parseEvidence, layer.analysis, evidencePath);
+    const result = parseAtPath((value) => javascriptApplicationAnalysisResultSchema.parse(value), evidence.normalized_result, [...evidencePath, "normalized_result"]);
     assertEvidenceIdentity(evidence, {
         operation: "analyze_javascript_application",
         predicate: "rea.javascript-application-analysis",
@@ -28,14 +18,14 @@ const parseStaticLayer = (layer) => {
         providerVersion: "1",
         authority: "shipped-artifact",
         confidence: "derived",
-    });
+    }, evidencePath);
     if (evidence.subject === null ||
         evidence.subject.digest.sha256 !== result.root_artifact_sha256 ||
         evidence.subject.format !== result.format ||
         evidence.subject.local_path !== result.input_path)
-        throw new TypeError("JavaScript application Evidence subject disagrees with its result");
+        throw invalidInput([...evidencePath, "subject"], "JavaScript application Evidence subject disagrees with its result");
     return {
-        layerId: `jrl_${canonicalDigest({
+        layerId: `jrl_${digestCanonicalValue({
             role: layer.role,
             evidence_id: evidence.evidence_id,
             runtime_mappings: layer.runtime_mappings,
@@ -47,203 +37,3 @@ const parseStaticLayer = (layer) => {
         runtimeMappings: layer.runtime_mappings,
     };
 };
-const parseRuntimeCapture = (input) => {
-    const evidence = parseEvidence(input);
-    if (evidence.operation === "inspect_web_page") {
-        assertEvidenceIdentity(evidence, {
-            operation: "inspect_web_page",
-            predicate: "rea.web-page-inspection",
-            providerId: "rea-cdp-browser",
-            providerName: "REA Chrome DevTools Protocol observation provider",
-            providerVersion: "2",
-            authority: "external-service",
-            confidence: "observed",
-        });
-        const inspection = webPageInspectionSchema.parse(evidence.normalized_result);
-        assertRuntimeParameters(evidence, {
-            kind: "browser",
-            targetId: inspection.target.target_id,
-            targetOrigin: inspection.target.origin,
-            sourceIncluded: inspection.scripts.items.some(({ source }) => source.included),
-        });
-        return {
-            kind: "browser",
-            evidence,
-            inspection,
-            captureSha256: canonicalDigest(inspection, "Runtime reconciliation"),
-            scriptsCompleteWithinScope: scriptsComplete(inspection.completeness),
-        };
-    }
-    if (evidence.operation === "inspect_electron_page") {
-        assertEvidenceIdentity(evidence, {
-            operation: "inspect_electron_page",
-            predicate: "rea.electron-page-inspection",
-            providerId: "rea-cdp-electron",
-            providerName: "REA Electron file-page CDP observation provider",
-            providerVersion: "1",
-            authority: "external-service",
-            confidence: "observed",
-        });
-        const inspection = electronPageInspectionSchema.parse(evidence.normalized_result);
-        assertRuntimeParameters(evidence, {
-            kind: "electron",
-            targetId: inspection.target.target_id,
-            sourceIncluded: inspection.scripts.items.some(({ source }) => source.included),
-        });
-        return {
-            kind: "electron",
-            evidence,
-            inspection,
-            captureSha256: canonicalDigest(inspection, "Runtime reconciliation"),
-            scriptsCompleteWithinScope: scriptsComplete(inspection.completeness),
-        };
-    }
-    if (evidence.operation === "observe_javascript_runtime") {
-        assertEvidenceIdentity(evidence, {
-            operation: "observe_javascript_runtime",
-            predicate: "rea.javascript-runtime-observation",
-            providerId: "rea-v8-inspector",
-            providerName: "REA passive Node/Electron V8 Inspector provider",
-            providerVersion: "1",
-            authority: "external-service",
-            confidence: "observed",
-        });
-        const result = javascriptRuntimeObservationSchema.parse(evidence.normalized_result);
-        assertV8RuntimeParameters(evidence, result);
-        const inspection = normalizeV8Inspection(result);
-        return {
-            kind: "v8-inspector",
-            evidence,
-            inspection,
-            captureSha256: canonicalDigest(result, "Runtime reconciliation"),
-            scriptsCompleteWithinScope: false,
-        };
-    }
-    if (evidence.operation === "capture_electron_scenario") {
-        return parseActiveElectronCapture(evidence);
-    }
-    throw new TypeError("Runtime reconciliation requires inspect_web_page, inspect_electron_page, observe_javascript_runtime, or capture_electron_scenario Evidence");
-};
-const assertV8RuntimeParameters = (evidence, result) => {
-    const parameters = z
-        .object({
-        inspector_endpoint: browserEndpointSchema,
-        target_id: z.string().trim().min(1),
-        runtime_kind: javascriptRuntimeKindSchema.optional(),
-    })
-        .passthrough()
-        .parse(evidence.parameters);
-    if (parameters.target_id !== result.target.target_id ||
-        (parameters.runtime_kind !== undefined &&
-            parameters.runtime_kind !== result.target.runtime_kind))
-        throw new TypeError("Runtime Evidence target or declared role disagrees with its result");
-    for (const location of [
-        result.target.location,
-        ...result.scripts.items.map(({ location }) => location),
-    ])
-        if (location.kind === "builtin" && !location.specifier.startsWith("node:"))
-            throw new TypeError("Runtime Evidence contains an invalid builtin location");
-};
-const normalizeV8Inspection = (result) => ({
-    target: {
-        target_id: result.target.target_id,
-        type: result.target.protocol_type,
-        title: result.target.runtime_kind,
-        attached: result.target.attached,
-        ...(result.target.location.kind === "unresolved"
-            ? { unresolved_location: result.target.location }
-            : runtimeLocation(result.target.location)),
-    },
-    frames: [],
-    scripts: {
-        items: result.scripts.items.map((script) => ({
-            script_key: script.script_key,
-            frame_id: script.execution_context_key,
-            ...runtimeLocation(script.location),
-            cdp_hash: script.cdp_hash ?? "",
-            length: script.length,
-            is_module: script.is_module,
-            language: null,
-            source: {
-                included: false,
-                reason: "V8 Inspector source capture is outside passive authority.",
-            },
-        })),
-    },
-    workers: [],
-    completeness: classifyBrowserCompleteness({
-        policyFilteredSections: new Set(excludedV8Scripts(result) > 0 ? ["scripts"] : []),
-        attachLimitedSections: new Set([
-            "frames",
-            "scripts",
-            "script_sources",
-            "workers",
-        ]),
-        truncatedSections: new Set(result.capture.truncated ? ["scripts"] : []),
-        unavailableSections: new Set(["frames", "script_sources", "workers"]),
-        excluded: excludedV8Scripts(result) === 0
-            ? []
-            : [
-                {
-                    section: "scripts",
-                    reason: "out_of_target_scope",
-                    count: excludedV8Scripts(result),
-                },
-            ],
-        droppedEvents: {
-            scripts: result.capture.events_dropped,
-            network_requests: 0,
-            console_events: 0,
-            websocket_connections: 0,
-            websocket_frames: 0,
-            webmcp_tools: 0,
-            timeline_events: 0,
-        },
-    }),
-});
-const runtimeLocation = (location) => {
-    if (location.kind === "file")
-        return { file_path: location.file_path };
-    if (location.kind === "url")
-        return { url: location.sanitized_url };
-    return { url: location.specifier };
-};
-const excludedV8Scripts = (result) => Object.values(result.scripts.excluded).reduce((total, count) => total + count, 0);
-const assertRuntimeParameters = (evidence, expected) => {
-    const common = {
-        target_id: z.string().trim().min(1),
-        cdp_endpoint: browserEndpointSchema,
-        include_script_sources: z.boolean(),
-    };
-    if (expected.kind === "browser") {
-        const parameters = z
-            .object({ ...common, allowed_origins: browserAllowedOriginsSchema })
-            .passthrough()
-            .parse(evidence.parameters);
-        if (parameters.target_id !== expected.targetId)
-            throw new TypeError("Runtime Evidence target disagrees with its captured result");
-        if (!parameters.allowed_origins.includes(expected.targetOrigin))
-            throw new TypeError("Browser Evidence target is outside its recorded origin scope");
-        if (expected.sourceIncluded && !parameters.include_script_sources)
-            throw new TypeError("Runtime Evidence contains source without source-capture selection");
-        return;
-    }
-    const parameters = z.object(common).passthrough().parse(evidence.parameters);
-    if (parameters.target_id !== expected.targetId)
-        throw new TypeError("Runtime Evidence target disagrees with its captured result");
-    if (expected.sourceIncluded && !parameters.include_script_sources)
-        throw new TypeError("Runtime Evidence contains source without source-capture selection");
-};
-const scriptsComplete = (completeness) => !completeness.truncated_sections.includes("scripts") &&
-    !completeness.unavailable_sections.includes("scripts") &&
-    completeness.dropped_events.scripts === 0;
-const assertEvidenceIdentity = (evidence, expected) => {
-    if (evidence.operation !== expected.operation ||
-        evidence.predicate_type !== expected.predicate ||
-        evidence.provider.id !== expected.providerId ||
-        evidence.provider.name !== expected.providerName ||
-        evidence.provider.version !== expected.providerVersion ||
-        evidence.authority !== expected.authority ||
-        evidence.confidence !== expected.confidence)
-        throw new TypeError(`Evidence does not match the supported ${expected.operation} contract`);
-};

package/dist/domain/javascript/javascriptRuntimeReconciliationResult.js

@@ -1,5 +1,5 @@
 import {} from "./javascriptApplicationGraph.js";
-import { canonicalDigest } from "../comparisonSemantics.js";
+import { digestCanonicalValue } from "../canonicalDigest.js";
 import { uniqueSorted } from "../canonicalOrdering.js";
 import { javascriptRuntimeReconciliationResultSchema, } from "./javascriptRuntimeReconciliationSchemas.js";
 /** Build and verify the deterministic caller-visible reconciliation result. */
@@ -21,7 +21,7 @@ export const createJavaScriptRuntimeReconciliationResult = (input) => {
         limitations: reconciliationLimitations(completion),
     };
     return javascriptRuntimeReconciliationResultSchema.parse({
-        reconciliation_id: `jrr_${canonicalDigest(semantic, "Runtime reconciliation")}`,
+        reconciliation_id: `jrr_${digestCanonicalValue(semantic, "Runtime reconciliation")}`,
         ...semantic,
     });
 };

package/dist/domain/javascript/javascriptRuntimeReconciliationRuntime.js

@@ -86,9 +86,14 @@ const frameEntities = (capture) => capture.inspection.frames.map((frame) => {
     });
 });
 const scriptEntities = (capture) => capture.inspection.scripts.items.map((script) => {
-    const location = "url" in script
-        ? { kind: "url", value: script.url }
-        : { kind: "file", value: script.file_path };
+    const location = "unresolved_location" in script
+        ? {
+            kind: "unresolved",
+            value: script.unresolved_location.reported_url,
+        }
+        : "url" in script
+            ? { kind: "url", value: script.url }
+            : { kind: "file", value: script.file_path };
     return runtimeEntity(capture, {
         kind: "script",
         nodeKind: "runtime-script-instance",
@@ -103,7 +108,13 @@ const scriptEntities = (capture) => capture.inspection.scripts.items.map((script
             : null,
         label: location.value,
         properties: {
-            location: location.value,
+            ...("unresolved_location" in script
+                ? {
+                    location_kind: "unresolved",
+                    reported_url: script.unresolved_location.reported_url,
+                    location_reason: script.unresolved_location.reason,
+                }
+                : { location: location.value }),
             cdp_hash: script.cdp_hash,
             length: script.length,
             is_module: script.is_module,

package/dist/domain/javascript/javascriptRuntimeReconciliationSchemas.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { compareCodePoints } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { evidenceSchema } from "../evidence.js";
 import { javascriptRuntimeUnresolvedLocationSchema } from "./javascriptRuntimeObservation.js";
 import { javascriptApplicationGraphSchema } from "./javascriptApplicationGraph.js";
@@ -64,7 +64,7 @@ const staticLayerSchema = z.strictObject({
 function normalizeRuntimeMappings(mappings) {
     return [
         ...new Map(mappings.map((mapping) => [runtimeMappingKey(mapping), mapping])).values(),
-    ].sort((left, right) => compareCodePoints(runtimeMappingKey(left), runtimeMappingKey(right)));
+    ].sort((left, right) => compareUnicodeCodePoints(runtimeMappingKey(left), runtimeMappingKey(right)));
 }
 function runtimeMappingKey(mapping) {
     return mapping.kind === "file-root"