rea-agents 3.1.0 → 3.2.1

package/dist/domain/webBundleAnalyzer.js

@@ -1,17 +1,15 @@
 import { analyzeScript, emptyAccumulator, isIncludedScript, } from "./webBundleAnalyzerInspection.js";
 import { buildWebBundleAnalysis } from "./webBundleAnalyzerResult.js";
 /** Analyze captured, explicitly approved JavaScript source without execution. */
-export const analyzeCapturedWebBundle = (inspection, input, sourceMaps = {
+export const analyzeCapturedWebBundle = (inspection, sourceMaps = {
     status: "not_requested",
     requested: 0,
     processed: 0,
-    dropped: 0,
-    dropped_script_keys: [],
     items: [],
 }) => {
     const accumulator = emptyAccumulator();
     const sourceScripts = inspection.scripts.items.filter(isIncludedScript);
     for (const script of sourceScripts)
-        analyzeScript(script, input, accumulator);
+        analyzeScript(script, accumulator);
     return buildWebBundleAnalysis(inspection, sourceScripts, sourceMaps, accumulator);
 };

package/dist/domain/webBundleAnalyzerAst.js

@@ -44,19 +44,6 @@ export const resolveSpecifier = (specifier, base) => {
         return null;
     }
 };
-export const sanitizeCandidate = (value) => {
-    const bounded = value.slice(0, 4_096);
-    try {
-        const parsed = new URL(bounded, "https://rea.invalid");
-        const sanitized = sanitizeBrowserUrl(parsed.href).url;
-        return parsed.origin === "https://rea.invalid"
-            ? sanitized.replace("https://rea.invalid", "")
-            : sanitized;
-    }
-    catch {
-        return bounded.split("#", 1)[0]?.split("?", 1)[0] ?? "";
-    }
-};
 export const location = (scriptKey, node) => ({
     script_key: scriptKey,
     ...locationFields(node),

package/dist/domain/webBundleAnalyzerInspection.js

@@ -1,7 +1,8 @@
 import { parse } from "@babel/parser";
 import * as t from "@babel/types";
-import { calleeName, endpointArgument, location, locationFields, objectString, objectValue, propertyName, resolveSpecifier, sanitizeCandidate, stringArgument, } from "./webBundleAnalyzerAst.js";
-export const analyzeScript = (script, input, accumulator) => {
+import { sanitizeEndpointCandidate } from "./browserObservation.js";
+import { calleeName, endpointArgument, location, locationFields, objectString, objectValue, propertyName, resolveSpecifier, stringArgument, } from "./webBundleAnalyzerAst.js";
+export const analyzeScript = (script, accumulator) => {
     let file;
     try {
         file = parse(script.source.artifact.text, {
@@ -15,18 +16,14 @@ export const analyzeScript = (script, input, accumulator) => {
         return;
     }
     accumulator.parsedScripts += 1;
-    detectVendorFingerprints(script, accumulator, input.analysis_limits.max_findings);
+    detectVendorFingerprints(script, accumulator);
     t.traverseFast(file, (node) => {
         accumulator.visitedNodes += 1;
-        if (accumulator.visitedNodes > input.analysis_limits.max_ast_nodes) {
-            accumulator.astLimitReached = true;
-            return t.traverseFast.stop;
-        }
-        inspectNode(script, node, accumulator, input.analysis_limits.max_findings);
+        inspectNode(script, node, accumulator);
         return undefined;
     });
 };
-const inspectNode = (script, node, accumulator, maximumFindings) => {
+const inspectNode = (script, node, accumulator) => {
     if ((t.isImportDeclaration(node) || t.isExportAllDeclaration(node)) &&
         node.source !== undefined)
         addEdge({
@@ -35,7 +32,6 @@ const inspectNode = (script, node, accumulator, maximumFindings) => {
             kind: "static_import",
             node,
             accumulator,
-            maximumFindings,
         });
     else if (t.isExportNamedDeclaration(node) && node.source != null)
         addEdge({
@@ -44,7 +40,6 @@ const inspectNode = (script, node, accumulator, maximumFindings) => {
             kind: "static_import",
             node,
             accumulator,
-            maximumFindings,
         });
     else if (t.isImportExpression(node) && t.isStringLiteral(node.source))
         addEdge({
@@ -53,14 +48,13 @@ const inspectNode = (script, node, accumulator, maximumFindings) => {
             kind: "dynamic_import",
             node,
             accumulator,
-            maximumFindings,
         });
     if (t.isObjectProperty(node))
-        inspectRouteProperty(script, node, accumulator, maximumFindings);
+        inspectRouteProperty(script, node, accumulator);
     if (t.isCallExpression(node) || t.isNewExpression(node))
-        inspectCall(script, node, accumulator, maximumFindings);
+        inspectCall(script, node, accumulator);
 };
-const inspectCall = (script, node, accumulator, maximumFindings) => {
+const inspectCall = (script, node, accumulator) => {
     const name = calleeName(node.callee);
     const first = stringArgument(node.arguments[0]);
     if ((name === "require" || name.endsWith(".require")) && first !== undefined)
@@ -70,7 +64,6 @@ const inspectCall = (script, node, accumulator, maximumFindings) => {
             kind: "require",
             node,
             accumulator,
-            maximumFindings,
         });
     if ((name === "importScripts" || name.endsWith(".importScripts")) &&
         first !== undefined)
@@ -80,7 +73,6 @@ const inspectCall = (script, node, accumulator, maximumFindings) => {
             kind: "worker_import",
             node,
             accumulator,
-            maximumFindings,
         });
     if (routeCallNames.some((candidate) => name === candidate || name.endsWith(`.${candidate}`))) {
         if (first !== undefined)
@@ -91,14 +83,12 @@ const inspectCall = (script, node, accumulator, maximumFindings) => {
                 mechanism: `call:${name}`,
                 node,
                 accumulator,
-                maximumFindings,
             });
         addRouteFrameworkInference({
             script,
             name,
             node,
             accumulator,
-            maximumFindings,
         });
     }
     const endpoint = endpointArgument(name, node.arguments);
@@ -110,13 +100,12 @@ const inspectCall = (script, node, accumulator, maximumFindings) => {
             mechanism: `call:${name}`,
             node,
             accumulator,
-            maximumFindings,
         });
     if (name.endsWith("modelContext.registerTool") ||
         name === "modelContext.registerTool")
-        addWebMcpDeclaration(script, node, accumulator, maximumFindings);
+        addWebMcpDeclaration(script, node, accumulator);
 };
-const inspectRouteProperty = (script, node, accumulator, maximumFindings) => {
+const inspectRouteProperty = (script, node, accumulator) => {
     const key = propertyName(node.key);
     if ((key === "path" || key === "route") && t.isStringLiteral(node.value))
         addFinding({
@@ -126,30 +115,28 @@ const inspectRouteProperty = (script, node, accumulator, maximumFindings) => {
             mechanism: `property:${key}`,
             node,
             accumulator,
-            maximumFindings,
         });
 };
 const addEdge = (context) => {
-    const bounded = context.specifier.slice(0, 4_096);
-    const key = `edge\0${context.script.script_key}\0${context.kind}\0${bounded}`;
-    addBounded(context.accumulator, key, context.maximumFindings, () => context.accumulator.edges.push({
+    const key = `edge\0${context.script.script_key}\0${context.kind}\0${context.specifier}`;
+    addUnique(context.accumulator, key, () => context.accumulator.edges.push({
         from_script_key: context.script.script_key,
         kind: context.kind,
-        specifier: bounded,
-        resolved_url: resolveSpecifier(bounded, context.script.url),
+        specifier: context.specifier,
+        resolved_url: resolveSpecifier(context.specifier, context.script.url),
         location: location(context.script.script_key, context.node),
     }));
 };
 const addFinding = (context) => {
-    const value = sanitizeCandidate(context.rawValue);
+    const value = sanitizeEndpointCandidate(context.rawValue);
     const key = `finding\0${context.mechanism}\0${context.script.script_key}\0${value}`;
-    addBounded(context.accumulator, key, context.maximumFindings, () => context.collection.push({
+    addUnique(context.accumulator, key, () => context.collection.push({
         value,
         mechanism: context.mechanism,
         location: location(context.script.script_key, context.node),
     }));
 };
-const addWebMcpDeclaration = (script, node, accumulator, maximumFindings) => {
+const addWebMcpDeclaration = (script, node, accumulator) => {
     const declaration = node.arguments[0];
     if (!t.isObjectExpression(declaration))
         return;
@@ -169,23 +156,21 @@ const addWebMcpDeclaration = (script, node, accumulator, maximumFindings) => {
             : [])
         : [];
     const key = `webmcp\0${script.script_key}\0${name ?? ""}\0${schemaPropertyNames.join("\0")}`;
-    addBounded(accumulator, key, maximumFindings, () => accumulator.webMcp.push({
-        name: name?.slice(0, 256) ?? null,
-        description: description?.slice(0, 2_048) ?? null,
-        schema_property_names: [...new Set(schemaPropertyNames)]
-            .sort()
-            .slice(0, 256),
+    addUnique(accumulator, key, () => accumulator.webMcp.push({
+        name: name ?? null,
+        description: description ?? null,
+        schema_property_names: [...new Set(schemaPropertyNames)].sort(),
         trust: "page-declared-untrusted",
         location: location(script.script_key, node),
     }));
 };
-const detectVendorFingerprints = (script, accumulator, maximumFindings) => {
+const detectVendorFingerprints = (script, accumulator) => {
     const text = script.source.artifact.text;
     for (const detector of vendorDetectors) {
         if (!detector.patterns.some((pattern) => text.includes(pattern)))
             continue;
         const key = `vendor\0${script.script_key}\0${detector.value}`;
-        addBounded(accumulator, key, maximumFindings, () => accumulator.inferences.push({
+        addUnique(accumulator, key, () => accumulator.inferences.push({
             kind: detector.kind,
             value: detector.value,
             confidence: detector.confidence,
@@ -199,7 +184,7 @@ const addRouteFrameworkInference = (context) => {
         ? "React Router-compatible route API"
         : "Generic route registration API";
     const key = `route-framework\0${context.script.script_key}\0${value}`;
-    addBounded(context.accumulator, key, context.maximumFindings, () => context.accumulator.inferences.push({
+    addUnique(context.accumulator, key, () => context.accumulator.inferences.push({
         kind: "route_framework",
         value,
         confidence: "medium",
@@ -211,18 +196,9 @@ const addRouteFrameworkInference = (context) => {
         ],
     }));
 };
-const addBounded = (accumulator, key, maximum, add) => {
+const addUnique = (accumulator, key, add) => {
     if (accumulator.seen.has(key))
         return;
-    const findings = accumulator.edges.length +
-        accumulator.routes.length +
-        accumulator.endpoints.length +
-        accumulator.webMcp.length +
-        accumulator.inferences.length;
-    if (findings >= maximum) {
-        accumulator.droppedFindings += 1;
-        return;
-    }
     accumulator.seen.add(key);
     add();
 };
@@ -243,8 +219,6 @@ export const emptyAccumulator = () => ({
     visitedNodes: 0,
     parsedScripts: 0,
     parseFailures: 0,
-    droppedFindings: 0,
-    astLimitReached: false,
 });
 export const isIncludedScript = (script) => script.source.included;
 const routeCallNames = [

package/dist/domain/webBundleAnalyzerResult.js

@@ -7,11 +7,7 @@ export const buildWebBundleAnalysis = (inspection, sourceScripts, sourceMaps, ac
     const partial = accumulator.parseFailures > 0 ||
         unavailable.length > 0 ||
         sourceMapIncomplete;
-    const truncated = accumulator.astLimitReached ||
-        accumulator.droppedFindings > 0 ||
-        sourceMaps.status === "truncated";
     return webBundleAnalysisSchema.parse({
-        schema_version: 1,
         capture: buildCaptureObservation(inspection, sourceScripts),
         observations: {
             chunks: {
@@ -31,12 +27,10 @@ export const buildWebBundleAnalysis = (inspection, sourceScripts, sourceMaps, ac
             sourceMaps,
         }),
         completeness: buildCompleteness({
-            truncated,
             partial,
             parsedScripts: accumulator.parsedScripts,
             parseFailures: accumulator.parseFailures,
             visitedNodes: accumulator.visitedNodes,
-            droppedFindings: accumulator.droppedFindings,
         }),
         limitations: bundleLimitations(),
     });
@@ -69,7 +63,7 @@ const buildUnknowns = (input) => [
         : [
             {
                 dimension: "script_source",
-                reason: "Source artifact was not captured within approved limits",
+                reason: "Source artifact was not captured",
                 affected_script_keys: input.unavailable,
             },
         ]),
@@ -88,30 +82,19 @@ const buildUnknowns = (input) => [
         : [
             {
                 dimension: "source_maps",
-                reason: input.sourceMaps.status === "truncated"
-                    ? "Source-map evidence was truncated by approved limits"
-                    : "One or more requested source maps were unavailable or incomplete",
-                affected_script_keys: [
-                    ...new Set([
-                        ...input.sourceMaps.items
-                            .filter(({ status }) => status !== "included")
-                            .map(({ script_key }) => script_key),
-                        ...input.sourceMaps.dropped_script_keys,
-                    ]),
-                ].sort(),
+                reason: "One or more requested source maps were unavailable or incomplete",
+                affected_script_keys: input.sourceMaps.items
+                    .filter(({ status }) => status !== "included")
+                    .map(({ script_key }) => script_key)
+                    .sort(),
             },
         ]),
 ];
 const buildCompleteness = (input) => ({
-    status: input.truncated
-        ? "truncated"
-        : input.partial
-            ? "partial"
-            : "complete_within_limits",
+    status: input.partial ? "partial" : "complete",
     parsed_scripts: input.parsedScripts,
     parse_failures: input.parseFailures,
     visited_ast_nodes: input.visitedNodes,
-    dropped_findings: input.droppedFindings,
 });
 const bundleLimitations = () => [
     "Static bundle findings are observations or bounded inferences; REA does not execute captured JavaScript.",

package/dist/domain/webCaptureDiff.js

@@ -1,64 +1,14 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-import { z } from "zod";
-import { webPageInspectionSchema, } from "./browserObservation.js";
-import { webMcpDiscoverySchema, } from "./webMcpDiscovery.js";
-/** One normalized passive page snapshot accepted by capture comparison. */
-export const captureSnapshotSchema = z.object({
-    inspection: webPageInspectionSchema,
-    webmcp: webMcpDiscoverySchema.nullable().default(null),
-});
-/** Input for deterministic comparison of two normalized web captures. */
-export const compareWebCapturesInputSchema = z.object({
-    before: captureSnapshotSchema,
-    after: captureSnapshotSchema,
-    max_changes: z.number().int().min(1).max(20_000).default(2_000),
-});
-const changeSchema = z.object({
-    identity: z.string(),
-    change: z.enum(["added", "removed", "modified"]),
-});
-const dimensionSchema = z.object({
-    status: z.enum(["changed", "unchanged", "unknown"]),
-    total_changes: z.number().int().min(0),
-    changes: z.array(changeSchema),
-    omitted_changes: z.number().int().min(0),
-    reason: z.string().nullable(),
-});
-const legacyUnknownDimension = {
-    status: "unknown",
-    total_changes: 0,
-    changes: [],
-    omitted_changes: 0,
-    reason: "Dimension was not recorded by this version 1 capture diff.",
-};
-/** Completeness-aware changes across stable browser evidence dimensions. */
-export const webCaptureDiffSchema = z.object({
-    schema_version: z.literal(1),
-    overall_status: z.enum(["changed", "unchanged", "unknown"]),
-    before_target: z.object({ target_id: z.string(), url: z.string() }),
-    after_target: z.object({ target_id: z.string(), url: z.string() }),
-    dimensions: z.object({
-        dom_structure: dimensionSchema,
-        scripts: dimensionSchema,
-        resources: dimensionSchema,
-        network: dimensionSchema,
-        metadata: dimensionSchema,
-        webmcp: dimensionSchema,
-        accessibility: dimensionSchema.default(legacyUnknownDimension),
-        storage: dimensionSchema.default(legacyUnknownDimension),
-    }),
-    limitations: z.array(z.string()),
-});
+import { webCaptureDiffSchema, } from "./webCaptureDiffSchemas.js";
+export { captureSnapshotSchema, compareWebCapturesInputSchema, webCaptureDiffSchema, } from "./webCaptureDiffSchemas.js";
 /** Compare normalized observations without treating incomplete absence as proof. */
 export const compareWebCaptures = (input) => {
-    const remaining = { value: input.max_changes };
     const before = input.before.inspection;
     const after = input.after.inspection;
-    const dimensions = compareWebCaptureDimensions(input, remaining);
+    const dimensions = compareWebCaptureDimensions(input);
     const statuses = Object.values(dimensions).map(({ status }) => status);
     return webCaptureDiffSchema.parse({
-        schema_version: 1,
         overall_status: statuses.includes("changed")
             ? "changed"
             : statuses.includes("unknown")
@@ -96,38 +46,49 @@ const compareIdentities = (before, after) => {
     return changes.sort((left, right) => left.identity.localeCompare(right.identity) ||
         left.change.localeCompare(right.change));
 };
-const compareDimension = (remaining) => (before, after, complete, reason) => {
+const compareDimension = (before, after, complete, reason) => {
     const all = compareIdentities(before, after);
-    const retained = all.slice(0, remaining.value);
-    remaining.value -= retained.length;
-    return {
-        status: all.length > 0 ? "changed" : complete ? "unchanged" : "unknown",
-        total_changes: all.length,
-        changes: retained,
-        omitted_changes: all.length - retained.length,
-        reason: all.length === 0 && !complete ? reason : null,
-    };
+    if (all.length > 0)
+        return {
+            status: "changed",
+            total_changes: all.length,
+            changes: all,
+            reason: null,
+        };
+    return complete
+        ? {
+            status: "unchanged",
+            total_changes: 0,
+            changes: [],
+            reason: null,
+        }
+        : {
+            status: "unknown",
+            total_changes: 0,
+            changes: [],
+            reason,
+        };
 };
-const accessibilityDimension = (before, after, remaining) => {
+const accessibilityDimension = (before, after) => {
     const beforeAccess = accessibilityComparable(before);
     const afterAccess = accessibilityComparable(after);
     const textComparable = beforeAccess.text && afterAccess.text;
     const nodesComparable = beforeAccess.nodes && afterAccess.nodes;
-    return compareDimension(remaining)(singleton("accessibility_tree", digest(accessibilityProjection(before.accessibility, textComparable, nodesComparable))), singleton("accessibility_tree", digest(accessibilityProjection(after.accessibility, textComparable, nodesComparable))), beforeAccess.complete && afterAccess.complete, "Accessibility tree or text capture was incomplete in at least one observation.");
+    return compareDimension(singleton("accessibility_tree", digest(accessibilityProjection(before.accessibility, textComparable, nodesComparable))), singleton("accessibility_tree", digest(accessibilityProjection(after.accessibility, textComparable, nodesComparable))), beforeAccess.complete && afterAccess.complete, "Accessibility tree or text capture was incomplete in at least one observation.");
 };
-const storageDimension = (before, after, remaining) => {
+const storageDimension = (before, after) => {
     const keysComplete = storageKeysComparable(before) && storageKeysComparable(after);
     const usageComplete = before.storage.usage_bytes !== null &&
         after.storage.usage_bytes !== null &&
         before.storage.quota_bytes !== null &&
         after.storage.quota_bytes !== null;
     const comparableFingerprints = storageFingerprintIdentities(before.storage, after.storage);
-    return compareDimension(remaining)(storageMap(before.storage, keysComplete, usageComplete, comparableFingerprints), storageMap(after.storage, keysComplete, usageComplete, comparableFingerprints), storageComparable(before, after, keysComplete, usageComplete), "Storage fingerprints, inventories, usage, or quota were unavailable or truncated in at least one observation.");
+    return compareDimension(storageMap(before.storage, keysComplete, usageComplete, comparableFingerprints), storageMap(after.storage, keysComplete, usageComplete, comparableFingerprints), storageComparable(before, after, keysComplete, usageComplete), "Storage fingerprints, inventories, usage, or quota were unavailable or truncated in at least one observation.");
 };
-const compareWebCaptureDimensions = (input, remaining) => {
+const compareWebCaptureDimensions = (input) => {
     const before = input.before.inspection;
     const after = input.after.inspection;
-    const dimension = compareDimension(remaining);
+    const dimension = compareDimension;
     return {
         dom_structure: dimension(singleton("document", digest(domProjection(before))), singleton("document", digest(domProjection(after))), sectionsComplete(before, ["frames", "dom"]) &&
             sectionsComplete(after, ["frames", "dom"]), "DOM or frame capture was incomplete in at least one observation."),
@@ -140,8 +101,8 @@ const compareWebCaptureDimensions = (input, remaining) => {
         metadata: dimension(singleton("metadata", digest(metadataProjection(before))), singleton("metadata", digest(metadataProjection(after))), sectionsComplete(before, ["metadata"]) &&
             sectionsComplete(after, ["metadata"]), "Safe metadata capture was incomplete in at least one observation."),
         webmcp: dimension(webMcpMap(input.before.webmcp), webMcpMap(input.after.webmcp), webMcpComplete(input.before.webmcp) && webMcpComplete(input.after.webmcp), "WebMCP discovery was unavailable or incomplete in at least one capture."),
-        accessibility: accessibilityDimension(before, after, remaining),
-        storage: storageDimension(before, after, remaining),
+        accessibility: accessibilityDimension(before, after),
+        storage: storageDimension(before, after),
     };
 };
 const keyed = (values, identity) => new Map(values.map((value) => [identity(value), digest(value)]));
@@ -220,8 +181,7 @@ const digest = (value) => {
 };
 const accessibilityComparable = (inspection) => {
     const text = inspection.accessibility.text_capture.status === "included" &&
-        inspection.accessibility.text_capture.excluded_fields === 0 &&
-        inspection.accessibility.text_capture.truncated_fields === 0;
+        inspection.accessibility.text_capture.excluded_fields === 0;
     const nodes = inspection.accessibility.total_nodes ===
         inspection.accessibility.nodes.length;
     const complete = text && nodes && sectionsComplete(inspection, ["accessibility"]);

package/dist/domain/webCaptureDiffSchemas.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import { webPageInspectionSchema } from "./browserObservation.js";
+import { webMcpDiscoverySchema } from "./webMcpDiscovery.js";
+/** One normalized passive page snapshot accepted by capture comparison. */
+export const captureSnapshotSchema = z.object({
+    inspection: webPageInspectionSchema,
+    webmcp: webMcpDiscoverySchema.nullable().default(null),
+});
+/** Input for deterministic comparison of two normalized web captures. */
+export const compareWebCapturesInputSchema = z.strictObject({
+    before: captureSnapshotSchema,
+    after: captureSnapshotSchema,
+});
+const changeSchema = z.object({
+    identity: z.string(),
+    change: z.enum(["added", "removed", "modified"]),
+});
+const emptyDimensionShape = {
+    total_changes: z.literal(0),
+    changes: z.tuple([]),
+};
+const dimensionSchema = z.union([
+    z
+        .object({
+        status: z.literal("changed"),
+        total_changes: z.number().int().min(1),
+        changes: z.array(changeSchema),
+        reason: z.null(),
+    })
+        .superRefine((dimension, context) => {
+        if (dimension.changes.length !== dimension.total_changes)
+            context.addIssue({
+                code: "custom",
+                message: "Inline changes must equal total changes",
+                path: ["total_changes"],
+            });
+    }),
+    z.object({
+        ...emptyDimensionShape,
+        status: z.literal("unchanged"),
+        reason: z.null(),
+    }),
+    z.object({
+        ...emptyDimensionShape,
+        status: z.literal("unknown"),
+        reason: z.string(),
+    }),
+]);
+const legacyUnknownDimension = {
+    status: "unknown",
+    total_changes: 0,
+    changes: [],
+    reason: "Dimension was not recorded by this version 1 capture diff.",
+};
+/** Completeness-aware changes across stable browser evidence dimensions. */
+export const webCaptureDiffSchema = z
+    .object({
+    overall_status: z.enum(["changed", "unchanged", "unknown"]),
+    before_target: z.object({ target_id: z.string(), url: z.string() }),
+    after_target: z.object({ target_id: z.string(), url: z.string() }),
+    dimensions: z.object({
+        dom_structure: dimensionSchema,
+        scripts: dimensionSchema,
+        resources: dimensionSchema,
+        network: dimensionSchema,
+        metadata: dimensionSchema,
+        webmcp: dimensionSchema,
+        accessibility: dimensionSchema.default(legacyUnknownDimension),
+        storage: dimensionSchema.default(legacyUnknownDimension),
+    }),
+    limitations: z.array(z.string()),
+})
+    .superRefine((comparison, context) => {
+    const statuses = Object.values(comparison.dimensions).map(({ status }) => status);
+    const expected = statuses.includes("changed")
+        ? "changed"
+        : statuses.includes("unknown")
+            ? "unknown"
+            : "unchanged";
+    if (comparison.overall_status !== expected)
+        context.addIssue({
+            code: "custom",
+            message: "Overall status must summarize dimension statuses",
+            path: ["overall_status"],
+        });
+});

package/dist/domain/webContentArtifact.js

@@ -3,10 +3,9 @@ import { z } from "zod";
 /** Self-verifying text artifact used by web-source analysis boundaries. */
 export const webTextArtifactSchema = z
     .object({
-    uri: z.string().regex(/^rea:\/\/web-content\/sha256\/[a-f0-9]{64}$/u),
     sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     bytes: z.number().int().min(0),
-    media_type: z.string().min(1).max(256),
+    media_type: z.string().min(1),
     charset: z.literal("utf-8"),
     text: z.string(),
 })
@@ -25,18 +24,11 @@ export const webTextArtifactSchema = z
             path: ["sha256"],
             message: "Digest mismatch",
         });
-    if (artifact.uri !== webContentUri(digest))
-        context.addIssue({
-            code: "custom",
-            path: ["uri"],
-            message: "Content URI mismatch",
-        });
 });
 /** Build an immutable content-addressed UTF-8 text artifact. */
 export const createWebTextArtifact = (text, mediaType) => {
     const sha256 = createHash("sha256").update(text).digest("hex");
     return {
-        uri: webContentUri(sha256),
         sha256,
         bytes: Buffer.byteLength(text),
         media_type: mediaType,
@@ -44,4 +36,3 @@ export const createWebTextArtifact = (text, mediaType) => {
         text,
     };
 };
-const webContentUri = (sha256) => `rea://web-content/sha256/${sha256}`;

package/dist/domain/webMcpDiscovery.js

@@ -3,21 +3,11 @@ import { browserCompletenessSchema } from "./browserCompleteness.js";
 import { browserAllowedOriginsSchema, browserEndpointSchema, } from "./browserObservation.js";
 import { jsonShapeSchema } from "./jsonShape.js";
 /** Input for passive discovery of page-registered WebMCP tools. */
-export const discoverWebMcpToolsInputSchema = z.object({
+export const discoverWebMcpToolsInputSchema = z.strictObject({
     cdp_endpoint: browserEndpointSchema,
     allowed_origins: browserAllowedOriginsSchema,
-    target_id: z.string().trim().min(1).max(256),
-    approved: z.literal(true),
-    observation_ms: z.number().int().min(0).max(10_000).default(100),
-    max_tools: z.number().int().min(1).max(5_000).default(500),
-    max_schema_bytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(1_024 * 1_024)
-        .default(256 * 1_024),
-    max_schema_nodes: z.number().int().min(1).max(100_000).default(5_000),
-    max_schema_depth: z.number().int().min(1).max(100).default(20),
+    target_id: z.string().trim().min(1),
+    observation_ms: z.number().int().min(0).default(100),
 });
 const browserVersionSchema = z.object({
     product: z.string(),
@@ -51,7 +41,6 @@ const webMcpToolSchema = z.object({
 });
 /** Passive WebMCP inventory; it intentionally has no invocation surface. */
 export const webMcpDiscoverySchema = z.object({
-    schema_version: z.literal(1),
     browser: browserVersionSchema,
     target: z.object({
         target_id: z.string(),