Deploy 2026-01-28 16:51:38

src/flow/ui/api/__init__.py

@@ -5,10 +5,12 @@ from .configs import router as configs_router
 from .tasks import router as tasks_router
 from .jobs import router as jobs_router
 from .runs import router as runs_router
+from .tests import router as tests_router
 
 __all__ = [
     "configs_router",
     "tasks_router",
     "jobs_router",
     "runs_router",
+    "tests_router",
 ]

src/flow/ui/api/configs.py

@@ -1,18 +1,20 @@
 # Copyright (c) Microsoft. All rights reserved.
 """Agent config API routes."""
 
+from typing import Annotated
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import select, desc
+from sqlmodel import desc, select
 
 from flow.experiments.models import Agent, CompactionConfig, GridSearchStrategy
 
+from ..auth import TokenData, get_current_user, get_effective_user_id, should_filter_by_user
 from ..database import get_session
 from ..models.config import AgentConfig
-from ..schemas import AgentCreate, AgentUpdate, AgentResponse
+from ..schemas import AgentCreate, AgentResponse, AgentUpdate
 
 router = APIRouter(prefix="/configs", tags=["configs"])
 
@@ -54,11 +56,18 @@ def parse_uuid(id_str: str) -> UUID:
 async def list_configs(
     include_auto_generated: bool = False,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> list[AgentConfig]:
-    """List agent configurations."""
+    """List agent configurations for the current user."""
     query = select(AgentConfig)
     if not include_auto_generated:
         query = query.where(AgentConfig.is_auto_generated == False)  # noqa: E712
+
+    # Filter by user if auth is enabled
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(AgentConfig.user_id == effective_user_id)
+
     query = query.order_by(desc(AgentConfig.created_at))
     result = await session.execute(query)
     return list(result.scalars().all())
@@ -68,12 +77,14 @@ async def list_configs(
 async def create_config(
     data: AgentCreate,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> AgentConfig:
     """Create a new agent configuration."""
     config = AgentConfig(
         name=data.name,
         description=data.description,
         config_json=data.to_config_json(),
+        user_id=get_effective_user_id(user),
     )
     session.add(config)
     await session.commit()
@@ -85,10 +96,18 @@ async def create_config(
 async def get_config(
     config_id: str,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> AgentConfig:
     """Get a specific agent configuration."""
     uuid_id = parse_uuid(config_id)
-    result = await session.execute(select(AgentConfig).where(AgentConfig.id == uuid_id))
+    query = select(AgentConfig).where(AgentConfig.id == uuid_id)
+
+    # Filter by user if auth is enabled
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(AgentConfig.user_id == effective_user_id)
+
+    result = await session.execute(query)
     config = result.scalar_one_or_none()
     if not config:
         raise HTTPException(status_code=404, detail="Config not found")
@@ -100,10 +119,18 @@ async def update_config(
     config_id: str,
     data: AgentUpdate,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> AgentConfig:
     """Update an agent configuration."""
     uuid_id = parse_uuid(config_id)
-    result = await session.execute(select(AgentConfig).where(AgentConfig.id == uuid_id))
+    query = select(AgentConfig).where(AgentConfig.id == uuid_id)
+
+    # Filter by user if auth is enabled
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(AgentConfig.user_id == effective_user_id)
+
+    result = await session.execute(query)
     config = result.scalar_one_or_none()
     if not config:
         raise HTTPException(status_code=404, detail="Config not found")
@@ -142,10 +169,18 @@ async def update_config(
 async def delete_config(
     config_id: str,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> None:
     """Delete an agent configuration."""
     uuid_id = parse_uuid(config_id)
-    result = await session.execute(select(AgentConfig).where(AgentConfig.id == uuid_id))
+    query = select(AgentConfig).where(AgentConfig.id == uuid_id)
+
+    # Filter by user if auth is enabled
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(AgentConfig.user_id == effective_user_id)
+
+    result = await session.execute(query)
     config = result.scalar_one_or_none()
     if not config:
         raise HTTPException(status_code=404, detail="Config not found")
@@ -158,12 +193,14 @@ async def delete_config(
 async def generate_candidates(
     data: CandidateRequest,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> list[AgentConfig]:
     """Generate candidate agents for optimization.
 
     Uses GridSearchStrategy to generate candidate variants from a base agent.
     Each candidate is stored as an AgentConfig in the database.
     """
+    effective_user_id = get_effective_user_id(user)
     variations: dict[str, list] = {}
 
     if data.vary_compaction:
@@ -212,6 +249,7 @@ async def generate_candidates(
             },
             is_auto_generated=True,
             job_id=job_uuid,
+            user_id=effective_user_id,
         )
         session.add(config)
         await session.commit()
@@ -244,6 +282,7 @@ async def generate_candidates(
                 },
                 is_auto_generated=True,
                 job_id=job_uuid,
+                user_id=effective_user_id,
             )
             session.add(config)
             configs.append(config)

src/flow/ui/api/jobs.py

@@ -3,17 +3,19 @@
 
 import asyncio
 import logging
-from typing import Any, AsyncGenerator
+from collections.abc import AsyncGenerator
+from typing import Annotated, Any
 from uuid import UUID
 
-from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException
 from fastapi.responses import StreamingResponse
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import select, desc
+from sqlmodel import desc, or_, select
 
-from ..database import get_session, async_session
-from ..models.job import OptimizationJob, JobStatus
+from ..auth import TokenData, get_current_user, get_effective_user_id, should_filter_by_user
+from ..database import async_session, get_session
 from ..models.config import AgentConfig
+from ..models.job import JobStatus, OptimizationJob
 from ..models.task import TaskModel
 from ..schemas import JobCreate, JobResponse
 from ..services.optimizer_service import OptimizerService
@@ -37,11 +39,18 @@ def parse_uuid(id_str: str) -> UUID:
 async def list_jobs(
     status: JobStatus | None = None,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> list[OptimizationJob]:
-    """List all optimization jobs."""
+    """List all optimization jobs for the current user."""
     query = select(OptimizationJob)
     if status:
         query = query.where(OptimizationJob.status == status)
+
+    # Filter by user if auth is enabled
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(OptimizationJob.user_id == effective_user_id)
+
     query = query.order_by(desc(OptimizationJob.created_at))
     result = await session.execute(query)
     return list(result.scalars().all())
@@ -51,19 +60,33 @@ async def list_jobs(
 async def create_job(
     data: JobCreate,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> OptimizationJob:
     """Create a new optimization job."""
-    # Validate candidate_ids exist
+    effective_user_id = get_effective_user_id(user)
+
+    # Validate candidate_ids exist AND belong to user
     for candidate_id in data.candidate_ids:
         uuid_id = parse_uuid(candidate_id)
-        result = await session.execute(select(AgentConfig).where(AgentConfig.id == uuid_id))
+        query = select(AgentConfig).where(AgentConfig.id == uuid_id)
+        if should_filter_by_user():
+            query = query.where(AgentConfig.user_id == effective_user_id)
+        result = await session.execute(query)
         if not result.scalar_one_or_none():
             raise HTTPException(status_code=400, detail=f"Candidate {candidate_id} not found")
 
-    # Validate task_ids exist
+    # Validate task_ids exist AND are accessible (shared or user's own)
     for task_id in data.task_ids:
         uuid_id = parse_uuid(task_id)
-        result = await session.execute(select(TaskModel).where(TaskModel.id == uuid_id))
+        query = select(TaskModel).where(TaskModel.id == uuid_id)
+        if should_filter_by_user():
+            query = query.where(
+                or_(
+                    TaskModel.user_id == None,  # noqa: E711 - Shared tasks
+                    TaskModel.user_id == effective_user_id,
+                )
+            )
+        result = await session.execute(query)
         if not result.scalar_one_or_none():
             raise HTTPException(status_code=400, detail=f"Task {task_id} not found")
 
@@ -74,6 +97,7 @@ async def create_job(
         parallel=data.parallel,
         use_llm_eval=data.use_llm_eval,
         total_experiments=len(data.candidate_ids) * len(data.task_ids),
+        user_id=effective_user_id,
     )
     session.add(job)
     await session.commit()
@@ -85,10 +109,17 @@ async def create_job(
 async def get_job(
     job_id: str,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> OptimizationJob:
     """Get a specific optimization job."""
     uuid_id = parse_uuid(job_id)
-    result = await session.execute(select(OptimizationJob).where(OptimizationJob.id == uuid_id))
+    query = select(OptimizationJob).where(OptimizationJob.id == uuid_id)
+
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(OptimizationJob.user_id == effective_user_id)
+
+    result = await session.execute(query)
     job = result.scalar_one_or_none()
     if not job:
         raise HTTPException(status_code=404, detail="Job not found")
@@ -122,8 +153,7 @@ async def _run_job_background(job_id: str) -> None:
                 await session.commit()
     finally:
         # Remove from running jobs tracker
-        if job_id in _running_jobs:
-            del _running_jobs[job_id]
+        _running_jobs.pop(job_id, None)
 
 
 @router.post("/{job_id}/start")
@@ -131,6 +161,7 @@ async def start_job(
     job_id: str,
     background_tasks: BackgroundTasks,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> StreamingResponse:
     """Start an optimization job and stream progress via SSE.
 
@@ -139,7 +170,13 @@ async def start_job(
     for progress updates.
     """
     uuid_id = parse_uuid(job_id)
-    result = await session.execute(select(OptimizationJob).where(OptimizationJob.id == uuid_id))
+    query = select(OptimizationJob).where(OptimizationJob.id == uuid_id)
+
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(OptimizationJob.user_id == effective_user_id)
+
+    result = await session.execute(query)
     job = result.scalar_one_or_none()
     if not job:
         raise HTTPException(status_code=404, detail="Job not found")
@@ -208,10 +245,17 @@ async def start_job(
 async def cancel_job(
     job_id: str,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> OptimizationJob:
     """Cancel a running optimization job."""
     uuid_id = parse_uuid(job_id)
-    result = await session.execute(select(OptimizationJob).where(OptimizationJob.id == uuid_id))
+    query = select(OptimizationJob).where(OptimizationJob.id == uuid_id)
+
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(OptimizationJob.user_id == effective_user_id)
+
+    result = await session.execute(query)
     job = result.scalar_one_or_none()
     if not job:
         raise HTTPException(status_code=404, detail="Job not found")
@@ -234,10 +278,17 @@ async def cancel_job(
 async def delete_job(
     job_id: str,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> None:
     """Delete an optimization job and its runs."""
     uuid_id = parse_uuid(job_id)
-    result = await session.execute(select(OptimizationJob).where(OptimizationJob.id == uuid_id))
+    query = select(OptimizationJob).where(OptimizationJob.id == uuid_id)
+
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(OptimizationJob.user_id == effective_user_id)
+
+    result = await session.execute(query)
     job = result.scalar_one_or_none()
     if not job:
         raise HTTPException(status_code=404, detail="Job not found")
@@ -254,16 +305,21 @@ async def delete_job(
 async def reset_job(
     job_id: str,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> OptimizationJob:
     """Reset a stuck job back to pending state.
 
     Use this to recover jobs that got stuck in 'running' state
     due to connection drops or server restarts.
     """
-    from datetime import datetime, timezone
-
     uuid_id = parse_uuid(job_id)
-    result = await session.execute(select(OptimizationJob).where(OptimizationJob.id == uuid_id))
+    query = select(OptimizationJob).where(OptimizationJob.id == uuid_id)
+
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(OptimizationJob.user_id == effective_user_id)
+
+    result = await session.execute(query)
     job = result.scalar_one_or_none()
     if not job:
         raise HTTPException(status_code=404, detail="Job not found")
@@ -292,24 +348,30 @@ async def reset_job(
 async def cleanup_stuck_jobs(
     max_age_hours: int = 2,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> list[OptimizationJob]:
-    """Mark stuck 'running' jobs as failed.
+    """Mark stuck 'running' jobs as failed (only user's own jobs).
 
     Jobs that have been 'running' for longer than max_age_hours without
     any progress update are assumed to be stuck (e.g., due to server
     restart or connection drop).
     """
-    from datetime import datetime, timezone, timedelta
+    from datetime import datetime, timedelta, timezone
 
     cutoff = datetime.now(timezone.utc) - timedelta(hours=max_age_hours)
 
     # Find jobs that are running and started before cutoff
-    result = await session.execute(
-        select(OptimizationJob).where(
-            OptimizationJob.status == JobStatus.RUNNING,
-            OptimizationJob.started_at < cutoff,
-        )
+    query = select(OptimizationJob).where(
+        OptimizationJob.status == JobStatus.RUNNING,
+        OptimizationJob.started_at < cutoff,
     )
+
+    # Only affect user's own jobs
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(OptimizationJob.user_id == effective_user_id)
+
+    result = await session.execute(query)
     stuck_jobs = list(result.scalars().all())
 
     # Mark them as failed

src/flow/ui/api/runs.py

@@ -1,16 +1,18 @@
 # Copyright (c) Microsoft. All rights reserved.
 """Run API routes."""
 
-from typing import Any
+from typing import Annotated, Any
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import select, desc
+from sqlmodel import desc, select
 
+from ..auth import TokenData, get_current_user, get_effective_user_id, should_filter_by_user
 from ..database import get_session
+from ..models.job import OptimizationJob
 from ..models.run import ExperimentRun
-from ..schemas import RunResponse, RunDetailResponse, CriterionResultSchema
+from ..schemas import CriterionResultSchema, RunDetailResponse, RunResponse
 
 router = APIRouter(prefix="/runs", tags=["runs"])
 
@@ -30,8 +32,12 @@ async def list_runs(
     task_name: str | None = None,
     is_pareto: bool | None = None,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> list[ExperimentRun]:
-    """List experiment runs with optional filters."""
+    """List experiment runs with optional filters.
+
+    Runs are filtered by their parent job's user_id.
+    """
     query = select(ExperimentRun)
 
     if job_id:
@@ -44,6 +50,13 @@ async def list_runs(
     if is_pareto is not None:
         query = query.where(ExperimentRun.is_pareto == is_pareto)
 
+    # Filter by user via parent job
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.join(OptimizationJob).where(
+            OptimizationJob.user_id == effective_user_id
+        )
+
     query = query.order_by(desc(ExperimentRun.created_at))
     result = await session.execute(query)
     return list(result.scalars().all())
@@ -53,10 +66,20 @@ async def list_runs(
 async def get_run(
     run_id: str,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> dict[str, Any]:
     """Get detailed information about a specific run."""
     uuid_id = parse_uuid(run_id)
-    result = await session.execute(select(ExperimentRun).where(ExperimentRun.id == uuid_id))
+    query = select(ExperimentRun).where(ExperimentRun.id == uuid_id)
+
+    # Filter by user via parent job
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.join(OptimizationJob).where(
+            OptimizationJob.user_id == effective_user_id
+        )
+
+    result = await session.execute(query)
     run = result.scalar_one_or_none()
     if not run:
         raise HTTPException(status_code=404, detail="Run not found")
@@ -99,9 +122,22 @@ async def get_run(
 async def get_job_summary(
     job_id: str,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> dict[str, Any]:
     """Get aggregated summary for a job's runs."""
     uuid_id = parse_uuid(job_id)
+
+    # First verify the job belongs to the user
+    job_query = select(OptimizationJob).where(OptimizationJob.id == uuid_id)
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        job_query = job_query.where(OptimizationJob.user_id == effective_user_id)
+
+    job_result = await session.execute(job_query)
+    if not job_result.scalar_one_or_none():
+        raise HTTPException(status_code=404, detail="Job not found")
+
+    # Then get runs (no need to filter again since we verified job ownership)
     result = await session.execute(
         select(ExperimentRun).where(ExperimentRun.job_id == uuid_id)
     )

src/flow/ui/api/tasks.py

@@ -1,12 +1,14 @@
 # Copyright (c) Microsoft. All rights reserved.
 """Task API routes."""
 
+from typing import Annotated
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import select, desc
+from sqlmodel import desc, or_, select
 
+from ..auth import TokenData, get_current_user, get_effective_user_id, should_filter_by_user
 from ..database import get_session
 from ..models.task import TaskModel
 from ..schemas import TaskCreate, TaskResponse
@@ -27,13 +29,31 @@ async def list_tasks(
     category: str | None = None,
     suite: str | None = None,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> list[TaskModel]:
-    """List all tasks, optionally filtered by category or suite."""
+    """List all tasks, optionally filtered by category or suite.
+
+    Shows:
+    - Shared tasks (user_id is None, e.g., built-in suites)
+    - User's own tasks (when auth is enabled)
+    """
     query = select(TaskModel)
     if category:
         query = query.where(TaskModel.category == category)
     if suite:
         query = query.where(TaskModel.suite == suite)
+
+    # Filter by user if auth is enabled
+    # Show both shared tasks (user_id=None) AND user's own tasks
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(
+            or_(
+                TaskModel.user_id == None,  # noqa: E711 - Shared tasks
+                TaskModel.user_id == effective_user_id,  # User's own tasks
+            )
+        )
+
     query = query.order_by(desc(TaskModel.created_at))
     result = await session.execute(query)
     return list(result.scalars().all())
@@ -43,6 +63,7 @@ async def list_tasks(
 async def create_task(
     data: TaskCreate,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> TaskModel:
     """Create a new task."""
     task = TaskModel(
@@ -50,6 +71,7 @@ async def create_task(
         prompt=data.prompt,
         criteria_json=data.to_criteria_json(),
         category=data.category,
+        user_id=get_effective_user_id(user),
     )
     session.add(task)
     await session.commit()
@@ -61,10 +83,23 @@ async def create_task(
 async def get_task(
     task_id: str,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> TaskModel:
     """Get a specific task."""
     uuid_id = parse_uuid(task_id)
-    result = await session.execute(select(TaskModel).where(TaskModel.id == uuid_id))
+    query = select(TaskModel).where(TaskModel.id == uuid_id)
+
+    # Allow access to shared tasks (user_id=None) OR user's own tasks
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(
+            or_(
+                TaskModel.user_id == None,  # noqa: E711
+                TaskModel.user_id == effective_user_id,
+            )
+        )
+
+    result = await session.execute(query)
     task = result.scalar_one_or_none()
     if not task:
         raise HTTPException(status_code=404, detail="Task not found")
@@ -75,10 +110,21 @@ async def get_task(
 async def delete_task(
     task_id: str,
     session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
 ) -> None:
-    """Delete a task."""
+    """Delete a task.
+
+    Only allows deleting user-owned tasks, not shared/built-in tasks.
+    """
     uuid_id = parse_uuid(task_id)
-    result = await session.execute(select(TaskModel).where(TaskModel.id == uuid_id))
+    query = select(TaskModel).where(TaskModel.id == uuid_id)
+
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        # Can only delete user's own tasks (not shared ones with user_id=None)
+        query = query.where(TaskModel.user_id == effective_user_id)
+
+    result = await session.execute(query)
     task = result.scalar_one_or_none()
     if not task:
         raise HTTPException(status_code=404, detail="Task not found")

src/flow/ui/api/tests.py

@@ -0,0 +1,282 @@
+# Copyright (c) Microsoft. All rights reserved.
+"""Test run API routes for interactive agent testing."""
+
+import asyncio
+import logging
+from collections.abc import AsyncGenerator
+from typing import Annotated, Any
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import desc, select
+
+from ..auth import TokenData, get_current_user, get_effective_user_id, should_filter_by_user
+from ..database import async_session, get_session
+from ..models.config import AgentConfig
+from ..models.test_run import TestRun, TestRunStatus
+from ..schemas.test import TestRunCreate, TestRunResponse, TestRunDetailResponse
+from ..services.test_service import TestService
+
+router = APIRouter(prefix="/tests", tags=["tests"])
+logger = logging.getLogger(__name__)
+
+# Store running tests for cancellation
+_running_tests: dict[str, asyncio.Task[Any]] = {}
+
+
+def parse_uuid(id_str: str) -> UUID:
+    """Parse a string to UUID, raising 400 if invalid."""
+    try:
+        return UUID(id_str)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=f"Invalid UUID: {id_str}") from e
+
+
+@router.get("", response_model=list[TestRunResponse])
+async def list_tests(
+    agent_id: str | None = None,
+    limit: int = 50,
+    session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
+) -> list[TestRun]:
+    """List test runs, optionally filtered by agent."""
+    query = select(TestRun)
+
+    if agent_id:
+        uuid_id = parse_uuid(agent_id)
+        query = query.where(TestRun.agent_id == uuid_id)
+
+    # Filter by user if auth is enabled
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(TestRun.user_id == effective_user_id)
+
+    query = query.order_by(desc(TestRun.created_at)).limit(limit)
+    result = await session.execute(query)
+    return list(result.scalars().all())
+
+
+@router.post("", response_model=TestRunResponse, status_code=201)
+async def create_test(
+    data: TestRunCreate,
+    session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
+) -> TestRun:
+    """Create a new test run for an agent."""
+    effective_user_id = get_effective_user_id(user)
+
+    # Validate agent exists and belongs to user
+    agent_uuid = parse_uuid(data.agent_id)
+    query = select(AgentConfig).where(AgentConfig.id == agent_uuid)
+    if should_filter_by_user():
+        query = query.where(AgentConfig.user_id == effective_user_id)
+    result = await session.execute(query)
+    if not result.scalar_one_or_none():
+        raise HTTPException(status_code=400, detail="Agent not found")
+
+    # Validate task exists if provided
+    task_uuid: UUID | None = None
+    if data.task_id:
+        task_uuid = parse_uuid(data.task_id)
+        from ..models.task import TaskModel
+        from sqlmodel import or_
+        query = select(TaskModel).where(TaskModel.id == task_uuid)
+        if should_filter_by_user():
+            query = query.where(
+                or_(
+                    TaskModel.user_id == None,  # noqa: E711 - Shared tasks
+                    TaskModel.user_id == effective_user_id,
+                )
+            )
+        result = await session.execute(query)
+        if not result.scalar_one_or_none():
+            raise HTTPException(status_code=400, detail="Task not found")
+
+    test_run = TestRun(
+        agent_id=agent_uuid,
+        prompt=data.prompt,
+        task_id=task_uuid,
+        user_id=effective_user_id,
+    )
+    session.add(test_run)
+    await session.commit()
+    await session.refresh(test_run)
+    return test_run
+
+
+@router.get("/{test_id}", response_model=TestRunDetailResponse)
+async def get_test(
+    test_id: str,
+    session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
+) -> dict[str, Any]:
+    """Get detailed test run info including trace."""
+    uuid_id = parse_uuid(test_id)
+    query = select(TestRun).where(TestRun.id == uuid_id)
+
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(TestRun.user_id == effective_user_id)
+
+    result = await session.execute(query)
+    test_run = result.scalar_one_or_none()
+    if not test_run:
+        raise HTTPException(status_code=404, detail="Test run not found")
+
+    # Convert to response with trace field renamed
+    return {
+        "id": str(test_run.id),
+        "agent_id": str(test_run.agent_id),
+        "prompt": test_run.prompt,
+        "task_id": str(test_run.task_id) if test_run.task_id else None,
+        "status": test_run.status.value if isinstance(test_run.status, TestRunStatus) else test_run.status,
+        "tokens_total": test_run.tokens_total,
+        "tokens_input": test_run.tokens_input,
+        "tokens_output": test_run.tokens_output,
+        "duration_seconds": test_run.duration_seconds,
+        "score": test_run.score,
+        "passed": test_run.passed,
+        "reasoning": test_run.reasoning,
+        "output": test_run.output,
+        "files_created": test_run.files_created,
+        "trace": test_run.trace_json,
+        "error": test_run.error,
+        "created_at": test_run.created_at,
+        "started_at": test_run.started_at,
+        "completed_at": test_run.completed_at,
+    }
+
+
+async def _run_test_background(test_id: str) -> None:
+    """Run test in background, updating DB with progress."""
+    service = TestService()
+    try:
+        async for progress in service.run_test(test_id):
+            logger.debug(f"Test {test_id[:8]} progress: {progress.event} - {progress.message}")
+    except Exception as e:
+        logger.error(f"Background test {test_id[:8]} failed: {e}")
+        # Ensure test is marked as failed
+        async with async_session() as session:
+            from datetime import datetime, timezone
+            result = await session.execute(
+                select(TestRun).where(TestRun.id == UUID(test_id))
+            )
+            test_run = result.scalar_one_or_none()
+            if test_run and test_run.status == TestRunStatus.RUNNING:
+                test_run.status = TestRunStatus.FAILED
+                test_run.error = f"Background execution failed: {e}"
+                test_run.completed_at = datetime.now(timezone.utc)
+                await session.commit()
+    finally:
+        _running_tests.pop(test_id, None)
+
+
+@router.post("/{test_id}/start")
+async def start_test(
+    test_id: str,
+    session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
+) -> StreamingResponse:
+    """Start a test run and stream progress via SSE.
+
+    Events streamed:
+    - started: Test execution started
+    - execution: Agent execution events (text_delta, tool_call_start, tool_result)
+    - span: OTEL span completed
+    - complete: Test finished
+    - error: Error occurred
+    """
+    uuid_id = parse_uuid(test_id)
+    query = select(TestRun).where(TestRun.id == uuid_id)
+
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(TestRun.user_id == effective_user_id)
+
+    result = await session.execute(query)
+    test_run = result.scalar_one_or_none()
+    if not test_run:
+        raise HTTPException(status_code=404, detail="Test run not found")
+
+    if test_run.status != TestRunStatus.PENDING:
+        raise HTTPException(status_code=400, detail=f"Test is already {test_run.status}")
+
+    async def event_stream() -> AsyncGenerator[str, None]:
+        """Stream test progress directly from the service."""
+        service = TestService()
+        try:
+            async for progress in service.run_test(test_id):
+                yield f"data: {progress.model_dump_json()}\n\n"
+        except Exception as e:
+            from ..schemas.test import TestProgress
+            yield f"data: {TestProgress(event='error', test_run_id=test_id, message=str(e)).model_dump_json()}\n\n"
+
+    return StreamingResponse(
+        event_stream(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+        },
+    )
+
+
+@router.post("/{test_id}/cancel", response_model=TestRunResponse)
+async def cancel_test(
+    test_id: str,
+    session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
+) -> TestRun:
+    """Cancel a running test."""
+    uuid_id = parse_uuid(test_id)
+    query = select(TestRun).where(TestRun.id == uuid_id)
+
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(TestRun.user_id == effective_user_id)
+
+    result = await session.execute(query)
+    test_run = result.scalar_one_or_none()
+    if not test_run:
+        raise HTTPException(status_code=404, detail="Test run not found")
+
+    if test_run.status != TestRunStatus.RUNNING:
+        raise HTTPException(status_code=400, detail=f"Test is not running (status: {test_run.status})")
+
+    # Cancel the running task if it exists
+    if test_id in _running_tests:
+        _running_tests[test_id].cancel()
+        del _running_tests[test_id]
+
+    test_run.status = TestRunStatus.CANCELLED
+    await session.commit()
+    await session.refresh(test_run)
+    return test_run
+
+
+@router.delete("/{test_id}", status_code=204)
+async def delete_test(
+    test_id: str,
+    session: AsyncSession = Depends(get_session),
+    user: Annotated[TokenData | None, Depends(get_current_user)] = None,
+) -> None:
+    """Delete a test run."""
+    uuid_id = parse_uuid(test_id)
+    query = select(TestRun).where(TestRun.id == uuid_id)
+
+    if should_filter_by_user():
+        effective_user_id = get_effective_user_id(user)
+        query = query.where(TestRun.user_id == effective_user_id)
+
+    result = await session.execute(query)
+    test_run = result.scalar_one_or_none()
+    if not test_run:
+        raise HTTPException(status_code=404, detail="Test run not found")
+
+    if test_run.status == TestRunStatus.RUNNING:
+        raise HTTPException(status_code=400, detail="Cannot delete a running test")
+
+    await session.delete(test_run)
+    await session.commit()

src/flow/ui/auth/__init__.py

@@ -5,6 +5,7 @@ from .config import AuthSettings, AuthMode, get_auth_settings, init_auth_setting
 from .tokens import create_access_token, verify_access_token, TokenData
 from .middleware import get_current_user, require_auth
 from .router import router as auth_router
+from .user_context import get_effective_user_id, should_filter_by_user, ANONYMOUS_USER_ID
 
 __all__ = [
     "AuthSettings",
@@ -17,4 +18,7 @@ __all__ = [
     "get_current_user",
     "require_auth",
     "auth_router",
+    "get_effective_user_id",
+    "should_filter_by_user",
+    "ANONYMOUS_USER_ID",
 ]

src/flow/ui/auth/user_context.py

@@ -0,0 +1,48 @@
+# Copyright (c) Microsoft. All rights reserved.
+"""User context utilities for access control."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .config import get_auth_settings
+
+if TYPE_CHECKING:
+    from .tokens import TokenData
+
+# Constant for anonymous/unauthenticated users
+ANONYMOUS_USER_ID = "anonymous"
+
+
+def get_effective_user_id(user: TokenData | None) -> str:
+    """Get the effective user ID for database queries.
+
+    Returns the user's subject (sub) from the token if authenticated,
+    or ANONYMOUS_USER_ID if auth is disabled or no user is provided.
+
+    Args:
+        user: TokenData from authentication, or None
+
+    Returns:
+        User ID string to use for database operations
+    """
+    settings = get_auth_settings()
+
+    # If auth is disabled, everyone is "anonymous"
+    if not settings.enabled:
+        return ANONYMOUS_USER_ID
+
+    # If auth is enabled but no user (shouldn't happen in protected routes)
+    if user is None:
+        return ANONYMOUS_USER_ID
+
+    # Return the user's subject identifier
+    return user.sub
+
+
+def should_filter_by_user() -> bool:
+    """Check if queries should filter by user_id.
+
+    Returns True only when auth is enabled.
+    """
+    return get_auth_settings().enabled

src/flow/ui/database.py

@@ -2,9 +2,10 @@
 """Database setup with SQLModel and SQLite."""
 
 import logging
+from collections.abc import AsyncGenerator
 from pathlib import Path
-from typing import AsyncGenerator
 
+from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 from sqlmodel import SQLModel
 
@@ -22,12 +23,14 @@ async_session = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit
 
 
 async def init_db() -> None:
-    """Initialize database tables."""
-    from flow.ui.models import AgentConfig, TaskModel, OptimizationJob, ExperimentRun  # noqa: F401
+    """Initialize database tables and run migrations."""
+    from flow.ui.models import AgentConfig, ExperimentRun, OptimizationJob, TaskModel, TestRun  # noqa: F401
 
     try:
         async with engine.begin() as conn:
             await conn.run_sync(SQLModel.metadata.create_all)
+            # Run migration for user_id columns (safe to run multiple times)
+            await _migrate_user_id_columns(conn)
     except Exception as e:
         if "already exists" in str(e).lower():
             logger.debug("Tables already exist (race condition handled)")
@@ -35,6 +38,56 @@ async def init_db() -> None:
             raise
 
 
+async def _migrate_user_id_columns(conn) -> None:  # type: ignore[no-untyped-def]
+    """Add user_id columns if they don't exist and backfill existing data.
+
+    This migration is idempotent - safe to run multiple times.
+    """
+    from flow.ui.auth.user_context import ANONYMOUS_USER_ID
+
+    # Check and migrate agent_configs
+    try:
+        await conn.execute(text("SELECT user_id FROM agent_configs LIMIT 1"))
+        logger.debug("agent_configs.user_id column exists")
+    except Exception:
+        # Column doesn't exist, add it
+        logger.info("Adding user_id column to agent_configs")
+        await conn.execute(text("ALTER TABLE agent_configs ADD COLUMN user_id TEXT"))
+        await conn.execute(
+            text(f"UPDATE agent_configs SET user_id = '{ANONYMOUS_USER_ID}' WHERE user_id IS NULL")
+        )
+        await conn.execute(text("CREATE INDEX IF NOT EXISTS ix_agent_configs_user_id ON agent_configs(user_id)"))
+
+    # Check and migrate tasks
+    try:
+        await conn.execute(text("SELECT user_id FROM tasks LIMIT 1"))
+        logger.debug("tasks.user_id column exists")
+    except Exception:
+        # Column doesn't exist, add it
+        logger.info("Adding user_id column to tasks")
+        await conn.execute(text("ALTER TABLE tasks ADD COLUMN user_id TEXT"))
+        # For tasks: only backfill non-suite tasks (suite tasks remain shared with user_id=NULL)
+        await conn.execute(
+            text(f"UPDATE tasks SET user_id = '{ANONYMOUS_USER_ID}' WHERE user_id IS NULL AND suite IS NULL")
+        )
+        await conn.execute(text("CREATE INDEX IF NOT EXISTS ix_tasks_user_id ON tasks(user_id)"))
+
+    # Check and migrate optimization_jobs
+    try:
+        await conn.execute(text("SELECT user_id FROM optimization_jobs LIMIT 1"))
+        logger.debug("optimization_jobs.user_id column exists")
+    except Exception:
+        # Column doesn't exist, add it
+        logger.info("Adding user_id column to optimization_jobs")
+        await conn.execute(text("ALTER TABLE optimization_jobs ADD COLUMN user_id TEXT"))
+        await conn.execute(
+            text(f"UPDATE optimization_jobs SET user_id = '{ANONYMOUS_USER_ID}' WHERE user_id IS NULL")
+        )
+        await conn.execute(
+            text("CREATE INDEX IF NOT EXISTS ix_optimization_jobs_user_id ON optimization_jobs(user_id)")
+        )
+
+
 async def get_session() -> AsyncGenerator[AsyncSession, None]:
     """Get database session."""
     async with async_session() as session:

src/flow/ui/main.py

@@ -12,7 +12,7 @@ from fastapi.responses import FileResponse
 from starlette.middleware.base import BaseHTTPMiddleware
 
 from .database import init_db
-from .api import configs_router, tasks_router, jobs_router, runs_router
+from .api import configs_router, tasks_router, jobs_router, runs_router, tests_router
 from .auth import auth_router, AuthSettings, get_auth_settings, init_auth_settings
 from .auth.middleware import AuthMiddleware
 
@@ -66,6 +66,7 @@ app.include_router(configs_router, prefix="/api")
 app.include_router(tasks_router, prefix="/api")
 app.include_router(jobs_router, prefix="/api")
 app.include_router(runs_router, prefix="/api")
+app.include_router(tests_router, prefix="/api")
 
 
 # Health check (public, not protected by auth)

src/flow/ui/models/__init__.py

@@ -5,6 +5,7 @@ from .config import AgentConfig
 from .task import TaskModel
 from .job import OptimizationJob, JobStatus
 from .run import ExperimentRun
+from .test_run import TestRun, TestRunStatus
 
 __all__ = [
     "AgentConfig",
@@ -12,4 +13,6 @@ __all__ = [
     "OptimizationJob",
     "JobStatus",
     "ExperimentRun",
+    "TestRun",
+    "TestRunStatus",
 ]

src/flow/ui/models/config.py

@@ -25,6 +25,9 @@ class AgentConfig(SQLModel, table=True):
     # Link to the job that created this candidate (if auto-generated)
     job_id: UUID | None = Field(default=None, index=True)
 
+    # Owner of this config (None for legacy data, will be backfilled)
+    user_id: str | None = Field(default=None, index=True)
+
     created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
 

src/flow/ui/models/job.py

@@ -26,6 +26,9 @@ class OptimizationJob(SQLModel, table=True):
     id: UUID = Field(default_factory=uuid4, primary_key=True)
     name: str = Field(default="")
 
+    # Owner of this job
+    user_id: str | None = Field(default=None, index=True)
+
     status: JobStatus = Field(default=JobStatus.PENDING)
 
     # Job configuration

src/flow/ui/models/task.py

@@ -24,6 +24,9 @@ class TaskModel(SQLModel, table=True):
     category: str = "default"
     suite: str | None = None  # If part of a built-in suite
 
+    # Owner of this task (None = shared/built-in suite task, visible to all)
+    user_id: str | None = Field(default=None, index=True)
+
     created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
 
     @property

src/flow/ui/models/test_run.py

@@ -0,0 +1,62 @@
+# Copyright (c) Microsoft. All rights reserved.
+"""Test run model for interactive agent testing."""
+
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any
+from uuid import UUID, uuid4
+
+from sqlmodel import Column, Field, JSON, SQLModel
+
+
+class TestRunStatus(str, Enum):
+    """Status of a test run."""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class TestRun(SQLModel, table=True):
+    """Individual test run for interactive agent testing."""
+
+    __tablename__ = "test_runs"  # type: ignore[assignment]
+
+    id: UUID = Field(default_factory=uuid4, primary_key=True)
+    agent_id: UUID = Field(foreign_key="agent_configs.id", index=True)
+
+    # Input
+    prompt: str
+    task_id: UUID | None = Field(default=None, foreign_key="tasks.id")
+
+    # Status
+    status: TestRunStatus = Field(default=TestRunStatus.PENDING)
+
+    # Results
+    output: str = ""
+    trace_json: dict[str, Any] = Field(default_factory=dict, sa_column=Column(JSON))
+    files_created: list[str] = Field(default_factory=list, sa_column=Column(JSON))
+
+    # Metrics
+    tokens_total: int = 0
+    tokens_input: int = 0
+    tokens_output: int = 0
+    duration_seconds: float = 0.0
+
+    # Evaluation (if task linked)
+    score: float | None = None
+    passed: bool | None = None
+    reasoning: str = ""
+
+    # Error info
+    error: str | None = None
+
+    # Timestamps
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+
+    # Multi-tenancy
+    user_id: str | None = Field(default=None, index=True)

src/flow/ui/schemas/__init__.py

@@ -5,6 +5,7 @@ from .config import AgentCreate, AgentUpdate, AgentResponse
 from .task import TaskCreate, TaskResponse, CriterionSchema
 from .job import JobCreate, JobResponse, JobProgress
 from .run import RunResponse, RunDetailResponse, CriterionResultSchema
+from .test import TestRunCreate, TestRunResponse, TestRunDetailResponse, TestProgress
 
 __all__ = [
     "AgentCreate",
@@ -19,4 +20,8 @@ __all__ = [
     "RunResponse",
     "RunDetailResponse",
     "CriterionResultSchema",
+    "TestRunCreate",
+    "TestRunResponse",
+    "TestRunDetailResponse",
+    "TestProgress",
 ]

src/flow/ui/schemas/config.py

@@ -63,6 +63,7 @@ class AgentResponse(BaseModel):
     config: dict[str, Any]
     is_auto_generated: bool = False
     job_id: str | None = None
+    user_id: str | None = None
     created_at: datetime
     updated_at: datetime
 

src/flow/ui/schemas/job.py

@@ -36,6 +36,7 @@ class JobResponse(BaseModel):
     error: str | None
     total_experiments: int
     completed_experiments: int
+    user_id: str | None = None
     created_at: datetime
     started_at: datetime | None
     completed_at: datetime | None

src/flow/ui/schemas/task.py

@@ -40,6 +40,7 @@ class TaskResponse(BaseModel):
     criteria: list[CriterionSchema]
     category: str
     suite: str | None
+    user_id: str | None = None
     created_at: datetime
 
     @field_validator("id", mode="before")

src/flow/ui/schemas/test.py

@@ -0,0 +1,107 @@
+# Copyright (c) Microsoft. All rights reserved.
+"""Test run schemas."""
+
+from datetime import datetime
+from typing import Any, Literal
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, field_validator
+
+
+class TestRunCreate(BaseModel):
+    """Request schema for creating a test run."""
+
+    agent_id: str
+    prompt: str
+    task_id: str | None = None
+
+
+class TestRunResponse(BaseModel):
+    """Response schema for a test run (summary)."""
+
+    model_config = ConfigDict(from_attributes=True)
+
+    id: str
+    agent_id: str
+    prompt: str
+    task_id: str | None
+    status: str
+    tokens_total: int
+    duration_seconds: float
+    score: float | None
+    passed: bool | None
+    error: str | None
+    created_at: datetime
+    started_at: datetime | None
+    completed_at: datetime | None
+
+    @field_validator("id", "agent_id", "task_id", mode="before")
+    @classmethod
+    def convert_uuid(cls, v: UUID | str | None) -> str | None:
+        """Convert UUID to string."""
+        if isinstance(v, UUID):
+            return str(v)
+        return v
+
+
+class TestRunDetailResponse(BaseModel):
+    """Response schema for test run details."""
+
+    model_config = ConfigDict(from_attributes=True)
+
+    id: str
+    agent_id: str
+    prompt: str
+    task_id: str | None
+    status: str
+
+    # Metrics
+    tokens_total: int
+    tokens_input: int
+    tokens_output: int
+    duration_seconds: float
+
+    # Evaluation (if task linked)
+    score: float | None
+    passed: bool | None
+    reasoning: str
+
+    # Output
+    output: str
+    files_created: list[str]
+    trace: dict[str, Any]
+
+    # Error
+    error: str | None
+
+    # Timestamps
+    created_at: datetime
+    started_at: datetime | None
+    completed_at: datetime | None
+
+    @field_validator("id", "agent_id", "task_id", mode="before")
+    @classmethod
+    def convert_uuid(cls, v: UUID | str | None) -> str | None:
+        """Convert UUID to string."""
+        if isinstance(v, UUID):
+            return str(v)
+        return v
+
+
+class TestProgress(BaseModel):
+    """SSE event for test streaming."""
+
+    event: Literal["started", "execution", "span", "complete", "error"]
+    test_run_id: str
+    message: str = ""
+
+    # For execution events
+    execution_event: str | None = None  # text_delta, tool_call_start, etc.
+    content: str | None = None
+    tool_name: str | None = None
+
+    # For span events
+    span: dict[str, Any] | None = None
+
+    # For complete event
+    result: TestRunResponse | None = None

src/flow/ui/services/test_service.py

@@ -0,0 +1,308 @@
+# Copyright (c) Microsoft. All rights reserved.
+"""Service for running interactive agent tests with real-time trace streaming."""
+
+import asyncio
+import logging
+import os
+import tempfile
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, AsyncGenerator
+from uuid import UUID
+
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor, SpanExporter, SpanExportResult
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import select
+
+from flow.experiments.models import CompactionConfig
+from flow.experiments.metrics import extract_metrics
+from flow.experiments.trace_collector import FlowTraceCollector
+from flow.harness.base import EventType
+from flow.harness.maf import MAFHarness
+from flow.harness.maf.agent import create_agent
+
+from ..database import async_session
+from ..models.config import AgentConfig
+from ..models.test_run import TestRun, TestRunStatus
+from ..schemas.test import TestProgress
+
+logger = logging.getLogger(__name__)
+
+
+class StreamingTraceCollector(FlowTraceCollector):
+    """Trace collector that pushes spans to a queue for real-time streaming."""
+
+    def __init__(self, span_queue: asyncio.Queue[dict[str, Any]]) -> None:
+        """Initialize with a queue for span streaming.
+
+        Args:
+            span_queue: Queue to push spans to for SSE streaming
+        """
+        super().__init__()
+        self._queue = span_queue
+
+    def export(self, spans: Any) -> SpanExportResult:
+        """Export spans and push to queue for streaming."""
+        # Get count before export
+        count_before = len(self.spans)
+
+        # Call parent export which populates self.spans
+        result = super().export(spans)
+
+        # Push newly added spans to queue
+        for span in self.spans[count_before:]:
+            try:
+                self._queue.put_nowait(span)
+            except asyncio.QueueFull:
+                logger.debug("Span queue full, dropping span")
+
+        return result
+
+
+class TestService:
+    """Service for running interactive agent tests."""
+
+    async def run_test(self, test_run_id: str | UUID) -> AsyncGenerator[TestProgress, None]:
+        """Run an agent test and yield real-time progress with spans.
+
+        Args:
+            test_run_id: ID of the test run to execute
+
+        Yields:
+            TestProgress events for SSE streaming
+        """
+        if isinstance(test_run_id, str):
+            test_run_id = UUID(test_run_id)
+
+        async with async_session() as session:
+            # Load test run
+            result = await session.execute(
+                select(TestRun).where(TestRun.id == test_run_id)
+            )
+            test_run = result.scalar_one_or_none()
+            if not test_run:
+                yield TestProgress(
+                    event="error",
+                    test_run_id=str(test_run_id),
+                    message="Test run not found",
+                )
+                return
+
+            # Load agent config
+            agent_result = await session.execute(
+                select(AgentConfig).where(AgentConfig.id == test_run.agent_id)
+            )
+            agent_config = agent_result.scalar_one_or_none()
+            if not agent_config:
+                yield TestProgress(
+                    event="error",
+                    test_run_id=str(test_run_id),
+                    message="Agent config not found",
+                )
+                return
+
+            # Update status to running
+            test_run.status = TestRunStatus.RUNNING
+            test_run.started_at = datetime.now(timezone.utc)
+            await session.commit()
+
+            yield TestProgress(
+                event="started",
+                test_run_id=str(test_run_id),
+                message="Starting test execution...",
+            )
+
+            # Set up span queue for streaming
+            span_queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue(maxsize=1000)
+
+            # Create workspace
+            workspace = Path(tempfile.mkdtemp(prefix="flow_test_"))
+
+            try:
+                # Set up streaming trace collection
+                collector = StreamingTraceCollector(span_queue)
+                processor: SimpleSpanProcessor | None = None
+
+                provider = trace.get_tracer_provider()
+                if isinstance(provider, TracerProvider):
+                    processor = SimpleSpanProcessor(collector)
+                    provider.add_span_processor(processor)
+
+                # Create agent from config
+                harness = self._create_harness_from_config(agent_config, workspace)
+
+                # Execute agent with streaming
+                start_time = time.time()
+                output_chunks: list[str] = []
+                error: str | None = None
+
+                original_cwd = os.getcwd()
+                os.chdir(workspace)
+
+                try:
+                    async for event in harness.run_stream(test_run.prompt):
+                        # Yield execution events
+                        if event.type == EventType.TEXT_DELTA:
+                            output_chunks.append(event.content)
+                            yield TestProgress(
+                                event="execution",
+                                test_run_id=str(test_run_id),
+                                execution_event="text_delta",
+                                content=event.content,
+                            )
+                        elif event.type == EventType.TOOL_CALL_START:
+                            yield TestProgress(
+                                event="execution",
+                                test_run_id=str(test_run_id),
+                                execution_event="tool_call_start",
+                                tool_name=event.tool_name,
+                            )
+                        elif event.type == EventType.TOOL_RESULT:
+                            yield TestProgress(
+                                event="execution",
+                                test_run_id=str(test_run_id),
+                                execution_event="tool_result",
+                                content=event.content[:500] if event.content else "",  # Truncate long results
+                            )
+
+                        # Drain span queue and yield span events
+                        while not span_queue.empty():
+                            try:
+                                span_data = span_queue.get_nowait()
+                                yield TestProgress(
+                                    event="span",
+                                    test_run_id=str(test_run_id),
+                                    span=span_data,
+                                )
+                            except asyncio.QueueEmpty:
+                                break
+
+                except Exception as e:
+                    error = str(e)
+                    logger.error(f"Test execution failed: {e}")
+                finally:
+                    os.chdir(original_cwd)
+
+                end_time = time.time()
+                duration_seconds = end_time - start_time
+
+                # Force flush and get all traces
+                if processor:
+                    try:
+                        processor.force_flush()
+                    except Exception as e:
+                        logger.debug(f"Error flushing processor: {e}")
+
+                # Drain remaining spans
+                while not span_queue.empty():
+                    try:
+                        span_data = span_queue.get_nowait()
+                        yield TestProgress(
+                            event="span",
+                            test_run_id=str(test_run_id),
+                            span=span_data,
+                        )
+                    except asyncio.QueueEmpty:
+                        break
+
+                # Get final trace data
+                trace_data = collector.get_traces()
+
+                # Clean up processor
+                if processor:
+                    try:
+                        processor.shutdown()
+                    except Exception as e:
+                        logger.debug(f"Error shutting down processor: {e}")
+
+                # Extract metrics from trace
+                metrics = extract_metrics(trace_data)
+
+                # Update test run with results
+                test_run.output = "".join(output_chunks)
+                test_run.trace_json = {"spans": trace_data}
+                test_run.tokens_total = metrics.total_tokens
+                test_run.tokens_input = metrics.input_tokens
+                test_run.tokens_output = metrics.output_tokens
+                test_run.duration_seconds = duration_seconds
+
+                if error:
+                    test_run.status = TestRunStatus.FAILED
+                    test_run.error = error
+                else:
+                    test_run.status = TestRunStatus.COMPLETED
+
+                test_run.completed_at = datetime.now(timezone.utc)
+                await session.commit()
+
+                # Yield completion
+                from ..schemas.test import TestRunResponse
+                yield TestProgress(
+                    event="complete",
+                    test_run_id=str(test_run_id),
+                    message="Test completed",
+                    result=TestRunResponse.model_validate(test_run),
+                )
+
+            except Exception as e:
+                test_run.status = TestRunStatus.FAILED
+                test_run.error = str(e)
+                test_run.completed_at = datetime.now(timezone.utc)
+                await session.commit()
+
+                yield TestProgress(
+                    event="error",
+                    test_run_id=str(test_run_id),
+                    message=f"Test failed: {e}",
+                )
+
+            finally:
+                # Clean up workspace
+                try:
+                    import shutil
+                    shutil.rmtree(workspace)
+                except Exception as e:
+                    logger.debug(f"Failed to clean up workspace: {e}")
+
+    def _create_harness_from_config(
+        self, agent_config: AgentConfig, workspace: Path
+    ) -> MAFHarness:
+        """Create a MAFHarness from an agent config.
+
+        Args:
+            agent_config: The agent configuration from database
+            workspace: Workspace directory for agent execution
+
+        Returns:
+            Configured MAFHarness
+        """
+        cfg = agent_config.config_json
+
+        # Extract compaction config
+        compaction_data = cfg.get("compaction", {})
+        enable_compaction = compaction_data.get("strategy", "head_tail") != "none"
+        params = compaction_data.get("params", {})
+        compaction_head_size = params.get("head_size", 10)
+        compaction_tail_size = params.get("tail_size", 40)
+
+        # Get tools configuration
+        tools = cfg.get("tools", "standard")
+
+        # Get instructions
+        instructions = cfg.get("instructions")
+
+        # Create agent
+        agent = create_agent(
+            name=agent_config.name,
+            instructions=instructions,
+            tools=tools,
+            workspace=workspace,
+            enable_compaction=enable_compaction,
+            compaction_head_size=compaction_head_size,
+            compaction_tail_size=compaction_tail_size,
+        )
+
+        return MAFHarness(agent)

src/flow/ui/tests/test_test_service.py

@@ -0,0 +1,152 @@
+# Copyright (c) Microsoft. All rights reserved.
+"""Unit tests for the TestService and StreamingTraceCollector."""
+
+import asyncio
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+from opentelemetry.sdk.trace.export import SpanExportResult
+
+from flow.ui.services.test_service import StreamingTraceCollector
+
+
+def create_mock_span(name: str, span_id: int = 12345, trace_id: int = 67890) -> MagicMock:
+    """Create a mock OpenTelemetry span with proper structure."""
+    mock_span = MagicMock()
+    # The FlowTraceCollector accesses span.context, not span.get_span_context()
+    mock_span.context = MagicMock()
+    mock_span.context.span_id = span_id
+    mock_span.context.trace_id = trace_id
+    mock_span.name = name
+    mock_span.start_time = 1000000000000000000  # nanoseconds
+    mock_span.end_time = 2000000000000000000    # nanoseconds
+    mock_span.status = MagicMock()
+    mock_span.status.status_code = MagicMock()
+    mock_span.status.status_code.name = "OK"
+    mock_span.parent = None
+    mock_span.attributes = {"key": "value"}
+    mock_span.events = []
+    return mock_span
+
+
+class TestStreamingTraceCollector:
+    """Tests for the StreamingTraceCollector class."""
+
+    @pytest.mark.asyncio
+    async def test_span_queue_receives_spans(self):
+        """Test that spans are pushed to the queue when exported."""
+        queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue(maxsize=100)
+        collector = StreamingTraceCollector(queue)
+
+        mock_span = create_mock_span("test_span")
+
+        # Export the span
+        result = collector.export([mock_span])
+        assert result == SpanExportResult.SUCCESS
+
+        # Verify span was added to collector
+        assert len(collector.spans) == 1
+
+        # Verify span was pushed to queue
+        assert not queue.empty()
+        span_data = await queue.get()
+        # StreamingTraceCollector pushes the span dict from parent class
+        assert "data" in span_data
+        assert span_data["data"]["operation_name"] == "test_span"
+
+    @pytest.mark.asyncio
+    async def test_multiple_spans_exported(self):
+        """Test exporting multiple spans in sequence."""
+        queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue(maxsize=100)
+        collector = StreamingTraceCollector(queue)
+
+        # Create and export multiple mock spans
+        for i in range(5):
+            mock_span = create_mock_span(f"span_{i}", span_id=i, trace_id=1000)
+            collector.export([mock_span])
+
+        # Verify all spans were collected
+        assert len(collector.spans) == 5
+
+        # Verify all spans were pushed to queue
+        received_spans = []
+        while not queue.empty():
+            received_spans.append(await queue.get())
+        assert len(received_spans) == 5
+
+    @pytest.mark.asyncio
+    async def test_queue_full_does_not_block(self):
+        """Test that a full queue doesn't block the export."""
+        # Create a very small queue
+        queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue(maxsize=1)
+        collector = StreamingTraceCollector(queue)
+
+        # Fill the queue first
+        await queue.put({"dummy": "span"})
+        assert queue.full()
+
+        mock_span = create_mock_span("blocked_span")
+
+        # This should complete without blocking
+        result = collector.export([mock_span])
+        assert result == SpanExportResult.SUCCESS
+
+        # Span should still be in collector even if not in queue
+        assert len(collector.spans) == 1
+
+    @pytest.mark.asyncio
+    async def test_get_traces_returns_all_spans(self):
+        """Test that get_traces returns all collected spans."""
+        queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue(maxsize=100)
+        collector = StreamingTraceCollector(queue)
+
+        # Export some spans
+        for i in range(3):
+            mock_span = create_mock_span(f"span_{i}", span_id=i, trace_id=1000)
+            collector.export([mock_span])
+
+        # Get all traces - note this clears the spans
+        traces = collector.get_traces()
+        assert len(traces) == 3
+
+        # Verify spans are cleared after get_traces
+        traces_after = collector.get_traces()
+        assert len(traces_after) == 0
+
+    @pytest.mark.asyncio
+    async def test_inherits_from_flow_trace_collector(self):
+        """Test that StreamingTraceCollector properly inherits from FlowTraceCollector."""
+        from flow.experiments.trace_collector import FlowTraceCollector
+
+        queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue(maxsize=100)
+        collector = StreamingTraceCollector(queue)
+
+        assert isinstance(collector, FlowTraceCollector)
+        assert hasattr(collector, "get_traces")
+        assert hasattr(collector, "clear")
+        assert hasattr(collector, "force_flush")
+        assert hasattr(collector, "shutdown")
+
+
+class TestTestServiceHelpers:
+    """Tests for TestService helper methods."""
+
+    def test_parse_uuid_valid(self):
+        """Test parsing a valid UUID string."""
+        from flow.ui.api.tests import parse_uuid
+        from uuid import UUID
+
+        result = parse_uuid("12345678-1234-1234-1234-123456789abc")
+        assert isinstance(result, UUID)
+        assert str(result) == "12345678-1234-1234-1234-123456789abc"
+
+    def test_parse_uuid_invalid(self):
+        """Test parsing an invalid UUID string raises HTTPException."""
+        from flow.ui.api.tests import parse_uuid
+        from fastapi import HTTPException
+
+        with pytest.raises(HTTPException) as exc_info:
+            parse_uuid("not-a-uuid")
+        assert exc_info.value.status_code == 400
+        assert "Invalid UUID" in str(exc_info.value.detail)

src/flow/ui/tests/test_tests_api.py

@@ -0,0 +1,239 @@
+# Copyright (c) Microsoft. All rights reserved.
+"""Unit tests for the tests API routes."""
+
+from typing import AsyncGenerator
+
+import httpx
+import pytest
+
+from flow.ui.main import app
+from flow.ui.database import init_db
+
+
+@pytest.fixture
+async def client() -> AsyncGenerator[httpx.AsyncClient, None]:
+    """Create an ASGI test client."""
+    await init_db()
+
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app),
+        base_url="http://test",
+        timeout=30.0,
+    ) as client:
+        yield client
+
+
+class TestTestsAPI:
+    """Tests for the /api/tests endpoints."""
+
+    @pytest.mark.asyncio
+    async def test_create_test_run_requires_valid_agent(self, client: httpx.AsyncClient):
+        """Test that creating a test run requires a valid agent ID."""
+        # Try to create test with non-existent agent
+        resp = await client.post(
+            "/api/tests",
+            json={
+                "agent_id": "00000000-0000-0000-0000-000000000000",
+                "prompt": "test prompt",
+            },
+        )
+        assert resp.status_code == 400
+        assert "Agent not found" in resp.json()["detail"]
+
+    @pytest.mark.asyncio
+    async def test_create_test_run_invalid_uuid(self, client: httpx.AsyncClient):
+        """Test that invalid UUID returns 400."""
+        resp = await client.post(
+            "/api/tests",
+            json={
+                "agent_id": "not-a-uuid",
+                "prompt": "test prompt",
+            },
+        )
+        assert resp.status_code == 400
+        assert "Invalid UUID" in resp.json()["detail"]
+
+    @pytest.mark.asyncio
+    async def test_list_tests_empty(self, client: httpx.AsyncClient):
+        """Test listing tests when none exist."""
+        resp = await client.get("/api/tests")
+        assert resp.status_code == 200
+        assert isinstance(resp.json(), list)
+
+    @pytest.mark.asyncio
+    async def test_get_test_not_found(self, client: httpx.AsyncClient):
+        """Test getting a non-existent test returns 404."""
+        resp = await client.get("/api/tests/00000000-0000-0000-0000-000000000000")
+        assert resp.status_code == 404
+        assert "not found" in resp.json()["detail"].lower()
+
+    @pytest.mark.asyncio
+    async def test_cancel_test_not_found(self, client: httpx.AsyncClient):
+        """Test cancelling a non-existent test returns 404."""
+        resp = await client.post("/api/tests/00000000-0000-0000-0000-000000000000/cancel")
+        assert resp.status_code == 404
+
+    @pytest.mark.asyncio
+    async def test_delete_test_not_found(self, client: httpx.AsyncClient):
+        """Test deleting a non-existent test returns 404."""
+        resp = await client.delete("/api/tests/00000000-0000-0000-0000-000000000000")
+        assert resp.status_code == 404
+
+    @pytest.mark.asyncio
+    async def test_start_test_not_found(self, client: httpx.AsyncClient):
+        """Test starting a non-existent test returns 404."""
+        resp = await client.post("/api/tests/00000000-0000-0000-0000-000000000000/start")
+        assert resp.status_code == 404
+
+    @pytest.mark.asyncio
+    async def test_full_test_run_lifecycle(self, client: httpx.AsyncClient):
+        """Test the complete lifecycle: create agent -> create test -> list tests."""
+        # Step 1: Create an agent
+        agent_data = {
+            "name": "test-agent-for-tests",
+            "description": "Agent for testing the tests API",
+            "enable_message_compaction": False,
+            "enable_memory_tool": False,
+            "enable_sub_agent": False,
+            "bash_timeout": 60,
+        }
+        agent_resp = await client.post("/api/configs", json=agent_data)
+        assert agent_resp.status_code == 201, f"Failed to create agent: {agent_resp.text}"
+        agent = agent_resp.json()
+        agent_id = agent["id"]
+
+        try:
+            # Step 2: Create a test run
+            test_data = {
+                "agent_id": agent_id,
+                "prompt": "Write hello world",
+            }
+            test_resp = await client.post("/api/tests", json=test_data)
+            assert test_resp.status_code == 201, f"Failed to create test: {test_resp.text}"
+            test_run = test_resp.json()
+            test_id = test_run["id"]
+
+            # Verify test run fields
+            assert test_run["agent_id"] == agent_id
+            assert test_run["prompt"] == "Write hello world"
+            assert test_run["status"] == "pending"
+            assert test_run["tokens_total"] == 0
+
+            # Step 3: List tests - should see our test
+            list_resp = await client.get("/api/tests")
+            assert list_resp.status_code == 200
+            tests = list_resp.json()
+            assert any(t["id"] == test_id for t in tests)
+
+            # Step 4: List tests filtered by agent
+            list_agent_resp = await client.get(f"/api/tests?agent_id={agent_id}")
+            assert list_agent_resp.status_code == 200
+            agent_tests = list_agent_resp.json()
+            assert len(agent_tests) >= 1
+            assert all(t["agent_id"] == agent_id for t in agent_tests)
+
+            # Step 5: Get test details
+            detail_resp = await client.get(f"/api/tests/{test_id}")
+            assert detail_resp.status_code == 200
+            detail = detail_resp.json()
+            assert detail["id"] == test_id
+            assert detail["prompt"] == "Write hello world"
+            assert "trace" in detail  # Detail response includes trace
+
+            # Step 6: Delete the test
+            delete_resp = await client.delete(f"/api/tests/{test_id}")
+            assert delete_resp.status_code == 204
+
+            # Verify test is deleted
+            get_deleted = await client.get(f"/api/tests/{test_id}")
+            assert get_deleted.status_code == 404
+
+        finally:
+            # Clean up: delete agent
+            await client.delete(f"/api/configs/{agent_id}")
+
+    @pytest.mark.asyncio
+    async def test_create_test_with_task(self, client: httpx.AsyncClient):
+        """Test creating a test run linked to a task."""
+        # Create agent
+        agent_resp = await client.post(
+            "/api/configs",
+            json={
+                "name": "test-agent-with-task",
+                "description": "Test agent",
+                "enable_message_compaction": False,
+                "enable_memory_tool": False,
+                "enable_sub_agent": False,
+                "bash_timeout": 60,
+            },
+        )
+        assert agent_resp.status_code == 201
+        agent_id = agent_resp.json()["id"]
+
+        # Create task
+        task_resp = await client.post(
+            "/api/tasks",
+            json={
+                "name": "test-task",
+                "prompt": "Write a function",
+                "criteria": [{"name": "correctness", "instruction": "Check if code works correctly"}],
+            },
+        )
+        assert task_resp.status_code == 201
+        task_id = task_resp.json()["id"]
+
+        try:
+            # Create test with task
+            test_resp = await client.post(
+                "/api/tests",
+                json={
+                    "agent_id": agent_id,
+                    "prompt": "Write a function",
+                    "task_id": task_id,
+                },
+            )
+            assert test_resp.status_code == 201
+            test_run = test_resp.json()
+            assert test_run["task_id"] == task_id
+
+            # Clean up test
+            await client.delete(f"/api/tests/{test_run['id']}")
+
+        finally:
+            # Clean up
+            await client.delete(f"/api/tasks/{task_id}")
+            await client.delete(f"/api/configs/{agent_id}")
+
+    @pytest.mark.asyncio
+    async def test_create_test_with_invalid_task(self, client: httpx.AsyncClient):
+        """Test creating a test run with non-existent task fails."""
+        # Create agent
+        agent_resp = await client.post(
+            "/api/configs",
+            json={
+                "name": "test-agent-invalid-task",
+                "description": "Test agent",
+                "enable_message_compaction": False,
+                "enable_memory_tool": False,
+                "enable_sub_agent": False,
+                "bash_timeout": 60,
+            },
+        )
+        assert agent_resp.status_code == 201
+        agent_id = agent_resp.json()["id"]
+
+        try:
+            # Create test with non-existent task
+            test_resp = await client.post(
+                "/api/tests",
+                json={
+                    "agent_id": agent_id,
+                    "prompt": "Write a function",
+                    "task_id": "00000000-0000-0000-0000-000000000000",
+                },
+            )
+            assert test_resp.status_code == 400
+            assert "Task not found" in test_resp.json()["detail"]
+
+        finally:
+            await client.delete(f"/api/configs/{agent_id}")

src/flow/ui/ui/assets/index-B2HaxLdE.css

@@ -0,0 +1 @@
+*,:before,:after{--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: rgb(59 130 246 / .5);--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: }::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: rgb(59 130 246 / .5);--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-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html,:host{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}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;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:JetBrains Mono,ui-monospace,monospace;font-feature-settings:normal;font-variation-settings:normal;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings: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:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-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{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,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{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]:where(:not([hidden=until-found])){display:none}.pointer-events-none{pointer-events:none}.fixed{position:fixed}.absolute{position:absolute}.relative{position:relative}.sticky{position:sticky}.inset-0{top:0;right:0;bottom:0;left:0}.bottom-0{bottom:0}.left-0{left:0}.left-3{left:.75rem}.top-0{top:0}.top-1\/2{top:50%}.z-10{z-index:10}.z-50{z-index:50}.mx-0\.5{margin-left:.125rem;margin-right:.125rem}.mx-4{margin-left:1rem;margin-right:1rem}.mx-auto{margin-left:auto;margin-right:auto}.-mt-1{margin-top:-.25rem}.mb-1{margin-bottom:.25rem}.mb-2{margin-bottom:.5rem}.mb-3{margin-bottom:.75rem}.mb-4{margin-bottom:1rem}.mb-6{margin-bottom:1.5rem}.mb-8{margin-bottom:2rem}.ml-2{margin-left:.5rem}.ml-4{margin-left:1rem}.ml-6{margin-left:1.5rem}.mr-1{margin-right:.25rem}.mt-0\.5{margin-top:.125rem}.mt-1{margin-top:.25rem}.mt-2{margin-top:.5rem}.mt-3{margin-top:.75rem}.mt-4{margin-top:1rem}.mt-8{margin-top:2rem}.mt-auto{margin-top:auto}.line-clamp-2{overflow:hidden;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:2}.line-clamp-3{overflow:hidden;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:3}.block{display:block}.inline-block{display:inline-block}.flex{display:flex}.inline-flex{display:inline-flex}.table{display:table}.grid{display:grid}.hidden{display:none}.h-1\.5{height:.375rem}.h-12{height:3rem}.h-2{height:.5rem}.h-3{height:.75rem}.h-32{height:8rem}.h-4{height:1rem}.h-5{height:1.25rem}.h-6{height:1.5rem}.h-8{height:2rem}.h-80{height:20rem}.h-full{height:100%}.max-h-32{max-height:8rem}.max-h-40{max-height:10rem}.max-h-48{max-height:12rem}.max-h-96{max-height:24rem}.max-h-\[80vh\]{max-height:80vh}.min-h-\[100px\]{min-height:100px}.min-h-screen{min-height:100vh}.w-12{width:3rem}.w-2{width:.5rem}.w-20{width:5rem}.w-24{width:6rem}.w-3{width:.75rem}.w-32{width:8rem}.w-4{width:1rem}.w-5{width:1.25rem}.w-6{width:1.5rem}.w-8{width:2rem}.w-full{width:100%}.min-w-0{min-width:0px}.min-w-\[90px\]{min-width:90px}.max-w-7xl{max-width:80rem}.max-w-full{max-width:100%}.max-w-lg{max-width:32rem}.max-w-md{max-width:28rem}.flex-1{flex:1 1 0%}.flex-shrink-0{flex-shrink:0}.-translate-y-1\/2{--tw-translate-y: -50%;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.rotate-180{--tw-rotate: 180deg;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(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)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}@keyframes pulse{50%{opacity:.5}}.animate-pulse{animation:pulse 2s cubic-bezier(.4,0,.6,1) infinite}@keyframes spin{to{transform:rotate(360deg)}}.animate-spin{animation:spin 1s linear infinite}.cursor-pointer{cursor:pointer}.select-none{-webkit-user-select:none;-moz-user-select:none;user-select:none}.resize-none{resize:none}.resize-y{resize:vertical}.resize{resize:both}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-start{align-items:flex-start}.items-center{align-items:center}.justify-end{justify-content:flex-end}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-1{gap:.25rem}.gap-1\.5{gap:.375rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.gap-4{gap:1rem}.gap-6{gap:1.5rem}.gap-8{gap:2rem}.gap-x-4{-moz-column-gap:1rem;column-gap:1rem}.gap-y-1{row-gap:.25rem}.space-y-1>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.25rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.25rem * var(--tw-space-y-reverse))}.space-y-2>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.5rem * var(--tw-space-y-reverse))}.space-y-4>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1rem * var(--tw-space-y-reverse))}.space-y-6>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1.5rem * 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}.truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.whitespace-pre-wrap{white-space:pre-wrap}.break-all{word-break:break-all}.rounded{border-radius:.25rem}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:.5rem}.rounded-md{border-radius:.375rem}.border{border-width:1px}.border-b{border-bottom-width:1px}.border-b-2{border-bottom-width:2px}.border-l-2{border-left-width:2px}.border-t{border-top-width:1px}.border-dashed{border-style:dashed}.border-\[var\(--accent\)\]{border-color:var(--accent)}.border-\[var\(--border\)\]{border-color:var(--border)}.border-blue-500\/30{border-color:#3b82f64d}.border-green-500\/20{border-color:#22c55e33}.border-green-500\/30{border-color:#22c55e4d}.border-red-500\/20{border-color:#ef444433}.border-red-500\/30{border-color:#ef44444d}.border-red-500\/50{border-color:#ef444480}.border-transparent{border-color:transparent}.bg-\[var\(--accent\)\]{background-color:var(--accent)}.bg-\[var\(--bg-primary\)\]{background-color:var(--bg-primary)}.bg-\[var\(--bg-secondary\)\]{background-color:var(--bg-secondary)}.bg-\[var\(--bg-tertiary\)\]{background-color:var(--bg-tertiary)}.bg-\[var\(--error\)\]{background-color:var(--error)}.bg-black\/80{background-color:#000c}.bg-blue-100{--tw-bg-opacity: 1;background-color:rgb(219 234 254 / var(--tw-bg-opacity, 1))}.bg-blue-400{--tw-bg-opacity: 1;background-color:rgb(96 165 250 / var(--tw-bg-opacity, 1))}.bg-blue-500{--tw-bg-opacity: 1;background-color:rgb(59 130 246 / var(--tw-bg-opacity, 1))}.bg-blue-500\/10{background-color:#3b82f61a}.bg-blue-600{--tw-bg-opacity: 1;background-color:rgb(37 99 235 / var(--tw-bg-opacity, 1))}.bg-emerald-500{--tw-bg-opacity: 1;background-color:rgb(16 185 129 / var(--tw-bg-opacity, 1))}.bg-green-100{--tw-bg-opacity: 1;background-color:rgb(220 252 231 / var(--tw-bg-opacity, 1))}.bg-green-400{--tw-bg-opacity: 1;background-color:rgb(74 222 128 / var(--tw-bg-opacity, 1))}.bg-green-500{--tw-bg-opacity: 1;background-color:rgb(34 197 94 / var(--tw-bg-opacity, 1))}.bg-green-500\/10{background-color:#22c55e1a}.bg-green-500\/20{background-color:#22c55e33}.bg-green-600{--tw-bg-opacity: 1;background-color:rgb(22 163 74 / var(--tw-bg-opacity, 1))}.bg-orange-100{--tw-bg-opacity: 1;background-color:rgb(255 237 213 / var(--tw-bg-opacity, 1))}.bg-purple-100{--tw-bg-opacity: 1;background-color:rgb(243 232 255 / var(--tw-bg-opacity, 1))}.bg-red-100{--tw-bg-opacity: 1;background-color:rgb(254 226 226 / var(--tw-bg-opacity, 1))}.bg-red-500{--tw-bg-opacity: 1;background-color:rgb(239 68 68 / var(--tw-bg-opacity, 1))}.bg-red-500\/10{background-color:#ef44441a}.bg-red-500\/5{background-color:#ef44440d}.bg-red-600{--tw-bg-opacity: 1;background-color:rgb(220 38 38 / var(--tw-bg-opacity, 1))}.bg-yellow-500{--tw-bg-opacity: 1;background-color:rgb(234 179 8 / var(--tw-bg-opacity, 1))}.p-1{padding:.25rem}.p-1\.5{padding:.375rem}.p-2{padding:.5rem}.p-3{padding:.75rem}.p-4{padding:1rem}.p-6{padding:1.5rem}.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-3{padding-left:.75rem;padding-right:.75rem}.px-4{padding-left:1rem;padding-right:1rem}.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-12{padding-top:3rem;padding-bottom:3rem}.py-16{padding-top:4rem;padding-bottom:4rem}.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-8{padding-top:2rem;padding-bottom:2rem}.pb-2{padding-bottom:.5rem}.pl-10{padding-left:2.5rem}.pr-3{padding-right:.75rem}.pr-4{padding-right:1rem}.pt-2{padding-top:.5rem}.pt-3{padding-top:.75rem}.pt-4{padding-top:1rem}.text-left{text-align:left}.text-center{text-align:center}.text-right{text-align:right}.font-mono{font-family:JetBrains Mono,ui-monospace,monospace}.text-2xl{font-size:1.5rem;line-height:2rem}.text-\[10px\]{font-size:10px}.text-lg{font-size:1.125rem;line-height:1.75rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xl{font-size:1.25rem;line-height:1.75rem}.text-xs{font-size:.75rem;line-height:1rem}.font-bold{font-weight:700}.font-medium{font-weight:500}.font-semibold{font-weight:600}.uppercase{text-transform:uppercase}.tracking-wide{letter-spacing:.025em}.tracking-wider{letter-spacing:.05em}.text-\[var\(--accent\)\]{color:var(--accent)}.text-\[var\(--error\)\]{color:var(--error)}.text-\[var\(--text-primary\)\]{color:var(--text-primary)}.text-\[var\(--text-secondary\)\]{color:var(--text-secondary)}.text-\[var\(--text-tertiary\)\]{color:var(--text-tertiary)}.text-black{--tw-text-opacity: 1;color:rgb(0 0 0 / var(--tw-text-opacity, 1))}.text-blue-400{--tw-text-opacity: 1;color:rgb(96 165 250 / var(--tw-text-opacity, 1))}.text-blue-800{--tw-text-opacity: 1;color:rgb(30 64 175 / var(--tw-text-opacity, 1))}.text-emerald-400{--tw-text-opacity: 1;color:rgb(52 211 153 / var(--tw-text-opacity, 1))}.text-green-400{--tw-text-opacity: 1;color:rgb(74 222 128 / var(--tw-text-opacity, 1))}.text-green-500{--tw-text-opacity: 1;color:rgb(34 197 94 / var(--tw-text-opacity, 1))}.text-green-800{--tw-text-opacity: 1;color:rgb(22 101 52 / var(--tw-text-opacity, 1))}.text-orange-800{--tw-text-opacity: 1;color:rgb(154 52 18 / var(--tw-text-opacity, 1))}.text-purple-400{--tw-text-opacity: 1;color:rgb(192 132 252 / var(--tw-text-opacity, 1))}.text-purple-800{--tw-text-opacity: 1;color:rgb(107 33 168 / var(--tw-text-opacity, 1))}.text-red-300{--tw-text-opacity: 1;color:rgb(252 165 165 / var(--tw-text-opacity, 1))}.text-red-400{--tw-text-opacity: 1;color:rgb(248 113 113 / var(--tw-text-opacity, 1))}.text-red-500{--tw-text-opacity: 1;color:rgb(239 68 68 / var(--tw-text-opacity, 1))}.text-red-800{--tw-text-opacity: 1;color:rgb(153 27 27 / var(--tw-text-opacity, 1))}.text-white{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity, 1))}.accent-\[var\(--accent\)\]{accent-color:var(--accent)}.shadow-lg{--tw-shadow: 0 10px 15px -3px rgb(0 0 0 / .1), 0 4px 6px -4px rgb(0 0 0 / .1);--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)}.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-all{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-colors{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.duration-300{transition-duration:.3s}:root{--bg-primary: #0a0a0a;--bg-secondary: #141414;--bg-tertiary: #1a1a1a;--text-primary: #f5f5f5;--text-secondary: #a3a3a3;--accent: #22c55e;--accent-dim: #166534;--border: #262626;--error: #ef4444}[data-theme=light]{--bg-primary: #ffffff;--bg-secondary: #f7f8f9;--bg-tertiary: #eef0f2;--text-primary: #1a1a1a;--text-secondary: #4a4a4a;--accent: #16a34a;--accent-dim: #dcfce7;--border: #d1d5db;--error: #dc2626}*{box-sizing:border-box}body{margin:0;background-color:var(--bg-primary);color:var(--text-primary);font-family:JetBrains Mono,ui-monospace,monospace;font-size:14px;line-height:1.6}::-webkit-scrollbar{width:8px;height:8px}::-webkit-scrollbar-track{background:var(--bg-secondary)}::-webkit-scrollbar-thumb{background:var(--border);border-radius:4px}::-webkit-scrollbar-thumb:hover{background:#404040}[data-theme=light] ::-webkit-scrollbar-thumb:hover{background:silver}.last\:border-0:last-child{border-width:0px}.hover\:border-\[var\(--accent-dim\)\]:hover{border-color:var(--accent-dim)}.hover\:bg-\[\#16a34a\]:hover{--tw-bg-opacity: 1;background-color:rgb(22 163 74 / var(--tw-bg-opacity, 1))}.hover\:bg-\[var\(--bg-primary\)\]:hover{background-color:var(--bg-primary)}.hover\:bg-\[var\(--bg-tertiary\)\]:hover{background-color:var(--bg-tertiary)}.hover\:bg-\[var\(--border\)\]:hover{background-color:var(--border)}.hover\:bg-red-600:hover{--tw-bg-opacity: 1;background-color:rgb(220 38 38 / var(--tw-bg-opacity, 1))}.hover\:text-\[var\(--accent\)\]:hover{color:var(--accent)}.hover\:text-\[var\(--text-primary\)\]:hover{color:var(--text-primary)}.hover\:opacity-80:hover{opacity:.8}.focus\:border-\[var\(--accent\)\]:focus{border-color:var(--accent)}.focus\:outline-none:focus{outline:2px solid transparent;outline-offset:2px}.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-\[var\(--accent\)\]:focus{--tw-ring-color: var(--accent)}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-50:disabled{opacity:.5}@media (min-width: 768px){.md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}}@media (min-width: 1024px){.lg\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}}@media (min-width: 1280px){.xl\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}}@media (prefers-color-scheme: dark){.dark\:bg-blue-900{--tw-bg-opacity: 1;background-color:rgb(30 58 138 / var(--tw-bg-opacity, 1))}.dark\:bg-green-900{--tw-bg-opacity: 1;background-color:rgb(20 83 45 / var(--tw-bg-opacity, 1))}.dark\:bg-orange-900{--tw-bg-opacity: 1;background-color:rgb(124 45 18 / var(--tw-bg-opacity, 1))}.dark\:bg-purple-900{--tw-bg-opacity: 1;background-color:rgb(88 28 135 / var(--tw-bg-opacity, 1))}.dark\:bg-red-900{--tw-bg-opacity: 1;background-color:rgb(127 29 29 / var(--tw-bg-opacity, 1))}.dark\:text-blue-200{--tw-text-opacity: 1;color:rgb(191 219 254 / var(--tw-text-opacity, 1))}.dark\:text-green-200{--tw-text-opacity: 1;color:rgb(187 247 208 / var(--tw-text-opacity, 1))}.dark\:text-orange-200{--tw-text-opacity: 1;color:rgb(254 215 170 / var(--tw-text-opacity, 1))}.dark\:text-purple-200{--tw-text-opacity: 1;color:rgb(233 213 255 / var(--tw-text-opacity, 1))}.dark\:text-red-200{--tw-text-opacity: 1;color:rgb(254 202 202 / var(--tw-text-opacity, 1))}}

src/flow/ui/ui/assets/index-CIxCoVSG.css

@@ -0,0 +1 @@
+*,:before,:after{--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: rgb(59 130 246 / .5);--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: }::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: rgb(59 130 246 / .5);--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-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html,:host{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}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;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:JetBrains Mono,ui-monospace,monospace;font-feature-settings:normal;font-variation-settings:normal;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings: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:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-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{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,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{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]:where(:not([hidden=until-found])){display:none}.pointer-events-none{pointer-events:none}.fixed{position:fixed}.absolute{position:absolute}.relative{position:relative}.sticky{position:sticky}.inset-0{top:0;right:0;bottom:0;left:0}.bottom-0{bottom:0}.left-0{left:0}.left-3{left:.75rem}.top-0{top:0}.top-1\/2{top:50%}.z-10{z-index:10}.z-50{z-index:50}.mx-0\.5{margin-left:.125rem;margin-right:.125rem}.mx-4{margin-left:1rem;margin-right:1rem}.mx-auto{margin-left:auto;margin-right:auto}.-mt-1{margin-top:-.25rem}.mb-1{margin-bottom:.25rem}.mb-2{margin-bottom:.5rem}.mb-3{margin-bottom:.75rem}.mb-4{margin-bottom:1rem}.mb-6{margin-bottom:1.5rem}.mb-8{margin-bottom:2rem}.ml-2{margin-left:.5rem}.ml-4{margin-left:1rem}.ml-6{margin-left:1.5rem}.mr-1{margin-right:.25rem}.mt-0\.5{margin-top:.125rem}.mt-1{margin-top:.25rem}.mt-2{margin-top:.5rem}.mt-3{margin-top:.75rem}.mt-4{margin-top:1rem}.mt-8{margin-top:2rem}.mt-auto{margin-top:auto}.line-clamp-2{overflow:hidden;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:2}.line-clamp-3{overflow:hidden;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:3}.block{display:block}.inline-block{display:inline-block}.flex{display:flex}.inline-flex{display:inline-flex}.table{display:table}.grid{display:grid}.hidden{display:none}.h-1\.5{height:.375rem}.h-12{height:3rem}.h-2{height:.5rem}.h-3{height:.75rem}.h-32{height:8rem}.h-4{height:1rem}.h-5{height:1.25rem}.h-6{height:1.5rem}.h-8{height:2rem}.h-full{height:100%}.max-h-32{max-height:8rem}.max-h-40{max-height:10rem}.max-h-48{max-height:12rem}.max-h-96{max-height:24rem}.max-h-\[80vh\]{max-height:80vh}.min-h-\[100px\]{min-height:100px}.min-h-screen{min-height:100vh}.w-12{width:3rem}.w-2{width:.5rem}.w-20{width:5rem}.w-24{width:6rem}.w-3{width:.75rem}.w-32{width:8rem}.w-4{width:1rem}.w-5{width:1.25rem}.w-6{width:1.5rem}.w-8{width:2rem}.w-full{width:100%}.min-w-0{min-width:0px}.min-w-\[90px\]{min-width:90px}.max-w-7xl{max-width:80rem}.max-w-lg{max-width:32rem}.max-w-md{max-width:28rem}.flex-1{flex:1 1 0%}.flex-shrink-0{flex-shrink:0}.-translate-y-1\/2{--tw-translate-y: -50%;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.rotate-180{--tw-rotate: 180deg;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(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)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}@keyframes pulse{50%{opacity:.5}}.animate-pulse{animation:pulse 2s cubic-bezier(.4,0,.6,1) infinite}@keyframes spin{to{transform:rotate(360deg)}}.animate-spin{animation:spin 1s linear infinite}.cursor-pointer{cursor:pointer}.select-none{-webkit-user-select:none;-moz-user-select:none;user-select:none}.resize-y{resize:vertical}.resize{resize:both}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-start{align-items:flex-start}.items-center{align-items:center}.justify-end{justify-content:flex-end}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-1{gap:.25rem}.gap-1\.5{gap:.375rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.gap-4{gap:1rem}.gap-6{gap:1.5rem}.gap-8{gap:2rem}.gap-x-4{-moz-column-gap:1rem;column-gap:1rem}.gap-y-1{row-gap:.25rem}.space-y-1>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.25rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.25rem * var(--tw-space-y-reverse))}.space-y-2>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.5rem * var(--tw-space-y-reverse))}.space-y-4>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1rem * var(--tw-space-y-reverse))}.space-y-6>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1.5rem * 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}.truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.whitespace-pre-wrap{white-space:pre-wrap}.break-all{word-break:break-all}.rounded{border-radius:.25rem}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:.5rem}.rounded-md{border-radius:.375rem}.border{border-width:1px}.border-b{border-bottom-width:1px}.border-l-2{border-left-width:2px}.border-t{border-top-width:1px}.border-dashed{border-style:dashed}.border-\[var\(--accent\)\]{border-color:var(--accent)}.border-\[var\(--border\)\]{border-color:var(--border)}.border-blue-500\/30{border-color:#3b82f64d}.border-green-500\/30{border-color:#22c55e4d}.border-red-500\/30{border-color:#ef44444d}.border-red-500\/50{border-color:#ef444480}.bg-\[var\(--accent\)\]{background-color:var(--accent)}.bg-\[var\(--bg-primary\)\]{background-color:var(--bg-primary)}.bg-\[var\(--bg-secondary\)\]{background-color:var(--bg-secondary)}.bg-\[var\(--bg-tertiary\)\]{background-color:var(--bg-tertiary)}.bg-\[var\(--error\)\]{background-color:var(--error)}.bg-black\/80{background-color:#000c}.bg-blue-100{--tw-bg-opacity: 1;background-color:rgb(219 234 254 / var(--tw-bg-opacity, 1))}.bg-blue-400{--tw-bg-opacity: 1;background-color:rgb(96 165 250 / var(--tw-bg-opacity, 1))}.bg-blue-500{--tw-bg-opacity: 1;background-color:rgb(59 130 246 / var(--tw-bg-opacity, 1))}.bg-blue-500\/10{background-color:#3b82f61a}.bg-blue-600{--tw-bg-opacity: 1;background-color:rgb(37 99 235 / var(--tw-bg-opacity, 1))}.bg-emerald-500{--tw-bg-opacity: 1;background-color:rgb(16 185 129 / var(--tw-bg-opacity, 1))}.bg-green-100{--tw-bg-opacity: 1;background-color:rgb(220 252 231 / var(--tw-bg-opacity, 1))}.bg-green-400{--tw-bg-opacity: 1;background-color:rgb(74 222 128 / var(--tw-bg-opacity, 1))}.bg-green-500{--tw-bg-opacity: 1;background-color:rgb(34 197 94 / var(--tw-bg-opacity, 1))}.bg-green-500\/10{background-color:#22c55e1a}.bg-green-500\/20{background-color:#22c55e33}.bg-green-600{--tw-bg-opacity: 1;background-color:rgb(22 163 74 / var(--tw-bg-opacity, 1))}.bg-orange-100{--tw-bg-opacity: 1;background-color:rgb(255 237 213 / var(--tw-bg-opacity, 1))}.bg-purple-100{--tw-bg-opacity: 1;background-color:rgb(243 232 255 / var(--tw-bg-opacity, 1))}.bg-red-100{--tw-bg-opacity: 1;background-color:rgb(254 226 226 / var(--tw-bg-opacity, 1))}.bg-red-500{--tw-bg-opacity: 1;background-color:rgb(239 68 68 / var(--tw-bg-opacity, 1))}.bg-red-500\/10{background-color:#ef44441a}.bg-red-600{--tw-bg-opacity: 1;background-color:rgb(220 38 38 / var(--tw-bg-opacity, 1))}.bg-yellow-500{--tw-bg-opacity: 1;background-color:rgb(234 179 8 / var(--tw-bg-opacity, 1))}.p-1{padding:.25rem}.p-2{padding:.5rem}.p-3{padding:.75rem}.p-4{padding:1rem}.p-6{padding:1.5rem}.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-3{padding-left:.75rem;padding-right:.75rem}.px-4{padding-left:1rem;padding-right:1rem}.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-12{padding-top:3rem;padding-bottom:3rem}.py-16{padding-top:4rem;padding-bottom:4rem}.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-8{padding-top:2rem;padding-bottom:2rem}.pb-2{padding-bottom:.5rem}.pl-10{padding-left:2.5rem}.pr-3{padding-right:.75rem}.pr-4{padding-right:1rem}.pt-2{padding-top:.5rem}.pt-3{padding-top:.75rem}.pt-4{padding-top:1rem}.text-left{text-align:left}.text-center{text-align:center}.text-right{text-align:right}.font-mono{font-family:JetBrains Mono,ui-monospace,monospace}.text-2xl{font-size:1.5rem;line-height:2rem}.text-lg{font-size:1.125rem;line-height:1.75rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xl{font-size:1.25rem;line-height:1.75rem}.text-xs{font-size:.75rem;line-height:1rem}.font-bold{font-weight:700}.font-medium{font-weight:500}.font-semibold{font-weight:600}.uppercase{text-transform:uppercase}.tracking-wide{letter-spacing:.025em}.tracking-wider{letter-spacing:.05em}.text-\[var\(--accent\)\]{color:var(--accent)}.text-\[var\(--error\)\]{color:var(--error)}.text-\[var\(--text-primary\)\]{color:var(--text-primary)}.text-\[var\(--text-secondary\)\]{color:var(--text-secondary)}.text-\[var\(--text-tertiary\)\]{color:var(--text-tertiary)}.text-black{--tw-text-opacity: 1;color:rgb(0 0 0 / var(--tw-text-opacity, 1))}.text-blue-400{--tw-text-opacity: 1;color:rgb(96 165 250 / var(--tw-text-opacity, 1))}.text-blue-800{--tw-text-opacity: 1;color:rgb(30 64 175 / var(--tw-text-opacity, 1))}.text-emerald-400{--tw-text-opacity: 1;color:rgb(52 211 153 / var(--tw-text-opacity, 1))}.text-green-400{--tw-text-opacity: 1;color:rgb(74 222 128 / var(--tw-text-opacity, 1))}.text-green-500{--tw-text-opacity: 1;color:rgb(34 197 94 / var(--tw-text-opacity, 1))}.text-green-800{--tw-text-opacity: 1;color:rgb(22 101 52 / var(--tw-text-opacity, 1))}.text-orange-800{--tw-text-opacity: 1;color:rgb(154 52 18 / var(--tw-text-opacity, 1))}.text-purple-400{--tw-text-opacity: 1;color:rgb(192 132 252 / var(--tw-text-opacity, 1))}.text-purple-800{--tw-text-opacity: 1;color:rgb(107 33 168 / var(--tw-text-opacity, 1))}.text-red-400{--tw-text-opacity: 1;color:rgb(248 113 113 / var(--tw-text-opacity, 1))}.text-red-800{--tw-text-opacity: 1;color:rgb(153 27 27 / var(--tw-text-opacity, 1))}.text-white{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity, 1))}.accent-\[var\(--accent\)\]{accent-color:var(--accent)}.shadow-lg{--tw-shadow: 0 10px 15px -3px rgb(0 0 0 / .1), 0 4px 6px -4px rgb(0 0 0 / .1);--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)}.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-all{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-colors{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.duration-300{transition-duration:.3s}:root{--bg-primary: #0a0a0a;--bg-secondary: #141414;--bg-tertiary: #1a1a1a;--text-primary: #f5f5f5;--text-secondary: #a3a3a3;--accent: #22c55e;--accent-dim: #166534;--border: #262626;--error: #ef4444}[data-theme=light]{--bg-primary: #ffffff;--bg-secondary: #f7f8f9;--bg-tertiary: #eef0f2;--text-primary: #1a1a1a;--text-secondary: #4a4a4a;--accent: #16a34a;--accent-dim: #dcfce7;--border: #d1d5db;--error: #dc2626}*{box-sizing:border-box}body{margin:0;background-color:var(--bg-primary);color:var(--text-primary);font-family:JetBrains Mono,ui-monospace,monospace;font-size:14px;line-height:1.6}::-webkit-scrollbar{width:8px;height:8px}::-webkit-scrollbar-track{background:var(--bg-secondary)}::-webkit-scrollbar-thumb{background:var(--border);border-radius:4px}::-webkit-scrollbar-thumb:hover{background:#404040}[data-theme=light] ::-webkit-scrollbar-thumb:hover{background:silver}.last\:border-0:last-child{border-width:0px}.hover\:border-\[var\(--accent-dim\)\]:hover{border-color:var(--accent-dim)}.hover\:bg-\[\#16a34a\]:hover{--tw-bg-opacity: 1;background-color:rgb(22 163 74 / var(--tw-bg-opacity, 1))}.hover\:bg-\[var\(--bg-primary\)\]:hover{background-color:var(--bg-primary)}.hover\:bg-\[var\(--bg-tertiary\)\]:hover{background-color:var(--bg-tertiary)}.hover\:bg-\[var\(--border\)\]:hover{background-color:var(--border)}.hover\:bg-red-600:hover{--tw-bg-opacity: 1;background-color:rgb(220 38 38 / var(--tw-bg-opacity, 1))}.hover\:text-\[var\(--accent\)\]:hover{color:var(--accent)}.hover\:text-\[var\(--text-primary\)\]:hover{color:var(--text-primary)}.hover\:opacity-80:hover{opacity:.8}.focus\:border-\[var\(--accent\)\]:focus{border-color:var(--accent)}.focus\:outline-none:focus{outline:2px solid transparent;outline-offset:2px}.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-\[var\(--accent\)\]:focus{--tw-ring-color: var(--accent)}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-50:disabled{opacity:.5}@media (min-width: 768px){.md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}}@media (min-width: 1024px){.lg\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}}@media (min-width: 1280px){.xl\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}}@media (prefers-color-scheme: dark){.dark\:bg-blue-900{--tw-bg-opacity: 1;background-color:rgb(30 58 138 / var(--tw-bg-opacity, 1))}.dark\:bg-green-900{--tw-bg-opacity: 1;background-color:rgb(20 83 45 / var(--tw-bg-opacity, 1))}.dark\:bg-orange-900{--tw-bg-opacity: 1;background-color:rgb(124 45 18 / var(--tw-bg-opacity, 1))}.dark\:bg-purple-900{--tw-bg-opacity: 1;background-color:rgb(88 28 135 / var(--tw-bg-opacity, 1))}.dark\:bg-red-900{--tw-bg-opacity: 1;background-color:rgb(127 29 29 / var(--tw-bg-opacity, 1))}.dark\:text-blue-200{--tw-text-opacity: 1;color:rgb(191 219 254 / var(--tw-text-opacity, 1))}.dark\:text-green-200{--tw-text-opacity: 1;color:rgb(187 247 208 / var(--tw-text-opacity, 1))}.dark\:text-orange-200{--tw-text-opacity: 1;color:rgb(254 215 170 / var(--tw-text-opacity, 1))}.dark\:text-purple-200{--tw-text-opacity: 1;color:rgb(233 213 255 / var(--tw-text-opacity, 1))}.dark\:text-red-200{--tw-text-opacity: 1;color:rgb(254 202 202 / var(--tw-text-opacity, 1))}}

src/flow/ui/ui/assets/index-CcGRa0_M.css

@@ -0,0 +1 @@
+*,:before,:after{--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: rgb(59 130 246 / .5);--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: }::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: rgb(59 130 246 / .5);--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-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html,:host{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}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;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:JetBrains Mono,ui-monospace,monospace;font-feature-settings:normal;font-variation-settings:normal;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings: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:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-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{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,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{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]:where(:not([hidden=until-found])){display:none}.pointer-events-none{pointer-events:none}.fixed{position:fixed}.absolute{position:absolute}.relative{position:relative}.sticky{position:sticky}.inset-0{top:0;right:0;bottom:0;left:0}.bottom-0{bottom:0}.left-0{left:0}.left-3{left:.75rem}.top-0{top:0}.top-1\/2{top:50%}.z-10{z-index:10}.z-50{z-index:50}.col-span-2{grid-column:span 2 / span 2}.mx-0\.5{margin-left:.125rem;margin-right:.125rem}.mx-4{margin-left:1rem;margin-right:1rem}.mx-auto{margin-left:auto;margin-right:auto}.-mt-1{margin-top:-.25rem}.mb-1{margin-bottom:.25rem}.mb-2{margin-bottom:.5rem}.mb-3{margin-bottom:.75rem}.mb-4{margin-bottom:1rem}.mb-6{margin-bottom:1.5rem}.mb-8{margin-bottom:2rem}.ml-1{margin-left:.25rem}.ml-2{margin-left:.5rem}.ml-4{margin-left:1rem}.ml-6{margin-left:1.5rem}.mr-1{margin-right:.25rem}.mt-0\.5{margin-top:.125rem}.mt-1{margin-top:.25rem}.mt-2{margin-top:.5rem}.mt-3{margin-top:.75rem}.mt-4{margin-top:1rem}.mt-8{margin-top:2rem}.mt-auto{margin-top:auto}.line-clamp-2{overflow:hidden;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:2}.line-clamp-3{overflow:hidden;display:-webkit-box;-webkit-box-orient:vertical;-webkit-line-clamp:3}.block{display:block}.inline-block{display:inline-block}.flex{display:flex}.inline-flex{display:inline-flex}.table{display:table}.grid{display:grid}.hidden{display:none}.h-1\.5{height:.375rem}.h-12{height:3rem}.h-2{height:.5rem}.h-3{height:.75rem}.h-32{height:8rem}.h-4{height:1rem}.h-5{height:1.25rem}.h-6{height:1.5rem}.h-8{height:2rem}.h-full{height:100%}.max-h-32{max-height:8rem}.max-h-40{max-height:10rem}.max-h-48{max-height:12rem}.max-h-96{max-height:24rem}.max-h-\[80vh\]{max-height:80vh}.min-h-0{min-height:0px}.min-h-\[100px\]{min-height:100px}.min-h-screen{min-height:100vh}.w-12{width:3rem}.w-2{width:.5rem}.w-20{width:5rem}.w-24{width:6rem}.w-3{width:.75rem}.w-32{width:8rem}.w-4{width:1rem}.w-5{width:1.25rem}.w-6{width:1.5rem}.w-8{width:2rem}.w-full{width:100%}.min-w-0{min-width:0px}.min-w-\[90px\]{min-width:90px}.max-w-7xl{max-width:80rem}.max-w-\[200px\]{max-width:200px}.max-w-full{max-width:100%}.max-w-lg{max-width:32rem}.max-w-md{max-width:28rem}.flex-1{flex:1 1 0%}.flex-shrink-0{flex-shrink:0}.-translate-y-1\/2{--tw-translate-y: -50%;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}.rotate-180{--tw-rotate: 180deg;transform:translate(var(--tw-translate-x),var(--tw-translate-y)) rotate(var(--tw-rotate)) skew(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)) skew(var(--tw-skew-x)) skewY(var(--tw-skew-y)) scaleX(var(--tw-scale-x)) scaleY(var(--tw-scale-y))}@keyframes pulse{50%{opacity:.5}}.animate-pulse{animation:pulse 2s cubic-bezier(.4,0,.6,1) infinite}@keyframes spin{to{transform:rotate(360deg)}}.animate-spin{animation:spin 1s linear infinite}.cursor-pointer{cursor:pointer}.select-none{-webkit-user-select:none;-moz-user-select:none;user-select:none}.resize-none{resize:none}.resize-y{resize:vertical}.resize{resize:both}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-start{align-items:flex-start}.items-end{align-items:flex-end}.items-center{align-items:center}.justify-end{justify-content:flex-end}.justify-center{justify-content:center}.justify-between{justify-content:space-between}.gap-1{gap:.25rem}.gap-1\.5{gap:.375rem}.gap-2{gap:.5rem}.gap-3{gap:.75rem}.gap-4{gap:1rem}.gap-6{gap:1.5rem}.gap-8{gap:2rem}.gap-x-4{-moz-column-gap:1rem;column-gap:1rem}.gap-y-1{row-gap:.25rem}.space-y-1>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.25rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.25rem * var(--tw-space-y-reverse))}.space-y-2>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.5rem * var(--tw-space-y-reverse))}.space-y-3>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(.75rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(.75rem * var(--tw-space-y-reverse))}.space-y-4>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1rem * var(--tw-space-y-reverse))}.space-y-6>:not([hidden])~:not([hidden]){--tw-space-y-reverse: 0;margin-top:calc(1.5rem * calc(1 - var(--tw-space-y-reverse)));margin-bottom:calc(1.5rem * 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}.truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.whitespace-pre-wrap{white-space:pre-wrap}.break-all{word-break:break-all}.rounded{border-radius:.25rem}.rounded-full{border-radius:9999px}.rounded-lg{border-radius:.5rem}.rounded-md{border-radius:.375rem}.border{border-width:1px}.border-b{border-bottom-width:1px}.border-b-2{border-bottom-width:2px}.border-l-2{border-left-width:2px}.border-t{border-top-width:1px}.border-dashed{border-style:dashed}.border-\[var\(--accent\)\]{border-color:var(--accent)}.border-\[var\(--border\)\]{border-color:var(--border)}.border-blue-500\/30{border-color:#3b82f64d}.border-green-500\/20{border-color:#22c55e33}.border-green-500\/30{border-color:#22c55e4d}.border-red-500\/20{border-color:#ef444433}.border-red-500\/30{border-color:#ef44444d}.border-red-500\/50{border-color:#ef444480}.border-transparent{border-color:transparent}.bg-\[var\(--accent\)\]{background-color:var(--accent)}.bg-\[var\(--bg-primary\)\]{background-color:var(--bg-primary)}.bg-\[var\(--bg-secondary\)\]{background-color:var(--bg-secondary)}.bg-\[var\(--bg-tertiary\)\]{background-color:var(--bg-tertiary)}.bg-\[var\(--error\)\]{background-color:var(--error)}.bg-black\/80{background-color:#000c}.bg-blue-100{--tw-bg-opacity: 1;background-color:rgb(219 234 254 / var(--tw-bg-opacity, 1))}.bg-blue-400{--tw-bg-opacity: 1;background-color:rgb(96 165 250 / var(--tw-bg-opacity, 1))}.bg-blue-500{--tw-bg-opacity: 1;background-color:rgb(59 130 246 / var(--tw-bg-opacity, 1))}.bg-blue-500\/10{background-color:#3b82f61a}.bg-blue-600{--tw-bg-opacity: 1;background-color:rgb(37 99 235 / var(--tw-bg-opacity, 1))}.bg-emerald-500{--tw-bg-opacity: 1;background-color:rgb(16 185 129 / var(--tw-bg-opacity, 1))}.bg-green-100{--tw-bg-opacity: 1;background-color:rgb(220 252 231 / var(--tw-bg-opacity, 1))}.bg-green-400{--tw-bg-opacity: 1;background-color:rgb(74 222 128 / var(--tw-bg-opacity, 1))}.bg-green-500{--tw-bg-opacity: 1;background-color:rgb(34 197 94 / var(--tw-bg-opacity, 1))}.bg-green-500\/10{background-color:#22c55e1a}.bg-green-500\/20{background-color:#22c55e33}.bg-green-600{--tw-bg-opacity: 1;background-color:rgb(22 163 74 / var(--tw-bg-opacity, 1))}.bg-orange-100{--tw-bg-opacity: 1;background-color:rgb(255 237 213 / var(--tw-bg-opacity, 1))}.bg-purple-100{--tw-bg-opacity: 1;background-color:rgb(243 232 255 / var(--tw-bg-opacity, 1))}.bg-red-100{--tw-bg-opacity: 1;background-color:rgb(254 226 226 / var(--tw-bg-opacity, 1))}.bg-red-500{--tw-bg-opacity: 1;background-color:rgb(239 68 68 / var(--tw-bg-opacity, 1))}.bg-red-500\/10{background-color:#ef44441a}.bg-red-500\/5{background-color:#ef44440d}.bg-red-600{--tw-bg-opacity: 1;background-color:rgb(220 38 38 / var(--tw-bg-opacity, 1))}.bg-yellow-500{--tw-bg-opacity: 1;background-color:rgb(234 179 8 / var(--tw-bg-opacity, 1))}.p-1{padding:.25rem}.p-2{padding:.5rem}.p-3{padding:.75rem}.p-4{padding:1rem}.p-6{padding:1.5rem}.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-3{padding-left:.75rem;padding-right:.75rem}.px-4{padding-left:1rem;padding-right:1rem}.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-12{padding-top:3rem;padding-bottom:3rem}.py-16{padding-top:4rem;padding-bottom:4rem}.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-8{padding-top:2rem;padding-bottom:2rem}.pb-2{padding-bottom:.5rem}.pl-10{padding-left:2.5rem}.pr-3{padding-right:.75rem}.pr-4{padding-right:1rem}.pt-2{padding-top:.5rem}.pt-3{padding-top:.75rem}.pt-4{padding-top:1rem}.text-left{text-align:left}.text-center{text-align:center}.text-right{text-align:right}.font-mono{font-family:JetBrains Mono,ui-monospace,monospace}.text-2xl{font-size:1.5rem;line-height:2rem}.text-lg{font-size:1.125rem;line-height:1.75rem}.text-sm{font-size:.875rem;line-height:1.25rem}.text-xl{font-size:1.25rem;line-height:1.75rem}.text-xs{font-size:.75rem;line-height:1rem}.font-bold{font-weight:700}.font-medium{font-weight:500}.font-semibold{font-weight:600}.uppercase{text-transform:uppercase}.tracking-wide{letter-spacing:.025em}.tracking-wider{letter-spacing:.05em}.text-\[var\(--accent\)\]{color:var(--accent)}.text-\[var\(--error\)\]{color:var(--error)}.text-\[var\(--text-primary\)\]{color:var(--text-primary)}.text-\[var\(--text-secondary\)\]{color:var(--text-secondary)}.text-\[var\(--text-tertiary\)\]{color:var(--text-tertiary)}.text-black{--tw-text-opacity: 1;color:rgb(0 0 0 / var(--tw-text-opacity, 1))}.text-blue-400{--tw-text-opacity: 1;color:rgb(96 165 250 / var(--tw-text-opacity, 1))}.text-blue-800{--tw-text-opacity: 1;color:rgb(30 64 175 / var(--tw-text-opacity, 1))}.text-emerald-400{--tw-text-opacity: 1;color:rgb(52 211 153 / var(--tw-text-opacity, 1))}.text-green-400{--tw-text-opacity: 1;color:rgb(74 222 128 / var(--tw-text-opacity, 1))}.text-green-500{--tw-text-opacity: 1;color:rgb(34 197 94 / var(--tw-text-opacity, 1))}.text-green-800{--tw-text-opacity: 1;color:rgb(22 101 52 / var(--tw-text-opacity, 1))}.text-orange-800{--tw-text-opacity: 1;color:rgb(154 52 18 / var(--tw-text-opacity, 1))}.text-purple-400{--tw-text-opacity: 1;color:rgb(192 132 252 / var(--tw-text-opacity, 1))}.text-purple-800{--tw-text-opacity: 1;color:rgb(107 33 168 / var(--tw-text-opacity, 1))}.text-red-300{--tw-text-opacity: 1;color:rgb(252 165 165 / var(--tw-text-opacity, 1))}.text-red-400{--tw-text-opacity: 1;color:rgb(248 113 113 / var(--tw-text-opacity, 1))}.text-red-500{--tw-text-opacity: 1;color:rgb(239 68 68 / var(--tw-text-opacity, 1))}.text-red-800{--tw-text-opacity: 1;color:rgb(153 27 27 / var(--tw-text-opacity, 1))}.text-white{--tw-text-opacity: 1;color:rgb(255 255 255 / var(--tw-text-opacity, 1))}.accent-\[var\(--accent\)\]{accent-color:var(--accent)}.shadow-lg{--tw-shadow: 0 10px 15px -3px rgb(0 0 0 / .1), 0 4px 6px -4px rgb(0 0 0 / .1);--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)}.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-all{transition-property:all;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.transition-colors{transition-property:color,background-color,border-color,text-decoration-color,fill,stroke;transition-timing-function:cubic-bezier(.4,0,.2,1);transition-duration:.15s}.duration-300{transition-duration:.3s}:root{--bg-primary: #0a0a0a;--bg-secondary: #141414;--bg-tertiary: #1a1a1a;--text-primary: #f5f5f5;--text-secondary: #a3a3a3;--accent: #22c55e;--accent-dim: #166534;--border: #262626;--error: #ef4444}[data-theme=light]{--bg-primary: #ffffff;--bg-secondary: #f7f8f9;--bg-tertiary: #eef0f2;--text-primary: #1a1a1a;--text-secondary: #4a4a4a;--accent: #16a34a;--accent-dim: #dcfce7;--border: #d1d5db;--error: #dc2626}*{box-sizing:border-box}body{margin:0;background-color:var(--bg-primary);color:var(--text-primary);font-family:JetBrains Mono,ui-monospace,monospace;font-size:14px;line-height:1.6}::-webkit-scrollbar{width:8px;height:8px}::-webkit-scrollbar-track{background:var(--bg-secondary)}::-webkit-scrollbar-thumb{background:var(--border);border-radius:4px}::-webkit-scrollbar-thumb:hover{background:#404040}[data-theme=light] ::-webkit-scrollbar-thumb:hover{background:silver}.last\:border-0:last-child{border-width:0px}.hover\:border-\[var\(--accent-dim\)\]:hover{border-color:var(--accent-dim)}.hover\:bg-\[\#16a34a\]:hover{--tw-bg-opacity: 1;background-color:rgb(22 163 74 / var(--tw-bg-opacity, 1))}.hover\:bg-\[var\(--bg-primary\)\]:hover{background-color:var(--bg-primary)}.hover\:bg-\[var\(--bg-tertiary\)\]:hover{background-color:var(--bg-tertiary)}.hover\:bg-\[var\(--border\)\]:hover{background-color:var(--border)}.hover\:bg-red-600:hover{--tw-bg-opacity: 1;background-color:rgb(220 38 38 / var(--tw-bg-opacity, 1))}.hover\:text-\[var\(--accent\)\]:hover{color:var(--accent)}.hover\:text-\[var\(--text-primary\)\]:hover{color:var(--text-primary)}.hover\:opacity-80:hover{opacity:.8}.focus\:border-\[var\(--accent\)\]:focus{border-color:var(--accent)}.focus\:outline-none:focus{outline:2px solid transparent;outline-offset:2px}.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-\[var\(--accent\)\]:focus{--tw-ring-color: var(--accent)}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-50:disabled{opacity:.5}@media (min-width: 768px){.md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}}@media (min-width: 1024px){.lg\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}}@media (min-width: 1280px){.xl\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}}@media (prefers-color-scheme: dark){.dark\:bg-blue-900{--tw-bg-opacity: 1;background-color:rgb(30 58 138 / var(--tw-bg-opacity, 1))}.dark\:bg-green-900{--tw-bg-opacity: 1;background-color:rgb(20 83 45 / var(--tw-bg-opacity, 1))}.dark\:bg-orange-900{--tw-bg-opacity: 1;background-color:rgb(124 45 18 / var(--tw-bg-opacity, 1))}.dark\:bg-purple-900{--tw-bg-opacity: 1;background-color:rgb(88 28 135 / var(--tw-bg-opacity, 1))}.dark\:bg-red-900{--tw-bg-opacity: 1;background-color:rgb(127 29 29 / var(--tw-bg-opacity, 1))}.dark\:text-blue-200{--tw-text-opacity: 1;color:rgb(191 219 254 / var(--tw-text-opacity, 1))}.dark\:text-green-200{--tw-text-opacity: 1;color:rgb(187 247 208 / var(--tw-text-opacity, 1))}.dark\:text-orange-200{--tw-text-opacity: 1;color:rgb(254 215 170 / var(--tw-text-opacity, 1))}.dark\:text-purple-200{--tw-text-opacity: 1;color:rgb(233 213 255 / var(--tw-text-opacity, 1))}.dark\:text-red-200{--tw-text-opacity: 1;color:rgb(254 202 202 / var(--tw-text-opacity, 1))}}

src/flow/ui/ui/index.html

@@ -8,8 +8,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;500;600;700&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="/assets/index-BU8a-zoU.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BHAF8mLj.css">
+    <script type="module" crossorigin src="/assets/index-CsLpRsjU.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CcGRa0_M.css">
   </head>
   <body>
     <div id="root"></div>