rea-agents 1.6.0 → 2.0.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

@@ -5,11 +5,13 @@ import { discoverCdpEndpoint, hasCdpTargetWebSocket, } from "./CdpEndpoint.js";
 import { closeCdpTargetSession, openCdpTargetSession, } from "./CdpTargetSession.js";
 import { inspectCdpElectronPage } from "./CdpElectronInspection.js";
 import { authorizedElectronFile, canonicalElectronRoots, } from "./ElectronFileScope.js";
-const IDENTITY = {
+/** Public identity committed by passive Electron observations. */
+export const CDP_ELECTRON_PROVIDER_IDENTITY = Object.freeze({
     id: "rea-cdp-electron",
     name: "REA Electron file-page CDP observation provider",
     version: "1",
-};
+});
+const IDENTITY = CDP_ELECTRON_PROVIDER_IDENTITY;
 /** Passive Electron provider with canonical file-root confinement. */
 export class CdpElectronProvider {
     identity() {
@@ -106,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/CdpEndpoint.js

@@ -1,6 +1,7 @@
 import { request } from "node:http";
 import { z } from "zod";
 import { AnalysisCancelledError, AnalysisError, AnalysisTimeoutError, BrowserObservationError, } from "../domain/errors.js";
+import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 const HTTP_TIMEOUT_MS = 5_000;
 const MAX_VERSION_BYTES = 64 * 1_024;
 const MAX_TARGET_LIST_BYTES = 2 * 1_024 * 1_024;
@@ -39,13 +40,25 @@ export const discoverCdpEndpoint = async (endpoint, operation, signal) => {
         targets: targets.map((target) => ({
             id: target.id,
             type: target.type,
-            title: target.title,
+            title: sanitizeTargetTitle(target.title),
             url: target.url,
             attached: target.attached,
             ...targetWebSocket(endpoint, target, operation),
         })),
     };
 };
+const sanitizeTargetTitle = (value) => {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return value;
+    }
+    return url.protocol === "http:" || url.protocol === "https:"
+        ? sanitizeBrowserUrl(value).url.slice(0, 16_384)
+        : value;
+};
 /** Select a browser attachment socket or a direct socket for one page target. */
 export const cdpTargetWebSocket = (discovery, target, operation) => {
     const webSocket = availableCdpTargetWebSocket(discovery, target);

package/dist/browser/CdpPageCapture.js

@@ -5,7 +5,7 @@ import { CdpCaptureEvents } from "./CdpCaptureEvents.js";
 import { captureStorage } from "./CdpCaptureStorage.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 import { captureAccessibility, captureDom, captureFrames, captureResources, mainFrameUrl, } from "./CdpCaptureDocuments.js";
-import { allowedSanitizedUrl, delayWithCancellation, isHttpUrl, recordValue, recordsValue, requiredRecord, sourceExcluded, sourceResult, stringValue, } from "./CdpCaptureValues.js";
+import { allowedSanitizedUrl, boundedText, delayWithCancellation, isHttpUrl, recordValue, recordsValue, requiredRecord, sourceExcluded, sourceResult, stringValue, } from "./CdpCaptureValues.js";
 /** Capture and normalize one attached page without evaluating page JavaScript. */
 export const capturePage = async (context) => {
     const allowedOrigins = new Set(context.input.allowed_origins);
@@ -59,7 +59,7 @@ const captureAuthorizedPage = async (state) => {
     const accessibility = await accessibilityForFrames(state, frames);
     if (accessibility.total > accessibility.nodes.length)
         state.events.completeness.truncate("accessibility");
-    const scripts = await captureScripts(context, state.events, resourceCapture.items, resources);
+    const scripts = await captureScripts(context, state.events, resourceCapture.items, resources, new Set(frames.map((frame) => frame.frame_id)));
     const workerCapture = await captureWorkers(state, new Set(frames.map((frame) => frame.frame_id)));
     if (workerCapture.total > workerCapture.items.length)
         state.events.completeness.truncate("workers");
@@ -220,7 +220,7 @@ const accessibilityForFrames = async (state, frames) => {
         events.completeness.truncate("accessibility");
     return capture;
 };
-const captureScripts = async (context, events, rawResources, resources) => {
+const captureScripts = async (context, events, rawResources, resources, frameIds) => {
     let totalSourceBytes = 0;
     const drafts = [];
     for (const script of events.scripts.values()) {
@@ -252,6 +252,7 @@ const captureScripts = async (context, events, rawResources, resources) => {
             }
         }
         const inventoryScript = {
+            frame_id: events.frameForScript(script, frameIds),
             url: script.url,
             cdp_hash: script.hash,
             length: script.length,
@@ -276,7 +277,8 @@ const captureScripts = async (context, events, rawResources, resources) => {
         base: stableWebScriptKey(draft.item),
     }));
     keyed.sort((left, right) => left.base.localeCompare(right.base) ||
-        sourceDigest(left.item.source).localeCompare(sourceDigest(right.item.source)));
+        sourceDigest(left.item.source).localeCompare(sourceDigest(right.item.source)) ||
+        (left.item.frame_id ?? "").localeCompare(right.item.frame_id ?? ""));
     const totals = new Map();
     for (const { base } of keyed)
         totals.set(base, (totals.get(base) ?? 0) + 1);
@@ -349,6 +351,8 @@ const captureWorkers = async (state, frameIds) => {
             url: url.url,
             origin: url.origin,
             attached: target.attached === true,
+            opener_target_id: boundedText(target.openerId, 256) ?? null,
+            parent_frame_id: boundedText(target.parentFrameId, 256) ?? null,
         });
     }
     return {