arize-phoenix 8.3.0__tar.gz → 8.4.1__tar.gz

{arize_phoenix-8.3.0 → arize_phoenix-8.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 8.3.0
+Version: 8.4.1
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -162,6 +162,7 @@ Phoenix is an open-source AI observability platform designed for experimentation
 - [**_Datasets_**](https://docs.arize.com/phoenix/datasets-and-experiments/overview-datasets) - Create versioned datasets of examples for experimentation, evaluation, and fine-tuning.
 - [**_Experiments_**](https://docs.arize.com/phoenix/datasets-and-experiments/overview-datasets#experiments) - Track and evaluate changes to prompts, LLMs, and retrieval.
 - [**_Playground_**](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts)- Optimize prompts, compare models, adjust parameters, and replay traced LLM calls.
+- [**_Prompt Mangement_**](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts/prompt-management)- Manage and test prompt changes systematically using version control, tagging, and experimentation.
 
 Phoenix is vendor and language agnostic with out-of-the-box support for popular frameworks (🦙[LlamaIndex](https://docs.arize.com/phoenix/tracing/integrations-tracing/llamaindex), 🦜⛓[LangChain](https://docs.arize.com/phoenix/tracing/integrations-tracing/langchain), [Haystack](https://docs.arize.com/phoenix/tracing/integrations-tracing/haystack), 🧩[DSPy](https://docs.arize.com/phoenix/tracing/integrations-tracing/dspy)) and LLM providers ([OpenAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/openai), [Bedrock](https://docs.arize.com/phoenix/tracing/integrations-tracing/bedrock), [MistralAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/mistralai), [VertexAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/vertexai), [LiteLLM](https://docs.arize.com/phoenix/tracing/integrations-tracing/litellm), and more). For details on auto-instrumentation, check out the [OpenInference](https://github.com/Arize-ai/openinference) project.
 

{arize_phoenix-8.3.0 → arize_phoenix-8.4.1}/README.md

@@ -34,6 +34,7 @@ Phoenix is an open-source AI observability platform designed for experimentation
 - [**_Datasets_**](https://docs.arize.com/phoenix/datasets-and-experiments/overview-datasets) - Create versioned datasets of examples for experimentation, evaluation, and fine-tuning.
 - [**_Experiments_**](https://docs.arize.com/phoenix/datasets-and-experiments/overview-datasets#experiments) - Track and evaluate changes to prompts, LLMs, and retrieval.
 - [**_Playground_**](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts)- Optimize prompts, compare models, adjust parameters, and replay traced LLM calls.
+- [**_Prompt Mangement_**](https://docs.arize.com/phoenix/prompt-engineering/overview-prompts/prompt-management)- Manage and test prompt changes systematically using version control, tagging, and experimentation.
 
 Phoenix is vendor and language agnostic with out-of-the-box support for popular frameworks (🦙[LlamaIndex](https://docs.arize.com/phoenix/tracing/integrations-tracing/llamaindex), 🦜⛓[LangChain](https://docs.arize.com/phoenix/tracing/integrations-tracing/langchain), [Haystack](https://docs.arize.com/phoenix/tracing/integrations-tracing/haystack), 🧩[DSPy](https://docs.arize.com/phoenix/tracing/integrations-tracing/dspy)) and LLM providers ([OpenAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/openai), [Bedrock](https://docs.arize.com/phoenix/tracing/integrations-tracing/bedrock), [MistralAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/mistralai), [VertexAI](https://docs.arize.com/phoenix/tracing/integrations-tracing/vertexai), [LiteLLM](https://docs.arize.com/phoenix/tracing/integrations-tracing/litellm), and more). For details on auto-instrumentation, check out the [OpenInference](https://github.com/Arize-ai/openinference) project.
 

{arize_phoenix-8.3.0 → arize_phoenix-8.4.1}/src/phoenix/db/models.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, Optional, Sequence, TypedDict
+from typing import Any, Iterable, Optional, Sequence, TypedDict, cast
 
 import sqlalchemy.sql as sql
 from openinference.semconv.trace import RerankerAttributes, SpanAttributes
@@ -39,7 +39,7 @@ from sqlalchemy.orm import (
     mapped_column,
     relationship,
 )
-from sqlalchemy.sql import expression
+from sqlalchemy.sql import Values, column, compiler, expression, literal, roles, union_all
 from sqlalchemy.sql.compiler import SQLCompiler
 from sqlalchemy.sql.functions import coalesce
 
@@ -74,6 +74,72 @@ RERANKER_OUTPUT_DOCUMENTS = RerankerAttributes.RERANKER_OUTPUT_DOCUMENTS.split("
 RETRIEVAL_DOCUMENTS = SpanAttributes.RETRIEVAL_DOCUMENTS.split(".")
 
 
+class SubValues(Values, roles.CompoundElementRole):
+    """
+    Adapted from the following recipe:
+    https://github.com/sqlalchemy/sqlalchemy/issues/7228#issuecomment-1746837960
+
+    This is part of a workaround to make it more convenient to construct the VALUES clause in
+    SQLite. The VALUES clause is useful for creating a temporary table in the database with a set
+    of user inputs in the form of multi-value tuples, which can then be joined with other tables.
+    """
+
+    inherit_cache = True
+
+    @property
+    def _all_selected_columns(self) -> Iterable[ColumnElement[Any]]:
+        return self.columns
+
+
+@compiles(SubValues, "sqlite")
+def render_subvalues_w_union(elem: SubValues, compiler: compiler.SQLCompiler, **kw: Any) -> str:
+    """
+    Adapted from the following recipe:
+    https://github.com/sqlalchemy/sqlalchemy/issues/7228#issuecomment-1746837960
+
+    This is part of a workaround to make it more convenient to construct the VALUES clause in
+    SQLite. The VALUES clause is useful for creating a temporary table in the database with a set
+    of user inputs in the form of multi-value tuples, which can then be joined with other tables.
+    """
+    # omit rendering parenthesis, columns, "AS name", etc.
+    kw.pop("asfrom", None)
+    return cast(str, compiler.visit_values(elem, **kw))  # type: ignore[no-untyped-call]
+
+
+@compiles(Values, "sqlite")
+def render_values_w_union(
+    elem: Values,
+    compiler: compiler.SQLCompiler,
+    from_linter: Optional[compiler.FromLinter] = None,
+    **kw: Any,
+) -> str:
+    """
+    Adapted from the following recipe:
+    https://github.com/sqlalchemy/sqlalchemy/issues/7228#issuecomment-1746837960
+
+    This is part of a workaround to make it more convenient to construct the VALUES clause in
+    SQLite. The VALUES clause is useful for creating a temporary table in the database with a set
+    of user inputs in the form of multi-value tuples, which can then be joined with other tables.
+    """
+    first: tuple[Any, ...]
+    rest: list[tuple[Any, ...]]
+    first, *rest = [e for chunk in elem._data for e in chunk]
+    stmt = select(*(literal(val).label(col.key) for col, val in zip(elem.columns, first)))
+    if rest:
+        cols = [column(c.key, c.type) for c in elem.columns]
+        stmt = union_all(stmt, SubValues(*cols).data(rest))  # type: ignore[assignment]
+    subquery = stmt.subquery(elem.name)
+    if from_linter:
+        # replace all occurrences of elem with subquery so the from linter
+        # can eliminate the values object from its cartesian product check.
+        edges = set(from_linter.edges)
+        from_linter.edges.clear()
+        from_linter.edges.update(
+            tuple(subquery if node == elem else node for node in edge) for edge in edges
+        )
+    return compiler.process(subquery, from_linter=from_linter, **kw)
+
+
 class AuthMethod(Enum):
     LOCAL = "LOCAL"
     OAUTH2 = "OAUTH2"

{arize_phoenix-8.3.0 → arize_phoenix-8.4.1}/src/phoenix/server/api/context.py

@@ -29,6 +29,7 @@ from phoenix.server.api.dataloaders import (
     ExperimentSequenceNumberDataLoader,
     LatencyMsQuantileDataLoader,
     MinStartOrMaxEndTimeDataLoader,
+    NumChildSpansDataLoader,
     ProjectByNameDataLoader,
     PromptVersionSequenceNumberDataLoader,
     RecordCountDataLoader,
@@ -76,6 +77,7 @@ class DataLoaders:
     experiment_sequence_number: ExperimentSequenceNumberDataLoader
     latency_ms_quantile: LatencyMsQuantileDataLoader
     min_start_or_max_end_times: MinStartOrMaxEndTimeDataLoader
+    num_child_spans: NumChildSpansDataLoader
     project_fields: TableFieldsDataLoader
     prompt_version_sequence_number: PromptVersionSequenceNumberDataLoader
     record_counts: RecordCountDataLoader

{arize_phoenix-8.3.0 → arize_phoenix-8.4.1}/src/phoenix/server/api/dataloaders/__init__.py

@@ -17,6 +17,7 @@ from .experiment_run_counts import ExperimentRunCountsDataLoader
 from .experiment_sequence_number import ExperimentSequenceNumberDataLoader
 from .latency_ms_quantile import LatencyMsQuantileCache, LatencyMsQuantileDataLoader
 from .min_start_or_max_end_times import MinStartOrMaxEndTimeCache, MinStartOrMaxEndTimeDataLoader
+from .num_child_spans import NumChildSpansDataLoader
 from .project_by_name import ProjectByNameDataLoader
 from .prompt_version_sequence_number import PromptVersionSequenceNumberDataLoader
 from .record_counts import RecordCountCache, RecordCountDataLoader
@@ -53,6 +54,7 @@ __all__ = [
     "ExperimentSequenceNumberDataLoader",
     "LatencyMsQuantileDataLoader",
     "MinStartOrMaxEndTimeDataLoader",
+    "NumChildSpansDataLoader",
     "PromptVersionSequenceNumberDataLoader",
     "RecordCountDataLoader",
     "SessionIODataLoader",

arize_phoenix-8.4.1/src/phoenix/server/api/dataloaders/num_child_spans.py

@@ -0,0 +1,35 @@
+from typing import Iterable
+
+from sqlalchemy import func, select
+from strawberry.dataloader import DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db import models
+from phoenix.server.types import DbSessionFactory
+
+SpanRowId: TypeAlias = int
+
+Key: TypeAlias = SpanRowId
+Result: TypeAlias = int
+
+
+class NumChildSpansDataLoader(DataLoader[Key, Result]):
+    def __init__(self, db: DbSessionFactory) -> None:
+        super().__init__(load_fn=self._load_fn)
+        self._db = db
+
+    async def _load_fn(self, keys: Iterable[Key]) -> list[Result]:
+        span_rowids = list(set(keys))
+        result: dict[Key, Result] = {}
+        children = select(models.Span).alias("children")
+        stmt = (
+            select(models.Span.id, func.count())
+            .where(models.Span.id.in_(span_rowids))
+            .join(children, children.c.parent_id == models.Span.span_id)
+            .group_by(models.Span.id)
+        )
+        async with self._db() as session:
+            data = await session.stream(stmt)
+            async for span_rowid, num_child_spans in data:
+                result[span_rowid] = num_child_spans
+        return [result.get(span_rowid, 0) for span_rowid in keys]

arize_phoenix-8.4.1/src/phoenix/server/api/dataloaders/span_descendants.py

@@ -0,0 +1,103 @@
+from collections import defaultdict
+from typing import Iterable, Optional
+
+import sqlalchemy as sa
+from aioitertools.itertools import groupby
+from sqlalchemy import select
+from strawberry.dataloader import DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db.models import Span
+from phoenix.server.types import DbSessionFactory
+
+SpanRowId: TypeAlias = int
+MaxDepth: TypeAlias = int
+
+Key: TypeAlias = tuple[SpanRowId, Optional[MaxDepth]]
+Result: TypeAlias = list[SpanRowId]
+
+
+class SpanDescendantsDataLoader(DataLoader[Key, Result]):
+    def __init__(self, db: DbSessionFactory) -> None:
+        super().__init__(load_fn=self._load_fn)
+        self._db = db
+
+    async def _load_fn(self, keys: Iterable[Key]) -> list[Result]:
+        # Create a values expression with Span.id and respective max_depth (which can be None).
+        values = sa.values(
+            sa.Column("root_rowid", sa.Integer),
+            sa.Column("max_depth", sa.Integer, nullable=True),
+            name="values",
+        ).data(list(keys))
+
+        # Get the root spans with their depth limits by joining the values to the Span table.
+        roots = (
+            select(
+                Span.span_id,
+                values.c.root_rowid,
+                values.c.max_depth,
+            )
+            .join_from(values, Span, Span.id == values.c.root_rowid)
+            .subquery("roots")
+        )
+
+        # Initialize the recursive common table expression (CTE) with direct children
+        # of root spans, setting depth=1.
+        descendants = (
+            select(
+                Span.id,
+                Span.span_id,
+                Span.start_time,
+                roots.c.root_rowid,
+                roots.c.max_depth,
+                sa.literal(1).label("depth"),  # immediate children are depth=1 from root
+            )
+            .join_from(roots, Span, Span.parent_id == roots.c.span_id)
+            .cte("descendants", recursive=True)
+        )
+
+        # Build the recursive part of the query to fetch descendants at increasing depths.
+        # This recursively finds children of spans in the current depth level.
+        parents = descendants.alias("parents")
+        descendants = descendants.union_all(
+            select(
+                Span.id,
+                Span.span_id,
+                Span.start_time,
+                parents.c.root_rowid,
+                parents.c.max_depth,
+                (parents.c.depth + 1).label("depth"),  # Increment depth for each level
+            )
+            .join_from(parents, Span, Span.parent_id == parents.c.span_id)
+            .where(
+                sa.or_(
+                    parents.c.max_depth.is_(None),  # No limit if max_depth is NULL
+                    parents.c.depth + 1 <= parents.c.max_depth,  # Stop when max depth is reached
+                ),
+            )
+        )
+
+        # Final query to select and order all descendants.
+        # Ordering ensures breadth-first traversal and consistent results.
+        stmt = select(
+            descendants.c.id,
+            descendants.c.root_rowid,
+            descendants.c.max_depth,
+        ).order_by(
+            descendants.c.root_rowid,
+            descendants.c.max_depth,
+            descendants.c.depth,  # Order by depth for BFS traversal
+            descendants.c.start_time,
+            descendants.c.id,
+        )
+
+        results: defaultdict[Key, Result] = defaultdict(list)
+        async with self._db() as session:
+            data = await session.stream(stmt)
+            # Group results by root_rowid and max_depth (the Key tuple)
+            async for key, group in groupby(data, key=lambda d: tuple(d[1:])):
+                # Extract span IDs (the database row IDs) and add them to the result list.
+                # The first column (index 0) from our query is Span.id.
+                results[key].extend(id_ for id_, *_ in group)
+
+        return [results[key].copy() for key in keys]

{arize_phoenix-8.3.0 → arize_phoenix-8.4.1}/src/phoenix/server/api/input_types/SpanSort.py

@@ -30,7 +30,7 @@ class SpanColumn(Enum):
 
     @property
     def column_name(self) -> str:
-        return "f{self.name}_span_sort_column"
+        return f"{self.name}_span_sort_column"
 
     @property
     def orm_expression(self) -> Any:

{arize_phoenix-8.3.0 → arize_phoenix-8.4.1}/src/phoenix/server/api/queries.py

@@ -1,19 +1,21 @@
 from collections import defaultdict
 from datetime import datetime
-from typing import Optional, Union
+from typing import Iterable, Iterator, Optional, Union, cast
 
 import numpy as np
 import numpy.typing as npt
 import strawberry
-from sqlalchemy import and_, distinct, func, select
+from sqlalchemy import and_, distinct, func, select, text
 from sqlalchemy.orm import joinedload
 from starlette.authentication import UnauthenticatedUser
 from strawberry import ID, UNSET
 from strawberry.relay import Connection, GlobalID, Node
 from strawberry.types import Info
-from typing_extensions import Annotated, TypeAlias
+from typing_extensions import Annotated, TypeAlias, assert_never
 
+from phoenix.config import ENV_PHOENIX_SQL_DATABASE_SCHEMA, getenv
 from phoenix.db import enums, models
+from phoenix.db.helpers import SupportedSQLDialect
 from phoenix.db.models import DatasetExample as OrmExample
 from phoenix.db.models import DatasetExampleRevision as OrmRevision
 from phoenix.db.models import DatasetVersion as OrmVersion
@@ -81,6 +83,12 @@ class ModelsInput:
     model_name: Optional[str] = None
 
 
+@strawberry.type
+class DbTableStats:
+    table_name: str
+    num_bytes: int
+
+
 @strawberry.type
 class Query:
     @strawberry.field
@@ -780,3 +788,64 @@ class Query:
         return to_gql_clusters(
             clustered_events=clustered_events,
         )
+
+    @strawberry.field
+    async def db_table_stats(
+        self,
+        info: Info[Context, None],
+    ) -> list[DbTableStats]:
+        if info.context.db.dialect is SupportedSQLDialect.SQLITE:
+            stmt = text("SELECT name, sum(pgsize) FROM dbstat group by name;")
+            async with info.context.db() as session:
+                stats = cast(Iterable[tuple[str, int]], await session.execute(stmt))
+            stats = _consolidate_sqlite_db_table_stats(stats)
+        elif info.context.db.dialect is SupportedSQLDialect.POSTGRESQL:
+            stmt = text(f"""\
+                SELECT c.relname, pg_total_relation_size(c.oid)
+                FROM pg_class as c
+                INNER JOIN pg_namespace as n ON n.oid = c.relnamespace
+                WHERE c.relkind = 'r'
+                AND n.nspname = '{getenv(ENV_PHOENIX_SQL_DATABASE_SCHEMA) or "public"}';
+            """)
+            async with info.context.db() as session:
+                stats = cast(Iterable[tuple[str, int]], await session.execute(stmt))
+        else:
+            assert_never(info.context.db.dialect)
+        return [
+            DbTableStats(table_name=table_name, num_bytes=num_bytes)
+            for table_name, num_bytes in stats
+        ]
+
+
+def _consolidate_sqlite_db_table_stats(
+    stats: Iterable[tuple[str, int]],
+) -> Iterator[tuple[str, int]]:
+    """
+    Consolidate SQLite database stats by combining indexes with their respective tables.
+    """
+    aggregate: dict[str, int] = {}
+    for name, num_bytes in stats:
+        # Skip internal SQLite tables and indexes.
+        if name.startswith("ix_") or name.startswith("sqlite_"):
+            continue
+        aggregate[name] = num_bytes
+    for name, num_bytes in stats:
+        # Combine indexes with their respective tables.
+        for flag in ["sqlite_autoindex_", "ix_"]:
+            if not name.startswith(flag):
+                continue
+            if parent := _longest_matching_prefix(name[len(flag) :], aggregate.keys()):
+                aggregate[parent] += num_bytes
+            break
+    yield from aggregate.items()
+
+
+def _longest_matching_prefix(s: str, prefixes: Iterable[str]) -> str:
+    """
+    Return the longest prefix of s that matches any of the given prefixes.
+    """
+    longest = ""
+    for prefix in prefixes:
+        if s.startswith(prefix) and len(prefix) > len(longest):
+            longest = prefix
+    return longest

{arize_phoenix-8.3.0 → arize_phoenix-8.4.1}/src/phoenix/server/api/types/Span.py

@@ -9,7 +9,7 @@ import numpy as np
 import strawberry
 from openinference.semconv.trace import SpanAttributes
 from strawberry import ID, UNSET
-from strawberry.relay import Node, NodeID
+from strawberry.relay import Connection, Node, NodeID
 from strawberry.types import Info
 from typing_extensions import Annotated, TypeAlias
 
@@ -30,6 +30,7 @@ from phoenix.server.api.types.Evaluation import DocumentEvaluation
 from phoenix.server.api.types.ExampleRevisionInterface import ExampleRevision
 from phoenix.server.api.types.GenerativeProvider import GenerativeProvider
 from phoenix.server.api.types.MimeType import MimeType
+from phoenix.server.api.types.pagination import ConnectionArgs, CursorString, connection_from_list
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.SpanAnnotation import SpanAnnotation, to_gql_span_annotation
 from phoenix.server.api.types.SpanIOValue import SpanIOValue, truncate_value
@@ -537,15 +538,41 @@ class Span(Node):
             (self.span_rowid, evaluation_name or None, num_documents),
         )
 
+    @strawberry.field
+    async def num_child_spans(self, info: Info[Context, None]) -> int:
+        return await info.context.data_loaders.num_child_spans.load(self.span_rowid)
+
     @strawberry.field(
         description="All descendant spans (children, grandchildren, etc.)",
     )  # type: ignore
     async def descendants(
         self,
         info: Info[Context, None],
-    ) -> list["Span"]:
-        ids: Iterable[int] = await info.context.data_loaders.span_descendants.load(self.span_rowid)
-        return [Span(span_rowid=id_) for id_ in ids]
+        max_depth: Annotated[
+            Optional[int],
+            strawberry.argument(
+                description="Maximum depth of breadth first search. For example, "
+                "maxDepth=1 searches for only the immediate child spans (if any); "
+                "maxDepth=2 searches for the immediate child spans plus their children. "
+                "maxDepth=0 (or None) means no limit."
+            ),
+        ] = 3,
+        first: Optional[int] = 50,
+        last: Optional[int] = UNSET,
+        after: Optional[CursorString] = UNSET,
+        before: Optional[CursorString] = UNSET,
+    ) -> Connection["Span"]:
+        args = ConnectionArgs(
+            first=first,
+            after=after if isinstance(after, CursorString) else None,
+            last=last,
+            before=before if isinstance(before, CursorString) else None,
+        )
+        span_rowids: Iterable[int] = await info.context.data_loaders.span_descendants.load(
+            (self.span_rowid, max_depth or None),
+        )
+        data = [Span(span_rowid=span_rowid) for span_rowid in span_rowids]
+        return connection_from_list(data=data, args=args)
 
     @strawberry.field(
         description="The span's attributes translated into an example revision for a dataset",

{arize_phoenix-8.3.0 → arize_phoenix-8.4.1}/src/phoenix/server/app.py

@@ -85,6 +85,7 @@ from phoenix.server.api.dataloaders import (
     ExperimentSequenceNumberDataLoader,
     LatencyMsQuantileDataLoader,
     MinStartOrMaxEndTimeDataLoader,
+    NumChildSpansDataLoader,
     ProjectByNameDataLoader,
     PromptVersionSequenceNumberDataLoader,
     RecordCountDataLoader,
@@ -614,6 +615,7 @@ def create_graphql_router(
                         else None
                     ),
                 ),
+                num_child_spans=NumChildSpansDataLoader(db),
                 project_fields=TableFieldsDataLoader(db, models.Project),
                 prompt_version_sequence_number=PromptVersionSequenceNumberDataLoader(db),
                 record_counts=RecordCountDataLoader(

arize_phoenix-8.4.1/src/phoenix/server/static/.vite/manifest.json

@@ -0,0 +1,87 @@
+{
+  "_components-CRlSj2mp.js": {
+    "file": "assets/components-CRlSj2mp.js",
+    "name": "components",
+    "imports": [
+      "_vendor-CRRq3WgM.js",
+      "_pages-o_YaLL0c.js",
+      "_vendor-arizeai-Dq64X_0o.js",
+      "_vendor-codemirror-C1oevlym.js",
+      "_vendor-three-C-AGeJYv.js"
+    ]
+  },
+  "_pages-o_YaLL0c.js": {
+    "file": "assets/pages-o_YaLL0c.js",
+    "name": "pages",
+    "imports": [
+      "_vendor-CRRq3WgM.js",
+      "_vendor-arizeai-Dq64X_0o.js",
+      "_components-CRlSj2mp.js",
+      "_vendor-codemirror-C1oevlym.js",
+      "_vendor-recharts-CPj01S89.js"
+    ]
+  },
+  "_vendor-CRRq3WgM.js": {
+    "file": "assets/vendor-CRRq3WgM.js",
+    "name": "vendor",
+    "imports": [
+      "_vendor-three-C-AGeJYv.js"
+    ],
+    "css": [
+      "assets/vendor-Cg6lcjUC.css"
+    ]
+  },
+  "_vendor-Cg6lcjUC.css": {
+    "file": "assets/vendor-Cg6lcjUC.css",
+    "src": "_vendor-Cg6lcjUC.css"
+  },
+  "_vendor-arizeai-Dq64X_0o.js": {
+    "file": "assets/vendor-arizeai-Dq64X_0o.js",
+    "name": "vendor-arizeai",
+    "imports": [
+      "_vendor-CRRq3WgM.js"
+    ]
+  },
+  "_vendor-codemirror-C1oevlym.js": {
+    "file": "assets/vendor-codemirror-C1oevlym.js",
+    "name": "vendor-codemirror",
+    "imports": [
+      "_vendor-CRRq3WgM.js",
+      "_vendor-shiki-aY7rz1pm.js"
+    ]
+  },
+  "_vendor-recharts-CPj01S89.js": {
+    "file": "assets/vendor-recharts-CPj01S89.js",
+    "name": "vendor-recharts",
+    "imports": [
+      "_vendor-CRRq3WgM.js"
+    ]
+  },
+  "_vendor-shiki-aY7rz1pm.js": {
+    "file": "assets/vendor-shiki-aY7rz1pm.js",
+    "name": "vendor-shiki",
+    "imports": [
+      "_vendor-CRRq3WgM.js"
+    ]
+  },
+  "_vendor-three-C-AGeJYv.js": {
+    "file": "assets/vendor-three-C-AGeJYv.js",
+    "name": "vendor-three"
+  },
+  "index.tsx": {
+    "file": "assets/index-YUNmSSFA.js",
+    "name": "index",
+    "src": "index.tsx",
+    "isEntry": true,
+    "imports": [
+      "_vendor-CRRq3WgM.js",
+      "_vendor-arizeai-Dq64X_0o.js",
+      "_pages-o_YaLL0c.js",
+      "_components-CRlSj2mp.js",
+      "_vendor-three-C-AGeJYv.js",
+      "_vendor-codemirror-C1oevlym.js",
+      "_vendor-shiki-aY7rz1pm.js",
+      "_vendor-recharts-CPj01S89.js"
+    ]
+  }
+}