rea-agents 4.0.1 → 5.0.0

package/dist/browser/CdpPageCapture.js

@@ -1,4 +1,5 @@
-import { BrowserObservationError, } from "../domain/errors.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import {} from "../domain/browserObservationErrors.js";
 import { stableWebResources } from "../domain/webInventory.js";
 import { CdpConnection } from "./CdpConnection.js";
 import { CdpCaptureEvents } from "./CdpCaptureEvents.js";
@@ -47,7 +48,7 @@ const captureAuthorizedPage = async (state) => {
         sessionId: context.sessionId,
         signal: context.signal,
         allowedOrigins,
-        delayOperation: context.operation,
+        operation: context.operation,
     });
     const attachedUrl = mainFrameUrl(frameResult) ?? "";
     const frameCapture = captureFrames(frameResult, allowedOrigins, undefined, state.events.completeness);
@@ -68,7 +69,7 @@ const captureAuthorizedPage = async (state) => {
         frameIds: new Set(frames.map((frame) => frame.frame_id)),
     });
     const workers = await captureWorkers({ context, allowedOrigins, limitations, events: state.events }, new Set(frames.map((frame) => frame.frame_id)));
-    const storageCapture = await captureStorage(context, frames[0]?.origin ?? new URL(attachedUrl).origin, limitations);
+    const storageCapture = await captureStorage(context, attachedUrl, limitations);
     if (!input.include_storage_keys)
         state.events.completeness.exclude("storage_keys", "not_approved", null);
     const completedFrameResult = await authorizedMainFrame({
@@ -76,7 +77,7 @@ const captureAuthorizedPage = async (state) => {
         sessionId: context.sessionId,
         signal: context.signal,
         allowedOrigins,
-        delayOperation: context.operation,
+        operation: context.operation,
     });
     const completedUrl = mainFrameUrl(completedFrameResult) ?? "";
     if (state.events.originViolation)
@@ -124,7 +125,7 @@ const authorizeObservationWindow = async (state) => {
         sessionId: context.sessionId,
         signal: context.signal,
         allowedOrigins,
-        delayOperation: context.operation,
+        operation: context.operation,
     });
     const mainFrame = captureFrames(initialFrameResult, allowedOrigins).items[0];
     if (mainFrame === undefined)

package/dist/browser/CdpPageCaptureScripts.js

@@ -1,5 +1,5 @@
 import { reconcileCapturedWebScript, stableWebScriptKey, } from "../domain/webInventory.js";
-import { requiredRecord, sourceExcluded, sourceResult, stringValue, } from "./CdpCaptureValues.js";
+import { requiredRecord, sourceExcluded, sourceResult, cdpStringValue, } from "./CdpCaptureValues.js";
 export const captureScripts = async (options) => {
     const { context, events, rawResources, resources, frameIds } = options;
     const state = {
@@ -43,7 +43,7 @@ const buildScriptDraft = async (script, state) => {
 const captureScriptSource = async (script, state) => {
     const { context } = state;
     const result = requiredRecord(await context.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, context.sessionId, context.signal));
-    const content = stringValue(result.scriptSource) ?? "";
+    const content = cdpStringValue(result.scriptSource) ?? "";
     return sourceResult(content);
 };
 const keyAndBuildInventory = (drafts, scriptCount) => {

package/dist/browser/CdpPageCaptureWorkers.js

@@ -1,4 +1,4 @@
-import { allowedSanitizedUrl, isHttpUrl, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
+import { allowedSanitizedUrl, isHttpUrl, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 export const captureWorkers = async (input, frameIds) => {
     const { context, allowedOrigins, limitations, events } = input;
@@ -8,11 +8,11 @@ export const captureWorkers = async (input, frameIds) => {
     if (result === undefined)
         completeness.unavailable("workers");
     for (const target of recordsValue(recordValue(result)?.targetInfos)) {
-        const type = stringValue(target.type) ?? "";
+        const type = cdpStringValue(target.type) ?? "";
         const url = allowedSanitizedUrl(target.url, allowedOrigins);
-        const relatedToPage = stringValue(target.openerId) === context.target.id ||
-            (stringValue(target.parentFrameId) !== undefined &&
-                frameIds.has(stringValue(target.parentFrameId) ?? ""));
+        const relatedToPage = cdpStringValue(target.openerId) === context.target.id ||
+            (cdpStringValue(target.parentFrameId) !== undefined &&
+                frameIds.has(cdpStringValue(target.parentFrameId) ?? ""));
         if (!type.includes("worker"))
             continue;
         if (!relatedToPage) {
@@ -20,7 +20,7 @@ export const captureWorkers = async (input, frameIds) => {
             continue;
         }
         if (url === undefined) {
-            const rawUrl = stringValue(target.url);
+            const rawUrl = cdpStringValue(target.url);
             completeness.exclude("workers", rawUrl === undefined || rawUrl === ""
                 ? "unattributed_origin"
                 : isHttpUrl(rawUrl)
@@ -29,13 +29,13 @@ export const captureWorkers = async (input, frameIds) => {
             continue;
         }
         items.push({
-            target_id: stringValue(target.targetId) ?? "",
+            target_id: cdpStringValue(target.targetId) ?? "",
             type,
             url: url.url,
             origin: url.origin,
             attached: target.attached === true,
-            opener_target_id: stringValue(target.openerId) ?? null,
-            parent_frame_id: stringValue(target.parentFrameId) ?? null,
+            opener_target_id: cdpStringValue(target.openerId) ?? null,
+            parent_frame_id: cdpStringValue(target.parentFrameId) ?? null,
         });
     }
     return items;

package/dist/browser/CdpSafeMetadata.js

@@ -1,5 +1,5 @@
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
-import { numberValue, stringValue, } from "./CdpCaptureValues.js";
+import { numberValue, cdpStringValue, } from "./CdpCaptureValues.js";
 /** Normalize an allowlisted subset of response metadata and discard raw headers. */
 export const safeResponseMetadata = (requestId, url, response, allowedOrigins) => {
     const headers = normalizedHeaders(response.headers);
@@ -16,7 +16,7 @@ export const safeResponseMetadata = (requestId, url, response, allowedOrigins) =
         response: {
             request_id: requestId,
             url,
-            mime_type: boundedHeader(stringValue(response.mimeType)),
+            mime_type: boundedHeader(cdpStringValue(response.mimeType)),
             content_length: nonnegativeInteger(headers.get("content-length")),
             content_encoding: boundedHeader(headers.get("content-encoding")),
             csp,
@@ -25,7 +25,7 @@ export const safeResponseMetadata = (requestId, url, response, allowedOrigins) =
                 coop: policyToken(headers.get("cross-origin-opener-policy")),
                 coep: policyToken(headers.get("cross-origin-embedder-policy")),
                 corp: policyToken(headers.get("cross-origin-resource-policy")),
-                referrer_policy: policyToken(headers.get("referrer-policy")),
+                referrer_policy: referrerPolicy(headers.get("referrer-policy")),
                 x_content_type_options: policyToken(headers.get("x-content-type-options")),
                 permissions_policy_features: permissionFeatures(headers.get("permissions-policy")),
             },
@@ -83,14 +83,55 @@ const cspSource = (token, baseUrl, allowedOrigins) => {
         return { kind: "keyword", value: lower };
     if (/^[a-z][a-z0-9+.-]*:$/u.test(lower))
         return { kind: "scheme", value: lower };
+    const hostOrigin = cspHostSourceOrigin(token, baseUrl);
+    if (hostOrigin === undefined)
+        return { kind: "other", value: null };
+    return hostOrigin !== null && allowedOrigins.has(hostOrigin)
+        ? { kind: "approved_origin", value: hostOrigin }
+        : { kind: "external_origin", value: null };
+};
+/**
+ * Resolve a CSP host-source (CSP3 §2.3.1) to the single origin it names. A
+ * scheme-less source inherits the protected resource's scheme instead of being
+ * resolved as a page-relative path. Returns `null` for a recognized wildcard
+ * host or port, which denotes a set of origins rather than one origin, and
+ * `undefined` when the token is not a host-source at all.
+ */
+const cspHostSourceOrigin = (token, baseUrl) => {
+    const match = /^(?:([a-z][a-z0-9+.-]*):\/\/)?([^/?#]+)(?:\/[^?#]*)?$/iu.exec(token);
+    const authority = match?.[2];
+    if (authority === undefined || authority.length === 0)
+        return undefined;
+    const scheme = (match?.[1] ?? schemeOf(baseUrl))?.toLowerCase();
+    if (scheme === undefined || !/^[a-z][a-z0-9+.-]*$/u.test(scheme))
+        return undefined;
+    if (!/^(?:\*|(?:\*\.)?[a-z0-9-]+(?:\.[a-z0-9-]+)*\.?)(?::(?:\*|\d+))?$/iu.test(authority))
+        return undefined;
+    if (authority.includes("*"))
+        return null;
     try {
-        const parsed = new URL(token, baseUrl);
-        return allowedOrigins.has(parsed.origin)
-            ? { kind: "approved_origin", value: parsed.origin }
-            : { kind: "external_origin", value: null };
+        const parsed = new URL(`${scheme}://${authority}`);
+        return parsed.username === "" &&
+            parsed.password === "" &&
+            parsed.pathname === "/" &&
+            parsed.origin !== "null"
+            ? parsed.origin
+            : undefined;
     }
-    catch {
-        return { kind: "other", value: null };
+    catch (cause) {
+        // Authorities that are not a bare host[:port] are classified as other.
+        void cause;
+        return undefined;
+    }
+};
+const schemeOf = (baseUrl) => {
+    try {
+        return new URL(baseUrl).protocol.replace(/:$/u, "");
+    }
+    catch (cause) {
+        // An unparseable protected-resource URL cannot lend a scheme.
+        void cause;
+        return undefined;
     }
 };
 const parseLinks = (value, baseUrl, allowedOrigins) => {
@@ -115,25 +156,40 @@ const parseLinks = (value, baseUrl, allowedOrigins) => {
     }
     return links;
 };
-const splitLinkHeader = (value) => {
+const splitLinkHeader = (value, delimiter = ",") => {
     const entries = [];
     let start = 0;
     let quoted = false;
+    let escaped = false;
+    let target = false;
     for (let index = 0; index < value.length; index += 1) {
         const character = value[index];
-        if (character === '"' && value[index - 1] !== "\\")
-            quoted = !quoted;
-        if (character !== "," || quoted)
+        if (quoted) {
+            if (escaped)
+                escaped = false;
+            else if (character === "\\")
+                escaped = true;
+            else if (character === '"')
+                quoted = false;
             continue;
-        entries.push(value.slice(start, index));
-        start = index + 1;
+        }
+        if (character === '"' && !target)
+            quoted = true;
+        else if (delimiter === "," && character === "<")
+            target = true;
+        else if (delimiter === "," && character === ">")
+            target = false;
+        else if (character === delimiter && !target) {
+            entries.push(value.slice(start, index));
+            start = index + 1;
+        }
     }
     entries.push(value.slice(start));
     return entries;
 };
 const linkParameters = (value) => {
     const parameters = new Map();
-    for (const raw of value.split(";").slice(1)) {
+    for (const raw of splitLinkHeader(value, ";").slice(1)) {
         const separator = raw.indexOf("=");
         const name = (separator < 0 ? raw : raw.slice(0, separator))
             .trim()
@@ -155,7 +211,9 @@ const safeDestination = (value, baseUrl, allowedOrigins) => {
             return { url: sanitized, scope: "outside_policy" };
         return { url: sanitized, scope: "approved" };
     }
-    catch {
+    catch (cause) {
+        // Unparseable link values keep their raw text for the analyst.
+        void cause;
         return { url: value, scope: "unsupported" };
     }
 };
@@ -172,7 +230,9 @@ const wellKnownHint = (url) => {
             ? [agentHint("well_known_resource", path, sanitizeBrowserUrl(url).url)]
             : [];
     }
-    catch {
+    catch (cause) {
+        // Non-URL input yields no well-known hint.
+        void cause;
         return [];
     }
 };
@@ -183,6 +243,29 @@ const agentHint = (mechanism, declaration, url) => ({
     trust: "page-declared-untrusted",
 });
 const isAgentRel = (value) => ["mcp", "model-context", "ai-plugin", "service-desc"].includes(value);
+const referrerPolicies = new Set([
+    "no-referrer",
+    "no-referrer-when-downgrade",
+    "same-origin",
+    "origin",
+    "strict-origin",
+    "origin-when-cross-origin",
+    "strict-origin-when-cross-origin",
+    "unsafe-url",
+]);
+const referrerPolicy = (value) => {
+    let policy = null;
+    for (const raw of (value ?? "").split(",")) {
+        const token = raw.trim().toLowerCase();
+        if (token === "")
+            continue;
+        if (!/^[a-z-]+$/u.test(token))
+            return null;
+        if (referrerPolicies.has(token))
+            policy = token;
+    }
+    return policy;
+};
 const policyToken = (value) => {
     const token = (value ?? "").trim().toLowerCase();
     return /^[a-z][a-z0-9_.-]*$/u.test(token) ? token : null;

package/dist/browser/CdpScreenshot.js

@@ -1,7 +1,7 @@
 import { createWebScreenshotArtifact } from "../domain/webScreenshot.js";
-import { BrowserObservationError } from "../domain/errors.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { isMainFrameNavigation } from "./CdpCaptureEventHelpers.js";
-import { allowedSanitizedUrl, recordValue, stringValue, } from "./CdpCaptureValues.js";
+import { allowedSanitizedUrl, recordValue, cdpStringValue, } from "./CdpCaptureValues.js";
 import { mainFrameUrl } from "./CdpCaptureDocuments.js";
 import { captureFrames } from "./CdpCaptureDocuments.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
@@ -27,7 +27,7 @@ export const captureCdpScreenshot = async (context) => {
         changed: false,
         leftScope: false,
         url: beforeUrl,
-        loaderId: stringValue(initialFrame?.loaderId),
+        loaderId: cdpStringValue(initialFrame?.loaderId),
     };
     const removeListener = context.connection.onEvent((event) => {
         if (event.sessionId !== context.sessionId)
@@ -43,7 +43,7 @@ export const captureCdpScreenshot = async (context) => {
     finally {
         removeListener();
     }
-    const encoded = stringValue(result?.data);
+    const encoded = cdpStringValue(result?.data);
     const bytes = encoded === undefined ? undefined : decodeCanonicalBase64(encoded);
     if (bytes === undefined)
         throw new BrowserObservationError("inspect_web_page", "payload_limit");
@@ -89,8 +89,8 @@ const observeScreenshotNavigation = (event, mainFrameId, origins, state) => {
     if (event.method === "Page.frameNavigated" &&
         state.loaderId !== undefined &&
         state.loaderId !== "" &&
-        stringValue(frame?.loaderId) === state.loaderId &&
-        stringValue(frame?.url) === state.url)
+        cdpStringValue(frame?.loaderId) === state.loaderId &&
+        cdpStringValue(frame?.url) === state.url)
         return;
     state.changed = true;
     if (allowedSanitizedUrl(frame?.url, origins) === undefined)

package/dist/browser/CdpTargetEvents.js

@@ -0,0 +1,8 @@
+import { cdpStringValue, recordValue } from "./CdpCaptureValues.js";
+/** Match ordinary session envelopes and root detachment's parameter-scoped session identity. */
+export const cdpTargetEventMatches = (event, sessionId) => {
+    if (event.method !== "Target.detachedFromTarget")
+        return event.sessionId === sessionId;
+    return (sessionId !== undefined &&
+        cdpStringValue(recordValue(event.params)?.sessionId) === sessionId);
+};

package/dist/browser/CdpTargetSession.js

@@ -1,10 +1,11 @@
-import { BrowserObservationError, } from "../domain/errors.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import {} from "../domain/browserObservationErrors.js";
 import { CdpConnection } from "./CdpConnection.js";
 import { cdpTargetWebSocket, } from "./CdpEndpoint.js";
 /** Open one authorized target through its supported browser or page transport. */
-export const openCdpTargetSession = async (discovery, target, operation, signal) => {
+export const openCdpTargetSession = async (discovery, target, operation, signal, limits) => {
     const webSocket = cdpTargetWebSocket(discovery, target, operation);
-    const connection = await CdpConnection.connect(webSocket.url, operation, signal);
+    const connection = await CdpConnection.connect(webSocket.url, operation, signal, limits);
     if (webSocket.scope === "page")
         return { connection, sessionId: undefined };
     try {
@@ -27,8 +28,9 @@ export const closeCdpTargetSession = async (targetSession, enabledDomains, signa
         try {
             await connection.send(`${domain}.disable`, {}, sessionId, signal);
         }
-        catch {
-            // Cleanup continues to the detach or direct-socket close boundary.
+        catch (cause) {
+            // best-effort cleanup: domain disable continues to detach/close boundary.
+            void cause;
         }
     }
     if (signal?.aborted === true) {
@@ -39,8 +41,9 @@ export const closeCdpTargetSession = async (targetSession, enabledDomains, signa
         try {
             await connection.send("Target.detachFromTarget", { sessionId }, undefined, signal);
         }
-        catch {
-            // Closing REA's socket is the final non-destructive cleanup boundary.
+        catch (cause) {
+            // best-effort cleanup: closing REA's socket is the final cleanup boundary.
+            void cause;
         }
     await connection.close();
 };

package/dist/browser/CdpWebMcpDiscovery.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
 import { inferJsonShape } from "../domain/jsonShape.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { BrowserObservationError } from "../domain/errors.js";
-import { allowedSanitizedUrl, delayWithCancellation, numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { allowedSanitizedUrl, delayWithCancellation, numberValue, recordValue, recordsValue, cdpStringValue, } from "./CdpCaptureValues.js";
 import { captureFrames, mainFrameUrl, walkFrameTrees, } from "./CdpCaptureDocuments.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 /** Discover WebMCP registrations without evaluating or invoking page code. */
@@ -96,10 +96,13 @@ const initialFrameScope = (frameTree, frames, completeness) => {
         return scoped;
     for (const tree of walkFrameTrees(root, () => completeness.exclude("webmcp_tools", "invalid_protocol_value"))) {
         const frame = recordValue(tree.frame);
-        const frameId = stringValue(frame?.id);
+        const frameId = cdpStringValue(frame?.id);
         const prior = frameId === undefined ? undefined : scoped.get(frameId);
         if (frameId !== undefined && prior !== undefined)
-            scoped.set(frameId, { ...prior, loaderId: stringValue(frame?.loaderId) });
+            scoped.set(frameId, {
+                ...prior,
+                loaderId: cdpStringValue(frame?.loaderId),
+            });
     }
     return scoped;
 };
@@ -119,7 +122,7 @@ const ingestFrameScopeEvent = (event, state) => {
     }
 };
 const handleFrameDetached = (params, state) => {
-    const frameId = stringValue(params.frameId);
+    const frameId = cdpStringValue(params.frameId);
     if (frameId === undefined) {
         state.completeness.exclude("webmcp_tools", "invalid_protocol_value");
         return true;
@@ -134,12 +137,12 @@ const handleFrameUpdate = (frame, state, documentCommitted) => {
         state.completeness.exclude("webmcp_tools", "invalid_protocol_value");
         return true;
     }
-    const frameId = stringValue(frame?.id) ?? stringValue(frame?.frameId);
+    const frameId = cdpStringValue(frame?.id) ?? cdpStringValue(frame?.frameId);
     if (frameId === undefined) {
         state.completeness.exclude("webmcp_tools", "invalid_protocol_value");
         return true;
     }
-    const rawUrl = stringValue(frame?.url);
+    const rawUrl = cdpStringValue(frame?.url);
     // Chromium can briefly commit an inherited, empty document while replacing
     // a subframe. That intermediate URL says nothing about the frame's eventual
     // scope or its registered tools; wait for the next committed URL (or the
@@ -164,7 +167,7 @@ const updateFrameScope = (frame, frameId, state, documentCommitted) => {
         return;
     }
     const previous = state.frames.get(frameId);
-    const loaderId = stringValue(frame?.loaderId);
+    const loaderId = cdpStringValue(frame?.loaderId);
     if (hasNewDocument(documentCommitted, previous, url.url, loaderId))
         removeFrameTools(frameId, state.tools);
     if (documentCommitted && state.transientFrames.has(frameId))
@@ -173,7 +176,7 @@ const updateFrameScope = (frame, frameId, state, documentCommitted) => {
         url: url.url,
         origin: url.origin,
         ...(loaderId === undefined ? {} : { loaderId }),
-        parentFrameId: (stringValue(frame?.parentId) ??
+        parentFrameId: (cdpStringValue(frame?.parentId) ??
             state.frames.get(frameId)?.parentFrameId ??
             "") ||
             null,
@@ -223,8 +226,8 @@ const ingestWebMcpEvent = (options) => {
         return;
     if (event.method === "WebMCP.toolsRemoved") {
         for (const removed of recordsValue(params.tools)) {
-            const name = stringValue(removed.name);
-            const frameId = stringValue(removed.frameId);
+            const name = cdpStringValue(removed.name);
+            const frameId = cdpStringValue(removed.frameId);
             if (name === undefined || frameId === undefined)
                 continue;
             for (const [key, tool] of tools)
@@ -236,7 +239,7 @@ const ingestWebMcpEvent = (options) => {
     if (event.method !== "WebMCP.toolsAdded")
         return;
     for (const declared of recordsValue(params.tools)) {
-        const frameId = stringValue(declared.frameId);
+        const frameId = cdpStringValue(declared.frameId);
         if (frameId !== undefined && transientFrames.has(frameId)) {
             if (!resolvedTransientFrames.has(frameId))
                 continue;
@@ -250,8 +253,8 @@ const ingestWebMcpEvent = (options) => {
     }
 };
 const normalizeTool = (value, input, frames, completeness) => {
-    const frameId = stringValue(value.frameId);
-    const name = stringValue(value.name);
+    const frameId = cdpStringValue(value.frameId);
+    const name = cdpStringValue(value.name);
     const frame = frameId === undefined ? undefined : frames.get(frameId);
     if (frameId === undefined ||
         name === undefined ||
@@ -260,10 +263,10 @@ const normalizeTool = (value, input, frames, completeness) => {
         completeness.exclude("webmcp_tools", "out_of_target_scope");
         return undefined;
     }
-    const description = stringValue(value.description) ?? "";
+    const description = cdpStringValue(value.description) ?? "";
     const annotations = recordValue(value.annotations);
     return {
-        tool_key: toolKey(frame.url, name),
+        tool_key: toolKey(frame.url, frameId, name),
         name,
         description,
         frame_id: frameId,
@@ -322,7 +325,10 @@ const buildWebMcpResult = (options) => {
         limitations,
     };
 };
-const toolKey = (frameUrl, name) => `webmcp_${createHash("sha256").update(`${frameUrl}\0${name}`).digest("hex")}`;
+const toolKey = (frameUrl, frameId, name) => 
+// Registrations without a known admitted frame are excluded above, so the
+// frame ID here always distinguishes owners and keys cannot collapse.
+`webmcp_${createHash("sha256").update(`${frameUrl}\0${frameId}\0${name}`).digest("hex")}`;
 const booleanOrNull = (value) => typeof value === "boolean" ? value : null;
 const integerOrNull = (value) => {
     const number = numberValue(value);

package/dist/browser/ElectronFileScope.js

@@ -9,7 +9,9 @@ export const authorizedElectronFile = async (value) => {
     try {
         url = new URL(value);
     }
-    catch {
+    catch (cause) {
+        // Non-URL input cannot authorize a local file.
+        void cause;
         return undefined;
     }
     if (url.protocol !== "file:" ||
@@ -21,7 +23,9 @@ export const authorizedElectronFile = async (value) => {
     try {
         path = fileURLToPath(url);
     }
-    catch {
+    catch (cause) {
+        // Unconvertible file URLs cannot authorize a local file.
+        void cause;
         return undefined;
     }
     if (!isAbsolute(path) || path.includes("\0"))
@@ -32,7 +36,9 @@ export const authorizedElectronFile = async (value) => {
             return undefined;
         canonical = await realpath(path);
     }
-    catch {
+    catch (cause) {
+        // Missing or unreadable files cannot authorize a local file.
+        void cause;
         return undefined;
     }
     return canonical;

package/dist/browser/PlaywrightBrowserScenarioProvider.js

@@ -1,5 +1,7 @@
 import { browserScenarioCaptureSchema, classifyBrowserScenarioCompleteness, browserScenarioStepSchema, browserStepArtifactsSchema, } from "../domain/browserScenarioCapture.js";
-import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from "../domain/errors.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { err, ok } from "../domain/result.js";
 const OPERATION = "capture_browser_scenario";
 let defaultFactory;
@@ -9,11 +11,8 @@ const lazyPlaywrightFactory = {
         return (await defaultFactory).open(scenario, options);
     },
 };
-export const PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY = Object.freeze({
-    id: "rea-playwright-browser-scenario",
-    name: "REA Playwright browser scenario capture provider",
-    version: "1",
-});
+export { PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY } from "./providerIdentities.js";
+import { PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY } from "./providerIdentities.js";
 const SNAPSHOT_KINDS = [
     "screenshot",
     "dom",
@@ -187,6 +186,7 @@ const runScenario = async (factory, scenario, options) => {
             start_origin: new URL(scenario.start_url.url).origin,
             action_count: scenario.actions.length,
             secret_references: scenario.secrets.map(({ secret_id: id }) => id).sort(),
+            network_content: scenario.capture.network,
         },
         duration_ms: Date.now() - startedAt,
         steps,
@@ -194,7 +194,10 @@ const runScenario = async (factory, scenario, options) => {
         completeness,
         limitations: [
             "Event sequence records provider receipt order; simultaneous browser causality is not inferred.",
-            "Response bodies are not retained.",
+            "Network content is retained only when selected; response bytes are browser-decoded, not compressed wire bytes.",
+            "Request bytes are limited to what Playwright exposes; not_exposed does not establish body absence or multipart file coverage.",
+            "Network content reads settle within 5 seconds each and never wait for unfinished responses or refetch them.",
+            "Playwright scenario events do not expose request initiator stacks; receipt order does not prove causality.",
             "Storage values are hashed only after declared-secret redaction.",
             ...(session.eventLimitations?.() ?? []),
             ...(session.mode === "connect"

package/dist/browser/PlaywrightElectronActiveActions.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { BrowserObservationError } from "../domain/errors.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
 const OPERATION = "capture_electron_scenario";
 const hookEventSchema = z.strictObject({
     sequence: z.number().int().min(1),

package/dist/browser/PlaywrightElectronActiveProvider.js

@@ -3,19 +3,20 @@ import { dirname } from "node:path";
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { _electron as electron } from "playwright-core";
-import { electronActiveObservationResultSchema, } from "../domain/electronActiveObservation.js";
-import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from "../domain/errors.js";
+import { electronActiveObservationResultSchema, } from "../domain/javascript/electronActiveObservation.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { err, ok } from "../domain/result.js";
-import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, observeOwnedProcessLineage, selectCapturedProcessGroupIds, verifyNoTokenOwnedProcesses, } from "../process/ProcessOwnership.js";
+import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, verifyNoTokenOwnedProcesses, } from "../process/ProcessOwnership.js";
+import { observeOwnedProcessLineage } from "../process/ProcessOwnershipObservation.js";
+import { selectCapturedProcessGroupIds } from "../process/ProcessOwnershipProcessTree.js";
 import { runElectronActions, readApplicationState, runWithExecutionLimits, } from "./PlaywrightElectronActiveActions.js";
 const OPERATION = "capture_electron_scenario";
 const STARTUP_TIMEOUT_MS = 60_000;
 /** Public identity for provider-owned Electron runtime experiments. */
-export const PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY = Object.freeze({
-    id: "rea-playwright-electron-active",
-    name: "REA Playwright active Electron observation provider",
-    version: "1",
-});
+export { PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY } from "./providerIdentities.js";
+import { PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY } from "./providerIdentities.js";
 const hookPath = fileURLToPath(new URL("../../scripts/electron-active-hook.cjs", import.meta.url));
 const observableEventFamilies = [
     "app-lifecycle",

package/dist/browser/PlaywrightExecutionBoundary.js

@@ -1,4 +1,4 @@
-import { AnalysisCancelledError, AnalysisTimeoutError, } from "../domain/errors.js";
+import { AnalysisCancelledError, AnalysisTimeoutError, } from "../domain/analysisErrorCore.js";
 const OPERATION = "capture_browser_scenario";
 export const withPlaywrightExecutionBoundary = (work, timeoutMs, signal) => {
     if (timeoutMs !== undefined && timeoutMs <= 0)