rea-agents 6.2.0 → 6.4.0

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 { 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,26 +1,15 @@
-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 { 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",
@@ -29,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,
@@ -48,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"

package/dist/domain/javascript/javascriptRuntimeStaticCandidates.js

@@ -1,10 +1,12 @@
 import { posix, relative, win32 } from "node:path";
-import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { logicalPathEscapesRoot, normalizeJoinedLogicalPath, } from "../artifactIdentity.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 /** Index statically reconstructed entities that can receive runtime matches. */
 export const collectStaticRuntimeCandidates = (layers) => layers
     .flatMap((layer) => candidatesForLayer(layer))
-    .sort((left, right) => compareCodePoints(left.layer.layerId, right.layer.layerId) ||
-    compareCodePoints(left.node.node_id, right.node.node_id));
+    .sort((left, right) => compareUnicodeCodePoints(left.layer.layerId, right.layer.layerId) ||
+    compareUnicodeCodePoints(left.node.node_id, right.node.node_id));
 /** Translate one already-authorized runtime location into artifact paths. */
 export const mappedRuntimePaths = (layer, entity) => {
     const paths = [];
@@ -107,7 +109,7 @@ const nodePaths = (node) => {
             paths.push(observation.evidence.location.value.path);
     }
     return paths
-        .map(normalizeArtifactPath)
+        .map(relativeLogicalPath)
         .filter((path) => path !== null && path !== "artifact-root");
 };
 const candidateDigests = (node) => {
@@ -141,7 +143,7 @@ const pathBelowRoot = (root, value) => {
         portableRemainder === ".." ||
         portableRemainder.startsWith("../"))
         return null;
-    return normalizeArtifactPath(portableRemainder);
+    return relativeLogicalPath(portableRemainder);
 };
 const absoluteFilePathStyle = (path) => {
     if (/^[a-z]:[\\/]/iu.test(path) ||
@@ -165,7 +167,7 @@ const pathBelowUrlPrefix = (prefix, value) => {
         !candidate.pathname.startsWith(base.pathname))
         return null;
     try {
-        return normalizeArtifactPath(decodeURIComponent(candidate.pathname.slice(base.pathname.length)));
+        return relativeLogicalPath(decodeURIComponent(candidate.pathname.slice(base.pathname.length)));
     }
     catch (cause) {
         // Undecodable path segments are represented by the null return.
@@ -186,23 +188,19 @@ const activeArtifactPrefixes = (layer, entities) => {
                 ? pathBelowUrlPrefix(mapping.prefix, location.value) !== null
                 : false))
             prefixes.add(mapping.artifact_prefix);
-    return [...prefixes].sort(compareCodePoints);
+    return [...prefixes].sort(compareUnicodeCodePoints);
 };
 const pathWithinPrefix = (path, prefix) => prefix === "" || path === prefix || path.startsWith(`${prefix}/`);
-const safeArtifactPath = (prefix, suffix) => normalizeArtifactPath(prefix === "" ? suffix : posix.join(prefix, suffix));
-const normalizeArtifactPath = (value) => {
-    const normalized = posix
-        .normalize(value.replaceAll("\\", "/"))
-        .replace(/^\.\//u, "");
+const safeArtifactPath = (prefix, suffix) => relativeLogicalPath(prefix === "" ? suffix : posix.join(prefix, suffix));
+const relativeLogicalPath = (value) => {
+    const normalized = normalizeJoinedLogicalPath(value);
     return normalized !== "" &&
         normalized !== "." &&
-        normalized !== ".." &&
-        !normalized.startsWith("/") &&
-        !normalized.startsWith("../")
+        !logicalPathEscapesRoot(normalized)
         ? normalized
         : null;
 };
 const uniqueMappedPaths = (values) => [
     ...new Map(values.map((value) => [`${value.basis}:${value.path}`, value])).values(),
-].sort((left, right) => compareCodePoints(left.path, right.path) ||
-    compareCodePoints(left.basis, right.basis));
+].sort((left, right) => compareUnicodeCodePoints(left.path, right.path) ||
+    compareUnicodeCodePoints(left.basis, right.basis));