rea-agents 3.1.0 → 3.2.1

package/dist/domain/javascriptRuntimeObservation.js

@@ -1,148 +1,89 @@
-import { isAbsolute, resolve } from "node:path";
 import { z } from "zod";
-import { browserEndpointSchema, browserOriginSchema, } from "./browserObservation.js";
-const boundedTextSchema = z.string().min(1).max(4_096);
-const runtimeFileRootsSchema = z
-    .array(z
-    .string()
-    .min(1)
-    .max(16_384)
-    .refine(isAbsolute, "Runtime file roots must be absolute paths")
-    .overwrite(resolve))
-    .max(32)
-    .overwrite((roots) => [...new Set(roots)].sort())
-    .default([]);
-const runtimeOriginsSchema = z
-    .array(browserOriginSchema)
-    .max(32)
-    .overwrite((origins) => [...new Set(origins)].sort())
-    .default([]);
-const approvedRuntimeScope = {
+import { browserEndpointSchema } from "./browserObservation.js";
+const observationTextSchema = z.string().min(1);
+const runtimeEndpoint = {
     inspector_endpoint: browserEndpointSchema,
-    allowed_file_roots: runtimeFileRootsSchema,
-    allowed_origins: runtimeOriginsSchema,
-    approved: z.literal(true),
 };
-const requireRuntimeScope = (input, context) => {
-    if (input.allowed_file_roots.length === 0 &&
-        input.allowed_origins.length === 0)
-        context.addIssue({
-            code: "custom",
-            path: ["allowed_file_roots"],
-            message: "At least one exact file root or HTTP(S) origin is required",
-        });
-};
-/** Input for listing approved Node/Electron V8 Inspector targets. */
-export const listJavaScriptRuntimeTargetsInputSchema = z
-    .strictObject({
-    ...approvedRuntimeScope,
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(200).default(100),
-})
-    .superRefine(requireRuntimeScope);
+/** Input for listing targets exposed by an explicit Node/Electron Inspector endpoint. */
+export const listJavaScriptRuntimeTargetsInputSchema = z.strictObject({
+    ...runtimeEndpoint,
+});
 export const javascriptRuntimeKindSchema = z.enum([
     "node",
     "electron-main",
     "electron-preload",
     "electron-renderer",
 ]);
-export const javascriptRuntimeObservationLimitsSchema = z.strictObject({
-    max_events: z.number().int().min(1).max(50_000).default(10_000),
-    max_scripts: z.number().int().min(1).max(10_000).default(2_000),
-    max_execution_contexts: z.number().int().min(1).max(5_000).default(1_000),
-    max_location_bytes: z.number().int().min(64).max(65_536).default(16_384),
-    max_total_metadata_bytes: z
-        .number()
-        .int()
-        .min(1_024)
-        .max(32 * 1_024 * 1_024)
-        .default(4 * 1_024 * 1_024),
-});
+const observedJavaScriptRuntimeKindSchema = javascriptRuntimeKindSchema.or(z.literal("unknown"));
 /** Input for one bounded, attach-only V8 Inspector observation. */
-export const observeJavaScriptRuntimeInputSchema = z
-    .strictObject({
-    ...approvedRuntimeScope,
-    target_id: z.string().trim().min(1).max(256),
-    runtime_kind: javascriptRuntimeKindSchema,
-    observation_ms: z.number().int().min(0).max(10_000).default(100),
-    limits: javascriptRuntimeObservationLimitsSchema.default({
-        max_events: 10_000,
-        max_scripts: 2_000,
-        max_execution_contexts: 1_000,
-        max_location_bytes: 16_384,
-        max_total_metadata_bytes: 4 * 1_024 * 1_024,
-    }),
-})
-    .superRefine(requireRuntimeScope);
+/** Input for one passive attach-only V8 Inspector observation. */
+export const observeJavaScriptRuntimeInputSchema = z.strictObject({
+    ...runtimeEndpoint,
+    target_id: z.string().trim().min(1),
+    runtime_kind: javascriptRuntimeKindSchema.optional(),
+    observation_ms: z.number().int().min(0).default(100),
+});
 export const javascriptRuntimeVersionSchema = z.strictObject({
-    product: z.string().min(1).max(1_024),
-    protocol_version: z.string().min(1).max(100),
-    v8_version: z.string().max(1_024).nullable(),
+    product: z.string().min(1),
+    protocol_version: z.string().min(1),
+    v8_version: z.string().nullable(),
 });
 export const javascriptRuntimeLocationSchema = z.discriminatedUnion("kind", [
     z.strictObject({
         kind: z.literal("file"),
-        file_path: z.string().min(1).max(16_384),
+        file_path: z.string().min(1),
         authority: z.literal("scope-fallback").optional(),
     }),
     z.strictObject({
         kind: z.literal("url"),
-        origin: z.string().min(1).max(2_048),
-        sanitized_url: z.string().min(1).max(65_536),
+        origin: z.string().min(1),
+        sanitized_url: z.string().min(1),
     }),
     z.strictObject({
         kind: z.literal("builtin"),
-        specifier: z.string().min(1).max(4_096),
+        specifier: z.string().min(1),
     }),
 ]);
 const javascriptRuntimeTargetSchema = z.strictObject({
-    target_id: z.string().min(1).max(256),
-    protocol_type: z.string().min(1).max(100),
+    target_id: z.string().min(1),
+    protocol_type: z.string().min(1),
     attached: z.boolean(),
     location: javascriptRuntimeLocationSchema,
 });
-/** Root/origin-filtered V8 Inspector target inventory. */
+/** Complete V8 Inspector target inventory exposed by the selected endpoint. */
 export const javascriptRuntimeTargetListSchema = z.strictObject({
-    schema_version: z.literal(1),
     runtime: javascriptRuntimeVersionSchema,
-    targets: z.strictObject({
-        items: z.array(javascriptRuntimeTargetSchema),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1),
-        total: z.number().int().min(0),
-        next_offset: z.number().int().min(0).nullable(),
-        has_more: z.boolean(),
-    }),
+    targets: z.array(javascriptRuntimeTargetSchema),
     excluded: z.strictObject({
-        outside_file_roots: z.number().int().min(0),
-        outside_origins: z.number().int().min(0),
         unsupported_location: z.number().int().min(0),
         unconnectable: z.number().int().min(0),
     }),
-    limitations: z.array(boundedTextSchema).max(100),
+    limitations: z.array(observationTextSchema),
 });
 const javascriptRuntimeScriptSchema = z.strictObject({
     script_key: z.string().regex(/^v8_script_[a-f0-9]{64}$/u),
     location: javascriptRuntimeLocationSchema,
-    execution_context_key: z.string().max(64).nullable(),
-    cdp_hash: z.string().max(512).nullable(),
+    execution_context_key: z.string().nullable(),
+    cdp_hash: z.string().nullable(),
     length: z.number().int().min(0),
     is_module: z.boolean(),
     status: z.literal("observed-loaded"),
 });
 const javascriptRuntimeContextSchema = z.strictObject({
-    context_key: z.string().min(1).max(64),
+    context_key: z.string().min(1),
     state: z.enum(["created", "destroyed", "cleared"]),
-    name: z.string().max(1_024).nullable(),
-    origin: z.string().max(4_096).nullable(),
+    name: z.string().nullable(),
+    origin: z.string().nullable(),
 });
 /** Deterministic passive script/context snapshot from one bounded window. */
 export const javascriptRuntimeObservationSchema = z.strictObject({
-    schema_version: z.literal(1),
     runtime: javascriptRuntimeVersionSchema,
     target: javascriptRuntimeTargetSchema.extend({
-        runtime_kind: javascriptRuntimeKindSchema,
-        runtime_kind_authority: z.literal("caller-declared-unverified"),
+        runtime_kind: observedJavaScriptRuntimeKindSchema,
+        runtime_kind_authority: z.enum([
+            "caller-declared-unverified",
+            "not-declared",
+        ]),
     }),
     capture: z.strictObject({
         observation_ms: z.number().int().min(0),
@@ -151,21 +92,19 @@ export const javascriptRuntimeObservationSchema = z.strictObject({
         events_dropped: z.number().int().min(0),
         metadata_bytes_retained: z.number().int().min(0),
         truncated: z.boolean(),
-        truncation_reasons: z.array(boundedTextSchema).max(20),
+        truncation_reasons: z.array(observationTextSchema),
     }),
     scripts: z.strictObject({
         items: z.array(javascriptRuntimeScriptSchema),
         observed_total: z.number().int().min(0),
         excluded: z.strictObject({
-            outside_file_roots: z.number().int().min(0),
-            outside_origins: z.number().int().min(0),
             unsupported_location: z.number().int().min(0),
             invalid_protocol_value: z.number().int().min(0),
         }),
     }),
     execution_contexts: z.array(javascriptRuntimeContextSchema),
-    directly_observed: z.array(boundedTextSchema).max(20),
-    unavailable_without_instrumentation: z.array(boundedTextSchema).max(20),
-    unknowns: z.array(boundedTextSchema).max(100),
-    limitations: z.array(boundedTextSchema).max(100),
+    directly_observed: z.array(observationTextSchema),
+    unavailable_without_instrumentation: z.array(observationTextSchema),
+    unknowns: z.array(observationTextSchema),
+    limitations: z.array(observationTextSchema),
 });

package/dist/domain/javascriptRuntimeReconciliation.js

@@ -11,16 +11,14 @@ export const reconcileJavaScriptRuntime = (input) => {
     const parsed = reconcileJavaScriptRuntimeInputSchema.parse(input);
     const layers = parseStaticLayers(parsed.static_layers);
     const captures = parseRuntimeCaptures(parsed.runtime_observations);
-    const runtime = projectRuntimeCaptures(captures, parsed.limits.max_runtime_entities);
+    const runtime = projectRuntimeCaptures(captures);
     const candidates = collectStaticRuntimeCandidates(layers);
     const matching = reconcileRuntimeEntities({
         entities: runtime.entities,
         candidates,
         layers,
-        maximumItems: parsed.limits.max_reconciliation_items,
     });
     const loadStates = classifyStaticLoadStates(layers, runtime.entities, matching.items, {
-        maximumStates: parsed.limits.max_static_load_states,
         reconciliationComplete: runtime.omittedEntities === 0 && matching.omittedItems === 0,
     });
     const graph = buildReconciledApplicationGraph({

package/dist/domain/javascriptRuntimeReconciliationActive.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
-import { isAbsolute, relative } from "node:path";
+import { isAbsolute } from "node:path";
+import { isPathWithinRoot } from "./localPath.js";
 import canonicalize from "canonicalize";
 import { z } from "zod";
 import { classifyBrowserCompleteness, } from "./browserCompleteness.js";
@@ -10,15 +11,14 @@ export const parseActiveElectronCapture = (evidence) => {
     const result = electronActiveObservationResultSchema.parse(evidence.normalized_result);
     const parameters = z
         .object({
-        approved: z.literal(true),
         application_path: absolutePathSchema,
         application_root: absolutePathSchema,
     })
         .passthrough()
         .parse(evidence.parameters);
     if (result.application.application_path !== parameters.application_path ||
-        !isWithinRoot(parameters.application_root, result.application.application_path))
-        throw new TypeError("Active Electron Evidence application path disagrees with its approved root");
+        !isPathWithinRoot(parameters.application_root, result.application.application_path))
+        throw new TypeError("Active Electron Evidence application path disagrees with its configured root");
     return {
         kind: "electron-active",
         evidence,
@@ -27,10 +27,10 @@ export const parseActiveElectronCapture = (evidence) => {
         scriptsCompleteWithinScope: false,
     };
 };
-const absolutePathSchema = z.string().min(1).max(16_384).refine(isAbsolute);
+const absolutePathSchema = z.string().min(1).refine(isAbsolute);
 const assertIdentity = (evidence) => {
     if (evidence.operation !== "capture_electron_scenario" ||
-        evidence.predicate_type !== "rea.electron-active-scenario/v1" ||
+        evidence.predicate_type !== "rea.electron-active-scenario" ||
         evidence.provider.id !== "rea-playwright-electron-active" ||
         evidence.provider.name !==
             "REA Playwright active Electron observation provider" ||
@@ -53,12 +53,7 @@ const normalizeInspection = (result) => ({
     completeness: classifyBrowserCompleteness({
         policyFilteredSections: new Set(),
         attachLimitedSections: new Set(),
-        truncatedSections: new Set(result.windows_truncated ||
-            result.processes.truncated ||
-            result.ipc.truncated ||
-            result.timeline.truncated
-            ? ["timeline"]
-            : []),
+        truncatedSections: new Set(),
         unavailableSections: new Set([
             "frames",
             "scripts",
@@ -73,7 +68,7 @@ const normalizeInspection = (result) => ({
             websocket_connections: 0,
             websocket_frames: 0,
             webmcp_tools: 0,
-            timeline_events: result.timeline.truncated ? result.timeline.observed : 0,
+            timeline_events: 0,
         },
     }),
 });
@@ -83,7 +78,3 @@ const digestCanonical = (value) => {
         throw new TypeError("Runtime reconciliation could not canonicalize input");
     return createHash("sha256").update(encoded).digest("hex");
 };
-const isWithinRoot = (root, path) => {
-    const remainder = relative(root, path);
-    return (remainder === "" || (!remainder.startsWith("..") && !isAbsolute(remainder)));
-};

package/dist/domain/javascriptRuntimeReconciliationGraph.js

@@ -10,11 +10,10 @@ export const buildReconciledApplicationGraph = (input) => {
         ...input.runtime.edges,
         ...input.reconciliationEdges,
     ]);
-    const bounded = boundGraphContent(input, merged.nodes, allEdges);
-    const facts = graphCoverageFacts(input, merged.omittedObservations + bounded.omittedItems);
+    const bounded = boundGraphContent(input, merged, allEdges);
+    const facts = graphCoverageFacts(input, bounded.omittedItems);
     const graph = createJavaScriptApplicationGraph({
         schema: "JavaScriptApplicationGraph",
-        schema_version: 1,
         root_node_ids: bounded.rootNodeIds,
         nodes: bounded.nodes,
         edges: bounded.edges,
@@ -31,38 +30,30 @@ export const buildReconciledApplicationGraph = (input) => {
                 : []),
             ...(facts.outputTruncated
                 ? [
-                    "The reconciled graph omitted entities or classifications at caller limits.",
+                    "The reconciled graph omitted entities or classifications during projection.",
                 ]
                 : []),
         ]),
     });
     return {
         graph,
-        omittedGraphItems: merged.omittedObservations + bounded.omittedItems,
+        omittedGraphItems: bounded.omittedItems,
     };
 };
 const boundGraphContent = (input, nodes, edges) => {
     const allRoots = preferredRootIds(input);
-    const rootNodeIds = allRoots.slice(0, 1_000);
-    const roots = new Set(rootNodeIds);
+    const rootNodeIds = allRoots;
     const sortedNodes = [...nodes].sort((left, right) => compareCodePoints(left.node_id, right.node_id));
-    const retainedNodes = [
-        ...sortedNodes.filter(({ node_id: id }) => roots.has(id)),
-        ...sortedNodes.filter(({ node_id: id }) => !roots.has(id)),
-    ].slice(0, 100_000);
+    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))
-        .filter(({ source_node_id: source, target_node_id: target }) => retainedIds.has(source) && retainedIds.has(target))
-        .slice(0, 200_000);
+        .filter(({ source_node_id: source, target_node_id: target }) => retainedIds.has(source) && retainedIds.has(target));
     return {
         rootNodeIds,
         nodes: retainedNodes,
         edges: retainedEdges,
-        omittedItems: allRoots.length -
-            rootNodeIds.length +
-            (nodes.length - retainedNodes.length) +
-            (edges.length - retainedEdges.length),
+        omittedItems: 0,
     };
 };
 const preferredRootIds = (input) => {
@@ -140,7 +131,6 @@ const mergeNodes = (nodes) => {
     const grouped = new Map();
     for (const node of nodes)
         grouped.set(node.node_id, [...(grouped.get(node.node_id) ?? []), node]);
-    let omittedObservations = 0;
     const merged = [...grouped.values()].map((group) => {
         const first = group[0];
         if (first === undefined)
@@ -153,16 +143,13 @@ const mergeNodes = (nodes) => {
                 .flatMap(({ observations: values }) => values)
                 .map((observation) => [observation.observation_id, observation])).values(),
         ].sort((left, right) => compareCodePoints(left.observation_id, right.observation_id));
-        omittedObservations += Math.max(0, observations.length - 64);
         return createJavaScriptApplicationNode({
             kind: first.kind,
             identity: first.identity,
-            observations: observations
-                .slice(0, 64)
-                .map(({ observation_id: _id, identifier_strategy: _strategy, ...value }) => value),
+            observations: observations.map(({ observation_id: _id, identifier_strategy: _strategy, ...value }) => value),
         });
     });
-    return { nodes: merged, omittedObservations };
+    return merged;
 };
 const uniqueEdges = (edges) => [
     ...new Map(edges.map((edge) => [edge.edge_id, edge])).values(),

package/dist/domain/javascriptRuntimeReconciliationMatching.js

@@ -5,13 +5,11 @@ import { mappedRuntimePaths, } from "./javascriptRuntimeStaticCandidates.js";
 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))
-        .slice(0, input.maximumItems);
+    const retained = evaluated.sort((left, right) => compareCodePoints(left.item.reconciliation_id, right.item.reconciliation_id));
     return {
         items: retained.map(({ item }) => item),
         edges: retained.flatMap(({ edge }) => (edge === null ? [] : [edge])),
-        omittedItems: evaluated.length - retained.length,
+        omittedItems: 0,
     };
 };
 const reconcileEntity = (entity, index, layers) => {
@@ -159,13 +157,22 @@ const unresolved = (entity, input) => ({
 });
 const createItem = (entity, input) => {
     const candidateReferences = uniqueCandidateReferences(input.candidates);
+    const staticMatch = input.status === "matched"
+        ? {
+            static_layer_id: input.layer.layerId,
+            static_node_id: input.staticNodeId,
+            status: input.status,
+        }
+        : {
+            static_layer_id: null,
+            static_node_id: null,
+            status: input.status,
+        };
     const semantic = {
         entity_kind: entity.kind,
         runtime_evidence_id: entity.capture.evidence.evidence_id,
         runtime_node_id: entity.node.node_id,
-        static_layer_id: input.layer?.layerId ?? null,
-        static_node_id: input.staticNodeId,
-        status: input.status,
+        ...staticMatch,
         basis: input.basis,
         confidence: input.confidence,
         reason: input.reason,
@@ -245,11 +252,10 @@ const uniqueCandidateReferences = (candidates) => {
             continue;
         seen.add(key);
         count += 1;
-        if (items.length < 1_000)
-            items.push({
-                static_layer_id: layer.layerId,
-                static_node_id: node.node_id,
-            });
+        items.push({
+            static_layer_id: layer.layerId,
+            static_node_id: node.node_id,
+        });
     }
     return { count, items };
 };

package/dist/domain/javascriptRuntimeReconciliationParsing.js

@@ -1,10 +1,9 @@
 import { createHash } from "node:crypto";
-import { isAbsolute, relative } from "node:path";
 import canonicalize from "canonicalize";
 import { z } from "zod";
-import { browserAllowedOriginsSchema, browserEndpointSchema, browserOriginSchema, webPageInspectionSchema, } from "./browserObservation.js";
+import { browserAllowedOriginsSchema, browserEndpointSchema, webPageInspectionSchema, } from "./browserObservation.js";
 import { classifyBrowserCompleteness, } from "./browserCompleteness.js";
-import { electronFileRootsSchema, electronPageInspectionSchema, } from "./electronObservation.js";
+import { electronPageInspectionSchema, } from "./electronObservation.js";
 import { javascriptRuntimeObservationSchema, javascriptRuntimeKindSchema, } from "./javascriptRuntimeObservation.js";
 import { parseEvidence } from "./evidence.js";
 import { javascriptApplicationAnalysisResultSchema, } from "./javascriptApplicationAnalysis.js";
@@ -29,7 +28,7 @@ const parseStaticLayer = (layer) => {
     const result = javascriptApplicationAnalysisResultSchema.parse(evidence.normalized_result);
     assertEvidenceIdentity(evidence, {
         operation: "analyze_javascript_application",
-        predicate: `rea.javascript-application-analysis/v${String(result.schema_version)}`,
+        predicate: "rea.javascript-application-analysis",
         providerId: "rea-javascript-application",
         providerName: "REA JavaScript application analyzer",
         providerVersion: "1",
@@ -41,13 +40,6 @@ const parseStaticLayer = (layer) => {
         evidence.subject.format !== result.format ||
         evidence.subject.local_path !== result.input_path)
         throw new TypeError("JavaScript application Evidence subject disagrees with its result");
-    const parameters = z
-        .object({
-        approved: z.literal(true),
-        source_map_read_approved: z.boolean(),
-    })
-        .passthrough()
-        .parse(evidence.parameters);
     return {
         layerId: `jrl_${digestCanonical({
             role: layer.role,
@@ -59,7 +51,6 @@ const parseStaticLayer = (layer) => {
         result,
         graph: result.graph,
         runtimeMappings: layer.runtime_mappings,
-        sourceMapReadApproved: parameters.source_map_read_approved,
     };
 };
 const parseRuntimeCapture = (input) => {
@@ -67,7 +58,7 @@ const parseRuntimeCapture = (input) => {
     if (evidence.operation === "inspect_web_page") {
         assertEvidenceIdentity(evidence, {
             operation: "inspect_web_page",
-            predicate: "rea.web-page-inspection/v2",
+            predicate: "rea.web-page-inspection",
             providerId: "rea-cdp-browser",
             providerName: "REA Chrome DevTools Protocol observation provider",
             providerVersion: "2",
@@ -92,7 +83,7 @@ const parseRuntimeCapture = (input) => {
     if (evidence.operation === "inspect_electron_page") {
         assertEvidenceIdentity(evidence, {
             operation: "inspect_electron_page",
-            predicate: "rea.electron-page-inspection/v1",
+            predicate: "rea.electron-page-inspection",
             providerId: "rea-cdp-electron",
             providerName: "REA Electron file-page CDP observation provider",
             providerVersion: "1",
@@ -116,7 +107,7 @@ const parseRuntimeCapture = (input) => {
     if (evidence.operation === "observe_javascript_runtime") {
         assertEvidenceIdentity(evidence, {
             operation: "observe_javascript_runtime",
-            predicate: "rea.javascript-runtime-observation/v1",
+            predicate: "rea.javascript-runtime-observation",
             providerId: "rea-v8-inspector",
             providerName: "REA passive Node/Electron V8 Inspector provider",
             providerVersion: "1",
@@ -143,32 +134,21 @@ const assertV8RuntimeParameters = (evidence, result) => {
     const parameters = z
         .object({
         inspector_endpoint: browserEndpointSchema,
-        allowed_file_roots: z
-            .array(z.string().min(1).max(16_384).refine(isAbsolute))
-            .max(32),
-        allowed_origins: z.array(browserOriginSchema).max(32),
-        target_id: z.string().trim().min(1).max(256),
-        runtime_kind: javascriptRuntimeKindSchema,
+        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 !== result.target.runtime_kind)
+        (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 === "file" &&
-            !parameters.allowed_file_roots.some((root) => isWithinRoot(root, location.file_path))) ||
-            (location.kind === "url" &&
-                !parameters.allowed_origins.includes(location.origin)) ||
-            (location.kind === "builtin" && !location.specifier.startsWith("node:")))
-            throw new TypeError("Runtime Evidence contains a location outside its recorded scope");
-};
-const isWithinRoot = (root, path) => {
-    const remainder = relative(root, path);
-    return (remainder === "" || (!remainder.startsWith("..") && !isAbsolute(remainder)));
+        if (location.kind === "builtin" && !location.specifier.startsWith("node:"))
+            throw new TypeError("Runtime Evidence contains an invalid builtin location");
 };
 const normalizeV8Inspection = (result) => ({
     target: {
@@ -235,7 +215,7 @@ const runtimeLocation = (location) => {
 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).max(256),
+        target_id: z.string().trim().min(1),
         cdp_endpoint: browserEndpointSchema,
         include_script_sources: z.boolean(),
     };
@@ -252,20 +232,11 @@ const assertRuntimeParameters = (evidence, expected) => {
             throw new TypeError("Runtime Evidence contains source without source-capture approval");
         return;
     }
-    const parameters = z
-        .object({
-        ...common,
-        allowed_file_roots: electronFileRootsSchema,
-        source_capture_approved: z.boolean(),
-    })
-        .passthrough()
-        .parse(evidence.parameters);
+    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 ||
-            parameters.source_capture_approved !== true))
-        throw new TypeError("Runtime Evidence contains source without source-capture approval");
+    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") &&

package/dist/domain/javascriptRuntimeReconciliationResult.js

@@ -5,7 +5,6 @@ import { javascriptRuntimeReconciliationResultSchema, } from "./javascriptRuntim
 export const createJavaScriptRuntimeReconciliationResult = (input) => {
     const completion = completionFlags(input);
     const semantic = {
-        schema_version: 1,
         static_layers: staticLayerSummaries(input.layers),
         runtime_captures: captureSummaries(input.captures, input.runtime),
         graph: input.graph,
@@ -45,9 +44,9 @@ const captureSummaries = (captures, runtime) => captures.map((capture) => {
         kind: capture.kind,
         target_node_id: targetNode.node_id,
         target_key: capture.inspection.target.target_id,
-        target_location: ("url" in capture.inspection.target
+        target_location: "url" in capture.inspection.target
             ? capture.inspection.target.url
-            : capture.inspection.target.file_path).slice(0, 4_096),
+            : capture.inspection.target.file_path,
         frames: capture.inspection.frames.length,
         scripts: capture.inspection.scripts.items.length,
         workers: capture.inspection.workers.length,
@@ -70,7 +69,7 @@ const reconciliationSummary = (input) => ({
 });
 const sourceMapAuthority = (input) => ({
     used_for_primary_matching: false,
-    static_layers_with_read_approval: input.layers.filter(({ sourceMapReadApproved }) => sourceMapReadApproved).length,
+    static_layer_count: input.layers.length,
     runtime_script_declarations: input.captures.reduce((total, capture) => total +
         (capture.kind === "browser"
             ? capture.inspection.scripts.items.filter(({ source_map_url: url }) => url !== null).length
@@ -118,7 +117,7 @@ const reconciliationLimitations = (completion) => uniqueSorted([
         : []),
     ...(completion.outputTruncated
         ? [
-            "Caller limits omitted runtime entities or reconciliation classifications.",
+            "Runtime reconciliation omitted entities or classifications during projection.",
         ]
         : []),
 ]);