rea-agents 5.0.0 → 6.1.0

package/dist/browser/CdpCaptureEventHandlers.js

@@ -1,8 +1,9 @@
 import { inferJsonShape } from "../domain/jsonShape.js";
 import { safeResponseMetadata } from "./CdpSafeMetadata.js";
 import { allowedSanitizedUrl, isHttpUrl, numberValue, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
-import { requestBodyShape } from "./CdpCaptureEventBodyShapes.js";
-import { consolePrimitive, decodeBase64, exclusionReasonForUrl, executionContextKey, firstCallFrame, initiatorLocation, integerOrNull, isMainFrameNavigation, } from "./CdpCaptureEventHelpers.js";
+import { requestBodyShape, updateResponseBodyShape, } from "./CdpCaptureEventBodyShapes.js";
+import { consolePrimitive, decodeBase64, exclusionReasonForUrl, executionContextKey, firstCallFrame, initiatorLocation, integerOrNull, isJsonMediaType, isMainFrameNavigation, } from "./CdpCaptureEventHelpers.js";
+import { CDP_CAPTURE_SCRIPT_METADATA_LIMITS, } from "./CdpCaptureEventTypes.js";
 export const handleExecutionContextCreated = (state, params) => {
     const context = recordValue(params.context);
     const identifier = numberValue(context?.id);
@@ -27,12 +28,18 @@ export const handleScriptParsed = (state, params) => {
         state.completeness.exclude("scripts", "invalid_protocol_value");
         return;
     }
+    const replacedBytes = state.scriptMetadataBytesById.get(scriptId) ?? 0;
+    state.scriptMetadataBudgetOmissionsById.delete(scriptId);
+    if (replacedBytes > 0) {
+        state.scripts.delete(scriptId);
+        state.scriptMetadataBytesById.delete(scriptId);
+        state.retainedScriptMetadataBytes -= replacedBytes;
+    }
     if (sanitized === undefined) {
         state.completeness.exclude("scripts", exclusionReasonForUrl(rawUrl));
         return;
     }
-    const sourceMap = sourceMapForScript(params.sourceMapURL, rawUrl, state);
-    const script = {
+    const baseScript = {
         scriptId,
         rawUrl,
         url: sanitized.url,
@@ -41,16 +48,49 @@ export const handleScriptParsed = (state, params) => {
         length: Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, Math.trunc(numberValue(params.length) ?? 0))),
         isModule: params.isModule === true,
         language: cdpStringValue(params.scriptLanguage) ?? null,
-        sourceMapUrl: sourceMap.sanitized,
-        sourceMapRawUrl: sourceMap.raw,
         executionContextKey: executionContextKey(params.executionContextId),
     };
+    const baseBytes = scriptMetadataStringBytes(baseScript);
+    const sourceMapDeclared = typeof params.sourceMapURL === "string" && params.sourceMapURL.length > 0;
+    if (state.scripts.size >= CDP_CAPTURE_SCRIPT_METADATA_LIMITS.scripts ||
+        baseBytes >
+            CDP_CAPTURE_SCRIPT_METADATA_LIMITS.retainedBytes -
+                state.retainedScriptMetadataBytes) {
+        state.rejectedScriptMetadataBudgetCount += 1;
+        if (sourceMapDeclared)
+            state.rejectedSourceMapMetadataBudgetCount += 1;
+        return;
+    }
+    const sourceMap = sourceMapForScript(params.sourceMapURL, rawUrl, state, CDP_CAPTURE_SCRIPT_METADATA_LIMITS.retainedBytes -
+        state.retainedScriptMetadataBytes -
+        baseBytes);
+    const { budgetExhausted, ...sourceMapFields } = sourceMap;
+    const script = { ...baseScript, ...sourceMapFields };
+    if (budgetExhausted)
+        state.scriptMetadataBudgetOmissionsById.set(scriptId, true);
+    const retainedBytes = baseBytes +
+        stringByteLength(sourceMap.sourceMapUrl) +
+        stringByteLength(sourceMap.sourceMapRawUrl);
+    state.retainedScriptMetadataBytes += retainedBytes;
+    state.scriptMetadataBytesById.set(scriptId, retainedBytes);
     state.scripts.set(scriptId, script);
 };
-const sourceMapForScript = (value, scriptUrl, state) => {
+const scriptMetadataStringBytes = (script) => stringByteLength(script.scriptId) +
+    stringByteLength(script.rawUrl) +
+    stringByteLength(script.url) +
+    stringByteLength(script.origin) +
+    stringByteLength(script.hash) +
+    stringByteLength(script.language) +
+    stringByteLength(script.executionContextKey);
+const stringByteLength = (value) => value === null ? 0 : Buffer.byteLength(value, "utf8");
+const sourceMapForScript = (value, scriptUrl, state, remainingBytes) => {
     const declaredUrl = cdpStringValue(value);
     if (declaredUrl === undefined || declaredUrl === "")
-        return { sanitized: null, raw: null };
+        return {
+            sourceMapUrl: null,
+            sourceMapRawUrl: null,
+            budgetExhausted: false,
+        };
     let rawUrl;
     try {
         rawUrl = new URL(declaredUrl, scriptUrl).href;
@@ -59,13 +99,34 @@ const sourceMapForScript = (value, scriptUrl, state) => {
         // Unparseable URLs are recorded as unsupported, not as failures.
         void cause;
         state.completeness.exclude("source_maps", "unsupported_url");
-        return { sanitized: null, raw: null };
+        return {
+            sourceMapUrl: null,
+            sourceMapRawUrl: null,
+            budgetExhausted: false,
+        };
     }
     const sanitized = allowedSanitizedUrl(rawUrl, state.allowedOrigins);
-    if (sanitized !== undefined)
-        return { sanitized: sanitized.url, raw: rawUrl };
+    if (sanitized !== undefined) {
+        if (stringByteLength(rawUrl) + stringByteLength(sanitized.url) >
+            remainingBytes) {
+            return {
+                sourceMapUrl: null,
+                sourceMapRawUrl: null,
+                budgetExhausted: true,
+            };
+        }
+        return {
+            sourceMapUrl: sanitized.url,
+            sourceMapRawUrl: rawUrl,
+            budgetExhausted: false,
+        };
+    }
     state.completeness.exclude("source_maps", exclusionReasonForUrl(rawUrl));
-    return { sanitized: null, raw: null };
+    return {
+        sourceMapUrl: null,
+        sourceMapRawUrl: null,
+        budgetExhausted: false,
+    };
 };
 export const handleRequestWillBeSent = (state, params) => {
     const requestId = cdpStringValue(params.requestId);
@@ -74,16 +135,73 @@ export const handleRequestWillBeSent = (state, params) => {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         return;
     }
+    if (state.malformedRedirectRequestIds.has(requestId))
+        return;
+    const previous = state.network.get(requestId);
+    if (!Object.hasOwn(params, "redirectResponse") &&
+        previous !== undefined &&
+        preserveMalformedRedirectEvidence(state, requestId, previous))
+        return;
     if (request === undefined) {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         state.network.delete(requestId);
+        state.networkRequestTimestamps.delete(requestId);
         return;
     }
     const sanitized = allowedSanitizedUrl(request.url, state.allowedOrigins);
     if (sanitized === undefined) {
         state.completeness.exclude("network_requests", exclusionReasonForUrl(cdpStringValue(request.url)));
         state.network.delete(requestId);
+        state.networkRequestTimestamps.delete(requestId);
+        return;
+    }
+    const redirectResponse = recordValue(params.redirectResponse);
+    if (Object.hasOwn(params, "redirectResponse") &&
+        redirectResponse === undefined &&
+        preserveMalformedRedirectEvidence(state, requestId, previous))
         return;
+    const redirects = [...(previous?.redirects ?? [])];
+    if (redirectResponse !== undefined) {
+        const rawResponseUrl = cdpStringValue(redirectResponse.url);
+        const responseUrl = rawResponseUrl === undefined || rawResponseUrl === ""
+            ? undefined
+            : allowedSanitizedUrl(rawResponseUrl, state.allowedOrigins);
+        const responseUrlReason = redirectResponseUrlReason(rawResponseUrl);
+        if (previous === undefined) {
+            if (responseUrl === undefined)
+                state.completeness.exclude("network_requests", responseUrlReason);
+            else
+                // CDP may deliver the continuation after its predecessor was excluded
+                // by origin policy or before capture began. Keep the final request but
+                // report missing prior coverage without calling it malformed protocol.
+                state.completeness.attachLimited("network_requests");
+        }
+        else if (responseUrl === undefined) {
+            // redirectResponse belongs to the same request ID and can contain an
+            // excluded origin. Drop the entire chain before retaining any details.
+            state.completeness.exclude("network_requests", responseUrlReason);
+            state.network.delete(requestId);
+            state.networkRequestTimestamps.delete(requestId);
+            return;
+        }
+        else {
+            redirects.push({
+                url: previous.url,
+                response_url: responseUrl.url,
+                method: previous.method,
+                resource_type: previous.resource_type,
+                status: numberValue(redirectResponse.status) ?? null,
+                mime_type: cdpStringValue(redirectResponse.mimeType) ?? null,
+                encoded_data_length: (() => {
+                    const length = numberValue(redirectResponse.encodedDataLength);
+                    return length === undefined ? null : Math.max(0, length);
+                })(),
+                request_timestamp: state.networkRequestTimestamps.get(requestId) ?? null,
+                // CDP reports redirectResponse on the next requestWillBeSent event.
+                // This is the event boundary, not a separately observed response time.
+                redirect_event_timestamp: numberValue(params.timestamp) ?? null,
+            });
+        }
     }
     const initiator = recordValue(params.initiator);
     const initiatorFrame = initiatorLocation(initiator);
@@ -100,6 +218,7 @@ export const handleRequestWillBeSent = (state, params) => {
         status: null,
         mime_type: null,
         encoded_data_length: null,
+        redirects,
         initiator: {
             type: cdpStringValue(initiator?.type) ?? "other",
             url: initiatorUrl?.url ?? null,
@@ -108,6 +227,35 @@ export const handleRequestWillBeSent = (state, params) => {
         },
         body_shapes: requestBodyShape(state, request),
     });
+    const timestamp = numberValue(params.timestamp);
+    if (timestamp === undefined)
+        state.networkRequestTimestamps.delete(requestId);
+    else
+        state.networkRequestTimestamps.set(requestId, timestamp);
+};
+const preserveMalformedRedirectEvidence = (state, requestId, previous) => {
+    state.completeness.exclude("network_requests", "invalid_protocol_value");
+    if (previous === undefined)
+        return false;
+    state.malformedRedirectRequestIds.add(requestId);
+    if (state.input.include_json_body_shapes &&
+        isJsonMediaType(previous.mime_type) &&
+        previous.body_shapes.response === null) {
+        updateResponseBodyShape(state, requestId, null);
+        state.completeness.exclude("json_body_shapes", "invalid_protocol_value");
+    }
+    return true;
+};
+const redirectResponseUrlReason = (value) => {
+    if (value === undefined || value === "")
+        return "invalid_protocol_value";
+    try {
+        new URL(value);
+    }
+    catch {
+        return "invalid_protocol_value";
+    }
+    return exclusionReasonForUrl(value);
 };
 export const handleResponseReceived = (state, params) => {
     const requestId = cdpStringValue(params.requestId);
@@ -115,6 +263,8 @@ export const handleResponseReceived = (state, params) => {
         state.completeness.exclude("network_requests", "invalid_protocol_value");
         return;
     }
+    if (state.malformedRedirectRequestIds.has(requestId))
+        return;
     const current = state.network.get(requestId);
     const response = recordValue(params.response);
     if (current === undefined)
@@ -125,6 +275,7 @@ export const handleResponseReceived = (state, params) => {
             ? "invalid_protocol_value"
             : exclusionReasonForUrl(cdpStringValue(response.url)));
         state.network.delete(requestId);
+        state.networkRequestTimestamps.delete(requestId);
         return;
     }
     state.network.set(requestId, {
@@ -140,6 +291,8 @@ export const handleLoadingFinished = (state, params) => {
     const requestId = cdpStringValue(params.requestId);
     if (requestId === undefined)
         return;
+    if (state.malformedRedirectRequestIds.has(requestId))
+        return;
     const current = state.network.get(requestId);
     if (current === undefined)
         return;

package/dist/browser/CdpCaptureEventTypes.js

@@ -1 +1,5 @@
-export {};
+/** Bounds retained CDP script identities independently from source text capture. */
+export const CDP_CAPTURE_SCRIPT_METADATA_LIMITS = {
+    retainedBytes: 8 * 1024 * 1024,
+    scripts: 50_000,
+};

package/dist/browser/CdpCaptureEvents.js

@@ -6,9 +6,17 @@ import { recordValue } from "./CdpCaptureValues.js";
 export {} from "./CdpCaptureEventTypes.js";
 /** Event accumulator that validates and normalizes payloads at ingestion. */
 export class CdpCaptureEvents {
+    #scriptMetadataBudgetExclusionsRecorded = false;
     scripts = new Map();
+    scriptMetadataBudgetOmissionsById = new Map();
+    rejectedScriptMetadataBudgetCount = 0;
+    rejectedSourceMapMetadataBudgetCount = 0;
+    scriptMetadataBytesById = new Map();
+    retainedScriptMetadataBytes = 0;
     executionContextFrames = new Map();
     network = new Map();
+    networkRequestTimestamps = new Map();
+    malformedRedirectRequestIds = new Set();
     allowedWebSockets = new Set();
     console = [];
     websockets = [];
@@ -37,8 +45,16 @@ export class CdpCaptureEvents {
         this.navigationDuringCapture = false;
         this.committedDocument = undefined;
         this.scripts.clear();
+        this.scriptMetadataBudgetOmissionsById.clear();
+        this.rejectedScriptMetadataBudgetCount = 0;
+        this.rejectedSourceMapMetadataBudgetCount = 0;
+        this.scriptMetadataBytesById.clear();
+        this.retainedScriptMetadataBytes = 0;
+        this.#scriptMetadataBudgetExclusionsRecorded = false;
         this.executionContextFrames.clear();
         this.network.clear();
+        this.networkRequestTimestamps.clear();
+        this.malformedRedirectRequestIds.clear();
         this.allowedWebSockets.clear();
         this.console.length = 0;
         this.websockets.length = 0;
@@ -63,6 +79,19 @@ export class CdpCaptureEvents {
         // compared against itself rather than the document we just left.
         this.committedDocument = undefined;
     }
+    /** Record final script metadata omissions after all scriptParsed replacements. */
+    recordScriptMetadataBudgetExclusions() {
+        if (this.#scriptMetadataBudgetExclusionsRecorded)
+            return;
+        this.#scriptMetadataBudgetExclusionsRecorded = true;
+        const omittedScripts = this.rejectedScriptMetadataBudgetCount;
+        const omittedSourceMaps = this.rejectedSourceMapMetadataBudgetCount +
+            this.scriptMetadataBudgetOmissionsById.size;
+        if (omittedScripts > 0)
+            this.completeness.exclude("scripts", "resource_budget_exhausted", omittedScripts);
+        if (omittedSourceMaps > 0)
+            this.completeness.exclude("source_maps", "resource_budget_exhausted", omittedSourceMaps);
+    }
     ingest(event) {
         const params = recordValue(event.params);
         if (params === undefined)
@@ -119,14 +148,19 @@ export class CdpCaptureEvents {
         if (!this.input.include_json_body_shapes)
             return [];
         return [...this.network.values()]
+            .filter((request) => !this.malformedRedirectRequestIds.has(request.request_id))
             .filter((request) => isJsonMediaType(request.mime_type))
             .map((request) => request.request_id);
     }
     responseBodyUnavailable(requestId) {
+        if (this.malformedRedirectRequestIds.has(requestId))
+            return;
         bodyShapes.updateResponseBodyShape(this, requestId, null);
         this.completeness.unavailable("json_body_shapes");
     }
     ingestResponseBody(requestId, value) {
+        if (this.malformedRedirectRequestIds.has(requestId))
+            return;
         bodyShapes.ingestResponseBodyShape(this, requestId, value);
     }
 }

package/dist/browser/CdpConnection.js

@@ -48,7 +48,7 @@ export class CdpConnection {
     /** Subscribe to an unexpected transport loss while an operation is active. */
     onDisconnect(listener) {
         if (this.#closed) {
-            listener();
+            listener(this.#transportError(this.#transportFailure));
             return () => undefined;
         }
         this.#disconnectListeners.add(listener);
@@ -85,6 +85,7 @@ export class CdpConnection {
             signal?.addEventListener("abort", onAbort, { once: true });
             this.#pending.set(id, {
                 method,
+                ...(sessionId === undefined ? {} : { sessionId }),
                 resolve,
                 reject,
                 removeAbort: () => signal?.removeEventListener("abort", onAbort),
@@ -171,17 +172,34 @@ export class CdpConnection {
         const pending = this.#pending.get(id);
         if (pending === undefined)
             return;
-        this.#complete(id, pending);
-        if ("error" in message) {
-            const reported = message.error;
-            pending.reject(new CdpCommandRejection(this.operation, pending.method, isRecord(reported) && typeof reported.code === "number"
-                ? reported.code
-                : null, isRecord(reported) && typeof reported.message === "string"
-                ? reported.message
-                : null));
+        const hasResult = "result" in message;
+        const hasError = "error" in message;
+        if (("sessionId" in message &&
+            (typeof message.sessionId !== "string" ||
+                message.sessionId !== pending.sessionId)) ||
+            hasResult === hasError) {
+            this.#failPending("protocol_error");
             return;
         }
-        pending.resolve("result" in message ? message.result : {});
+        if (hasResult) {
+            if (!isRecord(message.result)) {
+                this.#failPending("protocol_error");
+                return;
+            }
+            this.#complete(id, pending);
+            pending.resolve(message.result);
+            return;
+        }
+        const reported = message.error;
+        if (!isRecord(reported) ||
+            typeof reported.code !== "number" ||
+            !Number.isSafeInteger(reported.code) ||
+            typeof reported.message !== "string") {
+            this.#failPending("protocol_error");
+            return;
+        }
+        this.#complete(id, pending);
+        pending.reject(new CdpCommandRejection(this.operation, pending.method, reported.code, reported.message));
     }
     #complete(id, pending) {
         pending.removeAbort();
@@ -211,8 +229,9 @@ export class CdpConnection {
         this.#failPending(reason);
         if (wasClosed)
             return;
+        const error = this.#transportError(reason);
         for (const listener of this.#disconnectListeners)
-            listener();
+            listener(error);
         this.#disconnectListeners.clear();
     }
     #transportError(reason) {

package/dist/browser/CdpOptionalCommand.js

@@ -1,4 +1,4 @@
-import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { CdpCommandRejection } from "./CdpCommandRejection.js";
 import { CdpConnection } from "./CdpConnection.js";
 /** Execute an optional CDP method while preserving transport and cancellation failures. */
 export const optionalCdpCommand = async (context, method, parameters, limitations) => {
@@ -6,8 +6,7 @@ export const optionalCdpCommand = async (context, method, parameters, limitation
         return await context.connection.send(method, parameters, context.sessionId, context.signal);
     }
     catch (cause) {
-        if (!(cause instanceof BrowserObservationError) ||
-            cause.reason !== "protocol_error")
+        if (!(cause instanceof CdpCommandRejection) || cause.code !== -32_601)
             throw cause;
         limitations.push(`${method} was unavailable from this browser target.`);
         return undefined;

package/dist/browser/CdpPageCapture.js

@@ -6,6 +6,7 @@ import { CdpCaptureEvents } from "./CdpCaptureEvents.js";
 import { authorizedMainFrame } from "./CdpAuthorizedMainFrame.js";
 import { captureStorage } from "./CdpCaptureStorage.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
+import { CdpCommandRejection } from "./CdpCommandRejection.js";
 import { captureAccessibility, captureDom, captureFrames, captureResources, mainFrameUrl, } from "./CdpCaptureDocuments.js";
 import { allowedSanitizedUrl, delayWithCancellation, } from "./CdpCaptureValues.js";
 import { captureScripts } from "./CdpPageCaptureScripts.js";
@@ -85,6 +86,7 @@ const captureAuthorizedPage = async (state) => {
     if (state.events.navigationDuringCapture || completedUrl !== attachedUrl)
         throw new BrowserObservationError("inspect_web_page", "target_changed");
     await report(context.progress, 3, "Normalizing browser evidence");
+    state.events.recordScriptMetadataBudgetExclusions();
     return {
         inspection: normalizedInspection(state, {
             attachedUrl,
@@ -105,7 +107,27 @@ const captureJsonResponseBodies = async (state) => {
         const requestId = requestIds[index];
         if (requestId === undefined)
             continue;
-        const result = await optionalCdpCommand(state.context, "Network.getResponseBody", { requestId }, state.limitations);
+        const request = state.events.network.get(requestId);
+        if (request === undefined)
+            continue;
+        if (request.encoded_data_length === null) {
+            state.events.responseBodyUnavailable(requestId);
+            continue;
+        }
+        let result;
+        try {
+            result = await optionalCdpCommand(state.context, "Network.getResponseBody", { requestId }, state.limitations);
+        }
+        catch (cause) {
+            if (!(cause instanceof CdpCommandRejection) ||
+                cause.command !== "Network.getResponseBody" ||
+                cause.code !== -32_000 ||
+                cause.reportedMessage === null)
+                throw cause;
+            state.events.responseBodyUnavailable(requestId);
+            state.limitations.push(`Response body unavailable for request ${requestId}: ${cause.userMessage}`);
+            continue;
+        }
         if (result !== undefined) {
             state.events.ingestResponseBody(requestId, result);
             continue;

package/dist/browser/PlaywrightElectronActiveActions.js

@@ -58,6 +58,21 @@ const hookEventSchema = z.strictObject({
 });
 const hookSnapshotSchema = z.strictObject({
     events: z.array(hookEventSchema),
+    retention_budget_bytes: z.number().int().min(0),
+    estimated_retained_bytes: z.number().int().min(0),
+    event_serialized_byte_upper_bound: z.number().int().min(0),
+    retained: z.number().int().min(0),
+    dropped: z.number().int().min(0),
+    dropped_ipc: z.number().int().min(0),
+    dropped_runtime: z.number().int().min(0),
+    dropped_event_families: z.array(z.strictObject({
+        family: z.string().min(1),
+        count: z.number().int().min(1),
+    })),
+    dropped_event_roles: z.array(z.strictObject({
+        role: z.string().min(1),
+        count: z.number().int().min(1),
+    })),
     observed: z.number().int().min(0),
     observed_ipc: z.number().int().min(0),
     observed_runtime: z.number().int().min(0),
@@ -72,6 +87,8 @@ const metricSchema = z.strictObject({
 const windowMetadataSchema = z.strictObject({
     window_id: z.string(),
     web_contents_id: z.string(),
+    url: z.string(),
+    title: z.string(),
     visible: z.boolean().nullable(),
     destroyed: z.boolean(),
 });
@@ -79,12 +96,12 @@ const windowMetadataSchema = z.strictObject({
 export const runElectronActions = async (application, input, options) => {
     const actions = [];
     for (const action of input.actions) {
-        if (options.signal?.aborted === true)
-            throw new BrowserObservationError(OPERATION, "cancelled");
         const actionStartedAt = Date.now();
         const windowIndex = actionWindowIndex(action);
         let selectedWindow;
         try {
+            if (options.signal?.aborted === true)
+                throw new BrowserObservationError(OPERATION, "cancelled");
             selectedWindow =
                 windowIndex === null
                     ? undefined
@@ -200,16 +217,12 @@ const emitDeepLink = (application, action) => application.evaluate(({ app }, pay
 /** Read the current Electron windows, metrics, and hook snapshot. */
 // oxlint-disable-next-line max-lines-per-function -- one state read must share one capture boundary.
 export const readApplicationState = async (application) => {
-    const pages = application.windows();
-    const pageSnapshotsPromise = Promise.all(pages.map(async (page, index) => ({
-        index,
-        url: page.url(),
-        title: await page.title(),
-    })));
     const windowMetadataPromise = application
         .evaluate(({ BrowserWindow }) => BrowserWindow.getAllWindows().map((window) => ({
         window_id: `window:${String(window.id)}`,
         web_contents_id: `webContents:${String(window.webContents.id)}`,
+        url: window.webContents.getURL(),
+        title: window.webContents.getTitle(),
         visible: window.isDestroyed() ? null : window.isVisible(),
         destroyed: window.isDestroyed(),
     })))
@@ -234,6 +247,15 @@ export const readApplicationState = async (application) => {
             ? candidate()
             : {
                 events: [],
+                retention_budget_bytes: 0,
+                estimated_retained_bytes: 0,
+                event_serialized_byte_upper_bound: 0,
+                retained: 0,
+                dropped: 0,
+                dropped_ipc: 0,
+                dropped_runtime: 0,
+                dropped_event_families: [],
+                dropped_event_roles: [],
                 observed: 0,
                 observed_ipc: 0,
                 observed_runtime: 0,
@@ -241,27 +263,14 @@ export const readApplicationState = async (application) => {
             };
     })
         .then((value) => hookSnapshotSchema.parse(value));
-    const [pageSnapshots, windowMetadata, processMetrics, electronVersion, hookSnapshot,] = await Promise.all([
-        pageSnapshotsPromise,
+    const [windowMetadata, processMetrics, electronVersion, hookSnapshot] = await Promise.all([
         windowMetadataPromise,
         processMetricsPromise,
         electronVersionPromise,
         hookSnapshotPromise,
     ]);
     return {
-        windows: pageSnapshots.map((page) => {
-            const metadata = windowMetadata[page.index];
-            if (metadata === undefined)
-                throw new BrowserObservationError(OPERATION, "window_metadata_missing");
-            return {
-                window_id: metadata.window_id,
-                web_contents_id: metadata.web_contents_id,
-                url: page.url,
-                title: page.title,
-                visible: metadata.visible,
-                destroyed: metadata.destroyed,
-            };
-        }),
+        windows: windowMetadata,
         metrics: processMetrics,
         electronVersion,
         hookSnapshot,