arize-phoenix 8.2.1__py3-none-any.whl → 8.3.0__py3-none-any.whl

phoenix/server/api/types/Experiment.py

@@ -122,10 +122,8 @@ class Experiment(Node):
             return None
 
         return Project(
-            id_attr=db_project.id,
-            name=db_project.name,
-            gradient_start_color=db_project.gradient_start_color,
-            gradient_end_color=db_project.gradient_end_color,
+            project_rowid=db_project.id,
+            db_project=db_project,
         )
 
     @strawberry.field

phoenix/server/api/types/ExperimentRun.py

@@ -20,7 +20,7 @@ from phoenix.server.api.types.pagination import (
     CursorString,
     connection_from_list,
 )
-from phoenix.server.api.types.Trace import Trace, to_gql_trace
+from phoenix.server.api.types.Trace import Trace
 
 if TYPE_CHECKING:
     from phoenix.server.api.types.DatasetExample import DatasetExample
@@ -64,7 +64,7 @@ class ExperimentRun(Node):
         dataloader = info.context.data_loaders.trace_by_trace_ids
         if (trace := await dataloader.load(self.trace_id)) is None:
             return None
-        return to_gql_trace(trace)
+        return Trace(trace_rowid=trace.id, db_trace=trace)
 
     @strawberry.field
     async def example(

phoenix/server/api/types/ExperimentRunAnnotation.py

@@ -8,7 +8,7 @@ from strawberry.scalars import JSON
 
 from phoenix.db import models
 from phoenix.server.api.types.AnnotatorKind import ExperimentRunAnnotatorKind
-from phoenix.server.api.types.Trace import Trace, to_gql_trace
+from phoenix.server.api.types.Trace import Trace
 
 
 @strawberry.type
@@ -32,7 +32,7 @@ class ExperimentRunAnnotation(Node):
         dataloader = info.context.data_loaders.trace_by_trace_ids
         if (trace := await dataloader.load(self.trace_id)) is None:
             return None
-        return to_gql_trace(trace)
+        return Trace(trace_rowid=trace.id, db_trace=trace)
 
 
 def to_gql_experiment_run_annotation(

phoenix/server/api/types/Project.py

@@ -8,7 +8,7 @@ from openinference.semconv.trace import SpanAttributes
 from sqlalchemy import desc, distinct, func, or_, select
 from sqlalchemy.sql.elements import ColumnElement
 from sqlalchemy.sql.expression import tuple_
-from strawberry import ID, UNSET
+from strawberry import ID, UNSET, Private
 from strawberry.relay import Connection, Node, NodeID
 from strawberry.types import Info
 from typing_extensions import assert_never
@@ -33,7 +33,7 @@ from phoenix.server.api.types.pagination import (
 from phoenix.server.api.types.ProjectSession import ProjectSession, to_gql_project_session
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.Span import Span
-from phoenix.server.api.types.Trace import Trace, to_gql_trace
+from phoenix.server.api.types.Trace import Trace
 from phoenix.server.api.types.ValidationResult import ValidationResult
 from phoenix.trace.dsl import SpanFilter
 
@@ -41,10 +41,51 @@ from phoenix.trace.dsl import SpanFilter
 @strawberry.type
 class Project(Node):
     _table: ClassVar[type[models.Base]] = models.Project
-    id_attr: NodeID[int]
-    name: str
-    gradient_start_color: str
-    gradient_end_color: str
+    project_rowid: NodeID[int]
+    db_project: Private[models.Project] = UNSET
+
+    def __post_init__(self) -> None:
+        if self.db_project and self.project_rowid != self.db_project.id:
+            raise ValueError("Project ID mismatch")
+
+    @strawberry.field
+    async def name(
+        self,
+        info: Info[Context, None],
+    ) -> str:
+        if self.db_project:
+            name = self.db_project.name
+        else:
+            name = await info.context.data_loaders.project_fields.load(
+                (self.project_rowid, models.Project.name),
+            )
+        return name
+
+    @strawberry.field
+    async def gradient_start_color(
+        self,
+        info: Info[Context, None],
+    ) -> str:
+        if self.db_project:
+            gradient_start_color = self.db_project.gradient_start_color
+        else:
+            gradient_start_color = await info.context.data_loaders.project_fields.load(
+                (self.project_rowid, models.Project.gradient_start_color),
+            )
+        return gradient_start_color
+
+    @strawberry.field
+    async def gradient_end_color(
+        self,
+        info: Info[Context, None],
+    ) -> str:
+        if self.db_project:
+            gradient_end_color = self.db_project.gradient_end_color
+        else:
+            gradient_end_color = await info.context.data_loaders.project_fields.load(
+                (self.project_rowid, models.Project.gradient_end_color),
+            )
+        return gradient_end_color
 
     @strawberry.field
     async def start_time(
@@ -52,7 +93,7 @@ class Project(Node):
         info: Info[Context, None],
     ) -> Optional[datetime]:
         start_time = await info.context.data_loaders.min_start_or_max_end_times.load(
-            (self.id_attr, "start"),
+            (self.project_rowid, "start"),
         )
         start_time, _ = right_open_time_range(start_time, None)
         return start_time
@@ -63,7 +104,7 @@ class Project(Node):
         info: Info[Context, None],
     ) -> Optional[datetime]:
         end_time = await info.context.data_loaders.min_start_or_max_end_times.load(
-            (self.id_attr, "end"),
+            (self.project_rowid, "end"),
         )
         _, end_time = right_open_time_range(None, end_time)
         return end_time
@@ -76,7 +117,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> int:
         return await info.context.data_loaders.record_counts.load(
-            ("span", self.id_attr, time_range, filter_condition),
+            ("span", self.project_rowid, time_range, filter_condition),
         )
 
     @strawberry.field
@@ -86,7 +127,7 @@ class Project(Node):
         time_range: Optional[TimeRange] = UNSET,
     ) -> int:
         return await info.context.data_loaders.record_counts.load(
-            ("trace", self.id_attr, time_range, None),
+            ("trace", self.project_rowid, time_range, None),
         )
 
     @strawberry.field
@@ -97,7 +138,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> int:
         return await info.context.data_loaders.token_counts.load(
-            ("total", self.id_attr, time_range, filter_condition),
+            ("total", self.project_rowid, time_range, filter_condition),
         )
 
     @strawberry.field
@@ -108,7 +149,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> int:
         return await info.context.data_loaders.token_counts.load(
-            ("prompt", self.id_attr, time_range, filter_condition),
+            ("prompt", self.project_rowid, time_range, filter_condition),
         )
 
     @strawberry.field
@@ -119,7 +160,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> int:
         return await info.context.data_loaders.token_counts.load(
-            ("completion", self.id_attr, time_range, filter_condition),
+            ("completion", self.project_rowid, time_range, filter_condition),
         )
 
     @strawberry.field
@@ -132,7 +173,7 @@ class Project(Node):
         return await info.context.data_loaders.latency_ms_quantile.load(
             (
                 "trace",
-                self.id_attr,
+                self.project_rowid,
                 time_range,
                 None,
                 probability,
@@ -150,7 +191,7 @@ class Project(Node):
         return await info.context.data_loaders.latency_ms_quantile.load(
             (
                 "span",
-                self.id_attr,
+                self.project_rowid,
                 time_range,
                 filter_condition,
                 probability,
@@ -162,12 +203,12 @@ class Project(Node):
         stmt = (
             select(models.Trace)
             .where(models.Trace.trace_id == str(trace_id))
-            .where(models.Trace.project_rowid == self.id_attr)
+            .where(models.Trace.project_rowid == self.project_rowid)
         )
         async with info.context.db() as session:
             if (trace := await session.scalar(stmt)) is None:
                 return None
-        return to_gql_trace(trace)
+        return Trace(trace_rowid=trace.id, db_trace=trace)
 
     @strawberry.field
     async def spans(
@@ -185,7 +226,7 @@ class Project(Node):
         stmt = (
             select(models.Span.id)
             .join(models.Trace)
-            .where(models.Trace.project_rowid == self.id_attr)
+            .where(models.Trace.project_rowid == self.project_rowid)
         )
         if time_range:
             if time_range.start:
@@ -264,7 +305,7 @@ class Project(Node):
         filter_io_substring: Optional[str] = UNSET,
     ) -> Connection[ProjectSession]:
         table = models.ProjectSession
-        stmt = select(table).filter_by(project_id=self.id_attr)
+        stmt = select(table).filter_by(project_id=self.project_rowid)
         if time_range:
             if time_range.start:
                 stmt = stmt.where(time_range.start <= table.start_time)
@@ -382,7 +423,7 @@ class Project(Node):
         stmt = (
             select(distinct(models.TraceAnnotation.name))
             .join(models.Trace)
-            .where(models.Trace.project_rowid == self.id_attr)
+            .where(models.Trace.project_rowid == self.project_rowid)
         )
         async with info.context.db() as session:
             return list(await session.scalars(stmt))
@@ -399,7 +440,7 @@ class Project(Node):
             select(distinct(models.SpanAnnotation.name))
             .join(models.Span)
             .join(models.Trace, models.Span.trace_rowid == models.Trace.id)
-            .where(models.Trace.project_rowid == self.id_attr)
+            .where(models.Trace.project_rowid == self.project_rowid)
         )
         async with info.context.db() as session:
             return list(await session.scalars(stmt))
@@ -416,7 +457,7 @@ class Project(Node):
             select(distinct(models.DocumentAnnotation.name))
             .join(models.Span)
             .join(models.Trace, models.Span.trace_rowid == models.Trace.id)
-            .where(models.Trace.project_rowid == self.id_attr)
+            .where(models.Trace.project_rowid == self.project_rowid)
             .where(models.DocumentAnnotation.annotator_kind == "LLM")
         )
         if span_id:
@@ -432,7 +473,7 @@ class Project(Node):
         time_range: Optional[TimeRange] = UNSET,
     ) -> Optional[AnnotationSummary]:
         return await info.context.data_loaders.annotation_summaries.load(
-            ("trace", self.id_attr, time_range, None, annotation_name),
+            ("trace", self.project_rowid, time_range, None, annotation_name),
         )
 
     @strawberry.field
@@ -444,7 +485,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> Optional[AnnotationSummary]:
         return await info.context.data_loaders.annotation_summaries.load(
-            ("span", self.id_attr, time_range, filter_condition, annotation_name),
+            ("span", self.project_rowid, time_range, filter_condition, annotation_name),
         )
 
     @strawberry.field
@@ -456,7 +497,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> Optional[DocumentEvaluationSummary]:
         return await info.context.data_loaders.document_evaluation_summaries.load(
-            (self.id_attr, time_range, filter_condition, evaluation_name),
+            (self.project_rowid, time_range, filter_condition, evaluation_name),
         )
 
     @strawberry.field
@@ -464,7 +505,7 @@ class Project(Node):
         self,
         info: Info[Context, None],
     ) -> Optional[datetime]:
-        return info.context.last_updated_at.get(self._table, self.id_attr)
+        return info.context.last_updated_at.get(self._table, self.project_rowid)
 
     @strawberry.field
     async def validate_span_filter_condition(self, condition: str) -> ValidationResult:
@@ -483,17 +524,5 @@ class Project(Node):
             )
 
 
-def to_gql_project(project: models.Project) -> Project:
-    """
-    Converts an ORM project to a GraphQL Project.
-    """
-    return Project(
-        id_attr=project.id,
-        name=project.name,
-        gradient_start_color=project.gradient_start_color,
-        gradient_end_color=project.gradient_end_color,
-    )
-
-
 INPUT_VALUE = SpanAttributes.INPUT_VALUE.split(".")
 OUTPUT_VALUE = SpanAttributes.OUTPUT_VALUE.split(".")

phoenix/server/api/types/ProjectSession.py

@@ -93,7 +93,7 @@ class ProjectSession(Node):
         after: Optional[CursorString] = UNSET,
         before: Optional[CursorString] = UNSET,
     ) -> Connection[Annotated["Trace", lazy(".Trace")]]:
-        from phoenix.server.api.types.Trace import to_gql_trace
+        from phoenix.server.api.types.Trace import Trace
 
         args = ConnectionArgs(
             first=first,
@@ -109,7 +109,7 @@ class ProjectSession(Node):
         )
         async with info.context.db() as session:
             traces = await session.stream_scalars(stmt)
-            data = [to_gql_trace(trace) async for trace in traces]
+            data = [Trace(trace_rowid=trace.id, db_trace=trace) async for trace in traces]
         return connection_from_list(data=data, args=args)
 
     @strawberry.field

phoenix/server/api/types/Span.py

@@ -37,6 +37,7 @@ from phoenix.trace.attributes import get_attribute_value
 
 if TYPE_CHECKING:
     from phoenix.server.api.types.Project import Project
+    from phoenix.server.api.types.Trace import Trace
 
 
 @strawberry.enum
@@ -216,6 +217,34 @@ class Span(Node):
             )
         return SpanKind(value)
 
+    @strawberry.field
+    async def span_id(
+        self,
+        info: Info[Context, None],
+    ) -> ID:
+        if self.db_span:
+            span_id = self.db_span.span_id
+        else:
+            span_id = await info.context.data_loaders.span_fields.load(
+                (self.span_rowid, models.Span.span_id),
+            )
+        return ID(span_id)
+
+    @strawberry.field
+    async def trace(
+        self,
+        info: Info[Context, None],
+    ) -> Annotated["Trace", strawberry.lazy(".Trace")]:
+        if self.db_span:
+            trace_rowid = self.db_span.trace_rowid
+        else:
+            trace_rowid = await info.context.data_loaders.span_fields.load(
+                (self.span_rowid, models.Span.trace_rowid),
+            )
+        from phoenix.server.api.types.Trace import Trace
+
+        return Trace(trace_rowid=trace_rowid)
+
     @strawberry.field
     async def context(
         self,
@@ -319,8 +348,11 @@ class Span(Node):
         info: Info[Context, None],
     ) -> Optional[SpanIOValue]:
         if self.db_span:
-            mime_type = self.db_span.input_mime_type
             input_value = self.db_span.input_value
+            if input_value is None or input_value == "":
+                return None
+            input_value = str(input_value)
+            mime_type = self.db_span.input_mime_type
             return SpanIOValue(
                 cached_value=input_value,
                 mime_type=MimeType(mime_type),
@@ -348,8 +380,11 @@ class Span(Node):
         info: Info[Context, None],
     ) -> Optional[SpanIOValue]:
         if self.db_span:
-            mime_type = self.db_span.output_mime_type
             output_value = self.db_span.output_value
+            if output_value is None or output_value == "":
+                return None
+            output_value = str(output_value)
+            mime_type = self.db_span.output_mime_type
             return SpanIOValue(
                 cached_value=output_value,
                 mime_type=MimeType(mime_type),
@@ -555,11 +590,11 @@ class Span(Node):
     ) -> Annotated[
         "Project", strawberry.lazy("phoenix.server.api.types.Project")
     ]:  # use lazy types to avoid circular import: https://strawberry.rocks/docs/types/lazy
-        from phoenix.server.api.types.Project import to_gql_project
+        from phoenix.server.api.types.Project import Project
 
         span_id = self.span_rowid
         project = await info.context.data_loaders.span_projects.load(span_id)
-        return to_gql_project(project)
+        return Project(project_rowid=project.id, db_project=project)
 
     @strawberry.field(description="Indicates if the span is contained in any dataset")  # type: ignore
     async def contained_in_dataset(

phoenix/server/api/types/Trace.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Annotated, Optional, Union
 import strawberry
 from openinference.semconv.trace import SpanAttributes
 from sqlalchemy import desc, select
-from strawberry import UNSET, Private, lazy
+from strawberry import ID, UNSET, Private, lazy
 from strawberry.relay import Connection, GlobalID, Node, NodeID
 from strawberry.types import Info
 from typing_extensions import TypeAlias
@@ -24,6 +24,7 @@ from phoenix.server.api.types.Span import Span
 from phoenix.server.api.types.TraceAnnotation import TraceAnnotation, to_gql_trace_annotation
 
 if TYPE_CHECKING:
+    from phoenix.server.api.types.Project import Project
     from phoenix.server.api.types.ProjectSession import ProjectSession
 
 ProjectRowId: TypeAlias = int
@@ -33,49 +34,127 @@ TraceRowId: TypeAlias = int
 @strawberry.type
 class Trace(Node):
     trace_rowid: NodeID[TraceRowId]
-    project_rowid: Private[ProjectRowId]
-    project_session_rowid: Private[Optional[int]]
-    trace_id: str
-    start_time: datetime
-    end_time: datetime
+    db_trace: Private[models.Trace] = UNSET
+
+    def __post_init__(self) -> None:
+        if self.db_trace and self.trace_rowid != self.db_trace.id:
+            raise ValueError("Trace ID mismatch")
+
+    @strawberry.field
+    async def trace_id(
+        self,
+        info: Info[Context, None],
+    ) -> ID:
+        if self.db_trace:
+            trace_id = self.db_trace.trace_id
+        else:
+            trace_id = await info.context.data_loaders.trace_fields.load(
+                (self.trace_rowid, models.Trace.trace_id),
+            )
+        return ID(trace_id)
+
+    @strawberry.field
+    async def start_time(
+        self,
+        info: Info[Context, None],
+    ) -> datetime:
+        if self.db_trace:
+            start_time = self.db_trace.start_time
+        else:
+            start_time = await info.context.data_loaders.trace_fields.load(
+                (self.trace_rowid, models.Trace.start_time),
+            )
+        return start_time
+
+    @strawberry.field
+    async def end_time(
+        self,
+        info: Info[Context, None],
+    ) -> datetime:
+        if self.db_trace:
+            end_time = self.db_trace.end_time
+        else:
+            end_time = await info.context.data_loaders.trace_fields.load(
+                (self.trace_rowid, models.Trace.end_time),
+            )
+        return end_time
 
     @strawberry.field
     async def latency_ms(
         self,
         info: Info[Context, None],
     ) -> Optional[float]:
-        async with info.context.db() as session:
-            latency = await session.scalar(
-                select(
-                    models.Trace.latency_ms,
-                ).where(models.Trace.id == self.trace_rowid)
+        if self.db_trace:
+            latency_ms = self.db_trace.latency_ms
+        else:
+            latency_ms = await info.context.data_loaders.trace_fields.load(
+                (self.trace_rowid, models.Trace.latency_ms),
             )
-        return latency
+        return latency_ms
 
     @strawberry.field
-    async def project_id(self) -> GlobalID:
+    async def project(
+        self,
+        info: Info[Context, None],
+    ) -> Annotated["Project", strawberry.lazy(".Project")]:
+        if self.db_trace:
+            project_rowid = self.db_trace.project_rowid
+        else:
+            project_rowid = await info.context.data_loaders.trace_fields.load(
+                (self.trace_rowid, models.Trace.project_rowid),
+            )
+        from phoenix.server.api.types.Project import Project
+
+        return Project(project_rowid=project_rowid)
+
+    @strawberry.field
+    async def project_id(
+        self,
+        info: Info[Context, None],
+    ) -> GlobalID:
+        if self.db_trace:
+            project_rowid = self.db_trace.project_rowid
+        else:
+            project_rowid = await info.context.data_loaders.trace_fields.load(
+                (self.trace_rowid, models.Trace.project_rowid),
+            )
         from phoenix.server.api.types.Project import Project
 
-        return GlobalID(type_name=Project.__name__, node_id=str(self.project_rowid))
+        return GlobalID(type_name=Project.__name__, node_id=str(project_rowid))
 
     @strawberry.field
-    async def project_session_id(self) -> Optional[GlobalID]:
-        if self.project_session_rowid is None:
+    async def project_session_id(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[GlobalID]:
+        if self.db_trace:
+            project_session_rowid = self.db_trace.project_session_rowid
+        else:
+            project_session_rowid = await info.context.data_loaders.trace_fields.load(
+                (self.trace_rowid, models.Trace.project_session_rowid),
+            )
+        if project_session_rowid is None:
             return None
         from phoenix.server.api.types.ProjectSession import ProjectSession
 
-        return GlobalID(type_name=ProjectSession.__name__, node_id=str(self.project_session_rowid))
+        return GlobalID(type_name=ProjectSession.__name__, node_id=str(project_session_rowid))
 
     @strawberry.field
     async def session(
         self,
         info: Info[Context, None],
     ) -> Union[Annotated["ProjectSession", lazy(".ProjectSession")], None]:
-        if self.project_session_rowid is None:
+        if self.db_trace:
+            project_session_rowid = self.db_trace.project_session_rowid
+        else:
+            project_session_rowid = await info.context.data_loaders.trace_fields.load(
+                (self.trace_rowid, models.Trace.project_session_rowid),
+            )
+        if project_session_rowid is None:
             return None
         from phoenix.server.api.types.ProjectSession import to_gql_project_session
 
-        stmt = select(models.ProjectSession).filter_by(id=self.project_session_rowid)
+        stmt = select(models.ProjectSession).filter_by(id=project_session_rowid)
         async with info.context.db() as session:
             project_session = await session.scalar(stmt)
         if project_session is None:
@@ -141,16 +220,5 @@ class Trace(Node):
         return [to_gql_trace_annotation(annotation) for annotation in annotations]
 
 
-def to_gql_trace(trace: models.Trace) -> Trace:
-    return Trace(
-        trace_rowid=trace.id,
-        project_rowid=trace.project_rowid,
-        project_session_rowid=trace.project_session_rowid,
-        trace_id=trace.trace_id,
-        start_time=trace.start_time,
-        end_time=trace.end_time,
-    )
-
-
 INPUT_VALUE = SpanAttributes.INPUT_VALUE.split(".")
 OUTPUT_VALUE = SpanAttributes.OUTPUT_VALUE.split(".")

phoenix/server/app.py

@@ -97,8 +97,8 @@ from phoenix.server.api.dataloaders import (
     SpanByIdDataLoader,
     SpanDatasetExamplesDataLoader,
     SpanDescendantsDataLoader,
-    SpanFieldsDataLoader,
     SpanProjectsDataLoader,
+    TableFieldsDataLoader,
     TokenCountDataLoader,
     TraceByTraceIdsDataLoader,
     TraceRootSpansDataLoader,
@@ -614,6 +614,7 @@ def create_graphql_router(
                         else None
                     ),
                 ),
+                project_fields=TableFieldsDataLoader(db, models.Project),
                 prompt_version_sequence_number=PromptVersionSequenceNumberDataLoader(db),
                 record_counts=RecordCountDataLoader(
                     db,
@@ -626,7 +627,7 @@ def create_graphql_router(
                 session_token_usages=SessionTokenUsagesDataLoader(db),
                 session_trace_latency_ms_quantile=SessionTraceLatencyMsQuantileDataLoader(db),
                 span_annotations=SpanAnnotationsDataLoader(db),
-                span_fields=SpanFieldsDataLoader(db),
+                span_fields=TableFieldsDataLoader(db, models.Span),
                 span_by_id=SpanByIdDataLoader(db),
                 span_dataset_examples=SpanDatasetExamplesDataLoader(db),
                 span_descendants=SpanDescendantsDataLoader(db),
@@ -636,6 +637,7 @@ def create_graphql_router(
                     cache_map=cache_for_dataloaders.token_count if cache_for_dataloaders else None,
                 ),
                 trace_by_trace_ids=TraceByTraceIdsDataLoader(db),
+                trace_fields=TableFieldsDataLoader(db, models.Trace),
                 trace_root_spans=TraceRootSpansDataLoader(db),
                 project_by_name=ProjectByNameDataLoader(db),
                 users=UsersDataLoader(db),

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

@@ -1,22 +1,22 @@
 {
-  "_components-CgcYOKnv.js": {
-    "file": "assets/components-CgcYOKnv.js",
+  "_components-T5K9z49d.js": {
+    "file": "assets/components-T5K9z49d.js",
     "name": "components",
     "imports": [
       "_vendor-Cqfydjep.js",
-      "_pages-Cz-JsoAE.js",
+      "_pages-CY3ZXSHj.js",
       "_vendor-arizeai-WnerlUPN.js",
       "_vendor-codemirror-D-ZZKLFq.js",
       "_vendor-three-C-AGeJYv.js"
     ]
   },
-  "_pages-Cz-JsoAE.js": {
-    "file": "assets/pages-Cz-JsoAE.js",
+  "_pages-CY3ZXSHj.js": {
+    "file": "assets/pages-CY3ZXSHj.js",
     "name": "pages",
     "imports": [
       "_vendor-Cqfydjep.js",
       "_vendor-arizeai-WnerlUPN.js",
-      "_components-CgcYOKnv.js",
+      "_components-T5K9z49d.js",
       "_vendor-codemirror-D-ZZKLFq.js",
       "_vendor-recharts-KY97ZPfK.js"
     ]
@@ -69,15 +69,15 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-B_Nkd6Rh.js",
+    "file": "assets/index-DvHwFF8e.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
       "_vendor-Cqfydjep.js",
       "_vendor-arizeai-WnerlUPN.js",
-      "_pages-Cz-JsoAE.js",
-      "_components-CgcYOKnv.js",
+      "_pages-CY3ZXSHj.js",
+      "_components-T5K9z49d.js",
       "_vendor-three-C-AGeJYv.js",
       "_vendor-codemirror-D-ZZKLFq.js",
       "_vendor-shiki-D5K9GnFn.js",