rea-agents 1.4.0 → 1.6.0

package/dist/application/SetupInstallFailure.js

@@ -43,6 +43,30 @@ export const setupInstallFailure = (reason) => {
                 code: "setup_cancelled",
                 remediation: "Setup was cancelled before Hopper was installed. Rerun rea setup when ready.",
             };
+        case "destination_exists":
+            return {
+                status: "failed",
+                code: "destination_exists",
+                remediation: "The Hopper installation destination already exists and was not replaced. Reuse the existing installation or move it aside, then rerun rea setup.",
+            };
+        case "mount":
+            return {
+                status: "failed",
+                code: "mount_failed",
+                remediation: "The verified Hopper disk image could not be mounted. Eject any stale Hopper image, check local disk access, then rerun rea setup.",
+            };
+        case "bundle":
+            return {
+                status: "failed",
+                code: "bundle_invalid",
+                remediation: "The mounted package did not contain the expected Hopper application bundle. Retry setup; if it repeats, update REA before installing.",
+            };
+        case "copy":
+            return {
+                status: "failed",
+                code: "copy_failed",
+                remediation: "The verified Hopper application could not be copied to the installation destination. Check destination permissions and free space, then rerun rea setup.",
+            };
         default:
             return {
                 status: "failed",

package/dist/application/SetupPlan.js

@@ -1,5 +1,5 @@
 /** Build the complete setup mutation plan before approval. */
-export const setupPlan = (platform, installHopper, clients) => [
+export const setupPlan = (platform, installHopper, installSkill, clients) => [
     ...(installHopper
         ? [
             {
@@ -22,10 +22,14 @@ export const setupPlan = (platform, installHopper, clients) => [
         detail: `Add the REA MCP registration for ${client.name}; preserve unrelated configuration.`,
         external: false,
     })),
-    {
-        kind: "install_skill",
-        target: "~/.agents/skills/rea-analysis/SKILL.md",
-        detail: "Install or update the bundled REA analysis skill.",
-        external: false,
-    },
+    ...(installSkill
+        ? [
+            {
+                kind: "install_skill",
+                target: "~/.agents/skills/rea-analysis/SKILL.md",
+                detail: "Install or update the bundled REA analysis skill.",
+                external: false,
+            },
+        ]
+        : []),
 ];

package/dist/application/SetupSkill.js

@@ -2,13 +2,30 @@ import { mkdir, readFile, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import writeFileAtomic from "write-file-atomic";
 import { PRODUCT_IDENTITY } from "../identity.js";
+const canonicalSkillFiles = async (home) => ({
+    destination: join(home, ".agents/skills", PRODUCT_IDENTITY.skillName, "SKILL.md"),
+    content: await readFile(new URL(`../../skills/${PRODUCT_IDENTITY.skillName}/SKILL.md`, import.meta.url), "utf8"),
+});
+/** Report whether setup would change the managed REA skill. */
+export const canonicalSkillNeedsInstall = async (home) => {
+    try {
+        const { content, destination } = await canonicalSkillFiles(home);
+        return (await readFile(destination, "utf8")) !== content;
+    }
+    catch {
+        return true;
+    }
+};
 /** Transactionally install or upgrade the versioned canonical REA skill. */
 export const installCanonicalSkill = async (home) => {
-    const destination = join(home, ".agents/skills", PRODUCT_IDENTITY.skillName, "SKILL.md");
-    const backup = `${destination}.rea.backup`;
+    let destination = join(home, ".agents/skills", PRODUCT_IDENTITY.skillName, "SKILL.md");
+    let backup = `${destination}.rea.backup`;
     let original;
     try {
-        const content = await readFile(new URL(`../../skills/${PRODUCT_IDENTITY.skillName}/SKILL.md`, import.meta.url), "utf8");
+        const canonical = await canonicalSkillFiles(home);
+        destination = canonical.destination;
+        backup = `${destination}.rea.backup`;
+        const { content } = canonical;
         original = await readFile(destination, "utf8").catch(() => undefined);
         if (original === content)
             return "unchanged";

package/dist/application/TerminalRenderer.js

@@ -49,7 +49,7 @@ export class TerminalRenderer {
     /** Await all queued parsing and return immutable rendered observations. */
     async frames() {
         await this.#pending;
-        return this.#frames;
+        return structuredClone(this.#frames);
     }
     /** Whether a rendered observation exceeded its independent capture budget. */
     truncated() {

package/dist/application/Uninstall.js

@@ -1,16 +1,18 @@
-import { copyFile, lstat, readFile, rm } from "node:fs/promises";
+import { copyFile, lstat, readFile, realpath, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, isAbsolute, join } from "node:path";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import writeFileAtomic from "write-file-atomic";
 import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
+import { resolveClientConfigTransactionPath } from "./ClientConfigPath.js";
 import { supportedClients } from "./SupportedClients.js";
 const systemFileSystem = {
     readText: (path) => readFile(path, "utf8"),
     copy: (source, destination) => copyFile(source, destination),
     writeText: (path, contents) => writeFileAtomic(path, contents, { encoding: "utf8" }),
     stat: (path) => lstat(path),
+    realpath: (path) => realpath(path),
     remove: (path) => rm(path, { recursive: true }),
 };
 /** Remove only REA-owned registrations and managed files, optionally including local state. */
@@ -46,9 +48,13 @@ export const systemUninstallHost = (home = homedir(), fileSystem = systemFileSys
 const removeClient = async (client, fileSystem) => {
     if (client.format === "unsupported")
         return item(client.name, "skipped", "This client has no documented local MCP configuration boundary.");
+    const resolved = await resolveUninstallConfigPath(client, fileSystem);
+    if (typeof resolved !== "string")
+        return resolved;
+    const transactionPath = resolved;
     let original;
     try {
-        original = await fileSystem.readText(client.configPath);
+        original = await fileSystem.readText(transactionPath);
     }
     catch (cause) {
         return isMissing(cause)
@@ -76,7 +82,7 @@ const removeClient = async (client, fileSystem) => {
     document[key] = remaining;
     const backupPath = `${client.configPath}.rea.backup`;
     try {
-        await fileSystem.copy(client.configPath, backupPath);
+        await fileSystem.copy(transactionPath, backupPath);
     }
     catch {
         return item(client.name, "failed", "Configuration could not be backed up, so no change was made. Check file permissions, then rerun uninstall.");
@@ -85,17 +91,17 @@ const removeClient = async (client, fileSystem) => {
         const encoded = client.format === "toml"
             ? stringifyToml(document)
             : `${JSON.stringify(document, null, 2)}\n`;
-        await fileSystem.writeText(client.configPath, encoded);
+        await fileSystem.writeText(transactionPath, encoded);
         const readback = objectSchema.parse(client.format === "toml"
-            ? parseToml(await fileSystem.readText(client.configPath))
-            : JSON.parse(await fileSystem.readText(client.configPath)));
+            ? parseToml(await fileSystem.readText(transactionPath))
+            : JSON.parse(await fileSystem.readText(transactionPath)));
         if (PRODUCT_IDENTITY.mcpServerKey in optionalObject(readback[key]))
             throw new Error("registration readback mismatch");
         return item(client.name, "removed", `Removed registration from ${client.configPath}.`);
     }
     catch {
         try {
-            await fileSystem.writeText(client.configPath, original);
+            await fileSystem.writeText(transactionPath, original);
         }
         catch {
             return item(client.name, "failed", "Configuration could not be updated or restored. Restore its `.rea.backup` manually, then rerun uninstall.");
@@ -103,6 +109,13 @@ const removeClient = async (client, fileSystem) => {
         return item(client.name, "failed", "Configuration could not be updated. The original was restored and its `.rea.backup` was retained. Repair the configuration or restore the backup, then rerun uninstall.");
     }
 };
+const resolveUninstallConfigPath = async (client, fileSystem) => {
+    const path = await resolveClientConfigTransactionPath(client.configPath, fileSystem.realpath === undefined
+        ? { lstat: fileSystem.stat }
+        : { lstat: fileSystem.stat, realpath: fileSystem.realpath });
+    return (path ??
+        item(client.name, "failed", "Configuration path could not be safely verified. Check its permissions and, if it is a symbolic link, verify that the link resolves to a regular file owned by the current user, then rerun uninstall."));
+};
 /** Ownership rule for persistent MCP registrations created by REA setup. */
 const isOwnedRegistration = (value) => {
     const parsed = registrationSchema.safeParse(value);

package/dist/application/Upgrade.js

@@ -3,6 +3,7 @@ import { realpath } from "node:fs/promises";
 import { basename, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
+import { gt, valid } from "semver";
 import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
 const execFileAsync = promisify(execFile);
@@ -11,7 +12,17 @@ const UPGRADE_COMMAND = "npm install --global rea-agents@latest";
 /** Check the npm registry and update the same global REA installation. */
 export const runUpgrade = async (currentVersion, host = systemUpgradeHost(), output = "human") => {
     const latestVersion = await host.latestVersion();
-    if (latestVersion === currentVersion)
+    const currentIsValid = valid(currentVersion) !== null;
+    const latestIsValid = latestVersion !== undefined && valid(latestVersion) !== null;
+    if (!currentIsValid || !latestIsValid)
+        return {
+            status: "failed",
+            currentVersion,
+            latestVersion: latestVersion ?? null,
+            reason: "version-check",
+            remediation: "REA could not verify a newer registry release. Check npm registry access and version metadata, then rerun rea upgrade.",
+        };
+    if (!gt(latestVersion, currentVersion))
         return {
             status: "current",
             currentVersion,
@@ -38,8 +49,8 @@ export const runUpgrade = async (currentVersion, host = systemUpgradeHost(), out
     return {
         status: "upgraded",
         previousVersion: currentVersion,
-        latestVersion: latestVersion ?? null,
-        versionCheck: latestVersion === undefined ? "unavailable" : "available",
+        latestVersion,
+        versionCheck: "available",
         installMethod: "npm",
         command: UPGRADE_COMMAND,
         clientRestartRequired: true,

package/dist/artifacts/MachOSliceArtifactReader.js

@@ -59,7 +59,7 @@ export class MachOSliceArtifactReader {
         return Promise.resolve(createReadStream(this.path, { start: offset, end: offset + size - 1 }));
     }
     provenance() {
-        return this.#command === undefined ? [] : [this.#command];
+        return this.#command === undefined ? [] : [structuredClone(this.#command)];
     }
     close() {
         return Promise.resolve();

package/dist/artifacts/NativeDmgArtifactReader.js

@@ -67,7 +67,7 @@ export class NativeDmgArtifactReader {
         return this.#directory.open(entry, signal);
     }
     provenance() {
-        return this.#provenance;
+        return structuredClone(this.#provenance);
     }
     async close() {
         let detachFailure;

package/dist/artifacts/SafeOutputTree.js

@@ -59,7 +59,7 @@ export class SafeOutputTree {
         return this.#outputRoot;
     }
     get cleanup() {
-        return this.#cleanup;
+        return structuredClone(this.#cleanup);
     }
     /** Stream one selected regular file with exact byte and digest verification. */
     async write(relativePath, source, expectedSha256, signal) {
@@ -123,7 +123,7 @@ export class SafeOutputTree {
     /** Remove only this operation's unsealed tree and verify absence. */
     async rollback() {
         if (this.#published)
-            return this.#cleanup;
+            return structuredClone(this.#cleanup);
         await rm(this.#stagingRoot, { recursive: true, force: true });
         const absent = await isAbsent(this.#stagingRoot);
         this.#cleanup = {
@@ -133,7 +133,7 @@ export class SafeOutputTree {
         };
         if (!absent)
             throw new ArtifactReaderFailure("integrity", "Extraction output cleanup could not be verified");
-        return this.#cleanup;
+        return structuredClone(this.#cleanup);
     }
     async #prepareParent(relativePath) {
         const parts = relativePath.split("/");

package/dist/browser/CdpBrowserProvider.js

@@ -0,0 +1,261 @@
+import { browserTargetListSchema, sanitizeBrowserUrl, webPageInspectionSchema, } from "../domain/browserObservation.js";
+import { analyzeCapturedWebBundle } from "../domain/webBundleAnalyzer.js";
+import { webBundleAnalysisSchema, } from "../domain/webBundleAnalysis.js";
+import { webObservationSessionSchema, } from "../domain/browserSession.js";
+import { webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
+import { compareWebCaptures, webCaptureDiffSchema, } from "../domain/webCaptureDiff.js";
+import { webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
+import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from "../domain/errors.js";
+import { err, ok } from "../domain/result.js";
+import { discoverCdpEndpoint, hasCdpTargetWebSocket, } from "./CdpEndpoint.js";
+import { closeCdpTargetSession, openCdpTargetSession, } from "./CdpTargetSession.js";
+import { capturePage } from "./CdpPageCapture.js";
+import { fetchWebSourceMaps } from "./WebSourceMapFetcher.js";
+import { observeCdpSession } from "./CdpObservationSession.js";
+import { discoverWebMcp } from "./CdpWebMcpDiscovery.js";
+import { captureCdpScreenshot } from "./CdpScreenshot.js";
+import { comparePngScreenshots } from "./PngVisualDiff.js";
+const IDENTITY = {
+    id: "rea-cdp-browser",
+    name: "REA Chrome DevTools Protocol observation provider",
+    version: "2",
+};
+const CLEANUP_DOMAINS = ["Network", "Debugger", "Runtime", "Page"];
+/** Passive, origin-scoped browser observation through a user-owned CDP endpoint. */
+export class CdpBrowserProvider {
+    identity() {
+        return IDENTITY;
+    }
+    async listTargets(input, options = {}) {
+        try {
+            const discovery = await discoverCdpEndpoint(input.cdp_endpoint, "list_browser_targets", options.signal);
+            const allowedOrigins = new Set(input.allowed_origins);
+            const selected = selectTargets(discovery, allowedOrigins);
+            const items = selected.allowed.slice(input.offset, input.offset + input.limit);
+            const nextOffset = input.offset + items.length;
+            return ok(browserTargetListSchema.parse({
+                schema_version: 1,
+                browser: discovery.version,
+                targets: {
+                    items,
+                    offset: input.offset,
+                    limit: input.limit,
+                    total: selected.allowed.length,
+                    next_offset: nextOffset < selected.allowed.length ? nextOffset : null,
+                    has_more: nextOffset < selected.allowed.length,
+                },
+                excluded: selected.excluded,
+                limitations: [
+                    "Only page targets whose current URL matches an approved exact origin are listed.",
+                    ...(selected.unconnectable === 0
+                        ? []
+                        : [
+                            `${String(selected.unconnectable)} otherwise allowed page target(s) lacked a validated direct CDP WebSocket and were excluded.`,
+                        ]),
+                ],
+            }));
+        }
+        catch (cause) {
+            return err(providerError(cause, "list_browser_targets"));
+        }
+    }
+    async inspectPage(input, options = {}) {
+        try {
+            const captured = await this.#capture(input, options, "inspect_web_page");
+            return ok(webPageInspectionSchema.parse(captured.inspection));
+        }
+        catch (cause) {
+            return err(providerError(cause, "inspect_web_page"));
+        }
+    }
+    async analyzeBundle(input, options = {}) {
+        try {
+            const captured = await this.#capture(input, options, "analyze_web_bundle");
+            const sourceMaps = input.fetch_source_maps
+                ? await fetchWebSourceMaps(captured.sourceMapRequests, input, options.signal)
+                : undefined;
+            return ok(webBundleAnalysisSchema.parse(analyzeCapturedWebBundle(captured.inspection, input, sourceMaps)));
+        }
+        catch (cause) {
+            return err(providerError(cause, "analyze_web_bundle"));
+        }
+    }
+    async observeSession(input, options = {}) {
+        let targetSession;
+        try {
+            const discovery = await discoverCdpEndpoint(input.cdp_endpoint, "observe_web_session", options.signal);
+            const target = authorizeTarget(discovery, input);
+            targetSession = await openCdpTargetSession(discovery, target, "observe_web_session", options.signal);
+            return ok(webObservationSessionSchema.parse(await observeCdpSession({
+                connection: targetSession.connection,
+                sessionId: targetSession.sessionId,
+                discovery,
+                target,
+                input,
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+                ...(options.progress === undefined
+                    ? {}
+                    : { progress: options.progress }),
+            })));
+        }
+        catch (cause) {
+            return err(providerError(cause, "observe_web_session"));
+        }
+        finally {
+            if (targetSession !== undefined)
+                await closeCdpTargetSession(targetSession, CLEANUP_DOMAINS);
+        }
+    }
+    async discoverWebMcpTools(input, options = {}) {
+        let targetSession;
+        try {
+            const discovery = await discoverCdpEndpoint(input.cdp_endpoint, "discover_webmcp_tools", options.signal);
+            const target = authorizeTarget(discovery, input);
+            targetSession = await openCdpTargetSession(discovery, target, "discover_webmcp_tools", options.signal);
+            return ok(webMcpDiscoverySchema.parse(await discoverWebMcp({
+                connection: targetSession.connection,
+                sessionId: targetSession.sessionId,
+                discovery,
+                target,
+                input,
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+                ...(options.progress === undefined
+                    ? {}
+                    : { progress: options.progress }),
+            })));
+        }
+        catch (cause) {
+            return err(providerError(cause, "discover_webmcp_tools"));
+        }
+        finally {
+            if (targetSession !== undefined)
+                await closeCdpTargetSession(targetSession, CLEANUP_DOMAINS);
+        }
+    }
+    async compareCaptures(input) {
+        try {
+            return ok(webCaptureDiffSchema.parse(compareWebCaptures(input)));
+        }
+        catch (cause) {
+            return err(providerError(cause, "compare_web_captures"));
+        }
+    }
+    async captureScreenshot(input, options = {}) {
+        let targetSession;
+        try {
+            const discovery = await discoverCdpEndpoint(input.cdp_endpoint, "capture_web_screenshot", options.signal);
+            const target = authorizeTarget(discovery, input);
+            targetSession = await openCdpTargetSession(discovery, target, "capture_web_screenshot", options.signal);
+            return ok(webScreenshotSchema.parse(await captureCdpScreenshot({
+                connection: targetSession.connection,
+                sessionId: targetSession.sessionId,
+                discovery,
+                target,
+                input,
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+                ...(options.progress === undefined
+                    ? {}
+                    : { progress: options.progress }),
+            })));
+        }
+        catch (cause) {
+            return err(providerError(cause, "capture_web_screenshot"));
+        }
+        finally {
+            if (targetSession !== undefined)
+                await closeCdpTargetSession(targetSession, CLEANUP_DOMAINS);
+        }
+    }
+    async compareScreenshots(input) {
+        try {
+            return ok(webScreenshotDiffSchema.parse(comparePngScreenshots(input)));
+        }
+        catch (cause) {
+            return err(providerError(cause, "compare_web_screenshots"));
+        }
+    }
+    async #capture(input, options, operation) {
+        let targetSession;
+        try {
+            const discovery = await discoverCdpEndpoint(input.cdp_endpoint, operation, options.signal);
+            const target = authorizeTarget(discovery, input);
+            targetSession = await openCdpTargetSession(discovery, target, operation, options.signal);
+            return await capturePage({
+                connection: targetSession.connection,
+                sessionId: targetSession.sessionId,
+                operation,
+                discovery,
+                target,
+                input,
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+                ...(options.progress === undefined
+                    ? {}
+                    : { progress: options.progress }),
+            });
+        }
+        finally {
+            if (targetSession !== undefined)
+                await closeCdpTargetSession(targetSession, CLEANUP_DOMAINS);
+        }
+    }
+}
+const selectTargets = (discovery, allowedOrigins) => {
+    const allowed = [];
+    let disallowedOrigin = 0;
+    let unsupportedUrl = 0;
+    let nonPage = 0;
+    let unconnectable = 0;
+    for (const target of discovery.targets) {
+        if (target.type !== "page") {
+            nonPage += 1;
+            continue;
+        }
+        const url = sanitizeBrowserUrl(target.url);
+        if (url.origin === null) {
+            unsupportedUrl += 1;
+            continue;
+        }
+        if (!allowedOrigins.has(url.origin)) {
+            disallowedOrigin += 1;
+            continue;
+        }
+        if (!hasCdpTargetWebSocket(discovery, target)) {
+            unconnectable += 1;
+            continue;
+        }
+        allowed.push({
+            target_id: target.id,
+            type: target.type,
+            title: target.title.slice(0, 16_384),
+            url: url.url,
+            origin: url.origin,
+            attached: target.attached,
+        });
+    }
+    allowed.sort((left, right) => left.target_id.localeCompare(right.target_id));
+    return {
+        allowed,
+        excluded: {
+            disallowed_origin: disallowedOrigin,
+            unsupported_url: unsupportedUrl,
+            non_page: nonPage,
+        },
+        unconnectable,
+    };
+};
+const authorizeTarget = (discovery, input) => {
+    const target = discovery.targets.find((candidate) => candidate.id === input.target_id);
+    if (target === undefined)
+        throw new BrowserObservationError("inspect_web_page", "target_not_found");
+    const origin = sanitizeBrowserUrl(target.url).origin;
+    if (target.type !== "page" ||
+        origin === null ||
+        !input.allowed_origins.includes(origin))
+        throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
+    return target;
+};
+const providerError = (cause, operation) => cause instanceof BrowserObservationError && cause.operation !== operation
+    ? new BrowserObservationError(operation, cause.reason, { cause })
+    : cause instanceof AnalysisError
+        ? cause
+        : new ProviderAdapterError(IDENTITY.id, operation, { cause });

package/dist/browser/CdpCaptureCompleteness.js

@@ -0,0 +1,90 @@
+import { classifyBrowserCompleteness, } from "../domain/browserCompleteness.js";
+const EVENT_SECTIONS = {
+    scripts: "scripts",
+    network_requests: "network_requests",
+    console_events: "console_events",
+    websocket_connections: "websocket_connections",
+    websocket_frames: "websocket_frames",
+    webmcp_tools: "webmcp_tools",
+    timeline_events: "timeline",
+};
+const POLICY_REASONS = new Set([
+    "disallowed_origin",
+    "unsupported_url",
+    "unattributed_origin",
+    "not_approved",
+    "out_of_target_scope",
+]);
+/** Mutable adapter ledger projected into immutable, canonical completeness v2. */
+export class CdpCaptureCompleteness {
+    #initialAttachLimited;
+    #policyFiltered = new Set();
+    #attachLimited = new Set();
+    #truncated = new Set();
+    #unavailable = new Set();
+    #excluded = new Map();
+    #dropped = emptyDropped();
+    constructor(initialAttachLimited = []) {
+        this.#initialAttachLimited = [...initialAttachLimited];
+        this.reset();
+    }
+    reset() {
+        this.#policyFiltered.clear();
+        this.#attachLimited.clear();
+        this.#truncated.clear();
+        this.#unavailable.clear();
+        this.#excluded.clear();
+        Object.assign(this.#dropped, emptyDropped());
+        for (const section of this.#initialAttachLimited)
+            this.#attachLimited.add(section);
+    }
+    exclude(section, reason, count = 1) {
+        if (POLICY_REASONS.has(reason))
+            this.#policyFiltered.add(section);
+        if (reason === "provider_unavailable" ||
+            reason === "invalid_protocol_value")
+            this.#unavailable.add(section);
+        const key = `${section}\0${reason}`;
+        const existing = this.#excluded.get(key);
+        const combined = count === null || existing?.count === null
+            ? null
+            : (existing?.count ?? 0) + count;
+        this.#excluded.set(key, { section, reason, count: combined });
+    }
+    attachLimited(section) {
+        this.#attachLimited.add(section);
+    }
+    unavailable(section) {
+        this.#unavailable.add(section);
+        this.exclude(section, "provider_unavailable", null);
+    }
+    truncate(section) {
+        this.#truncated.add(section);
+    }
+    drop(kind, count = 1) {
+        this.#dropped[kind] += count;
+        this.#truncated.add(EVENT_SECTIONS[kind]);
+    }
+    get droppedTotal() {
+        return Object.values(this.#dropped).reduce((sum, count) => sum + count, 0);
+    }
+    snapshot() {
+        return classifyBrowserCompleteness({
+            policyFilteredSections: this.#policyFiltered,
+            attachLimitedSections: this.#attachLimited,
+            truncatedSections: this.#truncated,
+            unavailableSections: this.#unavailable,
+            excluded: [...this.#excluded.values()],
+            droppedEvents: this.#dropped,
+        });
+    }
+}
+const emptyDropped = () => ({
+    scripts: 0,
+    network_requests: 0,
+    console_events: 0,
+    websocket_connections: 0,
+    websocket_frames: 0,
+    webmcp_tools: 0,
+    timeline_events: 0,
+});