arize-phoenix 11.4.0__py3-none-any.whl → 11.5.0__py3-none-any.whl

phoenix/server/api/routers/v1/users.py

@@ -43,7 +43,7 @@ from phoenix.server.api.routers.v1.utils import (
     add_errors_to_responses,
 )
 from phoenix.server.api.types.node import from_global_id_with_expected_type
-from phoenix.server.authorization import require_admin
+from phoenix.server.authorization import is_not_locked, require_admin
 
 logger = logging.getLogger(__name__)
 
@@ -194,7 +194,7 @@ async def list_users(
             HTTP_422_UNPROCESSABLE_ENTITY,
         ]
     ),
-    dependencies=[Depends(require_admin)],
+    dependencies=[Depends(require_admin), Depends(is_not_locked)],
     response_model_by_alias=True,
     response_model_exclude_unset=True,
     response_model_exclude_defaults=True,

phoenix/server/app.py

@@ -16,17 +16,20 @@ from typing import (
     Any,
     NamedTuple,
     Optional,
+    Protocol,
     TypedDict,
     Union,
     cast,
 )
 from urllib.parse import urlparse
 
+import grpc
 import strawberry
 from fastapi import APIRouter, Depends, FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.utils import is_body_allowed_for_status_code
 from grpc.aio import ServerInterceptor
+from grpc_interceptor import AsyncServerInterceptor
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker
 from starlette.datastructures import URL, Secret
@@ -44,7 +47,7 @@ from starlette.types import Scope, StatefulLifespan
 from strawberry.extensions import SchemaExtension
 from strawberry.fastapi import GraphQLRouter
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL
-from typing_extensions import TypeAlias
+from typing_extensions import TypeAlias, override
 
 import phoenix.trace.v1 as pb
 from phoenix.config import (
@@ -134,6 +137,7 @@ from phoenix.server.api.routers import (
 from phoenix.server.api.routers.v1 import REST_API_VERSION
 from phoenix.server.api.schema import build_graphql_schema
 from phoenix.server.bearer_auth import BearerTokenAuthBackend, is_authenticated
+from phoenix.server.daemons.db_disk_usage_monitor import DbDiskUsageMonitor
 from phoenix.server.daemons.generative_model_store import GenerativeModelStore
 from phoenix.server.daemons.span_cost_calculator import SpanCostCalculator
 from phoenix.server.dml_event import DmlEvent
@@ -523,6 +527,7 @@ def _lifespan(
     trace_data_sweeper: Optional[TraceDataSweeper],
     span_cost_calculator: SpanCostCalculator,
     generative_model_store: GenerativeModelStore,
+    db_disk_usage_monitor: DbDiskUsageMonitor,
     token_store: Optional[TokenStore] = None,
     tracer_provider: Optional["TracerProvider"] = None,
     enable_prometheus: bool = False,
@@ -530,6 +535,7 @@ def _lifespan(
     shutdown_callbacks: Iterable[_Callback] = (),
     read_only: bool = False,
     scaffolder_config: Optional[ScaffolderConfig] = None,
+    grpc_interceptors: Iterable[AsyncServerInterceptor] = (),
 ) -> StatefulLifespan[FastAPI]:
     @contextlib.asynccontextmanager
     async def lifespan(_: FastAPI) -> AsyncIterator[dict[str, Any]]:
@@ -551,7 +557,7 @@ def _lifespan(
                 tracer_provider=tracer_provider,
                 enable_prometheus=enable_prometheus,
                 token_store=token_store,
-                interceptors=user_grpc_interceptors(),
+                interceptors=user_grpc_interceptors() + list(grpc_interceptors),
             )
             await stack.enter_async_context(grpc_server)
             await stack.enter_async_context(dml_event_handler)
@@ -559,6 +565,7 @@ def _lifespan(
                 await stack.enter_async_context(trace_data_sweeper)
             await stack.enter_async_context(span_cost_calculator)
             await stack.enter_async_context(generative_model_store)
+            await stack.enter_async_context(db_disk_usage_monitor)
             if scaffolder_config:
                 scaffolder = Scaffolder(
                     config=scaffolder_config,
@@ -826,6 +833,34 @@ async def plain_text_http_exception_handler(request: Request, exc: HTTPException
     return PlainTextResponse(str(exc.detail), status_code=exc.status_code, headers=headers)
 
 
+class _HasDbStatus(Protocol):
+    @property
+    def should_not_insert_or_update(self) -> bool: ...
+
+
+class DbDiskUsageInterceptor(AsyncServerInterceptor):
+    def __init__(self, db: _HasDbStatus) -> None:
+        self._db = db
+
+    @override
+    async def intercept(
+        self,
+        method: Callable[[Any, grpc.aio.ServicerContext], Awaitable[Any]],
+        request_or_iterator: Any,
+        context: grpc.aio.ServicerContext,
+        method_name: str,
+    ) -> Any:
+        if (
+            method_name.endswith("trace.v1.TraceService/Export")
+            and self._db.should_not_insert_or_update
+        ):
+            await context.abort(
+                grpc.StatusCode.RESOURCE_EXHAUSTED,
+                "Database disk usage threshold exceeded",
+            )
+        return await method(request_or_iterator, context)
+
+
 def create_app(
     db: DbSessionFactory,
     export_path: Path,
@@ -971,6 +1006,8 @@ def create_app(
         from phoenix.server.prometheus import PrometheusMiddleware
 
         middlewares.append(Middleware(PrometheusMiddleware))
+    grpc_interceptors: list[AsyncServerInterceptor] = []
+    grpc_interceptors.append(DbDiskUsageInterceptor(db))
     app = FastAPI(
         title="Arize-Phoenix REST API",
         version=REST_API_VERSION,
@@ -982,6 +1019,8 @@ def create_app(
             trace_data_sweeper=trace_data_sweeper,
             span_cost_calculator=span_cost_calculator,
             generative_model_store=generative_model_store,
+            db_disk_usage_monitor=DbDiskUsageMonitor(db, email_sender),
+            grpc_interceptors=grpc_interceptors,
             token_store=token_store,
             tracer_provider=tracer_provider,
             enable_prometheus=enable_prometheus,

phoenix/server/authorization.py

@@ -51,3 +51,12 @@ def require_admin(request: Request) -> None:
             status_code=fastapi_status.HTTP_403_FORBIDDEN,
             detail="Only admin or system users can perform this action.",
         )
+
+
+def is_not_locked(request: Request) -> None:
+    if request.app.state.db.should_not_insert_or_update:
+        raise HTTPException(
+            status_code=fastapi_status.HTTP_507_INSUFFICIENT_STORAGE,
+            detail="Operations that insert or update database "
+            "records are currently not allowed.",
+        )

phoenix/server/bearer_auth.py

@@ -7,10 +7,10 @@ from typing import Any, Optional, cast
 import grpc
 from fastapi import HTTPException, Request, WebSocket, WebSocketException
 from grpc_interceptor import AsyncServerInterceptor
-from grpc_interceptor.exceptions import Unauthenticated
 from starlette.authentication import AuthCredentials, AuthenticationBackend, BaseUser
 from starlette.requests import HTTPConnection
 from starlette.status import HTTP_401_UNAUTHORIZED
+from typing_extensions import override
 
 from phoenix import config
 from phoenix.auth import (
@@ -100,16 +100,19 @@ class PhoenixSystemUser(PhoenixUser):
 
 
 class ApiKeyInterceptor(HasTokenStore, AsyncServerInterceptor):
+    @override
     async def intercept(
         self,
-        method: Callable[[Any, grpc.ServicerContext], Awaitable[Any]],
+        method: Callable[[Any, grpc.aio.ServicerContext], Awaitable[Any]],
         request_or_iterator: Any,
-        context: grpc.ServicerContext,
+        context: grpc.aio.ServicerContext,
         method_name: str,
     ) -> Any:
-        for datum in context.invocation_metadata():
-            if datum.key.lower() == "authorization":
-                scheme, _, token = datum.value.partition(" ")
+        for key, value in context.invocation_metadata() or ():
+            if key.lower() == "authorization":
+                if isinstance(value, bytes):
+                    value = value.decode("utf-8")
+                scheme, _, token = value.partition(" ")
                 if scheme.lower() != "bearer" or not token:
                     break
                 if (
@@ -119,16 +122,16 @@ class ApiKeyInterceptor(HasTokenStore, AsyncServerInterceptor):
                 ):
                     return await method(request_or_iterator, context)
                 claims = await self._token_store.read(Token(token))
-                if not (isinstance(claims, UserClaimSet) and isinstance(claims.subject, UserId)):
+                if (
+                    not (
+                        isinstance(claims, (ApiKeyClaims, AccessTokenClaims))
+                        and isinstance(claims.subject, UserId)
+                    )
+                    or claims.status is not ClaimSetStatus.VALID
+                ):
                     break
-                if not isinstance(claims, (ApiKeyClaims, AccessTokenClaims)):
-                    raise Unauthenticated(details="Invalid token")
-                if claims.status is ClaimSetStatus.EXPIRED:
-                    raise Unauthenticated(details="Expired token")
-                if claims.status is ClaimSetStatus.VALID:
-                    return await method(request_or_iterator, context)
-                raise Unauthenticated()
-        raise Unauthenticated()
+                return await method(request_or_iterator, context)
+        await context.abort(grpc.StatusCode.UNAUTHENTICATED)
 
 
 async def is_authenticated(

phoenix/server/daemons/db_disk_usage_monitor.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import logging
+from asyncio import sleep
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+import sqlalchemy as sa
+from email_validator import EmailNotValidError, validate_email
+from sqlalchemy import text
+from typing_extensions import assert_never
+
+from phoenix.config import (
+    get_env_database_allocated_storage_capacity_gibibytes,
+    get_env_database_usage_email_warning_threshold_percentage,
+    get_env_database_usage_insertion_blocking_threshold_percentage,
+)
+from phoenix.db import models
+from phoenix.db.helpers import SupportedSQLDialect
+from phoenix.server.email.types import DbUsageWarningEmailSender
+from phoenix.server.prometheus import (
+    DB_DISK_USAGE_BYTES,
+    DB_DISK_USAGE_RATIO,
+    DB_DISK_USAGE_WARNING_EMAIL_ERRORS,
+    DB_DISK_USAGE_WARNING_EMAILS_SENT,
+    DB_INSERTIONS_BLOCKED,
+)
+from phoenix.server.types import DaemonTask, DbSessionFactory
+
+logger = logging.getLogger(__name__)
+
+_SLEEP_SECONDS = 60
+_EMAIL_FREQUENCY_HOURS = 24
+_BYTES_PER_GIBIBYTE = 1024**3
+
+
+class DbDiskUsageMonitor(DaemonTask):
+    """
+    Monitors database disk space usage and triggers warnings/blocking when thresholds are exceeded.
+
+    This daemon:
+    - Periodically checks current database size
+    - Compares usage against configured thresholds
+    - Sends warning emails to admins when warning threshold is reached
+    - Toggles insertion blocking when blocking threshold is reached
+    """
+
+    def __init__(
+        self,
+        db: DbSessionFactory,
+        email_sender: Optional[DbUsageWarningEmailSender] = None,
+    ) -> None:
+        super().__init__()
+        self._db = db
+        self._email_sender = email_sender
+        # Tracks last email send time per admin email address to prevent spam
+        self._last_email_sent: dict[str, datetime] = {}
+
+    @property
+    def _is_disabled(self) -> bool:
+        return not bool(
+            get_env_database_allocated_storage_capacity_gibibytes()
+            and (
+                get_env_database_usage_email_warning_threshold_percentage()
+                or get_env_database_usage_insertion_blocking_threshold_percentage()
+            )
+        )
+
+    async def _run(self) -> None:
+        if self._is_disabled:
+            return
+
+        while self._running:
+            try:
+                current_usage_bytes = await self._check_disk_usage_bytes()
+            except Exception:
+                logger.exception("Failed to check disk space")
+            else:
+                DB_DISK_USAGE_BYTES.set(current_usage_bytes)
+                current_usage_gibibytes = current_usage_bytes / _BYTES_PER_GIBIBYTE
+                try:
+                    await self._check_thresholds(current_usage_gibibytes)
+                except Exception:
+                    logger.exception("Failed to check database usage thresholds")
+            await sleep(_SLEEP_SECONDS)
+
+    async def _check_disk_usage_bytes(self) -> float:
+        if self._db.dialect is SupportedSQLDialect.SQLITE:
+            async with self._db() as session:
+                page_count = await session.scalar(text("PRAGMA page_count;"))
+                freelist_count = await session.scalar(text("PRAGMA freelist_count;"))
+                page_size = await session.scalar(text("PRAGMA page_size;"))
+            current_usage_bytes = (page_count - freelist_count) * page_size
+        elif self._db.dialect is SupportedSQLDialect.POSTGRESQL:
+            async with self._db() as session:
+                current_usage_bytes = await session.scalar(
+                    text("SELECT pg_database_size(current_database());")
+                )
+        else:
+            assert_never(self._db.dialect)
+        if not isinstance(current_usage_bytes, (int, float)):
+            raise TypeError(f"Expected int or float, got {type(current_usage_bytes)}")
+        return float(current_usage_bytes)
+
+    async def _check_thresholds(self, current_usage_gibibytes: float) -> None:
+        allocated_capacity_gibibytes = get_env_database_allocated_storage_capacity_gibibytes()
+        if not allocated_capacity_gibibytes:
+            return
+
+        used_ratio = current_usage_gibibytes / allocated_capacity_gibibytes
+        DB_DISK_USAGE_RATIO.set(used_ratio)
+        used_percentage = used_ratio * 100
+
+        # Check insertion blocking threshold
+        if (
+            insertion_blocking_threshold_percentage
+            := get_env_database_usage_insertion_blocking_threshold_percentage()
+        ):
+            should_not_insert_or_update = used_percentage > insertion_blocking_threshold_percentage
+            self._db.should_not_insert_or_update = should_not_insert_or_update
+            DB_INSERTIONS_BLOCKED.set(int(should_not_insert_or_update))
+
+        # Check warning email threshold
+        if (
+            notification_threshold_percentage
+            := get_env_database_usage_email_warning_threshold_percentage()
+        ):
+            if used_percentage > notification_threshold_percentage:
+                await self._send_warning_emails(
+                    used_percentage,
+                    allocated_capacity_gibibytes,
+                    notification_threshold_percentage,
+                )
+
+    async def _send_warning_emails(
+        self,
+        used_percentage: float,
+        allocated_capacity_gibibytes: float,
+        notification_threshold_percentage: float,
+    ) -> None:
+        if not self._email_sender:
+            return
+
+        current_usage_gibibytes = used_percentage / 100 * allocated_capacity_gibibytes
+        stmt = (
+            sa.select(models.User.email)
+            .join(models.UserRole)
+            .where(models.UserRole.name == "ADMIN")
+        )
+
+        try:
+            async with self._db() as session:
+                admin_emails = (await session.scalars(stmt)).all()
+        except Exception:
+            logger.exception(
+                "Failed to fetch admin emails from database, "
+                "skipping database usage warning emails"
+            )
+            return
+
+        if not admin_emails:
+            return
+
+        # Validate email addresses
+        valid_emails: list[str] = []
+
+        for email in admin_emails:
+            try:
+                normalized_email = validate_email(email, check_deliverability=False).normalized
+            except EmailNotValidError:
+                pass
+            else:
+                valid_emails.append(normalized_email)
+
+        if not valid_emails:
+            return
+
+        self._last_email_sent = {
+            email: timestamp
+            for email, timestamp in self._last_email_sent.items()
+            if email in valid_emails
+        }
+
+        now = datetime.now(timezone.utc)
+        emails_sent = 0
+        send_attempts = 0
+
+        for email in valid_emails:
+            if email in self._last_email_sent and now - self._last_email_sent[email] < timedelta(
+                hours=_EMAIL_FREQUENCY_HOURS
+            ):
+                continue
+            send_attempts += 1
+            try:
+                await self._email_sender.send_db_usage_warning_email(
+                    email=email,
+                    current_usage_gibibytes=current_usage_gibibytes,
+                    allocated_storage_gibibytes=allocated_capacity_gibibytes,
+                    notification_threshold_percentage=notification_threshold_percentage,
+                )
+            except Exception:
+                logger.exception(f"Failed to send database usage warning email to {email}")
+                # Count email send errors
+                DB_DISK_USAGE_WARNING_EMAIL_ERRORS.inc()
+            else:
+                self._last_email_sent[email] = now
+                emails_sent += 1
+                # Count successful warning email sends
+                DB_DISK_USAGE_WARNING_EMAILS_SENT.inc()

phoenix/server/email/sender.py

@@ -81,6 +81,31 @@ class SimpleEmailSender:
 
         await to_thread.run_sync(self._send_email, msg)
 
+    async def send_db_usage_warning_email(
+        self,
+        email: str,
+        current_usage_gibibytes: float,
+        allocated_storage_gibibytes: float,
+        notification_threshold_percentage: float,
+    ) -> None:
+        subject = "[Phoenix] Database Usage Threshold Exceeded"
+        template_name = "db_disk_usage_notification.html"
+
+        template = self.env.get_template(template_name)
+        html_content = template.render(
+            current_usage_gibibytes=current_usage_gibibytes,
+            allocated_storage_gibibytes=allocated_storage_gibibytes,
+            notification_threshold_percentage=notification_threshold_percentage,
+        )
+
+        msg = EmailMessage()
+        msg["Subject"] = subject
+        msg["From"] = self.sender_email
+        msg["To"] = email
+        msg.set_content(html_content, subtype="html")
+
+        await to_thread.run_sync(self._send_email, msg)
+
     def _send_email(self, msg: EmailMessage) -> None:
         context: ssl.SSLContext
         if self.validate_certs:

phoenix/server/email/templates/db_disk_usage_notification.html

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8" />
+  <title>Database Usage Notification</title>
+</head>
+<body>
+<h1>Database Usage Notification</h1>
+<p>Your Phoenix database usage has exceeded the notification threshold.</p>
+<p><strong>Current Usage:</strong> {{ current_usage_gibibytes|round(1) }} GiB</p>
+<p><strong>Allocated Storage:</strong> {{ allocated_storage_gibibytes|round(1) }} GiB</p>
+<p><strong>Usage Percentage:</strong> {{ ((current_usage_gibibytes / allocated_storage_gibibytes) * 100)|round(1) }}%</p>
+<p><strong>Notification Threshold:</strong> {{ notification_threshold_percentage }}%</p>
+<p>Please consider removing old data or increasing your storage allocation to prevent interruption.</p>
+</body>
+</html>

phoenix/server/email/types.py

@@ -19,8 +19,19 @@ class PasswordResetEmailSender(Protocol):
     ) -> None: ...
 
 
+class DbUsageWarningEmailSender(Protocol):
+    async def send_db_usage_warning_email(
+        self,
+        email: str,
+        current_usage_gibibytes: float,
+        allocated_storage_gibibytes: float,
+        notification_threshold_percentage: float,
+    ) -> None: ...
+
+
 class EmailSender(
     WelcomeEmailSender,
     PasswordResetEmailSender,
+    DbUsageWarningEmailSender,
     Protocol,
 ): ...

phoenix/server/grpc_server.py

@@ -1,5 +1,5 @@
 from collections.abc import Awaitable, Callable
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, Iterable, Optional
 
 import grpc
 from grpc.aio import RpcContext, Server, ServerInterceptor
@@ -61,7 +61,7 @@ class GrpcServer:
         enable_prometheus: bool = False,
         disabled: bool = False,
         token_store: Optional[CanReadToken] = None,
-        interceptors: list[ServerInterceptor] = [],
+        interceptors: Iterable[ServerInterceptor] = (),
     ) -> None:
         self._callback = callback
         self._server: Optional[Server] = None
@@ -69,7 +69,7 @@ class GrpcServer:
         self._enable_prometheus = enable_prometheus
         self._disabled = disabled
         self._token_store = token_store
-        self._interceptors = interceptors
+        self._interceptors = list(interceptors)
 
     async def __aenter__(self) -> None:
         interceptors = self._interceptors

phoenix/server/prometheus.py

@@ -73,6 +73,28 @@ JWT_STORE_API_KEYS_ACTIVE = Gauge(
     documentation="Current number of API keys in the JWT store",
 )
 
+DB_DISK_USAGE_BYTES = Gauge(
+    name="database_disk_usage_bytes",
+    documentation="Current database disk usage in bytes",
+)
+DB_DISK_USAGE_RATIO = Gauge(
+    name="database_disk_usage_ratio",
+    documentation="Current database disk usage as ratio of allocated capacity (0-1)",
+)
+DB_INSERTIONS_BLOCKED = Gauge(
+    name="database_insertions_blocked",
+    documentation="Whether database insertions are currently blocked due to disk usage "
+    "(1 = blocked, 0 = not blocked)",
+)
+DB_DISK_USAGE_WARNING_EMAILS_SENT = Counter(
+    name="database_disk_usage_warning_emails_sent_total",
+    documentation="Total count of database disk usage warning emails sent",
+)
+DB_DISK_USAGE_WARNING_EMAIL_ERRORS = Counter(
+    name="database_disk_usage_warning_email_errors_total",
+    documentation="Total count of database disk usage warning email send errors",
+)
+
 
 class PrometheusMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:

phoenix/server/static/.vite/manifest.json

@@ -1,67 +1,67 @@
 {
-  "_components-CVcMbu2U.js": {
-    "file": "assets/components-CVcMbu2U.js",
+  "_components-Bwf6zNbg.js": {
+    "file": "assets/components-Bwf6zNbg.js",
     "name": "components",
     "imports": [
-      "_vendor-pg5m6BWE.js",
-      "_pages-QK2o2V7x.js",
-      "_vendor-arizeai-BwMsgSAG.js",
-      "_vendor-codemirror-BwSDEu2g.js",
+      "_vendor-DRWIRkSJ.js",
+      "_pages-BCR8hW_l.js",
+      "_vendor-arizeai-DUhQaeau.js",
+      "_vendor-codemirror-D_6Q6Auv.js",
       "_vendor-three-C5WAXd5r.js"
     ]
   },
-  "_pages-QK2o2V7x.js": {
-    "file": "assets/pages-QK2o2V7x.js",
+  "_pages-BCR8hW_l.js": {
+    "file": "assets/pages-BCR8hW_l.js",
     "name": "pages",
     "imports": [
-      "_vendor-pg5m6BWE.js",
-      "_vendor-arizeai-BwMsgSAG.js",
-      "_components-CVcMbu2U.js",
-      "_vendor-codemirror-BwSDEu2g.js",
-      "_vendor-recharts-SW3HwAtG.js"
+      "_vendor-DRWIRkSJ.js",
+      "_vendor-arizeai-DUhQaeau.js",
+      "_components-Bwf6zNbg.js",
+      "_vendor-codemirror-D_6Q6Auv.js",
+      "_vendor-recharts-BNBwj7vz.js"
+    ]
+  },
+  "_vendor-DRWIRkSJ.js": {
+    "file": "assets/vendor-DRWIRkSJ.js",
+    "name": "vendor",
+    "imports": [
+      "_vendor-three-C5WAXd5r.js"
+    ],
+    "css": [
+      "assets/vendor-WIZid84E.css"
     ]
   },
   "_vendor-WIZid84E.css": {
     "file": "assets/vendor-WIZid84E.css",
     "src": "_vendor-WIZid84E.css"
   },
-  "_vendor-arizeai-BwMsgSAG.js": {
-    "file": "assets/vendor-arizeai-BwMsgSAG.js",
+  "_vendor-arizeai-DUhQaeau.js": {
+    "file": "assets/vendor-arizeai-DUhQaeau.js",
     "name": "vendor-arizeai",
     "imports": [
-      "_vendor-pg5m6BWE.js"
+      "_vendor-DRWIRkSJ.js"
     ]
   },
-  "_vendor-codemirror-BwSDEu2g.js": {
-    "file": "assets/vendor-codemirror-BwSDEu2g.js",
+  "_vendor-codemirror-D_6Q6Auv.js": {
+    "file": "assets/vendor-codemirror-D_6Q6Auv.js",
     "name": "vendor-codemirror",
     "imports": [
-      "_vendor-pg5m6BWE.js",
-      "_vendor-shiki-BsdYoDvs.js"
-    ]
-  },
-  "_vendor-pg5m6BWE.js": {
-    "file": "assets/vendor-pg5m6BWE.js",
-    "name": "vendor",
-    "imports": [
-      "_vendor-three-C5WAXd5r.js"
-    ],
-    "css": [
-      "assets/vendor-WIZid84E.css"
+      "_vendor-DRWIRkSJ.js",
+      "_vendor-shiki-k1qj_XjP.js"
     ]
   },
-  "_vendor-recharts-SW3HwAtG.js": {
-    "file": "assets/vendor-recharts-SW3HwAtG.js",
+  "_vendor-recharts-BNBwj7vz.js": {
+    "file": "assets/vendor-recharts-BNBwj7vz.js",
     "name": "vendor-recharts",
     "imports": [
-      "_vendor-pg5m6BWE.js"
+      "_vendor-DRWIRkSJ.js"
     ]
   },
-  "_vendor-shiki-BsdYoDvs.js": {
-    "file": "assets/vendor-shiki-BsdYoDvs.js",
+  "_vendor-shiki-k1qj_XjP.js": {
+    "file": "assets/vendor-shiki-k1qj_XjP.js",
     "name": "vendor-shiki",
     "imports": [
-      "_vendor-pg5m6BWE.js"
+      "_vendor-DRWIRkSJ.js"
     ]
   },
   "_vendor-three-C5WAXd5r.js": {
@@ -69,19 +69,19 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-Dz7I-Hpn.js",
+    "file": "assets/index-Bfg9uQ43.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
-      "_vendor-pg5m6BWE.js",
-      "_vendor-arizeai-BwMsgSAG.js",
-      "_pages-QK2o2V7x.js",
-      "_components-CVcMbu2U.js",
+      "_vendor-DRWIRkSJ.js",
+      "_vendor-arizeai-DUhQaeau.js",
+      "_pages-BCR8hW_l.js",
+      "_components-Bwf6zNbg.js",
       "_vendor-three-C5WAXd5r.js",
-      "_vendor-codemirror-BwSDEu2g.js",
-      "_vendor-shiki-BsdYoDvs.js",
-      "_vendor-recharts-SW3HwAtG.js"
+      "_vendor-codemirror-D_6Q6Auv.js",
+      "_vendor-shiki-k1qj_XjP.js",
+      "_vendor-recharts-BNBwj7vz.js"
     ]
   }
 }