webtap-tool 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

webtap/services/dom.py

@@ -46,7 +46,7 @@ class DOMService:
         self.state = state
         self._inspection_active = False
         self._next_id = 1
-        self._broadcast_queue: "Any | None" = None  # asyncio.Queue for thread-safe broadcasts
+        self._broadcast_callback: "Any | None" = None  # Callback to service._trigger_broadcast()
         self._state_lock = threading.Lock()  # Protect state mutations
         self._pending_selections = 0  # Track in-flight selection processing
         self._executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="dom-worker")
@@ -59,13 +59,13 @@ class DOMService:
         """Set state after initialization."""
         self.state = state
 
-    def set_broadcast_queue(self, queue: "Any") -> None:
-        """Set queue for broadcasting state changes.
+    def set_broadcast_callback(self, callback: "Any") -> None:
+        """Set callback for broadcasting state changes.
 
         Args:
-            queue: asyncio.Queue for thread-safe signaling
+            callback: Function to call when state changes (service._trigger_broadcast)
         """
-        self._broadcast_queue = queue
+        self._broadcast_callback = callback
 
     def start_inspect(self) -> dict[str, Any]:
         """Enable CDP element inspection mode.
@@ -116,6 +116,7 @@ class DOMService:
             self._inspection_active = True
             logger.info("Element inspection mode enabled")
 
+            self._trigger_broadcast()
             return {"success": True, "inspect_active": True}
 
         except Exception as e:
@@ -143,6 +144,7 @@ class DOMService:
             self._inspection_active = False
             logger.info("Element inspection mode disabled")
 
+            self._trigger_broadcast()
             return {"success": True, "inspect_active": False}
 
         except Exception as e:
@@ -244,12 +246,12 @@ class DOMService:
             self._trigger_broadcast()
 
     def _trigger_broadcast(self) -> None:
-        """Trigger SSE broadcast via queue (thread-safe helper)."""
-        if self._broadcast_queue:
+        """Trigger SSE broadcast via service callback (ensures snapshot update)."""
+        if self._broadcast_callback:
             try:
-                self._broadcast_queue.put_nowait({"type": "dom_update"})
+                self._broadcast_callback()
             except Exception as e:
-                logger.debug(f"Failed to queue broadcast: {e}")
+                logger.debug(f"Failed to trigger broadcast: {e}")
 
     def _extract_node_data(self, backend_node_id: int) -> dict[str, Any]:
         """Extract complete element data via CDP.
@@ -486,14 +488,16 @@ class DOMService:
                 self.state.browser_data["selections"] = {}
             self._next_id = 1
         logger.info("Selections cleared")
+        self._trigger_broadcast()
 
     def cleanup(self) -> None:
         """Cleanup resources (executor, callbacks).
 
         Call this before disconnect or app exit.
+        Safe to call multiple times.
         """
         # Shutdown executor - wait=False to avoid blocking on stuck tasks
-        # cancel_futures=True prevents hanging on incomplete selections (Python 3.9+)
+        # cancel_futures=True prevents hanging on incomplete selections
         if hasattr(self, "_executor"):
             try:
                 self._executor.shutdown(wait=False, cancel_futures=True)
@@ -501,12 +505,15 @@ class DOMService:
             except Exception as e:
                 logger.debug(f"Executor shutdown error (non-fatal): {e}")
 
-        # Clear inspection state
-        if self._inspection_active:
+        # Clear inspection state (only if connected)
+        if self._inspection_active and self.cdp and self.cdp.is_connected:
             try:
                 self.stop_inspect()
             except Exception as e:
                 logger.debug(f"Failed to stop inspect on cleanup: {e}")
 
+        # Force clear inspection flag even if CDP call failed
+        self._inspection_active = False
+
 
 __all__ = ["DOMService"]

webtap/services/fetch.py

@@ -21,6 +21,23 @@ class FetchService:
         self.enable_response_stage = False  # Config option for future
         self.cdp: CDPSession | None = None
         self.body_service: BodyService | None = None
+        self._broadcast_callback: "Any | None" = None  # Callback to service._trigger_broadcast()
+
+    def set_broadcast_callback(self, callback: "Any") -> None:
+        """Set callback for broadcasting state changes.
+
+        Args:
+            callback: Function to call when state changes (service._trigger_broadcast)
+        """
+        self._broadcast_callback = callback
+
+    def _trigger_broadcast(self) -> None:
+        """Trigger SSE broadcast via service callback (ensures snapshot update)."""
+        if self._broadcast_callback:
+            try:
+                self._broadcast_callback()
+            except Exception as e:
+                logger.debug(f"Failed to trigger broadcast: {e}")
 
     # ============= Core State Queries =============
 
@@ -147,6 +164,7 @@ class FetchService:
             stage_msg = "Request and Response stages" if response_stage else "Request stage only"
             logger.info(f"Fetch interception enabled ({stage_msg})")
 
+            self._trigger_broadcast()  # Update snapshot
             return {"enabled": True, "stages": stage_msg, "paused": self.paused_count}
 
         except Exception as e:
@@ -174,6 +192,7 @@ class FetchService:
                 self.body_service.clear_cache()
 
             logger.info("Fetch interception disabled")
+            self._trigger_broadcast()  # Update snapshot
             return {"enabled": False}
 
         except Exception as e:

webtap/services/main.py

@@ -12,6 +12,7 @@ from webtap.services.network import NetworkService
 from webtap.services.console import ConsoleService
 from webtap.services.body import BodyService
 from webtap.services.dom import DOMService
+from webtap.services.state_snapshot import StateSnapshot
 
 
 REQUIRED_DOMAINS = [
@@ -47,8 +48,11 @@ class WebTapService:
         Args:
             state: WebTapState instance from app.py
         """
+        import threading
+
         self.state = state
         self.cdp = state.cdp
+        self._state_lock = threading.RLock()  # Reentrant lock - safe to acquire multiple times by same thread
 
         self.enabled_domains: set[str] = set()
         self.filters = FilterManager()
@@ -65,8 +69,10 @@ class WebTapService:
         self.body.cdp = self.cdp
         self.dom.set_cdp(self.cdp)
         self.dom.set_state(self.state)
+        self.dom.set_broadcast_callback(self._trigger_broadcast)  # DOM calls back for snapshot updates
 
         self.fetch.body_service = self.body
+        self.fetch.set_broadcast_callback(self._trigger_broadcast)  # Fetch calls back for snapshot updates
 
         # Legacy wiring for CDP event handler
         self.cdp.fetch_service = self.fetch
@@ -75,14 +81,135 @@ class WebTapService:
         self.cdp.register_event_callback("Overlay.inspectNodeRequested", self.dom.handle_inspect_node_requested)
         self.cdp.register_event_callback("Page.frameNavigated", self.dom.handle_frame_navigated)
 
+        # Register disconnect callback for unexpected disconnects
+        self.cdp.set_disconnect_callback(self._handle_unexpected_disconnect)
+
+        # Broadcast queue for SSE state updates (set by API server)
+        self._broadcast_queue: "Any | None" = None
+
+        # Immutable state snapshot for thread-safe SSE reads
+        # Updated atomically on every state change, read without locks
+        self._state_snapshot: StateSnapshot = StateSnapshot.create_empty()
+
+    def set_broadcast_queue(self, queue: "Any") -> None:
+        """Set queue for broadcasting state changes.
+
+        Args:
+            queue: asyncio.Queue for thread-safe signaling
+        """
+        self._broadcast_queue = queue
+
+    def _create_snapshot(self) -> StateSnapshot:
+        """Create immutable state snapshot from current state.
+
+        MUST be called with self._state_lock held to ensure atomic read.
+
+        Returns:
+            Frozen StateSnapshot with current state
+        """
+        # Connection state (read page_info first to avoid race with disconnect)
+        page_info = self.cdp.page_info
+        connected = self.cdp.is_connected and page_info is not None
+        page_id = page_info.get("id", "") if page_info else ""
+        page_title = page_info.get("title", "") if page_info else ""
+        page_url = page_info.get("url", "") if page_info else ""
+
+        # Event count
+        event_count = self.event_count
+
+        # Fetch state
+        fetch_enabled = self.fetch.enabled
+        paused_count = self.fetch.paused_count if fetch_enabled else 0
+
+        # Filter state (convert to immutable tuples)
+        fm = self.filters
+        filter_categories = list(fm.filters.keys())
+        enabled_filters = tuple(fm.enabled_categories)
+        disabled_filters = tuple(cat for cat in filter_categories if cat not in enabled_filters)
+
+        # Browser/DOM state (get_state() is already thread-safe internally)
+        browser_state = self.dom.get_state()
+
+        # Error state
+        error = self.state.error_state
+        error_message = error.get("message") if error else None
+        error_timestamp = error.get("timestamp") if error else None
+
+        # Deep copy selections to ensure true immutability
+        import copy
+
+        selections = copy.deepcopy(browser_state["selections"])
+
+        return StateSnapshot(
+            connected=connected,
+            page_id=page_id,
+            page_title=page_title,
+            page_url=page_url,
+            event_count=event_count,
+            fetch_enabled=fetch_enabled,
+            paused_count=paused_count,
+            enabled_filters=enabled_filters,
+            disabled_filters=disabled_filters,
+            inspect_active=browser_state["inspect_active"],
+            selections=selections,  # Deep copy ensures nested dicts are immutable
+            prompt=browser_state["prompt"],
+            pending_count=browser_state["pending_count"],
+            error_message=error_message,
+            error_timestamp=error_timestamp,
+        )
+
+    def _trigger_broadcast(self) -> None:
+        """Trigger SSE broadcast with updated state snapshot (thread-safe).
+
+        Called after service mutations to:
+        1. Create fresh immutable snapshot (atomic replacement)
+        2. Signal SSE clients to broadcast
+
+        Uses RLock so same thread can call multiple times safely.
+        asyncio.Queue.put_nowait() is thread-safe for cross-thread communication.
+        """
+        import logging
+
+        logger = logging.getLogger(__name__)
+
+        # Update snapshot atomically
+        # RLock allows same thread to acquire multiple times, blocks other threads
+        try:
+            with self._state_lock:
+                self._state_snapshot = self._create_snapshot()
+        except (TypeError, AttributeError) as e:
+            # Programming errors should propagate for debugging
+            logger.error(f"Programming error in snapshot creation: {e}")
+            raise
+        except Exception as e:
+            # Unexpected errors logged but don't crash the app
+            logger.error(f"Failed to create state snapshot: {e}", exc_info=True)
+            return  # Don't signal broadcast if snapshot creation failed
+
+        # Signal broadcast (store reference to avoid TOCTOU race)
+        queue = self._broadcast_queue
+        if queue:
+            try:
+                queue.put_nowait({"type": "state_change"})
+            except Exception as e:
+                logger.warning(f"Failed to queue broadcast: {e}")
+
+    def get_state_snapshot(self) -> StateSnapshot:
+        """Get current immutable state snapshot (thread-safe, no locks).
+
+        Returns:
+            Current StateSnapshot - immutable, safe to read from any thread
+        """
+        return self._state_snapshot
+
     @property
     def event_count(self) -> int:
         """Total count of all CDP events stored."""
         if not self.cdp or not self.cdp.is_connected:
             return 0
         try:
-            result = self.cdp.db.execute("SELECT COUNT(*) FROM events").fetchone()
-            return result[0] if result else 0
+            result = self.cdp.query("SELECT COUNT(*) FROM events")
+            return result[0][0] if result else 0
         except Exception:
             return 0
 
@@ -105,6 +232,7 @@ class WebTapService:
             self.filters.load()
 
             page_info = self.cdp.page_info or {}
+            self._trigger_broadcast()
             return {"connected": True, "title": page_info.get("title", "Untitled"), "url": page_info.get("url", "")}
         except Exception as e:
             return {"error": str(e)}
@@ -118,6 +246,7 @@ class WebTapService:
 
         self.body.clear_cache()
         self.dom.clear_selections()
+        self.dom.cleanup()  # Shutdown executor properly
 
         # Clear error state on disconnect
         if self.state.error_state:
@@ -126,6 +255,7 @@ class WebTapService:
         self.cdp.disconnect()
         self.enabled_domains.clear()
 
+        self._trigger_broadcast()
         return {"disconnected": True, "was_connected": was_connected}
 
     def enable_domains(self, domains: list[str]) -> dict[str, str]:
@@ -175,6 +305,7 @@ class WebTapService:
     def clear_events(self) -> dict[str, Any]:
         """Clear all stored CDP events."""
         self.cdp.clear_events()
+        self._trigger_broadcast()
         return {"cleared": True, "events": 0}
 
     def list_pages(self) -> dict[str, Any]:
@@ -187,3 +318,64 @@ class WebTapService:
             return {"pages": pages}
         except Exception as e:
             return {"error": str(e), "pages": []}
+
+    def _handle_unexpected_disconnect(self, code: int, reason: str) -> None:
+        """Handle unexpected WebSocket disconnect (tab closed, crashed, etc).
+
+        Called from background thread by CDPSession._on_close.
+        Performs service-level cleanup and notifies SSE clients.
+        Events are preserved for debugging.
+
+        Args:
+            code: WebSocket close code (e.g., 1006 = abnormal closure)
+            reason: Human-readable close reason
+        """
+        import logging
+        import time
+
+        logger = logging.getLogger(__name__)
+
+        # Map WebSocket close codes to user-friendly messages
+        reason_map = {
+            1000: "Page closed normally",
+            1001: "Browser tab closed",
+            1006: "Connection lost (tab crashed or browser closed)",
+            1011: "Chrome internal error",
+        }
+
+        # Handle None code (abnormal closure with no code)
+        if code is None:
+            user_reason = "Connection lost (page closed or crashed)"
+        else:
+            user_reason = reason_map.get(code, f"Connection closed unexpectedly (code {code})")
+
+        logger.warning(f"Unexpected disconnect: {user_reason}")
+
+        try:
+            # Thread-safe state cleanup (called from background thread)
+            with self._state_lock:
+                # Clean up service state (no CDP calls - connection already gone)
+                if self.fetch.enabled:
+                    self.fetch.enabled = False  # Direct state update, no CDP disable
+
+                self.body.clear_cache()
+                self.dom.clear_selections()
+
+                # Events preserved for debugging - use Clear button to remove explicitly
+                # DB thread and field_paths persist for reconnection
+
+                # Set error state with disconnect info
+                self.state.error_state = {"message": user_reason, "timestamp": time.time()}
+
+                self.enabled_domains.clear()
+
+            # Cleanup outside lock (safe to call multiple times, has internal protection)
+            self.dom.cleanup()  # Shutdown executor
+
+            # Notify SSE clients
+            self._trigger_broadcast()
+
+            logger.info("Unexpected disconnect cleanup completed")
+
+        except Exception as e:
+            logger.error(f"Error during unexpected disconnect cleanup: {e}")

webtap/services/state_snapshot.py

@@ -0,0 +1,88 @@
+"""Immutable state snapshots for thread-safe SSE broadcasting.
+
+PUBLIC API:
+  - StateSnapshot: Frozen dataclass for zero-lock state reads
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class StateSnapshot:
+    """Immutable snapshot of WebTap state.
+
+    Frozen dataclass provides inherent thread safety - multiple threads can
+    read simultaneously without locks. Updated atomically when state changes.
+
+    Used by SSE broadcast to avoid lock contention between asyncio event loop
+    and background threads (WebSocket, disconnect handlers).
+
+    Attributes:
+        connected: Whether connected to Chrome page
+        page_id: Stable page identifier (empty if not connected)
+        page_title: Page title (empty if not connected)
+        page_url: Page URL (empty if not connected)
+        event_count: Total CDP events stored
+        fetch_enabled: Whether fetch interception is active
+        paused_count: Number of paused requests (if fetch enabled)
+        enabled_filters: Tuple of enabled filter category names
+        disabled_filters: Tuple of disabled filter category names
+        inspect_active: Whether element inspection mode is active
+        selections: Dict of selected elements (id -> element data)
+        prompt: Browser prompt text (unused, reserved)
+        pending_count: Number of pending element selections being processed
+        error_message: Current error message or None
+        error_timestamp: Error timestamp or None
+    """
+
+    # Connection state
+    connected: bool
+    page_id: str
+    page_title: str
+    page_url: str
+
+    # Event state
+    event_count: int
+
+    # Fetch interception state
+    fetch_enabled: bool
+    paused_count: int
+
+    # Filter state (immutable tuples)
+    enabled_filters: tuple[str, ...]
+    disabled_filters: tuple[str, ...]
+
+    # Browser/DOM state
+    inspect_active: bool
+    selections: dict[str, Any]  # Dict is mutable but replaced atomically
+    prompt: str
+    pending_count: int
+
+    # Error state
+    error_message: str | None
+    error_timestamp: float | None
+
+    @classmethod
+    def create_empty(cls) -> "StateSnapshot":
+        """Create empty snapshot for disconnected state."""
+        return cls(
+            connected=False,
+            page_id="",
+            page_title="",
+            page_url="",
+            event_count=0,
+            fetch_enabled=False,
+            paused_count=0,
+            enabled_filters=(),
+            disabled_filters=(),
+            inspect_active=False,
+            selections={},
+            prompt="",
+            pending_count=0,
+            error_message=None,
+            error_timestamp=None,
+        )
+
+
+__all__ = ["StateSnapshot"]

{webtap_tool-0.7.0.dist-info → webtap_tool-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webtap-tool
-Version: 0.7.0
+Version: 0.8.0
 Summary: Terminal-based web page inspector for AI debugging sessions
 Author-email: Fredrik Angelsen <fredrikangelsen@gmail.com>
 Classifier: Development Status :: 3 - Alpha

{webtap_tool-0.7.0.dist-info → webtap_tool-0.8.0.dist-info}/RECORD

@@ -1,51 +1,54 @@
 webtap/VISION.md,sha256=kfoJfEPVc4chOrD9tNMDmYBY9rX9KB-286oZj70ALCE,7681
-webtap/__init__.py,sha256=DFWJGmqZfX8_h4csLA5pKPR4SkaHBMlUgU-WQIE96Gw,1092
-webtap/api.py,sha256=twDO_aA861yjjvrKquZ0phm2SIL07Wq37DmFjtVbTw4,17990
-webtap/app.py,sha256=75x_MQ2sjt6-HJi-YYRdFoKc3ss6SQfgFVArE1QKs3M,3851
+webtap/__init__.py,sha256=gQPBOt8Q9Y9znQidBvIM5DbecNBTQe4XuoLK5WjFIfU,1250
+webtap/api.py,sha256=w-7WGyR54fv980GF873w4T5TPErYcgx9PfRBNiddk64,18251
+webtap/app.py,sha256=DG40lLVod4iSJP1TnrzxrEkkP4_sQ6G5euGubQqfEGQ,4073
 webtap/filters.py,sha256=kRCicGMSV3R_zSvwzqZqksnry6jxJNdXRcgWvpoBLfc,13323
 webtap/cdp/README.md,sha256=0TS0V_dRgRAzBqhddpXWD4S0YVi5wI4JgFJSll_KUBE,5660
 webtap/cdp/__init__.py,sha256=c6NFG0XJnAa5GTe9MLr9mDZcLZqoTQN7A1cvvOfLcgY,453
 webtap/cdp/query.py,sha256=x2Cy7KMolYkTelpROGezOfMFgYnbSlCvHkvvW1v_gLI,4229
-webtap/cdp/session.py,sha256=LkN676_gig06w9kcXhJXZQF0z0kDZG1TTvispiYw8fQ,16212
+webtap/cdp/session.py,sha256=nm4fpHKiGskvHkhxvlmZULEVaY4PpLb7g7lmuwdEEG4,21573
 webtap/cdp/schema/README.md,sha256=hnWCzbXYcYtWaZb_SgjVaFBiG81S9b9Y3x-euQFwQDo,1222
 webtap/cdp/schema/cdp_protocol.json,sha256=dp9_OLYLuVsQb1oV5r6MZfMzURscBLyAXUckdaPWyv4,1488452
 webtap/cdp/schema/cdp_version.json,sha256=OhGy1qpfQjSe3Z7OqL6KynBFlDFBXxKGPZCY-ZN_lVU,399
 webtap/commands/DEVELOPER_GUIDE.md,sha256=LYOhycZ3k5EHx5nREfkjvLz7vOs8pXCRLlcDm-keWao,11973
-webtap/commands/TIPS.md,sha256=XwnPKY5AgLsxNw3q0aF4Amr0P891Pt4QIkw0_3AF58g,9293
+webtap/commands/TIPS.md,sha256=ssTcJr-nzoAOtTQOvuziDVoWGFk7pLa7RomwX79_kaA,14228
 webtap/commands/__init__.py,sha256=rr3xM_bY0BgxkDOjsnsI8UBhjlz7nqiYlgJ8fjiJ1jQ,270
-webtap/commands/_builders.py,sha256=SYacZmZTdkolQ7OOf3rFtFPCjkukY8z020WFA-i_O_A,7902
+webtap/commands/_builders.py,sha256=VUHiObHfOveduILYEX711wnA-tfx6GL_8t_zuQ-CPQw,8146
+webtap/commands/_code_generation.py,sha256=uBpusbIGCWqm6HwaWSuhFnRu_J5jm4rJ7qmx-esogf4,3288
 webtap/commands/_tips.py,sha256=SleMpwdghrHNqdzR60Cu8T0NZqJfWfcfrgIcyWI6GIQ,4793
 webtap/commands/_utils.py,sha256=VLXDhhhJITrQjwEyeLRTU2ey0QcLzY-_OxTjtPJlhYM,6816
-webtap/commands/body.py,sha256=hJAoVU3iWBYCctPwBxVJM_xVe02TQnePB_OMTpsh1q4,7076
-webtap/commands/connection.py,sha256=nvJ5k1KlyphTeVW9yJaATHo4N-hX7w62pf1-fAypSRk,5430
+webtap/commands/body.py,sha256=wEBD1hCEopmPSnq7M_f5mU0Rb4EPGak9OVED4jo0ZW4,7278
+webtap/commands/connection.py,sha256=o_Ny6dbQewNsPZ8QfdGZKY4mgqeAhqbRIqq56ksniFU,6264
 webtap/commands/console.py,sha256=BBaxSiLsVBChBY3Xi_nXwWjFlfc5KW9FQTPp5PzMUoE,2145
 webtap/commands/events.py,sha256=dsS6xd8GfkZ4VOnAQSCMxyEvwdha9J0Kh9oeK0CaU5Y,4058
 webtap/commands/fetch.py,sha256=8J6TPBWhStbkN5c5Q4KmK6nB5WiIgnAk0BkPFbh9ggg,7737
 webtap/commands/filters.py,sha256=jDZ8JcYIZv_K6aupwuAo9uqAi85e3EIKbf38BXz5nnI,10316
 webtap/commands/inspect.py,sha256=QonZigFYnfEVWYQY__r0n1aVvTqFBukFV-AWzc5KmfA,5711
-webtap/commands/javascript.py,sha256=j0gKl6Y6-TWBYuN8SjoRHFPOhns9C1h8NkpIQkhRXG0,4879
+webtap/commands/javascript.py,sha256=d1aCs6VthNUkxGXRIWHxCzFTwrr0j81NVtGknsz75GU,4274
 webtap/commands/launch.py,sha256=iZDLundKlxKRLKf3Vz5at42-tp2f-Uj5wZf7fbhBfA0,2202
-webtap/commands/navigation.py,sha256=aRVW-t2YJ0Haf6Wkg7uq8GstiRftklop9W1TicUk3oo,6036
+webtap/commands/navigation.py,sha256=OBhCUnRvzF4aZ7c3YZUznr-yU4uuLBGTndDtkb1EJHg,6167
 webtap/commands/network.py,sha256=gEOg_u7VF9A5aKv5myzLCuvfAUkF1OPxsuj4UAgbS44,3111
+webtap/commands/quicktype.py,sha256=t4hAVxkAbwKcf_gZlsxWIUPIABoDrboeZMS937usXHg,9002
 webtap/commands/selections.py,sha256=M001d_Gc51aSTuVeXGa19LDh2ZGR_qBJEjVGKpcGGFM,4895
 webtap/commands/server.py,sha256=DOcIgYuKp0ydwrK9EA3hGwqOwfwM9DABhdPu3hk_jjo,6948
 webtap/commands/setup.py,sha256=dov1LaN50nAEMNIuBLSK7mcnwhfn9rtqdTopBm1-PhA,9648
-webtap/commands/to_model.py,sha256=jOb93t616m5weT75VyF506J6nydDXUWENF7cpscbe9Q,4962
+webtap/commands/to_model.py,sha256=M_X_Y6Eb6tU-Ar4UP43q5AHBfBlCXV0chEuwRJ-poOE,3214
 webtap/services/README.md,sha256=rala_jtnNgSiQ1lFLM7x_UQ4SJZDceAm7dpkQMRTYaI,2346
 webtap/services/__init__.py,sha256=IjFqu0Ak6D-r18aokcQMtenDV3fbelvfjTCejGv6CZ0,570
-webtap/services/body.py,sha256=XQPa19y5eUc3XJ2TuwVK6kffO1VQoKqNs33MBBz7hzU,3913
+webtap/services/body.py,sha256=5c1YO3xKHU4qHFLeczag0m91PoSzp9-tBE30SENJEzg,11586
 webtap/services/console.py,sha256=XVfSKTvEHyyOdujsg85S3wtj1CdZhzKtWwlx25MvSv8,3768
-webtap/services/dom.py,sha256=PC-mV56NMLvw37JNzI_jOnZrM7BiDPPn3kOQI9U81vI,19067
-webtap/services/fetch.py,sha256=nl6bpU2Vnf40kau4-mqAnIkhC-7Lx2vbTJKUglz9KnE,13602
-webtap/services/main.py,sha256=KUJFXzXL0ORlYfDV6DNULv_nzNfmlBFz_mfOvscp2wY,6287
+webtap/services/dom.py,sha256=JNYHFrgPpJnMZJ3s267R5m6xFWJwKA8Fwn3XGln6wxs,19399
+webtap/services/fetch.py,sha256=-ZsfEfF3iFge3fiyLniflU0v0In-SxJMb7VtIe7_sjU,14417
+webtap/services/main.py,sha256=kHKHtLnwR3rnpbtJXZZtAdNmD_dg0ejvd-TvrkXTqLg,13948
 webtap/services/network.py,sha256=0o_--F6YvmXqqFqrcjL1gc6Vr9V1Ytb_U7r_DSUWupA,3444
+webtap/services/state_snapshot.py,sha256=xy7q-QaDhrHrEKVctJNH0t14zzI4DNmlt_-4C5ipr2M,2701
 webtap/services/setup/__init__.py,sha256=lfoKCAroc-JoE_r7L-KZkF85ZWiB41MBIgrR7ZISSoE,7157
 webtap/services/setup/chrome.py,sha256=zfPWeb6zm_xjIfiS2S_O9lR2BjGKaPXXo06pN_B9lAU,7187
 webtap/services/setup/desktop.py,sha256=fXwQa201W-s2mengm_dJZ9BigJopVrO9YFUQcW_TSFQ,8022
 webtap/services/setup/extension.py,sha256=iJY43JlQO6Vicgd9Mz6Mw0LQfbBNUGhnwI8n-LnvHBY,3602
 webtap/services/setup/filters.py,sha256=lAPSLMH_KZQO-7bRkmURwzforx7C3SDrKEw2ZogN-Lo,3220
 webtap/services/setup/platform.py,sha256=7yn-7LQFffgerWzWRtOG-yNEsR36ICThYUAu_N2FAso,4532
-webtap_tool-0.7.0.dist-info/METADATA,sha256=JAfV9YTu10f5ss15yatHtYFx8W8HJewrPthMBS0TwN4,17636
-webtap_tool-0.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-webtap_tool-0.7.0.dist-info/entry_points.txt,sha256=iFe575I0CIb1MbfPt0oX2VYyY5gSU_dA551PKVR83TU,39
-webtap_tool-0.7.0.dist-info/RECORD,,
+webtap_tool-0.8.0.dist-info/METADATA,sha256=6EJihElxEAWvWgBttK2EXsdNPJc95JKY96FzZ50Z4Hs,17636
+webtap_tool-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+webtap_tool-0.8.0.dist-info/entry_points.txt,sha256=iFe575I0CIb1MbfPt0oX2VYyY5gSU_dA551PKVR83TU,39
+webtap_tool-0.8.0.dist-info/RECORD,,