@monotykamary/localterm-server 2.66.8 → 2.66.10

package/dist/cdp/cdp-client.js

@@ -14,82 +14,43 @@
  * reconnects on the next open; when no browser is reachable, `openBackgroundTab`
  * resolves null so the caller can fall back to the OS opener.
  */
-import { randomUUID } from "node:crypto";
+import { CdpConnection, CdpReplyError } from "./cdp-connection.js";
+import { CDP_CLOSE_SETTLE_MS } from "./constants.js";
 import { detectChromiumBrowsers } from "./detect-chromium.js";
-import { dismissDiaAllowPrompt } from "../utils/dismiss-dia-allow-prompt.js";
-import { CDP_AUTO_ALLOW_DELAY_MS, CDP_HEARTBEAT_GRACE_MS, CDP_HEARTBEAT_INTERVAL_MS, CDP_HEARTBEAT_TIMEOUT_MS, LOCALTERM_TAB_TOKEN_EVENT, LOCALTERM_TAB_TOKEN_PROPERTY, } from "../constants.js";
-const WS_OPEN = 1; // WebSocket.OPEN
-const WS_CONNECTING = 0; // WebSocket.CONNECTING
-// Cheap browser-level CDP round-trip used as a transport liveness probe by the
-// keepalive: no session, no side effects, minimal reply.
-const CDP_HEARTBEAT_PROBE_METHOD = "Target.getTargets";
-const DEFAULT_CONNECT_TIMEOUT_MS = 5_000;
-const DEFAULT_CALL_TIMEOUT_MS = 5_000;
-// Give the browser a beat to process window.close() before tearing down the
-// CDP target — some Chromium forks (Dia, Arc) leave the tab in the strip
-// otherwise (see browser-harness-js closeTab).
-const CLOSE_SETTLE_MS = 100;
-/** A CDP error *reply* — the browser answered a call with an error result (e.g.
- * "No target with given id found"), as opposed to a transport drop or a call
- * timeout. A reply leaves the persistent socket healthy, so the open/close
- * teardown paths must NOT tear it down on a reply: that would drop the one
- * socket kept for the daemon's lifetime and force a reconnect, which re-fires
- * the browser's remote-debugging consent dialog on every automation run. */
-class CdpReplyError extends Error {
-}
+import { TargetRegistry } from "./target-registry.js";
 export class CdpClient {
-    ws;
     connecting;
-    nextId = 1;
-    pending = new Map();
     detect;
-    connectTimeoutMs;
-    callTimeoutMs;
-    heartbeatIntervalMs;
-    heartbeatTimeoutMs;
-    heartbeatGraceMs;
-    autoAllow;
-    autoAllowDelayMs;
-    dismissDiaAllowPrompt;
-    platform;
-    /** Timestamp of the last inbound CDP frame (reply or event). */
-    lastReplyAt = 0;
-    /** Background keepalive timer; unref'd so it never blocks daemon shutdown. */
-    heartbeatTimer;
+    connection;
+    targetRegistry;
     /** Serializes closeTab() so concurrent closes don't orphan tabs. */
     closeQueue = Promise.resolve();
     /** The browser the live socket is attached to, for diagnostics. */
     connectedBrowser;
-    tabUrlFilter;
-    // Ambient tab provenance. The CDP-injected `token` <-> `targetId` pairs let
-    // the WS server match a localterm WS socket (which echoes the token back in
-    // its `{type:"identify"}` message) to the browser tab it belongs to, so
-    // onExit can drive closeTab on the right target without any open-path
-    // coordination. One entry per page-type target on our origin; cleared
-    // whenever the socket drops (a fresh browser session invalidates every
-    // prior targetId).
-    tokenToTargetId = new Map();
-    targetIdToToken = new Map();
-    // Event routing. CDP delivers events as `{ method, params, sessionId? }`
-    // with no `id`; browser-level events (Target.targetCreated etc.) have no
-    // sessionId, session-scoped events carry theirs. We key by
-    // `${sessionId ?? ""}:${method}` so browser and session events never collide.
-    eventHandlers = new Map();
     constructor(options = {}) {
         this.detect = options.detect ?? detectChromiumBrowsers;
-        this.connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
-        this.callTimeoutMs = options.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
-        this.heartbeatIntervalMs = options.heartbeatIntervalMs ?? CDP_HEARTBEAT_INTERVAL_MS;
-        this.heartbeatTimeoutMs = options.heartbeatTimeoutMs ?? CDP_HEARTBEAT_TIMEOUT_MS;
-        this.heartbeatGraceMs = options.heartbeatGraceMs ?? CDP_HEARTBEAT_GRACE_MS;
-        this.autoAllow = options.autoAllow ?? true;
-        this.autoAllowDelayMs = options.autoAllowDelayMs ?? CDP_AUTO_ALLOW_DELAY_MS;
-        this.dismissDiaAllowPrompt = options.dismissDiaAllowPrompt ?? dismissDiaAllowPrompt;
-        this.platform = options.platform ?? process.platform;
-        this.tabUrlFilter = options.tabUrlFilter;
+        this.connection = new CdpConnection({
+            connectTimeoutMs: options.connectTimeoutMs,
+            callTimeoutMs: options.callTimeoutMs,
+            heartbeatIntervalMs: options.heartbeatIntervalMs,
+            heartbeatTimeoutMs: options.heartbeatTimeoutMs,
+            heartbeatGraceMs: options.heartbeatGraceMs,
+            autoAllow: options.autoAllow,
+            autoAllowDelayMs: options.autoAllowDelayMs,
+            dismissDiaAllowPrompt: options.dismissDiaAllowPrompt,
+            platform: options.platform,
+            onDisconnect: () => {
+                this.connectedBrowser = undefined;
+                this.targetRegistry.clear();
+            },
+        });
+        this.targetRegistry = new TargetRegistry({
+            connection: this.connection,
+            tabUrlFilter: options.tabUrlFilter,
+        });
     }
     isConnected() {
-        return this.ws?.readyState === WS_OPEN;
+        return this.connection.isConnected();
     }
     /**
      * Ensure a live socket, detecting and attaching to the most-recently-launched
@@ -114,13 +75,13 @@ export class CdpClient {
         const errors = [];
         for (const browser of browsers) {
             try {
-                await this.openSocket(browser.wsUrl, browser.name);
+                await this.connection.open(browser.wsUrl, browser.name);
                 this.connectedBrowser = browser;
                 // Kick off ambient tab observation on the live socket. Fire-and-get:
                 // discovery fails soft (closeTab falls back to window.close()), and the
                 // connect() promise should resolve as soon as the socket is usable,
                 // not wait on the first Target.setDiscoverTargets round-trip.
-                void this.observeTargets().catch(() => {
+                void this.targetRegistry.observeTargets().catch(() => {
                     /* discovery is best-effort; tabs fall back to window.close() */
                 });
                 return;
@@ -131,240 +92,6 @@ export class CdpClient {
         }
         throw new Error(`no detected browser accepted a connection (${errors.join("; ")})`);
     }
-    openSocket(wsUrl, browserName) {
-        return new Promise((resolve, reject) => {
-            const ws = new WebSocket(wsUrl);
-            let settled = false;
-            // Dia (The Browser Company) is the only Chromium browser that gates the
-            // WS-open behind an "Allow debugging connection?" prompt (Return =
-            // Allow). When auto-allow is on and the WS is still CONNECTING past the
-            // delay, the prompt is up: fire one Return at the Dia process via osascript
-            // so connect completes with no manual click. No-op for every other browser
-            // and off macOS; cleared on open so a fast handshake never triggers it.
-            const allowTimer = this.autoAllow && browserName === "Dia" && this.platform === "darwin"
-                ? setTimeout(() => {
-                    if (settled || ws.readyState !== WS_CONNECTING)
-                        return;
-                    this.dismissDiaAllowPrompt();
-                }, this.autoAllowDelayMs)
-                : undefined;
-            const clearAllow = () => {
-                if (allowTimer)
-                    clearTimeout(allowTimer);
-            };
-            const timer = setTimeout(() => {
-                if (settled)
-                    return;
-                settled = true;
-                clearAllow();
-                try {
-                    ws.close();
-                }
-                catch {
-                    /* ignore */
-                }
-                reject(new Error(`timed out after ${this.connectTimeoutMs}ms`));
-            }, this.connectTimeoutMs);
-            ws.addEventListener("open", () => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                clearAllow();
-                this.ws = ws;
-                this.startHeartbeat();
-                resolve();
-            });
-            ws.addEventListener("message", (event) => this.onMessage(String(event.data)));
-            ws.addEventListener("error", () => {
-                if (settled) {
-                    this.failPending(ws, new Error("CDP websocket error"));
-                    return;
-                }
-                settled = true;
-                clearTimeout(timer);
-                clearAllow();
-                reject(new Error("websocket error (likely 403 or port closed)"));
-            });
-            ws.addEventListener("close", () => {
-                clearTimeout(timer);
-                clearAllow();
-                this.failPending(ws, new Error("CDP websocket closed"));
-                if (!settled) {
-                    settled = true;
-                    reject(new Error("websocket closed before open"));
-                }
-            });
-        });
-    }
-    /** Reject in-flight calls, drop the socket, and clear ambient state. */
-    failPending(ws, error) {
-        if (this.ws !== ws)
-            return;
-        this.stopHeartbeat();
-        this.ws = undefined;
-        this.connectedBrowser = undefined;
-        for (const pending of this.pending.values())
-            pending.reject(error);
-        this.pending.clear();
-        // Socket dropped → every prior targetId/token is invalid; the browser
-        // session is gone (or different). Reset so the next observeTargets cycle
-        // re-discovers from a clean slate.
-        this.tokenToTargetId.clear();
-        this.targetIdToToken.clear();
-        this.eventHandlers.clear();
-    }
-    onMessage(raw) {
-        let message;
-        try {
-            message = JSON.parse(raw);
-        }
-        catch {
-            return;
-        }
-        // Any inbound frame — a command reply or an unsolicited Target event —
-        // proves the socket is live; reset the keepalive's quiet-window clock so
-        // an active or chatty connection never gets a redundant probe.
-        this.lastReplyAt = Date.now();
-        if (typeof message.id === "number") {
-            // A command reply: route to the pending call by id.
-            const pending = this.pending.get(message.id);
-            if (!pending)
-                return;
-            this.pending.delete(message.id);
-            if (message.error)
-                pending.reject(new CdpReplyError(`CDP error: ${message.error.message ?? "unknown"}`));
-            else
-                pending.resolve(message.result);
-            return;
-        }
-        // An event (no `id`): route by `sessionId:method`. Browser-level events
-        // like Target.targetCreated carry no sessionId.
-        if (typeof message.method !== "string")
-            return;
-        const handler = this.eventHandlers.get(`${message.sessionId ?? ""}:${message.method}`);
-        if (handler)
-            handler(message.params);
-    }
-    /** Install a CDP-event handler keyed by `(sessionId, method)`. Idempotent. */
-    on(method, handler, sessionId) {
-        this.eventHandlers.set(`${sessionId ?? ""}:${method}`, handler);
-    }
-    call(method, params, sessionId, timeoutMs) {
-        const ws = this.ws;
-        if (!ws || ws.readyState !== WS_OPEN) {
-            return Promise.reject(new Error("CDP not connected"));
-        }
-        const id = this.nextId++;
-        const deadline = timeoutMs ?? this.callTimeoutMs;
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`CDP call timed out after ${deadline}ms`));
-            }, deadline);
-            this.pending.set(id, {
-                resolve: (value) => {
-                    clearTimeout(timer);
-                    resolve(value);
-                },
-                reject: (error) => {
-                    clearTimeout(timer);
-                    reject(error);
-                },
-            });
-            // flatten:true routes session-scoped replies back over this one socket,
-            // tagged by id, so the pending map matches them with no extra envelope.
-            ws.send(JSON.stringify(sessionId ? { id, method, params, sessionId } : { id, method, params }));
-        });
-    }
-    /**
-     * Begin observing target lifecycle. `Target.setDiscoverTargets` makes the
-     * browser emit `Target.targetCreated` for every existing page-type target
-     * (tabs already open) plus every subsequently-created one; for each on our
-     * origin we inject an ambient token the page echoes over its WS so the
-     * server can pair the socket with the targetId (for closeTab on shell exit).
-     * `Target.targetDestroyed` cleans up our maps. Best-effort and never throws
-     * — discovery is a soft layer on top of the persistent socket.
-     */
-    async observeTargets() {
-        if (!this.isConnected())
-            return;
-        // Idempotent: handlers overwrite in place if establish() runs again after
-        // a socket drop.
-        this.on("Target.targetCreated", (params) => {
-            const target = params?.targetInfo;
-            if (!target || target.type !== "page" || typeof target.targetId !== "string")
-                return;
-            if (this.targetIdToToken.has(target.targetId))
-                return; // already injected
-            if (typeof target.url !== "string" || (this.tabUrlFilter && !this.tabUrlFilter(target.url)))
-                return;
-            void this.injectToken(target.targetId).catch(() => {
-                /* injection is best-effort; never blocks observeTargets */
-            });
-        });
-        this.on("Target.targetDestroyed", (params) => {
-            const targetId = params?.targetId;
-            if (typeof targetId !== "string")
-                return;
-            const token = this.targetIdToToken.get(targetId);
-            if (token !== undefined) {
-                this.tokenToTargetId.delete(token);
-                this.targetIdToToken.delete(targetId);
-            }
-        });
-        await this.call("Target.setDiscoverTargets", { discover: true });
-    }
-    /**
-     * Attach to one target and inject an ambient token the page echoes back over
-     * its WS so the server can pair the socket with this targetId. The robust
-     * hook is `Page.addScriptToEvaluateOnNewDocument`: it re-runs on every
-     * navigation (reload, push to a new document), so the token survives the
-     * page's lifetime without per-event re-injection plumbing. Followed by a
-     * best-effort immediate `Runtime.evaluate` so a page that has already loaded
-     * (the daemon observed an existing tab) gets the token without waiting for a
-     * navigation. Never throws.
-     */
-    async injectToken(targetId) {
-        const token = randomUUID();
-        this.targetIdToToken.set(targetId, token);
-        this.tokenToTargetId.set(token, targetId);
-        // The injected expression assigns the token under a well-known window
-        // property the client reads on WS-open, then dispatches a named event the
-        // client also listens for — covering the case where injection lands after
-        // the WS has already connected with `token:null`.
-        const expression = `window[${JSON.stringify(LOCALTERM_TAB_TOKEN_PROPERTY)}]=${JSON.stringify(token)};window.dispatchEvent(new Event(${JSON.stringify(LOCALTERM_TAB_TOKEN_EVENT)}))`;
-        let sessionId;
-        try {
-            const attached = (await this.call("Target.attachToTarget", {
-                targetId,
-                flatten: true,
-            }));
-            sessionId = attached?.sessionId;
-            if (!sessionId)
-                return;
-            // Page domain must be enabled for addScriptToEvaluateOnNewDocument to
-            // install (and for Runtime.evaluate to land against this tab).
-            await this.call("Page.enable", {}, sessionId);
-            // Fires on every navigation (and reload) — the token survives across
-            // the page's lifetime via this attached session.
-            await this.call("Page.addScriptToEvaluateOnNewDocument", { source: expression }, sessionId);
-            // Best-effort immediate inject for an already-loaded page. Errors when
-            // the document has no execution context yet (still loading) — the
-            // addScript will run on context creation and dispatch the event then.
-            try {
-                await this.call("Runtime.evaluate", { expression }, sessionId);
-            }
-            catch {
-                /* execution context not yet ready; addScript covers it */
-            }
-        }
-        catch {
-            // attach/enable failed (target already closed, fork without attach
-            // support). Leave the maps — targetDestroyed will clean up if/when it
-            // fires; without it the entry is inert (no WS ever sends this token).
-        }
-    }
     /**
      * Resolve the CDP targetId an ambient token was injected for, so the WS
      * server can pair a `{type:"identify", token}` message with the right tab
@@ -372,7 +99,7 @@ export class CdpClient {
      * (no CDP reachable, or the page raced its identify in before injection).
      */
     findTargetIdForToken(token) {
-        return this.tokenToTargetId.get(token);
+        return this.targetRegistry.findTargetIdForToken(token);
     }
     /**
      * Find an existing page-type target whose URL passes `predicate` — used to
@@ -389,7 +116,7 @@ export class CdpClient {
             return null;
         }
         try {
-            const result = (await this.call("Target.getTargets", {}));
+            const result = (await this.connection.call("Target.getTargets", {}));
             const targets = result?.targetInfos ?? [];
             for (const target of targets) {
                 if (target.type === "page" &&
@@ -413,7 +140,10 @@ export class CdpClient {
      */
     async attachSession(targetId) {
         try {
-            const attached = (await this.call("Target.attachToTarget", { targetId, flatten: true }));
+            const attached = (await this.connection.call("Target.attachToTarget", {
+                targetId,
+                flatten: true,
+            }));
             return attached?.sessionId ?? null;
         }
         catch {
@@ -427,7 +157,7 @@ export class CdpClient {
      */
     async evaluateInSession(sessionId, expression, timeoutMs) {
         try {
-            const result = (await this.call("Runtime.evaluate", { expression, returnByValue: true }, sessionId, timeoutMs));
+            const result = (await this.connection.call("Runtime.evaluate", { expression, returnByValue: true }, sessionId, timeoutMs));
             return result?.result?.value ?? null;
         }
         catch {
@@ -445,7 +175,7 @@ export class CdpClient {
         if (!sessionId)
             return null;
         try {
-            await this.call("Page.enable", {}, sessionId, timeoutMs);
+            await this.connection.call("Page.enable", {}, sessionId, timeoutMs);
         }
         catch {
             /* page domain optional for a plain evaluate */
@@ -464,7 +194,7 @@ export class CdpClient {
             const params = { format: "png" };
             if (clip)
                 params.clip = { ...clip, scale: 1 };
-            const result = (await this.call("Page.captureScreenshot", params, sessionId));
+            const result = (await this.connection.call("Page.captureScreenshot", params, sessionId));
             return result?.data ? Buffer.from(result.data, "base64") : null;
         }
         catch {
@@ -481,7 +211,7 @@ export class CdpClient {
     async dispatchMouseEventsInSession(sessionId, events) {
         for (const event of events) {
             try {
-                await this.call("Input.dispatchMouseEvent", event, sessionId);
+                await this.connection.call("Input.dispatchMouseEvent", event, sessionId);
             }
             catch {
                 /* tab closed mid-sequence; the gesture is best-effort */
@@ -504,7 +234,7 @@ export class CdpClient {
             return false;
         }
         try {
-            const result = (await this.call("Network.setCookie", cookie));
+            const result = (await this.connection.call("Network.setCookie", cookie));
             return result?.success === true;
         }
         catch {
@@ -521,8 +251,8 @@ export class CdpClient {
      */
     async addVirtualAuthenticator(sessionId) {
         try {
-            await this.call("WebAuthn.enable", {}, sessionId);
-            const result = (await this.call("WebAuthn.addVirtualAuthenticator", {
+            await this.connection.call("WebAuthn.enable", {}, sessionId);
+            const result = (await this.connection.call("WebAuthn.addVirtualAuthenticator", {
                 options: {
                     protocol: "ctap2",
                     transport: "internal",
@@ -543,7 +273,7 @@ export class CdpClient {
         if (!this.isConnected())
             return;
         try {
-            await this.call("WebAuthn.removeVirtualAuthenticator", { authenticatorId }, sessionId);
+            await this.connection.call("WebAuthn.removeVirtualAuthenticator", { authenticatorId }, sessionId);
         }
         catch {
             /* best-effort */
@@ -562,7 +292,7 @@ export class CdpClient {
             return null;
         }
         try {
-            const result = (await this.call("Target.createTarget", { url }));
+            const result = (await this.connection.call("Target.createTarget", { url }));
             return typeof result?.targetId === "string" ? result.targetId : null;
         }
         catch {
@@ -585,7 +315,10 @@ export class CdpClient {
                 return null; // no reachable browser — fall back
             }
             try {
-                const result = (await this.call("Target.createTarget", { url, background: true }));
+                const result = (await this.connection.call("Target.createTarget", {
+                    url,
+                    background: true,
+                }));
                 return typeof result?.targetId === "string" ? result.targetId : null;
             }
             catch (error) {
@@ -596,16 +329,7 @@ export class CdpClient {
                 // explicitly (failPending doesn't close() on its own) and reset maps.
                 if (error instanceof CdpReplyError)
                     return null;
-                const stale = this.ws;
-                if (stale) {
-                    try {
-                        stale.close();
-                    }
-                    catch {
-                        /* ignore */
-                    }
-                    this.failPending(stale, new Error("CDP call failed; dropping stale socket"));
-                }
+                this.connection.dropStale("CDP call failed; dropping stale socket");
             }
         }
         return null;
@@ -628,7 +352,7 @@ export class CdpClient {
         }
         let sessionId;
         try {
-            const attached = (await this.call("Target.attachToTarget", {
+            const attached = (await this.connection.call("Target.attachToTarget", {
                 targetId,
                 flatten: true,
             }));
@@ -640,13 +364,13 @@ export class CdpClient {
         if (!sessionId)
             return;
         try {
-            await this.call("Page.navigate", { url }, sessionId);
+            await this.connection.call("Page.navigate", { url }, sessionId);
         }
         catch {
             /* tab may be navigating/closing — best-effort */
         }
         try {
-            await this.call("Target.detachFromTarget", { sessionId });
+            await this.connection.call("Target.detachFromTarget", { sessionId });
         }
         catch {
             /* detach is best-effort; the browser tears it down on navigation anyway */
@@ -683,25 +407,25 @@ export class CdpClient {
                     return; // no reachable browser — treat as already closed
                 }
                 try {
-                    const attached = (await this.call("Target.attachToTarget", {
+                    const attached = (await this.connection.call("Target.attachToTarget", {
                         targetId,
                         flatten: true,
                     }));
                     if (attached?.sessionId) {
                         try {
-                            await this.call("Runtime.evaluate", { expression: "window.close()" }, attached.sessionId);
+                            await this.connection.call("Runtime.evaluate", { expression: "window.close()" }, attached.sessionId);
                         }
                         catch {
                             /* tab may already be navigating/closing */
                         }
-                        await new Promise((resolve) => setTimeout(resolve, CLOSE_SETTLE_MS));
+                        await new Promise((resolve) => setTimeout(resolve, CDP_CLOSE_SETTLE_MS));
                     }
                 }
                 catch {
                     /* attach failed (already gone, or fork without attach) — try closeTarget */
                 }
                 try {
-                    await this.call("Target.closeTarget", { targetId });
+                    await this.connection.call("Target.closeTarget", { targetId });
                     return;
                 }
                 catch (error) {
@@ -713,16 +437,7 @@ export class CdpClient {
                     // socket worth tearing down for the retry to reconnect.
                     if (error instanceof CdpReplyError)
                         return;
-                    const stale = this.ws;
-                    if (stale) {
-                        try {
-                            stale.close();
-                        }
-                        catch {
-                            /* ignore */
-                        }
-                        this.failPending(stale, new Error("CDP closeTab call failed; dropping stale socket"));
-                    }
+                    this.connection.dropStale("CDP closeTab call failed; dropping stale socket");
                 }
             }
         };
@@ -731,72 +446,6 @@ export class CdpClient {
         this.closeQueue = this.closeQueue.then(doClose, doClose);
         return this.closeQueue;
     }
-    /** Background keepalive for the persistent socket. Its job is to detect a
-     * half-open socket during idle rather than discovering it on the next
-     * automation run: after a quiet window it probes liveness with a cheap
-     * `Target.getTargets` round-trip. The socket often still reads OPEN after a
-     * laptop sleep even though the browser was suspended and dropped the debug
-     * WS, so without the probe the next `Target.createTarget` call stalls
-     * against it for the full call timeout before the open-path catch closes
-     * it. A probe that goes unanswered past that timeout tears the socket down
-     * now, and the next `openBackgroundTab` reconnects cleanly instead of
-     * paying that stall. When the socket genuinely survived the quiet period
-     * (still OPEN and the browser still replies), the probe reuses it and
-     * avoids a needless reopen. One probe at a time is fine — the interval is
-     * larger than the call timeout, so probes never overlap. */
-    startHeartbeat() {
-        this.stopHeartbeat();
-        this.lastReplyAt = Date.now();
-        this.heartbeatTimer = setInterval(() => this.heartbeatTick(), this.heartbeatIntervalMs);
-        this.heartbeatTimer.unref?.();
-    }
-    stopHeartbeat() {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = undefined;
-        }
-    }
-    heartbeatTick() {
-        if (!this.isConnected())
-            return;
-        if (Date.now() - this.lastReplyAt < this.heartbeatTimeoutMs)
-            return;
-        // Quiet past the threshold: probe liveness rather than assume death. The
-        // probe gets its own generous reply-wait (heartbeatGraceMs, not the per-call
-        // timeout) so a slow-but-live browser — post-wake scheduling delay, a
-        // momentary main-thread block — replies in time and is reused, not torn
-        // down. One probe at a time is fine: the interval is larger than the grace
-        // window, so probes never overlap.
-        void this.call(CDP_HEARTBEAT_PROBE_METHOD, {}, undefined, this.heartbeatGraceMs)
-            .then(() => {
-            this.lastReplyAt = Date.now();
-        })
-            .catch((error) => {
-            // A CDP error *reply* means the browser answered on a healthy socket
-            // (onMessage already reset lastReplyAt) — keep it. Same guard as
-            // openBackgroundTab/closeTab: a reply must never drop the one persistent
-            // socket kept for the daemon's lifetime. Only a transport drop or a
-            // probe timeout is a genuinely stale socket worth tearing down.
-            if (error instanceof CdpReplyError)
-                return;
-            this.teardownStale("CDP heartbeat probe failed; dropping socket");
-        });
-    }
-    /** Close the (presumed dead) live socket and route teardown through
-     * failPending so maps/handlers reset in one place. Safe against a concurrent
-     * reconnect that already swapped in a fresh socket via the guard there. */
-    teardownStale(reason) {
-        const dead = this.ws;
-        if (!dead)
-            return;
-        try {
-            dead.close();
-        }
-        catch {
-            /* ignore */
-        }
-        this.failPending(dead, new Error(reason));
-    }
     /**
      * Drop the live socket so the next `connect()` re-runs detection — used when
      * the configured CDP endpoint changes via `PUT /api/config`, so the new port
@@ -807,21 +456,12 @@ export class CdpClient {
      * `openBackgroundTab` reconnects lazily.
      */
     resetConnection(reason = "cdp connection reset") {
-        this.teardownStale(reason);
+        this.connection.dropStale(reason);
     }
     close() {
-        this.stopHeartbeat();
-        try {
-            this.ws?.close();
-        }
-        catch {
-            /* ignore */
-        }
-        this.ws = undefined;
+        this.connection.close();
         this.connectedBrowser = undefined;
-        this.tokenToTargetId.clear();
-        this.targetIdToToken.clear();
-        this.eventHandlers.clear();
+        this.targetRegistry.clear();
     }
 }
 //# sourceMappingURL=cdp-client.js.map