Add Jaguar Re-ID MegaDescriptor Space

.dockerignore

@@ -0,0 +1,18 @@
+# Git
+.git
+
+# Python
+__pycache__
+*.py[cod]
+.venv
+venv
+
+# Caches
+.mypy_cache
+.pytest_cache
+
+# Local runtime artifacts
+demo_data
+
+# Misc
+.DS_Store

Dockerfile

@@ -0,0 +1,56 @@
+FROM python:3.11-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    curl \
+    git \
+    libssl-dev \
+    pkg-config \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    HF_HOME=/home/user/.cache/huggingface \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+WORKDIR $HOME/app
+
+RUN pip install --upgrade pip
+
+RUN pip install \
+    "fastapi==0.128.0" \
+    "uvicorn[standard]==0.40.0" \
+    "numpy==2.3.5" \
+    "umap-learn==0.5.11" \
+    "Pillow==12.1.0" \
+    "pydantic==2.12.5" \
+    "aiofiles==25.1.0" \
+    "datasets==4.5.0" \
+    "lancedb==0.27.1" \
+    "pyarrow==22.0.0" \
+    "torch==2.9.1" \
+    "torchvision==0.24.1" \
+    "timm==1.0.24"
+
+COPY --chown=user vendor ./vendor
+COPY --chown=user demo.py ./demo.py
+
+ENV PYTHONPATH=/home/user/app/vendor \
+    HYPERVIEW_DATASETS_DIR=/home/user/app/demo_data/datasets \
+    HYPERVIEW_MEDIA_DIR=/home/user/app/demo_data/media
+
+RUN python -c "import hyperview; print('hyperview', hyperview.__version__)"
+
+# Precompute at build time so the Space starts fast.
+RUN python -c "from demo import build_dataset; build_dataset()"
+
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=120s --retries=3 \
+    CMD curl -f http://localhost:7860/__hyperview__/health || exit 1
+
+CMD ["python", "demo.py"]

README.md

@@ -1,10 +1,50 @@
 ---
-title: HyperView Jaguar ReID
-emoji: 🚀
-colorFrom: pink
-colorTo: pink
+title: HyperView-Jaguar-ReID
+emoji: 🐆
+colorFrom: yellow
+colorTo: green
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# HyperView - Jaguar Re-ID (MegaDescriptor + Sphere)
+
+This Space runs the Jaguar Re-ID dataset through the MegaDescriptor timm
+backbone and renders the result with HyperView's spherical 3D layout.
+
+Unlike the Imagenette starter, this folder vendors the current HyperView source
+under `vendor/hyperview/`. The released `hyperview==0.2.0` wheel does not yet
+include the `timm-image` provider or spherical layout support required by this
+demo, so the Space builds against the local source snapshot instead of PyPI.
+
+This demo uses:
+
+- Hugging Face dataset `hyper3labs/jaguar-re-id`
+- Config `default`
+- Split `train`
+- Image field `image`
+- Label field `label`
+- Sample count `200`
+- Embedding model `hf-hub:BVRA/MegaDescriptor-L-384`
+- Layout `spherical` (3D)
+
+## Build model
+
+The Dockerfile precomputes the dataset, embeddings, and layout during image
+build so the runtime container only needs to launch HyperView.
+
+Because MegaDescriptor inference runs during Docker build on CPU, this Space
+keeps the sample count modest and uses a smaller batch size than the local demo
+script to stay within typical Hugging Face build limits.
+
+## Vendored source
+
+This folder includes a vendored `vendor/hyperview/` snapshot copied from the
+main HyperView repository. Keep that snapshot in sync with the local repo if
+you update the jaguar demo or any unreleased HyperView behavior it depends on.
+
+## Deploy source
+
+This folder is synchronized to Hugging Face Spaces by GitHub Actions from the
+`hyperview-spaces` deployment repository.

demo.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+"""HyperView Jaguar Re-ID Hugging Face Space."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+SPACE_HOST = "0.0.0.0"
+SPACE_PORT = 7860
+
+DATASET_NAME = "jaguar_reid_megadescriptor_spherical_space"
+HF_DATASET = "hyper3labs/jaguar-re-id"
+HF_CONFIG = "default"
+HF_SPLIT = "train"
+HF_IMAGE_KEY = "image"
+HF_LABEL_KEY = "label"
+SAMPLE_COUNT = 200
+MODEL_ID = "hf-hub:BVRA/MegaDescriptor-L-384"
+BATCH_SIZE = 4
+
+ROOT = Path(__file__).resolve().parent
+VENDOR_DIR = ROOT / "vendor"
+if str(VENDOR_DIR) not in sys.path:
+    sys.path.insert(0, str(VENDOR_DIR))
+
+import hyperview as hv
+
+
+def build_dataset() -> hv.Dataset:
+    dataset = hv.Dataset(DATASET_NAME)
+
+    if len(dataset) == 0:
+        print(f"Loading {SAMPLE_COUNT} samples from {HF_DATASET} [{HF_CONFIG}] ({HF_SPLIT})...")
+        dataset.add_from_huggingface(
+            HF_DATASET,
+            config=HF_CONFIG,
+            split=HF_SPLIT,
+            image_key=HF_IMAGE_KEY,
+            label_key=HF_LABEL_KEY,
+            max_samples=SAMPLE_COUNT,
+        )
+
+    print(f"Ensuring MegaDescriptor embeddings ({MODEL_ID})...")
+    space_key = dataset.compute_embeddings(
+        model=MODEL_ID,
+        provider="timm-image",
+        batch_size=BATCH_SIZE,
+        show_progress=True,
+    )
+
+    print("Ensuring spherical layout...")
+    dataset.compute_visualization(space_key=space_key, layout="spherical")
+
+    return dataset
+
+
+def main() -> None:
+    dataset = build_dataset()
+    print(f"Starting HyperView on {SPACE_HOST}:{SPACE_PORT}")
+    hv.launch(dataset, host=SPACE_HOST, port=SPACE_PORT, open_browser=False)
+
+
+if __name__ == "__main__":
+    main()

vendor/hyperview/__init__.py

@@ -0,0 +1,14 @@
+"""HyperView - Open-source dataset curation with hyperbolic embeddings visualization."""
+
+from . import _version as _version
+from . import api as _api
+
+Dataset = _api.Dataset
+launch = _api.launch
+__version__ = _version.__version__
+
+__all__ = [
+    "Dataset",
+    "launch",
+    "__version__",
+]

vendor/hyperview/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.2.1.dev2+g55532b8e3.d20260307'
+__version_tuple__ = version_tuple = (0, 2, 1, 'dev2', 'g55532b8e3.d20260307')
+
+__commit_id__ = commit_id = None

vendor/hyperview/api.py

@@ -0,0 +1,408 @@
+"""Public API for HyperView."""
+
+import json
+import os
+import socket
+import threading
+import time
+import webbrowser
+from dataclasses import dataclass
+from urllib.error import URLError
+from urllib.request import Request, urlopen
+from uuid import uuid4
+
+import uvicorn
+
+from hyperview.core.dataset import Dataset
+from hyperview.server.app import create_app, set_dataset
+
+__all__ = ["Dataset", "launch", "Session"]
+
+
+@dataclass(frozen=True)
+class _HealthResponse:
+    name: str | None
+    session_id: str | None
+    dataset: str | None
+    pid: int | None
+
+
+def _can_connect(host: str, port: int, timeout_s: float) -> bool:
+    try:
+        with socket.create_connection((host, port), timeout=timeout_s):
+            return True
+    except OSError:
+        return False
+
+
+def _try_read_health(url: str, timeout_s: float) -> _HealthResponse | None:
+    try:
+        return _read_health(url, timeout_s=timeout_s)
+    except (URLError, TimeoutError, OSError, ValueError, json.JSONDecodeError):
+        return None
+
+
+def _read_health(url: str, timeout_s: float) -> _HealthResponse:
+    request = Request(url, headers={"Accept": "application/json"})
+    with urlopen(request, timeout=timeout_s) as response:
+        data = json.loads(response.read().decode("utf-8"))
+
+    return _HealthResponse(
+        name=data.get("name"),
+        session_id=data.get("session_id"),
+        dataset=data.get("dataset"),
+        pid=data.get("pid") if isinstance(data.get("pid"), int) else None,
+    )
+
+
+def _resolve_default_launch_layout(dataset: Dataset) -> str:
+    spaces = dataset.list_spaces()
+
+    if any(space.geometry not in ("hyperboloid", "hypersphere") for space in spaces):
+        return "euclidean:2d"
+    if any(space.geometry == "hypersphere" for space in spaces):
+        return "spherical:3d"
+    return "poincare:2d"
+
+
+class Session:
+    """A session for the HyperView visualizer."""
+
+    def __init__(self, dataset: Dataset, host: str, port: int):
+        self.dataset = dataset
+        self.host = host
+        self.port = port
+        # Prefer a browser-connectable host for user-facing URLs.
+        # When binding to 0.0.0.0, users should connect via 127.0.0.1 locally.
+        self.url = f"http://{self._connect_host}:{port}"
+        self._server_thread: threading.Thread | None = None
+        self._server: uvicorn.Server | None = None
+        self._startup_error: BaseException | None = None
+        self.session_id = uuid4().hex
+
+    @property
+    def _connect_host(self) -> str:
+        return "127.0.0.1" if self.host == "0.0.0.0" else self.host
+
+    @property
+    def _health_url(self) -> str:
+        return f"http://{self._connect_host}:{self.port}/__hyperview__/health"
+
+    def _run_server(self):
+        try:
+            set_dataset(self.dataset)
+            app = create_app(self.dataset, session_id=self.session_id)
+            config = uvicorn.Config(app, host=self.host, port=self.port, log_level="warning")
+            self._server = uvicorn.Server(config)
+            self._server.run()
+        except BaseException as exc:
+            self._startup_error = exc
+
+    def start(self, background: bool = True):
+        """Start the visualizer server."""
+        if not background:
+            self._run_server()
+            return
+
+        # Fail fast if something is already listening on this port.
+        if _can_connect(self._connect_host, self.port, timeout_s=0.2):
+            health = _try_read_health(self._health_url, timeout_s=0.2)
+            if health is not None and health.name == "hyperview":
+                raise RuntimeError(
+                    "HyperView failed to start because the port is already serving "
+                    f"HyperView (port={self.port}, session_id={health.session_id}). "
+                    "Choose a different port or stop the existing server."
+                )
+
+            raise RuntimeError(
+                "HyperView failed to start because the port is already in use "
+                f"by a non-HyperView service (port={self.port}). Choose a different "
+                "port or stop the process listening on that port."
+            )
+
+        self._startup_error = None
+        self._server_thread = threading.Thread(target=self._run_server, daemon=True)
+        self._server_thread.start()
+
+        deadline = time.time() + 5.0
+        last_health_error: Exception | None = None
+
+        while time.time() < deadline:
+            if self._startup_error is not None:
+                raise RuntimeError(
+                    f"HyperView server failed to start (port={self.port}): "
+                    f"{type(self._startup_error).__name__}: {self._startup_error}"
+                )
+
+            if self._server_thread is not None and not self._server_thread.is_alive():
+                raise RuntimeError(
+                    "HyperView server thread exited during startup. "
+                    f"The port may be in use (port={self.port})."
+                )
+
+            try:
+                health = _read_health(self._health_url, timeout_s=0.2)
+            except (URLError, TimeoutError, OSError, ValueError, json.JSONDecodeError) as exc:
+                last_health_error = exc
+                time.sleep(0.05)
+                continue
+
+            if health.name == "hyperview" and health.session_id == self.session_id:
+                return
+
+            if health.name == "hyperview":
+                raise RuntimeError(
+                    "HyperView failed to start because the port is already serving "
+                    f"a different HyperView session (port={self.port}, "
+                    f"session_id={health.session_id})."
+                )
+
+            raise RuntimeError(
+                "HyperView failed to start because the port is already serving "
+                f"a non-HyperView app (port={self.port})."
+            )
+
+        raise TimeoutError(
+            "HyperView server did not become ready in time "
+            f"(port={self.port}). Last error: {last_health_error}"
+        )
+
+    def stop(self):
+        """Stop the visualizer server."""
+        if self._server:
+            self._server.should_exit = True
+
+    def show(self, height: int = 800):
+        """Display the visualizer in a notebook.
+
+        In Google Colab, notebook kernels cannot be accessed via localhost.
+        Colab exposes kernel ports through a proxy URL (see
+        `google.colab.kernel.proxyPort`). This renders a link to the proxied URL
+        that opens in a new tab.
+
+        In other notebook environments, it renders a clickable link to the local
+        URL and a best-effort JavaScript auto-open.
+        """
+        if _is_colab():
+            try:
+                from google.colab.output import eval_js  # type: ignore[import-not-found]
+                from IPython.display import HTML, display
+
+                proxy_url = eval_js(f"google.colab.kernel.proxyPort({self.port})")
+                app_url = str(proxy_url).rstrip("/") + "/"
+
+                display(
+                    HTML(
+                        "<p>HyperView is running in Colab. "
+                        f"<a href=\"{app_url}\" target=\"_blank\" rel=\"noopener noreferrer\">"
+                        "Open HyperView in a new tab</a>.</p>"
+                    )
+                )
+                display(HTML(f"<p style=\"font-size:12px;color:#666;\">{app_url}</p>"))
+                return
+            except Exception:
+                # Fall through to the generic notebook behavior.
+                pass
+
+        # Default: open in a new browser tab (works well for Jupyter).
+        try:
+            from IPython.display import HTML, Javascript, display
+
+            display(
+                HTML(
+                    "<p>HyperView is running. "
+                    f"<a href=\"{self.url}\" target=\"_blank\" rel=\"noopener\">Open in a new tab</a>."
+                    "</p>"
+                )
+            )
+
+            # Best-effort auto-open. Some browsers may block popups.
+            display(Javascript(f'window.open("{self.url}", "_blank");'))
+        except ImportError:
+            print(f"IPython not installed. Please visit {self.url} in your browser.")
+
+    def open_browser(self):
+        """Open the visualizer in a browser window."""
+        webbrowser.open(self.url)
+
+
+def launch(
+    dataset: Dataset,
+    port: int = 6262,
+    host: str = "127.0.0.1",
+    open_browser: bool = True,
+    notebook: bool | None = None,
+    height: int = 800,
+    reuse_server: bool = False,
+) -> Session:
+    """Launch the HyperView visualization server.
+
+    Note:
+        HyperView needs at least one visualization to display. If no layouts
+        exist yet but embedding spaces do, this function computes one default
+        layout automatically.
+
+    Args:
+        dataset: The dataset to visualize.
+        port: Port to run the server on.
+        host: Host to bind to.
+        open_browser: Whether to open a browser window.
+        notebook: Whether to display in a notebook. If None, auto-detects.
+        height: Height of the iframe in the notebook.
+        reuse_server: If True, and the requested port is already serving HyperView,
+            attach to the existing server instead of starting a new one. For safety,
+            this will only attach when the existing server reports the same dataset
+            name (via `/__hyperview__/health`).
+
+    Returns:
+        A Session object.
+
+    Example:
+        >>> import hyperview as hv
+        >>> dataset = hv.Dataset("my_dataset")
+        >>> dataset.add_images_dir("/path/to/images", label_from_folder=True)
+        >>> dataset.compute_embeddings(model="openai/clip-vit-base-patch32")
+        >>> dataset.compute_visualization()
+        >>> hv.launch(dataset)
+    """
+    if notebook is None:
+        # Colab is always a notebook environment, even if _is_notebook() fails to detect it
+        notebook = _is_notebook() or _is_colab()
+
+    if _is_colab() and host == "127.0.0.1":
+        # Colab port forwarding/proxying is most reliable when the server binds
+        # to all interfaces.
+        host = "0.0.0.0"
+
+    # Preflight: avoid doing expensive work if the port is already in use.
+    # If it's already serving HyperView and reuse_server=True, we can safely attach.
+    connect_host = "127.0.0.1" if host == "0.0.0.0" else host
+    health_url = f"http://{connect_host}:{port}/__hyperview__/health"
+
+    if _can_connect(connect_host, port, timeout_s=0.2):
+        health = _try_read_health(health_url, timeout_s=0.2)
+        if health is not None and health.name == "hyperview":
+            if not reuse_server:
+                raise RuntimeError(
+                    "HyperView failed to start because the port is already serving "
+                    f"HyperView (port={port}, dataset={health.dataset}, "
+                    f"session_id={health.session_id}, pid={health.pid}). "
+                    "Choose a different port, stop the existing server, or pass "
+                    "reuse_server=True to attach."
+                )
+
+            if health.dataset is not None and health.dataset != dataset.name:
+                raise RuntimeError(
+                    "HyperView refused to attach to the existing server because it is "
+                    f"serving a different dataset (port={port}, dataset={health.dataset}). "
+                    f"Requested dataset={dataset.name}. Stop the existing server or "
+                    "choose a different port."
+                )
+
+            session = Session(dataset, host, port)
+            if health.session_id is not None:
+                session.session_id = health.session_id
+
+            if notebook:
+                if _is_colab():
+                    print(
+                        f"\nHyperView is already running (Colab, port={session.port}). "
+                        "Use the link below to open it."
+                    )
+                else:
+                    print(
+                        f"\nHyperView is already running at {session.url} (port={session.port}). "
+                        "Opening a new tab..."
+                    )
+                session.show(height=height)
+            else:
+                print(f"\nHyperView is already running at {session.url} (port={session.port}).")
+                if open_browser:
+                    session.open_browser()
+
+            return session
+
+        raise RuntimeError(
+            "HyperView failed to start because the port is already in use "
+            f"by a non-HyperView service (port={port}). Choose a different "
+            "port or stop the process listening on that port."
+        )
+
+    layouts = dataset.list_layouts()
+    spaces = dataset.list_spaces()
+
+    if not layouts and not spaces:
+        raise ValueError(
+            "HyperView launch requires at least one visualization or embedding space. "
+            "No visualizations or embedding spaces were found. "
+            "Call `dataset.compute_embeddings()` and `dataset.compute_visualization()` "
+            "or `dataset.set_coords()` before `hv.launch()`."
+        )
+
+    if not layouts:
+        default_layout = _resolve_default_launch_layout(dataset)
+
+        print(f"No visualizations found. Computing {default_layout} visualization...")
+        # Let compute_visualization pick the most appropriate default space.
+        dataset.compute_visualization(
+            space_key=None,
+            layout=default_layout,
+        )
+
+    session = Session(dataset, host, port)
+
+    if notebook:
+        session.start(background=True)
+        if _is_colab():
+            print(
+                f"\nHyperView is running (Colab, port={session.port}). "
+                "Use the link below to open it."
+            )
+        else:
+            print(f"\nHyperView is running at {session.url}. Opening a new tab...")
+        session.show(height=height)
+    else:
+        session.start(background=True)
+        print("   Press Ctrl+C to stop.\n")
+        print(f"\nHyperView is running at {session.url}")
+
+        if open_browser:
+            session.open_browser()
+
+        try:
+            while True:
+                # Keep the main thread alive so the daemon server thread can run.
+                time.sleep(0.25)
+                if session._server_thread is not None and not session._server_thread.is_alive():
+                    raise RuntimeError("HyperView server stopped unexpectedly.")
+        except KeyboardInterrupt:
+            pass
+        finally:
+            session.stop()
+            if session._server_thread is not None:
+                session._server_thread.join(timeout=2.0)
+
+    return session
+
+
+def _is_notebook() -> bool:
+    """Check if running in a notebook environment."""
+    try:
+        from IPython import get_ipython
+    except ImportError:
+        return False
+
+    shell = get_ipython()
+    return shell is not None and shell.__class__.__name__ == "ZMQInteractiveShell"
+
+
+def _is_colab() -> bool:
+    """Check if running inside a Google Colab notebook runtime."""
+    if os.environ.get("COLAB_RELEASE_TAG"):
+        return True
+    try:
+        import google.colab  # type: ignore[import-not-found]
+
+        return True
+    except ImportError:
+        return False

vendor/hyperview/cli.py

@@ -0,0 +1,362 @@
+"""Command-line interface for HyperView."""
+
+from __future__ import annotations
+
+import argparse
+
+from hyperview import Dataset, launch
+from hyperview.core.dataset import parse_visualization_layout
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="hyperview",
+        description="HyperView - Dataset visualization with hyperbolic embeddings",
+    )
+
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default=None,
+        help=(
+            "Dataset name in persistent storage. Required unless "
+            "--dataset-json is provided."
+        ),
+    )
+    parser.add_argument(
+        "--dataset-json",
+        type=str,
+        help="Path to exported dataset JSON file (loads samples into memory)",
+    )
+    parser.add_argument(
+        "--hf-dataset",
+        type=str,
+        help="HuggingFace dataset ID to ingest before launch (e.g. uoft-cs/cifar10)",
+    )
+    parser.add_argument(
+        "--split",
+        type=str,
+        default=None,
+        help="HuggingFace split to use (required with --hf-dataset)",
+    )
+    parser.add_argument(
+        "--hf-config",
+        type=str,
+        default=None,
+        help="Optional HuggingFace subset/configuration to use",
+    )
+    parser.add_argument(
+        "--image-key",
+        type=str,
+        default=None,
+        help="Image column key for HuggingFace ingestion (required with --hf-dataset)",
+    )
+    parser.add_argument(
+        "--label-key",
+        type=str,
+        default=None,
+        help="Label column key for HuggingFace ingestion (optional)",
+    )
+    parser.add_argument(
+        "--label-names-key",
+        type=str,
+        default=None,
+        help="Optional dataset info key containing label names",
+    )
+    parser.add_argument(
+        "--images-dir",
+        type=str,
+        help="Local directory of images to ingest before launch",
+    )
+    parser.add_argument(
+        "--label-from-folder",
+        action="store_true",
+        help="When using --images-dir, derive label from parent folder name",
+    )
+    parser.add_argument(
+        "--samples",
+        type=int,
+        default=None,
+        help="Maximum number of ingested samples (omit to load all)",
+    )
+    parser.add_argument(
+        "--hf-streaming",
+        action="store_true",
+        help=(
+            "Stream HuggingFace rows instead of materializing the full split first. "
+            "Useful for loading subsets without eager full-split downloads."
+        ),
+    )
+    parser.add_argument(
+        "--shuffle",
+        action="store_true",
+        help="Shuffle HuggingFace dataset before sampling",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed used when --shuffle is enabled (default: 42)",
+    )
+    parser.add_argument(
+        "--hf-shuffle-buffer-size",
+        type=int,
+        default=1000,
+        help=(
+            "Shuffle buffer size used with --hf-streaming and --shuffle. "
+            "Streaming shuffle is approximate and trades larger buffers for more read-ahead."
+        ),
+    )
+
+    parser.add_argument(
+        "--model",
+        type=str,
+        default=None,
+        help=(
+            "Embedding model to compute before launch (e.g. openai/clip-vit-base-patch32). "
+            "If omitted, existing embedding spaces are reused."
+        ),
+    )
+    parser.add_argument(
+        "--method",
+        choices=["umap"],
+        default="umap",
+        help="Projection method (currently only 'umap')",
+    )
+    parser.add_argument(
+        "--layout",
+        action="append",
+        dest="layouts",
+        metavar="GEOMETRY[:2d|3d]",
+        help=(
+            "Visualization layout to compute. Repeat this flag to request multiple layouts, "
+            "for example '--layout euclidean --layout spherical'. "
+            "Omitting the suffix defaults to 2D for euclidean/poincare and 3D for spherical. "
+            "If omitted, HyperView picks one sensible default layout for the selected embedding space."
+        ),
+    )
+    parser.add_argument(
+        "--n-neighbors",
+        type=int,
+        default=15,
+        help="UMAP n_neighbors (default: 15)",
+    )
+    parser.add_argument(
+        "--min-dist",
+        type=float,
+        default=0.1,
+        help="UMAP min_dist (default: 0.1)",
+    )
+    parser.add_argument(
+        "--metric",
+        type=str,
+        default="cosine",
+        help="UMAP metric (default: cosine)",
+    )
+    parser.add_argument(
+        "--force-layout",
+        action="store_true",
+        help="Force layout recomputation even if projection already exists",
+    )
+
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=6262,
+        help="Port to run the server on (default: 6262)",
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="127.0.0.1",
+        help="Host to bind the server to (default: 127.0.0.1)",
+    )
+    parser.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Do not open a browser window automatically",
+    )
+    parser.add_argument(
+        "--reuse-server",
+        action="store_true",
+        help=(
+            "If the port is already serving HyperView, attach instead of failing. "
+            "For safety, this only attaches when the existing server reports the same dataset name."
+        ),
+    )
+
+    return parser
+
+
+def _validate_args(parser: argparse.ArgumentParser, args: argparse.Namespace) -> None:
+    if args.layouts:
+        canonical_layouts: list[str] = []
+        seen_layouts: set[str] = set()
+        for layout_spec in args.layouts:
+            try:
+                geometry, layout_dimension = parse_visualization_layout(layout_spec)
+            except ValueError as exc:
+                parser.error(str(exc))
+
+            canonical_layout = f"{geometry}:{layout_dimension}d"
+            if canonical_layout in seen_layouts:
+                continue
+            seen_layouts.add(canonical_layout)
+            canonical_layouts.append(canonical_layout)
+
+        args.layouts = canonical_layouts
+
+    if args.hf_dataset and args.images_dir:
+        parser.error("Use either --hf-dataset or --images-dir, not both.")
+
+    if args.dataset_json and (args.hf_dataset or args.images_dir):
+        parser.error("--dataset-json cannot be combined with --hf-dataset or --images-dir.")
+
+    if args.dataset_json and args.dataset:
+        parser.error("Use either --dataset or --dataset-json, not both.")
+
+    if not args.dataset and not args.dataset_json:
+        parser.error(
+            "Provide --dataset (persistent dataset) or --dataset-json (exported dataset file)."
+        )
+
+    if args.hf_dataset:
+        if not args.split:
+            parser.error("--split is required when using --hf-dataset.")
+        if not args.image_key:
+            parser.error("--image-key is required when using --hf-dataset.")
+        if args.hf_shuffle_buffer_size < 1:
+            parser.error("--hf-shuffle-buffer-size must be at least 1.")
+
+
+def _print_ingestion_result(added: int, skipped: int) -> None:
+    if skipped > 0:
+        print(f"Loaded {added} samples ({skipped} already present)")
+    else:
+        print(f"Loaded {added} samples")
+
+
+def _ingest_huggingface(dataset: Dataset, args: argparse.Namespace, dataset_name: str) -> None:
+    config_suffix = f" [{args.hf_config}]" if args.hf_config else ""
+    print(f"Loading HuggingFace dataset {dataset_name}{config_suffix}...")
+    added, skipped = dataset.add_from_huggingface(
+        dataset_name,
+        config=args.hf_config,
+        split=args.split,
+        image_key=args.image_key,
+        label_key=args.label_key,
+        label_names_key=args.label_names_key,
+        max_samples=args.samples,
+        shuffle=args.shuffle,
+        seed=args.seed,
+        streaming=args.hf_streaming,
+        shuffle_buffer_size=args.hf_shuffle_buffer_size,
+    )
+    _print_ingestion_result(added, skipped)
+
+
+def _prepare_dataset(args: argparse.Namespace) -> Dataset:
+    if args.dataset_json:
+        print(f"Loading dataset from {args.dataset_json}...")
+        dataset = Dataset.load(args.dataset_json)
+        print(f"Loaded {len(dataset)} samples")
+        return dataset
+
+    dataset = Dataset(args.dataset)
+    print(f"Using dataset '{dataset.name}' ({len(dataset)} samples)")
+
+    if args.hf_dataset:
+        _ingest_huggingface(dataset, args, args.hf_dataset)
+    elif args.images_dir:
+        print(f"Loading images from {args.images_dir}...")
+        added, skipped = dataset.add_images_dir(
+            args.images_dir,
+            label_from_folder=args.label_from_folder,
+        )
+        _print_ingestion_result(added, skipped)
+
+    return dataset
+
+
+def _resolve_default_layouts(
+    dataset: Dataset,
+    space_key: str | None,
+) -> list[str]:
+    spaces = dataset.list_spaces()
+    selected = next((space for space in spaces if space.space_key == space_key), None)
+
+    if selected is not None:
+        if selected.geometry == "hyperboloid":
+            return ["poincare:2d"]
+        if selected.geometry == "hypersphere":
+            return ["spherical:3d"]
+        return ["euclidean:2d"]
+
+    if any(space.geometry not in ("hyperboloid", "hypersphere") for space in spaces):
+        return ["euclidean:2d"]
+    if any(space.geometry == "hypersphere" for space in spaces):
+        return ["spherical:3d"]
+    return ["poincare:2d"]
+
+def _compute_layouts(dataset: Dataset, args: argparse.Namespace, space_key: str | None) -> None:
+    target_layouts = args.layouts or _resolve_default_layouts(dataset, space_key)
+
+    print("Computing visualizations...")
+    for target_layout in target_layouts:
+        dataset.compute_visualization(
+            space_key=space_key,
+            method=args.method,
+            layout=target_layout,
+            n_neighbors=args.n_neighbors,
+            min_dist=args.min_dist,
+            metric=args.metric,
+            force=args.force_layout,
+        )
+    print("Visualizations ready")
+
+
+def _prepare_embeddings_and_layouts(dataset: Dataset, args: argparse.Namespace) -> None:
+    has_spaces = len(dataset.list_spaces()) > 0
+
+    if args.model is not None:
+        print(f"Computing embeddings with {args.model}...")
+        space_key = dataset.compute_embeddings(model=args.model, show_progress=True)
+        print("Embeddings computed")
+        _compute_layouts(dataset, args, space_key)
+        return
+
+    if args.force_layout:
+        if not has_spaces:
+            raise ValueError(
+                "No embedding spaces found. Provide --model to compute embeddings first."
+            )
+        _compute_layouts(dataset, args, space_key=None)
+        return
+
+    if not has_spaces:
+        raise ValueError(
+            "No embedding spaces found. Provide --model to compute embeddings first."
+        )
+
+
+def main():
+    """Main CLI entry point."""
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    _validate_args(parser, args)
+
+    dataset = _prepare_dataset(args)
+    _prepare_embeddings_and_layouts(dataset, args)
+
+    launch(
+        dataset,
+        port=args.port,
+        host=args.host,
+        open_browser=not args.no_browser,
+        reuse_server=args.reuse_server,
+    )
+
+
+if __name__ == "__main__":
+    main()

vendor/hyperview/core/__init__.py

@@ -0,0 +1,6 @@
+"""Core data structures for HyperView."""
+
+from hyperview.core.dataset import Dataset
+from hyperview.core.sample import Sample
+
+__all__ = ["Dataset", "Sample"]

vendor/hyperview/core/dataset.py

@@ -0,0 +1,870 @@
+"""Dataset class for managing collections of samples."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import threading
+import time
+import uuid
+from collections.abc import Callable, Iterator
+from pathlib import Path
+from typing import Any, cast
+
+import numpy as np
+from datasets import DownloadConfig, load_dataset
+from PIL import Image
+
+from hyperview.core.sample import Sample
+from hyperview.storage.backend import StorageBackend
+from hyperview.storage.schema import (
+    make_layout_key,
+    normalize_layout_dimension,
+    parse_layout_dimension,
+)
+
+
+DEFAULT_VISUALIZATION_LAYOUT = "euclidean"
+VALID_VISUALIZATION_GEOMETRIES = ("euclidean", "poincare", "spherical")
+
+
+def _format_elapsed(seconds: float) -> str:
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    total_seconds = int(round(seconds))
+    minutes, secs = divmod(total_seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m {secs:02d}s"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h {minutes:02d}m {secs:02d}s"
+
+
+def _format_eta(seconds: float) -> str:
+    if not math.isfinite(seconds) or seconds < 0:
+        return "unknown"
+    return _format_elapsed(seconds)
+
+
+def _fallback_huggingface_fingerprint(
+    dataset_name: str,
+    config_name: str,
+    split: str,
+    version: str | None,
+) -> str:
+    identity = f"{dataset_name}:{config_name}:{split}:{version or 'unknown'}"
+    return hashlib.md5(identity.encode()).hexdigest()
+
+
+def parse_visualization_layout(layout: str) -> tuple[str, int]:
+    """Parse a public visualization layout spec like ``euclidean:3d``.
+
+    Omitting the suffix defaults to 2D for Euclidean and Poincare layouts,
+    and to 3D for spherical layouts.
+    """
+    layout_spec = layout.strip().lower()
+    if not layout_spec:
+        raise ValueError("layout must be a non-empty string")
+
+    if ":" in layout_spec:
+        geometry, dimension_spec = layout_spec.rsplit(":", 1)
+    else:
+        geometry = layout_spec
+        dimension_spec = "3d" if geometry.strip() == "spherical" else "2d"
+
+    geometry = geometry.strip()
+    dimension_spec = dimension_spec.strip()
+
+    if geometry not in VALID_VISUALIZATION_GEOMETRIES:
+        raise ValueError(
+            "layout geometry must be one of "
+            f"{VALID_VISUALIZATION_GEOMETRIES}, got '{geometry}'"
+        )
+
+    if dimension_spec not in ("2d", "3d"):
+        raise ValueError(
+            "layout must use the form '<geometry>:2d' or '<geometry>:3d', "
+            f"got '{layout}'"
+        )
+
+    layout_dimension = normalize_layout_dimension(int(dimension_spec[0]))
+    if geometry == "poincare" and layout_dimension != 2:
+        raise ValueError("Poincare layouts currently require 2D output.")
+
+    return geometry, layout_dimension
+
+
+class Dataset:
+    """A collection of samples with support for embeddings and visualization.
+
+    Datasets are automatically persisted to LanceDB by default, providing:
+    - Automatic persistence (no need to call save())
+    - Vector similarity search
+    - Efficient storage and retrieval
+
+    Embeddings are stored separately from samples, keyed by model_id.
+    Layouts (2D/3D projections) are stored per layout_key (space + method).
+    """
+
+    def __init__(
+        self,
+        name: str | None = None,
+        persist: bool = True,
+        storage: StorageBackend | None = None,
+    ):
+        self.name = name or f"dataset_{uuid.uuid4().hex[:8]}"
+
+        if storage is not None:
+            self._storage = storage
+        elif persist:
+            from hyperview.storage import LanceDBBackend, StorageConfig
+
+            config = StorageConfig.default()
+            self._storage = LanceDBBackend(self.name, config)
+        else:
+            from hyperview.storage import MemoryBackend
+
+            self._storage = MemoryBackend(self.name)
+
+        self.last_requested_sample_ids: list[str] = []
+
+    def __len__(self) -> int:
+        return len(self._storage)
+
+    def __iter__(self) -> Iterator[Sample]:
+        return iter(self._storage)
+
+    def __getitem__(self, sample_id: str) -> Sample:
+        sample = self._storage.get_sample(sample_id)
+        if sample is None:
+            raise KeyError(sample_id)
+        return sample
+
+    def add_sample(self, sample: Sample) -> None:
+        """Add a sample to the dataset (idempotent)."""
+        self._storage.add_sample(sample)
+
+    def _ingest_samples(
+        self,
+        samples: list[Sample],
+        *,
+        skip_existing: bool = True,
+    ) -> tuple[int, int]:
+        """Shared ingestion helper for batch sample insertion."""
+        self.last_requested_sample_ids = [sample.id for sample in samples]
+
+        if not samples:
+            return 0, 0
+
+        skipped = 0
+        if skip_existing:
+            all_ids = [sample.id for sample in samples]
+            existing_ids = self._storage.get_existing_ids(all_ids)
+            if existing_ids:
+                samples = [sample for sample in samples if sample.id not in existing_ids]
+                skipped = len(all_ids) - len(samples)
+
+        if not samples:
+            return 0, skipped
+
+        self._storage.add_samples_batch(samples)
+
+        return len(samples), skipped
+
+    def add_image(
+        self,
+        filepath: str,
+        label: str | None = None,
+        metadata: dict[str, Any] | None = None,
+        sample_id: str | None = None,
+    ) -> Sample:
+        """Add a single image to the dataset."""
+        if sample_id is None:
+            sample_id = hashlib.md5(filepath.encode()).hexdigest()[:12]
+
+        sample = Sample(
+            id=sample_id,
+            filepath=filepath,
+            label=label,
+            metadata=metadata or {},
+        )
+        self.add_sample(sample)
+        return sample
+
+    def add_images_dir(
+        self,
+        directory: str,
+        extensions: tuple[str, ...] = (".jpg", ".jpeg", ".png", ".webp"),
+        label_from_folder: bool = False,
+        recursive: bool = True,
+        skip_existing: bool = True,
+    ) -> tuple[int, int]:
+        """Add all images from a directory."""
+        directory_path = Path(directory)
+        if not directory_path.exists():
+            raise ValueError(f"Directory does not exist: {directory_path}")
+
+        samples = []
+        pattern = "**/*" if recursive else "*"
+
+        for path in directory_path.glob(pattern):
+            if path.is_file() and path.suffix.lower() in extensions:
+                label = path.parent.name if label_from_folder else None
+                sample_id = hashlib.md5(str(path).encode()).hexdigest()[:12]
+                sample = Sample(
+                    id=sample_id,
+                    filepath=str(path),
+                    label=label,
+                    metadata={},
+                )
+                samples.append(sample)
+
+        return self._ingest_samples(samples, skip_existing=skip_existing)
+
+    def add_from_huggingface(
+        self,
+        dataset_name: str,
+        config: str | None = None,
+        split: str = "train",
+        image_key: str = "img",
+        label_key: str | None = "fine_label",
+        label_names_key: str | None = None,
+        max_samples: int | None = None,
+        shuffle: bool = False,
+        seed: int = 42,
+        streaming: bool = False,
+        shuffle_buffer_size: int = 1000,
+        show_progress: bool = True,
+        skip_existing: bool = True,
+        image_format: str = "auto",
+    ) -> tuple[int, int]:
+        """Load samples from a Hugging Face dataset."""
+        from hyperview.storage import StorageConfig
+
+        source_index_key = "__hyperview_source_index"
+
+        def attach_huggingface_source_index(
+            example: dict[str, Any],
+            index: int,
+        ) -> dict[str, Any]:
+            augmented = dict(example)
+            augmented[source_index_key] = index
+            return augmented
+
+        if shuffle_buffer_size < 1:
+            raise ValueError("shuffle_buffer_size must be >= 1")
+
+        if streaming:
+            ds = cast(
+                Any,
+                load_dataset(
+                    dataset_name,
+                    name=config,
+                    split=split,
+                    streaming=True,
+                ),
+            )
+        else:
+            try:
+                ds = cast(
+                    Any,
+                    load_dataset(
+                        dataset_name,
+                        name=config,
+                        split=split,
+                        download_config=DownloadConfig(local_files_only=True),
+                    ),
+                )
+            except Exception:
+                ds = cast(Any, load_dataset(dataset_name, name=config, split=split))
+
+        source_fingerprint = ds._fingerprint if hasattr(ds, "_fingerprint") else None
+
+        label_names = None
+        if label_key and label_names_key:
+            if label_names_key in ds.features:
+                label_names = ds.features[label_names_key].names
+        elif label_key:
+            if hasattr(ds.features[label_key], "names"):
+                label_names = ds.features[label_key].names
+
+        config_name = getattr(ds.info, "config_name", None) or "default"
+        version = str(ds.info.version) if ds.info.version else None
+        fingerprint_source = source_fingerprint or _fallback_huggingface_fingerprint(
+            dataset_name,
+            config_name,
+            split,
+            version,
+        )
+        fingerprint = fingerprint_source[:8]
+
+        total: int | None
+        selected_indices: list[int] | None = None
+        iterator: Iterator[Any]
+        if streaming:
+            stream = ds
+            if hasattr(stream, "select_columns"):
+                columns = [image_key]
+                if label_key:
+                    columns.append(label_key)
+                stream = stream.select_columns(list(dict.fromkeys(columns)))
+            stream = stream.map(attach_huggingface_source_index, with_indices=True)
+            if shuffle:
+                if hasattr(stream, "reshard"):
+                    stream = stream.reshard()
+                stream = stream.shuffle(seed=seed, buffer_size=shuffle_buffer_size)
+            if max_samples is not None:
+                total = max_samples
+                iterator = iter(stream.take(max_samples))
+            else:
+                total = None
+                iterator = iter(stream)
+        else:
+            dataset_size = len(ds)
+            total = dataset_size if max_samples is None else min(dataset_size, max_samples)
+
+            if shuffle:
+                rng = np.random.default_rng(seed)
+                selected_indices = rng.permutation(dataset_size)[:total].tolist()
+                ds = ds.select(selected_indices)
+            elif max_samples is not None:
+                selected_indices = list(range(total))
+                ds = ds.select(selected_indices)
+
+            iterator = (ds[i] for i in range(total))
+
+        storage_config = StorageConfig.default()
+        media_dir = storage_config.get_huggingface_media_dir(dataset_name, split)
+
+        samples: list[Sample] = []
+
+        if show_progress:
+            if total is None:
+                print(f"Loading samples from {dataset_name} via streaming...", flush=True)
+            else:
+                mode_suffix = " via streaming" if streaming else ""
+                print(
+                    f"Loading {total} samples from {dataset_name}{mode_suffix}...",
+                    flush=True,
+                )
+
+        started_at = time.perf_counter()
+        last_report_at = started_at
+        report_every = 50 if total is None else max(25, min(200, total // 20 or 25))
+        loaded = 0
+        progress_stop = threading.Event()
+
+        def emit_progress(now: float, *, waiting_for_first_sample: bool = False) -> None:
+            elapsed = max(now - started_at, 1e-9)
+            if waiting_for_first_sample:
+                if total is None:
+                    print(
+                        "Still waiting for the first streamed sample "
+                        f"(elapsed {_format_elapsed(elapsed)})",
+                        flush=True,
+                    )
+                else:
+                    print(
+                        "Still waiting for the first streamed sample "
+                        f"(0/{total}, elapsed {_format_elapsed(elapsed)})",
+                        flush=True,
+                    )
+                return
+
+            rate = loaded / elapsed
+            if total is None:
+                print(
+                    f"Loaded {loaded} samples "
+                    f"({rate:.1f}/s, elapsed {_format_elapsed(elapsed)})",
+                    flush=True,
+                )
+                return
+
+            remaining = total - loaded
+            eta_seconds = remaining / rate if rate > 0 else float("inf")
+            print(
+                f"Loaded {loaded}/{total} samples "
+                f"({loaded / total:.0%}, {rate:.1f}/s, "
+                f"elapsed {_format_elapsed(elapsed)}, ETA {_format_eta(eta_seconds)})",
+                flush=True,
+            )
+
+        heartbeat: threading.Thread | None = None
+        if show_progress and streaming:
+            def heartbeat_reporter() -> None:
+                while not progress_stop.wait(10.0):
+                    now = time.perf_counter()
+                    if loaded == 0:
+                        emit_progress(now, waiting_for_first_sample=True)
+                    elif now - last_report_at >= 10.0:
+                        emit_progress(now)
+
+            heartbeat = threading.Thread(
+                target=heartbeat_reporter,
+                name="hyperview-hf-progress",
+                daemon=True,
+            )
+            heartbeat.start()
+
+        try:
+            for i, item in enumerate(iterator):
+                if streaming:
+                    source_index = int(item.pop(source_index_key, i))
+                else:
+                    source_index = selected_indices[i] if selected_indices is not None else i
+                image = item[image_key]
+
+                if isinstance(image, Image.Image):
+                    pil_image = image
+                else:
+                    pil_image = Image.fromarray(np.asarray(image))
+
+                label = None
+                if label_key and label_key in item:
+                    label_idx = item[label_key]
+                    if label_names and isinstance(label_idx, int):
+                        label = label_names[label_idx]
+                    else:
+                        label = str(label_idx)
+
+                safe_name = dataset_name.replace("/", "_")
+                sample_id = f"{safe_name}_{config_name}_{fingerprint}_{split}_{source_index}"
+
+                if image_format == "auto":
+                    original_format = getattr(pil_image, "format", None)
+                    if original_format in ("JPEG", "JPG"):
+                        save_format = "JPEG"
+                        ext = ".jpg"
+                    else:
+                        save_format = "PNG"
+                        ext = ".png"
+                elif image_format == "jpeg":
+                    save_format = "JPEG"
+                    ext = ".jpg"
+                else:
+                    save_format = "PNG"
+                    ext = ".png"
+
+                metadata = {
+                    "source": dataset_name,
+                    "config": config_name,
+                    "split": split,
+                    "index": source_index,
+                    "fingerprint": source_fingerprint,
+                    "version": version,
+                }
+
+                image_path = media_dir / f"{sample_id}{ext}"
+                if not image_path.exists():
+                    if save_format == "JPEG" or pil_image.mode in ("RGBA", "P", "L"):
+                        pil_image = pil_image.convert("RGB")
+                    pil_image.save(image_path, format=save_format)
+
+                sample = Sample(
+                    id=sample_id,
+                    filepath=str(image_path),
+                    label=label,
+                    metadata=metadata,
+                )
+
+                samples.append(sample)
+                loaded += 1
+
+                if not show_progress:
+                    continue
+
+                now = time.perf_counter()
+                should_report = loaded == 1
+                if total is not None and loaded == total:
+                    should_report = True
+                if loaded % report_every == 0:
+                    should_report = True
+                if now - last_report_at >= 5.0:
+                    should_report = True
+                if not should_report:
+                    continue
+
+                emit_progress(now)
+                last_report_at = now
+        finally:
+            progress_stop.set()
+            if heartbeat is not None:
+                heartbeat.join(timeout=0.1)
+
+        if total is None:
+            total = loaded
+
+        num_added, skipped = self._ingest_samples(samples, skip_existing=skip_existing)
+
+        if show_progress:
+            print(
+                f"Prepared {loaded} samples in {_format_elapsed(time.perf_counter() - started_at)}",
+                flush=True,
+            )
+            print(f"Images saved to: {media_dir}", flush=True)
+            if skipped > 0:
+                print(f"Skipped {skipped} existing samples", flush=True)
+
+        return num_added, skipped
+
+    def compute_embeddings(
+        self,
+        model: str,
+        *,
+        provider: str | None = None,
+        checkpoint: str | None = None,
+        batch_size: int = 32,
+        sample_ids: list[str] | None = None,
+        show_progress: bool = True,
+        **provider_kwargs: Any,
+    ) -> str:
+        """Compute embeddings for samples that don't have them yet.
+
+        Embeddings are stored in a dedicated space keyed by the embedding spec.
+
+        Args:
+            model: Model identifier (required). Use a HuggingFace model_id
+                (e.g. 'openai/clip-vit-base-patch32') for embed-anything, or a
+                hyper-models name (e.g. 'hycoclip-vit-s') for hyperbolic embeddings.
+            provider: Explicit provider identifier. If not specified, auto-detected:
+                'hyper-models' if model matches a hyper-models name, else 'embed-anything'.
+                Available providers: `hyperview.embeddings.list_embedding_providers()`.
+            checkpoint: Checkpoint path/URL (hf://... or local path) for weight-only models.
+            batch_size: Batch size for processing.
+            sample_ids: Optional subset of sample IDs to ensure embeddings for.
+                If omitted, computes embeddings for all samples missing them.
+            show_progress: Whether to show progress bar.
+            **provider_kwargs: Additional kwargs passed to the embedding function.
+
+        Returns:
+            space_key for the embedding space.
+
+        Raises:
+            ValueError: If model is not provided.
+        """
+        if not model:
+            raise ValueError(
+                "model is required. Examples: 'openai/clip-vit-base-patch32' (CLIP), "
+                "'hycoclip-vit-s' (hyperbolic). See hyperview.embeddings.list_embedding_providers()."
+            )
+
+        from hyperview.embeddings.engine import EmbeddingSpec
+        from hyperview.embeddings.pipelines import compute_embeddings
+
+        if provider is None:
+            provider = "embed-anything"
+            try:
+                import hyper_models
+                if model in hyper_models.list_models():
+                    provider = "hyper-models"
+            except ImportError:
+                pass
+        spec = EmbeddingSpec(
+            provider=provider,
+            model_id=model,
+            checkpoint=checkpoint,
+            provider_kwargs=provider_kwargs,
+        )
+
+        space_key, _num_computed, _num_skipped = compute_embeddings(
+            storage=self._storage,
+            spec=spec,
+            batch_size=batch_size,
+            sample_ids=sample_ids,
+            show_progress=show_progress,
+        )
+        return space_key
+
+    def compute_visualization(
+        self,
+        space_key: str | None = None,
+        method: str = "umap",
+        layout: str = DEFAULT_VISUALIZATION_LAYOUT,
+        n_neighbors: int = 15,
+        min_dist: float = 0.1,
+        metric: str = "cosine",
+        force: bool = False,
+    ) -> str:
+        """Compute projections for visualization.
+
+        Args:
+            space_key: Embedding space to project. If None, uses the first available.
+            method: Projection method ('umap' supported).
+            layout: Layout spec like 'euclidean', 'euclidean:3d', or 'spherical'.
+                Omitting the suffix defaults to 2D for Euclidean/Poincare and 3D for spherical.
+            n_neighbors: Number of neighbors for UMAP.
+            min_dist: Minimum distance for UMAP.
+            metric: Distance metric for UMAP.
+            force: Force recomputation even if layout exists.
+
+        Returns:
+            layout_key for the computed layout.
+        """
+        from hyperview.embeddings.pipelines import compute_layout
+
+        geometry, layout_dimension = parse_visualization_layout(layout)
+
+        return compute_layout(
+            storage=self._storage,
+            space_key=space_key,
+            method=method,
+            geometry=geometry,
+            layout_dimension=layout_dimension,
+            n_neighbors=n_neighbors,
+            min_dist=min_dist,
+            metric=metric,
+            force=force,
+            show_progress=True,
+        )
+
+    def list_spaces(self) -> list[Any]:
+        """List all embedding spaces in this dataset."""
+        return self._storage.list_spaces()
+
+    def list_layouts(self) -> list[Any]:
+        """List all layouts in this dataset (returns LayoutInfo objects)."""
+        return self._storage.list_layouts()
+
+    def find_similar(
+        self,
+        sample_id: str,
+        k: int = 10,
+        space_key: str | None = None,
+    ) -> list[tuple[Sample, float]]:
+        """Find k most similar samples to a given sample.
+
+        Args:
+            sample_id: ID of the query sample.
+            k: Number of neighbors to return.
+            space_key: Embedding space to search in. If None, uses first available.
+
+        Returns:
+            List of (sample, distance) tuples, sorted by distance ascending.
+        """
+        return self._storage.find_similar(sample_id, k, space_key)
+
+    def find_similar_by_vector(
+        self,
+        vector: list[float],
+        k: int = 10,
+        space_key: str | None = None,
+    ) -> list[tuple[Sample, float]]:
+        """Find k most similar samples to a given vector.
+
+        Args:
+            vector: Query vector.
+            k: Number of neighbors to return.
+            space_key: Embedding space to search in. If None, uses first available.
+
+        Returns:
+            List of (sample, distance) tuples, sorted by distance ascending.
+        """
+        return self._storage.find_similar_by_vector(vector, k, space_key)
+
+    def set_coords(
+        self,
+        geometry: str,
+        ids: list[str],
+        coords: np.ndarray | list[list[float]],
+    ) -> str:
+        """Set precomputed coordinates for visualization.
+
+        Use this when you have precomputed projections and want to skip
+        embedding computation. Useful for smoke tests or external projections.
+
+        Args:
+            geometry: "euclidean", "poincare", or "spherical".
+            ids: List of sample IDs.
+            coords: (N, D) array of coordinates.
+
+        Returns:
+            The layout_key for the stored coordinates.
+
+        Example:
+            >>> dataset.set_coords("euclidean", ["s0", "s1"], [[0.1, 0.2], [0.3, 0.4]])
+            >>> dataset.set_coords("spherical", ["s0", "s1"], [[0.1, 0.2, 0.3], [0.3, 0.4, 0.5]])
+            >>> hv.launch(dataset)
+        """
+        if geometry not in ("euclidean", "poincare", "spherical"):
+            raise ValueError(
+                f"geometry must be 'euclidean', 'poincare', or 'spherical', got '{geometry}'"
+            )
+
+        coords_arr = np.asarray(coords, dtype=np.float32)
+        if coords_arr.ndim != 2 or coords_arr.shape[1] < 2:
+            raise ValueError(f"coords must be (N, D) with D>=2, got shape {coords_arr.shape}")
+
+        layout_dimension = normalize_layout_dimension(int(coords_arr.shape[1]))
+        if geometry == "poincare" and layout_dimension != 2:
+            raise ValueError("poincare precomputed layouts must be 2D")
+
+        # Ensure a synthetic space exists (required by launch())
+        space_key = f"precomputed_{layout_dimension}d"
+        if not any(s.space_key == space_key for s in self._storage.list_spaces()):
+            precomputed_config = {
+                "provider": "precomputed",
+                "geometry": "unknown",  # Precomputed coords don't have a source embedding geometry
+            }
+            self._storage.ensure_space(space_key, dim=layout_dimension, config=precomputed_config)
+
+        layout_key = make_layout_key(
+            space_key,
+            method="precomputed",
+            geometry=geometry,
+            layout_dimension=layout_dimension,
+        )
+
+        # Ensure layout registry entry exists
+        self._storage.ensure_layout(
+            layout_key=layout_key,
+            space_key=space_key,
+            method="precomputed",
+            geometry=geometry,
+            params=None,
+        )
+
+        self._storage.add_layout_coords(layout_key, list(ids), coords_arr)
+        return layout_key
+
+    @property
+    def samples(self) -> list[Sample]:
+        """Get all samples as a list."""
+        return self._storage.get_all_samples()
+
+    @property
+    def labels(self) -> list[str]:
+        """Get unique labels in the dataset."""
+        return self._storage.get_unique_labels()
+
+    def filter(self, predicate: Callable[[Sample], bool]) -> list[Sample]:
+        """Filter samples based on a predicate function."""
+        return self._storage.filter(predicate)
+
+    def get_samples_paginated(
+        self,
+        offset: int = 0,
+        limit: int = 100,
+        label: str | None = None,
+    ) -> tuple[list[Sample], int]:
+        """Get paginated samples.
+
+        This avoids loading all samples into memory and is used by the server
+        API for efficient pagination.
+        """
+        return self._storage.get_samples_paginated(offset=offset, limit=limit, label=label)
+
+    def get_samples_by_ids(self, sample_ids: list[str]) -> list[Sample]:
+        """Retrieve multiple samples by ID.
+
+        The returned list is aligned to the input order and skips missing IDs.
+        """
+        return self._storage.get_samples_by_ids(sample_ids)
+
+    def get_visualization_data(
+        self,
+        layout_key: str,
+    ) -> tuple[list[str], list[str | None], np.ndarray]:
+        """Get visualization data (ids, labels, coords) for a layout."""
+        layout_dimension = parse_layout_dimension(layout_key)
+
+        layout_ids, layout_coords = self._storage.get_layout_coords(layout_key)
+        if not layout_ids:
+            return [], [], np.empty((0, layout_dimension), dtype=np.float32)
+
+        labels_by_id = self._storage.get_labels_by_ids(layout_ids)
+
+        ids: list[str] = []
+        labels: list[str | None] = []
+        coords: list[np.ndarray] = []
+
+        for i, sample_id in enumerate(layout_ids):
+            if sample_id in labels_by_id:
+                ids.append(sample_id)
+                labels.append(labels_by_id[sample_id])
+                coords.append(layout_coords[i])
+
+        if not coords:
+            return [], [], np.empty((0, layout_dimension), dtype=np.float32)
+
+        return ids, labels, np.asarray(coords, dtype=np.float32)
+
+
+    def get_lasso_candidates_aabb(
+        self,
+        *,
+        layout_key: str,
+        x_min: float,
+        x_max: float,
+        y_min: float,
+        y_max: float,
+        label_filter: str | None = None,
+    ) -> tuple[list[str], np.ndarray]:
+        """Return candidate (id, xy) rows within an AABB for a layout."""
+        return self._storage.get_lasso_candidates_aabb(
+            layout_key=layout_key,
+            x_min=x_min,
+            x_max=x_max,
+            y_min=y_min,
+            y_max=y_max,
+            label_filter=label_filter,
+        )
+
+    def save(self, filepath: str, include_thumbnails: bool = True) -> None:
+        """Export dataset to a JSON file.
+
+        Args:
+            filepath: Path to save the JSON file.
+            include_thumbnails: Whether to include cached thumbnails.
+        """
+        samples = self._storage.get_all_samples()
+        if include_thumbnails:
+            for s in samples:
+                s.cache_thumbnail()
+
+        data = {
+            "name": self.name,
+            "samples": [
+                {
+                    "id": s.id,
+                    "filepath": s.filepath,
+                    "label": s.label,
+                    "metadata": s.metadata,
+                    "thumbnail_base64": s.thumbnail_base64 if include_thumbnails else None,
+                }
+                for s in samples
+            ],
+        }
+        with open(filepath, "w") as f:
+            json.dump(data, f)
+
+    @classmethod
+    def load(cls, filepath: str, persist: bool = False) -> Dataset:
+        """Load dataset from a JSON file.
+
+        Args:
+            filepath: Path to the JSON file.
+            persist: If True, persist the loaded data to LanceDB.
+                    If False (default), keep in memory only.
+
+        Returns:
+            Dataset instance.
+        """
+        with open(filepath) as f:
+            data = json.load(f)
+
+        dataset = cls(name=data["name"], persist=persist)
+
+        # Add samples
+        samples = []
+        for s_data in data["samples"]:
+            sample = Sample(
+                id=s_data["id"],
+                filepath=s_data["filepath"],
+                label=s_data.get("label"),
+                metadata=s_data.get("metadata", {}),
+                thumbnail_base64=s_data.get("thumbnail_base64"),
+            )
+            samples.append(sample)
+
+        dataset._storage.add_samples_batch(samples)
+        return dataset

vendor/hyperview/core/sample.py

@@ -0,0 +1,95 @@
+"""Sample class representing a single data point in a dataset."""
+
+import base64
+import io
+from pathlib import Path
+from typing import Any
+
+from PIL import Image
+from pydantic import BaseModel, Field
+
+
+class Sample(BaseModel):
+    """A single sample in a HyperView dataset.
+
+    Samples are pure metadata containers. Embeddings and layouts are stored
+    separately in dedicated tables (per embedding space / per layout).
+    """
+
+    id: str = Field(..., description="Unique identifier for the sample")
+    filepath: str = Field(..., description="Path to the image file")
+    label: str | None = Field(default=None, description="Label for the sample")
+    metadata: dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+    thumbnail_base64: str | None = Field(default=None, description="Cached thumbnail as base64")
+    width: int | None = Field(default=None, description="Image width in pixels")
+    height: int | None = Field(default=None, description="Image height in pixels")
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    @property
+    def filename(self) -> str:
+        """Get the filename from the filepath."""
+        return Path(self.filepath).name
+
+    def load_image(self) -> Image.Image:
+        """Load the image from disk."""
+        return Image.open(self.filepath)
+
+    def get_thumbnail(self, size: tuple[int, int] = (128, 128)) -> Image.Image:
+        """Get a thumbnail of the image. Also captures original dimensions."""
+        img = self.load_image()
+        # Capture original dimensions while we have the image loaded
+        if self.width is None or self.height is None:
+            self.width, self.height = img.size
+        img.thumbnail(size, Image.Resampling.LANCZOS)
+        return img
+
+    def _encode_thumbnail(self, size: tuple[int, int] = (128, 128)) -> str:
+        """Encode thumbnail as base64 JPEG."""
+        thumb = self.get_thumbnail(size)
+        if thumb.mode in ("RGBA", "P"):
+            thumb = thumb.convert("RGB")
+        buffer = io.BytesIO()
+        thumb.save(buffer, format="JPEG", quality=85)
+        return base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+    def get_thumbnail_base64(self, size: tuple[int, int] = (128, 128)) -> str:
+        """Get thumbnail as base64 encoded string."""
+        return self.thumbnail_base64 or self._encode_thumbnail(size)
+
+    def cache_thumbnail(self, size: tuple[int, int] = (128, 128)) -> None:
+        """Cache the thumbnail as base64 for persistence."""
+        if self.thumbnail_base64 is None:
+            self.thumbnail_base64 = self._encode_thumbnail(size)
+
+    def to_api_dict(self, include_thumbnail: bool = True) -> dict[str, Any]:
+        """Convert to dictionary for API response."""
+        # Ensure dimensions are populated (loads image if needed but not cached)
+        if self.width is None or self.height is None:
+            self.ensure_dimensions()
+
+        data = {
+            "id": self.id,
+            "filepath": self.filepath,
+            "filename": self.filename,
+            "label": self.label,
+            "metadata": self.metadata,
+            "width": self.width,
+            "height": self.height,
+        }
+        if include_thumbnail:
+            data["thumbnail"] = self.get_thumbnail_base64()
+        return data
+
+    def ensure_dimensions(self) -> None:
+        """Load image dimensions if not already set."""
+        if self.width is None or self.height is None:
+            try:
+                img = self.load_image()
+                self.width, self.height = img.size
+            except Exception:
+                # If image can't be loaded, leave as None
+                pass
+
+
+

vendor/hyperview/core/selection.py

@@ -0,0 +1,309 @@
+"""Selection / geometry helpers.
+
+This module contains small, backend-agnostic utilities used by selection
+endpoints for both 2D and 3D lasso selection.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+from pydantic import BaseModel
+
+
+def points_in_polygon(points_xy: np.ndarray, polygon_xy: np.ndarray) -> np.ndarray:
+    """Vectorized point-in-polygon (even-odd rule / ray casting).
+
+    Args:
+        points_xy: Array of shape (m, 2) with point coordinates.
+        polygon_xy: Array of shape (n, 2) with polygon vertices.
+
+    Returns:
+        Boolean mask of length m, True where point lies inside polygon.
+
+    Notes:
+        Boundary points may be classified as outside depending on floating point
+        ties (common for lasso selection tools).
+    """
+    if polygon_xy.shape[0] < 3:
+        return np.zeros((points_xy.shape[0],), dtype=bool)
+
+    x = points_xy[:, 0]
+    y = points_xy[:, 1]
+    poly_x = polygon_xy[:, 0]
+    poly_y = polygon_xy[:, 1]
+
+    inside = np.zeros((points_xy.shape[0],), dtype=bool)
+    j = polygon_xy.shape[0] - 1
+
+    for i in range(polygon_xy.shape[0]):
+        xi = poly_x[i]
+        yi = poly_y[i]
+        xj = poly_x[j]
+        yj = poly_y[j]
+
+        # Half-open y-interval to avoid double-counting vertices.
+        intersects = (yi > y) != (yj > y)
+
+        denom = yj - yi
+        # denom == 0 => intersects is always False; add tiny epsilon to avoid warnings.
+        x_intersect = (xj - xi) * (y - yi) / (denom + 1e-30) + xi
+
+        inside ^= intersects & (x < x_intersect)
+        j = i
+
+    return inside
+
+
+class OrbitViewState3D(BaseModel):
+    """Orbit camera state for server-side 3D lasso projection."""
+
+    yaw: float
+    pitch: float
+    distance: float
+    target_x: float
+    target_y: float
+    target_z: float
+    ortho_scale: float
+
+
+def _normalize_vec(v: np.ndarray) -> np.ndarray:
+    norm = float(np.linalg.norm(v))
+    if norm < 1e-9:
+        return np.zeros_like(v, dtype=np.float32)
+    return (v / norm).astype(np.float32)
+
+
+def _mat4_look_at(eye: np.ndarray, target: np.ndarray, up: np.ndarray) -> np.ndarray:
+    """Column-major lookAt matrix matching hyper-scatter 3D renderer math."""
+    z_axis = _normalize_vec(eye - target)
+    if float(np.linalg.norm(z_axis)) < 1e-9:
+        z_axis = np.array([0.0, 0.0, 1.0], dtype=np.float32)
+
+    x_axis = _normalize_vec(np.cross(up, z_axis))
+    if float(np.linalg.norm(x_axis)) < 1e-9:
+        x_axis = np.array([1.0, 0.0, 0.0], dtype=np.float32)
+
+    y_axis = np.cross(z_axis, x_axis).astype(np.float32)
+
+    out = np.zeros(16, dtype=np.float32)
+    out[0] = x_axis[0]
+    out[1] = y_axis[0]
+    out[2] = z_axis[0]
+    out[3] = 0.0
+
+    out[4] = x_axis[1]
+    out[5] = y_axis[1]
+    out[6] = z_axis[1]
+    out[7] = 0.0
+
+    out[8] = x_axis[2]
+    out[9] = y_axis[2]
+    out[10] = z_axis[2]
+    out[11] = 0.0
+
+    out[12] = -float(np.dot(x_axis, eye))
+    out[13] = -float(np.dot(y_axis, eye))
+    out[14] = -float(np.dot(z_axis, eye))
+    out[15] = 1.0
+    return out
+
+
+def _mat4_ortho(
+    left: float,
+    right: float,
+    bottom: float,
+    top: float,
+    near: float,
+    far: float,
+) -> np.ndarray:
+    """Column-major orthographic matrix matching hyper-scatter 3D renderer math."""
+    rl = right - left
+    tb = top - bottom
+    fn = far - near
+
+    if abs(rl) < 1e-12 or abs(tb) < 1e-12 or abs(fn) < 1e-12:
+        raise ValueError("Invalid orthographic projection bounds")
+
+    out = np.zeros(16, dtype=np.float32)
+    out[0] = 2.0 / rl
+    out[5] = 2.0 / tb
+    out[10] = -2.0 / fn
+    out[12] = -(right + left) / rl
+    out[13] = -(top + bottom) / tb
+    out[14] = -(far + near) / fn
+    out[15] = 1.0
+    return out
+
+
+def _mat4_multiply(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """Column-major matrix multiply matching hyper-scatter mat4Multiply."""
+    out = np.zeros(16, dtype=np.float32)
+    for col in range(4):
+        for row in range(4):
+            out[col * 4 + row] = (
+                a[0 * 4 + row] * b[col * 4 + 0]
+                + a[1 * 4 + row] * b[col * 4 + 1]
+                + a[2 * 4 + row] * b[col * 4 + 2]
+                + a[3 * 4 + row] * b[col * 4 + 3]
+            )
+    return out
+
+
+def _build_mvp_for_orbit(
+    view: OrbitViewState3D,
+    coords: np.ndarray,
+    viewport_width: int,
+    viewport_height: int,
+) -> np.ndarray:
+    cp = math.cos(view.pitch)
+    sp = math.sin(view.pitch)
+    cy = math.cos(view.yaw)
+    sy = math.sin(view.yaw)
+
+    dir_target_to_eye = np.array([cp * sy, sp, cp * cy], dtype=np.float32)
+    target = np.array([view.target_x, view.target_y, view.target_z], dtype=np.float32)
+    eye = target + dir_target_to_eye * float(view.distance)
+
+    world_up = np.array([0.0, 1.0, 0.0], dtype=np.float32)
+    view_matrix = _mat4_look_at(eye, target, world_up)
+
+    aspect = float(viewport_width) / float(max(1, viewport_height))
+    half_h = max(0.01, float(view.ortho_scale))
+    half_w = half_h * aspect
+
+    center = np.mean(coords, axis=0)
+    scene_radius = float(np.max(np.linalg.norm(coords - center, axis=1)))
+    scene_radius = max(scene_radius, 0.25)
+
+    near = 0.01
+    far = max(near + 1.0, float(view.distance) + scene_radius * 6.0 + 10.0)
+
+    proj_matrix = _mat4_ortho(-half_w, half_w, -half_h, half_h, near, far)
+    return _mat4_multiply(proj_matrix, view_matrix)
+
+
+def _project_points_3d_to_screen(
+    mvp: np.ndarray,
+    coords: np.ndarray,
+    width: int,
+    height: int,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    x = coords[:, 0]
+    y = coords[:, 1]
+    z = coords[:, 2]
+
+    clip_x = mvp[0] * x + mvp[4] * y + mvp[8] * z + mvp[12]
+    clip_y = mvp[1] * x + mvp[5] * y + mvp[9] * z + mvp[13]
+    clip_z = mvp[2] * x + mvp[6] * y + mvp[10] * z + mvp[14]
+    clip_w = mvp[3] * x + mvp[7] * y + mvp[11] * z + mvp[15]
+
+    inv_w = np.zeros_like(clip_w)
+    np.divide(1.0, clip_w, out=inv_w, where=np.abs(clip_w) > 1e-12)
+    ndc_x = clip_x * inv_w
+    ndc_y = clip_y * inv_w
+    ndc_z = clip_z * inv_w
+
+    finite = np.isfinite(ndc_x) & np.isfinite(ndc_y) & np.isfinite(ndc_z)
+    in_clip = (
+        finite
+        & (ndc_x >= -1.0)
+        & (ndc_x <= 1.0)
+        & (ndc_y >= -1.0)
+        & (ndc_y <= 1.0)
+        & (ndc_z >= -1.0)
+        & (ndc_z <= 1.0)
+    )
+
+    screen_x = (ndc_x * 0.5 + 0.5) * float(width)
+    screen_y = (1.0 - (ndc_y * 0.5 + 0.5)) * float(height)
+    depth = ndc_z * 0.5 + 0.5
+
+    pixel_x = np.floor(screen_x).astype(np.int64)
+    pixel_y = np.floor(screen_y).astype(np.int64)
+    pixel_ok = (
+        in_clip
+        & (pixel_x >= 0)
+        & (pixel_x < width)
+        & (pixel_y >= 0)
+        & (pixel_y < height)
+    )
+
+    pixel_index = np.full(coords.shape[0], -1, dtype=np.int64)
+    pixel_index[pixel_ok] = pixel_y[pixel_ok] * width + pixel_x[pixel_ok]
+
+    return screen_x, screen_y, depth, pixel_index
+
+
+def select_ids_for_3d_lasso(
+    *,
+    ids: list[str],
+    labels: list[str | None],
+    coords: np.ndarray,
+    geometry: str,
+    polygon: np.ndarray,
+    view: OrbitViewState3D,
+    viewport_width: int,
+    viewport_height: int,
+    label_filter: str | None,
+) -> list[str]:
+    width = max(1, int(viewport_width))
+    height = max(1, int(viewport_height))
+
+    if label_filter is not None:
+        label_mask = np.fromiter(
+            (label == label_filter for label in labels),
+            dtype=bool,
+            count=len(labels),
+        )
+        if not np.any(label_mask):
+            return []
+        kept_indices = np.flatnonzero(label_mask)
+        ids = [ids[int(i)] for i in kept_indices]
+        coords = coords[label_mask]
+
+    if geometry == "spherical":
+        norms = np.linalg.norm(coords, axis=1, keepdims=True)
+        coords = coords / np.maximum(norms, 1e-8)
+
+    mvp = _build_mvp_for_orbit(view, coords, width, height)
+    screen_x, screen_y, depth, pixel_index = _project_points_3d_to_screen(
+        mvp, coords, width, height
+    )
+
+    pixel_count = max(1, width * height)
+    depth_buffer = np.full(pixel_count, np.inf, dtype=np.float32)
+
+    valid_mask = pixel_index >= 0
+    valid_pixels = pixel_index[valid_mask]
+    valid_depth = depth[valid_mask]
+    np.minimum.at(depth_buffer, valid_pixels, valid_depth)
+
+    visible_mask = np.zeros(coords.shape[0], dtype=bool)
+    visible_mask[valid_mask] = depth[valid_mask] <= depth_buffer[valid_pixels] + 1e-4
+
+    x_min = float(np.min(polygon[:, 0]))
+    x_max = float(np.max(polygon[:, 0]))
+    y_min = float(np.min(polygon[:, 1]))
+    y_max = float(np.max(polygon[:, 1]))
+
+    candidate_mask = (
+        visible_mask
+        & (screen_x >= x_min)
+        & (screen_x <= x_max)
+        & (screen_y >= y_min)
+        & (screen_y <= y_max)
+    )
+
+    candidate_indices = np.flatnonzero(candidate_mask)
+    if candidate_indices.size == 0:
+        return []
+
+    candidate_points = np.column_stack(
+        (screen_x[candidate_indices], screen_y[candidate_indices])
+    ).astype(np.float32)
+    inside = points_in_polygon(candidate_points, polygon)
+    selected_indices = candidate_indices[np.flatnonzero(inside)]
+
+    return [ids[int(i)] for i in selected_indices]

vendor/hyperview/embeddings/__init__.py

@@ -0,0 +1,31 @@
+"""Embedding computation and projection."""
+
+from hyperview.embeddings.compute import EmbeddingComputer
+from hyperview.embeddings.engine import (
+    EmbeddingSpec,
+    get_engine,
+    get_provider_info,
+    list_embedding_providers,
+)
+
+# Register HyperView providers into LanceDB registry.
+import hyperview.embeddings.providers.lancedb_providers as _lancedb_providers  # noqa: F401
+
+
+def __getattr__(name: str):
+    """Lazy import for heavy dependencies (UMAP/numba)."""
+    if name == "ProjectionEngine":
+        from hyperview.embeddings.projection import ProjectionEngine
+        return ProjectionEngine
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "EmbeddingComputer",
+    "EmbeddingSpec",
+    "ProjectionEngine",
+    # Provider utilities
+    "get_engine",
+    "get_provider_info",
+    "list_embedding_providers",
+]

vendor/hyperview/embeddings/compute.py

@@ -0,0 +1,89 @@
+"""Image embedding computation via EmbedAnything."""
+
+import os
+import tempfile
+from pathlib import Path
+
+import numpy as np
+from embed_anything import EmbeddingModel
+from PIL import Image
+
+from hyperview.core.sample import Sample
+
+
+class EmbeddingComputer:
+    """Compute embeddings for image samples using EmbedAnything."""
+
+    def __init__(self, model: str):
+        """Initialize the embedding computer.
+
+        Args:
+            model: HuggingFace model ID to load via EmbedAnything.
+        """
+        if not model or not model.strip():
+            raise ValueError("model must be a non-empty HuggingFace model_id")
+
+        self.model_id = model
+        self._model: EmbeddingModel | None = None
+
+    def _get_model(self) -> EmbeddingModel:
+        """Lazily initialize the EmbedAnything model."""
+        if self._model is None:
+            self._model = EmbeddingModel.from_pretrained_hf(model_id=self.model_id)
+        return self._model
+
+    def _load_rgb_image(self, sample: Sample) -> Image.Image:
+        """Load an image and normalize it to RGB.
+
+        For file-backed samples, returns an in-memory copy and closes the file
+        handle immediately to avoid leaking descriptors during batch processing.
+        """
+        with sample.load_image() as img:
+            img.load()
+            if img.mode != "RGB":
+                return img.convert("RGB")
+            return img.copy()
+
+    def _embed_file(self, file_path: str) -> np.ndarray:
+        model = self._get_model()
+        result = model.embed_file(file_path)
+
+        if not result:
+            raise RuntimeError(f"EmbedAnything returned no embeddings for: {file_path}")
+        if len(result) != 1:
+            raise RuntimeError(
+                f"Expected 1 embedding for an image file, got {len(result)}: {file_path}"
+            )
+
+        return np.asarray(result[0].embedding, dtype=np.float32)
+
+    def _embed_pil_image(self, image: Image.Image) -> np.ndarray:
+        temp_fd, temp_path = tempfile.mkstemp(suffix=".png")
+        os.close(temp_fd)
+        try:
+            image.save(temp_path, format="PNG")
+            return self._embed_file(temp_path)
+        finally:
+            Path(temp_path).unlink(missing_ok=True)
+
+    def compute_single(self, sample: Sample) -> np.ndarray:
+        """Compute embedding for a single sample."""
+        image = self._load_rgb_image(sample)
+        return self._embed_pil_image(image)
+
+    def compute_batch(
+        self,
+        samples: list[Sample],
+        batch_size: int = 32,
+        show_progress: bool = True,
+    ) -> list[np.ndarray]:
+        """Compute embeddings for a list of samples."""
+        if batch_size <= 0:
+            raise ValueError("batch_size must be > 0")
+        self._get_model()
+
+        if show_progress:
+            print(f"Computing embeddings for {len(samples)} samples...")
+
+        return [self.compute_single(sample) for sample in samples]
+

vendor/hyperview/embeddings/engine.py

@@ -0,0 +1,391 @@
+"""Embedding spec + engine built on LanceDB's embedding registry."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import time
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+import numpy as np
+
+# Register HyperView providers into LanceDB registry.
+import hyperview.embeddings.providers.lancedb_providers as _lancedb_providers  # noqa: F401
+
+__all__ = [
+    "EmbeddingSpec",
+    "EmbeddingEngine",
+    "get_engine",
+    "list_embedding_providers",
+    "get_provider_info",
+]
+
+HYPERBOLIC_PROVIDERS = frozenset({"hyper-models"})
+
+
+def _format_elapsed(seconds: float) -> str:
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    total_seconds = int(round(seconds))
+    minutes, secs = divmod(total_seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m {secs:02d}s"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h {minutes:02d}m {secs:02d}s"
+
+
+def _format_eta(seconds: float) -> str:
+    if not math.isfinite(seconds) or seconds < 0:
+        return "unknown"
+    return _format_elapsed(seconds)
+
+
+@dataclass
+class EmbeddingSpec:
+    """Specification for an embedding model.
+
+    All providers live in the LanceDB registry. HyperView's custom providers
+    (embed-anything, hyper-models) are registered on import.
+
+    Attributes:
+        provider: Provider identifier (e.g., 'embed-anything', 'hyper-models', 'open-clip')
+        model_id: Model identifier (HuggingFace model_id, checkpoint name, etc.)
+        checkpoint: Optional checkpoint path/URL for weight-only models
+        provider_kwargs: Additional kwargs passed to the embedding function
+        modality: What input type this embedder handles
+    """
+
+    provider: str
+    model_id: str | None = None
+    checkpoint: str | None = None
+    provider_kwargs: dict[str, Any] = field(default_factory=dict)
+    modality: Literal["image", "text", "multimodal"] = "image"
+
+    @property
+    def geometry(self) -> Literal["euclidean", "hyperboloid"]:
+        """Get the output geometry for this spec."""
+
+        if self.provider == "hyper-models":
+            model_name = self.model_id or self.provider_kwargs.get("name")
+            if model_name is None:
+                return "hyperboloid"
+            import hyper_models
+
+            geom = str(hyper_models.get_model_info(str(model_name)).geometry)
+            return "hyperboloid" if geom in ("hyperboloid", "poincare") else "euclidean"
+
+        if self.provider in HYPERBOLIC_PROVIDERS:
+            return "hyperboloid"
+        return "euclidean"
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to JSON-serializable dict for persistence."""
+        d: dict[str, Any] = {
+            "provider": self.provider,
+            "modality": self.modality,
+            "geometry": self.geometry,
+        }
+        if self.model_id:
+            d["model_id"] = self.model_id
+        if self.checkpoint:
+            d["checkpoint"] = self.checkpoint
+        if self.provider_kwargs:
+            d["provider_kwargs"] = self.provider_kwargs
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> EmbeddingSpec:
+        """Create from dict (e.g., loaded from JSON)."""
+        return cls(
+            provider=d["provider"],
+            model_id=d.get("model_id"),
+            checkpoint=d.get("checkpoint"),
+            provider_kwargs=d.get("provider_kwargs", {}),
+            modality=d.get("modality", "image"),
+        )
+
+    def content_hash(self) -> str:
+        """Generate a short hash of the spec for collision-resistant keys."""
+        content = json.dumps(self.to_dict(), sort_keys=True)
+        return hashlib.sha256(content.encode()).hexdigest()[:12]
+
+    def make_space_key(self) -> str:
+        """Generate a collision-resistant space_key from this spec.
+
+        Format: {provider}__{slugified_model_id}__{content_hash}
+        """
+        from hyperview.storage.schema import slugify_model_id
+
+        model_part = self.model_id or self.checkpoint or "default"
+        slug = slugify_model_id(model_part)
+        content_hash = self.content_hash()
+        return f"{self.provider}__{slug}__{content_hash}"
+
+
+class EmbeddingEngine:
+    """Embedding engine using LanceDB registry.
+
+    All providers are accessed through the LanceDB embedding registry.
+    HyperView providers are registered automatically on import.
+    """
+
+    def __init__(self) -> None:
+        self._cache: dict[str, Any] = {}  # spec_hash -> embedding function
+
+    def get_function(self, spec: EmbeddingSpec) -> Any:
+        """Get an embedding function from LanceDB registry.
+
+        Args:
+            spec: Embedding specification.
+
+        Returns:
+            LanceDB EmbeddingFunction instance.
+
+        Raises:
+            ValueError: If provider not found in registry.
+        """
+        cache_key = spec.content_hash()
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+
+        from lancedb.embeddings import get_registry
+
+        registry = get_registry()
+
+        # Get provider factory from registry
+        try:
+            factory = registry.get(spec.provider)
+        except KeyError:
+            available = list_embedding_providers()
+            raise ValueError(
+                f"Unknown provider: '{spec.provider}'. "
+                f"Available: {', '.join(sorted(available))}"
+            ) from None
+
+        create_kwargs: dict[str, Any] = {}
+        if spec.model_id:
+            create_kwargs["name"] = spec.model_id
+
+        if spec.checkpoint:
+            create_kwargs["checkpoint"] = spec.checkpoint
+
+        create_kwargs.update(spec.provider_kwargs)
+
+        try:
+            func = factory.create(**create_kwargs)
+        except ImportError as e:
+            raise ImportError(
+                f"Provider '{spec.provider}' requires additional dependencies. "
+                "Install the provider's extra dependencies and try again."
+            ) from e
+
+        self._cache[cache_key] = func
+        return func
+
+    def embed_images(
+        self,
+        samples: list[Any],
+        spec: EmbeddingSpec,
+        batch_size: int = 32,
+        show_progress: bool = True,
+    ) -> np.ndarray:
+        """Compute embeddings for image samples.
+
+        Args:
+            samples: List of Sample objects with image filepaths.
+            spec: Embedding specification.
+            batch_size: Batch size for processing.
+            show_progress: Whether to show progress.
+
+        Returns:
+            Array of shape (N, D) where N is len(samples) and D is embedding dim.
+        """
+        provider_target = spec.model_id or spec.checkpoint or spec.provider
+        if show_progress:
+            print(
+                f"Preparing embedding provider '{spec.provider}' ({provider_target})...",
+                flush=True,
+            )
+
+        func = self.get_function(spec)
+
+        if hasattr(func, "set_progress_enabled"):
+            func.set_progress_enabled(show_progress)
+
+        if show_progress:
+            print(f"Computing embeddings for {len(samples)} samples...", flush=True)
+
+        all_embeddings: list[np.ndarray] = []
+        total_samples = len(samples)
+        total_batches = max(1, math.ceil(total_samples / batch_size))
+        report_every_batches = 1 if total_batches <= 20 else max(1, total_batches // 20)
+        started_at = time.perf_counter()
+        last_report_at = started_at
+
+        for batch_index, i in enumerate(range(0, len(samples), batch_size), start=1):
+            batch_samples = samples[i:i + batch_size]
+
+            batch_paths = [s.filepath for s in batch_samples]
+            batch_embeddings = func.compute_source_embeddings(batch_paths)
+            all_embeddings.extend(batch_embeddings)
+
+            if not show_progress:
+                continue
+
+            completed = len(all_embeddings)
+            now = time.perf_counter()
+            should_report = batch_index == 1 or batch_index == total_batches
+            if batch_index % report_every_batches == 0:
+                should_report = True
+            if now - last_report_at >= 10.0:
+                should_report = True
+            if not should_report:
+                continue
+
+            elapsed = max(now - started_at, 1e-9)
+            rate = completed / elapsed
+            remaining = total_samples - completed
+            eta_seconds = remaining / rate if rate > 0 else float("inf")
+            print(
+                f"Embedded {completed}/{total_samples} samples "
+                f"({completed / total_samples:.0%}, batch {batch_index}/{total_batches}, "
+                f"{rate:.1f}/s, elapsed {_format_elapsed(elapsed)}, "
+                f"ETA {_format_eta(eta_seconds)})",
+                flush=True,
+            )
+            last_report_at = now
+
+        return np.array(all_embeddings, dtype=np.float32)
+
+    def embed_texts(
+        self,
+        texts: list[str],
+        spec: EmbeddingSpec,
+    ) -> np.ndarray:
+        """Compute embeddings for text inputs.
+
+        Args:
+            texts: List of text strings.
+            spec: Embedding specification.
+
+        Returns:
+            Array of shape (N, D).
+        """
+        func = self.get_function(spec)
+
+        if hasattr(func, "generate_embeddings"):
+            out = func.generate_embeddings(texts)
+            return np.asarray(out, dtype=np.float32)
+
+        embeddings: list[np.ndarray] = []
+        for text in texts:
+            out = func.compute_query_embeddings(text)
+            if not out:
+                raise RuntimeError(f"Provider '{spec.provider}' returned no embedding for query")
+            embeddings.append(np.asarray(out[0], dtype=np.float32))
+        return np.vstack(embeddings)
+
+    def get_space_config(self, spec: EmbeddingSpec, dim: int) -> dict[str, Any]:
+        """Get space configuration for storage.
+
+        Args:
+            spec: Embedding specification.
+            dim: Embedding dimension.
+
+        Returns:
+            Config dict for SpaceInfo.config_json.
+        """
+        func = self.get_function(spec)
+
+        config = spec.to_dict()
+        config["dim"] = dim
+
+        if hasattr(func, "geometry"):
+            config["geometry"] = func.geometry
+        if hasattr(func, "curvature") and func.curvature is not None:
+            config["curvature"] = func.curvature
+
+        if config.get("geometry") == "hyperboloid":
+            config["spatial_dim"] = dim - 1
+
+        return config
+
+
+_ENGINE: EmbeddingEngine | None = None
+
+
+def get_engine() -> EmbeddingEngine:
+    """Get the global embedding engine singleton."""
+    global _ENGINE
+    if _ENGINE is None:
+        _ENGINE = EmbeddingEngine()
+    return _ENGINE
+
+
+def list_embedding_providers(available_only: bool = False) -> list[str]:
+    """List all registered embedding providers.
+
+    Args:
+        available_only: If True, only return providers whose dependencies are installed.
+
+    Returns:
+        List of provider identifiers.
+    """
+    from lancedb.embeddings import get_registry
+
+    registry = get_registry()
+
+    all_providers = list(getattr(registry, "_functions", {}).keys())
+
+    if not available_only:
+        return sorted(all_providers)
+
+    available: list[str] = []
+    for provider in all_providers:
+        try:
+            factory = registry.get(provider)
+            factory.create()
+            available.append(provider)
+        except ImportError:
+            pass
+        except (TypeError, ValueError):
+            available.append(provider)
+
+    return sorted(available)
+
+
+def get_provider_info(provider: str) -> dict[str, Any]:
+    """Get information about an embedding provider.
+
+    Args:
+        provider: Provider identifier.
+
+    Returns:
+        Dict with provider info.
+    """
+    from lancedb.embeddings import get_registry
+
+    registry = get_registry()
+
+    try:
+        factory = registry.get(provider)
+    except KeyError:
+        raise ValueError(f"Unknown provider: {provider}") from None
+
+    info: dict[str, Any] = {
+        "provider": provider,
+        "source": "hyperview" if provider in ("embed-anything", "hyper-models") else "lancedb",
+        "geometry": "hyperboloid" if provider in HYPERBOLIC_PROVIDERS else "euclidean",
+    }
+
+    try:
+        factory.create()
+        info["installed"] = True
+    except ImportError:
+        info["installed"] = False
+    except (TypeError, ValueError):
+        info["installed"] = True
+
+    return info

vendor/hyperview/embeddings/pipelines.py

@@ -0,0 +1,265 @@
+"""Compute orchestration pipelines for HyperView.
+
+These functions coordinate embedding computation and layout/projection
+computation, persisting results into the configured storage backend.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+import numpy as np
+
+from hyperview.storage.backend import StorageBackend
+from hyperview.storage.schema import make_layout_key, normalize_layout_dimension
+
+
+def _format_elapsed(seconds: float) -> str:
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    total_seconds = int(round(seconds))
+    minutes, secs = divmod(total_seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m {secs:02d}s"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h {minutes:02d}m {secs:02d}s"
+
+
+def compute_embeddings(
+    storage: StorageBackend,
+    spec: Any,
+    batch_size: int = 32,
+    sample_ids: list[str] | None = None,
+    show_progress: bool = True,
+) -> tuple[str, int, int]:
+    """Compute embeddings for samples that don't have them yet.
+
+    Args:
+        storage: Storage backend to read samples from and write embeddings to.
+        spec: Embedding specification (provider, model_id, etc.)
+        batch_size: Batch size for processing.
+        sample_ids: Optional subset of sample IDs to ensure embeddings for.
+            If omitted, embeddings are ensured for the full dataset.
+        show_progress: Whether to show progress bar.
+
+    Returns:
+        Tuple of (space_key, num_computed, num_skipped).
+
+    Raises:
+        ValueError: If no samples exist, requested sample IDs are missing,
+            or the provider cannot be resolved.
+    """
+    from hyperview.embeddings.engine import get_engine
+
+    engine = get_engine()
+
+    if sample_ids is None:
+        target_samples = storage.get_all_samples()
+        if not target_samples:
+            raise ValueError("No samples in storage")
+    else:
+        if not sample_ids:
+            raise ValueError("sample_ids must contain at least one sample ID")
+
+        requested_sample_ids = list(dict.fromkeys(sample_ids))
+        target_samples = storage.get_samples_by_ids(requested_sample_ids)
+        found_sample_ids = {sample.id for sample in target_samples}
+        missing_sample_ids = [sample_id for sample_id in requested_sample_ids if sample_id not in found_sample_ids]
+        if missing_sample_ids:
+            raise ValueError(
+                "Requested sample_ids were not found in storage: "
+                f"{missing_sample_ids[:5]}"
+            )
+
+    # Generate space key before computing (deterministic from spec)
+    space_key = spec.make_space_key()
+    target_sample_ids = [sample.id for sample in target_samples]
+
+    if not storage.get_space(space_key):
+        missing_ids = target_sample_ids
+    elif sample_ids is None:
+        missing_ids = storage.get_missing_embedding_ids(space_key)
+    else:
+        embedded_ids = storage.get_embedded_ids(space_key)
+        missing_ids = [sample_id for sample_id in target_sample_ids if sample_id not in embedded_ids]
+
+    num_skipped = len(target_sample_ids) - len(missing_ids)
+
+    if not missing_ids:
+        if show_progress:
+            scope = "requested" if sample_ids is not None else "all"
+            print(
+                f"All {len(target_sample_ids)} {scope} samples already have embeddings "
+                f"in space '{space_key}'"
+            )
+        return space_key, 0, num_skipped
+
+    samples_to_embed = storage.get_samples_by_ids(missing_ids)
+
+    if show_progress and num_skipped > 0:
+        print(f"Skipped {num_skipped} samples with existing embeddings")
+
+    embeddings = engine.embed_images(
+        samples=samples_to_embed,
+        spec=spec,
+        batch_size=batch_size,
+        show_progress=show_progress,
+    )
+
+    dim = embeddings.shape[1]
+    config = engine.get_space_config(spec, dim)
+    storage.ensure_space(
+        model_id=spec.model_id or spec.provider,
+        dim=dim,
+        config=config,
+        space_key=space_key,
+    )
+
+    ids = [sample.id for sample in samples_to_embed]
+    storage.add_embeddings(space_key, ids, embeddings)
+
+    return space_key, len(ids), num_skipped
+
+
+def compute_layout(
+    storage: StorageBackend,
+    space_key: str | None = None,
+    method: str = "umap",
+    geometry: str = "euclidean",
+    layout_dimension: int = 2,
+    n_neighbors: int = 15,
+    min_dist: float = 0.1,
+    metric: str = "cosine",
+    force: bool = False,
+    show_progress: bool = True,
+) -> str:
+    """Compute layout/projection for visualization.
+
+    Args:
+        storage: Storage backend with embeddings.
+        space_key: Embedding space to project. If None, uses the first available.
+        method: Projection method ('umap' supported).
+        geometry: Output geometry type ('euclidean', 'poincare', or 'spherical').
+        layout_dimension: Visualization dimension (2D or 3D).
+        n_neighbors: Number of neighbors for UMAP.
+        min_dist: Minimum distance for UMAP.
+        metric: Distance metric for UMAP.
+        force: Force recomputation even if layout exists.
+        show_progress: Whether to print progress messages.
+
+    Returns:
+        layout_key for the computed layout.
+
+    Raises:
+        ValueError: If no embedding spaces, space not found, or insufficient samples.
+    """
+    from hyperview.embeddings.projection import ProjectionEngine
+
+    if method != "umap":
+        raise ValueError(f"Invalid method: {method}. Only 'umap' is supported.")
+    layout_dimension = normalize_layout_dimension(layout_dimension)
+
+    if geometry not in ("euclidean", "poincare", "spherical"):
+        raise ValueError(
+            f"Invalid geometry: {geometry}. Must be 'euclidean', 'poincare', or 'spherical'."
+        )
+    if geometry == "poincare" and layout_dimension != 2:
+        raise ValueError("Poincare layouts currently require 2D output.")
+
+    if space_key is None:
+        spaces = storage.list_spaces()
+        if not spaces:
+            raise ValueError("No embedding spaces. Call compute_embeddings() first.")
+
+        # Choose a sensible default space based on the requested output geometry.
+        # - For Poincaré output, prefer a hyperbolic (hyperboloid) embedding space if present.
+        # - For non-hyperbolic output, prefer a Euclidean embedding space if present.
+        if geometry == "poincare":
+            preferred = next((s for s in spaces if s.geometry == "hyperboloid"), None)
+        else:
+            preferred = next((s for s in spaces if s.geometry != "hyperboloid"), None)
+
+        space_key = preferred.space_key if preferred is not None else spaces[0].space_key
+
+    space = storage.get_space(space_key)
+    if space is None:
+        raise ValueError(f"Space not found: {space_key}")
+
+    input_geometry = space.geometry
+    curvature = (space.config or {}).get("curvature")
+
+    ids, vectors = storage.get_embeddings(space_key)
+    if len(ids) == 0:
+        raise ValueError(f"No embeddings in space '{space_key}'. Call compute_embeddings() first.")
+
+    if len(ids) < 3:
+        raise ValueError(f"Need at least 3 samples for visualization, have {len(ids)}")
+
+    layout_params = {
+        "n_neighbors": n_neighbors,
+        "min_dist": min_dist,
+        "metric": metric,
+    }
+
+    normalize_input = geometry == "spherical"
+
+    layout_key = make_layout_key(
+        space_key,
+        method,
+        geometry,
+        layout_dimension=layout_dimension,
+        params=layout_params,
+    )
+
+    if not force:
+        existing_layout = storage.get_layout(layout_key)
+        if existing_layout is not None:
+            existing_ids, _ = storage.get_layout_coords(layout_key)
+            if set(existing_ids) == set(ids):
+                if show_progress:
+                    print(f"Layout '{layout_key}' already exists with {len(ids)} points")
+                return layout_key
+            if show_progress:
+                print("Layout exists but has different samples, recomputing...")
+
+    if show_progress:
+        print(
+            f"Computing {geometry} {method} layout "
+            f"({layout_dimension}D) for {len(ids)} samples..."
+        )
+
+    storage.ensure_layout(
+        layout_key=layout_key,
+        space_key=space_key,
+        method=method,
+        geometry=geometry,
+        params=layout_params,
+    )
+
+    engine = ProjectionEngine()
+    started_at = time.perf_counter()
+    coords = engine.project(
+        vectors,
+        input_geometry=input_geometry,
+        output_geometry=geometry,
+        n_components=layout_dimension,
+        normalize_input=normalize_input,
+        curvature=curvature,
+        method=method,
+        n_neighbors=n_neighbors,
+        min_dist=min_dist,
+        metric=metric,
+        verbose=show_progress,
+    )
+
+    if show_progress:
+        print(
+            f"Computed {geometry} {method} layout in "
+            f"{_format_elapsed(time.perf_counter() - started_at)}",
+            flush=True,
+        )
+
+    storage.add_layout_coords(layout_key, ids, coords)
+
+    return layout_key

vendor/hyperview/embeddings/projection.py

@@ -0,0 +1,292 @@
+"""Projection methods for dimensionality reduction."""
+
+import logging
+import warnings
+
+import numpy as np
+import umap
+
+logger = logging.getLogger(__name__)
+
+
+class ProjectionEngine:
+    """Engine for projecting high-dimensional embeddings to low-dimensional layouts."""
+
+    def l2_normalize_rows(self, embeddings: np.ndarray) -> np.ndarray:
+        """L2-normalize embeddings row-wise with numerical safeguards."""
+        norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
+        norms = np.maximum(norms, 1e-12)
+        return (embeddings / norms).astype(np.float32)
+
+    def to_poincare_ball(
+        self,
+        hyperboloid_embeddings: np.ndarray,
+        curvature: float | None = None,
+        clamp_radius: float = 0.999999,
+    ) -> np.ndarray:
+        """Convert hyperboloid (Lorentz) coordinates to Poincaré ball coordinates.
+
+        Input is expected to be shape (N, D+1) with first coordinate being time-like.
+        Points are assumed to satisfy: t^2 - ||x||^2 = 1/c (c > 0).
+
+        Returns Poincaré ball coordinates of shape (N, D) in the unit ball.
+
+        Notes:
+        - Many hyperbolic libraries parameterize curvature as a positive number c
+          where the manifold has sectional curvature -c.
+        - We map to the unit ball for downstream distance metrics (UMAP 'poincare').
+        """
+        if hyperboloid_embeddings.ndim != 2 or hyperboloid_embeddings.shape[1] < 2:
+            raise ValueError(
+                "hyperboloid_embeddings must have shape (N, D+1) with D>=1"
+            )
+
+        c = float(curvature) if curvature is not None else 1.0
+        if c <= 0:
+            raise ValueError(f"curvature must be > 0, got {c}")
+
+        # Radius R = 1/sqrt(c) for curvature -c
+        R = 1.0 / np.sqrt(c)
+
+        t = hyperboloid_embeddings[:, :1]
+        x = hyperboloid_embeddings[:, 1:]
+
+        # Map to ball radius R: u_R = x / (t + R)
+        denom = t + R
+        u_R = x / denom
+
+        # Rescale to unit ball: u = u_R / R = sqrt(c) * u_R
+        u = u_R / R
+
+        # Numerical guard: ensure inside the unit ball
+        radii = np.linalg.norm(u, axis=1)
+        mask = radii >= clamp_radius
+        if np.any(mask):
+            u[mask] = u[mask] / radii[mask][:, np.newaxis] * clamp_radius
+
+        return u.astype(np.float32)
+
+    def project(
+        self,
+        embeddings: np.ndarray,
+        *,
+        input_geometry: str = "euclidean",
+        output_geometry: str = "euclidean",
+        n_components: int = 2,
+        normalize_input: bool = False,
+        curvature: float | None = None,
+        method: str = "umap",
+        n_neighbors: int = 15,
+        min_dist: float = 0.1,
+        metric: str = "cosine",
+        random_state: int = 42,
+        verbose: bool = False,
+    ) -> np.ndarray:
+        """Project embeddings with geometry-aware preprocessing.
+
+        This separates two concerns:
+        1) Geometry/model transforms for the *input* embeddings (e.g. hyperboloid -> Poincaré)
+        2) Dimensionality reduction / layout (currently UMAP)
+
+        Args:
+            embeddings: Input embeddings (N x D) or hyperboloid (N x D+1).
+            input_geometry: Geometry/model of the input embeddings (euclidean, hyperboloid).
+            output_geometry: Geometry of the output coordinates (euclidean, poincare, spherical).
+            n_components: Number of output dimensions.
+            normalize_input: Whether to L2-normalize vectors before projection.
+            curvature: Curvature parameter for hyperbolic embeddings (positive c).
+            method: Layout method (currently only 'umap').
+            n_neighbors: UMAP neighbors.
+            min_dist: UMAP min_dist.
+            metric: Input metric (used for euclidean inputs).
+            random_state: Random seed.
+
+        Returns:
+            Layout coordinates (N x n_components).
+        """
+        if method != "umap":
+            raise ValueError(f"Invalid method: {method}. Only 'umap' is supported.")
+        if n_components < 2:
+            raise ValueError(f"n_components must be >= 2, got {n_components}")
+
+        prepared = embeddings
+        prepared_metric: str = metric
+
+        if normalize_input:
+            prepared = self.l2_normalize_rows(prepared)
+
+        if input_geometry == "hyperboloid":
+            # Convert to unit Poincaré ball and use UMAP's built-in hyperbolic distance.
+            prepared = self.to_poincare_ball(embeddings, curvature=curvature)
+            prepared_metric = "poincare"
+
+        if output_geometry == "poincare":
+            if n_components != 2:
+                raise ValueError("Poincare layouts currently require 2D output")
+            return self.project_to_poincare(
+                prepared,
+                n_neighbors=n_neighbors,
+                min_dist=min_dist,
+                metric=prepared_metric,
+                random_state=random_state,
+                verbose=verbose,
+            )
+
+        if output_geometry in ("euclidean", "spherical"):
+            return self.project_umap(
+                prepared,
+                n_neighbors=n_neighbors,
+                min_dist=min_dist,
+                metric=prepared_metric,
+                n_components=n_components,
+                random_state=random_state,
+                verbose=verbose,
+            )
+
+        raise ValueError(
+            f"Invalid output_geometry: {output_geometry}. "
+            "Must be 'euclidean', 'poincare', or 'spherical'."
+        )
+
+    def project_umap(
+        self,
+        embeddings: np.ndarray,
+        n_neighbors: int = 15,
+        min_dist: float = 0.1,
+        metric: str = "cosine",
+        n_components: int = 2,
+        random_state: int = 42,
+        verbose: bool = False,
+    ) -> np.ndarray:
+        """Project embeddings to Euclidean layout coordinates using UMAP."""
+        n_neighbors = min(n_neighbors, len(embeddings) - 1)
+        if n_neighbors < 2:
+            n_neighbors = 2
+
+        n_jobs = 1 if random_state is not None else -1
+
+        reducer = umap.UMAP(
+            n_neighbors=n_neighbors,
+            min_dist=min_dist,
+            n_components=n_components,
+            metric=metric,
+            random_state=random_state,
+            n_jobs=n_jobs,
+            verbose=verbose,
+        )
+
+        coords = reducer.fit_transform(embeddings)
+        coords = self._normalize_coords(coords)
+
+        return coords
+
+    def project_to_poincare(
+        self,
+        embeddings: np.ndarray,
+        n_neighbors: int = 15,
+        min_dist: float = 0.1,
+        metric: str = "cosine",
+        random_state: int = 42,
+        verbose: bool = False,
+    ) -> np.ndarray:
+        """Project embeddings to the Poincaré disk using UMAP with hyperboloid output."""
+        n_neighbors = min(n_neighbors, len(embeddings) - 1)
+        if n_neighbors < 2:
+            n_neighbors = 2
+
+        n_jobs = 1 if random_state is not None else -1
+
+        # Suppress warning about missing gradient for poincare metric (only affects inverse_transform)
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", message="gradient function is not yet implemented")
+            reducer = umap.UMAP(
+                n_neighbors=n_neighbors,
+                min_dist=min_dist,
+                n_components=2,
+                metric=metric,
+                output_metric="hyperboloid",
+                random_state=random_state,
+                n_jobs=n_jobs,
+                verbose=verbose,
+            )
+            spatial_coords = reducer.fit_transform(embeddings)
+
+        squared_norm = np.sum(spatial_coords**2, axis=1)
+        t = np.sqrt(1 + squared_norm)
+
+        # Project to Poincaré disk: u = x / (1 + t)
+        denom = 1 + t
+        poincare_coords = spatial_coords / denom[:, np.newaxis]
+
+        # Clamp to unit disk for numerical stability
+        radii = np.linalg.norm(poincare_coords, axis=1)
+        max_radius = 0.999
+        mask = radii > max_radius
+        if np.any(mask):
+            logger.warning(f"Clamping {np.sum(mask)} points to unit disk.")
+            poincare_coords[mask] = (
+                poincare_coords[mask] / radii[mask][:, np.newaxis] * max_radius
+            )
+
+        poincare_coords = self._center_poincare(poincare_coords)
+        poincare_coords = self._scale_poincare(poincare_coords, factor=0.65)
+
+        return poincare_coords
+
+    def _scale_poincare(self, coords: np.ndarray, factor: float) -> np.ndarray:
+        """Scale points towards the origin in hyperbolic space.
+
+        Scales hyperbolic distance from origin by `factor`. If factor < 1, points move closer to center.
+        """
+        radii = np.linalg.norm(coords, axis=1)
+        mask = radii > 1e-6
+
+        r = radii[mask]
+        r = np.minimum(r, 0.9999999)
+        r_new = np.tanh(factor * np.arctanh(r))
+
+        scale_ratios = np.ones_like(radii)
+        scale_ratios[mask] = r_new / r
+
+        return coords * scale_ratios[:, np.newaxis]
+
+    def _center_poincare(self, coords: np.ndarray) -> np.ndarray:
+        """Center points in the Poincaré disk using a Möbius transformation."""
+        if len(coords) == 0:
+            return coords
+
+        z = coords[:, 0] + 1j * coords[:, 1]
+        centroid = np.mean(z)
+
+        if np.abs(centroid) > 0.99 or np.abs(centroid) < 1e-6:
+            return coords
+
+        # Möbius transformation: w = (z - a) / (1 - conj(a) * z)
+        a = centroid
+        w = (z - a) / (1 - np.conj(a) * z)
+
+        return np.stack([w.real, w.imag], axis=1)
+
+    def _normalize_coords(self, coords: np.ndarray) -> np.ndarray:
+        """Normalize coordinates to [-1, 1] range."""
+        if len(coords) == 0:
+            return coords
+
+        coords = coords - coords.mean(axis=0)
+        max_abs = np.abs(coords).max()
+        if max_abs > 0:
+            coords = coords / max_abs * 0.95
+
+        return coords
+
+    def poincare_distance(self, u: np.ndarray, v: np.ndarray) -> float:
+        """Compute the Poincaré distance between two points."""
+        u_norm_sq = np.sum(u**2)
+        v_norm_sq = np.sum(v**2)
+        diff_norm_sq = np.sum((u - v) ** 2)
+
+        u_norm_sq = min(u_norm_sq, 0.99999)
+        v_norm_sq = min(v_norm_sq, 0.99999)
+
+        delta = 2 * diff_norm_sq / ((1 - u_norm_sq) * (1 - v_norm_sq))
+        return np.arccosh(1 + delta)

vendor/hyperview/embeddings/providers/__init__.py

@@ -0,0 +1,7 @@
+"""Embedding providers.
+
+HyperView integrates with LanceDB's embedding registry.
+Custom providers are registered in `lancedb_providers.py`.
+"""
+
+__all__: list[str] = []

vendor/hyperview/embeddings/providers/lancedb_providers.py

@@ -0,0 +1,374 @@
+"""LanceDB-registered embedding providers for HyperView.
+
+This module registers HyperView's embedding providers into the LanceDB embedding
+registry using the @register decorator.
+
+Providers:
+- embed-anything: CLIP-based image embeddings (torch-free, default)
+- hyper-models: Non-Euclidean model zoo via `hyper-models` (torch-free ONNX; downloads from HF Hub)
+- timm-image: Image backbones loaded with timm (e.g. MegaDescriptor)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from lancedb.embeddings import EmbeddingFunction, register
+from pydantic import PrivateAttr
+
+__all__ = [
+    "EmbedAnythingEmbeddings",
+    "HyperModelsEmbeddings",
+    "TimmImageEmbeddings",
+]
+
+
+@register("embed-anything")
+class EmbedAnythingEmbeddings(EmbeddingFunction):
+    """CLIP-based image embeddings via embed-anything.
+
+    This is the default provider for HyperView - lightweight and torch-free.
+
+    Args:
+        name: HuggingFace model ID for CLIP (default: openai/clip-vit-base-patch32)
+        batch_size: Batch size for processing
+    """
+
+    name: str = "openai/clip-vit-base-patch32"
+    batch_size: int = 32
+
+    _computer: Any = PrivateAttr(default=None)
+    _ndims: int | None = PrivateAttr(default=None)
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._computer = None
+        self._ndims = None
+
+    def _get_computer(self) -> Any:
+        if self._computer is None:
+            from hyperview.embeddings.compute import EmbeddingComputer
+
+            self._computer = EmbeddingComputer(model=self.name)
+        return self._computer
+
+    def ndims(self) -> int:
+        if self._ndims is None:
+            if "large" in self.name.lower():
+                self._ndims = 768
+            elif "clip" in self.name.lower():
+                self._ndims = 512
+            else:
+                self._ndims = 512
+        return self._ndims
+
+    def compute_source_embeddings(
+        self, inputs: Any, *args: Any, **kwargs: Any
+    ) -> list[np.ndarray | None]:
+        from hyperview.core.sample import Sample
+
+        computer = self._get_computer()
+
+        samples: list[Any] = []
+        for inp in self.sanitize_input(inputs):
+            if isinstance(inp, Sample):
+                samples.append(inp)
+            elif isinstance(inp, str):
+                samples.append(Sample(id=inp, filepath=inp))
+            else:
+                raise TypeError(f"Unsupported input type: {type(inp)}")
+
+        embeddings = computer.compute_batch(samples, batch_size=self.batch_size, show_progress=False)
+        return list(embeddings)
+
+    def compute_query_embeddings(
+        self, query: Any, *args: Any, **kwargs: Any
+    ) -> list[np.ndarray | None]:
+        return self.compute_source_embeddings([query], *args, **kwargs)
+
+
+@register("hyper-models")
+class HyperModelsEmbeddings(EmbeddingFunction):
+    """Non-Euclidean embeddings via the `hyper-models` package.
+
+    This provider is a thin wrapper around `hyper_models.load(...)`.
+    Models are downloaded from the Hugging Face Hub on first use.
+
+    Args:
+        name: Model name in the hyper-models registry (e.g. 'hycoclip-vit-s').
+        checkpoint: Optional local path to an ONNX file (skips hub download).
+        batch_size: Batch size hint. Current HyCoCLIP/MERU ONNX exports may only
+            support batch_size=1; HyperView encodes one image at a time for
+            maximum compatibility.
+    """
+
+    name: str = "hycoclip-vit-s"
+    checkpoint: str | None = None
+    batch_size: int = 1
+
+    _model: Any = PrivateAttr(default=None)
+    _model_info: Any = PrivateAttr(default=None)
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._model = None
+        self._model_info = None
+
+    def _ensure_model_info(self) -> None:
+        if self._model_info is not None:
+            return
+
+        try:
+            import hyper_models
+        except ImportError as e:
+            raise ImportError(
+                "Provider 'hyper-models' requires the 'hyper-models' package. "
+                "Install it with: `uv pip install hyper-models`"
+            ) from e
+
+        try:
+            self._model_info = hyper_models.get_model_info(self.name)
+        except KeyError:
+            available = ", ".join(sorted(hyper_models.list_models()))
+            raise ValueError(
+                f"Unknown hyper-models model: '{self.name}'. Available: {available}"
+            ) from None
+
+    def _ensure_model(self) -> None:
+        if self._model is not None:
+            return
+
+        self._ensure_model_info()
+        import hyper_models
+
+        self._model = hyper_models.load(self.name, local_path=self.checkpoint)
+
+    def ndims(self) -> int:
+        self._ensure_model_info()
+        assert self._model_info is not None
+        return int(getattr(self._model_info, "dim"))
+
+    @property
+    def geometry(self) -> str:
+        self._ensure_model_info()
+        assert self._model_info is not None
+        return str(getattr(self._model_info, "geometry"))
+
+    def compute_source_embeddings(
+        self, inputs: Any, *args: Any, **kwargs: Any
+    ) -> list[np.ndarray | None]:
+        from hyperview.core.sample import Sample
+
+        self._ensure_model()
+        assert self._model is not None
+
+        inputs = self.sanitize_input(inputs)
+        all_embeddings: list[np.ndarray | None] = []
+
+        from PIL import Image
+
+        for inp in inputs:
+            if isinstance(inp, Sample):
+                with inp.load_image() as img:
+                    img.load()
+                    if img.mode != "RGB":
+                        img = img.convert("RGB")
+                    pil_img = img.copy()
+            elif isinstance(inp, str):
+                with Image.open(inp) as img:
+                    img.load()
+                    if img.mode != "RGB":
+                        img = img.convert("RGB")
+                    pil_img = img.copy()
+            elif isinstance(inp, Image.Image):
+                pil_img = inp.convert("RGB") if inp.mode != "RGB" else inp
+            else:
+                raise TypeError(f"Unsupported input type: {type(inp)}")
+
+            emb = self._model.encode_images([pil_img])
+            vec = np.asarray(emb[0], dtype=np.float32)
+            all_embeddings.append(vec)
+
+        return all_embeddings
+
+    def compute_query_embeddings(
+        self, query: Any, *args: Any, **kwargs: Any
+    ) -> list[np.ndarray | None]:
+        return self.compute_source_embeddings([query], *args, **kwargs)
+
+
+@register("timm-image")
+class TimmImageEmbeddings(EmbeddingFunction):
+    """Image embeddings via timm backbones.
+
+    This provider supports timm models, including Hugging Face-hosted timm
+    checkpoints like ``hf-hub:BVRA/MegaDescriptor-L-384``.
+
+    Args:
+        name: timm model name (local timm id or ``hf-hub:<repo>``).
+        batch_size: Batch size for image encoding.
+        device: Explicit torch device (e.g. ``cpu``, ``cuda``). If omitted,
+            selects ``cuda`` when available, otherwise ``cpu``.
+    """
+
+    name: str = "hf-hub:BVRA/MegaDescriptor-L-384"
+    batch_size: int = 8
+    device: str | None = None
+
+    _model: Any = PrivateAttr(default=None)
+    _transform: Any = PrivateAttr(default=None)
+    _torch: Any = PrivateAttr(default=None)
+    _device: str | None = PrivateAttr(default=None)
+    _ndims: int | None = PrivateAttr(default=None)
+    _show_progress: bool = PrivateAttr(default=False)
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._model = None
+        self._transform = None
+        self._torch = None
+        self._device = None
+        self._ndims = None
+        self._show_progress = False
+        if self.batch_size <= 0:
+            raise ValueError("batch_size must be > 0")
+
+    def set_progress_enabled(self, enabled: bool) -> None:
+        self._show_progress = bool(enabled)
+
+    def _import_ml_stack(self) -> tuple[Any, Any, Any]:
+        try:
+            import timm
+            import torch
+            from torchvision import transforms as tv_transforms
+        except ImportError as e:
+            raise ImportError(
+                "Provider 'timm-image' requires torch/timm/torchvision. "
+                "Install with: `uv sync --extra ml`"
+            ) from e
+        return torch, timm, tv_transforms
+
+    def _ensure_model(self) -> None:
+        if self._model is not None:
+            return
+
+        torch, timm, tv_transforms = self._import_ml_stack()
+        resolved_device = self.device or (
+            "cuda"
+            if torch.cuda.is_available()
+            else "mps"
+            if hasattr(torch.backends, "mps") and torch.backends.mps.is_available()
+            else "cpu"
+        )
+
+        if self._show_progress:
+            print(
+                f"Initializing timm model '{self.name}' on {resolved_device}...",
+                flush=True,
+            )
+
+        model = timm.create_model(self.name, num_classes=0, pretrained=True)
+        model.eval()
+        model.to(resolved_device)
+
+        cfg = getattr(model, "pretrained_cfg", {}) or {}
+        input_size = cfg.get("input_size", (3, 384, 384))
+        image_size = int(input_size[-1]) if isinstance(input_size, (tuple, list)) and input_size else 384
+        mean = cfg.get("mean", (0.5, 0.5, 0.5))
+        std = cfg.get("std", (0.5, 0.5, 0.5))
+
+        self._transform = tv_transforms.Compose(
+            [
+                tv_transforms.Resize((image_size, image_size)),
+                tv_transforms.ToTensor(),
+                tv_transforms.Normalize(mean, std),
+            ]
+        )
+
+        ndims = int(getattr(model, "num_features", 0))
+        if ndims <= 0:
+            dummy = torch.zeros((1, 3, image_size, image_size), device=resolved_device)
+            with torch.inference_mode():
+                out = model(dummy)
+            if isinstance(out, (tuple, list)):
+                out = out[0]
+            ndims = int(out.shape[-1])
+
+        self._model = model
+        self._torch = torch
+        self._device = resolved_device
+        self._ndims = ndims
+
+        if self._show_progress:
+            print(
+                f"timm model ready ({self._ndims} dims on {self._device})",
+                flush=True,
+            )
+
+    def ndims(self) -> int:
+        self._ensure_model()
+        assert self._ndims is not None
+        return self._ndims
+
+    @property
+    def geometry(self) -> str:
+        return "euclidean"
+
+    def _load_pil_image(self, inp: Any) -> Any:
+        from PIL import Image
+
+        from hyperview.core.sample import Sample
+
+        if isinstance(inp, Sample):
+            with inp.load_image() as img:
+                img.load()
+                if img.mode != "RGB":
+                    img = img.convert("RGB")
+                return img.copy()
+        if isinstance(inp, str):
+            with Image.open(inp) as img:
+                img.load()
+                if img.mode != "RGB":
+                    img = img.convert("RGB")
+                return img.copy()
+        if isinstance(inp, Image.Image):
+            return inp.convert("RGB") if inp.mode != "RGB" else inp
+        raise TypeError(f"Unsupported input type: {type(inp)}")
+
+    def compute_source_embeddings(
+        self, inputs: Any, *args: Any, **kwargs: Any
+    ) -> list[np.ndarray | None]:
+        self._ensure_model()
+        assert self._model is not None
+        assert self._transform is not None
+        assert self._torch is not None
+        assert self._device is not None
+
+        pil_images = [self._load_pil_image(inp) for inp in self.sanitize_input(inputs)]
+        embeddings: list[np.ndarray | None] = []
+
+        for start in range(0, len(pil_images), self.batch_size):
+            batch_imgs = pil_images[start:start + self.batch_size]
+            batch_tensors = [self._transform(img) for img in batch_imgs]
+            batch = self._torch.stack(batch_tensors).to(self._device)
+
+            with self._torch.inference_mode():
+                out = self._model(batch)
+
+            if isinstance(out, (tuple, list)):
+                out = out[0]
+
+            out_arr = np.asarray(out.detach().cpu().numpy(), dtype=np.float32)
+            if out_arr.ndim == 1:
+                out_arr = out_arr[None, :]
+
+            for vec in out_arr:
+                embeddings.append(np.asarray(vec, dtype=np.float32))
+
+        return embeddings
+
+    def compute_query_embeddings(
+        self, query: Any, *args: Any, **kwargs: Any
+    ) -> list[np.ndarray | None]:
+        return self.compute_source_embeddings([query], *args, **kwargs)

vendor/hyperview/server/__init__.py

@@ -0,0 +1,5 @@
+"""FastAPI server for HyperView."""
+
+from hyperview.server.app import create_app
+
+__all__ = ["create_app"]

vendor/hyperview/server/app.py

@@ -0,0 +1,521 @@
+"""FastAPI application for HyperView."""
+
+import os
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from fastapi import Depends, FastAPI, HTTPException, Query
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+
+from hyperview.core.dataset import Dataset
+from hyperview.core.selection import (
+    OrbitViewState3D,
+    points_in_polygon,
+    select_ids_for_3d_lasso,
+)
+from hyperview.storage.schema import parse_layout_dimension
+
+# Global dataset reference (set by launch())
+_current_dataset: Dataset | None = None
+_current_session_id: str | None = None
+
+
+class SelectionRequest(BaseModel):
+    """Request model for selection sync."""
+
+    sample_ids: list[str]
+
+
+class LassoSelectionRequest(BaseModel):
+    """Request model for lasso selection queries."""
+
+    layout_key: str  # e.g., "openai_clip-vit-base-patch32__umap"
+    # Polygon vertices, interleaved: [x0, y0, x1, y1, ...]
+    # - 2D layouts: data-space polygon (same coordinates as /api/embeddings)
+    # - 3D layouts: screen-space polygon in CSS pixels
+    polygon: list[float]
+    # Required for 3D lasso requests.
+    view_3d: dict[str, float] | None = None
+    viewport_width: int | None = None
+    viewport_height: int | None = None
+    label_filter: str | None = None
+    offset: int = 0
+    limit: int = 100
+    include_thumbnails: bool = True
+
+
+class SampleResponse(BaseModel):
+    """Response model for a sample."""
+
+    id: str
+    filepath: str
+    filename: str
+    label: str | None
+    thumbnail: str | None
+    metadata: dict
+    width: int | None = None
+    height: int | None = None
+
+
+class LayoutInfoResponse(BaseModel):
+    """Response model for layout info."""
+
+    layout_key: str
+    space_key: str
+    method: str
+    geometry: str
+    count: int
+    params: dict[str, Any] | None
+
+
+class SpaceInfoResponse(BaseModel):
+    """Response model for embedding space info."""
+
+    space_key: str
+    model_id: str
+    dim: int
+    count: int
+    provider: str
+    geometry: str
+    config: dict[str, Any] | None
+
+
+class DatasetResponse(BaseModel):
+    """Response model for dataset info."""
+
+    name: str
+    num_samples: int
+    labels: list[str]
+    spaces: list[SpaceInfoResponse]
+    layouts: list[LayoutInfoResponse]
+
+
+class EmbeddingsResponse(BaseModel):
+    """Response model for embeddings data (for scatter plot)."""
+
+    layout_key: str
+    geometry: str
+    ids: list[str]
+    labels: list[str | None]
+    coords: list[list[float]]
+
+
+class SimilarSampleResponse(BaseModel):
+    """Response model for a similar sample with distance."""
+
+    id: str
+    filepath: str
+    filename: str
+    label: str | None
+    thumbnail: str | None
+    distance: float
+    metadata: dict
+
+
+class SimilaritySearchResponse(BaseModel):
+    """Response model for similarity search results."""
+
+    query_id: str
+    k: int
+    results: list[SimilarSampleResponse]
+
+
+def create_app(dataset: Dataset | None = None, session_id: str | None = None) -> FastAPI:
+    """Create the FastAPI application.
+
+    Args:
+        dataset: Optional dataset to serve. If None, uses global dataset.
+
+    Returns:
+        FastAPI application instance.
+    """
+    global _current_dataset, _current_session_id
+    if dataset is not None:
+        _current_dataset = dataset
+    if session_id is not None:
+        _current_session_id = session_id
+
+    app = FastAPI(
+        title="HyperView",
+        description="Dataset visualization with hyperbolic embeddings",
+        version="0.1.0",
+    )
+
+    def get_dataset() -> Dataset:
+        """Dependency that returns the current dataset or raises 404."""
+        if _current_dataset is None:
+            raise HTTPException(status_code=404, detail="No dataset loaded")
+        return _current_dataset
+
+    # CORS middleware for development
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    @app.get("/__hyperview__/health")
+    async def hyperview_health():
+        return {
+            "name": "hyperview",
+            "version": app.version,
+            "session_id": _current_session_id,
+            "dataset": _current_dataset.name if _current_dataset is not None else None,
+            "pid": os.getpid(),
+        }
+
+    @app.get("/api/dataset", response_model=DatasetResponse)
+    async def get_dataset_info(ds: Dataset = Depends(get_dataset)):
+        """Get dataset metadata."""
+        spaces = ds.list_spaces()
+        space_dicts = [s.to_api_dict() for s in spaces]
+
+        layouts = ds.list_layouts()
+        layout_dicts = [layout.to_api_dict() for layout in layouts]
+
+        return DatasetResponse(
+            name=ds.name,
+            num_samples=len(ds),
+            labels=ds.labels,
+            spaces=space_dicts,
+            layouts=layout_dicts,
+        )
+
+    @app.get("/api/samples")
+    async def get_samples(
+        ds: Dataset = Depends(get_dataset),
+        offset: int = Query(0, ge=0),
+        limit: int = Query(100, ge=1, le=1000),
+        label: str | None = None,
+    ):
+        """Get paginated samples with thumbnails."""
+        samples, total = ds.get_samples_paginated(
+            offset=offset, limit=limit, label=label
+        )
+
+        return {
+            "total": total,
+            "offset": offset,
+            "limit": limit,
+            "samples": [s.to_api_dict(include_thumbnail=True) for s in samples],
+        }
+
+    @app.get("/api/samples/{sample_id}", response_model=SampleResponse)
+    async def get_sample(sample_id: str, ds: Dataset = Depends(get_dataset)):
+        """Get a single sample by ID."""
+        try:
+            sample = ds[sample_id]
+            return SampleResponse(**sample.to_api_dict())
+        except KeyError:
+            raise HTTPException(status_code=404, detail=f"Sample not found: {sample_id}")
+
+    @app.post("/api/samples/batch")
+    async def get_samples_batch(request: SelectionRequest, ds: Dataset = Depends(get_dataset)):
+        """Get multiple samples by their IDs."""
+        samples = ds.get_samples_by_ids(request.sample_ids)
+        return {"samples": [s.to_api_dict(include_thumbnail=True) for s in samples]}
+
+    @app.get("/api/embeddings", response_model=EmbeddingsResponse)
+    async def get_embeddings(ds: Dataset = Depends(get_dataset), layout_key: str | None = None):
+        """Get embedding coordinates for visualization."""
+        layouts = ds.list_layouts()
+        if not layouts:
+            raise HTTPException(
+                status_code=400, detail="No layouts computed. Call compute_visualization() first."
+            )
+
+        # Find the requested layout
+        layout_info = None
+        if layout_key is None:
+            layout_info = next(
+                (layout for layout in layouts if parse_layout_dimension(layout.layout_key) == 2),
+                layouts[0],
+            )
+            layout_key = layout_info.layout_key
+        else:
+            layout_info = next((layout for layout in layouts if layout.layout_key == layout_key), None)
+            if layout_info is None:
+                raise HTTPException(status_code=404, detail=f"Layout not found: {layout_key}")
+
+        ids, labels, coords = ds.get_visualization_data(layout_key)
+
+        if not ids:
+            raise HTTPException(status_code=400, detail=f"No data in layout '{layout_key}'.")
+
+        return EmbeddingsResponse(
+            layout_key=layout_key,
+            geometry=layout_info.geometry,
+            ids=ids,
+            labels=labels,
+            coords=coords.tolist(),
+        )
+
+    @app.get("/api/spaces")
+    async def get_spaces(ds: Dataset = Depends(get_dataset)):
+        """Get all embedding spaces."""
+        spaces = ds.list_spaces()
+        return {"spaces": [s.to_api_dict() for s in spaces]}
+
+    @app.get("/api/layouts")
+    async def get_layouts(ds: Dataset = Depends(get_dataset)):
+        """Get all available layouts."""
+        layouts = ds.list_layouts()
+        return {"layouts": [layout.to_api_dict() for layout in layouts]}
+
+    @app.post("/api/selection")
+    async def sync_selection(request: SelectionRequest):
+        """Sync selection state (for future use)."""
+        return {"status": "ok", "selected": request.sample_ids}
+
+    @app.post("/api/selection/lasso")
+    async def lasso_selection(request: LassoSelectionRequest, ds: Dataset = Depends(get_dataset)):
+        """Compute a lasso selection over the current embeddings.
+
+        Returns a total selected count and a paginated page of selected samples.
+
+                Selection modes:
+                - 2D layouts: polygon in data space (same coordinates as /api/embeddings).
+                - 3D layouts: polygon in screen space with explicit camera + viewport.
+        """
+        if request.offset < 0:
+            raise HTTPException(status_code=400, detail="offset must be >= 0")
+        if request.limit < 1 or request.limit > 2000:
+            raise HTTPException(status_code=400, detail="limit must be between 1 and 2000")
+
+        if len(request.polygon) < 6 or len(request.polygon) % 2 != 0:
+            raise HTTPException(
+                status_code=400,
+                detail="polygon must be an even-length list with at least 3 vertices",
+            )
+
+        layout_info = next(
+            (layout for layout in ds.list_layouts() if layout.layout_key == request.layout_key),
+            None,
+        )
+        if layout_info is None:
+            raise HTTPException(status_code=404, detail=f"Layout not found: {request.layout_key}")
+        layout_dimension = parse_layout_dimension(layout_info.layout_key)
+
+        poly = np.asarray(request.polygon, dtype=np.float32).reshape((-1, 2))
+        if not np.all(np.isfinite(poly)):
+            raise HTTPException(status_code=400, detail="polygon must contain only finite numbers")
+
+        selected_ids: list[str]
+
+        if layout_dimension == 2:
+            # Tight AABB prefilter in data space.
+            x_min = float(np.min(poly[:, 0]))
+            x_max = float(np.max(poly[:, 0]))
+            y_min = float(np.min(poly[:, 1]))
+            y_max = float(np.max(poly[:, 1]))
+
+            candidate_ids, candidate_coords = ds.get_lasso_candidates_aabb(
+                layout_key=request.layout_key,
+                x_min=x_min,
+                x_max=x_max,
+                y_min=y_min,
+                y_max=y_max,
+                label_filter=request.label_filter,
+            )
+
+            if candidate_coords.size == 0:
+                return {
+                    "total": 0,
+                    "offset": request.offset,
+                    "limit": request.limit,
+                    "sample_ids": [],
+                    "samples": [],
+                }
+
+            inside_mask = points_in_polygon(candidate_coords, poly)
+            if not np.any(inside_mask):
+                return {
+                    "total": 0,
+                    "offset": request.offset,
+                    "limit": request.limit,
+                    "sample_ids": [],
+                    "samples": [],
+                }
+
+            selected_ids = [candidate_ids[i] for i in np.flatnonzero(inside_mask)]
+        elif layout_dimension == 3:
+            if request.view_3d is None:
+                raise HTTPException(
+                    status_code=400,
+                    detail="view_3d is required for 3D lasso selection",
+                )
+            if request.viewport_width is None or request.viewport_height is None:
+                raise HTTPException(
+                    status_code=400,
+                    detail="viewport_width and viewport_height are required for 3D lasso selection",
+                )
+            if request.viewport_width <= 0 or request.viewport_height <= 0:
+                raise HTTPException(
+                    status_code=400,
+                    detail="viewport_width and viewport_height must be > 0",
+                )
+
+            try:
+                view_3d = OrbitViewState3D(**request.view_3d)
+            except Exception as exc:
+                raise HTTPException(status_code=400, detail=f"Invalid view_3d payload: {exc}")
+
+            view_vals = np.array(
+                [
+                    view_3d.yaw,
+                    view_3d.pitch,
+                    view_3d.distance,
+                    view_3d.target_x,
+                    view_3d.target_y,
+                    view_3d.target_z,
+                    view_3d.ortho_scale,
+                ],
+                dtype=np.float64,
+            )
+            if not np.all(np.isfinite(view_vals)):
+                raise HTTPException(status_code=400, detail="view_3d must contain only finite numbers")
+            if view_3d.distance <= 0 or view_3d.ortho_scale <= 0:
+                raise HTTPException(status_code=400, detail="view_3d.distance and view_3d.ortho_scale must be > 0")
+
+            ids, labels, coords = ds.get_visualization_data(request.layout_key)
+            if not ids:
+                return {
+                    "total": 0,
+                    "offset": request.offset,
+                    "limit": request.limit,
+                    "sample_ids": [],
+                    "samples": [],
+                }
+            if coords.ndim != 2 or coords.shape[1] != 3:
+                raise HTTPException(
+                    status_code=400,
+                    detail=(
+                        f"3D lasso requires a 3D layout coordinate matrix; "
+                        f"got shape {coords.shape} for layout '{request.layout_key}'."
+                    ),
+                )
+
+            finite_mask = np.all(np.isfinite(coords), axis=1)
+            if not np.all(finite_mask):
+                finite_indices = np.flatnonzero(finite_mask)
+                if finite_indices.size == 0:
+                    return {
+                        "total": 0,
+                        "offset": request.offset,
+                        "limit": request.limit,
+                        "sample_ids": [],
+                        "samples": [],
+                    }
+                ids = [ids[int(i)] for i in finite_indices]
+                labels = [labels[int(i)] for i in finite_indices]
+                coords = coords[finite_mask]
+
+            selected_ids = select_ids_for_3d_lasso(
+                ids=ids,
+                labels=labels,
+                coords=coords,
+                geometry=layout_info.geometry,
+                polygon=poly,
+                view=view_3d,
+                viewport_width=request.viewport_width,
+                viewport_height=request.viewport_height,
+                label_filter=request.label_filter,
+            )
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Unsupported layout dimension for lasso: {layout_dimension}D",
+            )
+
+        total = len(selected_ids)
+
+        start = int(request.offset)
+        end = int(request.offset + request.limit)
+        sample_ids = selected_ids[start:end]
+
+        samples = ds.get_samples_by_ids(sample_ids)
+        sample_dicts = [s.to_api_dict(include_thumbnail=request.include_thumbnails) for s in samples]
+
+        return {
+            "total": total,
+            "offset": request.offset,
+            "limit": request.limit,
+            "sample_ids": sample_ids,
+            "samples": sample_dicts,
+        }
+
+    @app.get("/api/search/similar/{sample_id}", response_model=SimilaritySearchResponse)
+    async def search_similar(
+        sample_id: str,
+        ds: Dataset = Depends(get_dataset),
+        k: int = Query(10, ge=1, le=100),
+        space_key: str | None = None,
+    ):
+        """Return k nearest neighbors for a given sample."""
+        try:
+            similar = ds.find_similar(
+                sample_id, k=k, space_key=space_key
+            )
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        except KeyError:
+            raise HTTPException(status_code=404, detail=f"Sample not found: {sample_id}")
+
+        results = []
+        for sample, distance in similar:
+            try:
+                thumbnail = sample.get_thumbnail_base64()
+            except Exception:
+                thumbnail = None
+
+            results.append(
+                SimilarSampleResponse(
+                    id=sample.id,
+                    filepath=sample.filepath,
+                    filename=sample.filename,
+                    label=sample.label,
+                    thumbnail=thumbnail,
+                    distance=distance,
+                    metadata=sample.metadata,
+                )
+            )
+
+        return SimilaritySearchResponse(
+            query_id=sample_id,
+            k=k,
+            results=results,
+        )
+
+    @app.get("/api/thumbnail/{sample_id}")
+    async def get_thumbnail(sample_id: str, ds: Dataset = Depends(get_dataset)):
+        """Get thumbnail image for a sample."""
+        try:
+            sample = ds[sample_id]
+            thumbnail_b64 = sample.get_thumbnail_base64()
+            return JSONResponse({"thumbnail": thumbnail_b64})
+        except KeyError:
+            raise HTTPException(status_code=404, detail=f"Sample not found: {sample_id}")
+
+    # Serve static frontend files
+    static_dir = Path(__file__).parent / "static"
+    if static_dir.exists():
+        app.mount("/", StaticFiles(directory=str(static_dir), html=True), name="static")
+    else:
+        # Fallback: serve a simple HTML page
+        @app.get("/")
+        async def root():
+            return {"message": "HyperView API", "docs": "/docs"}
+
+    return app
+
+
+def set_dataset(dataset: Dataset) -> None:
+    """Set the global dataset for the server."""
+    global _current_dataset
+    _current_dataset = dataset

vendor/hyperview/server/static/404.html

@@ -0,0 +1 @@
+<!DOCTYPE html><!--0EHglxORKBJP1WlpL6tAy--><html lang="en" class="h-full"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/><link rel="stylesheet" href="/_next/static/chunks/462c5e072cd14e02.css" data-precedence="next"/><link rel="preload" as="script" fetchPriority="low" href="/_next/static/chunks/86c1fc4cf542f408.js"/><script src="/_next/static/chunks/f29dd35a99c216ea.js" async=""></script><script src="/_next/static/chunks/567993cf36cd4ab1.js" async=""></script><script src="/_next/static/chunks/turbopack-cb59e03a04a579d1.js" async=""></script><script src="/_next/static/chunks/e954ba82c0a04100.js" async=""></script><meta name="robots" content="noindex"/><meta name="next-size-adjust" content=""/><title>404: This page could not be found.</title><title>HyperView</title><meta name="description" content="Dataset visualization with hyperbolic embeddings"/><script src="/_next/static/chunks/a6dad97d9634a72d.js" noModule=""></script></head><body class="inter_c50830d4-module__9YwRda__className antialiased h-full"><div hidden=""><!--$--><!--/$--></div><div style="font-family:system-ui,&quot;Segoe UI&quot;,Roboto,Helvetica,Arial,sans-serif,&quot;Apple Color Emoji&quot;,&quot;Segoe UI Emoji&quot;;height:100vh;text-align:center;display:flex;flex-direction:column;align-items:center;justify-content:center"><div><style>body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}</style><h1 class="next-error-h1" style="display:inline-block;margin:0 20px 0 0;padding:0 23px 0 0;font-size:24px;font-weight:500;vertical-align:top;line-height:49px">404</h1><div style="display:inline-block"><h2 style="font-size:14px;font-weight:400;line-height:49px;margin:0">This page could not be found.</h2></div></div></div><!--$--><!--/$--><script src="/_next/static/chunks/86c1fc4cf542f408.js" id="_R_" async=""></script><script>(self.__next_f=self.__next_f||[]).push([0])</script><script>self.__next_f.push([1,"1:\"$Sreact.fragment\"\n2:I[32035,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"default\"]\n3:I[91168,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"default\"]\n4:I[64381,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"OutletBoundary\"]\n5:\"$Sreact.suspense\"\n7:I[64381,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"ViewportBoundary\"]\n9:I[64381,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"MetadataBoundary\"]\nb:I[75115,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"default\"]\n:HL[\"/_next/static/chunks/462c5e072cd14e02.css\",\"style\"]\n"])</script><script>self.__next_f.push([1,"0:{\"P\":null,\"b\":\"0EHglxORKBJP1WlpL6tAy\",\"c\":[\"\",\"_not-found\",\"\"],\"q\":\"\",\"i\":false,\"f\":[[[\"\",{\"children\":[\"/_not-found\",{\"children\":[\"__PAGE__\",{}]}]},\"$undefined\",\"$undefined\",true],[[\"$\",\"$1\",\"c\",{\"children\":[[[\"$\",\"link\",\"0\",{\"rel\":\"stylesheet\",\"href\":\"/_next/static/chunks/462c5e072cd14e02.css\",\"precedence\":\"next\",\"crossOrigin\":\"$undefined\",\"nonce\":\"$undefined\"}],[\"$\",\"script\",\"script-0\",{\"src\":\"/_next/static/chunks/e954ba82c0a04100.js\",\"async\":true,\"nonce\":\"$undefined\"}]],[\"$\",\"html\",null,{\"lang\":\"en\",\"className\":\"h-full\",\"children\":[\"$\",\"body\",null,{\"className\":\"inter_c50830d4-module__9YwRda__className antialiased h-full\",\"children\":[\"$\",\"$L2\",null,{\"parallelRouterKey\":\"children\",\"error\":\"$undefined\",\"errorStyles\":\"$undefined\",\"errorScripts\":\"$undefined\",\"template\":[\"$\",\"$L3\",null,{}],\"templateStyles\":\"$undefined\",\"templateScripts\":\"$undefined\",\"notFound\":[[[\"$\",\"title\",null,{\"children\":\"404: This page could not be found.\"}],[\"$\",\"div\",null,{\"style\":{\"fontFamily\":\"system-ui,\\\"Segoe UI\\\",Roboto,Helvetica,Arial,sans-serif,\\\"Apple Color Emoji\\\",\\\"Segoe UI Emoji\\\"\",\"height\":\"100vh\",\"textAlign\":\"center\",\"display\":\"flex\",\"flexDirection\":\"column\",\"alignItems\":\"center\",\"justifyContent\":\"center\"},\"children\":[\"$\",\"div\",null,{\"children\":[[\"$\",\"style\",null,{\"dangerouslySetInnerHTML\":{\"__html\":\"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}\"}}],[\"$\",\"h1\",null,{\"className\":\"next-error-h1\",\"style\":{\"display\":\"inline-block\",\"margin\":\"0 20px 0 0\",\"padding\":\"0 23px 0 0\",\"fontSize\":24,\"fontWeight\":500,\"verticalAlign\":\"top\",\"lineHeight\":\"49px\"},\"children\":404}],[\"$\",\"div\",null,{\"style\":{\"display\":\"inline-block\"},\"children\":[\"$\",\"h2\",null,{\"style\":{\"fontSize\":14,\"fontWeight\":400,\"lineHeight\":\"49px\",\"margin\":0},\"children\":\"This page could not be found.\"}]}]]}]}]],[]],\"forbidden\":\"$undefined\",\"unauthorized\":\"$undefined\"}]}]}]]}],{\"children\":[[\"$\",\"$1\",\"c\",{\"children\":[null,[\"$\",\"$L2\",null,{\"parallelRouterKey\":\"children\",\"error\":\"$undefined\",\"errorStyles\":\"$undefined\",\"errorScripts\":\"$undefined\",\"template\":[\"$\",\"$L3\",null,{}],\"templateStyles\":\"$undefined\",\"templateScripts\":\"$undefined\",\"notFound\":\"$undefined\",\"forbidden\":\"$undefined\",\"unauthorized\":\"$undefined\"}]]}],{\"children\":[[\"$\",\"$1\",\"c\",{\"children\":[[[\"$\",\"title\",null,{\"children\":\"404: This page could not be found.\"}],[\"$\",\"div\",null,{\"style\":\"$0:f:0:1:0:props:children:1:props:children:props:children:props:notFound:0:1:props:style\",\"children\":[\"$\",\"div\",null,{\"children\":[[\"$\",\"style\",null,{\"dangerouslySetInnerHTML\":{\"__html\":\"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}\"}}],[\"$\",\"h1\",null,{\"className\":\"next-error-h1\",\"style\":\"$0:f:0:1:0:props:children:1:props:children:props:children:props:notFound:0:1:props:children:props:children:1:props:style\",\"children\":404}],[\"$\",\"div\",null,{\"style\":\"$0:f:0:1:0:props:children:1:props:children:props:children:props:notFound:0:1:props:children:props:children:2:props:style\",\"children\":[\"$\",\"h2\",null,{\"style\":\"$0:f:0:1:0:props:children:1:props:children:props:children:props:notFound:0:1:props:children:props:children:2:props:children:props:style\",\"children\":\"This page could not be found.\"}]}]]}]}]],null,[\"$\",\"$L4\",null,{\"children\":[\"$\",\"$5\",null,{\"name\":\"Next.MetadataOutlet\",\"children\":\"$@6\"}]}]]}],{},null,false,false]},null,false,false]},null,false,false],[\"$\",\"$1\",\"h\",{\"children\":[[\"$\",\"meta\",null,{\"name\":\"robots\",\"content\":\"noindex\"}],[\"$\",\"$L7\",null,{\"children\":\"$L8\"}],[\"$\",\"div\",null,{\"hidden\":true,\"children\":[\"$\",\"$L9\",null,{\"children\":[\"$\",\"$5\",null,{\"name\":\"Next.Metadata\",\"children\":\"$La\"}]}]}],[\"$\",\"meta\",null,{\"name\":\"next-size-adjust\",\"content\":\"\"}]]}],false]],\"m\":\"$undefined\",\"G\":[\"$b\",\"$undefined\"],\"S\":true}\n"])</script><script>self.__next_f.push([1,"8:[[\"$\",\"meta\",\"0\",{\"charSet\":\"utf-8\"}],[\"$\",\"meta\",\"1\",{\"name\":\"viewport\",\"content\":\"width=device-width, initial-scale=1\"}]]\n"])</script><script>self.__next_f.push([1,"6:null\na:[[\"$\",\"title\",\"0\",{\"children\":\"HyperView\"}],[\"$\",\"meta\",\"1\",{\"name\":\"description\",\"content\":\"Dataset visualization with hyperbolic embeddings\"}]]\n"])</script></body></html>

vendor/hyperview/server/static/404/index.html

@@ -0,0 +1 @@
+<!DOCTYPE html><!--0EHglxORKBJP1WlpL6tAy--><html lang="en" class="h-full"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/><link rel="stylesheet" href="/_next/static/chunks/462c5e072cd14e02.css" data-precedence="next"/><link rel="preload" as="script" fetchPriority="low" href="/_next/static/chunks/86c1fc4cf542f408.js"/><script src="/_next/static/chunks/f29dd35a99c216ea.js" async=""></script><script src="/_next/static/chunks/567993cf36cd4ab1.js" async=""></script><script src="/_next/static/chunks/turbopack-cb59e03a04a579d1.js" async=""></script><script src="/_next/static/chunks/e954ba82c0a04100.js" async=""></script><meta name="robots" content="noindex"/><meta name="next-size-adjust" content=""/><title>404: This page could not be found.</title><title>HyperView</title><meta name="description" content="Dataset visualization with hyperbolic embeddings"/><script src="/_next/static/chunks/a6dad97d9634a72d.js" noModule=""></script></head><body class="inter_c50830d4-module__9YwRda__className antialiased h-full"><div hidden=""><!--$--><!--/$--></div><div style="font-family:system-ui,&quot;Segoe UI&quot;,Roboto,Helvetica,Arial,sans-serif,&quot;Apple Color Emoji&quot;,&quot;Segoe UI Emoji&quot;;height:100vh;text-align:center;display:flex;flex-direction:column;align-items:center;justify-content:center"><div><style>body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}</style><h1 class="next-error-h1" style="display:inline-block;margin:0 20px 0 0;padding:0 23px 0 0;font-size:24px;font-weight:500;vertical-align:top;line-height:49px">404</h1><div style="display:inline-block"><h2 style="font-size:14px;font-weight:400;line-height:49px;margin:0">This page could not be found.</h2></div></div></div><!--$--><!--/$--><script src="/_next/static/chunks/86c1fc4cf542f408.js" id="_R_" async=""></script><script>(self.__next_f=self.__next_f||[]).push([0])</script><script>self.__next_f.push([1,"1:\"$Sreact.fragment\"\n2:I[32035,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"default\"]\n3:I[91168,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"default\"]\n4:I[64381,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"OutletBoundary\"]\n5:\"$Sreact.suspense\"\n7:I[64381,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"ViewportBoundary\"]\n9:I[64381,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"MetadataBoundary\"]\nb:I[75115,[\"/_next/static/chunks/e954ba82c0a04100.js\"],\"default\"]\n:HL[\"/_next/static/chunks/462c5e072cd14e02.css\",\"style\"]\n"])</script><script>self.__next_f.push([1,"0:{\"P\":null,\"b\":\"0EHglxORKBJP1WlpL6tAy\",\"c\":[\"\",\"_not-found\",\"\"],\"q\":\"\",\"i\":false,\"f\":[[[\"\",{\"children\":[\"/_not-found\",{\"children\":[\"__PAGE__\",{}]}]},\"$undefined\",\"$undefined\",true],[[\"$\",\"$1\",\"c\",{\"children\":[[[\"$\",\"link\",\"0\",{\"rel\":\"stylesheet\",\"href\":\"/_next/static/chunks/462c5e072cd14e02.css\",\"precedence\":\"next\",\"crossOrigin\":\"$undefined\",\"nonce\":\"$undefined\"}],[\"$\",\"script\",\"script-0\",{\"src\":\"/_next/static/chunks/e954ba82c0a04100.js\",\"async\":true,\"nonce\":\"$undefined\"}]],[\"$\",\"html\",null,{\"lang\":\"en\",\"className\":\"h-full\",\"children\":[\"$\",\"body\",null,{\"className\":\"inter_c50830d4-module__9YwRda__className antialiased h-full\",\"children\":[\"$\",\"$L2\",null,{\"parallelRouterKey\":\"children\",\"error\":\"$undefined\",\"errorStyles\":\"$undefined\",\"errorScripts\":\"$undefined\",\"template\":[\"$\",\"$L3\",null,{}],\"templateStyles\":\"$undefined\",\"templateScripts\":\"$undefined\",\"notFound\":[[[\"$\",\"title\",null,{\"children\":\"404: This page could not be found.\"}],[\"$\",\"div\",null,{\"style\":{\"fontFamily\":\"system-ui,\\\"Segoe UI\\\",Roboto,Helvetica,Arial,sans-serif,\\\"Apple Color Emoji\\\",\\\"Segoe UI Emoji\\\"\",\"height\":\"100vh\",\"textAlign\":\"center\",\"display\":\"flex\",\"flexDirection\":\"column\",\"alignItems\":\"center\",\"justifyContent\":\"center\"},\"children\":[\"$\",\"div\",null,{\"children\":[[\"$\",\"style\",null,{\"dangerouslySetInnerHTML\":{\"__html\":\"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}\"}}],[\"$\",\"h1\",null,{\"className\":\"next-error-h1\",\"style\":{\"display\":\"inline-block\",\"margin\":\"0 20px 0 0\",\"padding\":\"0 23px 0 0\",\"fontSize\":24,\"fontWeight\":500,\"verticalAlign\":\"top\",\"lineHeight\":\"49px\"},\"children\":404}],[\"$\",\"div\",null,{\"style\":{\"display\":\"inline-block\"},\"children\":[\"$\",\"h2\",null,{\"style\":{\"fontSize\":14,\"fontWeight\":400,\"lineHeight\":\"49px\",\"margin\":0},\"children\":\"This page could not be found.\"}]}]]}]}]],[]],\"forbidden\":\"$undefined\",\"unauthorized\":\"$undefined\"}]}]}]]}],{\"children\":[[\"$\",\"$1\",\"c\",{\"children\":[null,[\"$\",\"$L2\",null,{\"parallelRouterKey\":\"children\",\"error\":\"$undefined\",\"errorStyles\":\"$undefined\",\"errorScripts\":\"$undefined\",\"template\":[\"$\",\"$L3\",null,{}],\"templateStyles\":\"$undefined\",\"templateScripts\":\"$undefined\",\"notFound\":\"$undefined\",\"forbidden\":\"$undefined\",\"unauthorized\":\"$undefined\"}]]}],{\"children\":[[\"$\",\"$1\",\"c\",{\"children\":[[[\"$\",\"title\",null,{\"children\":\"404: This page could not be found.\"}],[\"$\",\"div\",null,{\"style\":\"$0:f:0:1:0:props:children:1:props:children:props:children:props:notFound:0:1:props:style\",\"children\":[\"$\",\"div\",null,{\"children\":[[\"$\",\"style\",null,{\"dangerouslySetInnerHTML\":{\"__html\":\"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}\"}}],[\"$\",\"h1\",null,{\"className\":\"next-error-h1\",\"style\":\"$0:f:0:1:0:props:children:1:props:children:props:children:props:notFound:0:1:props:children:props:children:1:props:style\",\"children\":404}],[\"$\",\"div\",null,{\"style\":\"$0:f:0:1:0:props:children:1:props:children:props:children:props:notFound:0:1:props:children:props:children:2:props:style\",\"children\":[\"$\",\"h2\",null,{\"style\":\"$0:f:0:1:0:props:children:1:props:children:props:children:props:notFound:0:1:props:children:props:children:2:props:children:props:style\",\"children\":\"This page could not be found.\"}]}]]}]}]],null,[\"$\",\"$L4\",null,{\"children\":[\"$\",\"$5\",null,{\"name\":\"Next.MetadataOutlet\",\"children\":\"$@6\"}]}]]}],{},null,false,false]},null,false,false]},null,false,false],[\"$\",\"$1\",\"h\",{\"children\":[[\"$\",\"meta\",null,{\"name\":\"robots\",\"content\":\"noindex\"}],[\"$\",\"$L7\",null,{\"children\":\"$L8\"}],[\"$\",\"div\",null,{\"hidden\":true,\"children\":[\"$\",\"$L9\",null,{\"children\":[\"$\",\"$5\",null,{\"name\":\"Next.Metadata\",\"children\":\"$La\"}]}]}],[\"$\",\"meta\",null,{\"name\":\"next-size-adjust\",\"content\":\"\"}]]}],false]],\"m\":\"$undefined\",\"G\":[\"$b\",\"$undefined\"],\"S\":true}\n"])</script><script>self.__next_f.push([1,"8:[[\"$\",\"meta\",\"0\",{\"charSet\":\"utf-8\"}],[\"$\",\"meta\",\"1\",{\"name\":\"viewport\",\"content\":\"width=device-width, initial-scale=1\"}]]\n"])</script><script>self.__next_f.push([1,"6:null\na:[[\"$\",\"title\",\"0\",{\"children\":\"HyperView\"}],[\"$\",\"meta\",\"1\",{\"name\":\"description\",\"content\":\"Dataset visualization with hyperbolic embeddings\"}]]\n"])</script></body></html>

vendor/hyperview/server/static/__next.__PAGE__.txt

@@ -0,0 +1,9 @@
+1:"$Sreact.fragment"
+2:I[73440,["/_next/static/chunks/e954ba82c0a04100.js"],"ClientPageRoot"]
+3:I[50912,["/_next/static/chunks/bdfca692596a10e2.js","/_next/static/chunks/8d5a2ef3447cb3ee.js"],"default"]
+6:I[64381,["/_next/static/chunks/e954ba82c0a04100.js"],"OutletBoundary"]
+7:"$Sreact.suspense"
+0:{"buildId":"0EHglxORKBJP1WlpL6tAy","rsc":["$","$1","c",{"children":[["$","$L2",null,{"Component":"$3","serverProvidedParams":{"searchParams":{},"params":{},"promises":["$@4","$@5"]}}],[["$","script","script-0",{"src":"/_next/static/chunks/bdfca692596a10e2.js","async":true}],["$","script","script-1",{"src":"/_next/static/chunks/8d5a2ef3447cb3ee.js","async":true}]],["$","$L6",null,{"children":["$","$7",null,{"name":"Next.MetadataOutlet","children":"$@8"}]}]]}],"loading":null,"isPartial":false}
+4:{}
+5:"$0:rsc:props:children:0:props:serverProvidedParams:params"
+8:null

vendor/hyperview/server/static/__next._full.txt

@@ -0,0 +1,18 @@
+1:"$Sreact.fragment"
+2:I[32035,["/_next/static/chunks/e954ba82c0a04100.js"],"default"]
+3:I[91168,["/_next/static/chunks/e954ba82c0a04100.js"],"default"]
+4:I[73440,["/_next/static/chunks/e954ba82c0a04100.js"],"ClientPageRoot"]
+5:I[50912,["/_next/static/chunks/bdfca692596a10e2.js","/_next/static/chunks/8d5a2ef3447cb3ee.js"],"default"]
+8:I[64381,["/_next/static/chunks/e954ba82c0a04100.js"],"OutletBoundary"]
+9:"$Sreact.suspense"
+b:I[64381,["/_next/static/chunks/e954ba82c0a04100.js"],"ViewportBoundary"]
+d:I[64381,["/_next/static/chunks/e954ba82c0a04100.js"],"MetadataBoundary"]
+f:I[75115,["/_next/static/chunks/e954ba82c0a04100.js"],"default"]
+:HL["/_next/static/chunks/462c5e072cd14e02.css","style"]
+:HL["/_next/static/media/83afe278b6a6bb3c-s.p.3a6ba036.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
+0:{"P":null,"b":"0EHglxORKBJP1WlpL6tAy","c":["",""],"q":"","i":false,"f":[[["",{"children":["__PAGE__",{}]},"$undefined","$undefined",true],[["$","$1","c",{"children":[[["$","link","0",{"rel":"stylesheet","href":"/_next/static/chunks/462c5e072cd14e02.css","precedence":"next","crossOrigin":"$undefined","nonce":"$undefined"}]],["$","html",null,{"lang":"en","className":"h-full","children":["$","body",null,{"className":"inter_c50830d4-module__9YwRda__className antialiased h-full","children":["$","$L2",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L3",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":[[["$","title",null,{"children":"404: This page could not be found."}],["$","div",null,{"style":{"fontFamily":"system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"","height":"100vh","textAlign":"center","display":"flex","flexDirection":"column","alignItems":"center","justifyContent":"center"},"children":["$","div",null,{"children":[["$","style",null,{"dangerouslySetInnerHTML":{"__html":"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"}}],["$","h1",null,{"className":"next-error-h1","style":{"display":"inline-block","margin":"0 20px 0 0","padding":"0 23px 0 0","fontSize":24,"fontWeight":500,"verticalAlign":"top","lineHeight":"49px"},"children":404}],["$","div",null,{"style":{"display":"inline-block"},"children":["$","h2",null,{"style":{"fontSize":14,"fontWeight":400,"lineHeight":"49px","margin":0},"children":"This page could not be found."}]}]]}]}]],[]],"forbidden":"$undefined","unauthorized":"$undefined"}]}]}]]}],{"children":[["$","$1","c",{"children":[["$","$L4",null,{"Component":"$5","serverProvidedParams":{"searchParams":{},"params":{},"promises":["$@6","$@7"]}}],[["$","script","script-0",{"src":"/_next/static/chunks/bdfca692596a10e2.js","async":true,"nonce":"$undefined"}],["$","script","script-1",{"src":"/_next/static/chunks/8d5a2ef3447cb3ee.js","async":true,"nonce":"$undefined"}]],["$","$L8",null,{"children":["$","$9",null,{"name":"Next.MetadataOutlet","children":"$@a"}]}]]}],{},null,false,false]},null,false,false],["$","$1","h",{"children":[null,["$","$Lb",null,{"children":"$Lc"}],["$","div",null,{"hidden":true,"children":["$","$Ld",null,{"children":["$","$9",null,{"name":"Next.Metadata","children":"$Le"}]}]}],["$","meta",null,{"name":"next-size-adjust","content":""}]]}],false]],"m":"$undefined","G":["$f",[]],"S":true}
+6:{}
+7:"$0:f:0:1:1:children:0:props:children:0:props:serverProvidedParams:params"
+c:[["$","meta","0",{"charSet":"utf-8"}],["$","meta","1",{"name":"viewport","content":"width=device-width, initial-scale=1"}]]
+a:null
+e:[["$","title","0",{"children":"HyperView"}],["$","meta","1",{"name":"description","content":"Dataset visualization with hyperbolic embeddings"}]]

vendor/hyperview/server/static/__next._head.txt

@@ -0,0 +1,5 @@
+1:"$Sreact.fragment"
+2:I[64381,["/_next/static/chunks/e954ba82c0a04100.js"],"ViewportBoundary"]
+3:I[64381,["/_next/static/chunks/e954ba82c0a04100.js"],"MetadataBoundary"]
+4:"$Sreact.suspense"
+0:{"buildId":"0EHglxORKBJP1WlpL6tAy","rsc":["$","$1","h",{"children":[null,["$","$L2",null,{"children":[["$","meta","0",{"charSet":"utf-8"}],["$","meta","1",{"name":"viewport","content":"width=device-width, initial-scale=1"}]]}],["$","div",null,{"hidden":true,"children":["$","$L3",null,{"children":["$","$4",null,{"name":"Next.Metadata","children":[["$","title","0",{"children":"HyperView"}],["$","meta","1",{"name":"description","content":"Dataset visualization with hyperbolic embeddings"}]]}]}]}],["$","meta",null,{"name":"next-size-adjust","content":""}]]}],"loading":null,"isPartial":false}

vendor/hyperview/server/static/__next._index.txt

@@ -0,0 +1,5 @@
+1:"$Sreact.fragment"
+2:I[32035,["/_next/static/chunks/e954ba82c0a04100.js"],"default"]
+3:I[91168,["/_next/static/chunks/e954ba82c0a04100.js"],"default"]
+:HL["/_next/static/chunks/462c5e072cd14e02.css","style"]
+0:{"buildId":"0EHglxORKBJP1WlpL6tAy","rsc":["$","$1","c",{"children":[[["$","link","0",{"rel":"stylesheet","href":"/_next/static/chunks/462c5e072cd14e02.css","precedence":"next"}]],["$","html",null,{"lang":"en","className":"h-full","children":["$","body",null,{"className":"inter_c50830d4-module__9YwRda__className antialiased h-full","children":["$","$L2",null,{"parallelRouterKey":"children","template":["$","$L3",null,{}],"notFound":[[["$","title",null,{"children":"404: This page could not be found."}],["$","div",null,{"style":{"fontFamily":"system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"","height":"100vh","textAlign":"center","display":"flex","flexDirection":"column","alignItems":"center","justifyContent":"center"},"children":["$","div",null,{"children":[["$","style",null,{"dangerouslySetInnerHTML":{"__html":"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"}}],["$","h1",null,{"className":"next-error-h1","style":{"display":"inline-block","margin":"0 20px 0 0","padding":"0 23px 0 0","fontSize":24,"fontWeight":500,"verticalAlign":"top","lineHeight":"49px"},"children":404}],["$","div",null,{"style":{"display":"inline-block"},"children":["$","h2",null,{"style":{"fontSize":14,"fontWeight":400,"lineHeight":"49px","margin":0},"children":"This page could not be found."}]}]]}]}]],[]]}]}]}]]}],"loading":null,"isPartial":false}

vendor/hyperview/server/static/__next._tree.txt

@@ -0,0 +1,3 @@
+:HL["/_next/static/chunks/462c5e072cd14e02.css","style"]
+:HL["/_next/static/media/83afe278b6a6bb3c-s.p.3a6ba036.woff2","font",{"crossOrigin":"","type":"font/woff2"}]
+0:{"buildId":"0EHglxORKBJP1WlpL6tAy","tree":{"name":"","paramType":null,"paramKey":"","hasRuntimePrefetch":false,"slots":{"children":{"name":"__PAGE__","paramType":null,"paramKey":"__PAGE__","hasRuntimePrefetch":false,"slots":null,"isRootLayout":false}},"isRootLayout":true},"staleTime":300}

vendor/hyperview/server/static/_next/static/0EHglxORKBJP1WlpL6tAy/_buildManifest.js

@@ -0,0 +1,15 @@
+self.__BUILD_MANIFEST = {
+  "__rewrites": {
+    "afterFiles": [
+      {
+        "source": "/api/:path*"
+      }
+    ],
+    "beforeFiles": [],
+    "fallback": []
+  },
+  "sortedPages": [
+    "/_app",
+    "/_error"
+  ]
+};self.__BUILD_MANIFEST_CB && self.__BUILD_MANIFEST_CB()

vendor/hyperview/server/static/_next/static/0EHglxORKBJP1WlpL6tAy/_clientMiddlewareManifest.json

@@ -0,0 +1 @@
+[]

vendor/hyperview/server/static/_next/static/0EHglxORKBJP1WlpL6tAy/_ssgManifest.js

@@ -0,0 +1 @@
+self.__SSG_MANIFEST=new Set([]);self.__SSG_MANIFEST_CB&&self.__SSG_MANIFEST_CB()

vendor/hyperview/server/static/_next/static/chunks/462c5e072cd14e02.css

@@ -0,0 +1,3 @@
+@font-face{font-family:Inter;font-style:normal;font-weight:400;font-display:swap;src:url(../media/2c55a0e60120577a-s.2a48534a.woff2)format("woff2");unicode-range:U+460-52F,U+1C80-1C8A,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F}@font-face{font-family:Inter;font-style:normal;font-weight:400;font-display:swap;src:url(../media/9c72aa0f40e4eef8-s.18a48cbc.woff2)format("woff2");unicode-range:U+301,U+400-45F,U+490-491,U+4B0-4B1,U+2116}@font-face{font-family:Inter;font-style:normal;font-weight:400;font-display:swap;src:url(../media/ad66f9afd8947f86-s.7a40eb73.woff2)format("woff2");unicode-range:U+1F??}@font-face{font-family:Inter;font-style:normal;font-weight:400;font-display:swap;src:url(../media/5476f68d60460930-s.c995e352.woff2)format("woff2");unicode-range:U+370-377,U+37A-37F,U+384-38A,U+38C,U+38E-3A1,U+3A3-3FF}@font-face{font-family:Inter;font-style:normal;font-weight:400;font-display:swap;src:url(../media/2bbe8d2671613f1f-s.76dcb0b2.woff2)format("woff2");unicode-range:U+102-103,U+110-111,U+128-129,U+168-169,U+1A0-1A1,U+1AF-1B0,U+300-301,U+303-304,U+308-309,U+323,U+329,U+1EA0-1EF9,U+20AB}@font-face{font-family:Inter;font-style:normal;font-weight:400;font-display:swap;src:url(../media/1bffadaabf893a1e-s.7cd81963.woff2)format("woff2");unicode-range:U+100-2BA,U+2BD-2C5,U+2C7-2CC,U+2CE-2D7,U+2DD-2FF,U+304,U+308,U+329,U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF}@font-face{font-family:Inter;font-style:normal;font-weight:400;font-display:swap;src:url(../media/83afe278b6a6bb3c-s.p.3a6ba036.woff2)format("woff2");unicode-range:U+??,U+131,U+152-153,U+2BB-2BC,U+2C6,U+2DA,U+2DC,U+304,U+308,U+329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD}@font-face{font-family:Inter;font-style:normal;font-weight:500;font-display:swap;src:url(../media/2c55a0e60120577a-s.2a48534a.woff2)format("woff2");unicode-range:U+460-52F,U+1C80-1C8A,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F}@font-face{font-family:Inter;font-style:normal;font-weight:500;font-display:swap;src:url(../media/9c72aa0f40e4eef8-s.18a48cbc.woff2)format("woff2");unicode-range:U+301,U+400-45F,U+490-491,U+4B0-4B1,U+2116}@font-face{font-family:Inter;font-style:normal;font-weight:500;font-display:swap;src:url(../media/ad66f9afd8947f86-s.7a40eb73.woff2)format("woff2");unicode-range:U+1F??}@font-face{font-family:Inter;font-style:normal;font-weight:500;font-display:swap;src:url(../media/5476f68d60460930-s.c995e352.woff2)format("woff2");unicode-range:U+370-377,U+37A-37F,U+384-38A,U+38C,U+38E-3A1,U+3A3-3FF}@font-face{font-family:Inter;font-style:normal;font-weight:500;font-display:swap;src:url(../media/2bbe8d2671613f1f-s.76dcb0b2.woff2)format("woff2");unicode-range:U+102-103,U+110-111,U+128-129,U+168-169,U+1A0-1A1,U+1AF-1B0,U+300-301,U+303-304,U+308-309,U+323,U+329,U+1EA0-1EF9,U+20AB}@font-face{font-family:Inter;font-style:normal;font-weight:500;font-display:swap;src:url(../media/1bffadaabf893a1e-s.7cd81963.woff2)format("woff2");unicode-range:U+100-2BA,U+2BD-2C5,U+2C7-2CC,U+2CE-2D7,U+2DD-2FF,U+304,U+308,U+329,U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF}@font-face{font-family:Inter;font-style:normal;font-weight:500;font-display:swap;src:url(../media/83afe278b6a6bb3c-s.p.3a6ba036.woff2)format("woff2");unicode-range:U+??,U+131,U+152-153,U+2BB-2BC,U+2C6,U+2DA,U+2DC,U+304,U+308,U+329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD}@font-face{font-family:Inter Fallback;src:local(Arial);ascent-override:90.44%;descent-override:22.52%;line-gap-override:0.0%;size-adjust:107.12%}.inter_c50830d4-module__9YwRda__className{font-family:Inter,Inter Fallback;font-style:normal}
+.dv-scrollable{position:relative;overflow:hidden}.dv-scrollable .dv-scrollbar-horizontal{will-change:background-color,transform;backface-visibility:hidden;background-color:#0000;border-radius:2px;height:4px;transition:background-color 1s ease-in-out;position:absolute;bottom:0;left:0;transform:translate(0,0)}.dv-scrollable:hover .dv-scrollbar-horizontal,.dv-scrollable.dv-scrollable-resizing .dv-scrollbar-horizontal,.dv-scrollable.dv-scrollable-scrolling .dv-scrollbar-horizontal{background-color:var(--dv-scrollbar-background-color,#ffffff40)}.dv-svg{fill:currentColor;stroke:currentColor;stroke-width:0;line-height:1;display:inline-block}.dockview-theme-dark{--dv-paneview-active-outline-color:dodgerblue;--dv-tabs-and-actions-container-font-size:13px;--dv-tabs-and-actions-container-height:35px;--dv-drag-over-background-color:#53595d80;--dv-drag-over-border-color:transparent;--dv-tabs-container-scrollbar-color:#888;--dv-icon-hover-background-color:#5a5d5e4f;--dv-floating-box-shadow:8px 8px 8px 0px #53595d80;--dv-overlay-z-index:999;--dv-tab-font-size:inherit;--dv-border-radius:0px;--dv-tab-margin:0;--dv-sash-color:transparent;--dv-active-sash-color:transparent;--dv-active-sash-transition-duration:.1s;--dv-active-sash-transition-delay:.5s;--dv-group-view-background-color:#1e1e1e;--dv-tabs-and-actions-container-background-color:#252526;--dv-activegroup-visiblepanel-tab-background-color:#1e1e1e;--dv-activegroup-hiddenpanel-tab-background-color:#2d2d2d;--dv-inactivegroup-visiblepanel-tab-background-color:#1e1e1e;--dv-inactivegroup-hiddenpanel-tab-background-color:#2d2d2d;--dv-tab-divider-color:#1e1e1e;--dv-activegroup-visiblepanel-tab-color:white;--dv-activegroup-hiddenpanel-tab-color:#969696;--dv-inactivegroup-visiblepanel-tab-color:#8f8f8f;--dv-inactivegroup-hiddenpanel-tab-color:#626262;--dv-separator-border:#444;--dv-paneview-header-border-color:#ccc3}.dockview-theme-dark .dv-drop-target-container .dv-drop-target-anchor.dv-drop-target-anchor-container-changed{opacity:0;transition:none}.dockview-theme-light{--dv-paneview-active-outline-color:dodgerblue;--dv-tabs-and-actions-container-font-size:13px;--dv-tabs-and-actions-container-height:35px;--dv-drag-over-background-color:#53595d80;--dv-drag-over-border-color:transparent;--dv-tabs-container-scrollbar-color:#888;--dv-icon-hover-background-color:#5a5d5e4f;--dv-floating-box-shadow:8px 8px 8px 0px #53595d80;--dv-overlay-z-index:999;--dv-tab-font-size:inherit;--dv-border-radius:0px;--dv-tab-margin:0;--dv-sash-color:transparent;--dv-active-sash-color:transparent;--dv-active-sash-transition-duration:.1s;--dv-active-sash-transition-delay:.5s;--dv-group-view-background-color:white;--dv-tabs-and-actions-container-background-color:#f3f3f3;--dv-activegroup-visiblepanel-tab-background-color:white;--dv-activegroup-hiddenpanel-tab-background-color:#ececec;--dv-inactivegroup-visiblepanel-tab-background-color:white;--dv-inactivegroup-hiddenpanel-tab-background-color:#ececec;--dv-tab-divider-color:white;--dv-activegroup-visiblepanel-tab-color:#333;--dv-activegroup-hiddenpanel-tab-color:#333333b3;--dv-inactivegroup-visiblepanel-tab-color:#333333b3;--dv-inactivegroup-hiddenpanel-tab-color:#33333359;--dv-separator-border:#80808059;--dv-paneview-header-border-color:#333;--dv-scrollbar-background-color:#00000040}.dockview-theme-light .dv-drop-target-container .dv-drop-target-anchor.dv-drop-target-anchor-container-changed{opacity:0;transition:none}.dockview-theme-vs{--dv-paneview-active-outline-color:dodgerblue;--dv-drag-over-background-color:#53595d80;--dv-drag-over-border-color:transparent;--dv-tabs-container-scrollbar-color:#888;--dv-icon-hover-background-color:#5a5d5e4f;--dv-floating-box-shadow:8px 8px 8px 0px #53595d80;--dv-overlay-z-index:999;--dv-tab-font-size:inherit;--dv-border-radius:0px;--dv-tab-margin:0;--dv-sash-color:transparent;--dv-active-sash-color:transparent;--dv-active-sash-transition-duration:.1s;--dv-active-sash-transition-delay:.5s;--dv-group-view-background-color:#1e1e1e;--dv-tabs-and-actions-container-background-color:#2d2d30;--dv-activegroup-visiblepanel-tab-background-color:#007acc;--dv-activegroup-hiddenpanel-tab-background-color:#2d2d2d;--dv-inactivegroup-visiblepanel-tab-background-color:#3f3f46;--dv-inactivegroup-hiddenpanel-tab-background-color:#2d2d2d;--dv-tab-divider-color:#1e1e1e;--dv-activegroup-hiddenpanel-tab-color:white;--dv-inactivegroup-visiblepanel-tab-color:white;--dv-inactivegroup-hiddenpanel-tab-color:white;--dv-separator-border:#444;--dv-paneview-header-border-color:#ccc3;--dv-tabs-and-actions-container-height:20px;--dv-tabs-and-actions-container-font-size:11px;--dv-activegroup-visiblepanel-tab-color:white}.dockview-theme-vs .dv-drop-target-container .dv-drop-target-anchor.dv-drop-target-anchor-container-changed{opacity:0;transition:none}.dockview-theme-vs .dv-groupview.dv-active-group>.dv-tabs-and-actions-container{box-sizing:content-box;border-bottom:2px solid var(--dv-activegroup-visiblepanel-tab-background-color)}.dockview-theme-vs .dv-groupview.dv-active-group>.dv-tabs-and-actions-container .dv-tab.dv-active-tab{border-top:2px solid var(--dv-activegroup-visiblepanel-tab-background-color)}.dockview-theme-vs .dv-groupview.dv-active-group>.dv-tabs-and-actions-container .dv-tab.dv-inactive-tab{border-top:2px solid var(--dv-activegroup-hiddenpanel-tab-background-color)}.dockview-theme-vs .dv-groupview.dv-inactive-group>.dv-tabs-and-actions-container{box-sizing:content-box;border-bottom:2px solid var(--dv-inactivegroup-visiblepanel-tab-background-color)}.dockview-theme-vs .dv-groupview.dv-inactive-group>.dv-tabs-and-actions-container .dv-tab.dv-active-tab{border-top:2px solid var(--dv-inactivegroup-visiblepanel-tab-background-color)}.dockview-theme-vs .dv-groupview.dv-inactive-group>.dv-tabs-and-actions-container .dv-tab.dv-inactive-tab{border-top:2px solid var(--dv-inactivegroup-hiddenpanel-tab-background-color)}.dockview-theme-abyss{--dv-paneview-active-outline-color:#596f99;--dv-tabs-and-actions-container-font-size:13px;--dv-tabs-and-actions-container-height:35px;--dv-drag-over-background-color:#53595d80;--dv-drag-over-border-color:transparent;--dv-tabs-container-scrollbar-color:#888;--dv-icon-hover-background-color:#5a5d5e4f;--dv-floating-box-shadow:8px 8px 8px 0px #53595d80;--dv-overlay-z-index:999;--dv-tab-font-size:inherit;--dv-border-radius:0px;--dv-tab-margin:0;--dv-sash-color:transparent;--dv-active-sash-color:transparent;--dv-active-sash-transition-duration:.1s;--dv-active-sash-transition-delay:.5s;--dv-color-abyss-dark:#000c18;--dv-color-abyss:#10192c;--dv-color-abyss-light:#1c1c2a;--dv-color-abyss-lighter:#2b2b4a;--dv-color-abyss-accent:#5b1ecf;--dv-color-abyss-primary-text:white;--dv-color-abyss-secondary-text:#9497a9;--dv-group-view-background-color:var(--dv-color-abyss-dark);--dv-tabs-and-actions-container-background-color:var(--dv-color-abyss-light);--dv-activegroup-visiblepanel-tab-background-color:var(--dv-color-abyss-dark);--dv-activegroup-hiddenpanel-tab-background-color:var(--dv-color-abyss);--dv-inactivegroup-visiblepanel-tab-background-color:var(--dv-color-abyss-dark);--dv-inactivegroup-hiddenpanel-tab-background-color:var(--dv-color-abyss);--dv-tab-divider-color:var(--dv-color-abyss-lighter);--dv-activegroup-visiblepanel-tab-color:white;--dv-activegroup-hiddenpanel-tab-color:#ffffff80;--dv-inactivegroup-visiblepanel-tab-color:#ffffff80;--dv-inactivegroup-hiddenpanel-tab-color:#ffffff40;--dv-separator-border:var(--dv-color-abyss-lighter);--dv-paneview-header-border-color:var(--dv-color-abyss-lighter)}.dockview-theme-abyss .dv-drop-target-container .dv-drop-target-anchor.dv-drop-target-anchor-container-changed{opacity:0;transition:none}.dockview-theme-dracula{--dv-paneview-active-outline-color:#6272a4;--dv-tabs-and-actions-container-font-size:13px;--dv-tabs-and-actions-container-height:35px;--dv-drag-over-background-color:#53595d80;--dv-drag-over-border-color:transparent;--dv-tabs-container-scrollbar-color:#888;--dv-icon-hover-background-color:#5a5d5e4f;--dv-floating-box-shadow:8px 8px 8px 0px #53595d80;--dv-overlay-z-index:999;--dv-tab-font-size:inherit;--dv-border-radius:0px;--dv-tab-margin:0;--dv-sash-color:transparent;--dv-active-sash-color:transparent;--dv-active-sash-transition-duration:.1s;--dv-active-sash-transition-delay:.5s;--dv-group-view-background-color:#282a36;--dv-tabs-and-actions-container-background-color:#191a21;--dv-activegroup-visiblepanel-tab-background-color:#282a36;--dv-activegroup-hiddenpanel-tab-background-color:#21222c;--dv-inactivegroup-visiblepanel-tab-background-color:#282a36;--dv-inactivegroup-hiddenpanel-tab-background-color:#21222c;--dv-tab-divider-color:#191a21;--dv-activegroup-visiblepanel-tab-color:#f8f8f2;--dv-activegroup-hiddenpanel-tab-color:#6272a4;--dv-inactivegroup-visiblepanel-tab-color:#f8f8f280;--dv-inactivegroup-hiddenpanel-tab-color:#6272a480;--dv-separator-border:#bd93f9;--dv-paneview-header-border-color:#bd93f9}.dockview-theme-dracula .dv-drop-target-container .dv-drop-target-anchor.dv-drop-target-anchor-container-changed{opacity:0;transition:none}.dockview-theme-dracula .dv-groupview.dv-active-group>.dv-tabs-and-actions-container .dv-tabs-container>.dv-tab.dv-active-tab{position:relative}.dockview-theme-dracula .dv-groupview.dv-active-group>.dv-tabs-and-actions-container .dv-tabs-container>.dv-tab.dv-active-tab:after{content:"";z-index:999;background-color:#94527e;width:100%;height:1px;position:absolute;top:0;left:0}.dockview-theme-dracula .dv-groupview.dv-inactive-group>.dv-tabs-and-actions-container .dv-tabs-container>.dv-tab.dv-active-tab{position:relative}.dockview-theme-dracula .dv-groupview.dv-inactive-group>.dv-tabs-and-actions-container .dv-tabs-container>.dv-tab.dv-active-tab:after{content:"";z-index:999;background-color:#5e3d5a;width:100%;height:1px;position:absolute;bottom:0;left:0}.dockview-theme-replit{--dv-paneview-active-outline-color:dodgerblue;--dv-tabs-and-actions-container-font-size:13px;--dv-tabs-and-actions-container-height:35px;--dv-drag-over-background-color:#53595d80;--dv-drag-over-border-color:transparent;--dv-tabs-container-scrollbar-color:#888;--dv-icon-hover-background-color:#5a5d5e4f;--dv-floating-box-shadow:8px 8px 8px 0px #53595d80;--dv-overlay-z-index:999;--dv-tab-font-size:inherit;--dv-border-radius:0px;--dv-tab-margin:0;--dv-sash-color:#cfd1d3;--dv-active-sash-color:#babbbb;--dv-active-sash-transition-duration:.1s;--dv-active-sash-transition-delay:.5s;box-sizing:border-box;--dv-group-view-background-color:#ebeced;--dv-tabs-and-actions-container-background-color:#fcfcfc;--dv-activegroup-visiblepanel-tab-background-color:#f0f1f2;--dv-activegroup-hiddenpanel-tab-background-color:#fcfcfc;--dv-inactivegroup-visiblepanel-tab-background-color:#f0f1f2;--dv-inactivegroup-hiddenpanel-tab-background-color:#fcfcfc;--dv-tab-divider-color:transparent;--dv-activegroup-visiblepanel-tab-color:#333;--dv-activegroup-hiddenpanel-tab-color:#333;--dv-inactivegroup-visiblepanel-tab-color:#333;--dv-inactivegroup-hiddenpanel-tab-color:#333;--dv-separator-border:transparent;--dv-paneview-header-border-color:#333;background-color:#ebeced;padding:10px}.dockview-theme-replit .dv-drop-target-container .dv-drop-target-anchor.dv-drop-target-anchor-container-changed{opacity:0;transition:none}.dockview-theme-replit .dv-resize-container:has(>.dv-groupview){border-radius:8px}.dockview-theme-replit .dv-resize-container{border:none;border-radius:10px!important}.dockview-theme-replit .dv-groupview{border-radius:10px;overflow:hidden}.dockview-theme-replit .dv-groupview .dv-tabs-and-actions-container{border-bottom:1px solid #80808059}.dockview-theme-replit .dv-groupview .dv-tabs-and-actions-container .dv-tab{border-radius:8px;margin:4px}.dockview-theme-replit .dv-groupview .dv-tabs-and-actions-container .dv-tab .dv-svg{width:8px;height:8px}.dockview-theme-replit .dv-groupview .dv-tabs-and-actions-container .dv-tab:hover{background-color:#e4e5e6!important}.dockview-theme-replit .dv-groupview .dv-content-container{background-color:#fcfcfc}.dockview-theme-replit .dv-groupview.dv-active-group{border:1px solid #80808059}.dockview-theme-replit .dv-groupview.dv-inactive-group{border:1px solid #0000}.dockview-theme-replit .dv-vertical>.dv-sash-container>.dv-sash{background-color:#0000}.dockview-theme-replit .dv-vertical>.dv-sash-container>.dv-sash:not(.disabled):after{content:"";background-color:var(--dv-sash-color);border-radius:2px;width:40px;height:4px;position:absolute;top:50%;left:50%;transform:translate(-50%,-50%)}.dockview-theme-replit .dv-vertical>.dv-sash-container>.dv-sash:not(.disabled):hover,.dockview-theme-replit .dv-vertical>.dv-sash-container>.dv-sash:not(.disabled):active{background-color:#0000}.dockview-theme-replit .dv-vertical>.dv-sash-container>.dv-sash:not(.disabled):hover:after,.dockview-theme-replit .dv-vertical>.dv-sash-container>.dv-sash:not(.disabled):active:after{background-color:var(--dv-active-sash-color)}.dockview-theme-replit .dv-horizontal>.dv-sash-container>.dv-sash{background-color:#0000}.dockview-theme-replit .dv-horizontal>.dv-sash-container>.dv-sash:not(.disabled):after{content:"";background-color:var(--dv-sash-color);border-radius:2px;width:4px;height:40px;position:absolute;top:50%;left:50%;transform:translate(-50%,-50%)}.dockview-theme-replit .dv-horizontal>.dv-sash-container>.dv-sash:not(.disabled):hover,.dockview-theme-replit .dv-horizontal>.dv-sash-container>.dv-sash:not(.disabled):active{background-color:#0000}.dockview-theme-replit .dv-horizontal>.dv-sash-container>.dv-sash:not(.disabled):hover:after,.dockview-theme-replit .dv-horizontal>.dv-sash-container>.dv-sash:not(.disabled):active:after{background-color:var(--dv-active-sash-color)}.dockview-theme-abyss-spaced{--dv-paneview-active-outline-color:dodgerblue;--dv-tabs-and-actions-container-font-size:13px;--dv-drag-over-background-color:"";--dv-drag-over-border-color:transparent;--dv-tabs-container-scrollbar-color:#888;--dv-icon-hover-background-color:#5a5d5e4f;--dv-floating-box-shadow:8px 8px 8px 0px #00000080;--dv-overlay-z-index:999;--dv-tab-font-size:12px;--dv-tab-margin:.5rem .25rem;--dv-sash-color:transparent;--dv-active-sash-color:var(--dv-color-abyss-accent);--dv-active-sash-transition-duration:.1s;--dv-active-sash-transition-delay:.5s;--dv-tabs-and-actions-container-height:44px;--dv-border-radius:20px;box-sizing:border-box;--dv-color-abyss-dark:#0b0611;--dv-color-abyss:#16121f;--dv-color-abyss-light:#201d2b;--dv-color-abyss-lighter:#2a2837;--dv-color-abyss-accent:#5b1ecf;--dv-color-abyss-primary-text:white;--dv-color-abyss-secondary-text:#9497a9;--dv-drag-over-border:2px solid var(--dv-color-abyss-accent);--dv-group-view-background-color:var(--dv-color-abyss-dark);--dv-tabs-and-actions-container-background-color:var(--dv-color-abyss);--dv-activegroup-visiblepanel-tab-background-color:var(--dv-color-abyss-lighter);--dv-activegroup-hiddenpanel-tab-background-color:var(--dv-color-abyss-light);--dv-inactivegroup-visiblepanel-tab-background-color:var(--dv-color-abyss-lighter);--dv-inactivegroup-hiddenpanel-tab-background-color:var(--dv-color-abyss-light);--dv-tab-divider-color:transparent;--dv-activegroup-visiblepanel-tab-color:var(--dv-color-abyss-primary-text);--dv-activegroup-hiddenpanel-tab-color:var(--dv-color-abyss-secondary-text);--dv-inactivegroup-visiblepanel-tab-color:var(--dv-color-abyss-primary-text);--dv-inactivegroup-hiddenpanel-tab-color:var(--dv-color-abyss-secondary-text);--dv-separator-border:transparent;--dv-paneview-header-border-color:#333;background-color:var(--dv-color-abyss-dark);padding:10px}.dockview-theme-abyss-spaced .dv-resize-container:has(>.dv-groupview){border-radius:8px}.dockview-theme-abyss-spaced .dv-sash{border-radius:4px}.dockview-theme-abyss-spaced .dv-drop-target-anchor{border-radius:calc(var(--dv-border-radius)/4)}.dockview-theme-abyss-spaced .dv-drop-target-anchor.dv-drop-target-content{border-radius:var(--dv-border-radius)}.dockview-theme-abyss-spaced .dv-resize-container{border:none;border-radius:var(--dv-border-radius)!important}.dockview-theme-abyss-spaced .dv-tabs-overflow-container,.dockview-theme-abyss-spaced .dv-tabs-overflow-dropdown-default{border-radius:8px;height:unset!important}.dockview-theme-abyss-spaced .dv-tab{border-radius:8px}.dockview-theme-abyss-spaced .dv-tab .dv-svg{width:8px;height:8px}.dockview-theme-abyss-spaced .dv-groupview{border-radius:var(--dv-border-radius)}.dockview-theme-abyss-spaced .dv-groupview .dv-tabs-and-actions-container{padding:0px calc(var(--dv-border-radius)/2)}.dockview-theme-abyss-spaced .dv-groupview .dv-content-container{background-color:var(--dv-tabs-and-actions-container-background-color)}.dockview-theme-abyss-spaced .dv-resize-container .dv-groupview{border:2px solid var(--dv-color-abyss-dark)}.dockview-theme-light-spaced{--dv-paneview-active-outline-color:dodgerblue;--dv-tabs-and-actions-container-font-size:13px;--dv-drag-over-background-color:"";--dv-drag-over-border-color:transparent;--dv-tabs-container-scrollbar-color:#888;--dv-icon-hover-background-color:#5a5d5e4f;--dv-floating-box-shadow:8px 8px 8px 0px #0000001a;--dv-overlay-z-index:999;--dv-tab-font-size:12px;--dv-tab-margin:.5rem .25rem;--dv-sash-color:transparent;--dv-active-sash-color:#5b1ecf;--dv-active-sash-transition-duration:.1s;--dv-active-sash-transition-delay:.5s;--dv-tabs-and-actions-container-height:44px;--dv-border-radius:20px;box-sizing:border-box;--dv-drag-over-border:2px solid #5b1ecf;--dv-group-view-background-color:#f6f5f9;--dv-tabs-and-actions-container-background-color:white;--dv-activegroup-visiblepanel-tab-background-color:#ededf0;--dv-activegroup-hiddenpanel-tab-background-color:#f9f9fa;--dv-inactivegroup-visiblepanel-tab-background-color:#ededf0;--dv-inactivegroup-hiddenpanel-tab-background-color:#f9f9fa;--dv-tab-divider-color:transparent;--dv-activegroup-visiblepanel-tab-color:#686b82;--dv-activegroup-hiddenpanel-tab-color:#9497a9;--dv-inactivegroup-visiblepanel-tab-color:#686b82;--dv-inactivegroup-hiddenpanel-tab-color:#9497a9;--dv-separator-border:transparent;--dv-paneview-header-border-color:#333;--dv-scrollbar-background-color:#00000040;background-color:#f6f5f9;padding:10px}.dockview-theme-light-spaced .dv-resize-container:has(>.dv-groupview){border-radius:8px}.dockview-theme-light-spaced .dv-sash{border-radius:4px}.dockview-theme-light-spaced .dv-drop-target-anchor{border-radius:calc(var(--dv-border-radius)/4)}.dockview-theme-light-spaced .dv-drop-target-anchor.dv-drop-target-content{border-radius:var(--dv-border-radius)}.dockview-theme-light-spaced .dv-resize-container{border:none;border-radius:var(--dv-border-radius)!important}.dockview-theme-light-spaced .dv-tabs-overflow-container,.dockview-theme-light-spaced .dv-tabs-overflow-dropdown-default{border-radius:8px;height:unset!important}.dockview-theme-light-spaced .dv-tab{border-radius:8px}.dockview-theme-light-spaced .dv-tab .dv-svg{width:8px;height:8px}.dockview-theme-light-spaced .dv-groupview{border-radius:var(--dv-border-radius)}.dockview-theme-light-spaced .dv-groupview .dv-tabs-and-actions-container{padding:0px calc(var(--dv-border-radius)/2)}.dockview-theme-light-spaced .dv-groupview .dv-content-container{background-color:var(--dv-tabs-and-actions-container-background-color)}.dockview-theme-light-spaced .dv-resize-container .dv-groupview{border:2px solid #ffffff1a}.dv-drop-target-container{z-index:9999;pointer-events:none;--dv-transition-duration:.3s;width:100%;height:100%;position:absolute;top:0;left:0;overflow:hidden}.dv-drop-target-container .dv-drop-target-anchor{border:var(--dv-drag-over-border);background-color:var(--dv-drag-over-background-color);opacity:1;will-change:transform,opacity;backface-visibility:hidden;contain:layout paint;transition:opacity var(--dv-transition-duration)ease-in,transform var(--dv-transition-duration)ease-out;position:relative;transform:translate(0,0)}.dv-drop-target{--dv-transition-duration:70ms;position:relative}.dv-drop-target>.dv-drop-target-dropzone{z-index:1000;pointer-events:none;width:100%;height:100%;position:absolute;top:0;left:0}.dv-drop-target>.dv-drop-target-dropzone>.dv-drop-target-selection{box-sizing:border-box;border:var(--dv-drag-over-border);background-color:var(--dv-drag-over-background-color);width:100%;height:100%;transition:top var(--dv-transition-duration)ease-out,left var(--dv-transition-duration)ease-out,width var(--dv-transition-duration)ease-out,height var(--dv-transition-duration)ease-out,opacity var(--dv-transition-duration)ease-out;will-change:transform;pointer-events:none;position:relative}.dv-drop-target>.dv-drop-target-dropzone>.dv-drop-target-selection.dv-drop-target-top.dv-drop-target-small-vertical{border-top:1px solid var(--dv-drag-over-border-color)}.dv-drop-target>.dv-drop-target-dropzone>.dv-drop-target-selection.dv-drop-target-bottom.dv-drop-target-small-vertical{border-bottom:1px solid var(--dv-drag-over-border-color)}.dv-drop-target>.dv-drop-target-dropzone>.dv-drop-target-selection.dv-drop-target-left.dv-drop-target-small-horizontal{border-left:1px solid var(--dv-drag-over-border-color)}.dv-drop-target>.dv-drop-target-dropzone>.dv-drop-target-selection.dv-drop-target-right.dv-drop-target-small-horizontal{border-right:1px solid var(--dv-drag-over-border-color)}.dv-dockview{background-color:var(--dv-group-view-background-color);contain:layout;position:relative}.dv-dockview .dv-watermark-container{z-index:1;width:100%;height:100%;position:absolute;top:0;left:0}.dv-dockview .dv-overlay-render-container{position:relative}.dv-groupview.dv-active-group>.dv-tabs-and-actions-container .dv-tabs-container>.dv-tab.dv-active-tab{background-color:var(--dv-activegroup-visiblepanel-tab-background-color);color:var(--dv-activegroup-visiblepanel-tab-color)}.dv-groupview.dv-active-group>.dv-tabs-and-actions-container .dv-tabs-container>.dv-tab.dv-inactive-tab{background-color:var(--dv-activegroup-hiddenpanel-tab-background-color);color:var(--dv-activegroup-hiddenpanel-tab-color)}.dv-groupview.dv-inactive-group>.dv-tabs-and-actions-container .dv-tabs-container>.dv-tab.dv-active-tab{background-color:var(--dv-inactivegroup-visiblepanel-tab-background-color);color:var(--dv-inactivegroup-visiblepanel-tab-color)}.dv-groupview.dv-inactive-group>.dv-tabs-and-actions-container .dv-tabs-container>.dv-tab.dv-inactive-tab{background-color:var(--dv-inactivegroup-hiddenpanel-tab-background-color);color:var(--dv-inactivegroup-hiddenpanel-tab-color)}.dv-tab.dv-tab-dragging{background-color:var(--dv-activegroup-visiblepanel-tab-background-color);color:var(--dv-activegroup-visiblepanel-tab-color)}.dv-groupview{background-color:var(--dv-group-view-background-color);flex-direction:column;height:100%;display:flex;overflow:hidden}.dv-groupview:focus{outline:none}.dv-groupview>.dv-content-container{outline:none;flex-grow:1;min-height:0}.dv-root-wrapper,.dv-grid-view,.dv-branch-node{width:100%;height:100%}.dv-debug .dv-resize-container .dv-resize-handle-top{background-color:red}.dv-debug .dv-resize-container .dv-resize-handle-bottom{background-color:green}.dv-debug .dv-resize-container .dv-resize-handle-left{background-color:#ff0}.dv-debug .dv-resize-container .dv-resize-handle-right{background-color:#00f}.dv-debug .dv-resize-container .dv-resize-handle-topleft,.dv-debug .dv-resize-container .dv-resize-handle-topright,.dv-debug .dv-resize-container .dv-resize-handle-bottomleft,.dv-debug .dv-resize-container .dv-resize-handle-bottomright{background-color:#0ff}.dv-resize-container{--dv-overlay-z-index:var(--dv-overlay-z-index,999);z-index:calc(var(--dv-overlay-z-index) - 2);border:1px solid var(--dv-tab-divider-color);box-shadow:var(--dv-floating-box-shadow);will-change:transform,opacity;backface-visibility:hidden;position:absolute;transform:translate(0,0)}.dv-resize-container.dv-hidden{display:none}.dv-resize-container.dv-resize-container-dragging{opacity:.5;will-change:transform,opacity}.dv-resize-container .dv-resize-handle-top{width:calc(100% - 8px);height:4px;z-index:var(--dv-overlay-z-index);cursor:ns-resize;position:absolute;top:-2px;left:4px}.dv-resize-container .dv-resize-handle-bottom{width:calc(100% - 8px);height:4px;z-index:var(--dv-overlay-z-index);cursor:ns-resize;position:absolute;bottom:-2px;left:4px}.dv-resize-container .dv-resize-handle-left{width:4px;height:calc(100% - 8px);z-index:var(--dv-overlay-z-index);cursor:ew-resize;position:absolute;top:4px;left:-2px}.dv-resize-container .dv-resize-handle-right{width:4px;height:calc(100% - 8px);z-index:var(--dv-overlay-z-index);cursor:ew-resize;position:absolute;top:4px;right:-2px}.dv-resize-container .dv-resize-handle-topleft{width:4px;height:4px;z-index:var(--dv-overlay-z-index);cursor:nw-resize;position:absolute;top:-2px;left:-2px}.dv-resize-container .dv-resize-handle-topright{width:4px;height:4px;z-index:var(--dv-overlay-z-index);cursor:ne-resize;position:absolute;top:-2px;right:-2px}.dv-resize-container .dv-resize-handle-bottomleft{width:4px;height:4px;z-index:var(--dv-overlay-z-index);cursor:sw-resize;position:absolute;bottom:-2px;left:-2px}.dv-resize-container .dv-resize-handle-bottomright{width:4px;height:4px;z-index:var(--dv-overlay-z-index);cursor:se-resize;position:absolute;bottom:-2px;right:-2px}.dv-render-overlay{--dv-overlay-z-index:var(--dv-overlay-z-index,999);z-index:1;contain:layout paint;isolation:isolate;will-change:transform;backface-visibility:hidden;width:100%;height:100%;position:absolute;transform:translate(0,0)}.dv-render-overlay.dv-render-overlay-float{z-index:calc(var(--dv-overlay-z-index) - 1)}.dv-debug .dv-render-overlay{outline-offset:-1;outline:1px solid red}.dv-pane-container{width:100%;height:100%}.dv-pane-container.dv-animated .dv-view{will-change:transform;backface-visibility:hidden;transition:transform .15s ease-out;transform:translate(0,0)}.dv-pane-container .dv-view{flex-direction:column;display:flex;overflow:hidden;padding:0!important}.dv-pane-container .dv-view:not(:first-child):before{background-color:#0000!important}.dv-pane-container .dv-view:not(:first-child) .dv-pane>.dv-pane-header{border-top:1px solid var(--dv-paneview-header-border-color)}.dv-pane-container .dv-view .dv-default-header{background-color:var(--dv-group-view-background-color);color:var(--dv-activegroup-visiblepanel-tab-color);cursor:pointer;padding:0 8px;display:flex}.dv-pane-container .dv-view .dv-default-header .dv-pane-header-icon{justify-content:center;align-items:center;display:flex}.dv-pane-container .dv-view .dv-default-header>span{flex-grow:1;padding-left:8px}.dv-pane-container:first-of-type>.dv-pane>.dv-pane-header{border-top:none!important}.dv-pane-container .dv-pane{flex-direction:column;height:100%;display:flex;overflow:hidden}.dv-pane-container .dv-pane .dv-pane-header{box-sizing:border-box;-webkit-user-select:none;user-select:none;outline:none;position:relative}.dv-pane-container .dv-pane .dv-pane-header.dv-pane-draggable{cursor:pointer}.dv-pane-container .dv-pane .dv-pane-header:focus:before,.dv-pane-container .dv-pane .dv-pane-header:focus-within:before{z-index:5;content:"";pointer-events:none;outline-offset:-1px;outline:-1px solid;outline-color:var(--dv-paneview-active-outline-color);width:100%;height:100%;position:absolute;top:0;left:0}.dv-pane-container .dv-pane .dv-pane-body{outline:none;flex-grow:1;position:relative;overflow:hidden auto}.dv-pane-container .dv-pane .dv-pane-body:focus:before,.dv-pane-container .dv-pane .dv-pane-body:focus-within:before{z-index:5;content:"";pointer-events:none;outline-offset:-1px;outline:-1px solid;outline-color:var(--dv-paneview-active-outline-color);width:100%;height:100%;position:absolute;top:0;left:0}.dv-debug .dv-split-view-container .dv-sash-container .dv-sash.dv-enabled{background-color:#000}.dv-debug .dv-split-view-container .dv-sash-container .dv-sash.dv-disabled{background-color:orange}.dv-debug .dv-split-view-container .dv-sash-container .dv-sash.dv-maximum{background-color:green}.dv-debug .dv-split-view-container .dv-sash-container .dv-sash.dv-minimum{background-color:red}.dv-split-view-container{width:100%;height:100%;position:relative;overflow:hidden}.dv-split-view-container.dv-splitview-disabled>.dv-sash-container>.dv-sash{pointer-events:none}.dv-split-view-container.dv-animation .dv-view,.dv-split-view-container.dv-animation .dv-sash{will-change:transform;backface-visibility:hidden;transition:transform .15s ease-out;transform:translate(0,0)}.dv-split-view-container.dv-horizontal{height:100%}.dv-split-view-container.dv-horizontal>.dv-sash-container>.dv-sash{width:4px;height:100%}.dv-split-view-container.dv-horizontal>.dv-sash-container>.dv-sash.dv-enabled{cursor:ew-resize}.dv-split-view-container.dv-horizontal>.dv-sash-container>.dv-sash.dv-disabled{cursor:default}.dv-split-view-container.dv-horizontal>.dv-sash-container>.dv-sash.dv-maximum{cursor:w-resize}.dv-split-view-container.dv-horizontal>.dv-sash-container>.dv-sash.dv-minimum{cursor:e-resize}.dv-split-view-container.dv-horizontal>.dv-view-container>.dv-view:not(:first-child):before{width:1px;height:100%}.dv-split-view-container.dv-vertical{width:100%}.dv-split-view-container.dv-vertical>.dv-sash-container>.dv-sash{width:100%;height:4px}.dv-split-view-container.dv-vertical>.dv-sash-container>.dv-sash.dv-enabled{cursor:ns-resize}.dv-split-view-container.dv-vertical>.dv-sash-container>.dv-sash.dv-disabled{cursor:default}.dv-split-view-container.dv-vertical>.dv-sash-container>.dv-sash.dv-maximum{cursor:n-resize}.dv-split-view-container.dv-vertical>.dv-sash-container>.dv-sash.dv-minimum{cursor:s-resize}.dv-split-view-container.dv-vertical>.dv-view-container>.dv-view{width:100%}.dv-split-view-container.dv-vertical>.dv-view-container>.dv-view:not(:first-child):before{width:100%;height:1px}.dv-split-view-container .dv-sash-container{width:100%;height:100%;position:absolute}.dv-split-view-container .dv-sash-container .dv-sash{z-index:99;-webkit-user-select:none;user-select:none;touch-action:none;background-color:var(--dv-sash-color,transparent);outline:none;position:absolute}.dv-split-view-container .dv-sash-container .dv-sash:not(.disabled):active,.dv-split-view-container .dv-sash-container .dv-sash:not(.disabled):hover{background-color:var(--dv-active-sash-color,transparent);transition-property:background-color;transition-timing-function:ease-in-out;transition-duration:var(--dv-active-sash-transition-duration,.1s);transition-delay:var(--dv-active-sash-transition-delay,.5s)}.dv-split-view-container .dv-view-container{width:100%;height:100%;position:relative}.dv-split-view-container .dv-view-container .dv-view{box-sizing:border-box;height:100%;position:absolute;overflow:auto}.dv-split-view-container.dv-separator-border .dv-view:not(:first-child):before{content:" ";z-index:5;pointer-events:none;background-color:var(--dv-separator-border);position:absolute;top:0;left:0}.dv-dragged{transform:translate(0,0)}.dv-tab{flex-shrink:0}.dv-tab:focus-within,.dv-tab:focus{position:relative}.dv-tab:focus-within:after,.dv-tab:focus:after{content:"";pointer-events:none;outline-offset:-1px;z-index:5;width:100%;height:100%;position:absolute;top:0;left:0;outline:1px solid var(--dv-tab-divider-color)!important}.dv-tab.dv-tab-dragging .dv-default-tab-action{background-color:var(--dv-activegroup-visiblepanel-tab-color)}.dv-tab.dv-active-tab .dv-default-tab .dv-default-tab-action{visibility:visible}.dv-tab.dv-inactive-tab .dv-default-tab .dv-default-tab-action{visibility:hidden}.dv-tab.dv-inactive-tab .dv-default-tab:hover .dv-default-tab-action{visibility:visible}.dv-tab .dv-default-tab{white-space:nowrap;text-overflow:ellipsis;align-items:center;height:100%;display:flex;position:relative}.dv-tab .dv-default-tab .dv-default-tab-content{flex-grow:1;margin-right:4px}.dv-tab .dv-default-tab .dv-default-tab-action{box-sizing:border-box;justify-content:center;align-items:center;padding:4px;display:flex}.dv-tab .dv-default-tab .dv-default-tab-action:hover{background-color:var(--dv-icon-hover-background-color);border-radius:2px}.dv-tabs-overflow-dropdown-default{height:100%;color:var(--dv-activegroup-hiddenpanel-tab-color);margin:var(--dv-tab-margin);cursor:pointer;flex-shrink:0;align-items:center;padding:.25rem .5rem;display:flex}.dv-tabs-overflow-dropdown-default>span{padding-left:.25rem}.dv-tabs-overflow-dropdown-default>svg{transform:rotate(90deg)}.dv-tabs-container{scrollbar-width:thin;will-change:scroll-position;height:100%;display:flex;overflow:auto;transform:translate(0,0)}.dv-tabs-container.dv-horizontal .dv-tab:not(:first-child):before{content:" ";z-index:5;pointer-events:none;background-color:var(--dv-tab-divider-color);width:1px;height:100%;position:absolute;top:0;left:0}.dv-tabs-container::-webkit-scrollbar{height:3px}.dv-tabs-container::-webkit-scrollbar-track{background:0 0}.dv-tabs-container::-webkit-scrollbar-thumb{background:var(--dv-tabs-container-scrollbar-color)}.dv-scrollable>.dv-tabs-container{overflow:hidden}.dv-tab{-webkit-user-drag:element;cursor:pointer;box-sizing:border-box;font-size:var(--dv-tab-font-size);margin:var(--dv-tab-margin);outline:none;padding:.25rem .5rem;position:relative}.dv-tabs-overflow-container{height:unset;border:1px solid var(--dv-tab-divider-color);background-color:var(--dv-group-view-background-color);flex-direction:column}.dv-tabs-overflow-container .dv-tab:not(:last-child){border-bottom:1px solid var(--dv-tab-divider-color)}.dv-tabs-overflow-container .dv-active-tab{background-color:var(--dv-activegroup-visiblepanel-tab-background-color);color:var(--dv-activegroup-visiblepanel-tab-color)}.dv-tabs-overflow-container .dv-inactive-tab{background-color:var(--dv-activegroup-hiddenpanel-tab-background-color);color:var(--dv-activegroup-hiddenpanel-tab-color)}.dv-tabs-and-actions-container{background-color:var(--dv-tabs-and-actions-container-background-color);box-sizing:border-box;height:var(--dv-tabs-and-actions-container-height);font-size:var(--dv-tabs-and-actions-container-font-size);flex-shrink:0;display:flex}.dv-tabs-and-actions-container.dv-single-tab.dv-full-width-single-tab .dv-scrollable,.dv-tabs-and-actions-container.dv-single-tab.dv-full-width-single-tab .dv-tabs-container{flex-grow:1}.dv-tabs-and-actions-container.dv-single-tab.dv-full-width-single-tab .dv-tabs-container .dv-tab{flex-grow:1;padding:0}.dv-tabs-and-actions-container.dv-single-tab.dv-full-width-single-tab .dv-void-container{flex-grow:0}.dv-tabs-and-actions-container .dv-void-container{flex-grow:1;display:flex}.dv-tabs-and-actions-container .dv-void-container.dv-draggable{cursor:grab}.dv-tabs-and-actions-container .dv-right-actions-container{display:flex}.dv-watermark{height:100%;display:flex}
+*,:before,:after,::backdrop{--tw-border-spacing-x:0;--tw-border-spacing-y:0;--tw-translate-x:0;--tw-translate-y:0;--tw-rotate:0;--tw-skew-x:0;--tw-skew-y:0;--tw-scale-x:1;--tw-scale-y:1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness:proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-color:#3b82f680;--tw-ring-offset-shadow:0 0 #0000;--tw-ring-shadow:0 0 #0000;--tw-shadow:0 0 #0000;--tw-shadow-colored:0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }*,:before,:after{box-sizing:border-box;border:0 solid #e5e7eb}:before,:after{--tw-content:""}html,:host{-webkit-text-size-adjust:100%;tab-size:4;font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent;font-family:ui-sans-serif,system-ui,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol,Noto Color Emoji;line-height:1.5}body{line-height:inherit;margin:0}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-feature-settings:normal;font-variation-settings:normal;font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-feature-settings:inherit;font-variation-settings:inherit;font-family:inherit;font-size:100%;font-weight:inherit;line-height:inherit;letter-spacing:inherit;color:inherit;margin:0;padding:0}button,select{text-transform:none}button,input:where([type=button]),input:where([type=reset]),input:where([type=submit]){-webkit-appearance:button;background-color:#0000;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dl,dd,h1,h2,h3,h4,h5,h6,hr,figure,p,pre{margin:0}fieldset{margin:0;padding:0}legend{padding:0}ol,ul,menu{margin:0;padding:0;list-style:none}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder{opacity:1;color:#9ca3af}textarea::-moz-placeholder{opacity:1;color:#9ca3af}input::placeholder,textarea::placeholder{opacity:1;color:#9ca3af}button,[role=button]{cursor:pointer}:disabled{cursor:default}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}[hidden]:where(:not([hidden=until-found])){display:none}html,body{height:100%;margin:0;padding:0;overflow:hidden}:root{--background:215 28% 7%;--foreground:213 27% 92%;--card:215 21% 11%;--card-foreground:213 27% 92%;--popover:215 21% 11%;--popover-foreground:213 27% 92%;--primary:212 100% 67%;--primary-foreground:215 28% 7%;--secondary:215 14% 17%;--secondary-foreground:213 27% 92%;--muted:215 14% 17%;--muted-foreground:213 12% 58%;--accent:215 14% 17%;--accent-foreground:213 27% 92%;--destructive:0 62% 50%;--destructive-foreground:0 0% 98%;--border:215 14% 22%;--input:215 14% 22%;--ring:212 100% 67%;--radius:.375rem;--surface:215 21% 11%;--surface-light:215 14% 17%;--surface-elevated:215 14% 22%;--border-subtle:215 14% 17%;--text:213 27% 92%;--text-muted:213 12% 58%;--text-subtle:215 10% 46%;--accent-cyan:176 60% 53%;--accent-orange:27 86% 59%}*{border-color:hsl(var(--border))}body{background-color:hsl(var(--background));color:hsl(var(--foreground));letter-spacing:-.15px;font-feature-settings:"liga" 1,"calt" 1;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale;font-size:12px;font-weight:500;line-height:16px}.\!container{width:100%!important}.container{width:100%}@media (min-width:640px){.\!container{max-width:640px!important}.container{max-width:640px}}@media (min-width:768px){.\!container{max-width:768px!important}.container{max-width:768px}}@media (min-width:1024px){.\!container{max-width:1024px!important}.container{max-width:1024px}}@media (min-width:1280px){.\!container{max-width:1280px!important}.container{max-width:1280px}}@media (min-width:1536px){.\!container{max-width:1536px!important}.container{max-width:1536px}}.sr-only{clip:rect(0,0,0,0);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.pointer-events-none{pointer-events:none}.visible{visibility:visible}.static{position:static}.fixed{position:fixed}.absolute{position:absolute}.relative{position:relative}.inset-0{inset:0}.bottom-0\.5{bottom:.125rem}.left-0\.5{left:.125rem}.left-1\.5{left:.375rem}.left-\[50\%\]{left:50%}.right-0\.5{right:.125rem}.right-3{right:.75rem}.right-4{right:1rem}.top-0\.5{top:.125rem}.top-3{top:.75rem}.top-4{top:1rem}.top-\[50\%\]{top:50%}.z-10{z-index:10}.z-50{z-index:50}.-mx-1{margin-left:-.25rem;margin-right:-.25rem}.mx-1{margin-left:.25rem;margin-right:.25rem}.mx-auto{margin-left:auto;margin-right:auto}.my-0\.5{margin-top:.125rem;margin-bottom:.125rem}.mb-2{margin-bottom:.5rem}.mb-4{margin-bottom:1rem}.ml-0\.5{margin-left:.125rem}.ml-1{margin-left:.25rem}.ml-2{margin-left:.5rem}.ml-auto{margin-left:auto}.mr-2{margin-right:.5rem}.mt-4{margin-top:1rem}.inline-block{display:inline-block}.inline{display:inline}.flex{display:flex}.inline-flex{display:inline-flex}.grid{display:grid}.hidden{display:none}.h-10{height:2.5rem}.h-12{height:3rem}.h-16{height:4rem}.h-2{height:.5rem}.h-2\.5{height:.625rem}.h-3{height:.75rem}.h-3\.5{height:.875rem}.h-4{height:1rem}.h-5{height:1.25rem}.h-6{height:1.5rem}.h-7{height:1.75rem}.h-8{height:2rem}.h-9{height:2.25rem}.h-\[10px\]{height:10px}.h-\[1px\]{height:1px}.h-full{height:100%}.h-px{height:1px}.h-screen{height:100vh}.max-h-\[300px\]{max-height:300px}.max-h-\[var\(--radix-dropdown-menu-content-available-height\)\]{max-height:var(--radix-dropdown-menu-content-available-height)}.min-h-0{min-height:0}.min-h-\[24px\]{min-height:24px}.min-h-\[28px\]{min-height:28px}.w-12{width:3rem}.w-16{width:4rem}.w-2{width:.5rem}.w-2\.5{width:.625rem}.w-3{width:.75rem}.w-3\.5{width:.875rem}.w-4{width:1rem}.w-48{width:12rem}.w-5{width:1.25rem}.w-6{width:1.5rem}.w-72{width:18rem}.w-8{width:2rem}.w-9{width:2.25rem}.w-\[10px\]{width:10px}.w-\[1px\]{width:1px}.w-\[280px\]{width:280px}.w-\[600px\]{width:600px}.w-full{width:100%}.w-px{width:1px}.min-w-0{min-width:0}.min-w-10{min-width:2.5rem}.min-w-8{min-width:2rem}.min-w-9{min-width:2.25rem}.min-w-\[10rem\]{min-width:10rem}.min-w-\[220px\]{min-width:220px}.min-w-\[240px\]{min-width:240px}.max-w-\[220px\]{max-width:220px}.max-w-\[260px\]{max-width:260px}.max-w-\[340px\]{max-width:340px}.max-w-\[60vw\]{max-width:60vw}.max-w-full{max-width:100%}.max-w-lg{max-width:32rem}.max-w-md{max-width:28rem}.flex-1{flex:1}.flex-shrink-0,.shrink-0{flex-shrink:0}.origin-\[--radix-dropdown-menu-content-transform-origin\]{transform-origin:var(--radix-dropdown-menu-content-transform-origin)}.origin-\[--radix-popover-content-transform-origin\]{transform-origin:var(--radix-popover-content-transform-origin)}.origin-\[--radix-tooltip-content-transform-origin\]{transform-origin:var(--radix-tooltip-content-transform-origin)}.translate-x-\[-50\%\]{--tw-translate-x:-50%;transform:translate(var(--tw-translate-x),var(--tw-translate-y))rotate(var(--tw-rotate))skewX(var(--tw-skew-x))skewY(var(--tw-skew-y))scaleX(var(--tw-scale-x))scaleY(var(--tw-scale-y))}.translate-y-\[-50\%\]{--tw-translate-y:-50%;transform:translate(var(--tw-translate-x),var(--tw-translate-y))rotate(var(--tw-rotate))skewX(var(--tw-skew-x))skewY(var(--tw-skew-y))scaleX(var(--tw-scale-x))scaleY(var(--tw-scale-y))}.transform{transform:translate(var(--tw-translate-x),var(--tw-translate-y))rotate(var(--tw-rotate))skewX(var(--tw-skew-x))skewY(var(--tw-skew-y))scaleX(var(--tw-scale-x))scaleY(var(--tw-scale-y))}@keyframes spin{to{transform:rotate(360deg)}}.animate-spin{animation:1s linear infinite spin}.cursor-default{cursor:default}.cursor-pointer{cursor:pointer}.touch-none{touch-action:none}.select-none{-webkit-user-select:none;user-select:none}.resize{resize:both}.flex-col{flex-direction:column}.flex-col-reverse{flex-direction:column-reverse}.items-center{align-items:center}.justify-start{justify-content:flex-start}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-0\.5{gap:.125rem}.gap-1{gap:.25rem}.gap-1\.5{gap:.375rem}.gap-2{gap:.5rem}.gap-4{gap:1rem}.space-y-1\.5>:not([hidden])~:not([hidden]){--tw-space-y-reverse:0;margin-top:calc(.375rem*calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.375rem*var(--tw-space-y-reverse))}.space-y-px>:not([hidden])~:not([hidden]){--tw-space-y-reverse:0;margin-top:calc(1px*calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1px*var(--tw-space-y-reverse))}.overflow-auto{overflow:auto}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-y-auto{overflow-y:auto}.overflow-x-hidden{overflow-x:hidden}.truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.whitespace-nowrap{white-space:nowrap}.rounded{border-radius:.25rem}.rounded-\[3px\]{border-radius:3px}.rounded-\[inherit\]{border-radius:inherit}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:var(--radius)}.rounded-md{border-radius:calc(var(--radius) - 2px)}.rounded-sm{border-radius:calc(var(--radius) - 4px)}.border{border-width:1px}.border-2{border-width:2px}.border-b{border-bottom-width:1px}.border-l{border-left-width:1px}.border-t{border-top-width:1px}.border-border{border-color:hsl(var(--border))}.border-border\/50{border-color:hsl(var(--border)/.5)}.border-input{border-color:hsl(var(--input))}.border-primary{border-color:hsl(var(--primary))}.border-l-transparent{border-left-color:#0000}.border-t-transparent{border-top-color:#0000}.bg-background{background-color:hsl(var(--background))}.bg-black\/80{background-color:#000c}.bg-border{background-color:hsl(var(--border))}.bg-border\/80{background-color:hsl(var(--border)/.8)}.bg-card{background-color:hsl(var(--card))}.bg-card\/80{background-color:hsl(var(--card)/.8)}.bg-card\/85{background-color:hsl(var(--card)/.85)}.bg-destructive{background-color:hsl(var(--destructive))}.bg-muted{background-color:hsl(var(--muted))}.bg-muted-foreground\/25{background-color:hsl(var(--muted-foreground)/.25)}.bg-muted\/40{background-color:hsl(var(--muted)/.4)}.bg-muted\/50{background-color:hsl(var(--muted)/.5)}.bg-muted\/60{background-color:hsl(var(--muted)/.6)}.bg-popover{background-color:hsl(var(--popover))}.bg-primary{background-color:hsl(var(--primary))}.bg-secondary{background-color:hsl(var(--secondary))}.bg-secondary\/20{background-color:hsl(var(--secondary)/.2)}.bg-transparent{background-color:#0000}.fill-current{fill:currentColor}.object-cover{-o-object-fit:cover;object-fit:cover}.p-0{padding:0}.p-1{padding:.25rem}.p-1\.5{padding:.375rem}.p-4{padding:1rem}.p-6{padding:1.5rem}.p-\[2px\]{padding:2px}.px-1{padding-left:.25rem;padding-right:.25rem}.px-1\.5{padding-left:.375rem;padding-right:.375rem}.px-2{padding-left:.5rem;padding-right:.5rem}.px-2\.5{padding-left:.625rem;padding-right:.625rem}.px-3{padding-left:.75rem;padding-right:.75rem}.px-4{padding-left:1rem;padding-right:1rem}.px-8{padding-left:2rem;padding-right:2rem}.py-0{padding-top:0;padding-bottom:0}.py-0\.5{padding-top:.125rem;padding-bottom:.125rem}.py-1{padding-top:.25rem;padding-bottom:.25rem}.py-1\.5{padding-top:.375rem;padding-bottom:.375rem}.py-2{padding-top:.5rem;padding-bottom:.5rem}.py-3{padding-top:.75rem;padding-bottom:.75rem}.py-4{padding-top:1rem;padding-bottom:1rem}.py-6{padding-top:1.5rem;padding-bottom:1.5rem}.pl-6{padding-left:1.5rem}.pl-8{padding-left:2rem}.pr-1\.5{padding-right:.375rem}.pt-0{padding-top:0}.text-left{text-align:left}.text-center{text-align:center}.font-mono{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace}.text-\[10px\]{font-size:10px}.text-\[11px\]{font-size:11px}.text-\[12px\]{font-size:12px}.text-lg{font-size:1.125rem;line-height:1.75rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xs{font-size:.75rem;line-height:1rem}.font-medium{font-weight:500}.font-normal{font-weight:400}.font-semibold{font-weight:600}.uppercase{text-transform:uppercase}.tabular-nums{--tw-numeric-spacing:tabular-nums;font-variant-numeric:var(--tw-ordinal)var(--tw-slashed-zero)var(--tw-numeric-figure)var(--tw-numeric-spacing)var(--tw-numeric-fraction)}.leading-4{line-height:1rem}.leading-\[16px\]{line-height:16px}.leading-none{line-height:1}.leading-tight{line-height:1.25}.tracking-\[-0\.15px\]{letter-spacing:-.15px}.tracking-\[0\.06em\]{letter-spacing:.06em}.tracking-tight{letter-spacing:-.025em}.tracking-widest{letter-spacing:.1em}.text-destructive{color:hsl(var(--destructive))}.text-destructive-foreground{color:hsl(var(--destructive-foreground))}.text-foreground{color:hsl(var(--foreground))}.text-foreground\/70{color:hsl(var(--foreground)/.7)}.text-muted-foreground{color:hsl(var(--muted-foreground))}.text-muted-foreground\/20{color:hsl(var(--muted-foreground)/.2)}.text-muted-foreground\/50{color:hsl(var(--muted-foreground)/.5)}.text-muted-foreground\/60{color:hsl(var(--muted-foreground)/.6)}.text-muted-foreground\/70{color:hsl(var(--muted-foreground)/.7)}.text-popover-foreground{color:hsl(var(--popover-foreground))}.text-primary{color:hsl(var(--primary))}.text-primary-foreground{color:hsl(var(--primary-foreground))}.text-secondary-foreground{color:hsl(var(--secondary-foreground))}.text-white{--tw-text-opacity:1;color:rgb(255 255 255/var(--tw-text-opacity,1))}.underline-offset-4{text-underline-offset:4px}.antialiased{-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.opacity-40{opacity:.4}.opacity-50{opacity:.5}.opacity-70{opacity:.7}.shadow{--tw-shadow:0 1px 3px 0 #0000001a,0 1px 2px -1px #0000001a;--tw-shadow-colored:0 1px 3px 0 var(--tw-shadow-color),0 1px 2px -1px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.shadow-lg{--tw-shadow:0 10px 15px -3px #0000001a,0 4px 6px -4px #0000001a;--tw-shadow-colored:0 10px 15px -3px var(--tw-shadow-color),0 4px 6px -4px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.shadow-md{--tw-shadow:0 4px 6px -1px #0000001a,0 2px 4px -2px #0000001a;--tw-shadow-colored:0 4px 6px -1px var(--tw-shadow-color),0 2px 4px -2px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.shadow-sm{--tw-shadow:0 1px 2px 0 #0000000d;--tw-shadow-colored:0 1px 2px 0 var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow,0 0 #0000),var(--tw-ring-shadow,0 0 #0000),var(--tw-shadow)}.outline-none{outline-offset:2px;outline:2px solid #0000}.outline{outline-style:solid}.ring-2{--tw-ring-offset-shadow:var(--tw-ring-inset)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color);--tw-ring-shadow:var(--tw-ring-inset)0 0 0 calc(2px + var(--tw-ring-offset-width))var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow,0 0 #0000)}.ring-inset{--tw-ring-inset:inset}.ring-primary{--tw-ring-color:hsl(var(--primary))}.ring-primary\/50{--tw-ring-color:hsl(var(--primary)/.5)}.ring-offset-background{--tw-ring-offset-color:hsl(var(--background))}.filter{filter:var(--tw-blur)var(--tw-brightness)var(--tw-contrast)var(--tw-grayscale)var(--tw-hue-rotate)var(--tw-invert)var(--tw-saturate)var(--tw-sepia)var(--tw-drop-shadow)}.transition-colors{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-duration:.15s;transition-timing-function:cubic-bezier(.4,0,.2,1)}.transition-opacity{transition-property:opacity;transition-duration:.15s;transition-timing-function:cubic-bezier(.4,0,.2,1)}.transition-shadow{transition-property:box-shadow;transition-duration:.15s;transition-timing-function:cubic-bezier(.4,0,.2,1)}.duration-150{transition-duration:.15s}.duration-200{transition-duration:.2s}.ease-out{transition-timing-function:cubic-bezier(0,0,.2,1)}@keyframes enter{0%{opacity:var(--tw-enter-opacity,1);transform:translate3d(var(--tw-enter-translate-x,0),var(--tw-enter-translate-y,0),0)scale3d(var(--tw-enter-scale,1),var(--tw-enter-scale,1),var(--tw-enter-scale,1))rotate(var(--tw-enter-rotate,0))}}@keyframes exit{to{opacity:var(--tw-exit-opacity,1);transform:translate3d(var(--tw-exit-translate-x,0),var(--tw-exit-translate-y,0),0)scale3d(var(--tw-exit-scale,1),var(--tw-exit-scale,1),var(--tw-exit-scale,1))rotate(var(--tw-exit-rotate,0))}}.animate-in{--tw-enter-opacity:initial;--tw-enter-scale:initial;--tw-enter-rotate:initial;--tw-enter-translate-x:initial;--tw-enter-translate-y:initial;animation-name:enter;animation-duration:.15s}.fade-in-0{--tw-enter-opacity:0}.zoom-in-95{--tw-enter-scale:.95}.duration-150{animation-duration:.15s}.duration-200{animation-duration:.2s}.ease-out{animation-timing-function:cubic-bezier(0,0,.2,1)}.running{animation-play-state:running}::-webkit-scrollbar{width:10px;height:10px}::-webkit-scrollbar-track{background:0 0}::-webkit-scrollbar-thumb{background:hsl(var(--muted-foreground)/.2);background-clip:padding-box;border:2px solid #0000;border-radius:3px}::-webkit-scrollbar-thumb:hover{background:hsl(var(--muted-foreground)/.35);background-clip:padding-box;border:2px solid #0000}*{scrollbar-width:thin;scrollbar-color:hsl(var(--muted-foreground)/.25)transparent}.hide-scrollbar::-webkit-scrollbar{display:none}.hide-scrollbar{-ms-overflow-style:none;scrollbar-width:none}.panel-scroll{scrollbar-gutter:stable}.hyperview-dockview{--dv-background-color:hsl(var(--background));--dv-group-view-background-color:hsl(var(--card));--dv-tabs-and-actions-container-background-color:hsl(var(--secondary));--dv-activegroup-visiblepanel-tab-background-color:hsl(var(--card));--dv-activegroup-hiddenpanel-tab-background-color:hsl(var(--secondary));--dv-inactivegroup-visiblepanel-tab-background-color:hsl(var(--secondary));--dv-inactivegroup-hiddenpanel-tab-background-color:hsl(var(--secondary));--dv-activegroup-visiblepanel-tab-color:hsl(var(--foreground));--dv-activegroup-hiddenpanel-tab-color:hsl(var(--muted-foreground));--dv-inactivegroup-visiblepanel-tab-color:hsl(var(--muted-foreground));--dv-inactivegroup-hiddenpanel-tab-color:hsl(var(--muted-foreground));--dv-tabs-and-actions-container-font-size:12px;--dv-tabs-and-actions-container-height:24px;--dv-tab-font-size:12px;--dv-tabs-container-scrollbar-color:hsl(var(--muted-foreground)/.25);--dv-scrollbar-background-color:hsl(var(--muted-foreground)/.25);--dv-tab-divider-color:hsl(var(--border));--dv-separator-border:transparent;--dv-paneview-header-border-color:hsl(var(--border));--dv-sash-color:hsl(var(--border));--dv-icon-hover-background-color:hsl(var(--accent));--dv-active-sash-color:hsl(var(--primary));--dv-drag-over-background-color:hsl(var(--primary)/.15);--dv-drag-over-border-color:hsl(var(--primary)/.6);--dv-tab-margin:0}.hyperview-dockview .dv-groupview{border:none}.hyperview-dockview .dv-tabs-and-actions-container{border-bottom:1px solid hsl(var(--border))}.hyperview-dockview .dv-tab{align-items:center;height:100%;padding:0 8px;line-height:16px;display:flex}.hyperview-dockview .dv-tab .dv-react-part{align-items:center;min-width:0;height:100%;display:flex}.hyperview-dockview .dv-scrollable .dv-scrollbar-horizontal{border-radius:3px;height:6px}.hyperview-dockview .dv-tabs-container{scrollbar-width:none}.hyperview-dockview .dv-tabs-container::-webkit-scrollbar{height:0}.hyperview-dockview .dv-scrollable .dv-scrollbar-horizontal{display:none}.hyperview-dockview .dv-split-view-container>.dv-sash-container>.dv-sash{background-color:#0000!important}.hyperview-dockview .dv-split-view-container.dv-horizontal>.dv-sash-container>.dv-sash:after{content:"";background-color:hsl(var(--border));pointer-events:none;width:1px;position:absolute;top:0;bottom:0;left:50%;transform:translate(-50%)}.hyperview-dockview .dv-split-view-container.dv-horizontal>.dv-sash-container>.dv-sash.dv-enabled:hover:after{background-color:hsl(var(--primary))}.hyperview-dockview .dv-split-view-container.dv-vertical>.dv-sash-container>.dv-sash:after{content:"";background-color:hsl(var(--border));pointer-events:none;height:1px;position:absolute;top:50%;left:0;right:0;transform:translateY(-50%)}.hyperview-dockview .dv-split-view-container.dv-vertical>.dv-sash-container>.dv-sash.dv-enabled:hover:after{background-color:hsl(var(--primary))}.placeholder\:text-muted-foreground::placeholder{color:hsl(var(--muted-foreground))}.placeholder\:text-muted-foreground\/50::placeholder{color:hsl(var(--muted-foreground)/.5)}.hover\:bg-accent:hover{background-color:hsl(var(--accent))}.hover\:bg-destructive\/90:hover{background-color:hsl(var(--destructive)/.9)}.hover\:bg-muted:hover{background-color:hsl(var(--muted))}.hover\:bg-muted-foreground\/40:hover{background-color:hsl(var(--muted-foreground)/.4)}.hover\:bg-muted\/40:hover{background-color:hsl(var(--muted)/.4)}.hover\:bg-muted\/50:hover{background-color:hsl(var(--muted)/.5)}.hover\:bg-muted\/60:hover{background-color:hsl(var(--muted)/.6)}.hover\:bg-primary\/90:hover{background-color:hsl(var(--primary)/.9)}.hover\:bg-secondary\/80:hover{background-color:hsl(var(--secondary)/.8)}.hover\:text-accent-foreground:hover{color:hsl(var(--accent-foreground))}.hover\:text-foreground:hover{color:hsl(var(--foreground))}.hover\:text-muted-foreground:hover{color:hsl(var(--muted-foreground))}.hover\:underline:hover{text-decoration-line:underline}.hover\:opacity-100:hover{opacity:1}.focus\:border-ring:focus{border-color:hsl(var(--ring))}.focus\:bg-accent\/70:focus{background-color:hsl(var(--accent)/.7)}.focus\:text-accent-foreground:focus{color:hsl(var(--accent-foreground))}.focus\:outline-none:focus{outline-offset:2px;outline:2px solid #0000}.focus\:ring-1:focus{--tw-ring-offset-shadow:var(--tw-ring-inset)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color);--tw-ring-shadow:var(--tw-ring-inset)0 0 0 calc(1px + var(--tw-ring-offset-width))var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow,0 0 #0000)}.focus\:ring-2:focus{--tw-ring-offset-shadow:var(--tw-ring-inset)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color);--tw-ring-shadow:var(--tw-ring-inset)0 0 0 calc(2px + var(--tw-ring-offset-width))var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow,0 0 #0000)}.focus\:ring-ring:focus{--tw-ring-color:hsl(var(--ring))}.focus\:ring-offset-2:focus{--tw-ring-offset-width:2px}.focus-visible\:outline-none:focus-visible{outline-offset:2px;outline:2px solid #0000}.focus-visible\:ring-1:focus-visible{--tw-ring-offset-shadow:var(--tw-ring-inset)0 0 0 var(--tw-ring-offset-width)var(--tw-ring-offset-color);--tw-ring-shadow:var(--tw-ring-inset)0 0 0 calc(1px + var(--tw-ring-offset-width))var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow,0 0 #0000)}.focus-visible\:ring-ring:focus-visible{--tw-ring-color:hsl(var(--ring))}.disabled\:pointer-events-none:disabled{pointer-events:none}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-50:disabled{opacity:.5}.data-\[disabled\=true\]\:pointer-events-none[data-disabled=true],.data-\[disabled\]\:pointer-events-none[data-disabled]{pointer-events:none}.data-\[state\=on\]\:border-primary[data-state=on]{border-color:hsl(var(--primary))}.data-\[selected\=true\]\:bg-accent[data-selected=true]{background-color:hsl(var(--accent))}.data-\[state\=on\]\:bg-primary[data-state=on]{background-color:hsl(var(--primary))}.data-\[state\=open\]\:bg-accent[data-state=open]{background-color:hsl(var(--accent))}.data-\[state\=open\]\:bg-accent\/70[data-state=open]{background-color:hsl(var(--accent)/.7)}.data-\[selected\=true\]\:text-accent-foreground[data-selected=true]{color:hsl(var(--accent-foreground))}.data-\[state\=on\]\:text-primary-foreground[data-state=on]{color:hsl(var(--primary-foreground))}.data-\[state\=open\]\:text-accent-foreground[data-state=open]{color:hsl(var(--accent-foreground))}.data-\[state\=open\]\:text-muted-foreground[data-state=open]{color:hsl(var(--muted-foreground))}.data-\[disabled\=true\]\:opacity-50[data-disabled=true],.data-\[disabled\]\:opacity-50[data-disabled]{opacity:.5}.data-\[state\=open\]\:animate-in[data-state=open]{--tw-enter-opacity:initial;--tw-enter-scale:initial;--tw-enter-rotate:initial;--tw-enter-translate-x:initial;--tw-enter-translate-y:initial;animation-name:enter;animation-duration:.15s}.data-\[state\=closed\]\:animate-out[data-state=closed]{--tw-exit-opacity:initial;--tw-exit-scale:initial;--tw-exit-rotate:initial;--tw-exit-translate-x:initial;--tw-exit-translate-y:initial;animation-name:exit;animation-duration:.15s}.data-\[state\=closed\]\:fade-out-0[data-state=closed]{--tw-exit-opacity:0}.data-\[state\=open\]\:fade-in-0[data-state=open]{--tw-enter-opacity:0}.data-\[state\=closed\]\:zoom-out-95[data-state=closed]{--tw-exit-scale:.95}.data-\[state\=open\]\:zoom-in-95[data-state=open]{--tw-enter-scale:.95}.data-\[side\=bottom\]\:slide-in-from-top-2[data-side=bottom]{--tw-enter-translate-y:-.5rem}.data-\[side\=left\]\:slide-in-from-right-2[data-side=left]{--tw-enter-translate-x:.5rem}.data-\[side\=right\]\:slide-in-from-left-2[data-side=right]{--tw-enter-translate-x:-.5rem}.data-\[side\=top\]\:slide-in-from-bottom-2[data-side=top]{--tw-enter-translate-y:.5rem}.data-\[state\=closed\]\:slide-out-to-left-1\/2[data-state=closed]{--tw-exit-translate-x:-50%}.data-\[state\=closed\]\:slide-out-to-top-\[48\%\][data-state=closed]{--tw-exit-translate-y:-48%}.data-\[state\=open\]\:slide-in-from-left-1\/2[data-state=open]{--tw-enter-translate-x:-50%}.data-\[state\=open\]\:slide-in-from-top-\[48\%\][data-state=open]{--tw-enter-translate-y:-48%}@media (min-width:640px){.sm\:flex-row{flex-direction:row}.sm\:justify-end{justify-content:flex-end}.sm\:space-x-2>:not([hidden])~:not([hidden]){--tw-space-x-reverse:0;margin-right:calc(.5rem*var(--tw-space-x-reverse));margin-left:calc(.5rem*calc(1 - var(--tw-space-x-reverse)))}.sm\:rounded-lg{border-radius:var(--radius)}.sm\:text-left{text-align:left}}.\[\&\>svg\]\:size-3\.5>svg{width:.875rem;height:.875rem}.\[\&\>svg\]\:shrink-0>svg{flex-shrink:0}.\[\&_\[cmdk-group-heading\]\]\:px-2 [cmdk-group-heading]{padding-left:.5rem;padding-right:.5rem}.\[\&_\[cmdk-group-heading\]\]\:py-1\.5 [cmdk-group-heading]{padding-top:.375rem;padding-bottom:.375rem}.\[\&_\[cmdk-group-heading\]\]\:text-xs [cmdk-group-heading]{font-size:.75rem;line-height:1rem}.\[\&_\[cmdk-group-heading\]\]\:font-medium [cmdk-group-heading]{font-weight:500}.\[\&_\[cmdk-group-heading\]\]\:text-muted-foreground [cmdk-group-heading]{color:hsl(var(--muted-foreground))}.\[\&_\[cmdk-group\]\:not\(\[hidden\]\)_\~\[cmdk-group\]\]\:pt-0 [cmdk-group]:not([hidden])~[cmdk-group]{padding-top:0}.\[\&_\[cmdk-group\]\]\:px-2 [cmdk-group]{padding-left:.5rem;padding-right:.5rem}.\[\&_\[cmdk-input-wrapper\]_svg\]\:h-5 [cmdk-input-wrapper] svg{height:1.25rem}.\[\&_\[cmdk-input-wrapper\]_svg\]\:w-5 [cmdk-input-wrapper] svg{width:1.25rem}.\[\&_\[cmdk-input\]\]\:h-12 [cmdk-input]{height:3rem}.\[\&_\[cmdk-item\]\]\:px-2 [cmdk-item]{padding-left:.5rem;padding-right:.5rem}.\[\&_\[cmdk-item\]\]\:py-3 [cmdk-item]{padding-top:.75rem;padding-bottom:.75rem}.\[\&_\[cmdk-item\]_svg\]\:h-5 [cmdk-item] svg{height:1.25rem}.\[\&_\[cmdk-item\]_svg\]\:w-5 [cmdk-item] svg{width:1.25rem}.\[\&_svg\]\:pointer-events-none svg{pointer-events:none}.\[\&_svg\]\:size-3\.5 svg{width:.875rem;height:.875rem}.\[\&_svg\]\:size-4 svg{width:1rem;height:1rem}.\[\&_svg\]\:shrink-0 svg{flex-shrink:0}

vendor/hyperview/server/static/_next/static/chunks/86c1fc4cf542f408.js

@@ -0,0 +1 @@
+(globalThis.TURBOPACK||(globalThis.TURBOPACK=[])).push(["object"==typeof document?document.currentScript:void 0,75115,(e,t,r)=>{"use strict";Object.defineProperty(r,"__esModule",{value:!0}),Object.defineProperty(r,"default",{enumerable:!0,get:function(){return s}});let n=e.r(48277),o=e.r(86846),i={fontFamily:'system-ui,"Segoe UI",Roboto,Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji"',height:"100vh",textAlign:"center",display:"flex",flexDirection:"column",alignItems:"center",justifyContent:"center"},u={fontSize:"14px",fontWeight:400,lineHeight:"28px",margin:"0 8px"},s=function({error:e}){let t=e?.digest;return(0,n.jsxs)("html",{id:"__next_error__",children:[(0,n.jsx)("head",{}),(0,n.jsxs)("body",{children:[(0,n.jsx)(o.HandleISRError,{error:e}),(0,n.jsx)("div",{style:i,children:(0,n.jsxs)("div",{children:[(0,n.jsxs)("h2",{style:u,children:["Application error: a ",t?"server":"client","-side exception has occurred while loading ",window.location.hostname," (see the"," ",t?"server logs":"browser console"," for more information)."]}),t?(0,n.jsx)("p",{style:u,children:`Digest: ${t}`}):null]})})]})]})};("function"==typeof r.default||"object"==typeof r.default&&null!==r.default)&&void 0===r.default.__esModule&&(Object.defineProperty(r.default,"__esModule",{value:!0}),Object.assign(r.default,r),t.exports=r.default)},90175,(e,t,r)=>{var n={229:function(e){var t,r,n,o=e.exports={};function i(){throw Error("setTimeout has not been defined")}function u(){throw Error("clearTimeout has not been defined")}try{t="function"==typeof setTimeout?setTimeout:i}catch(e){t=i}try{r="function"==typeof clearTimeout?clearTimeout:u}catch(e){r=u}function s(e){if(t===setTimeout)return setTimeout(e,0);if((t===i||!t)&&setTimeout)return t=setTimeout,setTimeout(e,0);try{return t(e,0)}catch(r){try{return t.call(null,e,0)}catch(r){return t.call(this,e,0)}}}var c=[],a=!1,l=-1;function f(){a&&n&&(a=!1,n.length?c=n.concat(c):l=-1,c.length&&p())}function p(){if(!a){var e=s(f);a=!0;for(var t=c.length;t;){for(n=c,c=[];++l<t;)n&&n[l].run();l=-1,t=c.length}n=null,a=!1,function(e){if(r===clearTimeout)return clearTimeout(e);if((r===u||!r)&&clearTimeout)return r=clearTimeout,clearTimeout(e);try{r(e)}catch(t){try{return r.call(null,e)}catch(t){return r.call(this,e)}}}(e)}}function d(e,t){this.fun=e,this.array=t}function y(){}o.nextTick=function(e){var t=Array(arguments.length-1);if(arguments.length>1)for(var r=1;r<arguments.length;r++)t[r-1]=arguments[r];c.push(new d(e,t)),1!==c.length||a||s(p)},d.prototype.run=function(){this.fun.apply(null,this.array)},o.title="browser",o.browser=!0,o.env={},o.argv=[],o.version="",o.versions={},o.on=y,o.addListener=y,o.once=y,o.off=y,o.removeListener=y,o.removeAllListeners=y,o.emit=y,o.prependListener=y,o.prependOnceListener=y,o.listeners=function(e){return[]},o.binding=function(e){throw Error("process.binding is not supported")},o.cwd=function(){return"/"},o.chdir=function(e){throw Error("process.chdir is not supported")},o.umask=function(){return 0}}},o={};function i(e){var t=o[e];if(void 0!==t)return t.exports;var r=o[e]={exports:{}},u=!0;try{n[e](r,r.exports,i),u=!1}finally{u&&delete o[e]}return r.exports}i.ab="/ROOT/frontend/node_modules/next/dist/compiled/process/",t.exports=i(229)},39057,(e,t,r)=>{"use strict";var n,o;t.exports=(null==(n=e.g.process)?void 0:n.env)&&"object"==typeof(null==(o=e.g.process)?void 0:o.env)?e.g.process:e.r(90175)},14871,(e,t,r)=>{"use strict";var n=Symbol.for("react.transitional.element");function o(e,t,r){var o=null;if(void 0!==r&&(o=""+r),void 0!==t.key&&(o=""+t.key),"key"in t)for(var i in r={},t)"key"!==i&&(r[i]=t[i]);else r=t;return{$$typeof:n,type:e,key:o,ref:void 0!==(t=r.ref)?t:null,props:r}}r.Fragment=Symbol.for("react.fragment"),r.jsx=o,r.jsxs=o},48277,(e,t,r)=>{"use strict";t.exports=e.r(14871)},24171,(e,t,r)=>{"use strict";Object.defineProperty(r,"__esModule",{value:!0});var n={bindSnapshot:function(){return a},createAsyncLocalStorage:function(){return c},createSnapshot:function(){return l}};for(var o in n)Object.defineProperty(r,o,{enumerable:!0,get:n[o]});let i=Object.defineProperty(Error("Invariant: AsyncLocalStorage accessed in runtime where it is not available"),"__NEXT_ERROR_CODE",{value:"E504",enumerable:!1,configurable:!0});class u{disable(){throw i}getStore(){}run(){throw i}exit(){throw i}enterWith(){throw i}static bind(e){return e}}let s="u">typeof globalThis&&globalThis.AsyncLocalStorage;function c(){return s?new s:new u}function a(e){return s?s.bind(e):u.bind(e)}function l(){return s?s.snapshot():function(e,...t){return e(...t)}}},98616,(e,t,r)=>{"use strict";Object.defineProperty(r,"__esModule",{value:!0}),Object.defineProperty(r,"workAsyncStorageInstance",{enumerable:!0,get:function(){return n}});let n=(0,e.r(24171).createAsyncLocalStorage)()},26628,(e,t,r)=>{"use strict";Object.defineProperty(r,"__esModule",{value:!0}),Object.defineProperty(r,"workAsyncStorage",{enumerable:!0,get:function(){return n.workAsyncStorageInstance}});let n=e.r(98616)},86846,(e,t,r)=>{"use strict";Object.defineProperty(r,"__esModule",{value:!0}),Object.defineProperty(r,"HandleISRError",{enumerable:!0,get:function(){return o}});let n="u"<typeof window?e.r(26628).workAsyncStorage:void 0;function o({error:e}){if(n){let t=n.getStore();if(t?.isStaticGeneration)throw e&&console.error(e),e}return null}("function"==typeof r.default||"object"==typeof r.default&&null!==r.default)&&void 0===r.default.__esModule&&(Object.defineProperty(r.default,"__esModule",{value:!0}),Object.assign(r.default,r),t.exports=r.default)},42124,(e,t,r)=>{"use strict";var n=e.i(39057),o=Symbol.for("react.transitional.element"),i=Symbol.for("react.portal"),u=Symbol.for("react.fragment"),s=Symbol.for("react.strict_mode"),c=Symbol.for("react.profiler"),a=Symbol.for("react.consumer"),l=Symbol.for("react.context"),f=Symbol.for("react.forward_ref"),p=Symbol.for("react.suspense"),d=Symbol.for("react.memo"),y=Symbol.for("react.lazy"),h=Symbol.for("react.activity"),g=Symbol.for("react.view_transition"),v=Symbol.iterator,_={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},m=Object.assign,b={};function S(e,t,r){this.props=e,this.context=t,this.refs=b,this.updater=r||_}function O(){}function E(e,t,r){this.props=e,this.context=t,this.refs=b,this.updater=r||_}S.prototype.isReactComponent={},S.prototype.setState=function(e,t){if("object"!=typeof e&&"function"!=typeof e&&null!=e)throw Error("takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,e,t,"setState")},S.prototype.forceUpdate=function(e){this.updater.enqueueForceUpdate(this,e,"forceUpdate")},O.prototype=S.prototype;var T=E.prototype=new O;T.constructor=E,m(T,S.prototype),T.isPureReactComponent=!0;var w=Array.isArray;function j(){}var R={H:null,A:null,T:null,S:null},x=Object.prototype.hasOwnProperty;function A(e,t,r){var n=r.ref;return{$$typeof:o,type:e,key:t,ref:void 0!==n?n:null,props:r}}function P(e){return"object"==typeof e&&null!==e&&e.$$typeof===o}var C=/\/+/g;function k(e,t){var r,n;return"object"==typeof e&&null!==e&&null!=e.key?(r=""+e.key,n={"=":"=0",":":"=2"},"$"+r.replace(/[=:]/g,function(e){return n[e]})):t.toString(36)}function H(e,t,r){if(null==e)return e;var n=[],u=0;return!function e(t,r,n,u,s){var c,a,l,f=typeof t;("undefined"===f||"boolean"===f)&&(t=null);var p=!1;if(null===t)p=!0;else switch(f){case"bigint":case"string":case"number":p=!0;break;case"object":switch(t.$$typeof){case o:case i:p=!0;break;case y:return e((p=t._init)(t._payload),r,n,u,s)}}if(p)return s=s(t),p=""===u?"."+k(t,0):u,w(s)?(n="",null!=p&&(n=p.replace(C,"$&/")+"/"),e(s,r,n,"",function(e){return e})):null!=s&&(P(s)&&(c=s,a=n+(null==s.key||t&&t.key===s.key?"":(""+s.key).replace(C,"$&/")+"/")+p,s=A(c.type,a,c.props)),r.push(s)),1;p=0;var d=""===u?".":u+":";if(w(t))for(var h=0;h<t.length;h++)f=d+k(u=t[h],h),p+=e(u,r,n,f,s);else if("function"==typeof(h=null===(l=t)||"object"!=typeof l?null:"function"==typeof(l=v&&l[v]||l["@@iterator"])?l:null))for(t=h.call(t),h=0;!(u=t.next()).done;)f=d+k(u=u.value,h++),p+=e(u,r,n,f,s);else if("object"===f){if("function"==typeof t.then)return e(function(e){switch(e.status){case"fulfilled":return e.value;case"rejected":throw e.reason;default:switch("string"==typeof e.status?e.then(j,j):(e.status="pending",e.then(function(t){"pending"===e.status&&(e.status="fulfilled",e.value=t)},function(t){"pending"===e.status&&(e.status="rejected",e.reason=t)})),e.status){case"fulfilled":return e.value;case"rejected":throw e.reason}}throw e}(t),r,n,u,s);throw Error("Objects are not valid as a React child (found: "+("[object Object]"===(r=String(t))?"object with keys {"+Object.keys(t).join(", ")+"}":r)+"). If you meant to render a collection of children, use an array instead.")}return p}(e,n,"","",function(e){return t.call(r,e,u++)}),n}function L(e){if(-1===e._status){var t=e._result;(t=t()).then(function(t){(0===e._status||-1===e._status)&&(e._status=1,e._result=t)},function(t){(0===e._status||-1===e._status)&&(e._status=2,e._result=t)}),-1===e._status&&(e._status=0,e._result=t)}if(1===e._status)return e._result.default;throw e._result}var I="function"==typeof reportError?reportError:function(e){if("object"==typeof window&&"function"==typeof window.ErrorEvent){var t=new window.ErrorEvent("error",{bubbles:!0,cancelable:!0,message:"object"==typeof e&&null!==e&&"string"==typeof e.message?String(e.message):String(e),error:e});if(!window.dispatchEvent(t))return}else if("object"==typeof n.default&&"function"==typeof n.default.emit)return void n.default.emit("uncaughtException",e);console.error(e)};function M(e){var t=R.T,r={};r.types=null!==t?t.types:null,R.T=r;try{var n=e(),o=R.S;null!==o&&o(r,n),"object"==typeof n&&null!==n&&"function"==typeof n.then&&n.then(j,I)}catch(e){I(e)}finally{null!==t&&null!==r.types&&(t.types=r.types),R.T=t}}function N(e){var t=R.T;if(null!==t){var r=t.types;null===r?t.types=[e]:-1===r.indexOf(e)&&r.push(e)}else M(N.bind(null,e))}r.Activity=h,r.Children={map:H,forEach:function(e,t,r){H(e,function(){t.apply(this,arguments)},r)},count:function(e){var t=0;return H(e,function(){t++}),t},toArray:function(e){return H(e,function(e){return e})||[]},only:function(e){if(!P(e))throw Error("React.Children.only expected to receive a single React element child.");return e}},r.Component=S,r.Fragment=u,r.Profiler=c,r.PureComponent=E,r.StrictMode=s,r.Suspense=p,r.ViewTransition=g,r.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=R,r.__COMPILER_RUNTIME={__proto__:null,c:function(e){return R.H.useMemoCache(e)}},r.addTransitionType=N,r.cache=function(e){return function(){return e.apply(null,arguments)}},r.cacheSignal=function(){return null},r.cloneElement=function(e,t,r){if(null==e)throw Error("The argument must be a React element, but you passed "+e+".");var n=m({},e.props),o=e.key;if(null!=t)for(i in void 0!==t.key&&(o=""+t.key),t)x.call(t,i)&&"key"!==i&&"__self"!==i&&"__source"!==i&&("ref"!==i||void 0!==t.ref)&&(n[i]=t[i]);var i=arguments.length-2;if(1===i)n.children=r;else if(1<i){for(var u=Array(i),s=0;s<i;s++)u[s]=arguments[s+2];n.children=u}return A(e.type,o,n)},r.createContext=function(e){return(e={$$typeof:l,_currentValue:e,_currentValue2:e,_threadCount:0,Provider:null,Consumer:null}).Provider=e,e.Consumer={$$typeof:a,_context:e},e},r.createElement=function(e,t,r){var n,o={},i=null;if(null!=t)for(n in void 0!==t.key&&(i=""+t.key),t)x.call(t,n)&&"key"!==n&&"__self"!==n&&"__source"!==n&&(o[n]=t[n]);var u=arguments.length-2;if(1===u)o.children=r;else if(1<u){for(var s=Array(u),c=0;c<u;c++)s[c]=arguments[c+2];o.children=s}if(e&&e.defaultProps)for(n in u=e.defaultProps)void 0===o[n]&&(o[n]=u[n]);return A(e,i,o)},r.createRef=function(){return{current:null}},r.forwardRef=function(e){return{$$typeof:f,render:e}},r.isValidElement=P,r.lazy=function(e){return{$$typeof:y,_payload:{_status:-1,_result:e},_init:L}},r.memo=function(e,t){return{$$typeof:d,type:e,compare:void 0===t?null:t}},r.startTransition=M,r.unstable_useCacheRefresh=function(){return R.H.useCacheRefresh()},r.use=function(e){return R.H.use(e)},r.useActionState=function(e,t,r){return R.H.useActionState(e,t,r)},r.useCallback=function(e,t){return R.H.useCallback(e,t)},r.useContext=function(e){return R.H.useContext(e)},r.useDebugValue=function(){},r.useDeferredValue=function(e,t){return R.H.useDeferredValue(e,t)},r.useEffect=function(e,t){return R.H.useEffect(e,t)},r.useEffectEvent=function(e){return R.H.useEffectEvent(e)},r.useId=function(){return R.H.useId()},r.useImperativeHandle=function(e,t,r){return R.H.useImperativeHandle(e,t,r)},r.useInsertionEffect=function(e,t){return R.H.useInsertionEffect(e,t)},r.useLayoutEffect=function(e,t){return R.H.useLayoutEffect(e,t)},r.useMemo=function(e,t){return R.H.useMemo(e,t)},r.useOptimistic=function(e,t){return R.H.useOptimistic(e,t)},r.useReducer=function(e,t,r){return R.H.useReducer(e,t,r)},r.useRef=function(e){return R.H.useRef(e)},r.useState=function(e){return R.H.useState(e)},r.useSyncExternalStore=function(e,t,r){return R.H.useSyncExternalStore(e,t,r)},r.useTransition=function(){return R.H.useTransition()},r.version="19.3.0-canary-f93b9fd4-20251217"},30668,(e,t,r)=>{"use strict";t.exports=e.r(42124)},15501,(e,t,r)=>{"use strict";var n=e.r(30668);function o(e){var t="https://react.dev/errors/"+e;if(1<arguments.length){t+="?args[]="+encodeURIComponent(arguments[1]);for(var r=2;r<arguments.length;r++)t+="&args[]="+encodeURIComponent(arguments[r])}return"Minified React error #"+e+"; visit "+t+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}function i(){}var u={d:{f:i,r:function(){throw Error(o(522))},D:i,C:i,L:i,m:i,X:i,S:i,M:i},p:0,findDOMNode:null},s=Symbol.for("react.portal"),c=Symbol.for("react.optimistic_key"),a=n.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;function l(e,t){return"font"===e?"":"string"==typeof t?"use-credentials"===t?t:"":void 0}r.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE=u,r.createPortal=function(e,t){var r=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!t||1!==t.nodeType&&9!==t.nodeType&&11!==t.nodeType)throw Error(o(299));return function(e,t,r){var n=3<arguments.length&&void 0!==arguments[3]?arguments[3]:null;return{$$typeof:s,key:null==n?null:n===c?c:""+n,children:e,containerInfo:t,implementation:r}}(e,t,null,r)},r.flushSync=function(e){var t=a.T,r=u.p;try{if(a.T=null,u.p=2,e)return e()}finally{a.T=t,u.p=r,u.d.f()}},r.preconnect=function(e,t){"string"==typeof e&&(t=t?"string"==typeof(t=t.crossOrigin)?"use-credentials"===t?t:"":void 0:null,u.d.C(e,t))},r.prefetchDNS=function(e){"string"==typeof e&&u.d.D(e)},r.preinit=function(e,t){if("string"==typeof e&&t&&"string"==typeof t.as){var r=t.as,n=l(r,t.crossOrigin),o="string"==typeof t.integrity?t.integrity:void 0,i="string"==typeof t.fetchPriority?t.fetchPriority:void 0;"style"===r?u.d.S(e,"string"==typeof t.precedence?t.precedence:void 0,{crossOrigin:n,integrity:o,fetchPriority:i}):"script"===r&&u.d.X(e,{crossOrigin:n,integrity:o,fetchPriority:i,nonce:"string"==typeof t.nonce?t.nonce:void 0})}},r.preinitModule=function(e,t){if("string"==typeof e)if("object"==typeof t&&null!==t){if(null==t.as||"script"===t.as){var r=l(t.as,t.crossOrigin);u.d.M(e,{crossOrigin:r,integrity:"string"==typeof t.integrity?t.integrity:void 0,nonce:"string"==typeof t.nonce?t.nonce:void 0})}}else null==t&&u.d.M(e)},r.preload=function(e,t){if("string"==typeof e&&"object"==typeof t&&null!==t&&"string"==typeof t.as){var r=t.as,n=l(r,t.crossOrigin);u.d.L(e,r,{crossOrigin:n,integrity:"string"==typeof t.integrity?t.integrity:void 0,nonce:"string"==typeof t.nonce?t.nonce:void 0,type:"string"==typeof t.type?t.type:void 0,fetchPriority:"string"==typeof t.fetchPriority?t.fetchPriority:void 0,referrerPolicy:"string"==typeof t.referrerPolicy?t.referrerPolicy:void 0,imageSrcSet:"string"==typeof t.imageSrcSet?t.imageSrcSet:void 0,imageSizes:"string"==typeof t.imageSizes?t.imageSizes:void 0,media:"string"==typeof t.media?t.media:void 0})}},r.preloadModule=function(e,t){if("string"==typeof e)if(t){var r=l(t.as,t.crossOrigin);u.d.m(e,{as:"string"==typeof t.as&&"script"!==t.as?t.as:void 0,crossOrigin:r,integrity:"string"==typeof t.integrity?t.integrity:void 0})}else u.d.m(e)},r.requestFormReset=function(e){u.d.r(e)},r.unstable_batchedUpdates=function(e,t){return e(t)},r.useFormState=function(e,t,r){return a.H.useFormState(e,t,r)},r.useFormStatus=function(){return a.H.useHostTransitionStatus()},r.version="19.3.0-canary-f93b9fd4-20251217"},69941,(e,t,r)=>{"use strict";!function e(){if("u">typeof __REACT_DEVTOOLS_GLOBAL_HOOK__&&"function"==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE)try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(e)}catch(e){console.error(e)}}(),t.exports=e.r(15501)}]);