rea-agents 4.0.1 → 4.1.0

package/dist/artifacts/ArtifactProvider.js

@@ -6,7 +6,9 @@ import { extractArtifact } from "../application/ArtifactExtraction.js";
 import { analyzeInterfaceBuilderBundle } from "../application/InterfaceBuilderAnalysis.js";
 import { analyzeAppleAssetCatalogs } from "../application/AppleAssetCatalogAnalysis.js";
 import { ARTIFACT_ANALYSIS_OPERATIONS, artifactInventoryInputSchema, artifactExtractionExecutionSchema, } from "../contracts/artifactToolContracts.js";
-import { AnalysisCapabilityUnavailableError, ArtifactOperationError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
+import { ArtifactOperationError } from "../domain/artifactOperationError.js";
+import {} from "../domain/analysisErrorBase.js";
 import { interfaceBuilderLimitsSchema } from "../domain/interfaceBuilderGraph.js";
 import { err, ok } from "../domain/result.js";
 import { ArtifactReaderFailure } from "./ArtifactReader.js";

package/dist/artifacts/DirectoryArtifactReader.js

@@ -25,6 +25,7 @@ export class DirectoryArtifactReader {
                     children.push(child.name);
             }
             finally {
+                // best-effort cleanup: directory-handle close must not mask traversal.
                 await handle.close().catch(() => undefined);
             }
             await assertContainedDirectory(root, directory);
@@ -85,6 +86,7 @@ export class DirectoryArtifactReader {
             return handle.createReadStream({ autoClose: true });
         }
         catch (cause) {
+            // best-effort cleanup: file-handle close must not mask the open failure.
             await handle.close().catch(() => undefined);
             throw cause;
         }

package/dist/artifacts/NativeDmgArtifactReader.js

@@ -1,4 +1,4 @@
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp, realpath, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { parse } from "plist";
@@ -91,7 +91,7 @@ export class NativeDmgArtifactReader {
     async attach(signal) {
         await runChecked(this.host, ["verify", this.path], signal);
         this.#provenance.push(command(["verify", this.path], ["read"]));
-        this.#mountRoot = await mkdtemp(join(tmpdir(), "rea-dmg-"));
+        this.#mountRoot = await realpath(await mkdtemp(join(tmpdir(), "rea-dmg-")));
         try {
             const attached = await runChecked(this.host, [
                 "attach",
@@ -103,7 +103,14 @@ export class NativeDmgArtifactReader {
                 this.path,
             ], signal);
             const parsed = attachOutputSchema.parse(parse(attached.stdout));
-            this.#devices = parsed["system-entities"].map((entity) => entity["dev-entry"]);
+            const devices = [
+                ...new Set(parsed["system-entities"].map((entity) => entity["dev-entry"])),
+            ];
+            // Detaching an observed whole disk also detaches its partitions. Do not
+            // subsequently detach the now-unavailable child devices.
+            this.#devices = devices.filter((device) => !devices.some((parent) => /^\/dev\/disk\d+$/u.test(parent) &&
+                device.startsWith(`${parent}s`) &&
+                /^\d+$/u.test(device.slice(parent.length + 1))));
             if (this.#devices.length === 0)
                 throw new ArtifactReaderFailure("format", "hdiutil returned no attached devices");
             for (const entity of parsed["system-entities"])

package/dist/artifacts/NibArchive.js

@@ -231,8 +231,10 @@ const decodeUtf8 = (bytes, start, end, label) => {
     try {
         return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(start, end));
     }
-    catch {
-        throw new TypeError(`NIBArchive ${label} is not valid UTF-8`);
+    catch (cause) {
+        throw new TypeError(`NIBArchive ${label} is not valid UTF-8`, {
+            cause,
+        });
     }
 };
 const readVarint = (bytes, cursor, end) => {

package/dist/artifacts/SafeOutputTree.js

@@ -7,17 +7,25 @@ import { ArtifactPathRegistry, normalizeArtifactPath, } from "./ArtifactPaths.js
 import { ArtifactReaderFailure } from "./ArtifactReader.js";
 /** Symlink-resistant materialization in an exclusively owned, initially absent tree. */
 export class SafeOutputTree {
+    platform;
     #registry = new ArtifactPathRegistry();
     #outputRoot;
     #published = false;
     #cleanup = {
         status: "not-required",
     };
-    constructor(outputRoot) {
+    constructor(outputRoot, platform) {
+        this.platform = platform;
         this.#outputRoot = outputRoot;
     }
-    /** Exclusively create the absent destination as this operation's owned tree. */
-    static async create(outputRoot) {
+    /**
+     * Exclusively create the absent destination as this operation's owned tree.
+     *
+     * POSIX mode bits and directory `fchmod`/`fsync` have no Windows equivalent:
+     * `mkdir` already applies the requested mode, so the redundant handle
+     * `chmod` is skipped there to avoid an `EPERM` on the directory descriptor.
+     */
+    static async create(outputRoot, platform = process.platform) {
         if (!isAbsolute(outputRoot))
             throw new ArtifactReaderFailure("path", "Extraction output root must be absolute");
         const requested = resolve(outputRoot);
@@ -34,14 +42,16 @@ export class SafeOutputTree {
             throw cause;
         });
         try {
-            const stagingHandle = await open(canonicalOutput, constants.O_RDONLY | constants.O_DIRECTORY);
-            try {
-                await stagingHandle.chmod(0o700);
+            if (platform !== "win32") {
+                const stagingHandle = await open(canonicalOutput, constants.O_RDONLY | constants.O_DIRECTORY);
+                try {
+                    await stagingHandle.chmod(0o700);
+                }
+                finally {
+                    await stagingHandle.close();
+                }
             }
-            finally {
-                await stagingHandle.close();
-            }
-            return new SafeOutputTree(canonicalOutput);
+            return new SafeOutputTree(canonicalOutput, platform);
         }
         catch (cause) {
             await rm(canonicalOutput, { recursive: true, force: true });
@@ -87,6 +97,7 @@ export class SafeOutputTree {
             return { relativePath: path, sha256, bytesWritten: bytes };
         }
         catch (cause) {
+            // best-effort cleanup: file-handle close must not mask the write failure.
             await handle.close().catch(() => undefined);
             throw cause;
         }
@@ -94,6 +105,11 @@ export class SafeOutputTree {
     /** Sync the owned output tree and prevent further writes through this instance. */
     async commit() {
         this.#assertWritable();
+        // Windows has no directory fsync; file contents are already synced in write().
+        if (this.platform === "win32") {
+            this.#published = true;
+            return;
+        }
         const parent = await open(dirname(this.#outputRoot), constants.O_RDONLY | constants.O_DIRECTORY);
         let output;
         try {

package/dist/artifacts/ZipArtifactReader.js

@@ -71,6 +71,7 @@ export class ZipArtifactReader {
         return Promise.resolve(extractStream(stored, signal));
     }
     async close() {
+        // best-effort cleanup: zip-reader close must not mask prior extraction state.
         await this.#reader.close().catch(() => undefined);
         await this.#source.closeHandle();
     }

package/dist/browser/BrowserProcessStartup.js

@@ -79,7 +79,9 @@ const readDevtoolsPort = async (path) => {
             ? port
             : null;
     }
-    catch {
+    catch (cause) {
+        // Missing or unreadable port files mean the port is unknown.
+        void cause;
         return null;
     }
 };

package/dist/browser/CdpAuthorizedMainFrame.js

@@ -1,4 +1,4 @@
-import { BrowserObservationError } from "../domain/errors.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { mainFrameUrl } from "./CdpCaptureDocuments.js";
 import { allowedSanitizedUrl, delayWithCancellation, isHttpUrl, } from "./CdpCaptureValues.js";
 /** Wait for the attached target's main frame to enter its approved origin. */

package/dist/browser/CdpBrowserProvider.js

@@ -5,7 +5,10 @@ import { webObservationSessionSchema, } from "../domain/browserSession.js";
 import { webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
 import { browserCaptureComparisonSchema, compareBrowserCaptures, } from "../domain/browserCaptureComparison.js";
 import { webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.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 {} from "../domain/browserObservationErrors.js";
 import { err, ok } from "../domain/result.js";
 import { discoverCdpEndpoint, hasCdpTargetWebSocket, } from "./CdpEndpoint.js";
 import { closeCdpTargetSession, openCdpTargetSession, } from "./CdpTargetSession.js";

package/dist/browser/CdpCaptureDocuments.js

@@ -312,7 +312,9 @@ const domDestination = (value, documentUrl, allowedOrigins) => {
             scope: "approved",
         };
     }
-    catch {
+    catch (cause) {
+        // Unparseable URLs are out of scope, not failures.
+        void cause;
         return { url: null, scope: "unsupported" };
     }
 };

package/dist/browser/CdpCaptureEventHandlers.js

@@ -55,7 +55,9 @@ const sourceMapForScript = (value, scriptUrl, state) => {
     try {
         rawUrl = new URL(declaredUrl, scriptUrl).href;
     }
-    catch {
+    catch (cause) {
+        // Unparseable URLs are recorded as unsupported, not as failures.
+        void cause;
         state.completeness.exclude("source_maps", "unsupported_url");
         return { sanitized: null, raw: null };
     }
@@ -240,7 +242,9 @@ export const handleWebSocketCreated = (state, params) => {
     try {
         parsed = new URL(rawUrl);
     }
-    catch {
+    catch (cause) {
+        // Unparseable URLs are recorded as unsupported, not as failures.
+        void cause;
         state.completeness.exclude("websocket_connections", "unsupported_url");
         return;
     }

package/dist/browser/CdpCaptureStorageFingerprints.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
+import { compareCodePoints } from "../domain/canonicalOrdering.js";
 import { CdpConnection } from "./CdpConnection.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 import { recordValue, recordsValue, stringValue } from "./CdpCaptureValues.js";
@@ -315,4 +316,3 @@ const decodeBase64 = (value) => {
         return null;
     return Buffer.from(value, "base64");
 };
-const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/browser/CdpCaptureValues.js

@@ -1,4 +1,6 @@
-import { AnalysisCancelledError, BrowserObservationError, } from "../domain/errors.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import {} from "../domain/browserObservationErrors.js";
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { createWebTextArtifact } from "../domain/webContentArtifact.js";
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -24,7 +26,9 @@ export const isHttpUrl = (value) => {
         const protocol = new URL(value).protocol;
         return protocol === "http:" || protocol === "https:";
     }
-    catch {
+    catch (cause) {
+        // Non-URL input is not an HTTP URL.
+        void cause;
         return false;
     }
 };

package/dist/browser/CdpConnection.js

@@ -1,5 +1,9 @@
 import WebSocket, {} from "ws";
-import { AnalysisCancelledError, AnalysisError, BrowserObservationError, } from "../domain/errors.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import {} from "../domain/browserObservationErrors.js";
+import { safeParseJson } from "../domain/safeJson.js";
 /** Correlated JSON-RPC transport for one CDP target operation. */
 export class CdpConnection {
     socket;
@@ -107,14 +111,12 @@ export class CdpConnection {
         });
     }
     #receive(data) {
-        let message;
-        try {
-            message = JSON.parse(rawText(data));
-        }
-        catch {
+        const parsed = safeParseJson(rawText(data));
+        if (!parsed.ok) {
             this.#failPending("protocol_error");
             return;
         }
+        const message = parsed.value;
         if (!isRecord(message)) {
             this.#failPending("protocol_error");
             return;

package/dist/browser/CdpElectronInspection.js

@@ -1,6 +1,6 @@
-import { BrowserObservationError } from "../domain/errors.js";
+import { canonicalDigest } from "../domain/comparisonSemantics.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { canonicalJsonDigest } from "./CdpCanonicalJsonDigest.js";
 import { delayWithCancellation, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
 import { walkFrameTrees } from "./CdpCaptureDocuments.js";
 import { ingestElectronScriptEvent, } from "./CdpElectronScriptEvents.js";
@@ -176,7 +176,7 @@ const captureResources = async (context, completeness) => {
                     ? null
                     : Math.max(0, numberValue(resource.contentSize) ?? 0),
             };
-            const resourceKey = `electron_resource_${canonicalJsonDigest(item)}`;
+            const resourceKey = `electron_resource_${canonicalDigest(item, "CDP capture")}`;
             if (seen.has(resourceKey))
                 continue;
             seen.add(resourceKey);

package/dist/browser/CdpElectronProvider.js

@@ -1,5 +1,8 @@
 import { electronPageInspectionSchema, electronTargetListSchema, } from "../domain/electronObservation.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 {} from "../domain/browserObservationErrors.js";
 import { err, ok } from "../domain/result.js";
 import { discoverCdpEndpoint, hasCdpTargetWebSocket, } from "./CdpEndpoint.js";
 import { closeCdpTargetSession, openCdpTargetSession, } from "./CdpTargetSession.js";

package/dist/browser/CdpElectronScripts.js

@@ -1,6 +1,6 @@
+import { canonicalDigest } from "../domain/comparisonSemantics.js";
 import { createWebTextArtifact } from "../domain/webContentArtifact.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { canonicalJsonDigest } from "./CdpCanonicalJsonDigest.js";
 import { requiredRecord, stringValue } from "./CdpCaptureValues.js";
 import { authorizedElectronFile } from "./ElectronFileScope.js";
 /** Normalize local script metadata and optionally approved source. */
@@ -27,7 +27,7 @@ export const captureElectronScripts = async (input) => {
             is_module: script.isModule,
             language: script.language,
         };
-        const scriptKey = `electron_script_${canonicalJsonDigest(identity)}`;
+        const scriptKey = `electron_script_${canonicalDigest(identity, "CDP capture")}`;
         if (seen.has(scriptKey))
             continue;
         seen.add(scriptKey);

package/dist/browser/CdpEndpoint.js

@@ -1,7 +1,11 @@
 import { request } from "node:http";
 import { z } from "zod";
-import { AnalysisCancelledError, AnalysisError, BrowserObservationError, } from "../domain/errors.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
+import {} from "../domain/browserObservationErrors.js";
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
+import { safeParseJson } from "../domain/safeJson.js";
 const endpointVersionSchema = z.object({
     Browser: z.string().min(1),
     "Protocol-Version": z.string().min(1),
@@ -49,7 +53,9 @@ const sanitizeTargetTitle = (value, targetUrl) => {
     try {
         url = new URL(value);
     }
-    catch {
+    catch (cause) {
+        // Non-URL titles fall back to alias redaction.
+        void cause;
         return sanitizeTargetUrlAlias(value, targetUrl);
     }
     return url.protocol === "http:" || url.protocol === "https:"
@@ -61,7 +67,9 @@ const sanitizeTargetUrlAlias = (value, targetUrl) => {
     try {
         parsed = new URL(targetUrl);
     }
-    catch {
+    catch (cause) {
+        // Without a parseable target URL there is nothing to redact.
+        void cause;
         return value;
     }
     const markers = [parsed.origin, `//${parsed.host}`, parsed.host];
@@ -79,7 +87,9 @@ const sanitizeSameOriginTitleUrl = (candidate, target) => {
                 ? new URL(`${target.protocol}//${candidate}`)
                 : new URL(candidate, target.origin);
     }
-    catch {
+    catch (cause) {
+        // Unparseable candidates are preserved verbatim.
+        void cause;
         return candidate;
     }
     return parsed.origin === target.origin &&
@@ -164,7 +174,9 @@ const targetWebSocket = (endpoint, target, operation) => {
             ? { webSocket }
             : {};
     }
-    catch {
+    catch (cause) {
+        // Endpoint validation failures mean no validated transport exists.
+        void cause;
         return {};
     }
 };
@@ -183,12 +195,12 @@ export const readCdpJson = async (url, operation, signal) => await new Promise((
         const chunks = [];
         response.on("data", (chunk) => chunks.push(chunk));
         response.on("end", () => {
-            try {
-                resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
-            }
-            catch (cause) {
-                reject(new BrowserObservationError(operation, "invalid_endpoint_response", { cause }));
+            const parsed = safeParseJson(Buffer.concat(chunks).toString("utf8"));
+            if (!parsed.ok) {
+                reject(new BrowserObservationError(operation, "invalid_endpoint_response", { cause: parsed.cause }));
+                return;
             }
+            resolve(parsed.value);
         });
         response.on("error", (cause) => reject(endpointFailure(cause, operation, signal)));
     });

package/dist/browser/CdpObservationSession.js

@@ -1,4 +1,5 @@
-import { AnalysisCancelledError, BrowserObservationError, } from "../domain/errors.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { CdpConnection } from "./CdpConnection.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
 import { authorizedMainFrame } from "./CdpAuthorizedMainFrame.js";

package/dist/browser/CdpOptionalCommand.js

@@ -1,4 +1,4 @@
-import { BrowserObservationError } from "../domain/errors.js";
+import { BrowserObservationError } from "../domain/browserObservationError.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) => {

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";

package/dist/browser/CdpSafeMetadata.js

@@ -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) => {
@@ -155,7 +196,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 +215,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 [];
     }
 };

package/dist/browser/CdpScreenshot.js

@@ -1,5 +1,5 @@
 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 { mainFrameUrl } from "./CdpCaptureDocuments.js";

package/dist/browser/CdpTargetSession.js

@@ -1,4 +1,5 @@
-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. */
@@ -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,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { inferJsonShape } from "../domain/jsonShape.js";
 import { CdpCaptureCompleteness } from "./CdpCaptureCompleteness.js";
-import { BrowserObservationError } from "../domain/errors.js";
+import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { allowedSanitizedUrl, delayWithCancellation, numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
 import { captureFrames, mainFrameUrl, walkFrameTrees, } from "./CdpCaptureDocuments.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";

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/JavaScriptRuntimeScope.js

@@ -18,7 +18,9 @@ export const authorizeRuntimeLocation = async (value) => {
     try {
         url = new URL(value);
     }
-    catch {
+    catch (cause) {
+        // Non-URL input is outside the authorized runtime scope.
+        void cause;
         return { allowed: false, reason: "unsupported_location" };
     }
     if (!["http:", "https:"].includes(url.protocol))

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;

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),