rea-agents 6.4.0 → 6.7.0

package/dist/domain/browserObservation.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { urlDeclaresQueryOrFragment } from "./urlComponents.js";
+import { parseRecordedTransportUrl, parseUrlQueryParameterNames, } from "./recordedTransportUrl.js";
 const parseExactOrigin = (value) => {
     let url;
     try {
@@ -14,8 +16,7 @@ const parseExactOrigin = (value) => {
         url.username !== "" ||
         url.password !== "" ||
         url.pathname !== "/" ||
-        url.search !== "" ||
-        url.hash !== "")
+        urlDeclaresQueryOrFragment(url))
         return undefined;
     return url.origin;
 };
@@ -36,43 +37,97 @@ export const browserOriginSchema = z
 });
 /** Recognize the URL API's bracketed IPv6 form and normalized bare literals. */
 export const isLiteralLoopbackHostname = (hostname) => hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+const HTTP_ENDPOINT_MESSAGE = "CDP endpoint must be an explicit-port HTTP URL on 127.0.0.1 or ::1";
+const BROWSER_SOCKET_PATH = "/devtools/browser/";
+const REDACTED_BROWSER_SOCKET_PATH = `${BROWSER_SOCKET_PATH}[REDACTED]`;
+/** Normalized origin of an accepted loopback CDP HTTP discovery endpoint. */
+const httpDiscoveryOrigin = (url) => url.protocol === "http:" &&
+    isLiteralLoopbackHostname(url.hostname) &&
+    url.port !== "" &&
+    url.username === "" &&
+    url.password === "" &&
+    url.pathname === "/" &&
+    !urlDeclaresQueryOrFragment(url)
+    ? url.origin
+    : undefined;
+/** Scheme and authority of an accepted loopback CDP browser WebSocket. */
+const browserSocketAuthority = (url) => {
+    const id = url.pathname.slice(BROWSER_SOCKET_PATH.length);
+    return url.protocol === "ws:" &&
+        isLiteralLoopbackHostname(url.hostname) &&
+        url.port !== "" &&
+        url.username === "" &&
+        url.password === "" &&
+        !urlDeclaresQueryOrFragment(url) &&
+        url.pathname.startsWith(BROWSER_SOCKET_PATH) &&
+        id.length > 0 &&
+        !id.includes("/")
+        ? `${url.protocol}//${url.host}`
+        : undefined;
+};
 /** Loopback-only HTTP endpoint accepted for a user-owned CDP browser. */
 export const browserEndpointSchema = z
     .string()
     .min(1)
     .transform((value, context) => {
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch (cause) {
-        // Invalid input is reported through the zod issue.
-        void cause;
+    const url = URL.parse(value);
+    const origin = url === null ? undefined : httpDiscoveryOrigin(url);
+    if (origin !== undefined)
+        return origin;
+    context.addIssue({
+        code: "custom",
+        message: url === null ? "Invalid CDP endpoint URL" : HTTP_ENDPOINT_MESSAGE,
+    });
+    return z.NEVER;
+});
+/** Loopback CDP HTTP discovery origin or browser WebSocket URL. */
+export const browserObservationEndpointSchema = z
+    .string()
+    .min(1)
+    .describe("Literal loopback CDP endpoint: http://127.0.0.1:PORT, or ws://127.0.0.1:PORT/devtools/browser/ID.")
+    .transform((value, context) => {
+    const url = URL.parse(value);
+    if (url === null) {
         context.addIssue({ code: "custom", message: "Invalid CDP endpoint URL" });
         return z.NEVER;
     }
-    if (url.protocol !== "http:" ||
-        !isLiteralLoopbackHostname(url.hostname) ||
-        url.port === "" ||
-        url.username !== "" ||
-        url.password !== "" ||
-        url.pathname !== "/" ||
-        url.search !== "" ||
-        url.hash !== "") {
-        context.addIssue({
-            code: "custom",
-            message: "CDP endpoint must be an explicit-port HTTP URL on 127.0.0.1 or ::1",
-        });
-        return z.NEVER;
-    }
-    return url.origin;
+    const origin = httpDiscoveryOrigin(url);
+    if (origin !== undefined)
+        return { transport: "http_discovery", url: origin, recorded: origin };
+    const authority = browserSocketAuthority(url);
+    if (authority !== undefined)
+        return {
+            transport: "browser_websocket",
+            url: url.href,
+            recorded: `${authority}${REDACTED_BROWSER_SOCKET_PATH}`,
+        };
+    context.addIssue({
+        code: "custom",
+        message: url.protocol === "ws:"
+            ? "CDP browser WebSocket must be ws://127.0.0.1:PORT/devtools/browser/ID or ws://[::1]:PORT/devtools/browser/ID"
+            : HTTP_ENDPOINT_MESSAGE,
+    });
+    return z.NEVER;
+});
+/** Evidence form of a passive browser endpoint, with any socket identifier redacted. */
+export const recordedBrowserObservationEndpointSchema = z
+    .string()
+    .min(1)
+    .refine((value) => {
+    const url = URL.parse(value);
+    return (url !== null &&
+        (httpDiscoveryOrigin(url) !== undefined ||
+            (browserSocketAuthority(url) !== undefined &&
+                url.pathname === REDACTED_BROWSER_SOCKET_PATH)));
+}, {
+    message: "Recorded CDP endpoint must be a loopback HTTP origin or a redacted browser WebSocket URL",
 });
 export const browserAllowedOriginsSchema = z
     .array(browserOriginSchema)
     .transform((origins) => Array.from(new Set(origins)).sort())
     .default([]);
 const browserInput = {
-    cdp_endpoint: browserEndpointSchema,
+    cdp_endpoint: browserObservationEndpointSchema,
     allowed_origins: browserAllowedOriginsSchema,
 };
 /** Public input for complete discovery, optionally filtered by exact origin. */
@@ -92,7 +147,7 @@ const inspectWebPageInputFacts = {
 };
 const inspectWebPageWithoutSourceSchema = z.strictObject({
     ...inspectWebPageInputFacts,
-    include_script_sources: z.literal(false).default(false),
+    include_script_sources: z.literal(false).optional().default(false),
 });
 const inspectWebPageWithSourceShapeSchema = z.strictObject({
     ...inspectWebPageInputFacts,
@@ -109,9 +164,13 @@ const refineInspectWebPageInput = (input, context) => {
 /** Caller schema for source-capturing inspection and bundle analysis. */
 export const inspectWebPageWithSourceInputSchema = inspectWebPageWithSourceShapeSchema.superRefine(refineInspectWebPageInput);
 /** Caller-visible schema for one passive inspection. */
-export const inspectWebPageInputSchema = z.union([
+export const inspectWebPageInputSchema = z.discriminatedUnion("include_script_sources", [
     inspectWebPageWithoutSourceSchema.superRefine(refineInspectWebPageInput),
-    inspectWebPageWithSourceInputSchema,
+    inspectWebPageWithSourceShapeSchema
+        .extend({
+        include_script_sources: z.literal(true),
+    })
+        .superRefine(refineInspectWebPageInput),
 ]);
 export const sanitizedBrowserUrlSchema = z.object({
     url: z.string(),
@@ -136,7 +195,7 @@ export const sanitizeBrowserUrl = (value) => {
         };
     }
     const hadCredentials = parsed.username !== "" || parsed.password !== "";
-    const names = [...parsed.searchParams.keys()];
+    const names = [...parseUrlQueryParameterNames(parsed.search)];
     const sanitizedUrl = hadCredentials
         ? removeUrlUserInfo(value, parsed)
         : value;
@@ -148,33 +207,10 @@ export const sanitizeBrowserUrl = (value) => {
     };
 };
 const removeUrlUserInfo = (value, parsed) => {
-    const schemeSeparator = value.indexOf("://");
-    const authorityStart = schemeSeparator < 0
-        ? value.startsWith("//")
-            ? 2
-            : -1
-        : schemeSeparator + 3;
-    if (authorityStart < 0)
-        return credentialFreeHref(parsed);
-    const remaining = value.slice(authorityStart);
-    const delimiter = remaining.search(/[/?#]/u);
-    const authorityEnd = delimiter < 0 ? value.length : authorityStart + delimiter;
-    const authority = value.slice(authorityStart, authorityEnd);
-    const userInfoEnd = authority.lastIndexOf("@");
-    if (userInfoEnd < 0)
-        return credentialFreeHref(parsed);
-    const candidate = `${value.slice(0, authorityStart)}${authority.slice(userInfoEnd + 1)}${value.slice(authorityEnd)}`;
-    try {
-        const candidateUrl = new URL(candidate);
-        return candidateUrl.username === "" && candidateUrl.password === ""
-            ? candidate
-            : credentialFreeHref(parsed);
-    }
-    catch (cause) {
-        // Fallback to the already-sanitized href when the candidate is invalid.
-        void cause;
-        return credentialFreeHref(parsed);
-    }
+    const { credentials } = parseRecordedTransportUrl(value);
+    return credentials === null || credentials === "ambiguous"
+        ? credentialFreeHref(parsed)
+        : `${value.slice(0, credentials.start)}${value.slice(credentials.end)}`;
 };
 const credentialFreeHref = (parsed) => {
     parsed.username = "";

package/dist/domain/browserObservationError.js

@@ -6,7 +6,6 @@ export class BrowserObservationError extends AnalysisError {
     reason;
     _tag = "BrowserObservationError";
     cleanupIncomplete;
-    cleanupResources;
     userCategory;
     userMessage;
     constructor(operation, reason, options) {
@@ -17,9 +16,8 @@ export class BrowserObservationError extends AnalysisError {
             options?.detail ?? observationFailureMessage(operation, reason);
         this.cleanupIncomplete =
             this.cleanup !== undefined || reason === "cleanup_failed";
-        this.cleanupResources =
-            this.cleanup?.resources ??
-                (reason === "cleanup_failed" ? ["browser_transport"] : []);
+        this.setCleanupResources(this.cleanup?.resources ??
+            (reason === "cleanup_failed" ? ["browser_transport"] : []));
         this.userCategory =
             reason === "cancelled" ||
                 options?.cause instanceof AnalysisCancelledError ||
@@ -38,6 +36,8 @@ const observationFailureMessage = (operation, reason) => {
         return `${operation} could not reach the selected loopback debugging endpoint. Verify that the target process is running with debugging enabled and that the endpoint's port matches it, then retry.`;
     if (reason === "target_not_found")
         return `${operation} could not find the selected target at the debugging endpoint. Refresh target discovery for that endpoint and retry with a returned target ID.`;
+    if (reason === "service_worker_blocked")
+        return `${operation} refused the selected page because it is controlled by or has a registered service worker while the service-worker policy is block. Set environment.service_workers to allow to permit observation, or remove the service worker registration through the browser.`;
     if (reason === "disconnected")
         return `${operation} lost its debugging connection. Verify that the target process is still running, refresh target discovery, and retry the observation.`;
     return undefined;

package/dist/domain/browserObservationSchemas.js

@@ -17,7 +17,10 @@ const browserTargetSchema = z.object({
     title: z.string(),
     url: z.string(),
     origin: z.string(),
-    attached: z.boolean(),
+    attached: z
+        .boolean()
+        .nullable()
+        .describe("Discovery-reported debugger attachment state; null means unknown"),
 });
 /** Complete policy-filtered browser target discovery result. */
 export const browserTargetListSchema = z.object({

package/dist/domain/browserScenarioCapture.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { browserNetworkContentSelectionValuesSchema } from "./browserNetworkEvidence.js";
-import { browserScenarioCompletenessSchema, browserScenarioEventSchema, browserScenarioStepSchema, } from "./browserScenarioCaptureValues.js";
+import { browserScenarioCaptureLimitsValuesSchema } from "./browserScenarioCaptureLimits.js";
+import { browserScenarioCompletenessSchema, browserScenarioEventFamilySchema, browserScenarioEventOmissionsSchema, browserScenarioEventSchema, browserScenarioStepSchema, } from "./browserScenarioCaptureValues.js";
 /** Step-indexed browser scenario observation. */
 export const browserScenarioCaptureSchema = z
     .strictObject({
@@ -16,6 +17,8 @@ export const browserScenarioCaptureSchema = z
         action_count: z.number().int().min(1),
         secret_references: z.array(z.string().min(1)),
         network_content: browserNetworkContentSelectionValuesSchema,
+        event_families: z.array(browserScenarioEventFamilySchema),
+        limits: browserScenarioCaptureLimitsValuesSchema,
     }),
     duration_ms: z.number().int().min(0),
     steps: z.array(browserScenarioStepSchema).min(1),
@@ -23,6 +26,7 @@ export const browserScenarioCaptureSchema = z
         retained: z.number().int().min(0),
         dropped: z.number().int().min(0),
         items: z.array(browserScenarioEventSchema),
+        omissions: browserScenarioEventOmissionsSchema,
     }),
     completeness: browserScenarioCompletenessSchema,
     limitations: z.array(z.string().min(1)),
@@ -54,6 +58,12 @@ export const browserScenarioCaptureSchema = z
             path: ["events", "retained"],
             message: "Retained event count must equal items length",
         });
+    if (capture.events.omissions.by_kind.reduce((count, omission) => count + omission.count, 0) !== capture.events.dropped)
+        context.addIssue({
+            code: "custom",
+            path: ["events", "omissions", "by_kind"],
+            message: "Per-kind omission counts must equal the dropped event count",
+        });
     if (capture.steps.length !== capture.scenario.action_count + 1)
         context.addIssue({
             code: "custom",

package/dist/domain/browserScenarioCaptureLimits.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+const positiveSafeInteger = z.number().int().safe().positive();
+export const DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS = {
+    max_events: 10_000,
+    max_event_allocation_bytes: 4 * 1024 * 1024,
+    max_total_event_allocation_bytes: 16 * 1024 * 1024,
+    max_network_transactions: 1024,
+    max_network_body_bytes: 64 * 1024,
+    max_network_body_allocation_bytes: 1024 * 1024,
+    max_network_header_allocation_bytes: 1024 * 1024,
+    max_network_metadata_allocation_bytes: 1024 * 1024,
+};
+/** Caller-selected retained-output budgets; byte values are allocation-cost estimates. */
+export const browserScenarioCaptureLimitsValuesSchema = z.strictObject({
+    max_events: positiveSafeInteger,
+    max_event_allocation_bytes: positiveSafeInteger,
+    max_total_event_allocation_bytes: positiveSafeInteger,
+    max_network_transactions: positiveSafeInteger,
+    max_network_body_bytes: positiveSafeInteger,
+    max_network_body_allocation_bytes: positiveSafeInteger,
+    max_network_header_allocation_bytes: positiveSafeInteger,
+    max_network_metadata_allocation_bytes: positiveSafeInteger,
+});
+/** Input budgets default omitted values; output evidence uses the values schema above. */
+export const browserScenarioCaptureLimitsSchema = browserScenarioCaptureLimitsValuesSchema.extend({
+    max_events: browserScenarioCaptureLimitsValuesSchema.shape.max_events.default(DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS.max_events),
+    max_event_allocation_bytes: browserScenarioCaptureLimitsValuesSchema.shape.max_event_allocation_bytes.default(DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS.max_event_allocation_bytes),
+    max_total_event_allocation_bytes: browserScenarioCaptureLimitsValuesSchema.shape.max_total_event_allocation_bytes.default(DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS.max_total_event_allocation_bytes),
+    max_network_transactions: browserScenarioCaptureLimitsValuesSchema.shape.max_network_transactions.default(DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS.max_network_transactions),
+    max_network_body_bytes: browserScenarioCaptureLimitsValuesSchema.shape.max_network_body_bytes.default(DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS.max_network_body_bytes),
+    max_network_body_allocation_bytes: browserScenarioCaptureLimitsValuesSchema.shape.max_network_body_allocation_bytes.default(DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS.max_network_body_allocation_bytes),
+    max_network_header_allocation_bytes: browserScenarioCaptureLimitsValuesSchema.shape.max_network_header_allocation_bytes.default(DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS.max_network_header_allocation_bytes),
+    max_network_metadata_allocation_bytes: browserScenarioCaptureLimitsValuesSchema.shape.max_network_metadata_allocation_bytes.default(DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS.max_network_metadata_allocation_bytes),
+});

package/dist/domain/browserScenarioCaptureValues.js

@@ -96,6 +96,17 @@ export const browserStepArtifactsSchema = z.strictObject({
     history: captureStateSchema(historySchema),
     storage: captureStateSchema(storageSnapshotSchema),
 });
+/** Event families a scenario can select for capture. */
+export const browserScenarioEventFamilySchema = z.enum([
+    "console",
+    "page-errors",
+    "network",
+    "websockets",
+    "frames",
+    "workers",
+    "popups",
+    "downloads",
+]);
 const eventBase = {
     sequence: z.number().int().min(1),
     step_index: z.number().int().min(0),
@@ -105,6 +116,8 @@ const networkEventShape = {
     ...eventBase,
     transaction_id: z.string().min(1),
     redirected_from_transaction_id: z.string().min(1).nullable(),
+    /** Distinguishes a captured root from an unobserved predecessor for null links. */
+    redirected_from_transaction_state: z.enum(["root", "unknown"]).optional(),
     method: z.string().min(1),
     url: sanitizedBrowserUrlSchema,
     resource_type: z.string().min(1),
@@ -117,7 +130,8 @@ const webSocketFrameShape = {
     payload_bytes: z.number().int().min(0),
     truncated: z.boolean(),
 };
-export const browserScenarioEventSchema = z.union([
+export const browserScenarioEventSchema = z
+    .union([
     z.strictObject({
         ...eventBase,
         kind: z.literal("console"),
@@ -206,7 +220,17 @@ export const browserScenarioEventSchema = z.union([
         suggested_filename: z.string(),
         url: sanitizedBrowserUrlSchema,
     }),
-]);
+])
+    .superRefine((event, context) => {
+    if ("redirected_from_transaction_id" in event &&
+        event.redirected_from_transaction_id !== null &&
+        event.redirected_from_transaction_state !== undefined)
+        context.addIssue({
+            code: "custom",
+            message: "Redirect state is valid only when the predecessor transaction ID is null",
+            path: ["redirected_from_transaction_state"],
+        });
+});
 const completenessSectionSchema = z.enum([
     "action",
     "screenshot",
@@ -221,6 +245,56 @@ const completenessSectionSchema = z.enum([
     "popups",
     "websockets",
 ]);
+export const browserScenarioEventKindSchema = z.enum([
+    "console",
+    "page-error",
+    "request",
+    "response",
+    "request-failed",
+    "request-finished",
+    "request-unfinished",
+    "network-content",
+    "websocket-opened",
+    "websocket-closed",
+    "websocket-frame-sent",
+    "websocket-frame-received",
+    "frame-attached",
+    "frame-detached",
+    "frame-navigated",
+    "worker-created",
+    "worker-closed",
+    "popup-opened",
+    "popup-closed",
+    "download-cancelled",
+]);
+export const browserScenarioEventBudgetReasonSchema = z.enum([
+    "max-events",
+    "max-event-allocation-bytes",
+    "max-total-event-allocation-bytes",
+    "max-network-transactions",
+    "max-network-metadata-allocation-bytes",
+    "max-listener-owners",
+]);
+export const browserScenarioEventOmissionsSchema = z.strictObject({
+    by_kind: z.array(z.strictObject({
+        kind: browserScenarioEventKindSchema,
+        count: z.number().int().positive(),
+        reasons: z.array(browserScenarioEventBudgetReasonSchema).min(1),
+    })),
+    network_transactions: z.array(z.strictObject({
+        transaction_id: z.string().min(1),
+        omitted_kinds: z.array(browserScenarioEventKindSchema).min(1),
+        reasons: z.array(browserScenarioEventBudgetReasonSchema).min(1),
+    })),
+    network_transaction_range: z
+        .strictObject({
+        first_transaction_id: z.string().min(1),
+        last_transaction_id: z.string().min(1),
+        count: z.number().int().positive(),
+        reason: z.literal("max-network-transactions"),
+    })
+        .nullable(),
+});
 export const browserScenarioCompletenessSchema = z.discriminatedUnion("status", [
     z.strictObject({
         status: z.literal("complete"),

package/dist/domain/browserScenarioDiff.js

@@ -1,15 +1,25 @@
-import { actionState, artifactEvidenceState, captured, eventEvidenceState, eventsFor, networkContentCoverageReason, screenshotProjection, } from "./browserScenarioDiffEvidence.js";
+import { z } from "zod";
+import { digestCanonicalValue } from "./canonicalDigest.js";
+import { actionState, artifactEvidenceState, captured, eventEvidenceState, eventFamilyCoverageReason, prepareScenarioEvents, networkContentCoverageReason, screenshotProjection, } from "./browserScenarioDiffEvidence.js";
 import { browserScenarioDiffSchema, } from "./browserScenarioDiffValues.js";
-import { commitBrowserScenarioNormalization, digestNormalizedScenarioValue, } from "./browserScenarioNormalization.js";
+import { commitBrowserScenarioNormalization, digestNormalizedScenarioValue, normalizeScenarioValue, } from "./browserScenarioNormalization.js";
+const scenarioEventsValueSchema = z.strictObject({
+    events: z.array(z.unknown()),
+    network_transactions: z.array(z.string()),
+});
 /** Compare scenario steps by stable step ID and apply only committed literal rules. */
 export const compareBrowserScenarios = (input) => {
     const normalization = commitBrowserScenarioNormalization(input.normalization);
+    const beforeEvents = prepareScenarioEvents(input.before_scenario, normalization.rules);
+    const afterEvents = prepareScenarioEvents(input.after_scenario, normalization.rules);
     const alignment = alignScenarioSteps(input.before_scenario, input.after_scenario);
     const compared = compareAlignedSteps({
         beforeCapture: input.before_scenario,
         afterCapture: input.after_scenario,
         alignment,
         rules: normalization.rules,
+        beforeEvents,
+        afterEvents,
     });
     const failures = [...alignment.failures, ...compared.failures];
     const alignmentStatus = failures.length === 0
@@ -44,7 +54,7 @@ export const compareBrowserScenarios = (input) => {
         limitations: [
             "Steps align only by exact, unique step_id; missing, duplicate, or action-mismatched steps are reported and prevent an unchanged claim.",
             "Only declared literal normalization rules are applied, in canonical rule_id order, to already-redacted durable capture fields.",
-            "Elapsed time and event sequence/index values are excluded as volatile; screenshot bytes are compared by content digest.",
+            "Elapsed time, event sequence/index values and capture-local transaction IDs are excluded as volatile; network transactions are compared as an unordered collection in the step that sent their request; screenshot bytes are compared by content digest.",
             "A changed status proves an observed normalized difference. Missing or truncated evidence, incompatible capture context, or alignment failure prevents an unchanged claim.",
         ],
     });
@@ -106,6 +116,8 @@ const compareAlignedSteps = (input) => {
             afterCapture: input.afterCapture,
             afterStep,
             rules: input.rules,
+            beforeEvents: input.beforeEvents,
+            afterEvents: input.afterEvents,
         });
         const reportable = artifacts.flatMap(({ diff }) => diff === null ? [] : [diff]);
         totalArtifactDiffs += reportable.length;
@@ -204,28 +216,121 @@ const compareStepArtifacts = (input) => {
             before: input.beforeStep.artifacts.storage,
             after: input.afterStep.artifacts.storage,
         }),
-        compareCapturedValues({
+        compareScenarioEvents({
             ...common,
             artifact: "events",
-            before: captured(eventsFor(input.beforeCapture, input.beforeStep.step_index)),
-            after: captured(eventsFor(input.afterCapture, input.afterStep.step_index)),
+            before: captured(input.beforeEvents.forStep(input.beforeStep.step_index)),
+            after: captured(input.afterEvents.forStep(input.afterStep.step_index)),
             beforeState: eventEvidenceState(input.beforeCapture, input.beforeStep),
             afterState: eventEvidenceState(input.afterCapture, input.afterStep),
-            incomparableReason: networkContentCoverageReason(input.beforeCapture, input.afterCapture),
+            incomparableReason: eventCoverageReason(input.beforeCapture, input.afterCapture, input.beforeEvents.coverageReason, input.afterEvents.coverageReason),
+            familyIncomparableReason: eventFamilyCoverageReason(input.beforeCapture, input.afterCapture),
         }),
     ];
 };
+const compareScenarioEvents = (input) => {
+    const beforeState = input.beforeState ??
+        artifactEvidenceState(input.artifact, input.before, input.beforeStep);
+    const afterState = input.afterState ??
+        artifactEvidenceState(input.artifact, input.after, input.afterStep);
+    if (beforeState === "not_requested" && afterState === "not_requested")
+        return { artifact: input.artifact, status: "not_compared", diff: null };
+    const beforeValue = input.before.state === "captured" ? input.before.value : undefined;
+    const afterValue = input.after.state === "captured" ? input.after.value : undefined;
+    const isCaptured = beforeState === "captured" &&
+        afterState === "captured" &&
+        beforeValue !== undefined &&
+        afterValue !== undefined;
+    const ordinaryBeforeDigest = beforeValue === undefined
+        ? null
+        : digestCanonicalValue(normalizeScenarioValue(beforeValue.events, "events", input.rules), "Browser scenario");
+    const ordinaryAfterDigest = afterValue === undefined
+        ? null
+        : digestCanonicalValue(normalizeScenarioValue(afterValue.events, "events", input.rules), "Browser scenario");
+    const beforeSha256 = beforeState === "captured" && beforeValue !== undefined
+        ? digestScenarioEvents(beforeValue, ordinaryBeforeDigest)
+        : null;
+    const afterSha256 = afterState === "captured" && afterValue !== undefined
+        ? digestScenarioEvents(afterValue, ordinaryAfterDigest)
+        : null;
+    const changedOrdinaryEvents = isCaptured && ordinaryBeforeDigest !== ordinaryAfterDigest;
+    if (changedOrdinaryEvents && input.familyIncomparableReason === undefined)
+        return {
+            artifact: input.artifact,
+            status: "changed",
+            diff: {
+                artifact: input.artifact,
+                status: "changed",
+                before_state: beforeState,
+                after_state: afterState,
+                before_sha256: beforeSha256,
+                after_sha256: afterSha256,
+                reason: input.incomparableReason ?? null,
+            },
+        };
+    if (!isCaptured ||
+        input.incomparableReason !== undefined ||
+        input.familyIncomparableReason !== undefined)
+        return {
+            artifact: input.artifact,
+            status: "unknown",
+            diff: {
+                artifact: input.artifact,
+                status: "unknown",
+                before_state: beforeState,
+                after_state: afterState,
+                before_sha256: beforeSha256,
+                after_sha256: afterSha256,
+                reason: joinIncomparableReasons(input.familyIncomparableReason, input.incomparableReason) ??
+                    `Artifact coverage is not comparable (${beforeState} before, ${afterState} after).`,
+            },
+        };
+    if (beforeSha256 === null || afterSha256 === null)
+        throw new TypeError("Captured event digest refinement failed");
+    if (beforeSha256 === afterSha256)
+        return { artifact: input.artifact, status: "unchanged", diff: null };
+    return {
+        artifact: input.artifact,
+        status: "changed",
+        diff: {
+            artifact: input.artifact,
+            status: "changed",
+            before_state: beforeState,
+            after_state: afterState,
+            before_sha256: beforeSha256,
+            after_sha256: afterSha256,
+            reason: null,
+        },
+    };
+};
+const digestScenarioEvents = (value, ordinaryEventsDigest) => {
+    const parsed = scenarioEventsValueSchema.parse(value);
+    return digestCanonicalValue({
+        ordinary_events_sha256: ordinaryEventsDigest,
+        // These are already normalized SHA-256 transaction fingerprints.
+        network_transactions: parsed.network_transactions,
+    }, "Browser scenario");
+};
+const eventCoverageReason = (before, after, beforeNetworkReason, afterNetworkReason) => {
+    const reasons = [
+        eventFamilyCoverageReason(before, after),
+        networkContentCoverageReason(before, after),
+        beforeNetworkReason,
+        afterNetworkReason,
+    ].filter((reason) => reason !== undefined);
+    return reasons.length === 0 ? undefined : reasons.join(" ");
+};
 const compareCapturedValues = (input) => {
-    const { artifact, before, after, beforeStep, afterStep, rules, project = (value) => value, } = input;
+    const { artifact, before, after, beforeStep, afterStep, rules, project = (value) => value, order, } = input;
     const beforeState = input.beforeState ?? artifactEvidenceState(artifact, before, beforeStep);
     const afterState = input.afterState ?? artifactEvidenceState(artifact, after, afterStep);
     if (beforeState === "not_requested" && afterState === "not_requested")
         return { artifact, status: "not_compared", diff: null };
     const beforeSha256 = beforeState === "captured" && before.state === "captured"
-        ? digestNormalizedScenarioValue(project(before.value), artifact, rules)
+        ? digestNormalizedScenarioValue(project(before.value), artifact, rules, order)
         : null;
     const afterSha256 = afterState === "captured" && after.state === "captured"
-        ? digestNormalizedScenarioValue(project(after.value), artifact, rules)
+        ? digestNormalizedScenarioValue(project(after.value), artifact, rules, order)
         : null;
     if (beforeState !== "captured" ||
         afterState !== "captured" ||
@@ -242,7 +347,7 @@ const compareCapturedValues = (input) => {
                 after_state: afterState,
                 before_sha256: beforeSha256,
                 after_sha256: afterSha256,
-                reason: input.incomparableReason ??
+                reason: joinIncomparableReasons(input.familyIncomparableReason, input.incomparableReason) ??
                     `Artifact coverage is not comparable (${beforeState} before, ${afterState} after).`,
             },
         };
@@ -264,3 +369,7 @@ const compareCapturedValues = (input) => {
         },
     };
 };
+const joinIncomparableReasons = (...reasons) => {
+    const present = reasons.filter((reason) => reason !== undefined);
+    return present.length === 0 ? undefined : [...new Set(present)].join(" ");
+};