sentienceapi 0.90.11__py3-none-any.whl → 0.90.13__py3-none-any.whl

sentience/__init__.py

@@ -70,7 +70,7 @@ from .utils import (
 )
 from .wait import wait_for
 
-__version__ = "0.90.11"
+__version__ = "0.90.13"
 
 __all__ = [
     # Core SDK

sentience/agent.py

@@ -149,23 +149,8 @@ class SentienceAgent(BaseAgent):
                 if snap_opts.goal is None:
                     snap_opts.goal = goal
 
-                # Convert screenshot config to dict if needed
-                screenshot_param = snap_opts.screenshot
-                if isinstance(snap_opts.screenshot, ScreenshotConfig):
-                    screenshot_param = {
-                        "format": snap_opts.screenshot.format,
-                        "quality": snap_opts.screenshot.quality,
-                    }
-
-                # Call snapshot with converted parameters
-                snap = snapshot(
-                    self.browser,
-                    screenshot=screenshot_param,
-                    limit=snap_opts.limit,
-                    filter=snap_opts.filter.model_dump() if snap_opts.filter else None,
-                    use_api=snap_opts.use_api,
-                    goal=snap_opts.goal,  # Pass goal to snapshot
-                )
+                # Call snapshot with options object (matches TypeScript API)
+                snap = snapshot(self.browser, snap_opts)
 
                 if snap.status != "success":
                     raise RuntimeError(f"Snapshot failed: {snap.error}")

sentience/browser.py

@@ -33,6 +33,8 @@ class SentienceBrowser:
         proxy: str | None = None,
         user_data_dir: str | None = None,
         storage_state: str | Path | StorageState | dict | None = None,
+        record_video_dir: str | Path | None = None,
+        record_video_size: dict[str, int] | None = None,
     ):
         """
         Initialize Sentience browser
@@ -57,6 +59,14 @@ class SentienceBrowser:
                           - StorageState object
                           - Dictionary with 'cookies' and/or 'origins' keys
                           If provided, browser starts with pre-injected authentication.
+            record_video_dir: Optional directory path to save video recordings.
+                            If provided, browser will record video of all pages.
+                            Videos are saved as .webm files in the specified directory.
+                            If None, no video recording is performed.
+            record_video_size: Optional video resolution as dict with 'width' and 'height' keys.
+                             Examples: {"width": 1280, "height": 800} (default)
+                                      {"width": 1920, "height": 1080} (1080p)
+                             If None, defaults to 1280x800.
         """
         self.api_key = api_key
         # Only set api_url if api_key is provided, otherwise None (free tier)
@@ -80,6 +90,10 @@ class SentienceBrowser:
         self.user_data_dir = user_data_dir
         self.storage_state = storage_state
 
+        # Video recording support
+        self.record_video_dir = record_video_dir
+        self.record_video_size = record_video_size or {"width": 1280, "height": 800}
+
         self.playwright: Playwright | None = None
         self.context: BrowserContext | None = None
         self.page: Page | None = None
@@ -209,6 +223,17 @@ class SentienceBrowser:
             launch_params["ignore_https_errors"] = True
             print(f"🌐 [Sentience] Using proxy: {proxy_config.server}")
 
+        # Add video recording if configured
+        if self.record_video_dir:
+            video_dir = Path(self.record_video_dir)
+            video_dir.mkdir(parents=True, exist_ok=True)
+            launch_params["record_video_dir"] = str(video_dir)
+            launch_params["record_video_size"] = self.record_video_size
+            print(f"🎥 [Sentience] Recording video to: {video_dir}")
+            print(
+                f"   Resolution: {self.record_video_size['width']}x{self.record_video_size['height']}"
+            )
+
         # Launch persistent context (required for extensions)
         # Note: We pass headless=False to launch_persistent_context because we handle
         # headless mode via the --headless=new arg above. This is a Playwright workaround.
@@ -390,15 +415,71 @@ class SentienceBrowser:
 
         return False
 
-    def close(self) -> None:
-        """Close browser and cleanup"""
+    def close(self, output_path: str | Path | None = None) -> str | None:
+        """
+        Close browser and cleanup
+
+        Args:
+            output_path: Optional path to rename the video file to.
+                        If provided, the recorded video will be moved to this location.
+                        Useful for giving videos meaningful names instead of random hashes.
+
+        Returns:
+            Path to video file if recording was enabled, None otherwise
+            Note: Video files are saved automatically by Playwright when context closes.
+            If multiple pages exist, returns the path to the first page's video.
+        """
+        temp_video_path = None
+
+        # Get video path before closing (if recording was enabled)
+        # Note: Playwright saves videos when pages/context close, but we can get the
+        # expected path before closing. The actual file will be available after close.
+        if self.record_video_dir:
+            try:
+                # Try to get video path from the first page
+                if self.page and self.page.video:
+                    temp_video_path = self.page.video.path()
+                # If that fails, check all pages in the context
+                elif self.context:
+                    for page in self.context.pages:
+                        if page.video:
+                            temp_video_path = page.video.path()
+                            break
+            except Exception:
+                # Video path might not be available until after close
+                # In that case, we'll return None and user can check the directory
+                pass
+
+        # Close context (this triggers video file finalization)
         if self.context:
             self.context.close()
+
+        # Close playwright
         if self.playwright:
             self.playwright.stop()
+
+        # Clean up extension directory
         if self._extension_path and os.path.exists(self._extension_path):
             shutil.rmtree(self._extension_path)
 
+        # Rename/move video if output_path is specified
+        final_path = temp_video_path
+        if temp_video_path and output_path and os.path.exists(temp_video_path):
+            try:
+                output_path = str(output_path)
+                # Ensure parent directory exists
+                Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+                shutil.move(temp_video_path, output_path)
+                final_path = output_path
+            except Exception as e:
+                import warnings
+
+                warnings.warn(f"Failed to rename video file: {e}")
+                # Return original path if rename fails
+                final_path = temp_video_path
+
+        return final_path
+
     def __enter__(self):
         """Context manager entry"""
         self.start()

sentience/cloud_tracing.py

@@ -213,7 +213,10 @@ class CloudTraceSink(TraceSink):
                 if on_progress:
                     on_progress(compressed_size, compressed_size)
 
-                # Call /v1/traces/complete to report file sizes (NEW)
+                # Upload trace index file
+                self._upload_index()
+
+                # Call /v1/traces/complete to report file sizes
                 self._complete_trace()
 
                 # Delete file only on successful upload
@@ -244,6 +247,95 @@ class CloudTraceSink(TraceSink):
             # Non-fatal: log but don't crash
             print(f"⚠️  Failed to generate trace index: {e}")
 
+    def _upload_index(self) -> None:
+        """
+        Upload trace index file to cloud storage.
+
+        Called after successful trace upload to provide fast timeline rendering.
+        The index file enables O(1) step lookups without parsing the entire trace.
+        """
+        # Construct index file path (same as trace file with .index.json extension)
+        index_path = Path(str(self._path).replace(".jsonl", ".index.json"))
+
+        if not index_path.exists():
+            if self.logger:
+                self.logger.warning("Index file not found, skipping index upload")
+            return
+
+        try:
+            # Request index upload URL from API
+            if not self.api_key:
+                # No API key - skip index upload
+                if self.logger:
+                    self.logger.info("No API key provided, skipping index upload")
+                return
+
+            response = requests.post(
+                f"{self.api_url}/v1/traces/index_upload",
+                headers={"Authorization": f"Bearer {self.api_key}"},
+                json={"run_id": self.run_id},
+                timeout=10,
+            )
+
+            if response.status_code != 200:
+                if self.logger:
+                    self.logger.warning(
+                        f"Failed to get index upload URL: HTTP {response.status_code}"
+                    )
+                return
+
+            upload_data = response.json()
+            index_upload_url = upload_data.get("upload_url")
+
+            if not index_upload_url:
+                if self.logger:
+                    self.logger.warning("No upload URL in index upload response")
+                return
+
+            # Read and compress index file
+            with open(index_path, "rb") as f:
+                index_data = f.read()
+
+            compressed_index = gzip.compress(index_data)
+            index_size = len(compressed_index)
+
+            if self.logger:
+                self.logger.info(f"Index file size: {index_size / 1024:.2f} KB")
+
+            print(f"📤 [Sentience] Uploading trace index ({index_size} bytes)...")
+
+            # Upload index to cloud storage
+            index_response = requests.put(
+                index_upload_url,
+                data=compressed_index,
+                headers={
+                    "Content-Type": "application/json",
+                    "Content-Encoding": "gzip",
+                },
+                timeout=30,
+            )
+
+            if index_response.status_code == 200:
+                print("✅ [Sentience] Trace index uploaded successfully")
+
+                # Delete local index file after successful upload
+                try:
+                    os.remove(index_path)
+                except Exception:
+                    pass  # Ignore cleanup errors
+            else:
+                if self.logger:
+                    self.logger.warning(
+                        f"Index upload failed: HTTP {index_response.status_code}"
+                    )
+                print(f"⚠️  [Sentience] Index upload failed: HTTP {index_response.status_code}")
+
+        except Exception as e:
+            # Non-fatal: log but don't crash
+            if self.logger:
+                self.logger.warning(f"Error uploading trace index: {e}")
+            print(f"⚠️  [Sentience] Error uploading trace index: {e}")
+
     def _complete_trace(self) -> None:
         """
         Call /v1/traces/complete to report file sizes to gateway.

sentience/conversational_agent.py

@@ -10,7 +10,7 @@ from typing import Any
 from .agent import SentienceAgent
 from .browser import SentienceBrowser
 from .llm_provider import LLMProvider
-from .models import Snapshot
+from .models import Snapshot, SnapshotOptions
 from .snapshot import snapshot
 
 
@@ -274,7 +274,7 @@ Create a step-by-step execution plan."""
             elif action == "EXTRACT_INFO":
                 info_type = params["info_type"]
                 # Get current page snapshot and extract info
-                snap = snapshot(self.browser, limit=50)
+                snap = snapshot(self.browser, SnapshotOptions(limit=50))
 
                 # Use LLM to extract specific information
                 extracted = self._extract_information(snap, info_type)
@@ -361,7 +361,7 @@ Return JSON with extracted information:
             True if condition is met, False otherwise
         """
         try:
-            snap = snapshot(self.browser, limit=30)
+            snap = snapshot(self.browser, SnapshotOptions(limit=30))
 
             # Build context
             elements_text = "\n".join([f"{el.role}: {el.text}" for el in snap.elements[:20]])

sentience/extension/release.json

@@ -67,7 +67,7 @@
       "state": "uploaded",
       "size": 78091,
       "digest": "sha256:e281f8b755b61da4b8015d6172064aa9a337c14133ceceff4ab29199ee53307e",
-      "download_count": 2,
+      "download_count": 4,
       "created_at": "2025-12-29T03:57:09Z",
       "updated_at": "2025-12-29T03:57:09Z",
       "browser_download_url": "https://github.com/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/download/v2.0.7/extension-files.tar.gz"

sentience/snapshot.py

@@ -5,7 +5,7 @@ Snapshot functionality - calls window.sentience.snapshot() or server-side API
 import json
 import os
 import time
-from typing import Any
+from typing import Any, Optional
 
 import requests
 
@@ -41,41 +41,33 @@ def _save_trace_to_file(raw_elements: list[dict[str, Any]], trace_path: str | No
 
 def snapshot(
     browser: SentienceBrowser,
-    screenshot: bool | None = None,
-    limit: int | None = None,
-    filter: dict[str, Any] | None = None,
-    use_api: bool | None = None,
-    save_trace: bool = False,
-    trace_path: str | None = None,
-    show_overlay: bool = False,
+    options: Optional[SnapshotOptions] = None,
 ) -> Snapshot:
     """
     Take a snapshot of the current page
 
     Args:
         browser: SentienceBrowser instance
-        screenshot: Whether to capture screenshot (bool or dict with format/quality)
-        limit: Limit number of elements returned
-        filter: Filter options (min_area, allowed_roles, min_z_index)
-        use_api: Force use of server-side API if True, local extension if False.
-                 If None, uses API if api_key is set, otherwise uses local extension.
-        save_trace: Whether to save raw_elements to JSON for benchmarking/training
-        trace_path: Path to save trace file. If None, uses "trace_{timestamp}.json"
-        show_overlay: Show visual overlay highlighting elements in browser
+        options: Snapshot options (screenshot, limit, filter, etc.)
+                If None, uses default options.
 
     Returns:
         Snapshot object
+
+    Example:
+        # Basic snapshot with defaults
+        snap = snapshot(browser)
+
+        # With options
+        snap = snapshot(browser, SnapshotOptions(
+            screenshot=True,
+            limit=100,
+            show_overlay=True
+        ))
     """
-    # Build SnapshotOptions from individual parameters
-    options = SnapshotOptions(
-        screenshot=screenshot if screenshot is not None else False,
-        limit=limit if limit is not None else 50,
-        filter=filter,
-        use_api=use_api,
-        save_trace=save_trace,
-        trace_path=trace_path,
-        show_overlay=show_overlay,
-    )
+    # Use default options if none provided
+    if options is None:
+        options = SnapshotOptions()
 
     # Determine if we should use server-side API
     should_use_api = (

sentience/text_search.py

@@ -127,9 +127,7 @@ def find_text_rect(
     except RuntimeError:
         raise
     except Exception as e:
-        raise RuntimeError(
-            f"Failed to verify findTextRect availability: {e}"
-        ) from e
+        raise RuntimeError(f"Failed to verify findTextRect availability: {e}") from e
 
     # Call the extension's findTextRect method
     result_dict = browser.page.evaluate(

sentience/trace_indexing/__init__.py

@@ -2,16 +2,16 @@
 Trace indexing module for Sentience SDK.
 """
 
-from .indexer import build_trace_index, write_trace_index, read_step_events
 from .index_schema import (
-    TraceIndex,
-    StepIndex,
-    TraceSummary,
-    TraceFileInfo,
-    SnapshotInfo,
     ActionInfo,
+    SnapshotInfo,
     StepCounters,
+    StepIndex,
+    TraceFileInfo,
+    TraceIndex,
+    TraceSummary,
 )
+from .indexer import build_trace_index, read_step_events, write_trace_index
 
 __all__ = [
     "build_trace_index",

sentience/trace_indexing/index_schema.py

@@ -2,8 +2,8 @@
 Type definitions for trace index schema using concrete classes.
 """
 
-from dataclasses import dataclass, field, asdict
-from typing import Optional, List, Literal
+from dataclasses import asdict, dataclass, field
+from typing import List, Literal, Optional
 
 
 @dataclass
@@ -27,7 +27,7 @@ class TraceSummary:
     event_count: int
     step_count: int
     error_count: int
-    final_url: Optional[str]
+    final_url: str | None
 
     def to_dict(self) -> dict:
         return asdict(self)
@@ -37,9 +37,9 @@ class TraceSummary:
 class SnapshotInfo:
     """Snapshot metadata for index."""
 
-    snapshot_id: Optional[str] = None
-    digest: Optional[str] = None
-    url: Optional[str] = None
+    snapshot_id: str | None = None
+    digest: str | None = None
+    url: str | None = None
 
     def to_dict(self) -> dict:
         return asdict(self)
@@ -49,10 +49,10 @@ class SnapshotInfo:
 class ActionInfo:
     """Action metadata for index."""
 
-    type: Optional[str] = None
-    target_element_id: Optional[int] = None
-    args_digest: Optional[str] = None
-    success: Optional[bool] = None
+    type: str | None = None
+    target_element_id: int | None = None
+    args_digest: str | None = None
+    success: bool | None = None
 
     def to_dict(self) -> dict:
         return asdict(self)
@@ -77,14 +77,14 @@ class StepIndex:
 
     step_index: int
     step_id: str
-    goal: Optional[str]
+    goal: str | None
     status: Literal["ok", "error", "partial"]
     ts_start: str
     ts_end: str
     offset_start: int
     offset_end: int
-    url_before: Optional[str]
-    url_after: Optional[str]
+    url_before: str | None
+    url_after: str | None
     snapshot_before: SnapshotInfo
     snapshot_after: SnapshotInfo
     action: ActionInfo
@@ -104,7 +104,7 @@ class TraceIndex:
     created_at: str
     trace_file: TraceFileInfo
     summary: TraceSummary
-    steps: List[StepIndex] = field(default_factory=list)
+    steps: list[StepIndex] = field(default_factory=list)
 
     def to_dict(self) -> dict:
         """Convert to dictionary for JSON serialization."""

sentience/trace_indexing/indexer.py

@@ -10,13 +10,13 @@ from pathlib import Path
 from typing import Any, Dict, List
 
 from .index_schema import (
-    TraceIndex,
-    StepIndex,
-    TraceSummary,
-    TraceFileInfo,
-    SnapshotInfo,
     ActionInfo,
+    SnapshotInfo,
     StepCounters,
+    StepIndex,
+    TraceFileInfo,
+    TraceIndex,
+    TraceSummary,
 )
 
 
@@ -34,7 +34,7 @@ def _normalize_text(text: str | None, max_len: int = 80) -> str:
     return normalized
 
 
-def _round_bbox(bbox: Dict[str, float], precision: int = 2) -> Dict[str, int]:
+def _round_bbox(bbox: dict[str, float], precision: int = 2) -> dict[str, int]:
     """Round bbox coordinates to reduce noise (default: 2px precision)."""
     return {
         "x": round(bbox.get("x", 0) / precision) * precision,
@@ -44,7 +44,7 @@ def _round_bbox(bbox: Dict[str, float], precision: int = 2) -> Dict[str, int]:
     }
 
 
-def _compute_snapshot_digest(snapshot_data: Dict[str, Any]) -> str:
+def _compute_snapshot_digest(snapshot_data: dict[str, Any]) -> str:
     """
     Compute stable digest of snapshot for diffing.
 
@@ -62,9 +62,7 @@ def _compute_snapshot_digest(snapshot_data: Dict[str, Any]) -> str:
             "id": elem.get("id"),
             "role": elem.get("role", ""),
             "text_norm": _normalize_text(elem.get("text")),
-            "bbox": _round_bbox(
-                elem.get("bbox", {"x": 0, "y": 0, "width": 0, "height": 0})
-            ),
+            "bbox": _round_bbox(elem.get("bbox", {"x": 0, "y": 0, "width": 0, "height": 0})),
             "is_primary": elem.get("is_primary", False),
             "is_clickable": elem.get("is_clickable", False),
         }
@@ -89,7 +87,7 @@ def _compute_snapshot_digest(snapshot_data: Dict[str, Any]) -> str:
     return f"sha256:{digest}"
 
 
-def _compute_action_digest(action_data: Dict[str, Any]) -> str:
+def _compute_action_digest(action_data: dict[str, Any]) -> str:
     """
     Compute digest of action args for privacy + determinism.
 
@@ -152,8 +150,8 @@ def build_trace_index(trace_path: str) -> TraceIndex:
     error_count = 0
     final_url = None
 
-    steps_by_id: Dict[str, StepIndex] = {}
-    step_order: List[str] = []  # Track order of first appearance
+    steps_by_id: dict[str, StepIndex] = {}
+    step_order: list[str] = []  # Track order of first appearance
 
     # Stream through file, tracking byte offsets
     with open(trace_path, "rb") as f:
@@ -228,9 +226,7 @@ def build_trace_index(trace_path: str) -> TraceIndex:
                     )
                     step.url_before = step.url_before or url
 
-                step.snapshot_after = SnapshotInfo(
-                    snapshot_id=snapshot_id, digest=digest, url=url
-                )
+                step.snapshot_after = SnapshotInfo(snapshot_id=snapshot_id, digest=digest, url=url)
                 step.url_after = url
                 step.counters.snapshots += 1
                 final_url = url
@@ -311,9 +307,7 @@ def write_trace_index(trace_path: str, index_path: str | None = None) -> str:
     return index_path
 
 
-def read_step_events(
-    trace_path: str, offset_start: int, offset_end: int
-) -> List[Dict[str, Any]]:
+def read_step_events(trace_path: str, offset_start: int, offset_end: int) -> list[dict[str, Any]]:
     """
     Read events for a specific step using byte offsets from index.
 

sentience/wait.py

@@ -5,7 +5,7 @@ Wait functionality - wait_for element matching selector
 import time
 
 from .browser import SentienceBrowser
-from .models import WaitResult
+from .models import WaitResult, SnapshotOptions
 from .query import find
 from .snapshot import snapshot
 
@@ -46,7 +46,7 @@ def wait_for(
 
     while time.time() - start_time < timeout:
         # Take snapshot (may be local extension or remote API)
-        snap = snapshot(browser, use_api=use_api)
+        snap = snapshot(browser, SnapshotOptions(use_api=use_api))
 
         # Try to find element
         element = find(snap, selector)

{sentienceapi-0.90.11.dist-info → sentienceapi-0.90.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sentienceapi
-Version: 0.90.11
+Version: 0.90.13
 Summary: Python SDK for Sentience AI Agent Browser Automation
 Author: Sentience Team
 License: MIT

{sentienceapi-0.90.11.dist-info → sentienceapi-0.90.13.dist-info}/RECORD

@@ -1,12 +1,12 @@
-sentience/__init__.py,sha256=qYtKo0JklnM7rI5GKH_mU717mWYBxxneR9copIPEkxI,3410
+sentience/__init__.py,sha256=AssM2lIDnK5UV7x1n_4S5yJbZ2xEgkGr86DKiQKHkTg,3410
 sentience/actions.py,sha256=RT8AoR_CNyp6bMCYhkToWH1WB8cyB8dcFJZMhfskTeo,13239
-sentience/agent.py,sha256=rTAaQGiuZIohrJZXpCK-dZWuoAR3k_dQodjFLBkrCxY,24527
+sentience/agent.py,sha256=IKSxDDCyMyGx8mMvIT4kq3HXtKNaK7BiHNGXnxHCkZc,23844
 sentience/agent_config.py,sha256=blyCUh2pjMOI6YQGLWP8mSi6GTnpzWLWem4nwYg3ngA,1489
 sentience/base_agent.py,sha256=861XkIJeig9nqdt7f2wfFKyxanGZtDhnrgsMDdXtkFM,2979
-sentience/browser.py,sha256=At0VYO3oagyaMrUcs6w2TxISztrQxSWpGpuSmVsAqwQ,17441
+sentience/browser.py,sha256=jB59HfZHHUOKTORA7gsaQlIKEZyxwivvW4VU9swyy_k,21311
 sentience/cli.py,sha256=R95DgCSJmezuymAdfL6fzUdB1HpCF3iMWcLO73KJ8eY,3851
-sentience/cloud_tracing.py,sha256=Y_20sdvOiYoavIJWh_ogZYb6H3RMRP59uM9p4u3QrGo,10128
-sentience/conversational_agent.py,sha256=UUgltp-EkAbAzE6Pa_S72t7fWbdIwb3C2YppXzPx2jA,17207
+sentience/cloud_tracing.py,sha256=KxVIT-HQW9EaX5GWC9DEVM2cdObomD3hkPNEnTceSpc,13541
+sentience/conversational_agent.py,sha256=8o2bvdaxoqgK-hHM1AVOywwKWyZturp1oLFcl6JtqCw,17258
 sentience/expect.py,sha256=BFSRocNJr6ZAusb6fy4OgfDNCukGfu5jto760bFN12E,2851
 sentience/formatting.py,sha256=0_UklIUd94a4W32gTorjxoXNE03qdffR-omfTA5eHF0,1828
 sentience/generator.py,sha256=Wj--yn6bVo02nABBzrAIKPMmU8TRQm3JHAOER9XXT4Y,8035
@@ -18,29 +18,29 @@ sentience/query.py,sha256=P9Hs3otwESNncaArUwaw73mNNRFeOgpjy-fOTDQiCOI,10474
 sentience/read.py,sha256=qoSbahcNumvb0mUe-WcWrKrkKCEqya6Ac7wqXFe3SRI,3490
 sentience/recorder.py,sha256=RWzkJP6LWiFAJUfbXQS3aAnRgl7aDrWuKw3slp-gR1Y,12496
 sentience/screenshot.py,sha256=1UJjRvPxPpiL3w1_MBvO_UPMAsmt-uyRujTYA50jim0,1607
-sentience/snapshot.py,sha256=zFQa-jGh8MBPuyvZZ3kam_d8qN93UtmigCvj9m2V5Ts,9947
-sentience/text_search.py,sha256=MK36zgtB7zqAW_Yxy6e9MqU3avTrIzKCgHc63nYjIJc,5775
+sentience/snapshot.py,sha256=OTxrp8tJQbkhHKZQHglJSn5dF4roeO4_JhzHx6t3HsA,9269
+sentience/text_search.py,sha256=UF7-Dlo69Stx_vkfcu5ss3dKCVgyWODrafJoJXU9NCw,5753
 sentience/tracer_factory.py,sha256=Fc_kb8ffJVGdy91cnxpxU2xjFZUyS2OiaI2pqtvl2lk,7643
 sentience/tracing.py,sha256=ciYSW3QXcO0BYDtjeKQLfpAysObBIKQKCAlviwU74AQ,7240
 sentience/utils.py,sha256=ryxiDVE_sUPHYmYnWYXADuyciD_ZawmsITDZNUeDVJg,8116
-sentience/wait.py,sha256=8E_5aRS3GJ4igDwWzMJvIV6ENPsqX19JGwXCPAMkX6s,2195
+sentience/wait.py,sha256=KJT7ITX-cO7hKOqwn4rvjIZrv8Id-Ug_o7fb-IHUwgM,2229
 sentience/extension/background.js,sha256=USlH3L6khes4YdhSkO2AkiSkqfGxdAbzt5KPsLMv9B0,8967
 sentience/extension/content.js,sha256=3lMCz9A9azFH-SdToUPqRd9b6Ssbn4R_WKzigHw8d_k,10458
 sentience/extension/injected_api.js,sha256=5SY-U0V2Kv-T85ss3zZcOvdRTLB2E3wvvK8GOX5vR3A,65355
 sentience/extension/manifest.json,sha256=MfkfsS5zVxb-scqJllN8aubrRN9vsznQ3-Aw69pZ47c,897
-sentience/extension/release.json,sha256=ikdgGGy_Jf6r_P6dKOUUaVZOQYMIRHz3ok5dVclxoT8,6437
+sentience/extension/release.json,sha256=KRRWbaBPVhWCES26NbU4alvSN2624b9skkv4_Wb5HXU,6437
 sentience/extension/test-content.js,sha256=RX6A42W-5pjP-avqGwrRq_GVp5yX2NqBDlDLc-SWL5g,156
 sentience/extension/pkg/sentience_core.d.ts,sha256=qrTEIR2WPkk1MmaSQzEpRyagbE9VirHowzZpbj41qeQ,1981
 sentience/extension/pkg/sentience_core.js,sha256=zldlOubec0pbNYhquwDzoQKuBF4SUVcIeXW_qLx0dVA,17904
 sentience/extension/pkg/sentience_core_bg.wasm,sha256=HtzBY8z4XgRgHHUqHQGm84EEQJirpf25wSVTXg-iJ1g,102522
 sentience/extension/pkg/sentience_core_bg.wasm.d.ts,sha256=O3c3HaUqmB6Aob6Pt0n3GEtTxM4VGeaClaA_-z2m2J4,517
 sentience/schemas/trace_v1.json,sha256=XpByPqRH1xzHmD7YeuaDE5ZaEb3L5fz762djcwXqPV8,7593
-sentience/trace_indexing/__init__.py,sha256=LuLRaq3Wjc1dZn9eXxI426oE_nahep-XadtsLMDIHSw,499
-sentience/trace_indexing/index_schema.py,sha256=hgkb2vUUQ_aqfa6DN5MR2wMjDvGtbfGmyGXNA_07IZg,2213
-sentience/trace_indexing/indexer.py,sha256=mqayI_Hl160Yb_3OBF3G-zsfZ3Stc8dNDMjebDJvAcs,10885
-sentienceapi-0.90.11.dist-info/licenses/LICENSE.md,sha256=Pl8BWUOOkFtYpgVhNwCl3YKzRvUpYid2utlJELIgr_8,3783
-sentienceapi-0.90.11.dist-info/METADATA,sha256=lMhnwilyuN5dilccgmd-MMv7PQcPRpghyerZRjDzbqg,26131
-sentienceapi-0.90.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sentienceapi-0.90.11.dist-info/entry_points.txt,sha256=HdW1BvgRJm3ZAbbqrwTvDWE2KbmVz-Ue0wllW-mLmvA,49
-sentienceapi-0.90.11.dist-info/top_level.txt,sha256=A9IKao--8PsFFz5vDfBIXWHgN6oh3HkMQSiQWgUTUBQ,10
-sentienceapi-0.90.11.dist-info/RECORD,,
+sentience/trace_indexing/__init__.py,sha256=urjLuqqXCQE8pnwpYBqoMKnzZSqFJkM1SHmFve9RVE8,499
+sentience/trace_indexing/index_schema.py,sha256=Hz9igHFrHATTZOqKNiLhESjnGbDPTyRTejMGT1AKC8g,2180
+sentience/trace_indexing/indexer.py,sha256=m-p57Va0cFlCpuMWkXNSHqODpGzpESZzoOkt3OiejlM,10811
+sentienceapi-0.90.13.dist-info/licenses/LICENSE.md,sha256=Pl8BWUOOkFtYpgVhNwCl3YKzRvUpYid2utlJELIgr_8,3783
+sentienceapi-0.90.13.dist-info/METADATA,sha256=xC9snXYmpohGd5NyyL7J4lahIW-r_hjQRPr1iiMOYSA,26131
+sentienceapi-0.90.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sentienceapi-0.90.13.dist-info/entry_points.txt,sha256=HdW1BvgRJm3ZAbbqrwTvDWE2KbmVz-Ue0wllW-mLmvA,49
+sentienceapi-0.90.13.dist-info/top_level.txt,sha256=A9IKao--8PsFFz5vDfBIXWHgN6oh3HkMQSiQWgUTUBQ,10
+sentienceapi-0.90.13.dist-info/RECORD,,