rea-agents 1.7.0 → 2.1.0

package/dist/browser/CdpElectronInspection.js

@@ -1,78 +1,126 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { BrowserObservationError } from "../domain/errors.js";
-import { createWebTextArtifact } from "../domain/webContentArtifact.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { boundedText, delayWithCancellation, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
+import { delayWithCancellation, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
+import { ingestElectronScriptEvent, } from "./CdpElectronScriptEvents.js";
+import { captureElectronScripts } from "./CdpElectronScripts.js";
+import { captureElectronWorkers } from "./CdpElectronWorkers.js";
 import { authorizedElectronFile, canonicalElectronRoots, } from "./ElectronFileScope.js";
 /** Passively inspect one root-confined Electron file page. */
 export const inspectCdpElectronPage = async (context) => {
-    const roots = await canonicalElectronRoots(context.input.allowed_file_roots);
-    const completeness = new CdpCaptureCompleteness();
-    const scripts = [];
-    let mainFrameId;
-    let navigationDuringCapture = false;
+    const state = {
+        roots: await canonicalElectronRoots(context.input.allowed_file_roots),
+        completeness: new CdpCaptureCompleteness(),
+        scripts: [],
+        executionContextFrames: new Map(),
+        limitations: [
+            "Only canonical file paths contained by an approved root are retained.",
+            "REA does not evaluate renderer JavaScript, invoke Electron APIs, navigate, click, or close the page.",
+            "Script contents require separate source-capture approval and remain byte bounded.",
+        ],
+        mainFrameId: undefined,
+        navigationDuringCapture: false,
+    };
     const removeListener = context.connection.onEvent((event) => {
         if (event.sessionId !== context.sessionId)
             return;
-        ingestScript(event, scripts, completeness);
-        if (mainFrameId !== undefined && navigatedFrameId(event) === mainFrameId)
-            navigationDuringCapture = true;
+        ingestElectronScriptEvent({
+            event,
+            scripts: state.scripts,
+            executionContextFrames: state.executionContextFrames,
+            completeness: state.completeness,
+        });
+        if (state.mainFrameId !== undefined &&
+            navigatedFrameId(event) === state.mainFrameId)
+            state.navigationDuringCapture = true;
     });
-    const startedAt = new Date().toISOString();
     try {
-        await report(context.progress, 1, "Authorizing Electron file frames");
-        await context.connection.send("Page.enable", {}, context.sessionId, context.signal);
-        const before = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
-        const frames = await captureFrames(before, roots, context.input.limits.max_frames, completeness);
-        const main = frames[0];
-        if (main === undefined)
-            throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
-        mainFrameId = main.frame_id;
-        await context.connection.send("Debugger.enable", { maxScriptsCacheSize: 4 * 1_024 * 1_024 }, context.sessionId, context.signal);
-        await delayWithCancellation(context.input.observation_ms, "inspect_electron_page", context.signal);
-        await report(context.progress, 2, "Capturing Electron structure");
-        const resources = await captureResources(context, roots, completeness);
-        const dom = await captureDom(context, roots, completeness);
-        const normalizedScripts = await captureScripts(context, roots, scripts, completeness);
-        const after = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
-        const afterMain = await mainFilePath(after, roots);
-        if (afterMain === undefined)
-            throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
-        if (navigationDuringCapture || afterMain !== main.file_path)
-            throw new BrowserObservationError("inspect_web_page", "target_changed");
-        await report(context.progress, 3, "Electron inspection complete");
-        return {
-            schema_version: 1,
-            browser: context.discovery.version,
-            target: {
-                target_id: context.target.id,
-                type: context.target.type,
-                title: context.target.title.slice(0, 16_384),
-                file_path: main.file_path,
-                attached: context.target.attached,
-            },
-            capture_window: {
-                started_at: startedAt,
-                ended_at: new Date().toISOString(),
-                observation_ms: context.input.observation_ms,
-            },
-            completeness: completeness.snapshot(),
-            frames,
-            dom,
-            scripts: normalizedScripts,
-            resources,
-            limitations: [
-                "Only canonical file paths contained by an approved root are retained.",
-                "REA does not evaluate renderer JavaScript, invoke Electron APIs, navigate, click, or close the page.",
-                "Script contents require separate source-capture approval and remain byte bounded.",
-            ],
-        };
+        return await runElectronInspection(context, state, new Date().toISOString());
     }
     finally {
         removeListener();
     }
 };
+const runElectronInspection = async (context, state, startedAt) => {
+    const frames = await authorizeInitialFrames(context, state);
+    const main = frames[0];
+    state.mainFrameId = main.frame_id;
+    await enableElectronCapture(context);
+    await delayWithCancellation(context.input.observation_ms, "inspect_electron_page", context.signal);
+    const captured = await captureElectronContent(context, state, frames);
+    await assertStableMainFrame(context, state, main.file_path);
+    await report(context.progress, 3, "Electron inspection complete");
+    return {
+        schema_version: 1,
+        browser: context.discovery.version,
+        target: {
+            target_id: context.target.id,
+            type: context.target.type,
+            title: context.target.title.slice(0, 16_384),
+            file_path: main.file_path,
+            attached: context.target.attached,
+        },
+        capture_window: {
+            started_at: startedAt,
+            ended_at: new Date().toISOString(),
+            observation_ms: context.input.observation_ms,
+        },
+        completeness: state.completeness.snapshot(),
+        frames,
+        ...captured,
+        limitations: state.limitations,
+    };
+};
+const authorizeInitialFrames = async (context, state) => {
+    await report(context.progress, 1, "Authorizing Electron file frames");
+    await context.connection.send("Page.enable", {}, context.sessionId, context.signal);
+    const result = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
+    const frames = await captureFrames(result, state.roots, context.input.limits.max_frames, state.completeness);
+    if (frames[0] === undefined)
+        throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
+    return frames;
+};
+const enableElectronCapture = async (context) => {
+    await context.connection.send("Runtime.enable", {}, context.sessionId, context.signal);
+    await context.connection.send("Debugger.enable", { maxScriptsCacheSize: 4 * 1_024 * 1_024 }, context.sessionId, context.signal);
+};
+const captureElectronContent = async (context, state, frames) => {
+    await report(context.progress, 2, "Capturing Electron structure");
+    const frameIds = new Set(frames.map((frame) => frame.frame_id));
+    const resources = await captureResources(context, state.roots, state.completeness);
+    const dom = await captureDom(context, state.roots, state.completeness);
+    const scripts = await captureElectronScripts({
+        connection: context.connection,
+        sessionId: context.sessionId,
+        ...(context.signal === undefined ? {} : { signal: context.signal }),
+        request: context.input,
+        roots: state.roots,
+        scripts: state.scripts,
+        executionContextFrames: state.executionContextFrames,
+        frameIds,
+        completeness: state.completeness,
+    });
+    const workers = await captureElectronWorkers({
+        connection: context.connection,
+        ...(context.signal === undefined ? {} : { signal: context.signal }),
+        target: context.target,
+        request: context.input,
+        roots: state.roots,
+        frameIds,
+        completeness: state.completeness,
+        limitations: state.limitations,
+    });
+    return { dom, scripts, resources, workers };
+};
+const assertStableMainFrame = async (context, state, expectedPath) => {
+    const result = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
+    const afterPath = await mainFilePath(result, state.roots);
+    if (afterPath === undefined)
+        throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
+    if (state.navigationDuringCapture || afterPath !== expectedPath)
+        throw new BrowserObservationError("inspect_web_page", "target_changed");
+};
 const navigatedFrameId = (event) => {
     const params = recordValue(event.params);
     if (params === undefined)
@@ -83,33 +131,6 @@ const navigatedFrameId = (event) => {
         return stringValue(params.frameId);
     return undefined;
 };
-const ingestScript = (event, scripts, completeness) => {
-    if (event.method !== "Debugger.scriptParsed")
-        return;
-    const value = recordValue(event.params);
-    const scriptId = stringValue(value?.scriptId);
-    const rawUrl = stringValue(value?.url);
-    if (scriptId === undefined || scriptId.length > 256) {
-        completeness.exclude("scripts", "invalid_protocol_value");
-        return;
-    }
-    if (rawUrl === undefined || rawUrl === "") {
-        completeness.exclude("scripts", "unattributed_origin");
-        return;
-    }
-    if (scripts.length >= 2_000) {
-        completeness.drop("scripts");
-        return;
-    }
-    scripts.push({
-        scriptId,
-        rawUrl,
-        hash: (stringValue(value?.hash) ?? "").slice(0, 512),
-        length: nonnegativeInteger(value?.length),
-        isModule: value?.isModule === true,
-        language: boundedText(value?.scriptLanguage, 100),
-    });
-};
 const captureFrames = async (result, roots, maximum, completeness) => {
     const frameTree = recordValue(requiredRecord(result).frameTree);
     if (frameTree === undefined)
@@ -227,82 +248,6 @@ const captureDom = async (context, roots, completeness) => {
         completeness.truncate("dom");
     return { total_nodes: total, nodes };
 };
-const captureScripts = async (context, roots, scripts, completeness) => {
-    let total = 0;
-    let sourceBytes = 0;
-    const items = [];
-    const seen = new Set();
-    for (const script of scripts) {
-        const path = await authorizedElectronFile(script.rawUrl, roots);
-        if (path === undefined) {
-            completeness.exclude("scripts", "out_of_target_scope");
-            continue;
-        }
-        const identity = {
-            file_path: path,
-            cdp_hash: script.hash,
-            length: script.length,
-            is_module: script.isModule,
-            language: script.language,
-        };
-        const scriptKey = `electron_script_${digest(identity)}`;
-        if (seen.has(scriptKey))
-            continue;
-        seen.add(scriptKey);
-        total += 1;
-        if (items.length >= context.input.limits.max_scripts) {
-            completeness.drop("scripts");
-            continue;
-        }
-        let source = {
-            included: false,
-            reason: "source capture was not approved",
-        };
-        if (context.input.include_script_sources) {
-            if (script.length > context.input.limits.max_script_source_bytes ||
-                sourceBytes + script.length >
-                    context.input.limits.max_total_script_source_bytes) {
-                source = {
-                    included: false,
-                    reason: "script source byte limit reached",
-                };
-                completeness.truncate("script_sources");
-            }
-            else {
-                const result = requiredRecord(await context.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, context.sessionId, context.signal));
-                const text = stringValue(result.scriptSource) ?? "";
-                const bytes = Buffer.byteLength(text);
-                if (bytes > context.input.limits.max_script_source_bytes ||
-                    sourceBytes + bytes >
-                        context.input.limits.max_total_script_source_bytes) {
-                    source = {
-                        included: false,
-                        reason: "script source byte limit reached",
-                    };
-                    completeness.truncate("script_sources");
-                }
-                else {
-                    source = {
-                        included: true,
-                        artifact: createWebTextArtifact(text, "text/javascript"),
-                    };
-                    sourceBytes += bytes;
-                }
-            }
-        }
-        items.push({
-            script_key: scriptKey,
-            ...identity,
-            source,
-        });
-    }
-    if (!context.input.include_script_sources)
-        completeness.exclude("script_sources", "not_approved", total);
-    return {
-        total,
-        items: items.sort((left, right) => left.script_key.localeCompare(right.script_key)),
-    };
-};
 const mainFilePath = async (result, roots) => {
     const frameTree = recordValue(requiredRecord(result).frameTree);
     const frame = recordValue(frameTree?.frame);
@@ -314,7 +259,6 @@ const integer = (value, fallback) => {
     const number = numberValue(value);
     return number === undefined ? fallback : Math.trunc(number);
 };
-const nonnegativeInteger = (value) => Math.max(0, integer(value, 0));
 const digest = (value) => {
     const encoded = canonicalize(value);
     if (encoded === undefined)

package/dist/browser/CdpElectronProvider.js

@@ -108,7 +108,11 @@ export class CdpElectronProvider {
         }
         finally {
             if (targetSession !== undefined)
-                await closeCdpTargetSession(targetSession, ["Debugger", "Page"]);
+                await closeCdpTargetSession(targetSession, [
+                    "Debugger",
+                    "Runtime",
+                    "Page",
+                ]);
         }
     }
 }

package/dist/browser/CdpElectronScriptEvents.js

@@ -0,0 +1,69 @@
+import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
+import { boundedText, numberValue, recordValue, stringValue, } from "./CdpCaptureValues.js";
+/** Retain only bounded script/frame metadata from passive Electron events. */
+export const ingestElectronScriptEvent = (input) => {
+    if (input.event.method === "Runtime.executionContextsCleared") {
+        input.executionContextFrames.clear();
+        return;
+    }
+    if (input.event.method === "Runtime.executionContextDestroyed") {
+        const parameters = recordValue(input.event.params);
+        const key = executionContextKey(parameters?.executionContextId);
+        if (key !== null)
+            input.executionContextFrames.delete(key);
+        return;
+    }
+    if (input.event.method === "Runtime.executionContextCreated") {
+        retainExecutionContext(input.event, input.executionContextFrames, input.completeness);
+        return;
+    }
+    if (input.event.method !== "Debugger.scriptParsed")
+        return;
+    const value = recordValue(input.event.params);
+    const scriptId = stringValue(value?.scriptId);
+    const rawUrl = stringValue(value?.url);
+    if (scriptId === undefined || scriptId.length > 256) {
+        input.completeness.exclude("scripts", "invalid_protocol_value");
+        return;
+    }
+    if (rawUrl === undefined || rawUrl === "") {
+        input.completeness.exclude("scripts", "unattributed_origin");
+        return;
+    }
+    if (input.scripts.length >= 2_000) {
+        input.completeness.drop("scripts");
+        return;
+    }
+    input.scripts.push({
+        scriptId,
+        rawUrl,
+        hash: (stringValue(value?.hash) ?? "").slice(0, 512),
+        length: nonnegativeInteger(value?.length),
+        isModule: value?.isModule === true,
+        language: boundedText(value?.scriptLanguage, 100),
+        executionContextKey: executionContextKey(value?.executionContextId),
+    });
+};
+const retainExecutionContext = (event, frames, completeness) => {
+    const parameters = recordValue(event.params);
+    const runtimeContext = recordValue(parameters?.context);
+    const contextKey = executionContextKey(runtimeContext?.id);
+    const frameId = stringValue(recordValue(runtimeContext?.auxData)?.frameId);
+    if (contextKey === null || frameId === undefined || frameId.length > 256)
+        return;
+    if (frames.size >= 2_000 && !frames.has(contextKey)) {
+        completeness.truncate("scripts");
+        return;
+    }
+    frames.set(contextKey, frameId);
+};
+const nonnegativeInteger = (value) => {
+    const number = numberValue(value);
+    return number === undefined ? 0 : Math.max(0, Math.trunc(number));
+};
+const executionContextKey = (value) => {
+    const identifier = numberValue(value);
+    return identifier !== undefined && Number.isSafeInteger(identifier)
+        ? String(identifier)
+        : null;
+};

package/dist/browser/CdpElectronScripts.js

@@ -0,0 +1,94 @@
+import { createHash } from "node:crypto";
+import canonicalize from "canonicalize";
+import { createWebTextArtifact } from "../domain/webContentArtifact.js";
+import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
+import { requiredRecord, stringValue } from "./CdpCaptureValues.js";
+import { authorizedElectronFile } from "./ElectronFileScope.js";
+/** Normalize root-confined script metadata and optionally approved source. */
+export const captureElectronScripts = async (input) => {
+    let total = 0;
+    let sourceBytes = 0;
+    const items = [];
+    const seen = new Set();
+    for (const script of input.scripts) {
+        const path = await authorizedElectronFile(script.rawUrl, input.roots);
+        if (path === undefined) {
+            input.completeness.exclude("scripts", "out_of_target_scope");
+            continue;
+        }
+        const mappedFrame = script.executionContextKey === null
+            ? undefined
+            : input.executionContextFrames.get(script.executionContextKey);
+        const identity = {
+            frame_id: mappedFrame !== undefined && input.frameIds.has(mappedFrame)
+                ? mappedFrame
+                : null,
+            file_path: path,
+            cdp_hash: script.hash,
+            length: script.length,
+            is_module: script.isModule,
+            language: script.language,
+        };
+        const scriptKey = `electron_script_${digest(identity)}`;
+        if (seen.has(scriptKey))
+            continue;
+        seen.add(scriptKey);
+        total += 1;
+        if (items.length >= input.request.limits.max_scripts) {
+            input.completeness.drop("scripts");
+            continue;
+        }
+        const capturedSource = await captureScriptSource(input, script, sourceBytes);
+        sourceBytes += capturedSource.bytes;
+        items.push({
+            script_key: scriptKey,
+            ...identity,
+            source: capturedSource.source,
+        });
+    }
+    if (!input.request.include_script_sources)
+        input.completeness.exclude("script_sources", "not_approved", total);
+    return {
+        total,
+        items: items.sort((left, right) => left.script_key.localeCompare(right.script_key)),
+    };
+};
+const captureScriptSource = async (input, script, sourceBytes) => {
+    if (!input.request.include_script_sources)
+        return {
+            source: {
+                included: false,
+                reason: "source capture was not approved",
+            },
+            bytes: 0,
+        };
+    if (sourceLimitReached(input.request.limits, script.length, sourceBytes))
+        return sourceLimitResult(input.completeness);
+    const result = requiredRecord(await input.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, input.sessionId, input.signal));
+    const text = stringValue(result.scriptSource) ?? "";
+    const bytes = Buffer.byteLength(text);
+    if (sourceLimitReached(input.request.limits, bytes, sourceBytes))
+        return sourceLimitResult(input.completeness);
+    return {
+        source: {
+            included: true,
+            artifact: createWebTextArtifact(text, "text/javascript"),
+        },
+        bytes,
+    };
+};
+const sourceLimitReached = (limits, bytes, previousBytes) => bytes > limits.max_script_source_bytes ||
+    previousBytes + bytes > limits.max_total_script_source_bytes;
+const sourceLimitResult = (completeness) => {
+    completeness.truncate("script_sources");
+    return {
+        source: { included: false, reason: "script source byte limit reached" },
+        bytes: 0,
+    };
+};
+const digest = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Expected canonical JSON");
+    return createHash("sha256").update(encoded).digest("hex");
+};

package/dist/browser/CdpElectronWorkers.js

@@ -0,0 +1,56 @@
+import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
+import { boundedText, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
+import { optionalCdpCommand } from "./CdpOptionalCommand.js";
+import { authorizedElectronFile } from "./ElectronFileScope.js";
+/** Inventory root-confined worker targets without attaching to them. */
+export const captureElectronWorkers = async (input) => {
+    const result = await optionalCdpCommand({
+        connection: input.connection,
+        sessionId: undefined,
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    }, "Target.getTargets", {}, input.limitations);
+    if (result === undefined) {
+        input.completeness.unavailable("workers");
+        return [];
+    }
+    const workers = [];
+    for (const target of recordsValue(recordValue(result)?.targetInfos)) {
+        const type = stringValue(target.type) ?? "";
+        if (!type.includes("worker"))
+            continue;
+        const openerTargetId = boundedTargetField(target.openerId);
+        const parentFrameId = boundedTargetField(target.parentFrameId);
+        if (openerTargetId !== input.target.id &&
+            (parentFrameId === null || !input.frameIds.has(parentFrameId))) {
+            input.completeness.exclude("workers", "out_of_target_scope");
+            continue;
+        }
+        const path = await authorizedElectronFile(stringValue(target.url) ?? "", input.roots);
+        if (path === undefined) {
+            input.completeness.exclude("workers", "out_of_target_scope");
+            continue;
+        }
+        if (workers.length >= input.request.limits.max_workers) {
+            input.completeness.truncate("workers");
+            continue;
+        }
+        const targetId = boundedTargetField(target.targetId);
+        if (targetId === null) {
+            input.completeness.exclude("workers", "invalid_protocol_value");
+            continue;
+        }
+        workers.push({
+            target_id: targetId,
+            type: type.slice(0, 100),
+            file_path: path,
+            attached: target.attached === true,
+            opener_target_id: openerTargetId,
+            parent_frame_id: parentFrameId,
+        });
+    }
+    return workers.sort((left, right) => left.target_id.localeCompare(right.target_id));
+};
+const boundedTargetField = (value) => {
+    const field = boundedText(value, 256);
+    return field === null || field === "" ? null : field;
+};

package/dist/browser/CdpObservationSession.js

@@ -133,7 +133,13 @@ class TimelineCapture {
     targetTerminated() {
         if (this.#endReason !== undefined)
             return;
-        this.#add("target_terminated", {}, null, null, "target_terminated");
+        this.#add({
+            type: "target_terminated",
+            params: {},
+            rawUrl: null,
+            requestId: null,
+            detail: "target_terminated",
+        });
         this.end("target_terminated");
     }
     setFinalUrl(rawUrl) {
@@ -145,7 +151,13 @@ class TimelineCapture {
             return;
         const reason = safeDetail(params.reason);
         this.#pendingReload = reason === "reload";
-        this.#add("navigation_requested", params, stringValue(params.url), null, reason);
+        this.#add({
+            type: "navigation_requested",
+            params,
+            rawUrl: stringValue(params.url) ?? null,
+            requestId: null,
+            detail: reason,
+        });
     }
     #navigationCommitted(params) {
         const frame = recordValue(params.frame);
@@ -153,7 +165,13 @@ class TimelineCapture {
             return;
         const rawUrl = stringValue(frame?.url);
         const destination = scopedUrl(rawUrl, this.allowedOrigins);
-        this.#add(this.#pendingReload ? "same_origin_reload" : "navigation_committed", { ...params, frameId: frame?.id, loaderId: frame?.loaderId }, rawUrl, null, safeDetail(frame?.transitionType));
+        this.#add({
+            type: this.#pendingReload ? "same_origin_reload" : "navigation_committed",
+            params: { ...params, frameId: frame?.id, loaderId: frame?.loaderId },
+            rawUrl: rawUrl ?? null,
+            requestId: null,
+            detail: safeDetail(frame?.transitionType),
+        });
         this.#pendingReload = false;
         if (destination.scope === "approved")
             this.finalUrl = destination.url;
@@ -168,7 +186,13 @@ class TimelineCapture {
             return;
         const rawUrl = stringValue(params.url);
         const destination = scopedUrl(rawUrl, this.allowedOrigins);
-        this.#add("same_document_navigation", params, rawUrl, null, null);
+        this.#add({
+            type: "same_document_navigation",
+            params,
+            rawUrl: rawUrl ?? null,
+            requestId: null,
+            detail: null,
+        });
         if (destination.scope === "approved")
             this.finalUrl = destination.url;
         else {
@@ -184,7 +208,13 @@ class TimelineCapture {
         const request = recordValue(params.request);
         const rawUrl = stringValue(request?.url);
         const destination = scopedUrl(rawUrl, this.allowedOrigins);
-        this.#add("redirect", params, rawUrl, stringValue(params.requestId) ?? null, null);
+        this.#add({
+            type: "redirect",
+            params,
+            rawUrl: rawUrl ?? null,
+            requestId: stringValue(params.requestId) ?? null,
+            detail: null,
+        });
         if (destination.scope !== "approved") {
             this.completeness.exclude("timeline", "out_of_target_scope");
             this.end("target_left_scope");
@@ -194,14 +224,27 @@ class TimelineCapture {
         const frame = stringValue(params.frameId);
         if (frame !== undefined && frame !== this.mainFrameId)
             return;
-        this.#add("load_failed", params, null, stringValue(params.requestId) ?? null, safeNetworkError(params.errorText));
+        this.#add({
+            type: "load_failed",
+            params,
+            rawUrl: null,
+            requestId: stringValue(params.requestId) ?? null,
+            detail: safeNetworkError(params.errorText),
+        });
     }
     #lifecycle(params) {
         if (stringValue(params.frameId) !== this.mainFrameId)
             return;
-        this.#add("lifecycle", params, null, null, safeDetail(params.name));
+        this.#add({
+            type: "lifecycle",
+            params,
+            rawUrl: null,
+            requestId: null,
+            detail: safeDetail(params.name),
+        });
     }
-    #add(type, params, rawUrl, requestId, detail) {
+    #add(options) {
+        const { type, params, rawUrl = null, requestId = null, detail = null, } = options;
         const destination = rawUrl == null ? null : scopedUrl(rawUrl, this.allowedOrigins);
         if (this.timeline.length >= this.maximum) {
             this.completeness.drop("timeline_events");